Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
G'MIC(1)		    General Commands Manual		      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.4
	       (https://gmic.eu)

	       Copyright (c) 2008-2021,	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 possibly complex  image  processing	 pipe-
       lines 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.4.
	 As  a	starting  point,  you  may want	to visit our detailed tutorial
       pages, at:
	 https://gmic.eu/tutorial/

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

	 * At any time,	G'MIC manages one list	of  numbered  (and  optionally
       named) pixel-based images,
	 entirely stored in computer memory (uncompressed).

	 *  The	first image of the list	has index '0' and is denoted by	'[0]'.
       The second image	of the list
	 is denoted by '[1]', the third	by '[2]' and so	on.

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

	 * A named image may be	also indicated by '[name]', if 'name' uses the
       character set [a-zA-Z0-9_]
	 and  does  not	 start	with a number. Image names can be set or reas-
       signed at any moment during the
	 processing pipeline (see command name for this	purpose).

	 * G'MIC defines a set of various commands and substitution mechanisms
       to allow	the design of
	 complex  pipelines  and  operators managing this list of images, in a
       very flexible way: You can
	 insert	or remove images in the	list, rearrange	image  order,  process
       images (individually or
	 grouped),  merge image	data together, display and output image	files,
       etc.

	 * Such	a pipeline can define a	new custom G'MIC command (stored in  a
       user command file), and
	 re-used afterwards as a regular command, in a larger pipeline if nec-
       essary.

	 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 im-
       ages.
	 * There are no	hard limitations on the	size of	the image  along  each
       dimension. For instance,	the
	 number	 of  image  slices or channels can be of arbitrary size	within
       the limits of the available
	 memory.

	 * The width, height and depth of an image are considered  as  spatial
       dimensions, while the
	 spectrum  has	a  multi-spectral  meaning.  Thus, a 4D	image in G'MIC
       should be most often regarded as
	 a 3D dataset of multi-spectral	voxels.	Most  of  the  G'MIC  commands
       will stick with this idea (e.g.
	 command blur blurs images only	along the spatial xyz-axes).

	 *  G'MIC  stores  all	the  image data	as buffers of float values (32
       bits, value range
	 '[-3.4E38,+3.4E38]'. It performs all its image	processing  operations
       with floating point numbers.
	 Each  image  pixel takes then 32bits/channel (except if double-preci-
       sion 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	preci-
       sion when executing image
	 processing pipelines. For image input/output operations, you may want
       to prescribe the	image
	 datatype  to  be  different  than float (like bool, char, int,	etc.).
       This is possible	by
	 specifying it as a file option	when using I/O commands. (see  section
       Input/Output Properties to
	 learn more about file options).

	 4. Items of a Processing Pipeline
	    ------------------------------

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

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

	 defines a valid pipeline composed of nine G'MIC items.
	 * Each	G'MIC item is a	string that is either a	 command,  a  list  of
       command arguments, a
	 filename or a special input string.

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

	 5. Input Data Items
	    ----------------

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

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

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

	   - '[selection]' or '[selection]xN': Insert 1	or N copies of already
       existing	images.	'selection'
	 may represent one or several images (see section  Command  Items  and
       Selections to learn more
	 about selections).
	   -  'width[%],_height[%],_depth[%],_spectrum[%],_values[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	mathe-
       matical 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  pre-
       scribed values. Value
	 separator  inside parentheses can be ',' (column separator), ';' (row
       separator), '/' (slice
	 separator) or	'^'  (channel  separator).  For	 instance,  expression
       '(1,2,3;4,5,6;7,8,9)' creates a 3x3
	 matrix	(scalar	image),	with values running from 1 to 9.
	   -  '('string'[:delimiter])[xN]':  Insert  one  or N new images from
       specified string, by filling the
	 images	with the character codes composing the string. When specified,
       'delimiter' tells about the
	 main orientation of the image.	Delimiter can be 'x' (eq. to ',' which
       is the default),	'y' (eq. to
	 ';'), 'z' (eq.	to '/')	or 'c' (eq. to '^'). When specified  delimiter
       is ',', ';', '/'	or '^',	the
	 expression  is	 actually equivalent to	'({'string'[:delimiter]})[xN]'
       (see section ''Substitution
	 Rules'' for more information on the syntax).
	   - '0[xN]': Insert one or N new empty	images,	 containing  no	 pixel
       data. Empty images are used
	 only in rare occasions.
	 * Input item 'name=value' declares a new variable 'name', or assign a
       new string value	to an
	 existing variable. Variable names must	use the	character  set	[a-zA-
       Z0-9_] and cannot start with a
	 number.

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

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

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

	 *  Input item 'name.=string' concatenates specified string to the end
       of variable 'name'.

	 * Multiple variable assignments and updates are allowed, with expres-
       sions:
	 'name1,name2,...,nameN=value'	       or	  'name1,name2,...,na-
       meN=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 des-
       ignates a 'command' most	of the
	 time. Generally, commands perform image processing operations on  one
       or several available images of
	 the list.

	 *  Reccurent  commands	 have  two  equivalent	names  ('regular'  and
       'short'). For instance, command names
	 'resize' and 'r' refer	to the same image resizing action.

	 * A G'MIC command may have mandatory or optional  arguments.  Command
       arguments must be specified
	 in the	next item on the command line. Commas ',' are used to separate
       multiple	arguments of a
	 single	command, when required.

	 * The execution of a G'MIC command may	be restricted only to a	subset
       of the image list, by
	 appending  '[selection]'  to the command name.	Examples of valid syn-
       taxes 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	single	command	multiple times on an image, use	a 're-
       peat..done' loop	instead. Inverting
	 the order of images for a command is achieved by explicitly inverting
       the order of the	images in
	 the list, with	command	'reverse[selection]'.

	 * Command selections '[-1]', '[-2]' and '[-3]'	are so often used they
       have their own shortcuts,
	 respectively '.', '..'	and '...'. For instance, command  'blur..'  is
       equivalent to 'blur[-2]'. These
	 shortcuts work	also when specifying command arguments.

	 * G'MIC commands invoked without '[selection]'	are applied on all im-
       ages of the list, i.e. the
	 default selection is '[0--1]' (except for command 'input'  whose  de-
       fault 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 in-
       terpreter 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  cor-
       rect.
	   -  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 cus-
       tom 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 commands cannot  be
       added (unless you modify	the
	 G'MIC interpreter source code and recompile it).

	 7. Input/Output Properties
	    -----------------------

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

	   - 2D	grayscale/color	files: .png, .jpeg, .gif,  .pnm,  .tif,	 .bmp,
       ...
	   - 3D	volumetric files: .dcm,	.hdr, .nii, .pan, .inr,	.pnk, ...
	   - Video files: .mpeg, .avi, .mov, .ogg, .flv, ...
	   -  Generic  text  or	 binary	data files: .gmz, .cimg, .cimgz, .dlm,
       .asc, .pfm, .raw,
	 .txt, .h.
	   - 3D	object files: .off
	 * When	dealing	with color images, G'MIC generally reads,  writes  and
       displays	data using the usual
	 sRGB color space.

	 *  G'MIC  is able to manage 3D	objects	that may be read from files or
       generated by G'MIC
	 commands. A 3D	object is stored as a one-column scalar	image contain-
       ing 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, sav-
       ing an image that was initially
	 loaded	 as  a	16bits/channel	image, as a .jpg file will result in a
       loss of information. Use	the
	 G'MIC-specific	file extension .gmz to ensure that all data  precision
       is preserved when saving
	 images.

	 * Sometimes, file options may/must be set for file formats:

	   -  Video files: Only	sub-frames of an image sequence	may be loaded,
       using the input expression
	 'filename.ext,[first_frame[,last_frame[,step]]]'.		   Set
       'last_frame==-1'	to tell	it must	be the last
	 frame	of  the	video. Set 'step' to '0' to force an opened video file
       to be opened/closed. Output
	 framerate and codec can be also set by	using the output expression
	 'filename.avi,_fps,_codec,_keep_open' where 'keep_open' can be	{ 0  |
       1 }. 'codec' is a 4-char
	 string	(see http://www.fourcc.org/codecs.php )	or '0' for the default
       codec. 'keep_open' tells	if
	 the output video file must be kept open for appending new frames  af-
       terwards.
	   -  .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
	 'filename.cimg[z][,datatype]'	can  be	used to	force the output pixel
       type. 'datatype'	can be { auto
	 | uchar | char	| ushort | short | uint	| int |	uint64 | int64 | float
       | double	}.
	   -  .raw  binary files: Image	dimensions and input pixel type	may be
       specified when loading
	 .raw	    files	with	   input       expression	'file-
       name.raw[,datatype][,width][,height[,depth[,dim[,offset]]]]]
	 '.  If	no dimensions are specified, the resulting image is a one-col-
       umn 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	'file-
       name.yuv,width,height[,chroma_subsampl
	 ing[,first_frame[,last_frame[,step]]]'. 'chroma_subsampling' can be {
       420 | 422 | 444 }. When
	 saving, chroma	subsampling mode can be	specified with output  expres-
       sion
	 'filename.yuv[,chroma_subsampling]'.
	   -  .tiff  files:  Only  sub-images of multi-pages tiff files	can be
       loaded, using the input
	 expression 'filename.tif,_first_frame,_last_frame,_step'. Output  ex-
       pression
	 'filename.tiff,_datatype,_compression,_force_multipage,_use_bigtiff'
       can be used to specify the
	 output	pixel type, as well as the compression method. 'datatype'  can
       be the same as for .cimg[z]
	 files.	 'compression'	can  be	  {  none  (default)  |	 lzw | jpeg }.
       'force_multipage' can be	{ 0=no
	 (default) | 1=yes }. 'use_bigtiff' can	be { 0=no | 1=yes (default) }.
	   - .gif files: Animated gif files can	be saved, using	the input  ex-
       pression
	 'filename.gif,fps>0,nb_loops'.	 Specify  'nb_loops=0' to get an infi-
       nite 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 se-
       lected 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 com-
       mands files. Loading such
	 a file	will add the commands it defines to the	interpreter. Debug in-
       formation can be
	 enabled/disabled  by  the  input  expression  'filename.gmic[,add_de-
       bug_info' where 'debug_info' can	be
	 { 0=false | 1=true }.
	   - Inserting 'ext:' on the beginning of a filename (e.g.  'jpg:file-
       name') forces G'MIC to
	 read/write  the  file as it would have	been done if it	had the	speci-
       fied extension .ext.
	 * Some	input/output formats and options may not be supported, depend-
       ing 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 in-
       terpreted. Use these
	 substituting expressions to access various data from the  interpreter
       environment.

	 *  '$name'  and  '${name}'  are  both substituted by the value	of the
       specified named variable	(set
	 previously by the item	'name=value'). If this variable	has  not  been
       already set, the	expression is
	 substituted  by  the  highest	positive  index	 of  the  named	 image
       '[name]'. If no image has this name,
	 the expression	is substituted by the  value  of  the  OS  environment
       variable	with same name (it may be
	 thus an empty string if it is not defined).

	 * The following reserved variables are	predefined by the G'MIC	inter-
       preter:

	   - '$!': 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  ma-
       chine.
	   - '$_pid': The current process identifier, as an integer.
	   -  '$_prerelease': For pre-releases,	the date of the	pre-release as
       yymmdd. For stable releases,
	 this variable is set to 0.
	   - '$_version': A 3-digits number telling about the current  version
       of the G'MIC interpreter
	 (e.g. '294').
	   -  '$_host':	 A string telling about	the host running the G'MIC in-
       terpreter (e.g. cli or gimp).
	   - '$_vt100':	Set to 1 if colored text output	is allowed on the con-
       sole. Otherwise,	set to 0.
	   -  '$_path_rc': The path to the G'MIC folder	used to	store configu-
       ration 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).
	 * '$$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 spec-
       ified name exists.

	 * '${"-pipeline"}' is substituted by the status value after the  exe-
       cution of the specified
	 G'MIC pipeline	(see command status). Expression '${}' thus stands for
       the current status value.

	 * '{``string}'	(starting with two backquotes)	is  substituted	 by  a
       double-quoted version of	the
	 specified string.

	 *  '{/string}'	is substituted by the escaped version of the specified
       string.

	 * '{'string'[:delimiter]}' (between single quotes) is substituted  by
       the sequence of character
	 codes	that composes the specified string, separated by specified de-
       limiter.	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 fea-
       ture. Specified 'feature' can be
	 one of:

	   - 'b': The image basename (i.e. filename without  the  folder  path
       nor extension).
	   - 'f': The image folder name.
	   -  'n': The image name or filename (if the image has	been read from
       a file).
	   - 't': The text string from the image values	regarded as  character
       codes.
	   -  'x': The image extension (i.e the	characters after the last . in
       the image name).
	   - '^': The sequence of all image values, separated by commas	,.
	   - '@subset':	The sequence of	 image	values	corresponding  to  the
       specified subset, and separated by
	 commas	,.
	   -  Any  other  'feature' is considered as a mathematical expression
       associated to the image
	 '[image]' and is substituted by the result of its  evaluation	(float
       value). For instance,
	 expression  '{0,w+h}'	is  substituted	 by  the  sum of the width and
       height of the first image (see
	 section Mathematical Expressions for more details). If	a mathematical
       expression starts with an
	 underscore  _,	the resulting value is truncated to a readable format.
       For instance, item '{_pi}'
	 is  substituted  by  '3.14159'	 (while	 '{pi}'	 is   substituted   by
       '3.141592653589793').
	   - A 'feature' delimited by backquotes is replaced by	a string whose
       character codes correspond to
	 the list of values resulting from the	evaluation  of	the  specified
       mathematical expression.	For
	 instance,  item  '{[102,111,111]}'  is	 substituted by	'foo' and item
       '{vector8(65)}' by 'AAAAAAAA'.
	 * '{*}' is substituted	by the visibility state	of the instant display
       window '#0]' (can be {
	 0=closed | 1=visible }.

	 *  '{*[index],feature1,...,featureN[:delimiter]}' is substituted by a
       specific	set of features	of
	 the instant display window '#0'  (or  '#index',  if  specified).  Re-
       quested '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 re-
       cently.
	   - 'm': boolean telling if the instant display has  been  moved  re-
       cently.
	   -  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 disable the  substitutions	 mechanism  in	items,
       when necessary.

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

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

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

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

	 *  A  math  expression	 may return a scalar or	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()', 'is-
       expr()',	'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_nor-
       malized?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()', 'vargmax-
       abs()', 'vavg()', 'vkth()',
	 'vmin()', 'vmax()', 'vminabs()',  'vmaxabs()',	 'vmed()',  'vprod()',
       'vstd()', 'vsum()' and 'vvar()'
	 are  the  versions  of	the previous function with vector-valued argu-
       ments.

	 * 'round(value,rounding_value,direction)' returns  a  rounded	value.
       'direction' can be {
	 -1=to-lowest |	0=to-nearest | 1=to-highest }.

	 * 'lerp(a,b,t)' returns 'a*(1-t) + b*t'.

	 * 'swap(a,b)' swaps the values	of the given arguments.

	 # 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.	number
       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 lo-
       cated 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 distribu-
       tion.

	 * '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  de-
       fault 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 co-
       efficients 'ak'.

	 * 'vectorN(a0,a1,,...,aN-1)' does the same, with the 'ak'  being  re-
       peated 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 values), 'reverse(A)' (reverse	order of components),
	 'shift(A,_length,_boundary_conditions)'			   and
       'same(A,B,_nb_vals,_is_case_sensitive)' (vector
	 equality test).

	 * Function 'normP(u1,...,un)' computes	the LP-norm of	the  specified
       vector ('P' being an `unsigned
	 integer` constant or 'inf'). If 'P' is	omitted, the L2	norm is	calcu-
       lated.

	 * Function  'resize(A,size,_interpolation,_boundary_conditions)'  re-
       turns a resized version of a
	 vector	 'A' with specified interpolation mode.	'interpolation'	can be
       { -1=none (memory content) |
	 0=none	| 1=nearest | 2=average	| 3=linear  |  4=grid  |  5=bicubic  |
       6=lanczos }, and
	 'boundary_conditions' can be {	0=dirichlet | 1=neumann	| 2=periodic |
       3=mirror	}.

	 * Function 'find(A,B,_starting_index,_search_step)' returns the index
       where sub-vector	'B' appears
	 in vector 'A',	(or '-1' if 'B'	is not contained in 'A'). Argument 'A'
       can be also replaced by an
	 image index '#ind'.

	 * A 2-dimensional vector may be seen as a complex number and used  in
       those particular
	 functions/operators: '**' (complex multiplication), '//' (complex di-
       vision),	'^^' (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	 loga-
       rithm),	'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/eigenvectors),
       '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 'trans-
       pose(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 com-
       mand that operates on image
	 values	 (e.g.	'fill')	 modifies the whole spectrum range of the pro-
       cessed 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	 char-
       acter codes of the specified
	 character string (e.g.	'foo' is equal to [ 102,111,111	]).

	 *  _'character' returns the (scalar) byte code	of the specified char-
       acter (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 cor-
       responding 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 evaluated as 'pi'.

	 * '=':	variable assignment. Variables in mathematical parser can only
       refer to	numerical values
	 (vectors or scalars). Variable	names are case-sensitive. Use this op-
       erator 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:

	 * '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'	other-
       wise). 'interpolation_type' can
	 be { 0=nearest	neighbor | 1=linear | 2=cubic }. 'boundary_conditions'
       can be {	0=dirichlet |
	 1=neumann | 2=periodic	| 3=mirror }. Omitted coordinates are replaced
       by their	default	values which
	 are  respectively 'x',	'y', 'z', 'c', 'interpolation' and 'boundary'.
       For instance command

	   fill	0.5*(i(x+1)-i(x-1))

	  will estimate	the X-derivative of an image with a  classical	finite
       difference scheme.

	 *  'j(_dx,_dy,_dz,_dc,_interpolation_type,_boundary_conditions)' does
       the same	for the	pixel located
	 at position (x+dx,y+dy,z+dz,c+dc) (pixel access relative to the  cur-
       rent coordinates).

	 * 'i[offset,_boundary_conditions]' returns the	value of the pixel lo-
       cated 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,offset,_boundary_conditions]'	and 'i[offset,_boundary_condi-
       tions]' 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,_interpo-
       lation,_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)'  re-
       turns a vector whose values come
	 from  the  cropped region of image '[ind]' (or	from default image se-
       lected 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 co-
       ordinates. 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,_pat-
       tern,_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  in-
       stance, 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 'expres-
       sion'.

	 * 'for(init,condition,_procedure,body)' first evaluates  the  expres-
       sion 'init', then iteratively
	 evaluates 'body' (followed by 'procedure' if specified) while 'condi-
       tion' holds (i.e. not zero). It
	 may happen that no iterations are done, in which  case	 the  function
       returns 'nan'. Otherwise, it
	 returns the last value	of 'body'. For instance, the expression:

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

	  returns  the	'N'-th	value  of  the	Fibonacci sequence, for	'N>=0'
       (e.g., '46368' for 'N=24').

	 * 'while(condition,expression)' is exactly the	same as	'for(init,con-
       dition,expression)' without the
	 specification of an initializing expression.

	 *  'break()'  and  'continue()' respectively breaks and continues the
       current running bloc (loop, init
	 or main environment).

	 * 'fsize('filename')' returns the size	of  the	 specified  'filename'
       (or '-1'	if file	does not exist).

	 * 'date(attr,'path')' returns the date	attribute for the given	'path'
       (file or	directory), with
	 'attr'	being {	0=year | 1=month | 2=day | 3=day of week  |  4=hour  |
       5=minute	| 6=second }, or a
	 vector	of those values.

	 *  'date(_attr)' returns the specified	attribute for the current (lo-
       cale) date (attributes being {
	 0...6=same meaning as above | 7=milliseconds }).

	 * 'print(expr1,expr2,...)' or 'print(#ind)' prints the	value  of  the
       specified expressions (or image
	 information)  on  the	console, and returns the value of the last ex-
       pression	(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 mem-
       ory 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 destina-
       tion '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,_to_numbers)' returns the	value  of  the
       specified variable, as a	vector
	 of  'size'  values,  or  as a scalar (if 'size' is zero or not	speci-
       fied).

	 * '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_condi-
       tions,_is_normalized,_channel_mode,_xcenter,
	 _ycenter,_zcenter,_xstart,_ystart,_zs-
       tart,_xend,_yend,_zend,_xstride,_ystride,_zstride,_xdilation,_y
	 dilation,_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  ef-
       fect.

	 *  Overloading	macros with different number of	arguments is possible.
       Re-defining a previously
	 defined macro with the	same number of arguments discards its previous
       definition.

	 *  Macro functions are	indeed processed as macros by the mathematical
       evaluator. You should
	 avoid invoking	them with arguments that are themselves	results	of as-
       signments 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, expres-
       sion

	   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  un-
       usual 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 computation threads.

	 *  Starting  an expression with ':' or	'*' forces the evaluations re-
       quired 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 ac-
       cess operators 'i()', 'i[]',
	 'j()' and 'j[]' return	values of the image being currently  modified,
       in forward ('>')	or backward
	 ('<') order. The multi-threading evaluation of	the expression is dis-
       abled in	this case.

	 * Function 'critical(expr)' forces the	execution of the given expres-
       sion in a single	thread at a
	 time.

	 *  'begin_t(expr)'  and 'end_t(expr)' evaluates the specified expres-
       sion once for each running thread
	 (so possibly several times) at	the beginning and the end of the eval-
       uation 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 | chan-
       nel-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	 'dis-
       play') 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.off'.
	   - 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 dis-
       carded 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	 argu-
       ments, each being double-quoted.
	   -  '$#' is substituted by the maximum index of known	arguments (ei-
       ther specified by the user or
	 set to	a default value	in the custom command).
	   - '$[]' is substituted by the list of selected image	 indices  that
       have been specified in the
	 command invocation.
	   - '$?' is substituted by a printable	version	of '$[]' to be used in
       command descriptions.
	   - '$i' and '${i}' are both substituted by the i-th specified	 argu-
       ment. 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 as-
       sign each argument '$i' to the
	 named variable	'var$i'	(for i in  '[0...$#]'.	This  is  particularly
       useful when a custom command want
	 to  manage  variable  numbers	of arguments. Variables	names must use
       character set [a-zA-Z0-9_] and
	 cannot	start with a number.
	 * These particular $-expressions for custom commands are always  sub-
       stituted, even in
	 double-quoted	items  or  when	 the dollar sign '$' is	escaped	with a
       backslash 'fR'. To avoid
	 substitution, place an	empty double quoted string just	after the  '$'
       (as in '$""1').

	 * Specifying arguments	may be skipped when invoking a custom command,
       by replacing them by commas
	 ',' as	in expression

	   flower ,,3

	  Omitted arguments are	set to their default  values,  which  must  be
       thus explicitly defined in the
	 code  of the corresponding custom command (using default argument ex-
       pressions 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 ar-
       gument specified	between	'[]' or
	 starting by '_' is optional except when standing for an existing  im-
       age '[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,_cap-
       ture_width>=0,_capture_height>=0

	   Insert one or several frames	from specified camera.
	   When	'nb_frames==0',	the camera stream is released instead of  cap-
       turing new images.

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

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

	   Insert one of the 862 pre-defined CLUTs at the  end	of  the	 image
       list.
	   'clut_name'	 can   be  {  2-strip-process  |  60s  |  60s_faded  |
       60s_faded_alt | 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_highligjtes_re-
       covery_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 |
       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	| bourbon_64 |
	   bright_green_01  | bright_teal_orange | bright_warm | brightgreen |
       brownish	| bw_1 | bw_10 | bw_2 |
	   bw_3	| bw_4 | bw_5 |	bw_6 | bw_7 | bw_8 | bw_9 | byers_11 | candle-
       light | caribe |	chemical_168 |
	   chrome_01  |	 cinema	 | cinema_2 | cinema_3 | cinema_4 | cinema_5 |
       cinema_noir | cinematic-1 |
	   cinematic-10	| cinematic-2 |	 cinematic-3  |	 cinematic-4  |	 cine-
       matic-5 | cinematic-6 | cinematic-7 |
	   cinematic-8	|  cinematic-9	|  cinematic_01	| cinematic_02 | cine-
       matic_03	| cinematic_for_flog |
	   cinematic_lady_bird	 |   cinematic_mexico	|   city_7   |	 clas-
       sic_teal_and_orange | clayton_33	|
	   clear_teal_fade    |	  clouseau_54	|   cobi_3   |	 coffee_44   |
       cold_clear_blue | cold_clear_blue_1 |
	   cold_simplicity_2 | color_rich | colorful_0209  |  colornegative  |
       conflict_01 | contrail_35 |
	   contrast_with_highlights_protection	|  contrasty_afternoon	| con-
       trasty_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_place_01 | date_39 | day_4nite | day_for_night
       | deep |	deep_blue |
	   deep_dark_warm   |	deep_high_contrast    |	   deep_teal_fade    |
       deep_warm_fade |	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 | ex-
       pired_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	| fad-
       edlook |	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_in-
       frared_color_yp_1 | fgcinebasic |
	   fgcinebright	| fgcinecold  |	 fgcinedrama  |	 fgcinetealorange_1  |
       fgcinetealorange_2 | fgcinevibrant |
	   fgcinewarm	|   film_0987	|  film_9879  |	 film_high_contrast  |
       film_print_01 | film_print_02 | filmic |
	   flat_30 | flavin | foggynight | folger_50 | french_comedy | frosted
       | frostedbeachpicnic |
	   fuji_160c   |   fuji_160c_+	 |   fuji_160c_++   |	fuji_160c_-  |
       fuji_3510_constlclip | fuji_3510_constlmap |
	   fuji_3510_cuspclip |	fuji_3513_constlclip |	fuji_3513_constlmap  |
       fuji_3513_cuspclip | fuji_400h |
	   fuji_400h_+	| fuji_400h_++ | fuji_400h_- | fuji_800z | fuji_800z_+
       | fuji_800z_++ |	fuji_800z_- |
	   fuji_astia_100_generic   |	fuji_astia_100f	  |   fuji_fp-100c   |
       fuji_fp-100c_+ |	fuji_fp-100c_++	|
	   fuji_fp-100c_+++   |	  fuji_fp-100c_++_alt	|   fuji_fp-100c_-   |
       fuji_fp-100c_-- | fuji_fp-100c_alt |
	   fuji_fp-100c_cool | fuji_fp-100c_cool_+  |  fuji_fp-100c_cool_++  |
       fuji_fp-100c_cool_- |
	   fuji_fp-100c_cool_--	 |  fuji_fp-100c_negative | fuji_fp-100c_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_negative_+	 |     fuji_fp-3000b_negative_++     |
       fuji_fp-3000b_negative_+++ |
	   fuji_fp-3000b_negative_-	|     fuji_fp-3000b_negative_--	     |
       fuji_fp-3000b_negative_early | fuji_fp_100c
	   |	fuji_hdr    |	 fuji_neopan_1600   |	fuji_neopan_1600_+   |
       fuji_neopan_1600_++ | fuji_neopan_1600_-	|
	   fuji_neopan_acros_100 | fuji_provia_100_generic |  fuji_provia_100f
       | fuji_provia_400f |
	   fuji_provia_400x  | fuji_sensia_100 | fuji_superia_100 | fuji_supe-
       ria_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 |	futur-
       isticbleak_1 | futuristicbleak_2
	   | futuristicbleak_3 | futuristicbleak_4 | going_for_a_walk |	golden
       | golden_bright | golden_fade |
	   golden_mono | golden_night_softner_43 | golden_sony_37 | golden_vi-
       brant | goldengate |
	   goldfx_bright_spring_breeze	  |    goldfx_bright_summer_heat     |
       goldfx_hot_summer_heat |
	   goldfx_perfect_sunset_01min	  |    goldfx_perfect_sunset_05min   |
       goldfx_perfect_sunset_10min |
	   goldfx_spring_breeze	| goldfx_summer_heat | good_morning | green_15
       | green_2025 | green_action |
	   green_afternoon  |  green_blues  |  green_conflict |	green_day_01 |
       green_day_02 | green_g_09 |
	   green_indoor	| green_light |	green_mono  |  green_yellow  |	green-
       ish_contrasty | greenish_fade |
	   greenish_fade_1  |  hackmanite | happyness_133 | hard_teal_orange |
       harsh_day | harsh_sunset	| helios
	   | herderite | heulandite | hiddenite	| highlights_protection	|  hi-
       lutite |	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	|  il-
       ford_hp_5_+ | ilford_hp_5_++ |
	   ilford_hp_5_-  |  ilford_hp_5_plus_400  |  ilford_hps_800   |   il-
       ford_pan_f_plus_50 | ilford_xp_2	|
	   indoor_blue	|  industrial_33 | instantc | justpeachy | k_tone_vin-
       tage_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_ek-
       tachrome_100 | kodak_ektachrome_100_vs |
	   kodak_ektachrome_100_vs_generic    |	   kodak_ektar_100    |	   ko-
       dak_elite_100_xpro | kodak_elite_chrome_200 |
	   kodak_elite_chrome_400    |	   kodak_elite_color_200     |	   ko-
       dak_elite_color_400 | kodak_elite_extracolor_100
	   | kodak_hie_hs_infra	| kodak_kodachrome_200 | kodak_kodachrome_25 |
       kodak_kodachrome_64 |
	   kodak_kodachrome_64_generic | kodak_portra_160 | kodak_portra_160_+
       | kodak_portra_160_++ |
	   kodak_portra_160_-  | kodak_portra_160_nc | kodak_portra_160_nc_+ |
       kodak_portra_160_nc_++ |
	   kodak_portra_160_nc_- | kodak_portra_160_vc | kodak_portra_160_vc_+
       | kodak_portra_160_vc_++	|
	   kodak_portra_160_vc_- | kodak_portra_400 | kodak_portra_400_+ | ko-
       dak_portra_400_++ |
	   kodak_portra_400_- |	kodak_portra_400_nc | kodak_portra_400_nc_+  |
       kodak_portra_400_nc_++ |
	   kodak_portra_400_nc_- | kodak_portra_400_uc | kodak_portra_400_uc_+
       | kodak_portra_400_uc_++	|
	   kodak_portra_400_uc_- | kodak_portra_400_vc | kodak_portra_400_vc_+
       | kodak_portra_400_vc_++	|
	   kodak_portra_400_vc_- | kodak_portra_800 | kodak_portra_800_+ | ko-
       dak_portra_800_++ |
	   kodak_portra_800_- |	kodak_portra_800_hc |  kodak_t-max_100	|  ko-
       dak_t-max_3200 |	kodak_t-max_400	|
	   kodak_tmax_3200  |  kodak_tmax_3200_+  |  kodak_tmax_3200_++	 | ko-
       dak_tmax_3200_- | kodak_tmax_3200_alt
	   | kodak_tri-x_400 | kodak_tri-x_400_+ |  kodak_tri-x_400_++	|  ko-
       dak_tri-x_400_- |
	   kodak_tri-x_400_alt	|  korben_214  |  landscape_1 |	landscape_10 |
       landscape_2 | landscape_3 |
	   landscape_4 | landscape_5 | landscape_6 | landscape_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	|  low_contrast_blue  |	 low_key_01  |
       lucky_64	| lushgreensummer |
	   magenta_day | magenta_day_01	| magenta_dream	| magenta_yellow | ma-
       gentacoffee | matrix |
	   mckinnon_75	| memories | metropolis	| milo_5 | minimalistcaffeina-
       tion | modern_film | mono_tinted	|
	   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 | morroco_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 | mysticpurplesunset |
	   nah | natural_vivid | nemesis | neon_770  |	neutral_teal_orange  |
       neutral_warm_fade | newspaper |
	   night_01  | night_blade_4 | night_king_141 |	night_spy | nightfrom-
       day | 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_--   |   po-
       laroid_665_negative |
	   polaroid_665_negative_+    |	   polaroid_665_negative_-    |	   po-
       laroid_665_negative_hc |	polaroid_667 |
	   polaroid_669	| polaroid_669_+ | polaroid_669_++ |  polaroid_669_+++
       | polaroid_669_-	|
	   polaroid_669_--  |  polaroid_669_cold  |  polaroid_669_cold_+ | po-
       laroid_669_cold_- |
	   polaroid_669_cold_--	| polaroid_672 | polaroid_690 |	polaroid_690_+
       | polaroid_690_++ |
	   polaroid_690_-   |	polaroid_690_--	  |  polaroid_690_cold	|  po-
       laroid_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_+    |	   po-
       laroid_px-100uv+_cold_++	|
	   polaroid_px-100uv+_cold_+++	 |   polaroid_px-100uv+_cold_-	|  po-
       laroid_px-100uv+_cold_--	|
	   polaroid_px-100uv+_warm   |	 polaroid_px-100uv+_warm_+    |	   po-
       laroid_px-100uv+_warm_++	|
	   polaroid_px-100uv+_warm_+++	 |   polaroid_px-100uv+_warm_-	|  po-
       laroid_px-100uv+_warm_--	|
	   polaroid_px-680 |  polaroid_px-680_+	 |  polaroid_px-680_++	|  po-
       laroid_px-680_- | polaroid_px-680_-- |
	   polaroid_px-680_cold	    |	  polaroid_px-680_cold_+     |	   po-
       laroid_px-680_cold_++ |
	   polaroid_px-680_cold_++_alt	 |   polaroid_px-680_cold_-   |	   po-
       laroid_px-680_cold_-- |
	   polaroid_px-680_warm	    |	  polaroid_px-680_warm_+     |	   po-
       laroid_px-680_warm_++ | polaroid_px-680_warm_- |
	   polaroid_px-680_warm_-- | polaroid_px-70 | polaroid_px-70_+	|  po-
       laroid_px-70_++ |
	   polaroid_px-70_+++  |  polaroid_px-70_-  |  polaroid_px-70_-- | po-
       laroid_px-70_cold |
	   polaroid_px-70_cold_+    |	  polaroid_px-70_cold_++     |	   po-
       laroid_px-70_cold_- | polaroid_px-70_cold_-- |
	   polaroid_px-70_warm	    |	   polaroid_px-70_warm_+     |	   po-
       laroid_px-70_warm_++ | polaroid_px-70_warm_- |
	   polaroid_px-70_warm_--   |	polaroid_time_zero_expired    |	   po-
       laroid_time_zero_expired_+ |
	   polaroid_time_zero_expired_++  | polaroid_time_zero_expired_- | po-
       laroid_time_zero_expired_-- |
	   polaroid_time_zero_expired_--- | polaroid_time_zero_expired_cold |
	   polaroid_time_zero_expired_cold_-	 |	polaroid_time_zero_ex-
       pired_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	| pur-
       ple_2 | red_afternoon_01	|
	   red_day_01  |  red_dream_01	|  redblueyellow  |  reds  |  reds_or-
       anges_yellows | reeve_38	| remy_24 |
	   rest_33  |  retro  |	retro_brown_01 | retro_magenta_01 | retro_sum-
       mer_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	| sav-
       ing_private_damon | science_fiction
	   |  serenity	|  seringe_4  |	  serpent   |	seventies_magazine   |
       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 | so-
       larized_color | solarized_color_2
	   |   springmorning   |   sprocket_231	 |  spy_29  |  street  |  stu-
       dio_skin_tone_shaper | subtle_blue |
	   subtle_green	| subtle_yellow	 |  summer  |  summer_alt  |  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 | tealor-
       ange_1 |	tealorange_2 |
	   tealorange_3	 | technicalfx_backlight_filter	| teigen_28 | tension-
       green_1 | tensiongreen_2	|
	   tensiongreen_3  |  tensiongreen_4  |	 terra_4  |   the_matrices   |
       thriller_2 | toastedgarden | trent_18 |
	   true_colors_8 | turkiest_42 | tweed_71 | ultra_water	| undeniable |
       undeniable_2 | unknown |
	   urban_cowboy	| uzbek_bukhara	| uzbek_marriage | uzbek_samarcande  |
       velvetia	| very_warm_greenish |
	   vibrant  |  vibrant_alien  |	 vibrant_contrast | vibrant_cromeish |
       victory | vintage | vintage_163 |
	   vintage_alt | vintage_brighter | vintage_chrome |  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 | whiter_whites |
       winterlighthouse	| wipe |
	   wooden_gold_20  |  yellow_55b  |  yellow_film_01  |	yellowstone  |
       you_can_do_it | zed_32 |	zeke_39	|
	   zilverfx_bw_solarization | 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' invo-
       cation.

	   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 in-
       dices instead of	image indices.

	   Default value: 'mode=1'.

	 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/tutorial/_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 channel).
	   * 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 in-
       stant 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.

	 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=cir-
       cles | 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',	 'ver-
       tex_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,_vertex_radius>=0,_is_an-
       tialiased={ 0 | 1 },_is_decorated={ 0 |	      1	},_xlabel,_ylabel

	   Render 2D or	3D parametric curve or point clouds from selected  im-
       age 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	 'yla-
       bel="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)-sin(t/12)^5)'
       display_parametric 512,512
		    [#2] 1000,1,1,2,u(-100,100)	quantize 4,1 noise 12 channels
       0,2 +normalize 0,255 append c	   display_parametric 512,512,0.1,8

	 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,_yla-
       bel

	   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	 'yla-
       bel="y-axis"'.

	   Example:   [#1]   300,1,1,1,'0.3+abs(cos(10*pi*x/w))+u(0.4)'	  dis-
       play_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  normal-
       ize[-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/tutorial/_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	 +dis-
       play_graph 400,300

	 funny_oneliners:

	   This	commands shows examples	of funny oneliners that	 produce  cool
       results!

	   Example:   [#1]   729,729,1,3,"c(x,y,l)   =	 (S   =	 round(w/3^l);
       (int(x/S)%3)*(int(y/S)%3)==1?255:l<6?c(x,y,l +	     1):0);  c(x,y,1)"
       nm "Sierpinski Carpet"
		    [#2] 1024,1024,1,1,">x>y?0:y<2?1:xor(j(0,-1),j(-1,-1))" f.
       "255*j(-w/2+y/2,0)" nm "Sierpinksi	Triangle"
		    [#3] 500,500 repeat	10 +noise_poissondisk[0]  {3+$>}  done
       rm[0]  a	 z f "!z?(R=cut(norm(x-w/2,	 y-h/2)/20,0,d-1);i(x,y,R)):0"
       slices 0	to_rgb f  "max(I)?u([255,255,255]):I"  blur_radial	  0.6%
       equalize	n 0,255	nm "Light Speed"
		    [#4]  100000,1,1,1,0.6180339887498948482*x round f i-j[-1]
       (1,-1)  *  cumulate  mod	 4  +  1   +f	arg(i,	      1,1,-1,-1)   f..
       arg(i,-1,1,1,-1)	 cumulate -[0] {0,im} -[1] {1,im} a y pointcloud 0 b 1
       nm	"Fibonacci Word, by James Prichard"
		    [#5]
       1000,1000,1,1,f(x,y,l)=l?f(max(x,y)%3,abs(min(x,y))*3,l-1):x;f(x/w-.7,y/w,6)
       nm	"Recursive macro, by James Prichard"

	 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  ex-
       isting 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.

	 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  re-
       peat...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_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  in-
       formation 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 localized
       filters,	empty if not
	   specified).
	   * '$_fF_nbparams' : Number of parameters.
	   For each parameter	  * '$_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_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=cir-
       cles | 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  in-
       stant display window [0]	if opened).
	   'feature_type'  can	be { 0=point | 1=segment | 2=rectangle | 3=el-
       lipse }.
	   Arguments 'X','Y','Z' determine the initial selection view, for  3D
       volumetric images.
	   The	retrieved  feature  is	returned  as  a	 3D  vector  (if 'fea-
       ture_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<=_off-
       set_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', 'off-
       set_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 re-
       moved 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  in-
       dices 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 is
       has been	closed by the user.

	   Default values: 'width=height=normalization=fullscreen=-1' and 'ti-
       tle=(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 argu-
       ment 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 bitwise AND of selected images.
	   (equivalent to shortcut command '&').

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

	 argmax:

	   Compute the argmax of selected images. Returns a single image
	   with	each pixel value being the index of the	input image with 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 sequential bitwise left shift
       of selected images.
	   (equivalent to shortcut command '<<').

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

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

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

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

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

	 cos (+):

	   Compute the pointwise cosine	of selected images.

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

	   Tutorial:   https://gmic.eu/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,...,re-
       alN,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  im-
       ages.
	   (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, im-
       age 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, im-
       age 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, im-
       age or mathematical expression,
	   or compute the pointwise sequential bitwise OR of selected images.
	   (equivalent to shortcut command '|').

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

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

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

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

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

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

	   Compute the bitwise left rotation of	selected images	with specified
       value, image or mathematical
	   expression, or compute the pointwise	sequential bitwise left	 rota-
       tion 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	sequential bitwise right rota-
       tion 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  se-
       lected 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 bitwise 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 re-
       spect 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 | double }.

	 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 (unlimited),_er-
       ror_metric={ 0=L2-norm |	       1=deltaE_1976 | 2=deltaE_2000 },_recon-
       struction_colorspace={ 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	 +com-
       press_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]	  dis-
       play_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_col-
       orspace=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_col-
       orspace=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_col-
       orspace=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 3x3
       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	{ uchar	| char | ushort	| short	| uint | int |
       uint64 |	int64 |	float |	double }.

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

	   Equalize histograms of selected images.
	   If value range is specified,	the equalization is done only for 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 'for-
       mula'.
	   (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 pal-
       ette.
	   '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	},_in-
       clude_max_boundary={ 0=no | 1=yes }

	   Detect pixels whose values are in specified range [min,max],	in se-
       lected 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  im-
       ages.
	   '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 | au-
       rora | hocuspocus | srb2	| uzebox
	   }
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann | 2=periodic
       | 3=mirror }.

	   Default value: 'boundary_conditions=0'.

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

	   Tutorial: https://gmic.eu/tutorial/_map.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	 +his-
       togram 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 co-
       ordinates.
	   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  se-
       lected 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 se-
       lected 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]	  dis-
       play_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 se-
       lected 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=me-
       dian-cut	| 0=k-means | 1=uniform	}

	   Quantize selected images.

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

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

	 quantize_area:
	     _min_area>0

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

	   Default value: 'min_area=10'.

	   Example:  [#1]  image.jpg  quantize	3  +blur  1  round[-1]	+quan-
       tize_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<=_con-
       trast<=100,-100<=_gamma<=100,-100<=_hue_shift<=100,	  -100<=_satu-
       ration<=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  se-
       lected images.
	   (equivalent to shortcut command 'ac').

	   Argument  'color_channels' refers to	a colorspace, and can be basi-
       cally 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 +autoin-
       dex[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_smooth-
       ness2=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=achromatomaly }

	   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 orienta-
       tion +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 3x3 specified matrix to RGB colors of selected	images.

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

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

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

	 palette:
	     palette_name | palette_number

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

	   Example: [#1] palette hsv

	 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

	 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  re-
       gions 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  ap-
       pend[-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 im-
       ages.
	   Argument  'color channels' is the same as with command 'apply_chan-
       nels'.

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

	   Example:  [#1]  image.jpg  100,100,1,3,"u([256,200,100])"   +trans-
       fer_histogram[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_chan-
       nels'.

	   Default value: 'color_channels=all'.

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

	 transfer_rgb:
	     [target],_gamma>=0,_regularization>=0,_luminosity_con-
       straints>=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_con-
       straints=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  re-
       move[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",num-
       ber_of_scales>0,_min_scale[%]>=0,_max_scale[%]>=0,_scale_gamma>0,_in-
       terpolation

	   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 'interpola-
       tion=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,  ac-
       cording 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_connec-
       tivity=0' and 'output_type=1'.

	   Example: [#1] 256,256 noise 0.1,2 eq	1 dilate_circ 20 label_fg  0,1
       normalize 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=pe-
       riodic |	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=pe-
       riodic |	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=pe-
       riodic |	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	},_la-
       bel_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 },"_process-
       ing_command"

	   Create a single image montage from selected	images,	 according  to
       specified layout	code :
	   *  'X' to assemble all images using an automatically	estimated lay-
       out.
	   * '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 normal-
       ize 0,255 frame 3,3,0 frame 10,10,255	    to_rgb  +montage  A	 +mon-
       tage[^-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,_bound-
       ary_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 cho-
       sen 'interpolation' mode	:
	   *  When  'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary_conditions'
       is meaningless.
	   * When 'interpolation==0', 'boundary_conditions' can	be { 0=dirich-
       let | 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  'interpola-
       tion=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] im-
       age.
	   (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 cho-
       sen 'interpolation' mode	:
	   * When 'interpolation=={ -1 | 1 | 2 | 4  }',	 'boundary_conditions'
       is meaningless.
	   * When 'interpolation==0', 'boundary_conditions' can	be { 0=dirich-
       let | 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 'interpola-
       tion=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 cho-
       sen 'interpolation' mode	:
	   * When 'interpolation=={ -1 | 1 | 2 | 4  }',	 'boundary_conditions'
       is meaningless.
	   * When 'interpolation==0', 'boundary_conditions' can	be { 0=dirich-
       let | 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 'interpola-
       tion=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 cho-
       sen 'interpolation' mode	:
	   *  When  'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary_conditions'
       is meaningless.
	   * When 'interpolation==0', 'boundary_conditions' can	be { 0=dirich-
       let | 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  'interpola-
       tion=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 cho-
       sen 'interpolation' mode	:
	   * When 'interpolation=={ -1 | 1 | 2 | 4  }',	 'boundary_conditions'
       is meaningless.
	   * When 'interpolation==0', 'boundary_conditions' can	be { 0=dirich-
       let | 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 'interpola-
       tion=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 cho-
       sen 'interpolation' mode	:
	   *  When  'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary_conditions'
       is meaningless.
	   * When 'interpolation==0', 'boundary_conditions' can	be { 0=dirich-
       let | 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  'interpola-
       tion=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 cho-
       sen 'interpolation' mode	:
	   * When 'interpolation=={ -1 | 1 | 2 | 4  }',	 'boundary_conditions'
       is meaningless.
	   * When 'interpolation==0', 'boundary_conditions' can	be { 0=dirich-
       let | 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 'interpola-
       tion=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

	 scale3x:

	   Resize selected images using	the Scale3x algorithm.

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

	 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_Cu-
       bic_Convolution_Interpolation.

	   Default  values:  'edge_threshold=1.15',  'exponent=5'   and	  'ex-
       tend_1px=0'.

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

	 seamcarve:
	     _width[%]>=0,_height[%]>=0,_is_priority_channel={ 0 | 1 },_is_an-
       tialiasing={ 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_an-
       tialiasing=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 se-
       quence 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[%],_cen-
       ter_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', 'cen-
       ter_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', 'an-
       isotropy=0.4' and
	     'sharpening=10'.

	   Example: [#1] image.jpg resize2dy 100 +upscale_smart	500%,500%  ap-
       pend 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=for-
       ward-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_condi-
       tions=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=atan2(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:
	     [warp-
       ing_field],patch_width>=1,_patch_height>=1,_patch_depth>=1,_std_fac-
       tor>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 quasi-gaussian or gaussian	filter (recur-
       sive implementation).
	   (equivalent to shortcut command 'b').

	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann }.
	   'kernel' can	be { 0=quasi-gaussian (faster) | 1=gaussian }.
	   When	specified, argument 'axes' is a	sequence of { x	| y | z	| c }.
	   Specifying  one  axis  multiple  times apply	also the blur multiple
       times.

	   Default values: 'boundary_conditions=1' and 'kernel=0'.

	   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=quasi-gaussian	       (faster)	| 1=gaussian | 2=box |
       3=triangle | 4=quadratic	},_normalize_scales={ 0	| 1 },_axes

	   Apply a bloom filter	that blend multiple blur filters of  different
       radii,
	   resulting in	a larger but sharper glare than	a simple blur.
	   When	specified, argument 'axes' is a	sequence of { x	| y | z	| c }.
	   Specifying  one  axis  multiple  times apply	also the blur multiple
       times.
	   Reference: Masaki Kawase, "Practical	Implementation of High Dynamic
       Range Rendering", GDC 2004.

	   Default values: 'amplitude=1', 'ratio=2', 'nb_iter=5', 'blend_oper-
       ator=+',	'kernel=0',
	     '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 am-
       plitudes.

	   Default  values:  'amplitude2=0',  'angle=0'	 and  'boundary_condi-
       tions=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_selective ,	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,_zs-
       tart,_xend,_yend,_zend,_xstride,_ystride,_zstride,_xdilation,_ydila-
       tion,	   _zdilation

	   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',	'chan-
       nel_mode=1',
	     'xcenter=ycenter=zcenter=-1'  (-1=centered),   'xstart=ystart=zs-
       tart=0',	'xend=yend=zend=-1' (-1=max
	     coordinates),  'xstride=ystride=zstride=1'	 and 'xdilation=ydila-
       tion=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  do-
       main.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann | 2=periodic
       | 3=mirror }.

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

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

	   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',	'chan-
       nel_mode=1',
	     'xcenter=ycenter=zcenter=-1'   (-1=centered),  'xstart=ystart=zs-
       tart=0',	'xend=yend=zend=-1' (-1=max
	     coordinates), 'xstride=ystride=zstride=1'	and  'xdilation=ydila-
       tion=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=quasi-
       gaussian	(faster) | 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=quasi-gaussian (faster)  |
       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=mo-
       tion-compensated	}).

	   Default value: 'method=0'.

	   Example:  [#1]  image.jpg +rotate 3,1,1,50%,50% resize 100%,50% re-
       size 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_ap-
       prox={ 0	| 1 } |
	     std_deviation_s[%]>=0,_std_devia-
       tion_r[%]>=0,_patch_size>0,_lookup_size>0,_smoothness,	     _fast_ap-
       prox={ 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_spin-
       ning=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_patch-
       pca[-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	diver-
       gence[-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 im-
       ages.
	   (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 im-
       ages.
	   (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 },_time_step>0,_[initial_estimate]

	   Invert selected Laplacian images.
	   If given 'nb_iterations' is '0', inversion is done in Fourier space
       (single iteration),
	   otherwise, by applying 'nb_iterations' of a Laplacian-inversion PDE
       flow (with specified
	   'time_step').
	   Note	that the resulting inversions are just	estimation  of	possi-
       ble/approximated	solutions.

	   Default  values: 'nb_iterations=0','time_step=10' and '[initial_es-
       timated]=(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_fac-
       tor>=0,_lookup_increment!=0,_blend_size>=0,	     0<=_blend_thresh-
       old<=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-connec-
       tivity 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 el-
       lipse 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 re-
       move[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	trans-
       port-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 'diffu-
       sion_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,_al-
       pha>=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_con-
       nectivity=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_itera-
       tions_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_band-
       width>0,_patch_measure_command |
	     _patch_radius>0,_spatial_bandwidth>0,_tonal_band-
       width>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_correla-
       tion[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_se-
       quence=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  key-
       point '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  'attenua-
       tion=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, de-
       scribed 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 'pre-
       cision=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<=_anisotropy<=1,_al-
       pha[%],_sigma[%],_dl>0,_da>0,_precision>0,		   _interpola-
       tion,_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  'diffu-
       sion_iter=20'.

	   Example:  [#1] image.jpg 100%,100% circle[-1] 50%,50%,25%,1,255 ap-
       pend 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_match-
       patch 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 'thresh-
       old=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]
       +gradient[-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!" +dis-
       play_fft	 remove[-3,-1]	normalize  0,255	append[-4,-2]  y   ap-
       pend[-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 la-
       bel[-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  se-
       lected 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[%],_interpola-
       tion,_boundary_conditions |
	     x0[%],y0[%],z0[%],x1[%],y1[%],z1[%],x2[%],y2[%],z2[%],x3[%],y3[%],z3[%],_in-
       terpolation,	  _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
       +delaunay
		    [#2]  image.jpg b 1% 100%,100% noise. 0.8,2	eq. 1 mul +de-
       launay 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	 ifft-
       polar

	 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 im-
       ages.
	   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_vot-
       ing=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  dis-
       play_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 se-
       lected 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 se-
       lected 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 rectangle	$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_con-
       nectivity={ 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)	 mini-
       mal_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 lo-
       cations.

	   Example:		[#1]		 image.jpg	      +patches
       64,64,1,153,124,0,184,240,0,217,126,0,275,38,0

	 matchpatch (+):
	     [patch_im-
       age],patch_width>=1,_patch_height>=1,_patch_depth>=1,_nb_itera-
       tions>=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	occur-
       rences.
	   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  specified
       axis.
	     - If set to N>0, the size along the specified axis	is N.
	     - If set to N<0, the size along the specified axis	is at most N.
	   Points  with	coordinates that are negative or higher	than specified
       ('width','height','depth')
	   are not plotted.

	   Default values: 'type=0' and	'max_width=max_height=max_depth=0'.

	   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
       +pointcloud 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',	'dila-
       tion=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,bound-
       ary=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  se-
       lected images.

	   Default value: 'patch_size=16'

	   Example: [#1] image.jpg +variance_patch

	 12.10.	Image Drawing
		-------------

	 arrow:
	     x0[%],y0[%],x1[%],y1[%],_thick-
       ness[%]>=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_thick-
       ness=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=(unde-
       fined)' 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',   'specu-
       lar_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_angle-
       max<=180,_spline_roundness>=0,_area_min>=0,_allow_self_intersection={ 0
       | 1 }

	   Automatically  close	 open  shapes in binary	images (defining white
       strokes on black	background).

	   Default  values:   'endpoint_rate=75',   'endpoint_connectivity=2',
       'spline_distmax=80',
	     'segment_distmax=20',     'spline_anglemax=90',	'spline_round-
       ness=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 el-
       lipse 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 el-
       lipse 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=cir-
       cles | 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=(unde-
       fined)' 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,0xCCCCC-
       CCC,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 ex-
       pected 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=(unde-
       fined)' 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,	 0xCC-
       CCCCCC,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 el-
       evation3d[-1] -0.2

	 marble:
	     _image_weight,_pattern_weight,_angle,_amplitude,_sharp-
       ness>=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',	  'an-
       gle=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,_itera-
       tion_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   },	  _fo-
       cale,_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_it-
       erations>=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 de-
       creasing	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,"la-
       bel1",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',	'opac-
       ity=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  ex-
       pected 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  ex-
       pected 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 ma-
       trices or matrix	fields.
	   If one selected image has 3 or 6 channels,  it  is  regarded	 as  a
       field of	2x2 or 3x3 symmetric
	   matrices,
	   whose eigen elements	are computed at	each point of the field.

	   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 col-
       umns 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 ro-
       tate3d[-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',	  'an-
       gle_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=off-
       set_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_ra-
       dius[%]>=0

	   Input 3D arrow with specified starting and ending 3D	points.

	   Default  values:  'radius=5%',  'head_length=25%'   and   'head_ra-
       dius=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,_la-
       bel_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',	  'la-
       bel_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
       pointcloud3d color3d[-1]	255,255,255	  circles3d 0.7

	 col3d (+):
	     Shortcut for command 'color3d'.

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

	   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
       pointcloud3d 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	double3d $> snapshot3d[-1] 400 done

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

	   Build 3D elevation of selected images, with a  specified  elevation
       map.
	   When	invoked	with (no arg) or 'z-factor', the elevation map is com-
       puted 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
       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  'smooth-
       ness=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  per-
       spective).
	   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 fo-
       cale3d {$<*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  col-
       orcube3d	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 opac-
       ity3d. 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%  ex-
       pand_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_an-
       gle=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(a*t+A*2*pi),
       y(t)=sin(b*t+B*2*pi), z(t)=sin(c*t+C*2*pi)).

	   Default  values:  'resolution=1024',	 'a=2',	 'A=0',	 'b=1',	'B=0',
       'c=0' and 'C=0'.

	   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  ro-
       tate3d[-1]  1,1,0,60  mode3d  {0,@$>}	   snapshot3d[-1] 300 done re-
       move[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)
       (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_in-
       put=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_subdivi-
       sions_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 an-
       gle (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 3x3 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]=(de-
       fault)'.

	   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 ?	+snap-
       shot3d[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  ro-
       tate3d[-1]  1,1,0,60  color3d[-1]  255,0,0	 specl3d {0,@$>} snap-
       shot3d[-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  ro-
       tate3d[-1]  1,1,0,60  color3d[-1]  255,0,0	 specs3d {0,@$>} snap-
       shot3d[-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_func-
       tion="abs(1+0.5*cos(3*phi)*sin(4*thet
	     a))"'.

	   Example: [#1] spherical3d 64	+primitives3d 1

	 spline3d:
	     x0[%],y0[%],z0[%],u0[%],v0[%],w0[%],x1[%],y1[%],z1[%],u1[%],v1[%],w1[%],_nb_ver-
       tices>=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 (+):
	     _keep_shared_data={ 0 | 1 }

	   Split selected 3D objects into 6 feature vectors :
	   { header, sizes, vertices, primitives, colors, opacities }.
	   (equivalent to shortcut command 's3d').

	   To recreate the 3D object, append these 6 images along the y-axis.

	   Default value: 'keep_shared_data=1'.

	   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%
       gaussian[-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  +stream-
       line3d[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   'smooth-
       ness=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 a 3D 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 ob-
       jects.

	   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:
	     "com-
       mand",_tile_width[%]>0,_tile_height[%]>0,_tile_depth[%]>0,_over-
       lap_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_con-
       ditions=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'	other-
       wise.

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

	 check_display:

	   Check if a display is available, and	throw an error otherwise.

	 continue (+):

	   Go to end of	current	'repeat...done', 'do...while' or 'local...end-
       local' 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 veri-
       fied
	   and test if specified condition holds
	   'condition' is a mathematical expression, whose evaluation  is  in-
       terpreted 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 evaluated
       once and	its result is set to
	   status.
	   *  If command selection is specified, the evaluation	is looped over
       selected	images.	Status is not
	   modified.
	     (in this latter case, 'eval' is similar to	'fill' without assign-
       ing 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'.

	 for (+):
	     condition

	   Start a 'for...done'	block.

	   Example: [#1] image.jpg resize2dy 32	400,400,1,3 x=0	for $x<400 im-
       age[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 in-
       terpreted 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 argu-
       ment 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=immedi-
       ately }.

	   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  ap-
       plication.

	 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	speci-
       fied condition holds.
	   'condition'	is  a mathematical expression, whose evaluation	is in-
       terpreted 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,_ex-
       pand_type={0=min	| 1=max	| 2=all}

	   Create MxN array from selected images.

	   Default  values:  'N=M',  'fade_start=60',  'fade_end=90'  and 'ex-
       pand_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',	'shad-
       ing=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,_up-
       per_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_smooth-
       ness[%]>=0,_R,_G,_B,_vignette_size[%]>=0,		_vignette_con-
       trast>=0,_defects_contrast>=0,0<=_defects_density<=100,_de-
       fects_size>=0,	    _defects_smoothness[%]>=0,_serial_number

	   Add a painting frame	to selected images.

	   Default   values:   'size=10%',   'contrast=0.4',  'profile_smooth-
       ness=6%', 'R=225', 'G=200',
	     'B=120',	'vignette_size=2%',   'vignette_contrast=400',	  'de-
       fects_contrast=50', 'defects_density=10',
	     'defects_size=1',	 'defects_smoothness=0.5%'   and  'serial_num-
       ber=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',	'shad-
       ing=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_direc-
       tion=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_an-
       tialiased=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_crite-
       rion=max(w,h)'.

	   Example:   [#1]   image.jpg	 repeat	 10  +resize2dx[-1]  75%  bal-
       ance_gamma[-1] ${-rgb} done pack	0

	 puzzle:
	     _width>0,_height>0,_M>=1,_N>=1,_curvature,_centering,_connec-
       tors_variability,_resolution>=1

	   Input puzzle	binary mask with specified size	and geometry.

	   Default values: 'width=height=512', 'M=N=5',	'curvature=0.5', 'cen-
       tering=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
       display_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',	 'bor-
       der_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=center-
       ing_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_density>=0,_nb_at-
       tempts>=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_den-
       sity=0.1' and 'nb_attempts=3'.

	   Example: [#1] image.jpg boxfitting ,

	 brushify:
	     [brush],_brush_nb_sizes>=1,0<=_brush_min_size_fac-
       tor<=1,_brush_nb_orientations>=1,_brush_light_type,
       0<=_brush_light_strength<=1,_brush_opacity,_painting_density[%]>=0,
       0<=_painting_contours_coherence<=1,0<=_painting_orientation_coher-
       ence<=1,		      _painting_coherence_alpha[%]>=0,_painting_coher-
       ence_sigma[%]>=0,_painting_primary_angle,       0<=_painting_angle_dis-
       persion<=1

	   Apply specified brush to create painterly versions of specified im-
       ages.
	   '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_opac-
       ity=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,_thick-
       ness>=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,_ex-
       pand_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-cir-
       cle },_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',	'opac-
       ity=0.1'	and 'votesize=100%'.

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

	 lightrays:
	     100<=_density<=0,_center_x[%],_cen-
       ter_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,_dark-
       ness,_light_smoothness,_xl,_yl,_zl,_zscale,			_opac-
       ity_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_opac-
       ity>=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_crite-
       rion=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_thick-
       ness>=0,_edge_antialiasing>=0,	     0<=_posterization_level<=15,_pos-
       terization_antialiasing>=0

	   Apply poster	edges effect on	selected images.

	   Default  values:  'edge_threshold=40', 'edge_shade=5', 'edge_thick-
       ness=0.5',
	     'edge_antialiasing=10', 'posterization_level=12' and  'posteriza-
       tion_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,_anisot-
       ropy>=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]
       overlay

	 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,_fi-
       delity_smoothness_finest>=0,		    _fidelity_smoothnes_coars-
       est>=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_repeti-
       tions>=0,_matching_precision>=0,				   _scale_fac-
       tor>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', 'fi-
       delity_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_synthe-
       sis=5',
	     'patchsize_synthesis_final=5', 'nb_matches_finest=2',  'nb_match-
       esc_coarsest=30',
	     'penalize_repetitions=10',	  'matching_precision=2',  'scale_fac-
       tor=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,_shad-
       ing>=0,_fibers_amplitude>=0,		    _fibers_smoothness>=0,_an-
       gle,-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',	'shad-
       ing=0.5', 'fibers_amplitude=0',
	      _'fibers_smoothness=0',	 'angle=0'   and   'curvature_x=curva-
       ture_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=pe-
       riodic |	3=mirror}

	   Apply flower	deformation on selected	images.

	   Default values: 'amplitude=30', 'frequency=6',  'offset_r=0',  'an-
       gle=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',  'an-
       gle=0' and 'offset=0'.

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

	 rotoidoscope:
	     _center_x[%],_center_y[%],_tiles>0,_smoothness[%]>=0,_bound-
       ary_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', 'cen-
       ter_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[%],_bound-
       ary_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=cen-
       ter_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 'bound-
       ary_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=cen-
       ter_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_condi-
       tions=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	  'em-
       boss_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	  'ra-
       dius_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', 'an-
       gle=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 | 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  'selec-
       tion_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:"	  "${arg{$>+1}},2,2,23,2,1,255
       done"   image.jpg  testimage2d  {w},{h}	ex  add,alpha,and,	 aver-
       age,blue,burn,darken
		    [#4]  command  "ex	:  $""=arg  repeat  $""#   +blend[0,1]
       ${arg{$>+1}} text_outline[-1] Mode:"	  "${arg{$>+1}},2,2,23,2,1,255
       done"   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:"	  "${arg{$>+1}},2,2,23,2,1,255
       done"  image.jpg	 testimage2d  {w},{h}  ex  green,hardlight,	 hard-
       mix,hue,interpolation,lighten,lightness
		    [#6]  command  "ex	:  $""=arg  repeat  $""#   +blend[0,1]
       ${arg{$>+1}} text_outline[-1] Mode:"	  "${arg{$>+1}},2,2,23,2,1,255
       done" image.jpg testimage2d {w},{h} ex linearburn,      linearlight,lu-
       minance,multiply,negation,or,overlay
		    [#7]   command  "ex	 :  $""=arg  repeat  $""#  +blend[0,1]
       ${arg{$>+1}} text_outline[-1] Mode:"	  "${arg{$>+1}},2,2,23,2,1,255
       done" image.jpg testimage2d {w},{h} ex pinlight,red,reflect,	 satu-
       ration,screen,shapeaverage,softburn
		    [#8]  command  "ex	:  $""=arg  repeat  $""#   +blend[0,1]
       ${arg{$>+1}} text_outline[-1] Mode:"	  "${arg{$>+1}},2,2,23,2,1,255
       done"   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_me-
       dian

	 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_fad-
       ing=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] dis-
       play_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 an-
       imate 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].

	   Default values: 'command=""',  'camera_index=0'  (default  camera),
       'skip_frames=0' and
	     'output_filename=""'.

	 apply_files:
	     "filename_pattern",_"command",_first_frame>=0,_last_frame={ >=0 |
       -1=last },_frame_step>=1,       _output_filename

	   Apply a G'MIC command on specified input image files, in a streamed
       way.
	   If  a display window	is opened, rendered frames are displayed in it
       during processing.
	   The output filename may have	extension '.avi' (saved	as  a  video),
       or any other usual image	file
	   extension (saved as a sequence of images).

	   Default     values:	   'command=(undefined)',     'first_frame=0',
       'last_frame=-1',	'frame_step=1' and
	     'output_filename=(undefined)'.

	 apply_video:
	     video_filename,_"command",_first_frame>=0,_last_frame={   >=0   |
       -1=last },_frame_step>=1,       _output_filename

	   Apply  a  G'MIC  command on all frames of the specified input video
       file, in	a streamed way.
	   If a	display	window is opened, rendered frames are displayed	in  it
       during processing.
	   The	output	filename may have extension '.avi' (saved as a video),
       or any other usual image
	   file	extension (saved as a sequence of images).

	   Default values:  'first_frame=0',  'last_frame=-1',	'frame_step=1'
       and
	     'output_filename=(undefined)'.

	 average_files:
	     "filename_pattern",_first_frame>=0,_last_frame={  >=0  |  -1=last
       },_frame_step>=1,_output_filename

	   Average specified input image files,	in a streamed way.
	   If a	display	window is opened, rendered frames are displayed	in  it
       during processing.
	   The	output	filename may have extension '.avi' (saved as a video),
       or any other usual image
	   file	extension (saved as a sequence of images).

	   Default values:  'first_frame=0',  'last_frame=-1',	'frame_step=1'
       and
	     'output_filename=(undefined)'.

	 average_video:
	     video_filename,_first_frame>=0,_last_frame={    >=0   |   -1=last
       },_frame_step>=1,_output_filename

	   Average frames of specified input video file, in a streamed way.
	   If a	display	window is opened, rendered frames are displayed	in  it
       during processing.
	   The	output	filename may have extension '.avi' (saved as a video),
       or any other usual image
	   file	extension (saved as a sequence of images).

	   Default values:  'first_frame=0',  'last_frame=-1',	'frame_step=1'
       and
	     'output_filename=(undefined)'.

	 fade_files:
	     "filename_pattern",_nb_in-
       ner_frames>0,_first_frame>=0,_last_frame={      >=0	|      -1=last
       },_frame_step>=1,       _output_filename

	   Generate  a	temporal fading	from specified input image files, in a
       streamed	way.
	   If a	display	window is opened, rendered frames are displayed	in  it
       during processing.
	   The output filename may have	extension 'avi'	(saved as a video), or
       any other usual image
	   file	extension (saved as a sequence of images).

	   Default     values:	   'nb_inner_frames=10',      'first_frame=0',
       'last_frame=-1',	'frame_step=1' and
	     'output_filename=(undefined)'.

	 fade_video:
	     video_filename,_nb_inner_frames>0,_first_frame>=0,_last_frame={
       >=0 | -1=last },_frame_step>=1,	     _output_filename

	   Create a temporal fading sequence from specified input video	 file,
       in a streamed way.
	   If  a display window	is opened, rendered frames are displayed in it
       during processing.

	   Default     values:	   'nb_inner_frames=10',      'first_frame=0',
       'last_frame=-1',	'frame_step=1' and
	     'output_filename=(undefined)'.

	 files2video:
	     "filename_pattern",_output_filename,_fps>0,_codec

	   Convert several files into a	single video file.

	   Default    values:	'output_filename=output.avi',	'fps=25'   and
       'codec=mp4v'.

	 median_files:
	     "filename_pattern",_first_frame>=0,_last_frame={  >=0  |  -1=last
       },_frame_step>=1,_frame_rows[%]>=1,	  _is_fast_approximation={ 0 |
       1 }

	   Compute the median frame of	specified  input  image	 files,	 in  a
       streamed	way.
	   If  a  display  window is opened, rendered frame is displayed in it
       during processing.

	   Default values: 'first_frame=0',  'last_frame=-1',  'frame_step=1',
       'frame_rows=20%'	and
	     'is_fast_approximation=0'.

	 median_video:
	     video_filename,_first_frame>=0,_last_frame={    >=0   |   -1=last
       },_frame_step>=1,_frame_rows[%]>=1,	 _is_fast_approximation={ 0  |
       1 }

	   Compute  the	 median	 of  all  frames  of an	input video file, in a
       streamed	way.
	   If a	display	window is opened, rendered frame is  displayed	in  it
       during processing.

	   Default  values:  'first_frame=0', 'last_frame=-1', 'frame_step=1',
       'frame_rows=100%' and
	     'is_fast_approximation=1'.

	 morph:
	     nb_inner_frames>=1,_smoothness>=0,_precision>=0

	   Create morphing sequence between selected images.

	   Default values: 'smoothness=0.1' and	'precision=4'.

	   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' (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',  'preci-
       sion=4',	'first_frame=0',
	     'last_frame=-1',	'frame_step=1'	 and   'output_filename=(unde-
       fined)'.

	 morph_rbf:
	     nb_in-
       ner_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,_preci-
       sion>=0,_first_frame>=0,_last_frame={	  >=0	  |	       -1=last
       },_frame_step>=1,_output_filename

	   Generate a temporal morphing	from specified input video file, in  a
       streamed	way.
	   If  a display window	is opened, rendered frames are displayed in it
       during processing.
	   The output filename may have	extension '.avi' (saved	as  a  video),
       or any other usual image
	   file	extension (saved as a sequence of images).

	   Default  values:  'nb_inner_frames=10',  'smoothness=0.1',  'preci-
       sion=4',	'first_frame=0',
	     'last_frame=-1',	'frame_step=1'	 and   'output_filename=(unde-
       fined)'.

	 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_non-
       rigid[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 tran-
       sition[0,1] [2],5

	 transition3d:
	     _nb_frames>=2,_nb_xtiles>0,_nb_ytiles>0,_axis_x,_axis_y,_axis_z,_is_an-
       tialias={ 0 | 1 }

	   Create 3D transition	sequence between selected consecutive images.
	   'axis_x',  'axis_y' and 'axis_z' can	be set as mathematical expres-
       sions, 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],_in-
       sert_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  im-
       ages.

	 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 im-
       age 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	under-
       score
	   (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.0-0./ 550-0./ End G'MIC	inter-
       preter.

	 file_mv:
	     filename_src,filename_dest

	   Rename or move a file from a	location $1 to another location	$2.

	 file_rand:

	   Return a random filename for	storing	temporary data.

	 file_rm:
	     filename

	   Delete a file.

	 filename:
	     filename,_number1,_number2,...,_numberN

	   Return a filename numbered with specified indices.

	 files (+):
	     _mode,path

	   Return the list of files and/or subfolders from specified path.
	   'path' can be eventually a matching pattern.
	   'mode'  can	be { 0=files only | 1=folders only | 2=files + folders
       }.
	   Add '3' to 'mode' to	return full paths instead of filenames only.

	   Default value: 'mode=5'.

	 fitratio_wh:
	     min_width,min_height,ratio_wh

	   Return  a   2D   size   'width,height'   which   is	 bigger	  than
       'min_width,min_height' and has the specified
	   w/h ratio.

	 fitscreen:
	     width,height,_depth,_minimal_size[%],_maximal_size[%] |
	     [image],_minimal_size[%],_maximal_size[%]

	   Return the 'ideal' size WxH for a window intended to	display	an im-
       age of specified	size on	screen.

	   Default   values:   'depth=1',   'minimal_size=128'	 and	'maxi-
       mal_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.

	 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	repre-
       sentations (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=high-
       est 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.

	 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 into a sequence of hexadecimal values.

	 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.

	 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.

	 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 with-
       out opening interactive windows.

	   Default value: 'colorspace=rgb'.

	 x_colorize:
	     _is_lineart={ 0 | 1 },_max_resolution={ 0 |  >=128	 },_multichan-
       nels_output={ 0 | 1 },_[palette1],	_[palette2],_[grabber1]

	   Colorized selected B&W images, using	an interactive window.
	   When	 >0, argument 'max_resolution' defines the maximal image reso-
       lution used in the interactive
	   window.

	   Default values: 'is_lineart=1', 'max_resolution=1024'  and  'multi-
       channels_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_toler-
       ance>=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',	'back-
       ground_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_col-
       umns=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_key-
       points_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

	 ## Plot a 3D elevated function	in random colors:

	   $ gmic 128,128,1,3,"u(0,255)" plasma	10,3 blur 4 sharpen 10000 ele-
       vation3d[-1]
	 "'X=(x-64)/6;Y=(y-64)/6;100*exp(-(X^2+Y^2)/30)*abs(cos(X)*sin(Y))'"

	 ## Plot the isosurface	of a 3D	volume:

	   $   gmic   mode3d   5   moded3d   5	 double3d    0	  isosurface3d
       "'x^2+y^2+abs(z)^abs(4*cos(x*y*z*3))'",3

	 ## Render a G'MIC 3D logo:

	   $  gmic 0 text G'MIC,0,0,53,1,1,1,1 expand_xy 10,0 blur 1 normalize
       0,100 +plasma 0.4 add blur 1
	 elevation3d -0.1 moded3d 4

	 ## Generate a 3D ring of torii:

	   $	 gmic	  repeat     20	    torus3d	 15,2	   color3d[-1]
       "{u(60,255)},{u(60,255)},{u(60,255)}" *3d[-1] 0.5,1 if
	 "{$>%2}"   rotate3d[-1]  0,1,0,90  fi	add3d[-1]  70  add3d  rotate3d
       0,0,1,18	done moded3d 3 mode3d 5
	 double3d 0

	 ## Create a vase from a 3D isosurface:

	   $ gmic moded3d 4 isosurface3d "'x^2+2*abs(y/2)*sin(2*y)^2+z^2-3',0"
       sphere3d	1.5 sub3d[-1] 0,5
	 plane3d  15,15	 rotate3d[-1]  1,0,0,90	 center3d[-1]  add3d[-1] 0,3.2
       color3d[-1] 180,150,255
	 color3d[-2] 128,255,0 color3d[-3] 255,128,0 add3d

	 ## Display filtered webcam stream:

	   $ gmic apply_camera

	 ## Launch a set of interactive	demos:

	   $ gmic demos

	 ** G'MIC comes	 with  ABSOLUTELY  NO  WARRANTY;  for  details	visit:
       https://gmic.eu **

								      G'MIC(1)

NAME | HELP

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=gmic&sektion=1&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help