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 3.1.6
	     (https://gmic.eu)

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

       1. Usage
	  -----

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

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

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

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

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

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

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

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

	*  There are no hard limitations on the size of the image along each di-
     mension.
	For instance, the number of image slices or channels can be of arbitrary
     size
	within the limits of the available memory.
	* The 'width', 'height' and 'depth' of an image are
	considered as spatial dimensions, while the 'spectrum' has a
	multi-spectral meaning. Thus, a 4D image in G'MIC should be  most  often
     regarded
	as  a  3D  dataset  of multi-spectral voxels. Most of the G'MIC commands
     will stick
	with this idea (e.g. command blur blurs images only along the spatial
	'xyz'-axes).
	* G'MIC stores all the image data as buffers of 'float' values (32 bits,
	value range '[-3.4E38,+3.4E38]'. It performs all its image processing
	operations with floating point numbers. Each image pixel takes then
	32bits/channel (except if double-precision  buffers  have  been  enabled
     during the
	compilation of the software, in which case 64bits/channel can be the de-
     fault).
	* Considering 'float'-valued pixels ensure to keep the numerical
	precision  when  executing  image  processing  pipelines.  For image in-
     put/output
	operations, you may want to prescribe the image datatype to be different
     than
	'float' (like 'bool', 'char', 'int', etc.). This is
	possible by specifying it as a file option when using I/O commands. (see
	section Input/Output Properties to learn more about file options).

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

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

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

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

	* Each G'MIC item is a string that is either a command, a list of
	command arguments, a filename or a special input string.
	* Escape characters '' and double quotes '"' can be used to define items
	containing  spaces  or	other  special characters. For instance, the two
     strings
	'single item' and '"single item"' both define the same single item,
	 with a space in it.

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

	* If a specified G'MIC item appears to be an existing filename, the
	corresponding image data are loaded and inserted at the end of the image
     list
	(which is equivalent to the use of 'input filename').
	* Special filenames '-' and '-.ext' stand for the standard
	input/output streams, optionally forced to be in a specific 'ext' file
	format (e.g. '-.jpg' or '-.png').
	* The following special input strings may be used as G'MIC items to cre-
     ate and
	insert new images with prescribed values, at the end of the image list:
	  -  '[selection]' or '[selection]xN': Insert 1 or N copies of
	already existing images. 'selection' may represent one or several images
	(see section Command Items and Selections to  learn  more  about  selec-
     tions).
	  -  'width[%],_height[%],_depth[%],_spectrum[%],_values[xN]': Insert
	one  or  N images with specified size and values (adding '%' to a dimen-
     sion
	means "percentage of the size along the same axis", taken from the last
	image '[-1]'). Any specified dimension can be also written as
	'[image]', and is then set to the size (along the same axis) of the
	existing specified image '[image]'. 'values' can be either a
	sequence of numbers separated by commas ',', or a  mathematical  expres-
     sion,
	 as e.g. in input item '256,256,1,3,[x,y,128]' which creates a
	'256x256' RGB color image with a spatial shading on the red and green
	channels. (see section Mathematical Expressions to learn more about
	mathematical expressions).
	  -  '(v1,v2,..)[xN]': Insert one or 'N' new images from specified
	prescribed values. Value separator inside parentheses can be ',' (column
	separator), ';' (row separator), '/' (slice separator) or '^'
	(channel separator). For instance, expression '(1,2,3;4,5,6;7,8,9)'
	creates a 3x3 matrix (scalar image), with values running from 1 to 9.
	  -  '('string'[:delimiter])[xN]': Insert one or N new images from
	specified string, by filling the images with the character codes compos-
     ing the
	string. When specified, 'delimiter' tells about the main orientation of
	the image. Delimiter can be 'x' (eq. to ',' which is the default),
	'y' (eq. to ';'), 'z' (eq. to '/') or 'c' (eq. to
	'^'). When specified delimiter is ',', ';', '/' or
	'^', the expression is actually equivalent to
	'({'string'[:delimiter]})[xN]' (see section Substitution Rules for
	more information on the syntax).
	  -  '0[xN]': Insert one or N new 'empty' images, containing no
	pixel data. Empty images are used only in rare occasions.

	* Input item 'name=value' declares a new variable 'name', or
	assign	a  new string value to an existing variable. Variable names must
     use the
	character set '[a-zA-Z0-9_]' and cannot start with a number.
	* A variable definition is always local to the	current  command  except
     when it
	starts by the underscore character '_'. In that case, it becomes also
	accessible  by	any  command  invoked  outside the current command scope
     (global
	variable).
	* If a variable name starts with two underscores '__', the global
	variable is also shared among different threads and can be  read/set  by
     commands
	running in parallel (see command parallel for this purpose). Otherwise,
	it remains local to the thread that defined it.
	* Numerical variables can be updated with the use of these special oper-
     ators:
	'+=' (addition), '-=' (subtraction), '*=' (multiplication),
	'/=' (division), '%=' (modulo), '&=' (bitwise and),
	'|=' (bitwise or), '^=' (power), '<<=' and '>>'
	(bitwise left and right shifts). For instance, 'foo=1' 'foo+=3'.
	* Input item 'name.=string' appends specified 'string' at the end
	of variable 'name'.
	* Input item 'name..=string' prepends specified 'string' at the
	beginning of variable 'name'.
	*  Multiple  variable  assignments and updates are allowed, with expres-
     sions:
	'name1,name2,...,nameN=value' or 'name1,name2,...,nameN=value1,value2,
	...,valueN' where assignment operator '=' can be replaced by one of
	the allowed operators (e.g. '+=').
	* Variables usually store numbers or strings. Use command store to
	assign variables from image data (and syntax 'input $variable' to bring
	them back on the image list afterwards).

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

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

	* Most of the existing commands in G'MIC are actually defined as custom
	commands.
	* A user can easily add its own custom commands to the G'MIC interpreter
     (see
	section  Adding Custom Commands for more details). New built-in commands
	cannot be added (unless you modify the G'MIC interpreter source code and
	recompile it).

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

	* G'MIC is able to read/write most of the classical image file formats,
	including:
	  -  2D grayscale/color files: '.png', '.jpeg', '.gif',
	'.pnm', '.tif', '.bmp', ...
	  -  3D volumetric files: '.dcm', '.hdr', '.nii',
	'.cube', '.pan', '.inr', '.pnk', ...
	  -  Video files: '.mpeg', '.avi', '.mp4', '.mov',
	'.ogg', '.flv', ...
	  -  Generic text or binary data files: '.gmz', '.cimg',
	'.cimgz', 'flo', 'ggr', 'gpl', '.dlm',
	'.asc', '.pfm', '.raw', '.txt', '.h'.
	  -  3D mesh files: '.off', '.obj'.

	* When dealing with color images, G'MIC generally reads, writes and dis-
     plays
	data using the usual sRGB color space.
	* When loading a '.png' and '.tiff' file, the bit-depth of the
	input image(s) is returned to the status.
	* G'MIC is able to manage 3D objects that may be read from files or
	generated by G'MIC commands. A 3D  object  is  stored  as  a  one-column
     scalar image
	containing  the  object  data,	in  the following order: { magic_number;
     sizes;
	vertices; primitives; colors; opacities }. These 3D representations  can
     be
	then processed as regular images (see command split3d for accessing each
	of these 3D object data separately).
	* Be aware that usual file formats may be sometimes not adapted to store
     all
	the  available	image data, since G'MIC uses float-valued image buffers.
     For
	instance, saving an image that was initially loaded as a  16bits/channel
     image,
	as a '.jpg' file will result in a loss of information. Use the
	G'MIC-specific	file  extension '.gmz' to ensure that all data precision
     is
	preserved when saving images.
	* Sometimes, file options may/must be set for file formats:
	  -  Video files: Only sub-frames of an image sequence may be loaded,
	using the input expression 'filename.ext,[first_frame[,last_frame[,
	step]]]'. Set 'last_frame==-1' to tell it must be the last frame of
	the video. Set 'step' to '0' to force an opened video file to be
	opened/closed. Output framerate and codec can be also set by  using  the
     output
	expression 'filename.avi,_fps,_codec,_keep_open' where 'keep_open'
	can be { 0 | 1 }. 'codec' is a 4-char string (see
	http://www.fourcc.org/codecs.php ) or '0' for the default codec.
	'keep_open' tells if the output video file must be kept open for
	appending new frames afterwards.
	  -  '.cimg[z]' files: Only crops and sub-images of .cimg files
	can be loaded, using the input expressions 'filename.cimg,N0,N1',
	'filename.cimg,N0,N1,x0,x1', 'filename.cimg,N0,N1,x0,y0,x1,y1',
	'filename.cimg,N0,N1,x0,y0,z0,x1,y1,z1' or 'filename.cimg,N0,N1,x0,y0,
	z0,c0,x1,y1,z1,c1'. Specifying '-1' for one coordinates stands for the
	maximum possible value. Output expression 'filename.cimg[z][,datatype]'
	can be used to force the output pixel type. 'datatype' can be { auto |
	bool | uint8 | int8 | uint16 | int16 | uint32 | int32 | uint64 | int64 |
	float32 | float64 }.
	  -  '.raw' binary files: Image dimensions and input pixel type
	may be specified when loading '.raw' files with input expression
	'filename.raw[,datatype][,width][,height[,depth[,dim[,offset]]]]]'.   If
     no
	dimensions are specified, the resulting image  is  a  one-column  vector
     with
	maximum  possible height. Pixel type can also be specified with the out-
     put
	expression 'filename.raw[,datatype]'. 'datatype' can be the same as
	for '.cimg[z]' files.
	  -  '.yuv' files: Image dimensions must be specified when loading,
	 and only sub-frames of an image sequence may be loaded, using the input
	expression 'filename.yuv,width,height[,chroma_subsampling[,first_frame[,
	last_frame[,step]]]'. 'chroma_subsampling' can be { 420 | 422 | 444
	}. When saving, chroma subsampling mode can be specified with output
	expression 'filename.yuv[,chroma_subsampling]'.
	  -  '.tiff' files: Only sub-images of multi-pages tiff files can
	be     loaded,	   using      the      input	  expression	  'file-
     name.tif,_first_frame,_last_frame,
	_step'. Output expression 'filename.tiff,_datatype,_compression,
	_force_multipage,_use_bigtiff'	can  be used to specify the output pixel
     type,
	as well as the compression method. 'datatype' can be the same as for
	'.cimg[z]' files. 'compression' can be	{ none (default) | lzw |
	jpeg }. 'force_multipage' can be { 0=no (default) | 1=yes }.
	'use_bigtiff' can be { 0=no | 1=yes (default) }.
	  -  '.pdf' files: When loading a file, the rendering resolution
	can be specified using the input expression 'filename.pdf,resolution',
	where 'resolution' is an unsigned integer value.
	  -  '.gif' files: Animated gif files can be saved, using the
	input expression 'filename.gif,fps>0,nb_loops'. Specify
	'nb_loops=0' to get an infinite number of animation loops (this is the
	default behavior).
	  -  '.jpeg' files: The output quality may be specified (in %),
	using the output expression 'filename.jpg,30' (here, to get a 30%  qual-
     ity
	output). '100' is the default.
	  -  '.mnc' files: The output header can set from another file,
	using the output expression 'filename.mnc,header_template.mnc'.
	  -  '.pan', '.cpp', '.hpp', '.c' and '.h'
	files: The output datatype can be selected with output expression
	'filename[,datatype]'. 'datatype' can be the same as for
	'.cimg[z]' files.
	  -  '.gmic' files: These filenames are assumed to be G'MIC custom
	commands  files. Loading such a file will add the commands it defines to
     the
	interpreter. Debug information can be enabled/disabled by the input  ex-
     pression
	'filename.gmic[,add_debug_info]' where 'debug_info' can be {
	0=false | 1=true }.
	  -  Inserting 'ext:' on the beginning of a filename (e.g.
	'jpg:filename')  forces  G'MIC	to  read/write the file as it would have
     been
	done if it had the specified extension '.ext'.

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

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

	* G'MIC items containing '$' or '{}' are substituted before
	being interpreted. Use these substituting expressions to access  various
     data
	from the interpreter environment.
	* '$name' and '${name}' are both substituted by the value of the
	specified named variable (set previously by the item 'name=value'). If
	this variable has not been already set, the expression is substituted by
     the
	highest positive index of the named image '[name]'. If no image has this
	name,  the  expression is substituted by the value of the OS environment
     variable
	with same name (it may be thus an empty string if it is not defined).
	* The following reserved variables are predefined by  the  G'MIC  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.
	  -  '$_flags': The list of enabled flags when G'MIC interpreter has
	been compiled.
	  -  '$_host': A string telling about the host running the G'MIC
	interpreter (e.g. 'cli' or 'gimp').
	  -  '$_os': A string describing the running operating system.
	  -  '$_path_rc': The path to the G'MIC folder used to store
	configuration files (its value is OS-dependent).
	  -  '$_path_user': The path to the G'MIC user file '.gmic' or
	'user.gmic' (its value is OS-dependent).
	  -  '$_path_commands': A list of all imported command files (stored as
	an image list).
	  -  '$_pid': The current process identifier, as an integer.
	  -  '$_pixeltype': The type of image pixels (default: 'float32').
	  -  '$_prerelease': For pre-releases, the date of the pre-release as
	'yymmdd'. For stable releases, this variable is set to '0'.
	  -  '$_version': A 3-digits number telling about the current version of
	the G'MIC interpreter  (e.g. '316').
	  -  '$_vt100': Set to '1' if colored text output is allowed on
	the console. Otherwise, set to '0'.

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

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

	* Item substitution is never performed in items between double quotes.
	One  must break the quotes to enable substitution if needed, as in '"3+8
     kg =
	"{3+8}" kg"'. Using double quotes is then a convenient	way  to  disable
     the
	substitutions mechanism in items, when necessary.
	*  One can also disable the substitution mechanism on items outside dou-
     ble
	quotes, by escaping the '{', '}' or '$' characters, as in
	'3+4 doesn't evaluate'.

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

	* G'MIC has an embedded mathematical parser, used to evaluate
	(possibly complex) math expressions specified inside braces '{}', or
	formulas in commands that may take one as an argument (e.g. fill or
	eval).
	* When the context allows it, a formula is evaluated for each pixel of
	the selected images (e.g. fill or eval).
	* A math expression may return a scalar or a vector-valued result
	(with a fixed number of components).
       The mathematical parser understands the following set of functions, oper-
     ators
	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()',
	'deg2rad()', 'erf()', 'erfinv()', 'exp()',
	'fact()', 'fibo()', 'floor()', 'gauss()', 'gcd()',
	 'int()', 'isnan()', 'isnum()', 'isinf()',
	'isint()', 'isbool()', 'isexpr()', 'isfile()',
	'isdir()', 'isin()', 'kth()', 'log()', 'log2()',
	'log10()', 'max()', 'maxabs()', 'med()', 'min()',
	'minabs()', 'narg()', 'prod()', 'rad2deg()',
	'rol()' (left bit rotation), 'ror()' (right bit rotation),
	'round()', 'sign()', 'sin()', 'sinc()', 'sinh()',
	'sqrt()', 'std()', 'srand(_seed)', 'sum()',
	'tan()', 'tanh()', 'var()', 'xor()'.

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

       ## 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', 'id', 'is',
	'ip', 'ic', 'in': Respectively the minimum, maximum, average,
	variance, standard deviation, sum, product, median value and L2-norm  of
     the
	associated image, if any ('0' otherwise).
	* 'xm', 'ym', 'zm', 'cm': The pixel coordinates of the
	minimum value in the associated image, if any ('0' otherwise).
	* 'xM', 'yM', 'zM', 'cM': The pixel coordinates of the
	maximum value in the associated image, if any ('0' otherwise).
	* All these variables are considered as constant values by the math
	parser	(for optimization purposes) which is indeed the case most of the
     time.
	Anyway, this might not be the case,  if  function  'resize(#ind,..)'  is
     used
	in the math expression. If so, it is safer to invoke functions 'l()',
	'w(_#ind)', 'h(_#ind)', ... 's(_#ind)' and 'in(_#ind)'
	instead of the corresponding named variables.
	* 'i': current processed pixel value (i.e. value located at '(x,y,z,
	c)') in the associated image, if any ('0' otherwise).
	* 'iN': N-th channel value of current processed pixel (i.e. value
	located at '(x,y,z,N)' in the associated image, if any ('0'
	otherwise). 'N' must be an integer in range '[0,9]'.
	* 'R', 'G', 'B' and 'A' are equivalent to 'i0',
	'i1', 'i2' and 'i3' respectively.
	* 'I': current vector-valued processed pixel in the associated image, if
	any ('0' otherwise). The number of vector components is equal to the
	number of image channels (e.g. 'I' = '[ R,G,B ]' for a 'RGB'
	image).
	* You may add '#ind' to any of the variable name above to retrieve the
	information for any numbered image '[ind]' of the list (when this makes
	sense). For instance 'ia#0' denotes the average value of the first image
	of the list).
	* 'x': current processed column of the associated image, if any
	('0' otherwise).
	* 'y': current processed row of the associated image, if any ('0'
	otherwise).
	* 'z': current processed slice of the associated image, if any
	('0' otherwise).
	* 'c': current processed channel of the associated image, if any
	('0' otherwise).
	* 't': thread id when an expression is evaluated with multiple threads
	('0' means master thread).
	* 'n': maximum number of threads when expression is evaluated in
	parallel (so that 't' goes from '0' to 'n-1').
	* 'e': value of e, i.e. '2.71828...'.
	* 'pi': value of pi, i.e. '3.1415926...'.
	* 'u': a random value between '[0,1]', following a uniform
	distribution.
	* 'g': a random value, following a gaussian distribution of variance 1
	(roughly in '[-6,6]').
	* 'interpolation': value of the default interpolation mode used when
	reading pixel values with the pixel access operators (i.e. when the
	interpolation  argument  is not explicitly specified, see below for more
     details
	on pixel access operators). Its initial default value is '0'.
	* 'boundary': value of the default boundary conditions used when reading
	pixel values with the pixel access operators  (i.e.  when  the	boundary
     condition
	argument  is  not  explicitly  specified,  see below for more details on
     pixel
	access operators). Its initial default value is '0'.
	* The last image of the list is always associated to the evaluations of
	'expressions', e.g. G'MIC sequence

	 256,128 fill {w}

	will create a 256x128 image filled with value 256.

       ## Vector calculus:

       Most operators are also able to work with vector-valued elements.
	* '[a0,a1,...,aN-1]' defines a 'N'-dimensional vector with scalar
	coefficients 'ak'.
	* 'vectorN(a0,a1,,...,aN-1)' does the same, with the 'ak' being
	repeated periodically if only a few are specified.
	* 'vector(#N,a0,a1,,...,aN-1)' does the same, and can be used for any
	constant expression 'N'.
	* In previous expressions, the 'ak' can be vectors themselves, to be
	concatenated into a single vector.
	* The scalar element 'ak' of a vector 'X' is retrieved by
	'X[k]'.
	* The sub-vector '[X[p],X[p+s]...X[p+s*(q-1)]]' (of size 'q') of a
	vector 'X' is retrieved by 'X[p,q,s]'.
	* 'expr(formula,_w,_h,_d,_s)' outputs a vector of size 'w*h*d*s'
	with values generated from the specified formula, as if one were filling
     an
	image with dimensions '(w,h,d,s)'.
	* Equality/inequality comparisons between two vectors is done with oper-
     ators
	'==' 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 calculated.
	* Function 'resize(A,size,_interpolation,_boundary_conditions)' returns
	a resized version of a vector 'A' with specified interpolation mode.
	'interpolation' can be { -1=none (memory content) | 0=none | 1=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 'resize(A,ow,oh,od,os,nw,_nh,_nd,_ns,_interpolation,
	_boundary_conditions,_ax,_ay,_az,_ac)' is an extended version of the
	previous function. It allows to resize the vector 'A', seen as an image
	of size 'ow x oh x od x os' as a new image of size 'nw x nh x nd x  ns',
     with
	specified resizing options.
	* Function 'find(A,B,_starting_index,_search_step)' returns the index
	where sub-vector 'B' appears in vector 'A', (or '-1' if
	'B' is not contained in 'A'). Argument 'A' can be also
	replaced by an image index '#ind'.
	* A '2'-dimensional vector may be seen as a complex number and used in
	those particular functions/operators: '**' (complex multiplication),
	'//' (complex division), '^^' (complex exponentiation), '**='
	(complex self-multiplication), '//=' (complex self-division), '^^='
	(complex self-exponentiation), 'cabs()' (complex modulus), 'carg()'
	(complex argument), 'cconj()' (complex conjugate), 'cexp()'
	(complex exponential), 'clog()' (complex logarithm),  'ccos()'
	(complex cosine), 'csin()' (complex sine), 'ctan()' (complex
	tangent), 'ccosh()' (complex hyperpolic cosine), 'csinh()' (complex
	hyperbolic sine) and 'ctanh()' (complex hyperbolic tangent).
	* A 'MN'-dimensional vector may be seen as a 'M' x 'N'
	matrix and used in those particular functions/operators: '*'
	(matrix-vector multiplication), 'det(A)' (determinant), 'diag(V)'
	(diagonal matrix from a vector), 'eig(A)' (eigenvalues/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
	'transpose(A,nb_colsA)' (matrix transpose). Argument 'nb_colsB' may
	be omitted if it is equal to '1'.
	* 'mproj(S,nb_colsS,D,nb_colsD,method,max_iter,max_residual)' projects a
	matrix 'S' onto a dictionary (matrix) 'D'. Equivalent to command
	mproj but inside the math evaluator.
	* Specifying a vector-valued math expression as an argument of a command
     that
	operates on image values (e.g. 'fill') modifies the whole spectrum range
	of the processed image(s), for each spatial coordinates '(x,y,z)'. The
	command does not loop over the 'c'-axis in this case.

       ## String manipulation:

       Character strings are defined and managed as vectors objects. Dedicated
	functions and initializers to manage strings are:
	* '['string']' and ''string'' define a vector whose values are the
	character codes of the specified 'character string' (e.g. ''foo''
	is equal to '[ 102,111,111 ]').
	* '_'character'' returns the (scalar) byte code of the specified
	character (e.g. '_'A'' is equal to '65').
	* A special case happens for empty strings: Values of both expressions
	'['']' and '''' are '0'.
	* Functions 'lowercase()' and 'uppercase()' return string with all
	string characters lowercased or uppercased.
	* Function 'stov(str,_starting_index,_is_strict)' parses specified
	string 'str' and returns the value contained in it.
	* Function 'vtos(expr,_nb_digits,_siz)' returns a vector of size
	'siz' which contains the character representation of values described by
	expression 'expr'. 'nb_digits' can be { -1=auto-reduced | 0=all
	| >0=max number of digits }.
	* Function 'echo(str1,str2,...,strN)' prints the concatenation of given
	string arguments on the console.
	* Function 'string(_#siz,str1,str2,...,strN)' generates a vector
	corresponding to the concatenation of given string/number arguments.

       ## Dynamic arrays:

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

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

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

       ## Special operators:

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

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

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

       ## Specific functions:

	* 'addr(expr)': return the pointer address to the specified expression
	'expr'.
	* 'fill(target,expr)' or 'fill(target,index_name,expr)' fill the
	content  of the specified target (often vector-valued) using a given ex-
     pression,
	e.g. 'V = vector16(); fill(V,k,k^2 + k + 1);'. For a vector-valued  tar-
     get,
	 it is basically equivalent to: 'for (index_name = 0,
	index_name<size(target), ++index_name, target[index_name] = expr);'.
	* 'u(max)' or 'u(min,max)': 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  pre-
     cision.
	* 'i(_a,_b,_c,_d,_interpolation_type,_boundary_conditions)': return the
	value of the pixel located at position '(a,b,c,d)' in the associated
	image, if any ('0' otherwise). 'interpolation_type' can be {
	0=nearest neighbor | 1=linear | 2=cubic }. 'boundary_conditions' can
	be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }. Omitted
	coordinates are replaced by their default values which are respectively
	'x', 'y', 'z', 'c', 'interpolation' and
	'boundary'. For instance command

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

	will  estimate the X-derivative of an image with a classical finite dif-
     ference
	scheme.
	* 'j(_dx,_dy,_dz,_dc,_interpolation_type,_boundary_conditions)' does the
	same for the pixel located at position '(x+dx,y+dy,z+dz,c+dc)' (pixel
	access relative to the current coordinates).
	* 'i[offset,_boundary_conditions]' returns the value of the pixel
	located at specified 'offset' in the associated image buffer (or
	'0' if offset is out-of-bounds).
	* 'j[offset,_boundary_conditions]' does the same for an offset relative
	to the current pixel coordinates '(x,y,z,c)'.
	* 'i(#ind,_x,_y,_z,_c,_interpolation,_boundary_conditions)', 'j(#ind,
	_dx,_dy,_dz,_dc,_interpolation,_boundary_conditions)', 'i[#ind,offset,
	_boundary_conditions]' and 'i[offset,_boundary_conditions]' are
	similar expressions used to access pixel values for any numbered image
	'[ind]' of the list.
	* 'I/J[_#ind,offset,_boundary_conditions]' and 'I/J(_#ind,_x,_y,_z,
	_interpolation,_boundary_conditions)' do the same as 'i/j[_#ind,offset,
	_boundary_conditions]' and 'i/j(_#ind,_x,_y,_z,_c,_interpolation,
	_boundary_conditions)' but return a vector instead of a scalar (e.g. a
	vector '[ R,G,B ]' for a pixel at '(a,b,c)' in a color image).
	* 'crop(_#ind,_x,_y,_z,_c,_dx,_dy,_dz,_dc,_boundary_conditions)' returns
	a vector whose values come from the cropped region of image '[ind]' (or
	from default image selected if 'ind' is not specified). Cropped region
	starts from point '(x,y,z,c)' and has a size of 'dx x dy x dz x
	dc'. Arguments for coordinates and sizes can be omitted if they are not
	ambiguous (e.g. 'crop(#ind,x,y,dx,dy)' is a valid invocation of this
	function).
	* 'draw(_#ind,S,x,y,z,c,dx,_dy,_dz,_dc,_opacity,_M,_max_M)' draws a
	sprite 'S' in image '[ind]' (or in default image selected if
	'ind' is not specified) at coordinates '(x,y,z,c)'. The size of the
	sprite 'dx x dy x dz x dc' must be specified. You can also specify a
	corresponding opacity mask 'M' if its size matches 'S'.
	* 'polygon(_#ind,nb_vertices,coords,_opacity,_color)' draws a filled
	polygon in image '[ind]' (or in default image selected if 'ind' is
	not specified) at specified coordinates. It draws a single line if
	'nb_vertices' is set to 2.
	* 'polygon(_#ind,-nb_vertices,coords,_opacity,_pattern,_color)' draws a
	outlined polygon in image '[ind]' (or in default image selected if
	'ind' is not specified) at specified coordinates and with specified line
	pattern. It draws a single line if 'nb_vertices' is set to 2.
	* 'ellipse(_#ind,xc,yc,radius1,_radius2,_angle,_opacity,_color)' draws a
	filled ellipse in image '[ind]' (or in default image selected if
	'ind' is not specified) with specified coordinates.
	* 'ellipse(_#ind,xc,yc,-radius1,-_radius2,_angle,_opacity,_pattern,
	_color)' draws an outlined ellipse in image '[ind]' (or in default
	image selected if 'ind' is not specified).
	* 'resize(#ind,w,_h,_d,_s,_interp,_boundary_conditions,_cx,_cy,_cz,_cc)'
	resizes an image of the associated list with specified dimension and
	interpolation method. When using this function, you should consider  re-
     trieving
	the (non-constant) image dimensions using the dynamic functions
	'w(_#ind)', 'h(_#ind)', 'd(_#ind)', 's(_#ind)',
	'wh(_#ind)', 'whd(_#ind)' and 'whds(_#ind)' instead of the
	corresponding constant variables.
	* 'if(condition,expr_then,_expr_else)': return value of
	'expr_then' or 'expr_else', depending on the value of
	'condition' { 0=false | other=true }. 'expr_else' can be
	omitted in which case '0' is returned if the condition does not hold.
	Using the ternary operator 'condition?expr_then[:expr_else]' gives an
	equivalent expression. For instance, G'MIC commands

	 fill if(x%10==0,255,i)

	and

	 fill x%10?i:255

	both draw blank vertical lines on every 10th column of an image.
	* 'do(expression,_condition)' repeats the evaluation of
	'expression' until 'condition' vanishes (or until
	'expression' vanishes if no 'condition' is specified). For instance,
	 the expression:

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

	returns the N-th value of the Fibonacci sequence, for 'N>=0' (e.g.,
	'46368' for 'N=24'). 'do(expression,condition)' always
	evaluates  the	specified  expression  at least once, then check for the
     loop
	condition. When done, it returns the last value of 'expression'.
	* 'for(init,condition,_procedure,body)' first evaluates the expression
	'init', then iteratively evaluates 'body' (followed by
	'procedure' if specified) while 'condition' holds (i.e. not zero).
	It may happen that no iterations are done, in which  case  the	function
     returns
	'nan'. Otherwise, it returns the last value of 'body'. For instance,
	 the expression:

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

	returns the 'N'-th value of the Fibonacci sequence, for 'N>=0'
	(e.g., '46368' for 'N=24').
	* 'while(condition,expression)' is exactly the same as 'for(init,
	condition,expression)' without the specification of an initializing
	expression.
	* 'repeat(nb_iters,expr)' or 'fill(nb_iters,iter_name,expr)' run
	'nb_iters' iterations of the specified expression 'expr', e.g.
	'V = vector16(); repeat(16,k,V[k] = k^2 + k + 1);'. It is basically
	equivalent to: 'for (iter_name = 0, iter_name<nb_iters, ++iter_name,
	expr);'.
	* 'break()' and 'continue()' respectively breaks and continues the
	current running block (loop, init or main environment).
	* 'fsize('filename')' returns the size of the specified 'filename'
	(or '-1' if file does not exist).
	* 'date(attr,'path')' returns the date attribute for the given
	'path' (file or directory), with 'attr' being { 0=year | 1=month
	| 2=day | 3=day of week | 4=hour | 5=minute | 6=second }, or a vector of
	those values.
	* 'date(_attr)' returns the specified attribute for the current (locale)
	date  (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 re-
     turns
	the value of the last expression (or 'nan' in case of an  image).  Func-
     tion
	'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 re-
     turns its
	value).
	* 'display(_X,_w,_h,_d,_s)' or 'display(#ind)' display the
	contents of the vector 'X'  (or  specified  image)  and  wait  for  user
     events.
	if no arguments are provided, a memory snapshot of the math parser envi-
     ronment
	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  re-
     quired
	(e.g. in 'fill ">begin(foo = 0); ++foo"').
	* 'copy(dest,src,_nb_elts,_inc_d,_inc_s,_opacity)' copies an entire
	memory block of 'nb_elts' elements starting from a source value
	'src' to a specified destination 'dest', with increments defined by
	'inc_d' and 'inc_s' respectively for the destination and source
	pointers.
	* 'stats(_#ind)' returns the statistics vector of the running image
	'[ind]', i.e the vector '[ im,iM,ia,iv,xm,ym,zm,cm,xM,yM,zM,cM,is,ip
	]' (14 values).
	* 'ref(expr,a)' references specified expression 'expr' as variable
	name 'a'.
	* 'unref(a,b,...)' destroys references to the named variable given as
	arguments.
	* 'breakpoint()' inserts a possible computation breakpoint (useless with
	the cli interface).
	* '_(comment) expr' just returns expression 'expr' (useful for inserting
	inline comments in math expressions).
	* 'run('pipeline')' executes the specified G'MIC pipeline as if it was
	called outside the currently evaluated expression.
	* 'set('variable_name',A)' set the G'MIC variable '$variable_name'
	with the value of expression 'A'. If 'A' is a vector-valued
	variable, it is assumed to encode a string.
	* 'store('variable_name',A,_w,_h,_d,_s,_is_compressed)' transfers the
	data of vector 'A' as a 'w x h x d x s' image to the G'MIC variable
	'$variable_name'. Thus, the data becomes available outside the math
	expression (that is equivalent to using the regular command store, but
	directly in the math expression).
	* 'get('variable_name',_size,_return_as_string)' returns the value of
	the specified variable, as a vector of 'size' values, or as a scalar (if
	'size' is zero or not specified).
	* 'name(_#ind,size)' returns a vector of size 'size', whose values
	are the characters codes of the name of image '[ind]' (or default image
	selected if 'ind' is not specified).
	* 'correlate(I,wI,hI,dI,sI,K,wK,hK,dK,sK,_boundary_conditions,
	_is_normalized,_channel_mode,_xcenter,_ycenter,_zcenter,_xstart,_ys-
     tart,_zstart,
	_xend,_yend,_zend,_xstride,_ystride,_zstride,_xdilation,_ydilation,_zdi-
     lation,
	_interpolation_type)'  returns the correlation, unrolled as a vector, of
     the
	'wI x hI x dI x sI'-sized image 'I' with the 'wK x hK x dK x
	sK'-sized kernel 'K' (the meaning of the other arguments are the same
	as in command 'correlate'). Similar function 'convolve(...)' is
	also defined for computing the convolution between 'I' and 'K'.

       ## User-defined macros:

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

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

	* Trying to override a built-in function (e.g. 'abs()') has no effect.
	* Overloading macros with different number of arguments is possible.
	Re-defining a previously defined macro with the same number of 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  them-
     selves
	results of assignments or self-operations. For instance,

	 foo(x) = x + x; z = 0; foo(++z)

	returns '4' rather than expected value '2'.
	*  When  substituted, macro arguments are placed inside parentheses, ex-
     cept if a
	number sign '#' is located just before or after the argument name. For
	instance, expression

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

	returns '9' (being substituted as '(1+2)*(3)'), while expression

	 foo(x,y) = x#*y#; foo(1+2,3)

	returns '7' (being substituted as '1+2*3').
	* Number signs appearing between macro arguments function actually count
     for
	empty separators. They may be used to force the substitution of macro
	arguments in unusual places, e.g. as in

	 str(N) = ['I like N#'];

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

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

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

       ## Multi-threaded and in-place evaluation:

	*  If  your image data are large enough and you have several CPUs avail-
     able, it
	is likely that the math expression passed to a 'fill', 'eval' or
	'input' commands is evaluated in parallel, using multiple computation
	threads.
	* Starting an expression with ':' or '*' forces the evaluations
	required for an image to be run in parallel, even if the amount of  data
     to
	process  is  small (beware, it may be slower to evaluate in this case!).
     Specify
	':' (rather than '*') to avoid possible image copy done before
	evaluating the expression (this saves memory, but do this  only  if  you
     are sure
	this step is not required!)
	* If the specified expression starts with '>' or '<', the pixel
	access operators 'i()', 'i[]', 'j()' and 'j[]' return
	values of the image being currently modified, in forward ('>') or
	backward  ('<')  order. The multi-threading evaluation of the expression
     is
	disabled in this case.
	* Function 'critical(expr)' forces the execution of the given expression
	in a single thread at a time.
	* 'begin_t(expr)' and 'end_t(expr)' evaluates the specified
	expression once for each running thread (so possibly several  times)  at
     the
	beginning and the end of the evaluation procedure.
	* 'merge(variable,operator)' tells to merge the local variable value
	computed by threads, with the specified operator, when all threads have
	finished computing.
	* Expressions 'i(_#ind,x,_y,_z,_c)=value', 'j(_#ind,x,_y,_z,
	_c)=value', 'i[_#ind,offset]=value' and 'j[_#ind,offset]=value'
	set  a	pixel  value at a different location than the running one in the
     image
	'[ind]' (or in the associated image if argument '#ind' is omitted),
	either with global coordinates/offsets (with 'i(...)' and 'i[...]'),
	 or relatively to the current position '(x,y,z,c)' (with 'j(...)'
	and 'j[...]'). These expressions always return 'value'.

       10. Image and Data Viewers
	   ----------------------

	* G'MIC has some very handy embedded visualization modules, for 1D
	signals (command plot), 1D/2D/3D images (command display) and 3D
	vector objects (command display3d). It manages interactive views of the
	selected image data.
	* The following actions are available in the interactive viewers:
	  -  '(mousewheel)': Zoom in/out.
	  -  'ESC': Close window.
	  -  'CTRL+D': Increase window size.
	  -  'CTRL+C': Decrease window size.
	  -  'CTRL+R': Reset window size.
	  -  'CTRL+F': Toggle fullscreen mode.
	  -  'CTRL+S': Save current view as a numbered file
	'gmic_xxxx.ext'.
	  -  'CTRL+O': Save copy of the viewed data, as a numbered file
	'gmic_xxxx.ext'.

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

	* Actions specific to the 3D volumetric image viewer (command
	display) are:
	  -  'CTRL+P': Play z-stack of frames as a movie.
	  -  'CTRL+V': Show/hide 3D view on bottom right zone.
	  -  'CTRL+X': Show/hide axes.
	  -  'CTRL+(mousewheel)': Go up/down.
	  -  'SHIFT+(mousewheel)': Go left/right.
	  -  'Numeric PAD': Zoom in/out ('+'/'-') and move through
	zoomed image (digits).
	  -  'BACKSPACE': Reset zoom scale.

	* Actions specific to the 3D object viewer (command display3d) are:
	  -  '(mouse)+(left mouse button)': Rotate 3D object.
	  -  '(mouse)+(right mouse button)': Zoom 3D object.
	  -  '(mouse)+(middle mouse button)': Shift 3D object.
	  -  'F1 ... F6': Toggle between different 3D rendering modes.
	  -  'F7/F8': Decrease/increase focale.
	  -  'F9': Select animation mode.
	  -  'F10': Select animation speed.
	  -  'SPACE': Start/stop animation.
	  -  'CTRL+A': Show/hide 3D axes.
	  -  'CTRL+B': Switch between available background.
	  -  'CTRL+G': Save 3D object, as numbered file 'gmic_xxxx.obj'.
	  -  'CTRL+L': Show/hide outline.
	  -  'CTRL+P': Print current 3D pose on stderr.
	  -  'CTRL+T': Switch between single/double-sided 3D modes.
	  -  'CTRL+V': Start animation with video output.
	  -  'CTRL+X': Show/hide 3D bounding box.
	  -  'CTRL+Z': Enable/disable z-buffered rendering.

       11. Adding Custom Commands
	   ----------------------

	* New custom commands can be added by the user, through the use of G'MIC
	custom commands files.
	* A command file is a simple text file, where each line starts either by

	 command_name: command_definition

	or

	 command_definition (continuation)

	* At startup, G'MIC automatically includes user's command file
	'$HOME/.gmic' (on Unix) or '%APPDATA%/user.gmic' (on
	Windows). The CLI tool 'gmic' automatically runs the command
	'cli_start' if defined.
	* Custom command names must use character set '[a-zA-Z0-9_]' and cannot
	start with a number.
	* Any '# comment' expression found in a custom commands file is
	discarded by the G'MIC parser, wherever it is located in a line.
	* In a custom command, the following '$-expressions' are recognized and
	substituted:
	  -  '$*' is substituted by a copy of the specified string of arguments.
	  -  '$"*"' is substituted by a copy of the specified string of
	arguments, each being double-quoted.
	  -  '$#' is substituted by the maximum index of known arguments (either
	specified by the user or set to a default value in the custom command).
	  -  '$[]' is substituted by the list of selected image indices that
	have been specified in the command invocation.
	  -  '$?' is substituted by a printable version of '$[]' to be
	used in command descriptions.
	  -  '$i' and '${i}' are both substituted by the 'i'-th
	specified argument. Negative indices such as '${-j}' are allowed and
	refer to the 'j'-th latest argument. '$0' is substituted by the
	custom command name.
	  -  '${i=default}' is substituted by the value of '$i' (if
	defined) or by its new value set to 'default' otherwise ('default'
	may be a '$-expression' as well).
	  -  '${subset}' is substituted by the argument values (separated by
	commas ',') of a specified argument subset. For instance expression
	'${2--2}' is substituted by all specified command arguments except the
	first and the last one. Expression '${^0}' is then substituted by all
	arguments of the invoked command (eq. to '$*' if all arguments have been
	indeed specified).
	  -  '$=var' is substituted by the set of instructions that will assign
	each argument '$i' to the named variable 'var$i' (for i in
	'[0...$#]'. This is particularly useful when a custom command want to
	manage variable numbers of arguments. Variables names must use character
     set
	'[a-zA-Z0-9_]' and cannot start with a number.

	* These particular '$-expressions' for custom commands are always
	substituted, even in double-quoted items or when the dollar sign '$'
	is escaped with a backslash '$'. To avoid substitution, place an empty
	double quoted string just after the '$' (as in '$""1').
	* Specifying arguments may be skipped when invoking a custom command, by
	replacing them by commas ',' as in expression

	 flower ,,3

	Omitted arguments are set to their default values, which must be thus
	explicitly defined in the code of the corresponding custom command  (us-
     ing
	default argument expressions as '${1=default}').
	*  If one numbered argument required by a custom command misses a value,
     an
	error is thrown by the G'MIC interpreter.
	* It is possible to specialize the invocation of a '+command' by
	defining it as

	 +command_name: command_definition

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

       12. List of Commands
	   ----------------

       All available G'MIC commands are listed below, by categories. An argument
	specified between '[]' or starting by '_' is optional except when
	standing for an existing image '[image]', where 'image' can be
	either an index number or an image name. In this case, the '[]'
	characters  are  mandatory  when  writing the item. Note that all images
     that serve
	as illustrations in this reference documentation are normalized in range
     '[0,
	255]' before being displayed. You may need to do this  explicitly  (com-
     mand
	'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 outputs
     additional log
	 messages about its internal state on the standard output (stdout).
	 This option is useful for developers or to report possible bugs of  the
     interpreter.

       h:
	   Shortcut for command 'help'.

       help:
	   command |
	   (no arg)

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

       version:

	 Display current version number on stdout.

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

       camera (+):
	   _camera_index>=0,_nb_frames>0,_skip_frames>=0,_capture_width>=0,_cap-
     ture_height>=0

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

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

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

	 Insert one of the 958 pre-defined CLUTs at the end of the image list.

	 'clut_name'  can be { 2-strip-process | 60s | 60s_faded | 60s_faded_alt
     |	7drk_21  |  action_magenta_01  |  action_red_01   |   adventure_1453   |
     agfa_apx_100 | agfa_apx_25 | agfa_precisa_100 |
	  agfa_ultra_color_100	|  agfa_vista_200 | agressive_highligjtes_recov-
     ery_5 | alberto_street | alien_green |  amstragram  |  amstragram+  |  ana-
     log_film_1 | analogfx_anno_1870_color | analogfx_old_style_i |
	  analogfx_old_style_ii  | analogfx_old_style_iii | analogfx_sepia_color
     |	analogfx_soft_sepia_i  |  analogfx_soft_sepia_ii  |   anime   |   apoca-
     lypse_this_very_moment | aqua | aqua_and_orange_dark | arabica_12 |
	  atomic_pink  |  autumn  |  ava_614 | avalanche | azrael_93 | bboyz_2 |
     bc_darkum	|  beach_aqua_orange  |  beach_faded_analog   |   berlin_sky   |
     black_and_white | black_star | black_white_01 | black_white_02 |
	  black_white_03  |  black_white_04  | black_white_05 | black_white_06 |
     blade_runner | bleach_bypass | bleachbypass_1 | bleachbypass_2 |  bleachby-
     pass_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 | brown_mobster | brownbm | brownish | bw_1 | bw_10 | bw_2
     | bw_3 | bw_4 | bw_5 | bw_6 | bw_7 | bw_8 | bw_9 | bw_but_yellow | byers_11
     | candlelight | caribe | chemical_168 | chrome_01 |
	  cineblue  | cinebm_4k | cinema | cinema_2 | cinema_3 | cinema_4 | cin-
     ema_5 | cinema_noir | cinematic-1 |  cinematic-10	|  cinematic-2	|  cine-
     matic-3 | cinematic-4 | cinematic-5 | cinematic-6 | cinematic-7 |
	  cinematic-8 | cinematic-9 | cinematic_01 | cinematic_02 | cinematic_03
     |	cinematic_for_flog  |  cinematic_forest  |  cinematic_lady_bird  | cine-
     matic_mexico | city | city_7 | city_dust | classic_films_01 |
	  classic_films_02  |  classic_films_03  |  classic_films_04   |   clas-
     sic_films_05  |  classic_teal_and_orange  |  clayton_33 | clear_teal_fade |
     clouseau_54 | cobi_3 | coffee_44 | cold_clear_blue |
	  cold_clear_blue_1 | cold_ice | cold_simplicity_2 | color_rich | color-
     ful_0209 | colornegative | conflict_01 | contrail_35 |  contrast_with_high-
     lights_protection | contrasty_afternoon | contrasty_green |
	  crispromance	|  crispwarm  |  crispwinter  |  cross_process_cp_130  |
     cross_process_cp_14   |   cross_process_cp_15   |	 cross_process_cp_16   |
     cross_process_cp_18 | cross_process_cp_3 | cross_process_cp_4 |
	  cross_process_cp_6 | crushin | cubicle_99 | d_o_1 | dark_blues_in_sun-
     light  |  dark_green_02  |  dark_green_1  | dark_man_x | dark_orange_teal |
     dark_place_01 | darkness | date_39 | day_4nite | day_for_night
	  | day_to_night_kings_blue  |	deep  |  deep_blue  |  deep_dark_warm  |
     deep_high_contrast  |  deep_teal_fade  | deep_warm_fade | deepskintones_2 |
     deepskintones_3 | delicatessen | denoiser_simple_40 |
	  desert_gold_37 | dimension | directions_23 | django_25 | domingo_145 |
     dream_1 | dream_85 | drop_green_tint_14 | dropblues  |  duotone_blue_red  |
     earth_tone_boost | edgyember | elegance_38 | enchanted |
	  eterna_for_flog  |  expired_69 | expired_fade | expired_polaroid | ex-
     treme | fade | fade_to_green | faded | faded_47 | faded_alt |  faded_analog
     | faded_extreme | faded_green | faded_pink-ish | faded_print
	  | faded_retro_01 | faded_retro_02 | faded_vivid | fadedlook | fallcol-
     ors  |  faux_infrared  |  faux_infrared_bw_1  |  faux_infrared_color_p_2  |
     faux_infrared_color_p_3 | faux_infrared_color_r_0a |
	  faux_infrared_color_r_0b | faux_infrared_color_yp_1  |  fgcinebasic  |
     fgcinebright | fgcinecold | fgcinedrama | fgcinetealorange_1 | fgcinetealo-
     range_2 | fgcinevibrant | fgcinewarm | film_0987 | film_9879
	  |  film_gb-19  |  film_high_contrast | film_print_01 | film_print_02 |
     filmic | flat_30 | flat_blue_moon | flavin | foggynight | folger_50 |  for-
     mula_b | french_comedy | frosted | frostedbeachpicnic |
	  fuji_160c  | fuji_160c_+ | fuji_160c_++ | fuji_160c_- | fuji_3510_con-
     stlclip | fuji_3510_constlmap | fuji_3510_cuspclip | fuji_3513_constlclip |
     fuji_3513_constlmap | fuji_3513_cuspclip | fuji_400h |
	  fuji_400h_+ | fuji_400h_++ | fuji_400h_- | fuji_800z |  fuji_800z_+  |
     fuji_800z_++  |  fuji_800z_-  |  fuji_astia_100_generic | fuji_astia_100f |
     fuji_fp-100c | fuji_fp-100c_+ | fuji_fp-100c_++ |
	  fuji_fp-100c_+++   |	 fuji_fp-100c_++_alt	|    fuji_fp-100c_-    |
     fuji_fp-100c_--	 |     fuji_fp-100c_alt     |	  fuji_fp-100c_cool    |
     fuji_fp-100c_cool_+  |   fuji_fp-100c_cool_++   |	 fuji_fp-100c_cool_-   |
     fuji_fp-100c_cool_--
	  | fuji_fp-100c_negative | fuji_fp-100c_negative_+ | fuji_fp-100c_nega-
     tive_++   |   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_nega-
     tive_early | fuji_fp_100c | fuji_hdr | fuji_neopan_1600 |
	  fuji_neopan_1600_+   |   fuji_neopan_1600_++	|  fuji_neopan_1600_-  |
     fuji_neopan_acros_100  |  fuji_provia_100_generic	|   fuji_provia_100f   |
     fuji_provia_400f | fuji_provia_400x | fuji_sensia_100 |
	  fuji_superia_100 | fuji_superia_100_+ | fuji_superia_100_++ | fuji_su-
     peria_100_-   |   fuji_superia_1600   |  fuji_superia_1600_+  |  fuji_supe-
     ria_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_supe-
     ria_800_+ | fuji_superia_800_++ | fuji_superia_800_- |
	  fuji_superia_hg_1600 | fuji_superia_reala_100 | fuji_superia_x-tra_800
     |	fuji_velvia_100_generic  |  fuji_velvia_50  |  fuji_xtrans_iii_acros   |
     fuji_xtrans_iii_acros+g | fuji_xtrans_iii_acros+r |
	  fuji_xtrans_iii_acros+ye	  |	   fuji_xtrans_iii_astia       |
     fuji_xtrans_iii_classic_chrome	  |	   fuji_xtrans_iii_mono        |
     fuji_xtrans_iii_mono+g | fuji_xtrans_iii_mono+r | fuji_xtrans_iii_mono+ye |
	  fuji_xtrans_iii_pro_neg_hi	 |     fuji_xtrans_iii_pro_neg_std     |
     fuji_xtrans_iii_provia | fuji_xtrans_iii_sepia |  fuji_xtrans_iii_velvia  |
     fusion_88 | futuristicbleak_1 | futuristicbleak_2 | futuristicbleak_3
	  |  futuristicbleak_4	|  going_for_a_walk  |	golden | golden_bright |
     golden_fade | golden_mono	|  golden_night_softner_43  |  golden_sony_37  |
     golden_vibrant | goldengate | goldentime |
	  goldfx_bright_spring_breeze	   |	 goldfx_bright_summer_heat     |
     goldfx_hot_summer_heat | goldfx_perfect_sunset_01min |  goldfx_perfect_sun-
     set_05min | goldfx_perfect_sunset_10min | goldfx_spring_breeze |
	  goldfx_summer_heat  | good_morning | green_15 | green_2025 | green_ac-
     tion | green_afternoon | green_and_orange | green_blues | green_conflict  |
     green_day_01 | green_day_02 | green_g_09 | green_indoor |
	  green_light  | green_mono | green_yellow | greenish_contrasty | green-
     ish_fade | greenish_fade_1 | gremerta | hackmanite | hallowen_dark | happy-
     ness_133 | hard_teal_orange | harsh_day | harsh_sunset |
	  helios | herderite | heulandite | hiddenite | highlights_protection  |
     hilutite  |  hitman  |  hlg_1_1  |  honey_light  | 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  |  il-
     ford_fp_4_plus_125 | ilford_hp_5 | ilford_hp_5_+ |
	  ilford_hp_5_++ | ilford_hp_5_- | ilford_hp_5_plus_400 | ilford_hps_800
     |	ilford_pan_f_plus_50  |  ilford_xp_2 | indoor_blue | industrial_33 | in-
     frared_-_dust_pink | instantc | justpeachy | jwick_21 |
	  k_tone_vintage_kodachrome | kh_1 | kh_10 | kh_2 | kh_3 | kh_4 | kh_5 |
     kh_6 | kh_7 | kh_8 |  kh_9  |  killstreak	|  kodak_2383_constlclip  |  ko-
     dak_2383_constlmap | kodak_2383_cuspclip | kodak_2393_constlclip
	  |  kodak_2393_constlmap  | kodak_2393_cuspclip | kodak_bw_400_cn | ko-
     dak_e-100_gx_ektachrome_100   |   kodak_ektachrome_100_vs	  |    kodak_ek-
     tachrome_100_vs_generic | kodak_ektar_100 | kodak_elite_100_xpro |
	  kodak_elite_chrome_200      |     kodak_elite_chrome_400     |     ko-
     dak_elite_color_200 | kodak_elite_color_400 | kodak_elite_extracolor_100  |
     kodak_hie_hs_infra | kodak_kodachrome_200 | kodak_kodachrome_25 |
	  kodak_kodachrome_64 | kodak_kodachrome_64_generic | kodak_portra_160 |
     kodak_portra_160_+  | kodak_portra_160_++ | kodak_portra_160_- | kodak_por-
     tra_160_nc | kodak_portra_160_nc_+ |
	  kodak_portra_160_nc_++ | kodak_portra_160_nc_- | kodak_portra_160_vc |
     kodak_portra_160_vc_+ | kodak_portra_160_vc_++  |	kodak_portra_160_vc_-  |
     kodak_portra_400 | kodak_portra_400_+ |
	  kodak_portra_400_++  |  kodak_portra_400_- | kodak_portra_400_nc | ko-
     dak_portra_400_nc_+ | kodak_portra_400_nc_++ | kodak_portra_400_nc_- |  ko-
     dak_portra_400_uc | kodak_portra_400_uc_+ |
	  kodak_portra_400_uc_++ | kodak_portra_400_uc_- | kodak_portra_400_vc |
     kodak_portra_400_vc_+  |  kodak_portra_400_vc_++  | kodak_portra_400_vc_- |
     kodak_portra_800 | kodak_portra_800_+ |
	  kodak_portra_800_++ | kodak_portra_800_- | kodak_portra_800_hc  |  ko-
     dak_t-max_100  | kodak_t-max_3200 | kodak_t-max_400 | kodak_tmax_3200 | ko-
     dak_tmax_3200_+ | kodak_tmax_3200_++ | kodak_tmax_3200_- |
	  kodak_tmax_3200_alt | kodak_tri-x_400 | kodak_tri-x_400_+ | kodak_tri-
     x_400_++ | kodak_tri-x_400_- | kodak_tri-x_400_alt  |  korben_214	|  land-
     scape_01 | landscape_02 | landscape_03 | landscape_04 |
	  landscape_05	| landscape_1 | landscape_10 | landscape_2 | landscape_3
     | landscape_4 | landscape_5 | landscape_6 |  landscape_7  |  landscape_8  |
     landscape_9 | lateafternoonwanderlust | latesunset | lc_1 |
	  lc_10  |  lc_2  |  lc_3  |  lc_4  | lc_5 | lc_6 | lc_7 | lc_8 | lc_9 |
     lenox_340 | life_giving_tree | light_blown | lomo | lomography_redscale_100
     | lomography_x-pro_slide_200 | london_nights | louetta |
	  low_contrast_blue | low_key_01 |  lucky_64  |  lushgreensummer  |  ma-
     genta_day | magenta_day_01 | magenta_dream | magenta_yellow | magentacoffee
     | matrix | mckinnon_75 | memories | metropolis | milo_5 |
	  minimalistcaffeination   |   modern_film   |	modern_films_01  |  mod-
     ern_films_02 | modern_films_03 | modern_films_04 | modern_films_05  |  mod-
     ern_films_06 | modern_films_07 | mono_tinted | monochrome |
	  monochrome_1 | monochrome_2 | moody_1 | moody_10 | moody_2 | moody_3 |
     moody_4  |  moody_5  |  moody_6 | moody_7 | moody_8 | moody_9 | moonlight |
     moonlight_01 | moonrise | morning_6 | 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_pump | neutral_teal_or-
     ange  |  neutral_warm_fade  |  newspaper  |  night_01  |  night_blade_4   |
     night_king_141 | night_spy | nightfromday | nightlife |
	  nostalgiahoney  | nostalgic | nw-1 | nw-10 | nw-2 | nw-3 | nw-4 | nw-5
     | nw-6 | nw-7 | nw-8 | nw-9 | old_west  |	once_upon_a_time  |  only_red  |
     only_red_and_blue | operation_yellow | orange_dark_4 |
	  orange_dark_7 | orange_dark_look | orange_tone | orange_underexposed |
     oranges  |  paladin | paladin_1875 | pasadena_21 | passing_by | pink_fade |
     pitaya_15 | pmcinematic_01 | pmcinematic_02 |
	  pmcinematic_03 | pmcinematic_04 | pmcinematic_05  |  pmcinematic_06  |
     pmcinematic_07  |	pmnight_01  | pmnight_02 | pmnight_03 | pmnight_04 | pm-
     night_05 | polaroid_664 | polaroid_665 | polaroid_665_+ |
	  polaroid_665_++ | polaroid_665_- | polaroid_665_-- | polaroid_665_neg-
     ative   |	 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_+  |  polaroid_669_cold_-  |  po-
     laroid_669_cold_-- | polaroid_672 | polaroid_690 |
	  polaroid_690_+  | polaroid_690_++ | polaroid_690_- | polaroid_690_-- |
     polaroid_690_cold	|  polaroid_690_cold_+	|  polaroid_690_cold_++  |   po-
     laroid_690_cold_- | polaroid_690_cold_-- | polaroid_690_warm |
	  polaroid_690_warm_+ | polaroid_690_warm_++ | polaroid_690_warm_- | po-
     laroid_690_warm_--  |  polaroid_polachrome  | polaroid_px-100uv+_cold | po-
     laroid_px-100uv+_cold_+ | polaroid_px-100uv+_cold_++ |
	  polaroid_px-100uv+_cold_+++	|   polaroid_px-100uv+_cold_-	|    po-
     laroid_px-100uv+_cold_--	   |	  polaroid_px-100uv+_warm      |     po-
     laroid_px-100uv+_warm_+	 |     polaroid_px-100uv+_warm_++     |      po-
     laroid_px-100uv+_warm_+++ |
	  polaroid_px-100uv+_warm_-    |    polaroid_px-100uv+_warm_--	 |   po-
     laroid_px-680 | polaroid_px-680_+ | polaroid_px-680_++ |  polaroid_px-680_-
     | polaroid_px-680_-- | polaroid_px-680_cold | polaroid_px-680_cold_+
	  |   polaroid_px-680_cold_++	|   polaroid_px-680_cold_++_alt   |  po-
     laroid_px-680_cold_- | polaroid_px-680_cold_-- | polaroid_px-680_warm | po-
     laroid_px-680_warm_+ | polaroid_px-680_warm_++ |
	  polaroid_px-680_warm_- | polaroid_px-680_warm_--  |  polaroid_px-70  |
     polaroid_px-70_+	|   polaroid_px-70_++	|   polaroid_px-70_+++	 |   po-
     laroid_px-70_- | polaroid_px-70_-- | polaroid_px-70_cold |
	  polaroid_px-70_cold_+ | polaroid_px-70_cold_++ | polaroid_px-70_cold_-
     | polaroid_px-70_cold_-- | polaroid_px-70_warm  |	polaroid_px-70_warm_+  |
     polaroid_px-70_warm_++ | polaroid_px-70_warm_- |
	  polaroid_px-70_warm_--     |	  polaroid_time_zero_expired	|    po-
     laroid_time_zero_expired_+   |    polaroid_time_zero_expired_++	|    po-
     laroid_time_zero_expired_- | polaroid_time_zero_expired_-- |
	  polaroid_time_zero_expired_--- | polaroid_time_zero_expired_cold | po-
     laroid_time_zero_expired_cold_-  | polaroid_time_zero_expired_cold_-- | po-
     laroid_time_zero_expired_cold_--- | portrait_1 | portrait_10
	  | portrait_2 | portrait_3 | portrait_4 |  portrait_5	|  portrait_6  |
     portrait_7 | portrait_8 | portrait_9 | progressen | protect_highlights_01 |
     prussian_blue | pseudogrey | purple | purple_2 |
	  red_afternoon_01  | red_day_01 | red_dream_01 | redblueyellow | reds |
     reds_oranges_yellows  |  reeve_38	|  remy_24   |	 rest_33   |   retro   |
     retro_brown_01 | retro_magenta_01 | retro_summer_3 | retro_yellow_01 |
	  rollei_ir_400    |	rollei_ortho_25   |   rollei_retro_100_tonal   |
     rollei_retro_80s | rotate_muted | rotate_vibrant | rotated |  rotated_crush
     | saturated_blue | saving_private_damon | science_fiction | sea |
	  serenity  |  seringe_4  |  serpent  |  seventies_magazine  |	sevsuz |
     shade_kings_ink | shadow_king_39 | shine | skin_tones  |  smart_contrast  |
     smokey | smooth_clear | smooth_cromeish | smooth_fade |
	  smooth_green_orange  | smooth_sailing | smooth_teal_orange | soft_fade
     | softwarming |  solarized_color  |  solarized_color_2  |	springmorning  |
     sprocket_231 | spy_29 | street | studio_skin_tone_shaper |
	  subtle_blue  |  subtle_green	|  subtle_yellow | summer | summer_alt |
     sunlightlove  |  sunny  |	sunny_alt  |  sunny_rich  |  sunny_warm  |  sun-
     set_aqua_orange | sunset_intense_violet_blue | sunset_violet_mood |
	  super_warm   |   super_warm_rich   |	 sutro_fx  |  sweet_bubblegum  |
     sweet_gelatto | taiga | tarraco | teal_fade | teal_moonlight  |  tealmagen-
     tagold | tealorange | tealorange_1 | tealorange_2 | tealorange_3 |
	  technicalfx_backlight_filter	|  teigen_28 | tensiongreen_1 | tension-
     green_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 | un-
     known | urban_01 | urban_02 | urban_03 | urban_04 | urban_05 | urban_cowboy
     | uzbek_bukhara | uzbek_marriage | uzbek_samarcande |
	  velvetia | very_warm_greenish | vfb_21 | vibrant | vibrant_alien | vi-
     brant_contrast  |	vibrant_cromeish | victory | vintage | vintage_01 | vin-
     tage_02 | vintage_03 | vintage_04 | vintage_05 | vintage_163
	  | vintage_alt | vintage_brighter | vintage_chrome | vintage_mob | vin-
     tage_warmth_1 | violet_taste | vireo_37  |  warm  |  warm_dark_contrasty  |
     warm_fade | warm_fade_1 | warm_highlight | warm_neutral |
	  warm_sunset_red  | warm_teal | warm_vintage | warm_yellow | well_see |
     western  |  westernlut_2  |  whiter_whites  |  winterlighthouse  |  wipe  |
     wooden_gold_20 | yellow_55b | yellow_film_01 | yellowstone |
	  you_can_do_it  |  zed_32  |  zeke_39 | zilverfx_bw_solarization | zil-
     verfx_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' invoca-
     tion.

	 Default value: 'add_debug_info=1'.

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

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

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

	 Default value: 'mode=1'.

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

	 Delete  specified  filenames  on disk. Multiple filenames must be sepa-
     rated by commas.

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

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

	 Display selected images in an interactive viewer (use the instant  dis-
     play window [0] if opened).
	 (equivalent to shortcut command 'd').

	 Arguments 'X','Y','Z' determine the initial selection view, for 3D vol-
     umetric images.

	 Default value: 'X=Y=Z=0' and 'exit_on_anykey=0'.

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

       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 displaying 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 possible:
	  * 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 instant
     display window [0] if opened).
	 (equivalent to shortcut command 'd3d').

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

       da:
	   Shortcut for command 'display_array'.

       display_array:
	   _width>0,_height>0

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

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

       dc:
	   Shortcut for command 'display_camera'.

       display_camera:

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

       dfft:
	   Shortcut for command 'display_fft'.

       display_fft:

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

	 Example:
	   [#1] image.jpg +display_fft

       dg:
	   Shortcut for command 'display_graph'.

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

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

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

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

       dh:
	   Shortcut for command 'display_histogram'.

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

	 Render a channel-by-channel histogram.
	 If selected images have several slices, the rendering is performed  for
     all input slices.
	 'expression'  is  a  mathematical expression used to transform the his-
     togram 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 image
     data.
	 Curve points are defined as pixels of a 2 or 3-channel image.
	 If the point image contains more than 3 channels,  additional	channels
     define the (R,G,B) color for each vertex.
	 If  'outline_opacity>1', the outline is colored according to the speci-
     fied vertex colors and
	 'outline_opacity-1' is used as the actual drawing opacity.

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

	 Example:
	   [#1]
     1024,1,1,2,'t=x/40;if(c==0,sin(t),cos(t))*(exp(cos(t))-2*cos(4*t)-sin(t/12)^5)'
     display_parametric 512,512
	   [#2] 1000,1,1,2,u(-100,100) quantize 4,1 noise 12 channels 0,2  +nor-
     malize 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 window.
	 (equivalent to shortcut command 'dp').

       dp0:
	   Shortcut for command 'display_parallel0'.

       display_parallel0:

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

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

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

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

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

       dq:
	   Shortcut for command 'display_quiver'.

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

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

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

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

       drgba:
	   Shortcut for command 'display_rgba'.

       display_rgba:
	   _background_RGB_color

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

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

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

       dt:
	   Shortcut for command 'display_tensors'.

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

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

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

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

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

       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 in-
     stead of image indices.
	 When invoked with a '+' prefix (i.e. '+echo'), the command  output  its
     message on stdout rather than stderr.

       echo_file:
	   filename,message

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

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

	 Insert continuous 1D function from specified list of keypoints (xk,yk)
	 in range [0,max(xk)] (xk are positive integers).

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

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

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

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

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

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

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

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

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

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

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

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

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

	 Default value: 'reverse_endianness=0'.

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

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

	 Default value: 'read_data_as=1'.

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

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

	 Default value: 'convert_1d_cluts_to_3d=1'.

       input_flo:
	   "filename"

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

       ig:
	   Shortcut for command 'input_glob'.

       input_glob:
	   pattern

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

       input_gpl:
	   filename

	 Input specified filename as a .gpl palette data file.

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

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

	 Default value: 'try_downloading_from_gmic_server=1'.

       input_obj:
	   filename

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

       it:
	   Shortcut for command 'input_text'.

       input_text:
	   filename

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

       lorem:
	   _width>0,_height>0

	 Input random image of specified size, retrieved from Internet.

	 Default values: 'width=height=800'.

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

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

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

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

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

	 Default value: 'format_options'=(undefined).

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

	 Output selected images as raw RGB-565 files.

	 Default value: 'reverse_endianness=0'.

       output_cube:
	   "filename"

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

       output_flo:
	   "filename"

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

       output_ggr:
	   filename,_gradient_name

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

       output_gmz:
	   filename,_datatype

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

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

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

	 Default value: 'save_materials=1'.

       ot:
	   Shortcut for command 'output_text'.

       output_text:
	   filename

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

       on:
	   Shortcut for command 'outputn'.

       outputn:
	   filename,_index

	 Output  selected  images  as  automatically  numbered	filenames in 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_location={  0
     | 1 }

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

	 Default value: 'output_at_same_location=0'.

       parse_cli:
	   _output_mode,_{ * | command_name }

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

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

       parse_gmd:

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

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

	 Convert selected gmd-formatted text images to html format.

	 Default values: 'include_default_header_footer=1'.

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

	 Convert selected gmd-formatted text images to ascii format.

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

       parse_gui:
	   _outputmode,_{ * | filter_name}

	 Parse selected filter definitions and generate info  about  filters  in
     selected output mode.
	 'outputmode' can be { gmicol | json | list | print | strings | update |
     zart }.
	 It is possible to define a custom output mode, by implementing the fol-
     lowing commands
	 ('outputmode'	must  be  replaced by the name of the custom user output
     mode):
	 . 'parse_gui_outputmode' : A command that outputs the parsing	informa-
     tion with a custom format.
	 .  'parse_gui_parseparams_outputmode' (optional): A simple command that
     returns 0 or 1. It tells the parser whether parameters of	matching  filter
     must be analyzed (slower) or not.
	 .  'parse_gui_trigger_outputmode'  (optional): A command that is called
     by the parser just before parsing the set of each matching filters.
	 Here is the list of global variables set by the parser,  accessible  in
     command 'parse_gui_outputmode':
	 '$_nb_filters': Number of matching filters.
	 '$_nongui'  (stored  as an image): All merged lines in the file that do
     not correspond to '#@gui' lines.
	 For each filter '     * '$_fF_name' : Filter name.
	  * '$_fF_path' : Full path.
	  * '$_fF_locale' : Filter locale (empty, if not specified).
	  * '$_fF_command' : Filter command.
	  * '$_fF_command_preview' : Filter preview command (empty, if not spec-
     ified).
	  * '$_fF_zoom_factor' : Default zoom factor (empty, if not specified).
	  * '$_fF_preview_accuracy' : Preview accuracy (can be { 0=does not sup-
     port zoom in/out | 1=support zoom in/out | 2=pixel-perfect }).
	  * '$_fF_input_mode' : Default preferred  input  mode	(empty,  if  not
     specified).
	  *  '$_fF_hide'  :  Path of filter hid by current filter (for localized
     filters, empty if not specified).
	  * '$_fF_nb_params' : Number of parameters.
	 For each parameter '	  * '$_fF_pP_name' : Parameter name.
	  * '$_fF_pP_type' : Parameter type.
	  * '$_fF_pP_responsivity' : Parameter responsivity (can be { 0 | 1 }).
	  * '$_fF_pP_visibility' : Parameter visibility.
	  * '$_fF_pP_propagation' : Propagation of the parameter visibility.
	  * '$_fF_pP_nb_args' : Number of parameter arguments.
	 For each argument '	 * '$_fF_pP_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 envi-
     ronment.
	 Command selection (if any) stands for a selection of images in the par-
     ent 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 envi-
     ronment as well.
	 Typical  use  of  command 'pass' concerns the design of custom commands
     that take images as arguments.
	 This commands return the list of corresponding indices in the status.

	 Default value: 'shared_state=2'.

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

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

	 Display selected images or formula in an interactive  viewer  (use  the
     instant display window [0] if opened).
	 'plot_type' can be { 0=none | 1=lines | 2=splines | 3=bar }.
	 'vertex_type'	can be { 0=none | 1=points | 2,3=crosses | 4,5=circles |
     6,7=squares }.
	 'xmin', 'xmax', 'ymin', 'ymax' set the coordinates of the displayed xy-
     axes.

	 Default values: 'plot_type=1', 'vertex_type=1',  'xmin=xmax=ymin=ymax=0
     (auto)' and 'exit_on_anykey=0'.

       portrait:
	   _size>0

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

	 Default values: 'size=800'.

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

       print (+):

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

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

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

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

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

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

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

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

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

	 Interactively select a feature from selected images  (use  the  instant
     display window [0] if opened).
	 'feature_type'  can  be { 0=point | 1=segment | 2=rectangle | 3=ellipse
     }.
	 Arguments 'X','Y','Z' determine the initial selection view, for 3D vol-
     umetric images.
	 The retrieved feature is returned as a 3D vector (if 'feature_type==0')
     or as a 6d vector
	 (if 'feature_type!=0') containing the feature coordinates.

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

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

	 Serialize  selected list of images into a single image, optionally in a
     compressed form.
	 'datatype' can be { auto | uint8 | int8 | uint16 |  int16  |  uint32  |
     int32 | uint64 | int64 | float32 | float64 }.
	 Specify  'datatype'  if all selected images have a range of values con-
     strained to a particular datatype,
	 in order to minimize the memory footprint.
	 The resulting image has only integers values in [0,255] and can then be
     saved as a raw image of
	 unsigned chars (doing so will output a valid .cimg[z] or .gmz file).
	 If 'store_names' is set to '1', serialization uses the .gmz  format  to
     store data in memory
	 (otherwise the .cimg[z] format).

	 Default values: 'datatype=auto', 'is_compressed=1' and 'store_names=1'.

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

       shape_circle:
	   _size>=0

	 Input a 2D circle binary shape with specified size.

	 Default value: 'size=512'.

	 Example:
	   [#1] shape_circle ,

       shape_cupid:
	   _size>=0

	 Input a 2D cupid binary shape with specified size.

	 Default value: 'size=512'.

	 Example:
	   [#1] shape_cupid ,

       shape_diamond:
	   _size>=0

	 Input a 2D diamond binary shape with specified size.

	 Default value: 'size=512'.

	 Example:
	   [#1] shape_diamond ,

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

	 Input a 2D Dragon curve with specified size.

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

	 Example:
	   [#1] shape_dragon ,

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

	 Input a 2D Barnsley fern with specified size.

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

	 Example:
	   [#1] shape_fern ,

       shape_gear:
	   _size>=0,_nb_teeth>0,0<=_height_teeth<=100,0<=_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+$>} }

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

	 Input a 2D snowflake binary shape with specified size.

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

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

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

	 Input a 2D star binary shape with specified size.

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

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

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

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

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

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

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

       sp:
	   Shortcut for command 'sample'.

       sample:
	   _name1={  ? | apples | balloons | barbara | boats | bottles | butter-
     fly | 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 | par-
     rots | pencils | peppers | portrait0 | portrait1 |
	     portrait2	|  portrait3  | portrait4 | portrait5 | portrait6 | por-
     trait7 | portrait8 | portrait9 | roddy | rooster | rose | square |  swan  |
     teddy | tiger | tulips | wall | waterfall | zelda },_name2,...,
	     _nameN,_width={ >=0 | 0 (auto) },_height = { >=0 | 0 (auto) } |
	   (no arg)

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

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

	 Example:
	   [#1] repeat 6 { sample }

       srand (+):
	   value |
	   (no arg)

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

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

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

	 Default value: 'is_compressed=0'.

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

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

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

	 Input a 2D synthetic image.

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

	 Example:
	   [#1] testimage2d 512

       um:
	   Shortcut for command 'uncommand'.

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

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

       uniform_distribution:
	   nb_levels>=1,spectrum>=1

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

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

       unserialize (+):

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

       up:
	   Shortcut for command 'update'.

       update:

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

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

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

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

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

	 Default value: 'level=1'.

       wait (+):
	   delay |
	   (no arg)

	 Wait  for  a  given  delay  (in  ms), optionally since the last call to
     'wait'.
	 or wait for a user event occurring on the selected instant display win-
     dows.
	 'delay' can be { <0=delay+flush events | 0=event | >0=delay }.
	 Command selection (if any) stands for instant	display  window  indices
     instead of image indices.
	 If no window indices are specified and if 'delay' is positive, the com-
     mand 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 in-
     stead 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  specified
     size, normalization type,
	 fullscreen mode and title.
	 (equivalent to shortcut command 'w').

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

	 Default  values:  'width=height=normalization=fullscreen=-1'  and  '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

       kn:
	   Shortcut for command 'keep_named'.

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

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

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

       move (+):
	   position[%]

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

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

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

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

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

	 Set names of selected images.
	  *  If  selection  is empty or not explicitely specified, it represents
     the last 'N' images of the list, where'N' is the number of specified  argu-
     ments to the command 'name'.
	  *  If  the  selection  contains a single image, then it is assumed the
     command has a single name argument (possibly containing multiple commas).
	  * If the selection contains more than one image, each command argument
     defines a single image name for each image of the selection.
	 (equivalent to shortcut command '=>').

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

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

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

       remove (+):

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

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

       remove_duplicates:

	 Remove duplicates images in the selected images list.

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

       remove_empty:

	 Remove empty images in the selected image list.

       rmn:
	   Shortcut for command 'remove_named'.

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

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

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

       reverse (+):

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

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

       sort_list:
	   _ordering={ + | - },_criterion

	 Sort list of selected images according to the	specified  image  crite-
     rion.

	 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/oldtutorial/trigometric-and-inverse-trigomet-
     ric-commands

       acosh (+):

	 Compute the pointwise hyperbolic arccosine of selected images.

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

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

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

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

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

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

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

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

       argmax:

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

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

       argmaxabs:

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

       argmin:

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

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

       argminabs:

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

       asin (+):

	 Compute the pointwise arcsine of selected images.

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

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

       asinh (+):

	 Compute the pointwise hyperbolic arcsine of selected images.

       atan (+):

	 Compute the pointwise arctangent of selected images.

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

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

       atan2 (+):
	   [x_argument]

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

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

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

       atanh (+):

	 Compute the pointwise hyperbolic arctangent of selected images.

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

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

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

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

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

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

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

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

       cos (+):

	 Compute the pointwise cosine of selected images.

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

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

       cosh (+):

	 Compute the pointwise hyperbolic cosine of selected images.

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

       deg2rad:

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

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

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

	 Divide  selected  images  by specified value, image or mathematical ex-
     pression, 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 se-
     lected images.
	 (equivalent to shortcut command '==').

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

       erf (+):

	 Compute the pointwise error function of selected images.

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

       exp (+):

	 Compute the pointwise exponential of selected images.

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

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

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

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

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

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

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

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

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

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

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

	 Compute the boolean 'less or equal than' of selected images with speci-
     fied 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 se-
     lected images.

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

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

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

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

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

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

       med:

	 Compute the median of selected images.

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

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

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

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

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

	 Compute the minabs between selected images and specified  value,  image
     or  mathematical  expression,  or	compute the pointwise minabs between se-
     lected 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 se-
     lected 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/vectors by
     specified value, image or mathematical expression, or  compute  the  matrix
     right multiplication of selected images.
	 (equivalent to shortcut command 'm*').

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

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

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

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

	 See also: add, sub, div.

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

       mul_channels:
	   value1,_value2,...,_valueN

	 Multiply channels of selected images by specified sequence of values.

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

       mul_complex:
	   [multiplier_real,multiplier_imag]

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

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

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

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

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

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

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

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

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

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

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

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

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

       rad2deg:

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

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

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

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

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

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

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

       sign (+):

	 Compute the pointwise sign of selected images.

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

       sin (+):

	 Compute the pointwise sine of selected images.

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

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

       sinc (+):

	 Compute the pointwise sinc function of selected images.

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

       sinh (+):

	 Compute the pointwise hyperbolic sine of selected images.

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

       sqr (+):

	 Compute the pointwise square function of selected images.

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

       sqrt (+):

	 Compute the pointwise square root of selected images.

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

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

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

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

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

       tan (+):

	 Compute the pointwise tangent of selected images.

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

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

       tanh (+):

	 Compute the pointwise hyperbolic tangent of selected images.

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

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

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

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

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

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

	 Apply curve transformation to image values.

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

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

       apply_gamma:
	   gamma>=0

	 Apply gamma correction to selected images.

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

       balance_gamma:
	   _ref_color1,...

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

	 Default value: 'ref_color1=128'.

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

       cast:
	   datatype_source,datatype_target

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

       complex2polar:

	 Compute complex to polar transforms of selected images.

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

       compress_clut:
	   _max_error>0,_avg_error>0,_max_nbpoints>=8	|   0	(unlimited),_er-
     ror_metric={  0=L2-norm  |  1=deltaE_1976	|  2=deltaE_2000  },_reconstruc-
     tion_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 constraint.

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

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

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

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

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

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

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

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

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

       decompress_clut:
	   _width>0,_height>0,_depth>0,_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_color-
     space=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_color-
     space=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 multiscale
     diffusion PDE's.

	 Default  values:  'width=height=depth=33'  and   'reconstruction_color-
     space=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 du-
     plicate values,
	 optionally only for the values along the first of a specified axis.
	 If no arguments are specified, neighboring duplicate  values  are  dis-
     carded.
	 If  all pixels of a selected image are discarded, an empty image is re-
     turned.

	 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 ten-
     sor fields.

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

       endian (+):
	   _datatype

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

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

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

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

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

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

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

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

	 Example:
	   [#1] 4,4 fill 1,2,3,4,5,6,7
	   [#2] 4,4 (1,2,3,4,5,6,7) fill[-2] [-1]
	   [#3]   400,400,1,3	fill   "X=x-w/2;    Y=y-h/2;	R=sqrt(X^2+Y^2);
     a=atan2(Y,X);
     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

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

	 Index selected vector-valued images by specified vector-valued palette.
	 'palette_name' can be { default | hsv | lines | hot | cool | jet | flag
     |	cube  |  rainbow  | algae | amp |balance | curl | deep | delta | dense |
     diff | haline | ice | matter | oxy | phase | rain |
	 solar | speed | tarn |tempo | thermal | topo | turbid | aurora | hocus-
     pocus | 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/gindex

       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 images.
	 'palette_name' can be { default | hsv | lines | hot | cool | jet | flag
     | cube | rainbow | algae | amp | balance | curl | deep | delta  |	dense  |
     diff | gray | haline | ice | matter | oxy | phase |
	 rain  | solar | speed | tarn | tempo | thermal | topo | turbid | aurora
     | hocuspocus | srb2 | uzebox }
	 'boundary_conditions' can be { 0=dirichlet | 1=neumann |  2=periodic  |
     3=mirror }.

	 Default value: 'boundary_conditions=0'.

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

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

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

	 Apply specified matrix to channels of selected images.

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

       negate:
	   base_value |
	   (no arg)

	 Negate image values.

	 Default value: 'base_value=(undefined)'.

	 Example:
	   [#1] image.jpg +negate

       noise (+):
	   std_deviation>=0[%],_noise_type

	 Add random noise to selected images.
	 'noise_type' can be { 0=gaussian | 1=uniform | 2=salt&pepper |  3=pois-
     son | 4=rice }.

	 Default value: 'noise_type=0'.

	 Example:
	   [#1] image.jpg +noise[0] 50,0 +noise[0] 50,1 +noise[0] 10,2 cut 0,255
	   [#2]  300,300,1,3 [0] noise[0] 20,0 noise[1] 20,1 +histogram 100 dis-
     play_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 coordi-
     nates.
	 The Perlin noise is a specific type of smooth noise,
	 described here : https://en.wikipedia.org/wiki/Perlin_noise.

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

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

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

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

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

	 Example:
	   [#1] 300,300 noise_poissondisk 8

       normp:
	   p>=0

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

	 Default value: 'p=2'.

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

       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

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

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

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

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

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

       normalize_l2:

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

       normalize_sum:

	 Normalize selected images such that they have a unit sum.

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

       not:

	 Apply boolean not operation on selected images.

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

       orientation:

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

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

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

       oneminus:

	 For each selected image, compute one minus image.

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

       otsu:
	   _nb_levels>0

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

	 Default value: 'nb_levels=256'.

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

       polar2complex:

	 Compute polar to complex transforms of selected images.

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

	 Quantize selected images.

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

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

       quantize_area:
	   _min_area>0

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

	 Default value: 'min_area=10'.

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

       rand (+):
	   { value0[%] | [image0] },_{ value1[%] | [image1] } |
	   [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 expression.

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

       replace_seq:
	   "search_seq","replace_seq"

	 Search and replace a sequence of values in selected images.

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

       replace_str:
	   "search_str","replace_str"

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

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

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

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

	 Default value: 'rounding_type=0'.

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

       roundify:
	   gamma>=0

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

	 Default value: 'gamma=0'.

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

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

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

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

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

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

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

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

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

	 Default value: 'is_soft=0'.

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

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

       vector2tensor:

	 Convert selected vector fields to corresponding tensor fields.

       12.6. Colors
	     ------

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

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

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

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

       ac:
	   Shortcut for command 'apply_channels'.

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

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

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

	 Default value: 'value_action=0'.

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

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

	 Index selected vector-valued images by adapted colormaps.

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

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

       bayer2rgb:
	   _GM_smoothness,_RB_smoothness1,_RB_smoothness2

	 Transform selected RGB-Bayer sampled images to color images.

	 Default   values:   'GM_smoothness=RB_smoothness=1'   and   'RB_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_command"

	 Compute  the  CIE  DeltaE  color difference between selected images and
     specified [image].
	 Argument 'to_Lab_command' is a command able to convert colors	of  [im-
     age] 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=deuteranom-
     aly | 4=tritanopia | 5=tritanomaly | 6=achromatopsia | 7=achromatomaly }

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

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

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

	 Estimate  best-fitting  colormap with 'nb_colors' entries, to index se-
     lected 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  de-
     creasing occurrence }.

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

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

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

       compose_channels:

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

	 Default value: '1=+'.

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

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

       direction2rgb:

	 Compute RGB representation of selected 2D direction fields.

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

       ditheredbw:

	 Create dithered B&W version of selected images.

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

       fc:
	   Shortcut for command 'fill_color'.

       fill_color:
	   col1,...,colN

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

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

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

       gradient2rgb:
	   _is_orientation={ 0 | 1 }

	 Compute RGB representation of 2D gradient of selected images.

	 Default value: 'is_orientation=0'.

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

       hcy2rgb:

	 Convert color representation of selected images from HCY to RGB.

       hsi2rgb:

	 Convert color representation of selected images from HSI to RGB.

       hsi82rgb:

	 Convert color representation of selected images from HSI8 to RGB.

       hsl2rgb:

	 Convert color representation of selected images from HSL to RGB.

       hsl82rgb:

	 Convert color representation of selected images from HSL8 to RGB.

       hsv2rgb:

	 Convert color representation of selected images from HSV to RGB.

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

       hsv82rgb:

	 Convert color representation of selected images from HSV8 to RGB.

       int2rgb:

	 Convert color representation of selected images from INT24 to RGB.

       ipremula:

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

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

	 Convert color representation of selected images from RGB to Jzazbz.

	 Default value: 'illuminant=2'.

       jzazbz2xyz:

	 Convert color representation of selected images from RGB to XYZ.

       lab2lch:

	 Convert color representation of selected images from Lab to Lch.

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

	 Convert color representation of selected images from Lab to RGB.

	 Default value: 'illuminant=2'.

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

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

	 Convert color representation of selected images from Lab to sRGB.

	 Default value: 'illuminant=2'.

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

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

	 Convert color representation of selected images from Lab8 to sRGB.

	 Default value: 'illuminant=2'.

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

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

	 Convert color representation of selected images from Lab to XYZ.

	 Default value: 'illuminant=2'.

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

	 Convert color representation of selected images from Lab8 to RGB.

	 Default value: 'illuminant=2'.

       lch2lab:

	 Convert color representation of selected images from Lch to Lab.

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

	 Convert color representation of selected images from Lch to RGB.

	 Default value: 'illuminant=2'.

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

	 Convert color representation of selected images from Lch8 to RGB.

	 Default value: 'illuminant=2'.

       luminance:

	 Compute luminance of selected sRGB images.

	 Example:
	   [#1] image.jpg +luminance

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

       lightness:

	 Compute lightness of selected sRGB images.

	 Example:
	   [#1] image.jpg +lightness

       lut_contrast:
	   _nb_colors>1,_min_rgb_value

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

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

       map_clut:
	   [clut] | "clut_name"

	 Map specified RGB color LUT to selected images.

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

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

	 Apply 3x3 specified matrix to RGB colors of selected images.

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

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

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

       oklab2rgb:

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

       palette:
	   palette_name | palette_number

	 Input specified color palette at the end of the image list.
	 'palette_name' can be { default | hsv | lines | hot | cool | jet | flag
     | cube | rainbow | parula | spring | summer | autumn | winter | bone | cop-
     per | pink | vga | 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 | amiga7800 | amiga7800mess |
	 fornaxvoid1 }

	 Example:
	   [#1] palette hsv

       premula:

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

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

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

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

	 Example:
	   [#1] pseudogray 5

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

	 Replace pixels from/to specified colors in selected images.

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

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

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

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

       rgb2bayer:
	   _start_pattern=0,_color_grid=0

	 Transform selected color images to RGB-Bayer sampled images.

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

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

       rgb2cmy:

	 Convert color representation of selected images from RGB to CMY.

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

       rgb2cmyk:

	 Convert color representation of selected images from RGB to CMYK.

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

       rgb2hcy:

	 Convert color representation of selected images from RGB to HCY.

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

       rgb2hsi:

	 Convert color representation of selected images from RGB to HSI.

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

       rgb2hsi8:

	 Convert color representation of selected images from RGB to HSI8.

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

       rgb2hsl:

	 Convert color representation of selected images from RGB to HSL.

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

       rgb2hsl8:

	 Convert color representation of selected images from RGB to HSL8.

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

       rgb2hsv:

	 Convert color representation of selected images from RGB to HSV.

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

       rgb2hsv8:

	 Convert color representation of selected images from RGB to HSV8.

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

       rgb2int:

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

	 Example:
	   [#1] image.jpg rgb2int

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

	 Convert color representation of selected images from RGB to Jzazbz.

	 Default value: 'illuminant=2'.

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

	 Convert color representation of selected images from RGB to Lab.

	 Default value: 'illuminant=2'.

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

	 Convert color representation of selected images from RGB to Lab8.

	 Default value: 'illuminant=2'.

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

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

	 Convert color representation of selected images from RGB to Lch.

	 Default value: 'illuminant=2'.

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

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

	 Convert color representation of selected images from RGB to Lch8.

	 Default value: 'illuminant=2'.

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

       rgb2luv:

	 Convert color representation of selected images from RGB to LUV.

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

       rgb2oklab:

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

       rgb2ryb:

	 Convert color representation of selected images from RGB to RYB.

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

       rgb2srgb:

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

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

	 Convert color representation of selected images from RGB to XYZ.

	 Default value: 'illuminant=2'.

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

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

	 Convert color representation of selected images from RGB to XYZ8.

	 Default value: 'illuminant=2'.

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

       rgb2yiq:

	 Convert color representation of selected images from RGB to YIQ.

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

       rgb2yiq8:

	 Convert color representation of selected images from RGB to YIQ8.

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

       rgb2ycbcr:

	 Convert color representation of selected images from RGB to YCbCr.

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

       rgb2yuv:

	 Convert color representation of selected images from RGB to YUV.

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

       rgb2yuv8:

	 Convert color representation of selected images from RGB to YUV8.

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

       remove_opacity:

	 Remove opacity channel of selected images.

       ryb2rgb:

	 Convert color representation of selected images from RYB to RGB.

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

	 Select pixels with specified color in selected images.

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

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

       sepia:

	 Apply sepia tones effect on selected images.

	 Example:
	   [#1] image.jpg sepia

       solarize:

	 Solarize selected images.

	 Example:
	   [#1] image.jpg solarize

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

	 Split selected images as several image containing a single color.
	 One selected image can be split as at most 'max_nb_outputs' images.
	 Output images are sorted by decreasing area of extracted color  regions
     and have an additional alpha-channel.

	 Default values: 'tolerance=0', 'max_nb_outputs=256' and 'min_area=8'.

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

       split_opacity:

	 Split color and opacity parts of selected images.
	 This  command returns 1 or 2 images for each selected image, whether it
     has an opacity channel or not.

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

	 Convert color representation of selected images from sRGB to Lab.

	 Default value: 'illuminant=2'.

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

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

	 Convert color representation of selected images from sRGB to Lab8.

	 Default value: 'illuminant=2'.

       srgb2rgb:

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

       to_a:

	 Force selected images to have an alpha channel.

       to_color:

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

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

	 Force selected images to be in a given color mode.

	 Default value: 'mode=0'.

       to_gray:

	 Force selected images to be in GRAY mode.

	 Example:
	   [#1] image.jpg +to_gray

       to_graya:

	 Force selected images to be in GRAYA mode.

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

	 Convert selected scalar images ([0-255]-valued)  to  pseudo-gray  color
     images.

	 Default    values:   'max_step=5',   'is_perceptual_constraint=1'   and
     'bits_depth=8'.
	 The original pseudo-gray technique has been introduced by Rich  Franzen
     http://r0k.us/graphics/pseudoGrey.html.
	 Extension of this technique to arbitrary increments for more tones, has
     been done by David TschumperlA(C).

       to_rgb:

	 Force selected images to be in RGB mode.

       to_rgba:

	 Force selected images to be in RGBA mode.

       transfer_histogram:
	   [reference_image],_nb_levels>0,_color_channels

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

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

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

       transfer_pca:
	   [reference_image],_color_channels

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

	 Default value: 'color_channels=all'.

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

       transfer_rgb:
	   [target],_gamma>=0,_regularization>=0,_luminosity_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 ap-
     plied 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 to-
     gether, 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*$>}% } remove[0] append
     x,0.5
	   [#3] image.jpg append[0] [0],y

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

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

	 Default values: 'M=0', 'N=0', 'centering_x=centering_y=0.5'.

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

       apply_scales:
	   "command",num-
     ber_of_scales>0,_min_scale[%]>=0,_max_scale[%]>=0,_scale_gamma>0,_interpo-
     lation

	 Apply specified command on different scales of selected images.
	 'interpolation' can be { 0=none | 1=nearest | 2=average  |  3=linear  |
     4=grid | 5=bicubic | 6=lanczos }.

	 Default value: 'min_scale=25%', 'max_scale=100%' and 'interpolation=3'.

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

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

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

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

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

	 Autocrop and extract connected components in selected images, according
     to a mask given as the last channel of
	 each of the selected image (e.g. alpha-channel).

	 Default  values:  'threshold=0%',  'min_area=0.1%', 'is_high_connectiv-
     ity=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  au-
     tocrop_seq 0

       channels:
	   c0[%],_c1[%]

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

	 Default value: 'c1=c0'.

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

       columns:
	   x0[%],_x1[%]

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

	 Default value: 'x1=x0'.

	 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_conditions

	 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

       edgels:
	   x0,y0 |
	   (no arg)

	 Retrieve list of edgels (and their normals) that go around a 2D  binary
     silhouette.
	 When  specified, arguments 'x0,y0' are the 2D coordinates of the start-
     ing point (must be located at the edge of the binary silhouette).
	 Output image has 3 channels '[x,y,n]' where 'x' and 'y' are the 2D  co-
     ordinates	of the edgel point, and 'n' is the orientation of its associated
     canonical normal (can be { 0=[1,0]
	 | 1=[0,1] | 2=[-1,0] | 3=[0,-1] }.

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

	 Elevate selected 2D images into 3D volumes.

	 Default values: 'depth=64', 'is_plain=1' and 'is_colored=1'.

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

	 Expand selected images along the x-axis.

	 Default value: 'boundary_conditions=0'.

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

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

	 Expand selected images along the xy-axes.

	 Default value: 'boundary_conditions=0'.

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

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

	 Expand selected images along the xyz-axes.

	 Default value: 'boundary_conditions=0'.

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

	 Expand selected images along the y-axis.

	 Default value: 'boundary_conditions=0'.

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

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

	 Expand selected images along the z-axis.

	 Default value: 'boundary_conditions=0'.

       extract:
	   "condition",_output_type={ 0=xyzc-coordinates |  1=xyz-coordinates  |
     2=scalar-values | 3=vector-values }

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

	 Default values: 'output_type=0'.

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

       extract_region:
	   [label_image],_extract_xyz_coordinates={  0	|  1 },_label_1,...,_la-
     bel_M

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

	 Default value: 'extract_xyz_coordinates=0'.

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

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

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

	 Default values: 'layout_code=X', 'montage_mode=2', output_mode='0'  and
     'processing_command=""'.

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

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

	 Mirror selected images along specified axes.

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

       permute (+):
	   permutation_string

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

	 Example:
	   [#1] image.jpg permute yxzc

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

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

	 Resize selected images with specified geometry.
	 (equivalent to shortcut command 'r').

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

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

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

       ri:
	   Shortcut for command 'resize_as_image'.

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

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

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

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

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

	 Resize selected images with Mitchell-Netravali filter (cubic).
	 For	    details	   about	the	    method,	    see:
     https://de.wikipedia.org/wiki/Mitchell-Netravali-Filter.

	 Default values: 'height=100%', 'depth=100%', 'B=0.3333' and 'C=0.3333'.

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

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

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

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

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

       rr2d:
	   Shortcut for command 'resize_ratio2d'.

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

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

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

       r2din:
	   Shortcut for command 'resize2din'.

       resize2din:
	   width[%]>0,_height[%]>0,_interpolation,_boundary_condi-
     tions,_ax,_ay,_az,_ac

	 Resize selected images so the size is not larger than	'width'x'height'
     while preserving 2D ratio.
	 (equivalent to shortcut command 'r2din').

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

	 Default   values:  'height=100%',  'interpolation=3',	'boundary_condi-
     tions=0' and 'ax=ay=az=ac=0'.

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

       r3din:
	   Shortcut for command 'resize3din'.

       resize3din:
	   width[%]>0,_height[%]>0,_depth[%]>0,_interpolation,_boundary_condi-
     tions,_ax,_ay,_az,_ac

	 Resize   selected   images   so   the	 size	is   not   larger   than
     'width'x'height'x'depth' while preserving 3D ratio.
	 (equivalent to shortcut command 'r3din').

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

	 Default values: 'height=100%', 'depth=100%', 'interpolation=3', 'bound-
     ary_conditions=0' and 'ax=ay=az=ac=0'.

       r2dout:
	   Shortcut for command 'resize2dout'.

       resize2dout:
	   width[%]>0,_height[%]>0,_interpolation,_boundary_condi-
     tions,_ax,_ay,_az,_ac

	 Resize selected images so the size is not smaller than 'width'x'height'
     while preserving 2D ratio.
	 (equivalent to shortcut command 'r2dout').

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

	 Default   values:  'height=100%',  'interpolation=3',	'boundary_condi-
     tions=0' and 'ax=ay=az=ac=0'.

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

       r3dout:
	   Shortcut for command 'resize3dout'.

       resize3dout:
	   width[%]>0,_height[%]>0,_depth[%]>0,_interpolation,_boundary_condi-
     tions,_ax,_ay,_az,_ac

	 Resize  selected   images   so   the	size   is   not   smaller   than
     'width'x'height'x'depth' while preserving 3D ratio.
	 (equivalent to shortcut command 'r3dout').

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

	 Default values: 'height=100%', 'depth=100%', 'interpolation=3', 'bound-
     ary_conditions=0' and 'ax=ay=az=ac=0'.

       r2dx:
	   Shortcut for command 'resize2dx'.

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

	 Resize selected images along the x-axis, while preserving 2D ratio.
	 (equivalent to shortcut command 'r2dx').

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

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

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

       r2dy:
	   Shortcut for command 'resize2dy'.

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

	 Resize selected images along the y-axis, while preserving 2D ratio.
	 (equivalent to shortcut command 'r2dy').

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

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

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

       r3dx:
	   Shortcut for command 'resize3dx'.

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

	 Resize selected images along the x-axis, while preserving 3D ratio.
	 (equivalent to shortcut command 'r3dx').

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

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

       r3dy:
	   Shortcut for command 'resize3dy'.

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

	 Resize selected images along the y-axis, while preserving 3D ratio.
	 (equivalent to shortcut command 'r3dy').

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

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

       r3dz:
	   Shortcut for command 'resize3dz'.

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

	 Resize selected images along the z-axis, while preserving 3D ratio.
	 (equivalent to shortcut command 'r3dz').

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

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

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

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

	 Default  values:  'interpolation=1',  'boundary_conditions=0' and 'cen-
     ter_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:
	   y0[%],_y1[%]

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

	 Default value: 'y1=y0'.

	 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 interpolation,
	 as described in  https://en.wikipedia.org/wiki/Directional_Cubic_Convo-
     lution_Interpolation.

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

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

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

	 Resize selected images with specified 2D geometry, using the seam-carv-
     ing algorithm.

	 Default values: 'height=100%', 'is_priority_channel=0',  'is_antialias-
     ing=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 interpola-
     tion 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:
	   z0[%],_z1[%]

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

	 Default value: 'z1=z0'.

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

	 Sort pixel values of selected images.
	 If 'axis' is specified, the sorting is done according to  the	data  of
     the first column/row/slice/channel
	 of selected images.

	 Default values: 'ordering=+' and 'axis=(undefined)'.

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

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

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

	 Split selected images along specified axes, or regarding to a	sequence
     of scalar values
	 (optionally along specified axes too).
	 (equivalent to shortcut command 's').

	 'split_mode'  can  be { 0=split according to constant values | >0=split
     in N parts | <0=split in parts of size -N }.

	 Default value: 'split_mode=-1'.

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

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

	 Split selected images as a MxN array of tiles.
	 If M or N is negative, it stands for the tile size instead.

	 Default values: 'N=M' and 'is_homogeneous=0'.

	 Example:
	   [#1] image.jpg +local  split_tiles  5,4  blur  3,0  sharpen	700  ap-
     pend_tiles 4,5 done

       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 mul-
     tiple 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,_anisotropy=[0,1],sharpen-
     ing>=0

	 Upscale selected images with an edge-preserving algorithm.

	 Default   values:    'height=100%',	'depth=100%',	 'smoothness=2',
     'anisotropy=0.4' and 'sharpening=10'.

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

       warp (+):
	   [warping_field],_mode,_interpolation,_boundary_condi-
     tions,_nb_frames>0

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

	 Default  values:  'mode=0',  'interpolation=1', 'boundary_conditions=0'
     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/oldtutorial/_warp

       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 keypoints
     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/oldtutorial/_bandpass

       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) bilateral
     filtering.
	 If a guide image is provided, it is used for drive the  smoothing  fil-
     ter.
	 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 }

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

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

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

	 'boundary_conditions' can be { 0=dirichlet | 1=neumann |  2=periodic  |
     3=mirror }.
	 'kernel' can be { 0=deriche | 1=gaussian }.
	 When specified, argument 'axes' is a sequence of { x | y | z | c }.
	 Specifying one axis multiple times apply also the blur multiple times.

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

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

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

       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/oldtutorial/_blur_angular

       blur_bloom:
	   _amplitude>=0,_ratio>=0,_nb_iter>=0,_blend_operator={  +  | max | min
     },_kernel={ 0=deriche | 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_opera-
     tor=+', 'kernel=1', 'normalize_scales=0' and 'axes=(all)'

	 Example:
	   [#1] image.jpg blur_bloom ,

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

	 Apply	linear	blur on selected images, with specified angle and ampli-
     tudes.

	 Default values: 'amplitude2=0', 'angle=0' and 'boundary_conditions=1'.

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

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

       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/oldtutorial/_blur_radial

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

	 Blur selected images using selective gaussian scales.

	 Default values: 'sigma=5', 'edges=0.5' and 'nb_scales=5'.

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

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

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

	 Blur selected images along the x-axis.

	 Default value: 'boundary_conditions=1'.

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

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

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

	 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/oldtutorial/_blur_y

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

	 Blur selected images along the X, Y and Z axes.

	 Default value: 'boundary_conditions=1'.

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

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

	 Blur selected images along the y-axis.

	 Default value: 'boundary_conditions=1'.

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

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

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

	 Blur selected images along the z-axis.

	 Default value: 'boundary_conditions=1'.

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

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

	 Blur  selected images by a box filter of specified size (fast recursive
     implementation).
	 'order' can be { 0=smooth | 1=1st-derivative | 2=2nd-derivative }.
	 'boundary_conditions' can be { 0=dirichlet | 1=neumann |  2=periodic  |
     3=mirror }.
	 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

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

	 Apply morphological closing to selected images.
	 'boundary_conditions' can be { 0=dirichlet | 1=neumann |  2=periodic  |
     3=mirror }.

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

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

       closing_circ:
	   _size>=0,_is_real={ 0 | 1 }

	 Apply circular dilation of selected images by specified size.

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

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

       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,
	     interpolation_type

	 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
     }.
	 'interpolation_type' can be { 0=nearest-neighbor | 1=linear }.

	 Default   values:  'boundary_conditions=1',  'is_normalized=0',  'chan-
     nel_mode=1',   'xcenter=ycenter=zcenter=(undefined)',    'xstart=ystart=zs-
     tart=0',
	  'xend=yend=zend=(max-coordinates)', 'xstride=ystride=zstride=1', 'xdi-
     lation=ydilation=zdilation=1' and 'interpolation_type=0'.

	 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/oldtutorial/_convolve

       convolve_fft:
	   [mask],_boundary_conditions

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

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

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

	 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
     }.
	 'interpolation_type' can be { 0=nearest-neighbor | 1=linear }.

	 Default  values:  'boundary_conditions=1',  'is_normalized=0',   'chan-
     nel_mode=1', 'xcenter=ycenter=zcenter=-1', 'xstart=ystart=zstart=0',
	  'xend=yend=zend=(max-coordinates)', 'xstride=ystride=zstride=1', 'xdi-
     lation=ydilation=zdilation=1' and 'interpolation_type=0'.

	 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, optionally
     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/oldtutorial/_dct-and-idct

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

	 Deblur image using a regularized Jansson-Van Cittert algorithm.

	 Default values: 'nb_iter=10', 'dt=20', 'regul=0.7' and 'regul_type=1'.

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

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

	 Deblur selected images using Gold-Meinel algorithm

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

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

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

	 Deblur selected images using Richardson-Lucy algorithm.

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

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

       deconvolve_fft:
	   [kernel],_regularization>=0

	 Deconvolve selected images by specified mask in the fourier space.

	 Default value: 'regularization>=0'.

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

       deinterlace:
	   _method={ 0 | 1 }

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

	 Default value: 'method=0'.

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

       denoise (+):
	   [guide],std_deviation_s[%]>=0,_std_devia-
     tion_r[%]>=0,_patch_size>0,_lookup_size>0,_smoothness,_fast_approx={  0 | 1
     } |
	   std_deviation_s[%]>=0,_std_devia-
     tion_r[%]>=0,_patch_size>0,_lookup_size>0,_smoothness,_fast_approx={ 0 |  1
     }

	 Denoise selected images by non-local patch averaging.

	 Default  values:  'std_deviation_p=10', 'patch_size=5', 'lookup_size=6'
     and 'smoothness=1'.

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

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

	 Denoise selected images  using  haar-wavelet  thresholding  with  cycle
     spinning.
	 Set  'nb_scales==0'  to  automatically  determine the optimal number of
     scales.

	 Default values: 'threshold=1.4', 'nb_scale=0' and 'cycle_spinning=10'.

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

       denoise_cnn:
	   _noise_type={ 0=soft | 1=heavy | 2=heavy (faster) |	3=poisson+gauss-
     ian | 4=poisson+gaussian2 },_patch_size>0

	 Denoise selected images using a convolutional neural network (CNN).
	 Input value range should be [0,255]. Output value range is [0,255].

	 Default value: 'patch_size=64'.

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

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

	 Denoise selected images using the patch-pca algorithm.

	 Default  values:  'patch_size=7',  'lookup_size=11',  'details=1.8' and
     'spatial_sampling=5'.

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

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

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

	 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/oldtutorial/_deriche

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

	 Dilate  selected  images  by a rectangular or the specified structuring
     element.
	 'boundary_conditions' can be { 0=dirichlet | 1=neumann |  2=periodic  |
     3=mirror }.

	 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_real={ 0 | 1 }

	 Apply circular dilation of selected images by specified size.
	 'boundary_conditions'	can  be { 0=dirichlet | 1=neumann | 2=periodic |
     3=mirror }.

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

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

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

	 Apply octagonal dilation of selected images by specified size.

	 Default values: 'boundary_conditions=1' and 'is_real=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 |  2=periodic  |
     3=mirror }.

	 Default   values:   'size_y=size_x',  'size_z=1',  'threshold=255'  and
     'boundary_conditions=1'.

       divergence:

	 Compute divergence of selected vector fields.

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

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

	 Compute difference of gaussian on selected images.

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

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

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

	 Compute the diffusion tensors of selected  images  for  edge-preserving
     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/oldtutorial/_diffusiontensors

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

	 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_real={ 0 | 1 }

	 Apply circular erosion of selected images by specified size.
	 'boundary_conditions' can be { 0=dirichlet | 1=neumann |  2=periodic  |
     3=mirror }.

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

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

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

	 Apply octagonal erosion of selected images by specified size.

	 Default values: 'boundary_conditions=1' and 'is_real=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 | 2=periodic |
     3=mirror }.

	 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 se-
     lected 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 el-
     lipse $w2,$h2,30,30,0,1,0 shift -$w2,-$h2,0,0,2 ifft remove[-1]

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

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

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

	 Compute the gradient components (first derivatives) of selected images,
     along specified axes.
	 (equivalent to shortcut command 'g').

	 'scheme' can be { -1=backward | 0=centered  |	1=forward  |  2=sobel  |
     3=rotation-invariant (default) | 4=deriche | 5=vanvliet }.
	 'boundary_conditions'	can  be { 0=dirichlet | 1=neumann | 2=periodic |
     3=mirror }.
	 (no arg) compute all significant components.

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

	 Example:
	   [#1] image.jpg gradient

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

       gradient_norm:

	 Compute gradient norm of selected images.

	 Example:
	   [#1] image.jpg gradient_norm equalize

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

       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 im-
     ages.
	 See also: ihaar.

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

       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
     },_boundary_conditions |
	   (no arg) :

	 Compute  the hessian components (second derivatives) of selected images
     along specified axes.
	 'boundary_conditions' can be { 0=dirichlet | 1=neumann |  2=periodic  |
     3=mirror }.
	 (no arg) compute all significant components.

	 Default value: 'boundary_conditions=1'.

	 Example:
	   [#1] image.jpg hessian

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

	 Compute  the  inverse discrete cosine transform of selected images, op-
     tionally 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 anyway).

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

	 Tutorial: https://gmic.eu/oldtutorial/_dct-and-idct

       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 se-
     lected images.
	 optionally along the specified axes only.
	 See also: fft.

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

       ihaar:
	   scale>0

	 Compute  the  inverse haar multiscale wavelet transform of selected im-
     ages.
	 See also: haar.

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

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

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

	 Default   values:   'nb_iterations=0'	and  '[initial_estimated]=(unde-
     fined)'.

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

       inn:

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

	 Example:
	   [#1] image.jpg inn

       inpaint (+):
	   [mask] |
	   [mask],0,_fast_method |
	   [mask],_patch_size>=1,_lookup_size>=1,_lookup_factor>=0,_lookup_in-
     crement!=0,_blend_size>=0,0<=_blend_threshold<=1,_blend_de-
     cay>=0,_blend_scales>=1,_is_blend_outer={ 0 | 1 }

	 Inpaint selected images by specified mask.
	 If no patch size (or 0) is specified, inpainting is done using  a  fast
     average or median algorithm.
	 Otherwise,  it  used  a  patch-based reconstruction method, that can be
     very time consuming.
	 'fast_method' can be { 0=low-connectivity average | 1=high-connectivity
     average | 2=low-connectivity median | 3=high-connectivity median }.

	 Default  values:  'patch_size=0',  'fast_method=1',   'lookup_size=22',
     'lookup_factor=0.5',  'lookup_increment=1',  'blend_size=0', 'blend_thresh-
     old=0',
	  'blend_decay=0.05', 'blend_scales=10' and 'is_blend_outer=1'.

	 Example:
	   [#1]  image.jpg  100%,100%  ellipse	 50%,50%,30,30,0,1,255	 ellipse
     20%,20%,30,10,0,1,255 +inpaint[-2] [-1] remove[-2]
	   [#2]   image.jpg   100%,100%   circle  30%,30%,30,1,255,0,255  circle
     70%,70%,50,1,255,0,255 +inpaint[0] [1],5,15,0.5,1,9,0 remove[1]

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

	 Inpaint selected images by specified mask using a multiscale transport-
     diffusion algorithm.
	 If  'diffusion  type==3',  non-zero values of the mask (e.g. a distance
     function) are used
	 to guide the diffusion process.

	 Default  values:  'nb_scales=75%',   'diffusion_type=1'   and	 'diffu-
     sion_iter=20'.

	 Example:
	   [#1]   image.jpg  100%,100%	ellipse[-1]  30%,30%,40,30,0,1,255  +in-
     paint_pde[0] [1]

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

	 Apply iteration of the inpainting flow on selected images.

	 Default values: 'nb_global_iter=10', 'nb_local_iter=100', 'dt=5',  'al-
     pha=1' and 'sigma=3'.

	 Example:
	   [#1]   image.jpg   100%,100%  ellipse[-1]  30%,30%,40,30,0,1,255  in-
     paint_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_connectiv-
     ity=0'.

	 Example:
	   [#1] image.jpg noise 5%,2 +inpaint_holes 8,40

       inpaint_morpho:
	   [mask]

	 Inpaint selected images by specified mask  using  morphological  opera-
     tors.

	 Example:
	   [#1]   image.jpg  100%,100%	ellipse[-1]  30%,30%,40,30,0,1,255  +in-
     paint_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_al-
     ready_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_al-
     ready_initialized=0'.

	 Example:
	   [#1]   image.jpg  100%,100%	ellipse[-1]  30%,30%,40,30,0,1,255  +in-
     paint_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 equa-
     tion.

	 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 struc-
     turing 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_bandwidth>0,_patch_mea-
     sure_command

	 Apply non local means denoising of Buades et al, 2005. on selected  im-
     ages.
	 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_band-
     width=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_bandwidth>0

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

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

	 Normalize selected images locally.

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

	 Example:
	   [#1] image.jpg normalize_local 8,10

       normalized_cross_correlation:
	   [mask]

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

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

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

	 Apply morphological opening to selected images.
	 'boundary_conditions' can be { 0=dirichlet | 1=neumann |  2=periodic  |
     3=mirror }.

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

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

       opening_circ:
	   _size>=0,_is_real={ 0 | 1 }

	 Apply circular opening of selected images by specified size.

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

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

       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  speci-
     fied destination.

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

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

	 Apply iterations of a generic PDE flow on selected images.

	 Default values: 'nb_iter=10', 'dt=30', 'velocity_command=laplacian' and
     'keep_sequence=0'.

	 Example:
	   [#1] image.jpg +pde_flow 20

       periodize_poisson:

	 Periodize selected images using a Poisson solver in Fourier space.

	 Example:
	   [#1] image.jpg +periodize_poisson array 2,2,2

       rbf:
	   dx,_x0,_x1,_phi(r) |
	   dx,dy,_x0,_y0,_x1,_y1,_phi(r) |
	   dx,dy,dz,x0,y0,z0,x1,y1,z1,phi(r)

	 Reconstruct  1D/2D or 3D image from selected sets of keypoints, by RBF-
     interpolation.
	 A set of keypoints is represented by a vector-valued image, where  each
     pixel represents a single keypoint.
	 Vector components of a keypoint have the following meaning:
	    -  For 1D reconstruction: [ x_k, f1(k),...fN(k) ].
	    -  For 2D reconstruction: [ x_k,y_k, f1(k),...,fN(k) ].
	    -  For 3D reconstruction: [ x_k,y_k,z_k, f1(k),...,fN(k) ].
	 Values  'x_k','y_k'  and  'z_k' are the spatial coordinates of keypoint
     'k'.
	 Values 'f1(k),..,fN(k)' are the 'N' components of the vector  value  of
     keypoint 'k'.
	 The  command  reconstructs an image with specified size 'dx'x'dy'x'dz',
     with 'N' channels.

	 Default  values:   'x0=y0=z0=0',   'x1=dx-1',	 'y1=dy-1',   'z1=dz-1',
     'phi(r)=r^2*log(1e-5+r)'.

	 Example:
	   [#1]  sp colorful r2dx 400 100%,100% noise_poissondisk. 10 1,{is},1,5
     eval[-2]  "begin(p=0);i?(I[#-1,p++]=[x,y,I(#0)])"	to_rgb[1]  mul[0,1]  di-
     late_circ[0] 5 +rbf[-1] {0,[w,h]} c[-1] 0,255
	   [#2] 32,1,1,5,u([400,400,255,255,255]) rbf 400,400 c 0,255

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

	 Attenuate red-eye effect in selected images.

	 Default values: 'threshold=75', 'smoothness=3.5' and 'attenuation=0.1'.

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

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

	 Remove hot pixels in selected images.

	 Default values: 'mask_size=3' and 'threshold=10%'.

	 Example:
	   [#1] image.jpg noise 10,2 +remove_hotpixels ,

       remove_pixels:
	   number_of_pixels[%]>=0

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

	 Example:
	   [#1] image.jpg +remove_pixels 50%

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

	 Apply the rolling guidance filter on selected image.
	 Rolling guidance filter is a fast image abstraction  filter,  described
     in:
	 "Rolling  Guidance  Filter",  Qi Zhang Xiaoyong, Shen Li, Xu Jiaya Jia,
     ECCV'2014.

	 Default values: 'std_deviation_s=4', 'std_deviation_r=10'  and  'preci-
     sion=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 methods.
	 'edge' must be specified to enable shock-filter method.

	 Default values: 'edge=0', '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,_interpolation,_fast_approx={ 0 |
     1 } |
	   nb_iterations>=0,_sharpness>=0,_anisotropy,_alpha,_sigma,_dt>0,0 |
	   [tensor_field],_amplitude>=0,_dl>0,_da>0,_precision>0,_interpola-
     tion,_fast_approx={ 0 | 1 } |
	   [tensor_field],_nb_iters>=0,_dt>0,0

	 Smooth  selected  images  anisotropically  using  diffusion PDE's, with
     specified field of
	 diffusion tensors.
	 'interpolation' can be { 0=nearest | 1=linear | 2=runge-kutta }.

	 Default   values:   'sharpness=0.7',	'anisotropy=0.3',   'alpha=0.6',
     'sigma=1.1', 'dl=0.8', 'da=30', 'precision=2', 'interpolation=0' and
	  'fast_approx=1'.

	 Example:
	   [#1] image.jpg repeat 3 smooth 40,0,1,1,2 done
	   [#2]  image.jpg  100%,100%,1,2  rand[-1] -100,100 repeat 2 smooth[-1]
     100,0.2,1,4,4 done warp[0] [-1],1,1,1

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

       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 algorithm.
	 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 deviations.

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

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

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

       solidify:
	   _smoothness[%]>=0,_diffusion_type={ 0=isotropic | 1=Delaunay-guided |
     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 append c +so-
     lidify , display_rgba

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

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

	 Default values: 'width=height=100%'.

	 Example:
	   [#1] image.jpg crop 2,282,50,328 +syntexturize 320,320

       syntexturize_matchpatch:
	   _width[%]>0,_height[%]>0,_nb_scales>=0,_patch_size>0,_blend-
     ing_size>=0,_precision>=0

	 Resynthetize 'width'x'height' versions of selected micro-textures using
     a patch-matching algorithm.
	 If 'nbscales==0', the number of scales used is estimated from the image
     size.

	 Default  values:  'width=height=100%',  'nb_scales=0',  'patch_size=7',
     'blending_size=5' and 'precision=1'.

	 Example:
	   [#1] image.jpg crop 25%,25%,75%,75% syntexturize_matchpatch 512,512

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

	 Apply iterations of the total variation flow on selected images.

	 Default values: 'nb_iter=10', 'dt=30' and 'keep_sequence=0'.

	 Example:
	   [#1] image.jpg +tv_flow 40

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

	 Apply unsharp mask on selected images.

	 Default values: 'amount=2' and 'threshold=0'.

	 Example:
	   [#1] image.jpg blur 3 +unsharp 1.5,15 cut 0,255

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

	 Apply octave sharpening on selected images.

	 Default  values:  'nb_scales=4',  'radius=1',	'amount=2'  and '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 |  2=periodic  |
     3=mirror }.

	 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 im-
     ages.

	 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!"  +display_fft  re-
     move[-3,-1] normalize 0,255 append[-4,-2] y append[-2,-1] y

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

	 Compute the watershed transform of selected images.

	 Default value: 'is_high_connectivity=1'.

	 Example:
	   [#1] 400,400 noise 0.2,2 eq 1 +distance 1 mul[-1] -1 label[-2] water-
     shed[-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/oldtutorial/_area

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

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

	 Default values: 'is_high_connectivity=0'.

	 Example:
	   [#1] image.jpg luminance stencil[-1] 1 +area_fg 0

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

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

	 Example:
	   [#1]      image.jpg	    +at_line	  0,0,0,100%,100%,0	 line[0]
     0,0,100%,100%,1,0xFF00FF00,255,0,0

       at_quadrangle:
	   x0[%],y0[%],x1[%],y1[%],x2[%],y2[%],x3[%],y3[%],_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 +el-
     lipse[-2] {@0,1},5,5,0,10

       delaunay:
	   _output_type={ 0=image | 1=coordinates/triangles }

	 Generate discrete 2D Delaunay triangulation of non-zero pixels  in  se-
     lected 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 100%,100% noise. 2,2 eq. 1 delaunay. +blend shapeaver-
     age0

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

	 Detect  skin in selected color images and output an appartenance proba-
     bility 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 tar-
     get 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', 'itera-
     tion_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.  ac-
     cording 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 dis-
     tance[0] 1,0 mod 32 threshold 16 append c

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

       fftpolar:

	 Compute fourier  transform  of  selected  images,  as	centered  magni-
     tude/phase images.

	 Example:
	   [#1] image.jpg fftpolar ellipse 50%,50%,10,10,0,1,0 ifftpolar

       histogram (+):
	   nb_levels>0[%],_min_value[%],_max_value[%]

	 Compute the histogram of selected images.
	 If  value  range  is set, the histogram is estimated only for pixels in
     the specified
	 value range. Argument 'max_value' must be specified if  'min_value'  is
     set.

	 Default values: 'min_value=0%' and 'max_value=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  display_graph
     400,300,3

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

	 Compute the histogram of each vector-valued point of selected images.
	 If  value  range  is set, the histogram is estimated only for values in
     the specified
	 value range.

	 Default values: 'value0=0%' and 'value1=100%'.

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

	 Compute hough transform (theta,rho) of selected images.

	 Default values:  'width=512',	'height=width'	and  'gradient_norm_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.

       img2patches:
	   patch_size>0,_overlap[%]>0,_boundary_conditions

	 Decompose  selected  2D  images into (possibly overlapping) patches and
     stack them along the z-axis.
	 'overlap' must be in range '[0,patch_size-1]'.
	 'boundary_conditions' can be { 0=dirichlet | 1=neumann |  2=periodic  |
     3=mirror }.

	 Default values: 'overlap=0' and 'boundary_conditions=0'.
	 See also: patches2img.
	 image.jpg img2patches 64

       isophotes:
	   _nb_levels>0

	 Render isophotes of selected images on a transparent background.

	 Default value: 'nb_levels=64'

	 Example:
	   [#1] image.jpg blur 2 isophotes 6 dilate_circ 5 display_rgba

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

	 Label connected components in selected images.

	 Default    values:    'tolerance=0',	 'is_high_connectivity=0'    and
     'is_L2_norm=1'.

	 Example:
	   [#1] image.jpg luminance threshold 60% label normalize 0,255 map 0
	   [#2] 400,400 set 1,50%,50% distance 1 mod 16 threshold  8  label  mod
     255 map 2

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

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

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

	 Default value: 'is_high_connectivity=0'.

       laar:

	 Extract  the  largest	axis-aligned  rectangle in non-zero areas of se-
     lected images.
	 Rectangle coordinates are returned in status, as a sequence of  numbers
     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 neighborhood 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 neighborhood 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)	minimal_path[-1]
     0,0,0,100%,100%,0 pointcloud[-1] 0 *[-1] 280 to_rgb[-1] ri[-1] [-2],0 or

       mse:
	   [reference]

	 Compute MSE (Mean-Squared Error) between selected images and  specified
     reference image.
	 This  command	does not modify the images, it just returns a value or a
     list of values in the status.

       mse_matrix:

	 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_matrix

       patches2img:
	   width>0,height>0,_overlap[%]>0,_overlap_std[%]

	 Recompose 2D images from their selected patch representations.
	 'overlap' must be in range '[0,patch_size-1]' where 'patch_size' is the
     width/height of the selected image.
	 'overlap_std'	is  the  standard deviation of the gaussian weights used
     for reconstructing overlapping patches.
	 If 'overlap_std' is set to '-1', uniform weights are used  rather  than
     gaussian.

	 Default value: 'overlap=0' and 'overlap_std=-1'.
	 See also: img2patches.
	 image.jpg +img2patches 32,0,3 mirror[-1] xy patches2img[-1] {0,[w,h]}

       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 loca-
     tions.

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

       matchpatch (+):
	   [patch_image],patch_width>=1,_patch_height>=1,_patch_depth>=1,_nb_it-
     erations>=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 be-
     tween patches are less than '-patch_penalization'.

	 Default values: 'patch_height=patch_width', 'patch_depth=1', 'nb_itera-
     tions=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 +dis-
     play_graph[-1] 400,300

       pointcloud:
	   _type = { -X=-X-opacity | 0=binary | 1=cumulative | 2=label	|  3=re-
     trieve 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:
	   [reference],_max_value>0

	 Compute PSNR (Peak Signal-to-Noise Ratio) between selected  images  and
     specified reference image.
	 This  command	does not modify the images, it just returns a value or a
     list of values in the status.

	 Default value: 'max_value=255'.

       psnr_matrix:
	   _max_value>0

	 Compute PSNR (Peak Signal-to-Noise Ratio) matrix between  selected  im-
     ages.

	 Default value: 'max_value=255'.

	 Example:
	   [#1]  image.jpg  +noise  30	+noise[0]  35  +noise[0]  38  cut. 0,255
     +psnr_matrix

       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_std_max_avg<=1,_dilation,_smoothness>=0

	 Estimate bumpmap from binary shape in selected images.

	 Default value:  'resolution=256',  'weight_std_max=0.75',  'dilation=0'
     and 'smoothness=100'.

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

	 Compute  skeleton  of	binary	shapes using distance transform and con-
     strained thinning.

	 Default value: 'boundary_conditions=1'.

	 Example:
	   [#1] shape_cupid 320 +skeleton 0

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

	 Segment selected 2D images with superpixels, using the  SLIC  algorithm
     (Simple Linear Iterative Clustering).
	 Scalar images of increasingly labeled pixels are returned.
	 Reference  paper:  Achanta,  R., Shaji, A., Smith, K., Lucchi, A., Fua,
     P., & 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

	 Compute fields of SSD between selected images and specified patch.
	 Argument 'boundary_conditions' is valid only when 'use_fourier=0'.
	 'boundary_conditions'	can  be { 0=dirichlet | 1=neumann | 2=periodic |
     3=mirror }.

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

	 Example:
	   [#1] image.jpg +crop 20%,20%,35%,35% +ssd_patch[0] [1],0,0

       ssim:
	   [reference],_patch_size>0,_max_value>0

	 Compute the Structural Similarity Index Measure (SSIM) between selected
     images and specified reference image.
	 This command does not modify the images, it just returns a value  or  a
     list of values in the status.
	 When 'downsampling_factor' is specified with a ending '%', its value is
     equal to '1+(patch_size-1)*spatial_factor%'.

	 SSIM is a measure introduced int the following paper:
	 Wang, Zhou, et al., "Image quality assessment: from error visibility to
     structural similarity.",
	 in IEEE transactions on image processing 13.4 (2004): 600-612.

	 The  implementation of this command is a direct translation of the ref-
     erence code (in Matlab), found at :
	 https://ece.uwaterloo.ca/~z70wang/research/ssim/

	 Default values: 'patch_size=11', and 'max_value=255'.

       ssim_matrix:
	   _patch_size>0,_max_value>0

	 Compute SSIM (Structural Similarity Index Measure) matrix  between  se-
     lected images.

	 Default values: 'patch_size=11', and 'max_value=255'.

	 Example:
	   [#1]  image.jpg  +noise  30	+noise[0]  35  +noise[0]  38  cut. 0,255
     +ssim_matrix

       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	selected
     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,_pat-
     tern,_color1,...

	 Draw specified arrow on selected images.
	 'pattern'  is	an  hexadecimal  number  starting with '0x' which can be
     omitted
	 even if a color is specified. If a pattern is specified, the arrow is
	 drawn outlined instead of filled.

	 Default values: 'thickness=1%', 'head_length=10%', 'head_thickness=3%',
     'opacity=1', 'pattern=(undefined)' and 'color1=0'.

	 Example:
	   [#1] 	 400,400,1,3	      repeat	      100	   arrow
     50%,50%,{u(100)}%,{u(100)}%,3,20,10,0.3,${-rgb} done

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

	 Draw xy-axes on selected images.
	 'pattern'  is	an  hexadecimal  number  starting with '0x' which can be
     omitted
	 even if a color is specified.
	 To draw only one x-axis at row Y, set both 'y0' and 'y1' to Y.
	 To draw only one y-axis at column X, set both 'x0' and 'x1' to X.

	 Default values:  'font_height=14',  'opacity=1',  'pattern=(undefined)'
     and 'color1=0'.

	 Example:
	   [#1] 400,400,1,3,255 axes -1,1,1,-1

       ball:
	   _size>0,		       _R,_G,_B,0<=_specular_light<=8,0<=_specu-
     lar_size<=8,_shadow>=0

	 Input a 2D RGBA colored ball sprite.

	 Default values: 'size=64', 'R=255', 'G=R', 'B=R', 'specular_light=0.8',
     'specular_size=1' and 'shading=1.5'.

	 Example:
	   [#1] repeat 9 { ball {1.5^($>+2)},${-rgb} } 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',  'opac-
     ity=1', 'color1=0' and 'color2=255'.

	 Example:
	   [#1] image.jpg chessboard 32,32,0,0,25,0.3,255,128,0,0,128,255

       cie1931:

	 Draw CIE-1931 chromaticity diagram on selected images.

	 Example:
	   [#1] 500,400,1,3 cie1931

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

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

	 Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.

	 Example:
	   [#1] 	 image.jpg	    repeat	    300 	  circle
     {u(100)}%,{u(100)}%,{u(30)},0.3,${-rgb} done circle 50%,50%,100,0.7,255

       close_binary:
	   0<=_endpoint_rate<=100,_endpoint_connectivity>=0,_spline_dist-
     max>=0,_segment_distmax>=0,0<=_spline_anglemax<=180,_spline_round-
     ness>=0,_area_min>=0,_allow_self_intersection={ 0 | 1 }

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

	 Default    values:    'endpoint_rate=75',    'endpoint_connectivity=2',
     'spline_distmax=80',	'segment_distmax=20',	   'spline_anglemax=90',
     'spline_roundness=1',
	  'area_min=100', 'allow_self_intersection=1'.

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

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

	 Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.

	 Example:
	   [#1] 	 image.jpg	    repeat	    300 	 ellipse
     {u(100)}%,{u(100)}%,{u(30)},{u(30)},{u(180)},0.3,${-rgb}	 done	 ellipse
     50%,50%,100,100,0,0.7,255

       flood (+):
	   x[%],_y[%],_z[%],_tolerance>=0,_is_high_connectivity={ 0 | 1 },_opac-
     ity,_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	standard
     deviations and orientation.

	 Default values: 'sigma1=3', 'sigma2=sigma1' and 'angle=0'.

	 Example:
	   [#1] 400,400 gaussian 100,30,45

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

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

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

	 Default  values:  'plot_type=1', 'vertex_type=1', 'ymin=ymax=0 (auto)',
     'opacity=1', 'pattern=(undefined)'
	 and 'color1=0'.

	 Example:
	   [#1] image.jpg +rows 50% blur[-1] 3 split[-1] c div[0]  1.5	graph[0]
     [1],2,0,0,0,1,255,0,0	graph[0]      [2],2,0,0,0,1,0,255,0	graph[0]
     [3],2,0,0,0,1,0,0,255 keep[0]

       grid:
	   size_x[%]>=0,size_y[%]>=0,_offset_x[%],_offset_y[%],_opacity,_pat-
     tern,_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,0xCCCCCCCC,128,32,16

       j (+):
	   Shortcut for command 'image'.

       image (+):
	   [sprite],_x[%|~],_y[%|~],_z[%|~],_c[%|~],_opacity,_[opac-
     ity_mask],_max_opacity_mask

	 Draw specified sprite image on selected images.
	 (equivalent to shortcut command 'j').

	 If one of the x,y,z or c argument ends with a '~',  its  value  is  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=(undefined)'
     and 'max_opacity_mask=1'.

	 Example:
	   [#1]   image.jpg  +crop  40%,40%,60%,60%  resize[-1]  200%,200%,1,3,5
     frame[-1] 2,2,0 image[0] [-1],30%,30% keep[0]

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

	 Draw specified colored line on selected images.
	 'pattern' is an hexadecimal number starting  with  '0x'  which  can  be
     omitted
	 even if a color is specified.

	 Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.

	 Example:
	   [#1] image.jpg repeat 500 line 50%,50%,{u(w)},{u(h)},0.5,${-rgb} done
     line 0,0,100%,100%,1,0xCCCCCCCC,255 line 100%,0,0,100%,1,0xCCCCCCCC,255

       thickline:
	   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 thickline {u([w,h,w,h,5])},0.5,${-rgb}
     done

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

	 Draw mandelbrot/julia fractal on selected images.

	 Default  values:  'iteration_max=100',  'is_julia=0',	'c0r=c0i=0'  and
     'opacity=1'.

	 Example:
	   [#1]  400,400  mandelbrot  -2.5,-2,2,2,1024	map  0	+blur  2  eleva-
     tion3d[-1] -0.2

       marble:
	   _image_weight,_pattern_weight,_angle,_amplitude,_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', 'angle=45',
     'amplitude=0', 'sharpness=0.4' and 'anisotropy=0.8',
	 'alpha=0.6', 'sigma=1.1' and 'cut_low=cut_high=0'.

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

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

	 Input maze with specified size.

	 Example:
	   [#1] maze 30,20 negate normalize 0,255

       maze_mask:
	   _cellsize>0

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

	 Example:
	   [#1] 0 text	"G'MIC",0,0,53,1,1  dilate  3  autocrop  0  frame  1,1,0
     maze_mask 8 dilate 3 negate mul 255

       newton_fractal:
	   z0r,z0i,z1r,z1i,_angle,0<=_descent_method<=2,_iteration_max>=0,_con-
     vergence_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_double_sided={
     0 | 1 },_is_zbuffer={ 0  |  1  },_focale,_light_x,_light_y,_light_z,_specu-
     lar_lightness,_specular_shininess

	 Draw specified 3D object on selected images.
	 (equivalent to shortcut command 'j3d').

	 'rendering_mode' can be { 0=dots | 1=wireframe | 2=flat | 3=flat-shaded
     | 4=gouraud-shaded | 5=phong-shaded }.

	 Default  values:  'x=y=z=0',  'opacity=1' and 'is_zbuffer=1'. All other
     arguments take their default values
	 from the 3D environment variables.

	 Example:
	   [#1] image.jpg torus3d 100,10 cone3d 30,-120  add3d[-2,-1]  rotate3d.
     1,1,0,60 object3d[0] [-1],50%,50% keep[0]

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

	 Try to randomly pack as many sprites as possible onto the 'empty' areas
     of an image.
	 Sprites can  be  eventually  rotated  and  scaled  during  the  packing
     process.
	 First	selected  image  is  the  canvas  that	will  be filled with the
     sprites.
	 Its last channel must be a binary mask whose zero values represent  po-
     tential 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 (speci-
     fied as a percentage of the
	 original sprite size).
	 'spacing' can be positive or negative.
	 'precision' tells about the desired number of failed trials before end-
     ing 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/oldtutorial/_plasma

       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', 'alias-
     ing=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 polygon 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 },_opac-
     ity,_color1,...

	 Draw specified 2D vector/orientation field on selected images.

	 Default  values:  'sampling=5%', 'factor=1', 'is_arrow=1', 'opacity=1',
     'pattern=(undefined)'
	 and 'color1=0'.

	 Example:
	   [#1]  100,100,1,2,'if(c==0,x-w/2,y-h/2)'  500,500,1,3,255  quiver[-1]
     [-2],10
	   [#2]  image.jpg +resize2dy 600 luminance[0] gradient[0] mul[1] -1 re-
     verse[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  rectangle
     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} }

       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,1,1	+warp[2]
     [1],2,1,1

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

	 Draw  specified  colored spline curve on selected images (cubic hermite
     spline).

	 Default values: 'opacity=1' and 'color1=0'.

	 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
     }

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

       t (+):
	   Shortcut for command 'text'.

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

	 Draw specified colored text string on selected images.
	 (equivalent to shortcut command 't').

	 If one of the x or y argument ends with a '~', its value is expected to
     be
	 a centering ratio (in [0,1]) rather than a position.
	 Usual centering ratio are { 0=left-justified | 0.5=centered |	1=right-
     justified }.
	 Sizes '13' and '128' are special and correspond to binary fonts (no-an-
     tialiasing).
	 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*$>} }
	   [#2] 0 text "G'MIC",0,0,23,1,255

       to:
	   Shortcut for command 'text_outline'.

       text_outline:
	   text,_x[%|~],_y[%|~],_font_height[%]>0,_outline>=0,_opac-
     ity,_color1,...

	 Draw specified colored and outlined text string on selected images.
	 If one of the x or y argument ends with a '~', its value is expected to
     be
	 a centering ratio (in [0,1]) rather than a position.
	 Usual centering ratio are { 0=left-justified | 0.5=centered |	1=right-
     justified }.

	 Default  values:  'x=y=0.01~',  'font_height=7.5%', 'outline=2', 'opac-
     ity=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/oldtutorial/_turbulence

       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 matrices
     by the Dijkstra algorithm.

       eigen (+):

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

	 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/oldtutorial/_eigen

       eye:
	   _size>0

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

	 Example:
	   [#1] eye 3 eye 7 eye 10

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

       meigen:
	   m>=1

	 Compute an approximation of the 'm' largest eigenvalues  and  eigenvec-
     tors of selected symmetric matrices,
	 using		 the	      Arnoldi	       iteration	  method
     (https://en.wikipedia.org/wiki/Arnoldi_iteration).
	 A larger 'm' goes with better numerical precision.

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

       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 algo-
     rithm.
	 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  projection
     step is performed
		    every 'method-2' iterations.
	 'max_iter' sets the max number of iterations processed for each signal.
	 If  set  to '0' (default), 'max_iter' is equal to the number of columns
     in D.
	 (only meaningful for matching pursuit and its variants).
	 'max_residual' gives a stopping criterion on signal reconstruction  ac-
     curacy.
	 (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 ma-
     trix.

	 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-ma-
     trix.
	 If  the system is under- or over-determined, the least squares solution
     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  specified
     tridiagonal A-matrix.
	 Tridiagonal  matrix must be stored as a 3 column vector, where 2nd col-
     umn 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} } add3d
	   [#2]  repeat 20 { torus3d 15,2 color3d[-1] ${-rgb} mul3d[-1] 0.5,1 if
     $>%2 rotate3d[-1] 0,1,0,90 fi add3d[-1] 70 add3d  rotate3d[-1]  0,0,1,18  }
     double3d 0

       animate3d:
	   nb_frames>0,_step_angle_x,_step_angle_y,_step_angle_z,_zoom_fac-
     tor,0<=_fake_shadow_level<=100,_[background]

	 Generate 3D animation frames of rotating 3D objects.
	 Frames are stacked along the z-axis (volumetric image).
	 Frame	size  is  the  same  as the size of the '[background]' image (or
     800x800 if no background specified).

	 Default values: '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,-15A<degree>),[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_radius[%]>=0

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

	 Default values: 'radius=5%', 'head_length=25%' and 'head_radius=15%'.

	 Example:
	   [#1]       repeat	   10	    {	    a={$>*2*pi/10}	 arrow3d
     0,0,0,{cos($a)},{sin($a)},-0.5 } +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 orientations.

	 Default values: 'size_x=size_y=size_z=1', 'font_size=23',  'label_x=X',
     'label_y=Y', 'label_z=Z' and 'is_origin=1'

	 Example:
	   [#1] axes3d ,

       boundingbox3d:

	 Replace selected 3D objects by their 3D bounding boxes.

	 Example:
	   [#1] torus3d 100,30 +boundingbox3d +3d[-1] [-2]

       box3d:
	   _size_x,_size_y,_size_z

	 Input 3D box at (0,0,0), with specified geometry.

	 Default values: 'size_x=1' and 'size_z=size_y=size_x'.

	 Example:
	   [#1] box3d 100,40,30 +primitives3d 1 color3d[-2] ${-rgb}

       c3d:
	   Shortcut for command 'center3d'.

       center3d:

	 Center selected 3D objects at (0,0,0).
	 (equivalent to shortcut command 'c3d').

	 Example:
	   [#1]  repeat  100  {  circle3d  {u(100)},{u(100)},{u(100)},2  } 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 } add3d

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

	 Convert  specified  3D objects to sets of 3D circles with specified ra-
     dius.

	 Default values: 'radius=1' and 'is_wireframe=1'.

	 Example:
	   [#1] image.jpg luminance resize2dy 40  threshold  50%  *  255  point-
     cloud3d color3d[-1] 255,255,255 circles3d 0.7

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

       color3d (+):
	   R,_G,_B,_opacity |
	   (no arg)

	 Set color and opacity of selected 3D objects.
	 (equivalent to shortcut command 'col3d').

	 Default value: 'B=G=R' and 'opacity=(undefined)'.

	 Example:
	   [#1]  torus3d  100,10  double3d  0  repeat 7 { +rotate3d[-1] 1,0,0,20
     color3d[-1] ${-rgb} } add3d

       colorcube3d:

	 Input 3D color cube.

	 Example:
	   [#1] colorcube3d mode3d 2 +primitives3d 1

       cone3d:
	   _radius,_height,_nb_subdivisions>0

	 Input 3D cone at (0,0,0), with specified geometry.

	 Default value: 'radius=1','height=1' and 'nb_subdivisions=24'.

	 Example:
	   [#1] cone3d 10,40 +primitives3d 1 color3d[-2] ${-rgb}

       cubes3d:
	   _size>=0

	 Convert specified 3D objects to sets of 3D cubes with specified size.

	 Default value: 'size=1'.

	 Example:
	   [#1] image.jpg luminance resize2dy 40  threshold  50%  *  255  point-
     cloud3d color3d[-1] 255,255,255 cubes3d 1

       cup3d:
	   _resolution>0

	 Input 3D cup object.

	 Default value: 'resolution=128'.

	 Example:
	   [#1] cup3d ,

       cylinder3d:
	   _radius,_height,_nb_subdivisions>0

	 Input 3D cylinder at (0,0,0), with specified geometry.

	 Default value: 'radius=1','height=1' and 'nb_subdivisions=24'.

	 Example:
	   [#1] cylinder3d 10,40 +primitives3d 1 color3d[-2] ${-rgb}

       delaunay3d:

	 Generate 3D Delaunay triangulations from selected images.
	 One assumes that the selected input images are binary images containing
     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=1'.

	 Example:
	   [#1]  torus3d  5,2  repeat  5  {  +add3d[-1]  12,0,0  div3d[-1]   1.2
     color3d[-1] ${-rgb} } add3d

       db3d (+):
	   Shortcut for command 'double3d'.

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

	 Enable/disable double-sided mode for 3D rendering.
	 (equivalent to shortcut command 'db3d').

	 Default value: 'is_double_sided=1'.

	 Example:
	   [#1]  mode3d  1  repeat 2 { torus3d 100,30 rotate3d[-1] 1,1,0,60 dou-
     ble3d $> snapshot3d[-1] 400 }

       elevation3d:
	   { z-factor | [elevation_map] | 'formula' },base_height={ -1 | >=0 } |
	   (no arg)

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

	 Example:
	   [#1] image.jpg +blur 5 elevation3d. 0.75
	   [#2] 128,128,1,3,u(255) plasma 10,3 blur 4 sharpen 10000 n 0,255 ele-
     vation3d[-1]
     'X=(x-64)/6;Y=(y-64)/6;-100*exp(-(X^2+Y^2)/30)*abs(cos(X)*sin(Y))'

       empty3d:

	 Input empty 3D object.

	 Example:
	   [#1] empty3d

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

	 Generate extruded 3D object from selected binary XY-profiles.

	 Default values: 'depth=16', 'resolution=1024' and 'smoothness=0.5%'.

	 Example:
	   [#1] image.jpg threshold 50% extrude3d 16

       f3d (+):
	   Shortcut for command 'focale3d'.

       focale3d (+):
	   focale

	 Set 3D focale.
	 (equivalent to shortcut command 'f3d').

	 Set 'focale' to 0 to enable parallel projection  (instead  of	perspec-
     tive).
	 Set negative 'focale' will disable 3D sprite zooming.

	 Default value: 'focale=700'.

	 Example:
	   [#1] repeat 5 { torus3d 100,30 rotate3d[-1] 1,1,0,60 focale3d {$<*90}
     snapshot3d[-1] 400 } remove[0]

       gaussians3d:
	   _size>0,_opacity

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

	 Example:
	   [#1]  image.jpg  r2dy  32  distribution3d  gaussians3d 20 colorcube3d
     primitives3d[-1] 1 +3d

       gmic3d:

	 Input a 3D G'MIC logo.

	 Example:
	   [#1] gmic3d +primitives3d 1

       gyroid3d:
	   _resolution>0,_zoom

	 Input 3D gyroid at (0,0,0), with specified resolution.

	 Default values: 'resolution=32' and 'zoom=5'.

	 Example:
	   [#1] gyroid3d 48 +primitives3d 1

       histogram3d:

	 Get 3D color histogram of selected images.

	 Example:
	   [#1] image.jpg resize2dx 64 histogram3d circles3d 3	opacity3d.  0.75
     colorcube3d primitives3d[-1] 1 add3d

       image6cube3d:

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

	 Example:
	   [#1] image.jpg animate flower,"30,0","30,5",6 image6cube3d

       imageblocks3d:
	   _maximum_elevation,_smoothness[%]>=0

	 Generate 3D blocks from selected images.
	 Transparency of selected images is taken into account.

	 Default values: 'maximum_elevation=10' and 'smoothness=0'.

	 Example:
	   [#1] image.jpg resize2dy 32 imageblocks3d -20 mode3d 3

       imagecube3d:

	 Generate 3D mapped cubes from selected images.

	 Example:
	   [#1] image.jpg imagecube3d

       imageplane3d:

	 Generate 3D mapped planes from selected images.

	 Example:
	   [#1] image.jpg imageplane3d

       imagepyramid3d:

	 Generate 3D mapped pyramids from selected images.

	 Example:
	   [#1] image.jpg imagepyramid3d

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

	 Generate 3D mapped rubik's cubes from selected images.

	 Default values: 'xy_tiles=3', 'xy_shift=5' and 'z_shift=5'.

	 Example:
	   [#1] image.jpg imagerubik3d ,

       imagesphere3d:
	   _resolution1>=3,_resolution2>=3

	 Generate 3D mapped sphere from selected images.

	 Default values: 'resolution1=32' and 'resolutions2=16'.

	 Example:
	   [#1] image.jpg imagesphere3d 32,16

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

	 Extract  3D  isolines with specified value from selected images or from
     specified formula.

	 Default values: 'x0=y0=-3', 'x1=y1=3' and 'size_x=size_y=256'.

	 Example:
	   [#1] image.jpg blur 1 isoline3d 50%
	   [#2] isoline3d 'X=x-w/2;Y=y-h/2;(X^2+Y^2)%20',10,-10,-10,10,10

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

	 Extract 3D isosurfaces with specified value  from  selected  images  or
     from specified formula.

	 Default       values:	     'x0=y0=z0=-3',	  'x1=y1=z1=3'	     and
     'size_x=size_y=size_z=32'.

	 Example:
	   [#1] image.jpg resize2dy 128 luminance  threshold  50%  expand_z  2,0
     blur 1 isosurface3d 50% mul3d 1,1,30
	   [#2] isosurface3d 'x^2+y^2+abs(z)^abs(4*cos(x*y*z*3))',3

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

	 Generate 3D text label.

	 Default values: 'font_height=13', 'opacity=1' and 'color=255,255,255'.

       label_points3d:
	   _label_size>0,_opacity

	 Add a numbered label to all vertices of selected 3D objects.

	 Default values: 'label_size=13' and 'opacity=0.8'.

	 Example:
	   [#1] torus3d 100,40,6,6 label_points3d 23,1 mode3d 1

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

	 Generate 3D object from selected binary XY-profiles.

	 Default   values:   'resolution=128',	'smoothness=0.5%'  and	'max_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 } 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} } add3d

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

	 Input	3D  lissajous  curves  (x(t)=sin(at+A*2pi),  y(t)=sin(bt+B*2pi),
     z(t)=sin(ct+C*2pi)).

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

	 Example:
	   [#1] lissajous3d ,

       m3d (+):
	   Shortcut for command 'mode3d'.

       mode3d (+):
	   _mode

	 Set static 3D rendering mode.
	 (equivalent to shortcut command 'm3d').

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

	 Default value: 'mode=4'.

	 Example:
	   [#1]  (0,1,2,3,4,5) double3d 0 repeat w { torus3d 100,30 rotate3d[-1]
     1,1,0,60 mode3d {0,@$>} snapshot3d[-1] 300 } remove[0]

       md3d (+):
	   Shortcut for command 'moded3d'.

       moded3d (+):
	   _mode

	 Set dynamic 3D rendering mode for interactive 3D viewer.
	 (equivalent to shortcut command 'md3d').

	 'mode' can be { -1=bounding-box |  0=dots  |  1=wireframe  |  2=flat  |
     3=flat-shaded | 4=gouraud-shaded | 5=phong-shaded }.

	 Default value: 'mode=-1'.

       *3d (+):
	   Shortcut for command 'mul3d'.

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

	 Scale selected 3D objects isotropically or anisotropically, with speci-
     fied factors.
	 (equivalent to shortcut command '*3d').

	 Default value: 'factor_z=1'.

	 Example:
	   [#1]   torus3d  5,2	repeat	5  {  +add3d[-1]  10,0,0  mul3d[-1]  1.2
     color3d[-1] ${-rgb} } 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   }   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} } 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,_smooth-
     ness>=0,_isovalue>=0

	 Input 3D object from specified parametric surface  '(a,b)  a<paragraph>
     (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 'iso-
     value=10%'.

	 Example:
	   [#1] parametric3d ,

       pca_patch3d:
	   _patch_size>0,_M>0,_N>0,_normalize_input={ 0  |  1  },_normalize_out-
     put={ 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} } add3d

       pointcloud3d:

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

	 Example:
	   [#1]  image.jpg  luminance resize2dy 100 threshold 50% mul 255 point-
     cloud3d 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  im-
     ages.

       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 } add3d mode3d 2

       random3d:
	   nb_points>=0

	 Input random 3D point cloud in [0,1]^3.

	 Example:
	   [#1] random3d 100 circles3d 0.1 opacity3d 0.5

       rv3d (+):
	   Shortcut for command 'reverse3d'.

       reverse3d (+):

	 Reverse primitive orientations of selected 3D objects.
	 (equivalent to shortcut command 'rv3d').

	 Example:
	   [#1] torus3d 100,40 double3d 0 +reverse3d

       r3d (+):
	   Shortcut for command 'rotate3d'.

       rotate3d (+):
	   u,v,w,angle

	 Rotate  selected  3D objects around specified axis with specified angle
     (in deg.).
	 (equivalent to shortcut command 'r3d').

	 Example:
	   [#1] torus3d 100,10 double3d 0 repeat 7 {  +rotate3d[-1]  1,0,0,20  }
     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 se-
     lected 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,_backgroundA
     |
	   [background_image],zoom>=0

	 Take 2d snapshots of selected 3D objects.
	 Set 'zoom' to 0 to disable object auto-scaling.

	 Default   values:  'size=512',  'zoom=1'  and	'[background_image]=(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 ? +snapshot3d[0] [1],1.2

       sl3d (+):
	   Shortcut for command 'specl3d'.

       specl3d (+):
	   value>=0

	 Set lightness of 3D specular light.
	 (equivalent to shortcut command 'sl3d').

	 Default value: 'value=0.15'.

	 Example:
	   [#1] (0,0.3,0.6,0.9,1.2)  repeat  w	{  torus3d  100,30  rotate3d[-1]
     1,1,0,60 color3d[-1] 255,0,0 specl3d {0,@$>} snapshot3d[-1] 400 } remove[0]

       ss3d (+):
	   Shortcut for command 'specs3d'.

       specs3d (+):
	   value>=0

	 Set shininess of 3D specular light.
	 (equivalent to shortcut command 'ss3d').

	 Default value: 'value=0.8'.

	 Example:
	   [#1]  (0,0.3,0.6,0.9,1.2)  repeat  w  {  torus3d  100,30 rotate3d[-1]
     1,1,0,60 color3d[-1] 255,0,0 specs3d {0,@$>} snapshot3d[-1] 400 } 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*theta))"'.

	 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}  }
     box3d 1 primitives3d[-1] 1 add3d

       s3d (+):
	   Shortcut for command 'split3d'.

       split3d (+):
	   _full_split={ 0 | 1 }

	 Split selected 3D objects into feature vectors :
	  *  If  'full_split==0', { header, sizes, vertices, primitives, colors,
     opacities }.
	  * If 'full_split==1', { header, sizes, vertices, p0,...,pP, c0,...,cP,
     o0,...,oP }.
	 (equivalent to shortcut command 's3d').

	 To recreate the 3D object, append all produced images along the y-axis.

	 Default value: 'full_split=0'.

	 Example:
	   [#1] box3d 100 +split3d

       sprite3d:

	 Convert selected images as 3D sprites.
	 Selected images with alpha channels are managed.

	 Example:
	   [#1] image.jpg sprite3d

       sprites3d:
	   [sprite],_sprite_has_alpha_channel={ 0 | 1 }

	 Convert selected 3D objects as a sprite cloud.
	 Set 'sprite_has_alpha_channel' to 1 to make the last channel of the se-
     lected 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  specified
     formula.
	 'interpolation'  can be { 0=nearest integer | 1=1st-order | 2=2nd-order
     | 3=4th-order }.

	 Default  values:  'dl=0.1',  'interpolation=2',   'is_backward=0'   and
     'is_oriented=0'.

	 Example:
	   [#1]  100,100,100,3	rand -10,10 blur 3 repeat 300 { +streamline3d[0]
     {u(100)},{u(100)},{u(100)},1000,1,1 color3d[-1] ${-rgb} }	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 displacement
     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} } 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 ,

       surfels3d:
	   0<=_left_right_attenuation<=1,0<=_top_bottom_attenua-
     tion<=1,0<=_closer_further_attenuation<=1

	 Convert  selected  images  to	3d objects composed of 3D surfels (or 2D
     edgels for 2D images).
	 Selected images must contain binary shapes, where each value  0  is  an
     exterior voxel, and each value !=0 is an interior voxel.
	 The  resulting  3D object is colored according to the color of non zero
     voxels.

	 Default values: 'left_right_attenuation=1',  'top_bottom_attenuation=1'
     and 'closer_further_attenuation=1'.

	 Example:
	   [#1]  100,100,100  =  1,40%,40%,40% = 1,60%,60%,60% distance 1 lt 30%
     blur 3 gt 50% surfels3d 0.5,0.75,1

       tensors3d:
	   _radius_factor>=0,_shape={ 0=box | >=N=ellipsoid },_radius_min>=0

	 Generate 3D tensor fields from selected images.
	 when 'shape'>0, it gives the ellipsoid shape precision.

	 Default values: 'radius_factor=1', 'shape=2' and 'radius_min=0.05'.

	 Example:
	   [#1] 6,6,6,9,"U =  [x,y,z]  -  [w,h,d]/2;  U/=norm(U);  mul(U,U,3)  +
     0.3*eye(3)" tensors3d 0.8

       text_pointcloud3d:
	   _"text1",_"text2",_smoothness

	 Input 3D text pointcloud from the two specified strings.

	 Default values: 'text1="text1"', 'text2="text2"' and 'smoothness=1'.

	 Example:
	   [#1] text_pointcloud3d "G'MIC","Rocks!"

       text3d:
	   text,_font_height>0,_depth>0,_smoothness

	 Input a 3D text object from specified text.

	 Default values: 'font_height=53', 'depth=10' and 'smoothness=1.5'.

	 Example:
	   [#1] text3d "G'MIC as a0D logo!"

       t3d:
	   Shortcut for command 'texturize3d'.

       texturize3d:
	   [ind_texture],_[ind_coords]

	 Texturize selected 3D objects with specified texture and coordinates.
	 (equivalent to shortcut command 't3d').

	 When  '[ind_coords]'  is omitted, default XY texture projection is per-
     formed.

	 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} } add3d

       volume3d:

	 Transform selected 3D volumetric images as 3D parallelepipedic objects.

	 Example:
	   [#1] image.jpg animate blur,0,5,30 append z volume3d

       weird3d:
	   _resolution>0

	 Input 3D weird object at (0,0,0), with specified resolution.

	 Default value: 'resolution=32'.

	 Example:
	   [#1] weird3d 48 +primitives3d 1 color3d[-2] ${-rgb}

       12.13. Flow Control
	      ------------

       ap:
	   Shortcut for command 'apply_parallel'.

       apply_parallel:
	   "command"

	 Apply specified command on each of the selected images, by  paralleliz-
     ing 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 paralleliz-
     ing 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  paralleliz-
     ing it on 'nb_threads'
	 overlapped sub-images.
	 (equivalent to shortcut command 'apo').

	 'nb_threads' must be a power of 2.

	 Default values: 'overlap=0','nb_threads=0'.

	 Example:
	   [#1] image.jpg +apply_parallel_overlap "smooth 500,0,1",1

       at:
	   Shortcut for command 'apply_tiles'.

       apply_tiles:
	   "command",_tile_width[%]>0,_tile_height[%]>0,_tile_depth[%]>0,_over-
     lap_width[%]>=0,_overlap_height[%]>=0,_overlap_depth[%]>=0,_boundary_condi-
     tions={ 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	 Apply specified command on each tile (neighborhood) of the selected im-
     ages, eventually with overlapping tiles.
	 (equivalent to shortcut command 'at').

	 Default      values:	  'tile_width=tile_height=tile_depth=10%','over-
     lap_width=overlap_height=overlap_depth=0' and 'boundary_conditions=1'.

	 Example:
	   [#1]   image.jpg   +equalize[0]   256    +apply_tiles[0]    "equalize
     256",16,16,1,50%,50%

       apply_timeout:
	   "command",_timeout={  0=no  timeout	|  >0=with specified timeout (in
     seconds) }

	 Apply a command with a timeout.
	 Set variable '$_is_timeout' to '1' if timeout occurred, '0' otherwise.

	 Default value: 'timeout=20'.

       check (+):
	   condition

	 Evaluate specified condition and display an error message if  evaluated
     to false.

       check3d (+):
	   _is_full_check={ 0 | 1 }

	 Check validity of selected 3D vector objects, and display an error mes-
     sage
	 if one of the selected images is not a valid 3D vector object.
	 Full 3D object check is slower but more precise.

	 Default value: 'is_full_check=1'.

       continue (+):

	 Go to end of current 'do...while', 'for...done', 'foreach...done', 'lo-
     cal...done' or 'repeat...done' block.

	 Example:
	   [#1] image.jpg repeat 10 blur 1 if 1==1 continue fi deform 10 done

       break (+):

	 Break	 current   'do...while',  'for...done',  'foreach...done',  'lo-
     cal...done' or 'repeat...done' 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

       } (+):
	   Shortcut for command 'done'.

       done (+):

	 End  a  'for/foreach/local/repeat...done'  block,  and go to associated
     'for/foreach/repeat' if iterations remain.
	 (equivalent to shortcut command '}').

       elif (+):
	   condition

	 Start a 'elif...[else]...fi' block if previous 'if' was not verified
	 and test if specified condition holds
	 'condition' is a mathematical expression, whose  evaluation  is  inter-
     preted as { 0=false | other=true }..

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

       else (+):

	 Execute  following  commands  if  previous  'if'  or  'elif' conditions
     failed.

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

       fi (+):

	 End a 'if...[elif]...[else]...fi' block.
	 (equivalent to shortcut command 'fi').

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

       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 in-
     stead 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 se-
     lected images. Status is not modified.
	   (in	this  latter case, 'eval' is similar to 'fill' without assigning
     the image values).

       x (+):
	   Shortcut for command 'exec'.

       exec (+):
	   _is_verbose={ 0 | 1 },"command"

	 Execute external command using a system call.
	 The status value is then set to the error code returned by  the  system
     call.
	 If  'is_verbose=1',  the  executed command is allowed to output on std-
     out/stderr.
	 (equivalent to shortcut command 'x').

	 Default value: 'is_verbose=1'.

       xo:
	   Shortcut for command 'exec_out'.

       exec_out:
	   _mode,"command"

	 Execute external command using a  system  call,  and  return  resulting
     'stdout' and/or 'stderr'.
	 'mode' can be { 0=stdout | 1=stderr | 2=stdout+stderr }.

       for (+):
	   condition

	 Start a 'for...done' block.

	 Example:
	   [#1]  image.jpg  resize2dy  32  400,400,1,3	x=0  for $x<400 image[1]
     [0],$x,$x x+=40 done

       foreach (+):

	 Start a 'foreach...[onfail]...done' block, that iterates over	all  im-
     ages in the selection, with a separate local environment for each one.

	 Example:
	   [#1]  sample colorful,earth,duck,dog foreach[^2] +blur 10 sub normal-
     ize 0,255 done

       if (+):
	   condition

	 Start a 'if...[elif]...[else]...fi' block and test if specified  condi-
     tion holds.
	 'condition'  is  a  mathematical expression, whose evaluation is inter-
     preted 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

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

       l (+):
	   Shortcut for command 'local'.

       local (+):

	 Start a 'local...[onfail]...done' 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
     done
	   [#2] image.jpg +local repeat 3 { deform 20 } done

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

       mutex (+):
	   index,_action={ 0=unlock | 1=lock }

	 Lock or unlock specified mutex for multi-threaded programming.
	 A locked mutex can be unlocked only by the same thread. All mutexes are
     unlocked by default.
	 'index' designates the mutex index, in [0,255].

	 Default value: 'action=1'.

       noarg (+):

	 Used in a custom command, 'noarg' tells the command that  its	argument
     list have not been used
	 finally, and so they must be evaluated next in the G'MIC pipeline, just
     as if the custom
	 command takes no arguments at all.
	 Use this command to write a custom command which can decide if it takes
     arguments or not.

       onfail (+):

	 Execute  following commands when an error is encountered in the body of
     the 'local...done' block.
	 The status value is set with the corresponding error message.

	 Example:
	   [#1] image.jpg +local blur -3 onfail mirror x done

       parallel (+):
	   _wait_threads,"command1","command2",...

	 Execute specified commands in parallel, each in a different thread.
	 Parallel threads share the list of images.
	 'wait_threads' can be { 0=when current environment ends | 1=immediately
     }.

	 Default value: 'wait_threads=1'.

	 Example:
	   [#1] image.jpg [0] parallel "blur[0] 3","mirror[1] c"

       progress (+):
	   0<=value<=100 |
	   -1

	 Set the progress index of the current processing pipeline.
	 This command is useful only when G'MIC is used by an embedding applica-
     tion.

       q (+):
	   Shortcut for command 'quit'.

       quit (+):

	 Quit G'MIC interpreter.
	 (equivalent to shortcut command 'q').

       repeat (+):
	   nb_iterations

	 Start 'nb_iterations' iterations of a 'repeat...done' block.
	 'nb_iterations' is a mathematical expression that will be evaluated.

	 Example:
	   [#1] image.jpg split y repeat $! n=$> shift[$n] $<,0,0,0,2  done  ap-
     pend y
	   [#2]  image.jpg mode3d 2 repeat 4 imagecube3d rotate3d 1,1,0,40 snap-
     shot3d 400,1.4 done

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

       return (+):

	 Return from current custom command.

       rprogress:
	   0<=value<=100 | -1 | "command",0<=value_min<=100,0<=value_max<=100

	 Set the progress index of the current processing  pipeline  (relatively
     to
	 previously defined progress bounds), or call the specified command with
	 specified progress bounds.

       run:
	   "G'MIC pipeline"

	 Run specified G'MIC pipeline.
	 This is only useful when used from a shell, e.g. to avoid shell substi-
     tutions 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 func-
     tion.
	 (equivalent to shortcut command 'u').

	 Example:
	   [#1] image.jpg command "foo : u0=Dark u1=Bright status ${u{ia>=128}}"
     text_outline ${-foo},2,2,23,2,1,255

       while (+):
	   condition

	 End a 'do...while' block and go back to associated  'do'  if  specified
     condition holds.
	 'condition'  is  a  mathematical expression, whose evaluation is inter-
     preted as { 0=false | other=true }.

       12.14. Neural Networks
	      ---------------

       nn_lib ::

	 Return the list of library functions that has to be included in a  math
     expression,in order to use the neural network library.

       nn_init:

	 Initialize a new network.

       nn_check_layer:
	   name

	 Check that the layer with specified name exists in the network.

       nn_layer_input:
	   name,width,_height,_depth,_spectrum

	 Add an 'input' layer to the network.

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

       nn_layer_add:
	   name,in0,in1

	 Add an 'add' layer to the network.

       nn_layer_append:
	   name,in0,in1

	 Add an 'append' layer to the network.

       nn_layer_avgpool2d:
	   name,in

	 Add a 'avgpool2d' layer (2d average pooling) to the network.

       nn_layer_batchnorm:
	   name,in,_learning_mode.

	 Add a 'batchnorm' layer to the network.
	 'learning_mode'  can  be  {  0=learn  no  parameters  | 1=learn gamma |
     2=learn beta | 3=learn gamma and beta}.

	 Default value: 'learning_mode=3'.

       nn_layer_clone:
	   name0,name1,in

	 Add a 'clone' layer to the network.

       nn_layer_conv2d:
	   name,in,nb_channels>0,_kernel_size>0,_stride>0,_dila-
     tion,_is_learned={ 0 | 1 }

	 Add a 'conv2d' layer (2D convolutional layer) to the network.

	 Default   values:   'kernel_size=3',	'stride=1',   'dilation=1'   and
     'is_learned=1'.

       nn_layer_conv2dbnnl:
	   name,in,nb_channels>0,_kernel_size>0,_stride>0,_dilation>0,_activa-
     tion,_is_learned={ 0 | 1 }

	 Add a 'con2dbnnl' (2D convolutional layer followed by a batchnorm, then
     a non-linearity), to the network.

	 Default  values:  'kernel_size=3',  'stride=1',  'dilation=1', 'activa-
     tion=leakyrelu' and 'is_learned=1'.

       nn_layer_conv2dnl:
	   name,in,nb_channels>0,_kernel_size>0,_stride>0,_dilation>0,_activa-
     tion,_is_learned={ 0 | 1 }

	 Add a 'con2dnl' (2D convolutional layer followed by  a  non-linearity),
     to the network.

	 Default  values:  'kernel_size=3',  'stride=1',  'dilation=1', 'activa-
     tion=leakyrelu' and 'is_learned=1'.

       nn_layer_resconv2d:
	   name,in,_kernel_size>0,_stride>0,_dilation>0,_is_learned={ 0 | 1 }

	 Add a 'rescon2d' (residual 2D convolutional layer), to the network.

	 Default   values:   'kernel_size=3',	'stride=1',   'dilation=1'   and
     'is_learned=1'.

       nn_layer_resconv2dnl:
	   name,in,_kernel_size>0,_stride>0,_dilation>0,_activa-
     tion,_is_learned={ 0 | 1 }

	 Add  a 'rescon2dnl' (residual 2D convolutional layer followed by a non-
     linearity), to the network.

	 Default  values:  'kernel_size=3',  'stride=1',  'dilation=1',  activa-
     tion='leakyrelu' and 'is_learned=1'.

       nn_layer_crop:
	   name,in,x0,y0,z0,x1,y1,z1

	 Add a 'crop' layer to the network.

       nn_layer_fc:
	   name,in,nb_channels>0,_is_learned={ 0 | 1 }

	 Add a 'fc' layer (fully connected layer) to the network.

	 Default value: 'is_learned=1'.

       nn_layer_fcbnnl:
	   name,in,nb_neurons>0,_activation,_is_learned={ 0 | 1 }

	 Add a 'fcbnnl' layer (fully connected layer followed by batchnorm, then
     a non-linearity), to the network.

	 Default value: 'activation=leakyrelu' and 'is_learned=1'.

       nn_layer_fcnl:
	   name,in,nb_neurons>0,_activation,_is_learned={ 0 | 1 }

	 Add a 'fcnl' layer (fully connected layer followed by a non-linearity),
     to the network.

	 Default value: 'activation=leakyrelu' and 'is_learned=1'.

       nn_layer_maxpool2d:
	   name,in

	 Add a 'maxpool2d' layer (2d max pooling) to the network.

       nn_layer_nl:
	   name,in,_activation

	 Add a 'nl' (nonlinearity) layer to the network.
	 'activation'  can be { elu | gelu | leakyrelu | linear | relu | sigmoid
     | softmax | sqr | sqrt | swish | tanh }.

	 Default value: 'activation=leakyrelu'.

       nn_layer_rename:
	   name,in

	 Add a 'rename' layer to the network.

       nn_layer_reshape:
	   name,in,width>0,height>0,depth>0,spectrum>0

	 Add a 'reshape' layer to the network.

       nn_layer_resize:
	   name,in,width[%]>0,_height[%]>0,_depth[%]>0,_spectrum[%]>0,_interpo-
     lation

	 Add a 'resize' layer to the network.

	 Default values: 'height=depth=spectrum=100%'.

       nn_layer_run:
	   name,in,"command",_width[%]>0,_height[%]>0,_depth[%]>0,_spectrum[%]>0

	 Add a 'run' layer to the network.

	 Default values: 'width=height=depth=spectrum=100%'.

       nn_layer_split:
	   name0,name1,in,nb_channels0

	 Add a 'split' layer to the network.

       nn_loss_bce:
	   name,in,ground_truth

	 Add a 'bce' loss to the network (binary cross entropy).

       nn_loss_mse:
	   name,in,ground_truth

	 Add a 'mse' loss to the network (mean-squared error).

       nn_trainer:
	   name,loss,_learning_rate>0,_optimizer,_scheduler

	 Add a network trainer to the network.
	 'optimizer' can be { sgd | rmsprop | adam | adamax }.
	 'scheduler' can be { constant | linear | exponential | adaptive }.

	 Default  value:  'learning_rate=1e-6',  'optimizer=adam'  and	 'sched-
     uler=constant'.

       nn_load:
	   'filename.gmz'

	 Load and initialize network saved as a .gmz file.
	 Neural network files can be only loaded in .gmz format.

       nn_save:
	   'filename.gmz'

	 Save current network as a .gmz file.
	 Neural network files can be only saved in .gmz format.

       12.15. Arrays, Tiles and Frames
	      ------------------------

       array:
	   M>0,_N>0,_expand_type={ 0=min | 1=max | 2=all }

	 Create MxN array from selected images.

	 Default values: 'N=M' and 'expand_type=0'.

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

       array_fade:
	   M>0,_N>0,0<=_fade_start<=100,0<=_fade_end<=100,_expand_type={0=min  |
     1=max | 2=all}

	 Create MxN array from selected images.

	 Default  values:  'N=M',  'fade_start=60',   'fade_end=90'   and   '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', 'shading=1'
     and 'blur=3%'.

	 Example:
	   [#1] image.jpg frame_blur 3,30,8,10%

       frame_cube:
	   _depth>=0,_centering_x,_centering_y,_left_side={0=normal | 1=mirror-x
     | 2=mirror-y | 3=mirror-xy},_right_side,_lower_side,_upper_side

	 Insert 3D frames in selected images.

	 Default    values:    'depth=1',    'centering_x=centering_y=0'     and
     'left_side=right_side,lower_side=upper_side=0'.

	 Example:
	   [#1] image.jpg frame_cube ,

       frame_fuzzy:
	   size_x[%]>=0,_size_y[%]>=0,_fuzzyness>=0,_smooth-
     ness[%]>=0,_R,_G,_B,_A

	 Draw RGBA-colored fuzzy frame in selected images.

	 Default  values:  'size_y=size_x',  'fuzzyness=5',  'smoothness=1'  and
     'R=G=B=A=255'.

	 Example:
	   [#1] image.jpg frame_fuzzy 20

       frame_painting:
	   _size[%]>=0,0<=_contrast<=1,_profile_smoothness[%]>=0,_R,_G,_B,_vi-
     gnette_size[%]>=0,_vignette_contrast>=0,_defects_contrast>=0,0<=_de-
     fects_density<=100,_defects_size>=0,_defects_smoothness[%]>=0,
	     _serial_number

	 Add a painting frame to selected images.

	 Default values:  'size=10%',  'contrast=0.4',	'profile_smoothness=6%',
     'R=225', 'G=200', 'B=120', 'vignette_size=2%', 'vignette_contrast=400',
	  'defects_contrast=50',  'defects_density=10',  'defects_size=1',  'de-
     fects_smoothness=0.5%' and 'serial_number=123456789'.

	 Example:
	   [#1] image.jpg frame_painting ,

       frame_pattern:
	   M>=3,_constrain_size={ 0 | 1 } |
	   M>=3,_[frame_image],_constrain_size={ 0 | 1 }

	 Insert selected pattern frame in selected images.

	 Default values: 'pattern=0' and 'constrain_size=0'.

	 Example:
	   [#1] image.jpg frame_pattern 8

       frame_round:
	   frame_size[%]>=0,radius[%]>=0,_smoothness[%]>=0,_col1,...,_colN

	 Insert an inner round frame in selected images.

	 Default   values:    'size=1,	  'radius=30%',    'smoothness=0'    and
     'col=0,0,0,255'.

       frame_seamless:
	   frame_size>=0,_patch_size>0,_blend_size>=0,_frame_direction={ 0=inner
     (preserve image size) | 1=outer }

	 Insert  frame	in  selected  images, so that tiling the resulting image
     makes less visible seams.

	 Default values: 'patch_size=7', 'blend_size=5' and 'frame_direction=1'.

	 Example:
	   [#1] image.jpg +frame_seamless 30 array 2,2

       frame_x:
	   size_x[%],_col1,...,_colN

	 Insert outer 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 outer 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 outer 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 outer 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', 'analy-
     sis_smoothness=20%', 'synthesis_scale=16' and  '_output_ascii_filename=[un-
     defined]'.

	 Example:
	   [#1] image.jpg img2ascii ,

       imagegrid:
	   M>0,_N>0

	 Create MxN image grid from selected images.

	 Default value: 'N=M'.

	 Example:
	   [#1] image.jpg imagegrid 16

       imagegrid_hexagonal:
	   _resolution>0,0<=_outline<=1

	 Create hexagonal grids from selected images.

	 Default values: 'resolution=32', 'outline=0.1' and 'is_antialiased=1'.

	 Example:
	   [#1] image.jpg imagegrid_hexagonal 24

       imagegrid_triangular:
	   pattern_width>=1,_pattern_height>=1,_pattern_type,0<=_outline_opac-
     ity<=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 in-
     put image.
	 Parameter  'is_ratio_constraint' tells if the resulting image must tend
     to a square image.

	 Default values: 'is_ratio_constraint=0' and 'sort_criterion=max(w,h)'.

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

       puzzle:
	   _width>0,_height>0,_M>=1,_N>=1,_curvature,_centering,_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',	'center-
     ing=0.5', 'connectors_variability=0.5' and 'resolution=64'.

	 Example:
	   [#1] puzzle ,

       quadratize_tiles:
	   M>0,_N>0

	 Quadratize MxN tiles on selected images.

	 Default value: 'N=M'.

	 Example:
	   [#1] image.jpg +quadratize_tiles 16

       rotate_tiles:
	   angle,_M>0,N>0

	 Apply MxN tiled-rotation effect on selected images.

	 Default values: 'M=8' and 'N=M'.

	 Example:
	   [#1]  image.jpg  to_rgba  rotate_tiles  10,8  drop_shadow  10,10 dis-
     play_rgba

       shift_tiles:
	   M>0,_N>0,_amplitude

	 Apply MxN tiled-shift effect on selected images.

	 Default values: 'N=M' and 'amplitude=20'.

	 Example:
	   [#1] image.jpg +shift_tiles 8,8,10

       taquin:
	   M>0,_N>0,_remove_tile={ 0=none | 1=first | 2=last |	3=random  },_re-
     lief,_border_thickness[%],_border_outline[%],_outline_color

	 Create MxN taquin puzzle from selected images.

	 Default  value:  'N=M', 'relief=50', 'border_thickness=5', 'border_out-
     line=0' and 'remove_tile=0'.

	 Example:
	   [#1] image.jpg +taquin 8

       tunnel:
	   _level>=0,_factor>0,_centering_x,_centering_y,_opacity,_angle

	 Apply tunnel effect on selected images.

	 Default values: 'level=9', 'factor=80%', 'centering_x=centering_y=0.5',
     'opacity=1' and 'angle=0'

	 Example:
	   [#1] image.jpg tunnel 20

       12.16. Artistic
	      --------

       boxfitting:
	   _min_box_size>=1,_max_box_size>=0,_initial_density>=0,_min_spacing>0

	 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.25' and 'min_spacing=1'.

	 Example:
	   [#1] image.jpg boxfitting ,

       brushify:
	   [brush],_brush_nb_sizes>=1,0<=_brush_min_size_fac-
     tor<=1,_brush_nb_orienta-
     tions>=1,_brush_light_type,0<=_brush_light_strength<=1,_brush_opac-
     ity,_painting_density[%]>=0,0<=_painting_contours_coherence<=1,
	     0<=_painting_orientation_coherence<=1,_painting_coherence_al-
     pha[%]>=0,_painting_coherence_sigma[%]>=0,_painting_primary_an-
     gle,0<=_painting_angle_dispersion<=1

	 Apply specified brush to create painterly versions of specified images.
	 'brush_light_type'  can  be  { 0=none | 1=flat | 2=darken | 3=lighten |
     4=full }.

	 Default   values:   'brush_nb_sizes=3',   'brush_min_size_factor=0.66',
     'brush_nb_orientations=12',			   'brush_light_type=0',
     'brush_light_strength=0.25', 'brush_opacity=0.8',
	   'painting_density=20%',  'painting_contours_coherence=0.9',	 'paint-
     ing_orientation_coherence=0.9', 'painting_coherence_alpha=1', 'painting_co-
     herence_sigma=1',
	  'painting_primary_angle=0', 'painting_angle_dispersion=0.2'

	 Example:
	   [#1]  image.jpg  40,40  gaussian[-1] 10,4 spread[-1] 10,0 brushify[0]
     [1],1

       cartoon:
	   _smoothness,_sharpening,_threshold>=0,_thickness>=0,_color>=0,quanti-
     zation>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', 'opac-
     ity=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 display_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', 'out-
     line=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=dia-
     mond  |  2=circle	| 3=inv-square | 4=inv-diamond | 5=inv-circle },_smooth-
     ness[%]>=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_threshold<=100,_is_fast={
     0 | 1 }

	 Apply hard B&W sketch effect on selected images.

	 Default    values:   'amplitude=1000',   'sampling=3',   'opacity=0.1',
     'edge_threshold=20' and 'is_fast=0'.

	 Example:
	   [#1] image.jpg +hardsketchbw 200,70,0.1,10 median[-1]  2  +local  re-
     verse blur[-1] 3 blend[-2,-1] overlay done

       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[%],_center_y[%],_ray_length>=0,_ray_atten-
     uation>=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,_opacity_is_heightmap={ 0 | 1 }

	 Apply relief light to selected images.
	 Default   values(s)  :  'ambient_light=0.3',  'specular_lightness=0.5',
     'specular_size=0.2', 'darkness=0', 'xl=0.2', 'yl=zl=0.5',
	 'zscale=1', 'opacity=1' and 'opacity_is_heightmap=0'.

	 Example:
	   [#1] image.jpg blur 2 light_relief 0.3,4,0.1,0

       linify:
	   0<=_density<=100,_spreading>=0,_resolution[%]>0,_line_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_crite-
     rion],_[mask]

	 Apply	a  'pixel sorting' algorithm on selected images, as described in
     the page :
	 http://satyarth.me/articles/pixel-sorting/.

	 Default values: 'ordering=+', 'axis=x' and 'sorting_criterion=mask=(un-
     defined)'.

	 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,_posteriza-
     tion_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,_sharp-
     ness>=0,_anisotropy>=0,_smoothness>=0,_coherence>=0,_is_boost={   0   |   1
     },_is_curved={ 0 | 1 }

	 Apply sketch effect to selected images.

	 Default  values:  'nb_angles=2',  'start_angle=45',  'angle_range=180',
     'length=30', 'threshold=3', 'opacity=0.03', 'bgfactor=0', 'density=0.6',
	  'sharpness=0.1', 'anisotropy=0.6',  'smoothness=0.25',  'coherence=1',
     'is_boost=0' and 'is_curved=1'.

	 Example:
	   [#1] image.jpg +sketchbw 1 reverse blur[-1] 3 blend[-2,-1] 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,_fidelity_smooth-
     ness_finest>=0,_fidelity_smoothnes_coarsest>=0,0<=_fi-
     delity_chroma<=1,_init_type,_init_resolution>=0,init_max_gradient>=0,
	     _patchsize_analysis>0,_patchsize_synthesis>0,_patchsize_synthe-
     sis_final>0,_nb_matches_finest>=0,_nb_matches_coarsest>=0,_penalize_repeti-
     tions>=0,_matching_precision>=0,_scale_factor>1,
	     _skip_finest_scales>=0,_"image_matching_command"

	 Transfer colors and textures from specified style image to selected im-
     ages, using a multi-scale patch-mathing algorithm.
	 If instant display window[0] is opened, the steps of the image  synthe-
     sis 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',    'fi-
     delity_chroma=0.1',
	  'init_type=0',  'init_resolution=16',  'init_max_gradient=0',  'patch-
     size_analysis=5', 'patchsize_synthesis=5', 'patchsize_synthesis_final=5',
	  'nb_matches_finest=2',  'nb_matchesc_coarsest=30',   'penalize_repeti-
     tions=2',		  'matching_precision=2',	    'scale_factor=1.85',
     'skip_finest_scales=0' and
	  'image_matching_command'="s c,-3  transfer_pca[0]  [2]  b[0,2]  xy,0.7
     n[0,2] 0,255 n[1,2] 0,200 a[0,1] c a[1,2] c"'.

       tetris:
	   _scale>0

	 Apply tetris effect on selected images.

	 Default value: 'scale=10'.

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

       warhol:
	   _M>0,_N>0,_smoothness>=0,_color>=0

	 Create MxN Andy Warhol-like artwork from selected images.

	 Default values: 'M=3', 'N=M', 'smoothness=2' and 'color=20'.

	 Example:
	   [#1] image.jpg warhol 3,3,3,40

       weave:
	   _density>=0,0<=_thickness<=100,0<=_shadow<=100,_shad-
     ing>=0,_fibers_amplitude>=0,_fibers_smoothness>=0,_angle,-1<=_x_curva-
     ture<=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=curvature_y=0'

	 Example:
	   [#1] image.jpg weave ,

       whirls:
	   _texture>=0,_smoothness>=0,_darkness>=0,_lightness>=0

	 Add random whirl texture to selected images.

	 Default values: 'texture=3', 'smoothness=6', 'darkness=0.5' and 'light-
     ness=1.8'.

	 Example:
	   [#1] image.jpg whirls ,

       12.17. 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_conditions={
     0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	 Apply euclidean to polar transform on selected images.

	 Default values: 'center_x=center_y=50%', 'stretch_factor=1' and 'bound-
     ary_conditions=3'.

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

       equirectangular2nadirzenith:

	 Transform selected equirectangular images to  nadir/zenith  rectilinear
     projections.

       fisheye:
	   _center_x,_center_y,0<=_radius<=100,_amplitude>=0

	 Apply fish-eye deformation on selected images.

	 Default values: 'x=y=50', 'radius=50' and 'amplitude=1.2'.

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

       flower:
	   _amplitude,_frequency,_offset_r[%],_angle,_center_x[%],_cen-
     ter_y[%],_boundary_conditions={  0=dirichlet  |  1=neumann  |  2=periodic |
     3=mirror}

	 Apply flower deformation on selected images.

	 Default values: 'amplitude=30', 'frequency=6', 'offset_r=0', 'angle=0',
     'center_x=center_y=50%' and 'boundary_conditions=3'.

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

       kaleidoscope:
	   _center_x[%],_center_y[%],_radius,_angle,_boundary_conditions={
     0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	 Create kaleidoscope effect from selected images.

	 Default values: 'center_x=center_y=50%', 'radius=100',  'angle=30'  and
     'boundary_conditions=3'.

	 Example:
	   [#1] image.jpg kaleidoscope ,

       map_sphere:
	   _width>0,_height>0,_radius,_dilation>0,_fading>=0,_fading_power>=0

	 Map selected images on a sphere.

	 Default values: 'width=height=512', 'radius=100', 'dilation=0.5', 'fad-
     ing=0' and 'fading_power=0.5'.

	 Example:
	   [#1] image.jpg map_sphere ,

       nadirzenith2equirectangular:

	 Transform  selected nadir/zenith rectilinear projections to equirectan-
     gular images.

       polar2euclidean:
	   _center_x[%],_center_y[%],_stretch_factor>0,_boundary_conditions={
     0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	 Apply euclidean to polar transform on selected images.

	 Default values: 'center_x=center_y=50%', 'stretch_factor=1' and 'bound-
     ary_conditions=3'.

	 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 'merg-
     ing_steps=0'.

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

       ripple:
	   _amplitude,_bandwidth,_shape={  0=block  |  1=triangle  |  2=sine   |
     3=sine+ | 4=random },_angle,_offset

	 Apply ripple deformation on selected images.

	 Default  values:  'amplitude=10',  'bandwidth=10', 'shape=2', 'angle=0'
     and 'offset=0'.

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

       rotoidoscope:
	   _center_x[%],_center_y[%],_tiles>0,_smoothness[%]>=0,_boundary_condi-
     tions={ 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_an-
     tisymmetry=0' and 'swap_sides=0'.

	 Example:
	   [#1] image.jpg +symmetrize 50%,50%,45 +symmetrize[-1] 50%,50%,-45

       transform_polar:
	   "expr_radius",_"expr_angle",_center_x[%],_center_y[%],_boundary_con-
     ditions={ 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	 Apply user-defined transform on polar representation  of  selected  im-
     ages.

	 Default   values:  'expr_radius=R-r',	'expr_rangle=a',  'center_x=cen-
     ter_y=50%' and 'boundary_conditions=3'.

	 Example:
	   [#1] image.jpg  +transform_polar[0]	R*(r/R)^2,a  +transform_polar[0]
     r,2*a

       twirl:
	   _amplitude,_center_x[%],_center_y[%],_boundary_conditions={ 0=dirich-
     let | 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_conditions={
     0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	 Warp selected images with perspective deformation.

	 Default values: 'x-angle=1.5', 'y-angle=0', 'zoom=1',	'x-center=y-cen-
     ter=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=neumann |
     2=periodic | 3=mirror }

	 Apply zoom factor to selected images.

	 Default values: 'factor=1', 'cx=cy=cz=0.5' and 'boundary_conditions=0'.

	 Example:
	   [#1] image.jpg +zoom[0] 0.6 +zoom[0] 1.5

       12.18. 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=block  |	1=triangle  |  2=sine  |
     3=sine+ | 4=random },_angle,_offset

	 Apply ripple deformation on selected images.

	 Default values: 'amplitude=60', 'bandwidth=2', 'shape=0', 'angle=0' and
     'offset=0'.

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

       shade_stripes:
	   _frequency>=0,_direction={	0=horizontal   |   1=vertical	},_dark-
     ness>=0,_lightness>=0

	 Add shade stripes to selected images.

	 Default   values:   'frequency=5',  'direction=1',  'darkness=0.8'  and
     'lightness=2'.

	 Example:
	   [#1] image.jpg +shade_stripes 30

       shadow_patch:
	   _opacity>=0

	 Add shadow patches to selected images.

	 Default value: 'opacity=0.7'.

	 Example:
	   [#1] image.jpg +shadow_patch 0.4

       spread:
	   _dx>=0,_dy>=0,_dz>=0

	 Spread pixel values of selected images randomly along x,y and z.

	 Default values: 'dx=3', 'dy=dx' and 'dz=0'.

	 Example:
	   [#1] image.jpg +spread 3

       stripes_y:
	   _frequency>=0

	 Add vertical stripes to selected images.

	 Default value: 'frequency=10'.

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

       texturize_canvas:
	   _amplitude>=0,_fibrousness>=0,_emboss_level>=0

	 Add paint canvas texture to selected images.

	 Default values: 'amplitude=20', 'fibrousness=3' and 'emboss_level=0.6'.

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

       texturize_paper:

	 Add paper texture to selected images.

	 Example:
	   [#1] image.jpg +texturize_paper

       vignette:
	   _strength>=0,0<=_radius_min<=100,0<=_radius_max<=100

	 Add vignette effect to selected images.

	 Default values: 'strength=100', 'radius_min=70' and 'radius_max=90'.

	 Example:
	   [#1] image.jpg vignette ,

       watermark_visible:
	   _text,0<_opacity<1,_size>0,_angle,_mode={ 0=remove | 1=add },_smooth-
     ness>=0

	 Add or remove a visible watermark on selected images (value range  must
     be [0,255]).

	 Default values: 'text=(c) G'MIC', 'opacity=0.3', 'size=53', 'angle=25',
     'mode=1' and 'smoothness=0'.

	 Example:
	   [#1] image.jpg watermark_visible ,0.7

       12.19. Blending and Fading
	      -------------------

       blend:
	   [layer],blending_mode,_opacity[%],_selection_is={   0=base-layers   |
     1=top-layers } |
	   blending_mode,_opacity[%]

	 Blend selected G,GA,RGB or RGBA images by specified layer or blend  all
     selected images together,
	 using specified blending mode.
	 'blending_mode'  can  be  { add | alpha | and | average | blue | burn |
     darken | difference |
	 divide | dodge | edges | exclusion | freeze | grainextract | grainmerge
     | green | hardlight |
	 hardmix | hue | interpolation | lchlightness | lighten  |  lightness  |
     linearburn | linearlight | luminance |
	 multiply | negation | or | overlay | pinlight | red | reflect | satura-
     tion |
	 screen  |  seamless  |  seamless_mixed | shapeareamax | shapeareamax0 |
     shapeareamin | shapeareamin0 |
	 shapeaverage | shapeaverage0 | shapemedian | shapemedian0 | shapemin  |
     shapemin0 | shapemax | shapemax0 |
	 softburn  |  softdodge  | softlight | stamp | subtract | value | vivid-
     light | xor }.
	 'opacity' must be in range '[0,1]' (or '[0%,100%]').

	 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:
	   [#4]  command  "ex  :  $""=arg  repeat  $""# +blend[0,1] ${arg{$>+1}}
     text_outline[-1] Mode:
	    grainextract,grainmerge
	   [#5] command "ex  :	$""=arg  repeat  $""#  +blend[0,1]  ${arg{$>+1}}
     text_outline[-1] Mode:
	    lighten,lightness
	   [#6]  command  "ex  :  $""=arg  repeat  $""# +blend[0,1] ${arg{$>+1}}
     text_outline[-1] Mode:
	    negation,or,overlay
	   [#7] command "ex  :	$""=arg  repeat  $""#  +blend[0,1]  ${arg{$>+1}}
     text_outline[-1] Mode:
	    shapeaverage,softburn
	   [#8]  command  "ex  :  $""=arg  repeat  $""# +blend[0,1] ${arg{$>+1}}
     text_outline[-1] Mode:
	    vividlight,xor

       blend:
	   [layer],blending_mode,_opacity[%],_selection_is={   0=base-layers   |
     1=top-layers } |
	   blending_mode,_opacity[%]

       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)' normal-
     ize[-1] 0,1 +blend_fade[0,1] [2]

       blend_median:

	 Blend selected images together using 'median' mode.

	 Example:
	   [#1] image.jpg testimage2d {w},{h} +mirror[0] y +blend_median

       blend_seamless:
	   _is_mixed_mode={ 0 | 1 },_inner_fading[%]>=0,_outer_fading[%]>=0

	 Blend selected images using a seamless blending mode (Poisson-based).

	 Default values: 'is_mixed=0', 'inner_fading=0' and 'outer_fading=100%'.

       fade_diamond:
	   0<=_start<=100,0<=_end<=100

	 Create diamond fading from selected images.

	 Default values: 'start=80' and 'end=90'.

	 Example:
	   [#1] image.jpg testimage2d {w},{h} +fade_diamond 80,85

       fade_linear:
	   _angle,0<=_start<=100,0<=_end<=100

	 Create linear fading from selected images.

	 Default values: 'angle=45', 'start=30' and 'end=70'.

	 Example:
	   [#1] image.jpg testimage2d {w},{h} +fade_linear 45,48,52

       fade_radial:
	   0<=_start<=100,0<=_end<=100

	 Create radial fading from selected images.

	 Default values: 'start=30' and 'end=70'.

	 Example:
	   [#1] image.jpg testimage2d {w},{h} +fade_radial 30,70

       fade_x:
	   0<=_start<=100,0<=_end<=100

	 Create horizontal fading from selected images.

	 Default values: 'start=30' and 'end=70'.

	 Example:
	   [#1] image.jpg testimage2d {w},{h} +fade_x 30,70

       fade_y:
	   0<=_start<=100,0<=_end<=100

	 Create vertical fading from selected images.

	 Default values: 'start=30' and 'end=70'.

	 Example:
	   [#1] image.jpg testimage2d {w},{h} +fade_y 30,70

       fade_z:
	   0<=_start<=100,0<=_end<=100

	 Create transversal fading from selected images.

	 Default values: 'start=30' and 'end=70'.

       sub_alpha:
	   [base_image],_opacity_gain>=1

	 Compute the minimal alpha-channel difference (opposite of alpha  blend-
     ing) between the selected images
	 and the specified base image.
	 The  alpha  difference A-B is defined as the image having minimal opac-
     ity, such that alpha_blend(B,A-B) = A.

	 Default value: 'opacity_gain=1'.

	 Example:
	   [#1] image.jpg testimage2d {w},{h} +sub_alpha[0] [1] display_rgba

       12.20. Image Sequences and Videos
	      --------------------------

       animate:
	   fil-
     ter_name,"param1_start,...,paramN_start","param1_end,...,paramN_end",nb_frames>=0,_out-
     put_frames={ 0 | 1 },_output_filename |
	   delay>0,_back and forth={ 0 | 1 }

	 Animate filter from starting parameters to ending parameters or animate
     selected images
	 in a display window.

	 Default value: 'delay=30'.

	 Example:
	   [#1] image.jpg animate flower,"0,3","20,8",9

       apply_camera:
	   _"command",_camera_index>=0,_skip_frames>=0,_output_filename

	 Apply specified command on live camera stream, and display it	on  dis-
     play window [0].
	 This  command requires features from the OpenCV library (not enabled in
     G'MIC by default).

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

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

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

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

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

	 Apply	a G'MIC command on all frames of the specified input video file,
     in a streamed way.
	 If a display window is opened, rendered frames are displayed in it dur-
     ing processing.
	 The output filename may have extension '.avi' or  '.mp4'  (saved  as  a
     video), or any other usual image
	 file extension (saved as a sequence of images).
	 This  command requires features from the OpenCV library (not enabled in
     G'MIC by default).

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

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

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

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

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

	 Average frames of specified input video file, in a streamed way.
	 If a display window is opened, rendered frames are displayed in it dur-
     ing processing.
	 The  output  filename	may  have extension '.avi' or '.mp4' (saved as a
     video), or any other usual image
	 file extension (saved as a sequence of images).
	 This command requires features from the OpenCV library (not enabled  in
     G'MIC by default).

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

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

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

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

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

	 Create a temporal fading sequence from specified input video file, in a
     streamed way.
	 If a display window is opened, rendered frames are displayed in it dur-
     ing processing.
	 This command requires features from the OpenCV library (not enabled  in
     G'MIC by default).

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

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

	 Convert several files into a single video file.

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

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

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

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

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

	 Compute the median of all frames of an input video file, in a	streamed
     way.
	 If a display window is opened, rendered frame is displayed in it during
     processing.
	 This  command requires features from the OpenCV library (not enabled in
     G'MIC by default).

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

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

	 Create morphing sequence between selected images.

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

	 Example:
	   [#1] image.jpg +rotate 20,1,1,50%,50% morph 9

       morph_files:
	   "filename_pattern",_nb_inner_frames>0,_smoothness>=0,_preci-
     sion>=0,_first_frame>=0,_last_frame={  >=0 | -1=last },_frame_step>=1,_out-
     put_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 dur-
     ing processing.
	 The  output  filename	may  have extension '.avi' or '.mp4' (saved as a
     video), or any other usual image
	 file extension (saved as a sequence of images).

	 Default values: 'nb_inner_frames=10', 'smoothness=0.1',  'precision=4',
     'first_frame=0',  'last_frame=-1', 'frame_step=1' and 'output_filename=(un-
     defined)'.

       morph_rbf:
	   nb_in-
     ner_frames>=1,xs0[%],ys0[%],xt0[%],yt0[%],...,xsN[%],ysN[%],xtN[%],ytN[%]

	 Create morphing sequence between selected images, using  RBF-based  in-
     terpolation.
	 Each  argument  (xsk,ysk)-(xtk,ytk) corresponds to the coordinates of a
     keypoint
	 respectively on the source and target images. The set of all  keypoints
     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,_out-
     put_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 dur-
     ing processing.
	 The  output  filename	may  have extension '.avi' or '.mp4' (saved as a
     video), or any other usual image
	 file extension (saved as a sequence of images).
	 This command requires features from the OpenCV library (not enabled  in
     G'MIC by default).

	 Default  values: 'nb_inner_frames=10', 'smoothness=0.1', 'precision=4',
     'first_frame=0', 'last_frame=-1', 'frame_step=1' and  'output_filename=(un-
     defined)'.

       register_nonrigid:
	   [destination],_smoothness>=0,_precision>0,_nb_scale>=0

	 Register selected source images with specified destination image, using
     non-rigid warp.

	 Default values: 'smoothness=0.2', 'precision=6' and 'nb_scale=0(auto)'.

	 Example:
	   [#1] image.jpg +rotate 20,1,1,50%,50% +register_nonrigid[0] [1]

       register_rigid:
	   [destination],_smoothness>=0,_boundary_conditions={	 0=dirichlet   |
     1=neumann | 2=periodic | 3=mirror }

	 Register selected source images with specified destination image, using
     rigid warp (shift).

	 Default values: 'smoothness=0.1%' and 'boundary_conditions=0'.

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

       transition:
	   [transition_shape],nb_added_frames>=0,100>=shading>=0,_sin-
     gle_frame_only={ -1=disabled | >=0 }

	 Generate a transition sequence between selected images.

	 Default values: 'shading=0' and 'single_frame_only=-1'.

	 Example:
	   [#1] image.jpg +mirror c 100%,100% plasma[-1]  1,1,6  transition[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 expressions,
     depending on 'x' and 'y'.

	 Default  values:  'nb_frames=10',  'nb_xtiles=nb_ytiles=3', 'axis_x=1',
     'axis_y=1', 'axis_z=0' and 'is_antialias=1'.

	 Example:
	   [#1] image.jpg +blur 5 transition3d 9 display_rgba

       video2files:
	   input_filename,_output_filename,_first_frame>=0,_last_frame={  >=0  |
     -1=last },_frame_step>=1

	 Split specified input video file into image files, one for each frame.
	 First and last frames as well as step between frames can be specified.

	 Default     values:	'output_filename=frame.png',	'first_frame=0',
     'last_frame=-1' and 'frame_step=1'.

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

       arg2img:
	   argument_1,...,argument_N

	 Split	specified list of arguments and return each as a new image (as a
     null-terminated string).

       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_vectors:

	 Return the vector-valued average of the latest of the selected images.

       base642img:
	   "base64_string"

	 Decode given base64-encoded string as a newly inserted image at the end
     of the list.
	 The  argument	string	must   have   been   generated	 using	 command
     'img2base64'.

       base642uint8:
	   "base64_string"

	 Decode  given	base64-encoded string as a newly inserted 1-column image
     at the end of the list.
	 The  argument	string	must   have   been   generated	 using	 command
     'uint82base64'.

       basename:
	   file_path,_variable_name_for_folder

	 Return the basename of a file path, and opt. its folder location.
	 When specified 'variable_name_for_folder' must starts by an underscore
	 (global variable accessible from calling function).

       bin:
	   binary_int1,...

	 Print	specified binary integers into their octal, decimal, hexadecimal
     and string representations.

       bin2dec:
	   binary_int1,...

	 Convert specified binary integers into their decimal representations.

       covariance_vectors:
	   _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,  hexadecimal
     and string representations.

       dec2str:
	   decimal_int1,...

	 Convert specifial decimal integers into its string representation.

       dec2bin:
	   decimal_int1,...

	 Convert specified decimal integers into their binary representations.

       dec2hex:
	   decimal_int1,...

	 Convert  specified  decimal integers into their hexadecimal representa-
     tions.

       dec2oct:
	   decimal_int1,...

	 Convert specified decimal integers into their octal representations.

       fact:
	   value

	 Return the factorial of the specified value.

       fibonacci:
	   N>=0

	 Return the Nth number of the Fibonacci sequence.

	 Example:
	   [#1] echo ${"fibonacci 10"}

	   [gmic]-0./ Start G'MIC interpreter.
	   [gmic]-0./ 55
	   [gmic]-0./ End G'MIC interpreter.

       file_mv:
	   filename_src,filename_dest

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

       file_rand:

	 Return a random filename for storing temporary data.

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

	 Return a filename numbered with specified indices.

       files (+):
	   _mode,path

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

	 Default value: 'mode=5'.

       files2img:
	   _mode,path

	 Insert a new image where each vector-valued pixel is a string	encoding
     the filenames returned by command files.
	 Useful  to  manage  list of filenames containing characters that have a
     special meaning in the G'MIC language,such as spaces or commas.

       fitratio_wh:
	   min_width,min_height,ratio_wh

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

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

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

	 Default values: 'depth=1', 'minimal_size=128' and 'maximal_size=85%'.

       fontchart:

	 Insert G'MIC font chart at the end of the image list.

	 Example:
	   [#1] fontchart

       fps:

	 Return the number of time this function is called per second, or -1  if
     this info is not yet available.
	 Useful to display the framerate when displaying animations.

       gcd:
	   a,b

	 Return the GCD (greatest common divisor) between a and b.

       hex:
	   hexadecimal_int1,...

	 Print	specified hexadecimal integers into their binary, octal, decimal
     and string representations.

       hex2dec:
	   hexadecimal_int1,...

	 Convert specified hexadecimal integers into their  decimal  representa-
     tions.

       hex2img:
	   "hexadecimal_string"

	 Insert  new  image  1xN at the end of the list with values specified by
     the given hexadecimal-encoded string.

       hex2str:
	   hexadecimal_string

	 Convert specified hexadecimal string into a string.
	 See also: str2hex.

       img2base64:
	   _encoding={ 0=base64 | 1=base64url },_store_names={ 0 | 1 }

	 Encode selected images as a base64-encoded string.
	 The images can be then decoded using command 'base642img'.

	 Default values: 'encoding=0' and 'store_names=1'.

       img2hex:

	 Return representation of last image as an hexadecimal-encoded string.
	 Input image must have values that are integers in [0,255].

       img2str:

	 Return the content of the latest of the selected images  as  a  special
     G'MIC input string.

       img2text:
	   _line_separator

	 Return text contained in a multi-line image.

	 Default value: 'line_separator= '.

       img82hex:

	 Convert  selected 8bits-valued vectors into their hexadecimal represen-
     tations (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_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  em-
     bedded 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_vectors:

	 Return  the median vector value of the last selected image (median com-
     puted channel by channel)

       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  (un-
     signed integers),
	 separated  by	commas (or an empty string if no images with those names
     have been found).
	 (equivalent to shortcut command 'nmd').

	 'mode' can be { 0=all indices (default) | 1=lowest  index  |  2=highest
     index  | 3 = all indices (case insensitive) | 4 = lowest index (case insen-
     sitive) | 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,  hexadecimal
     and string representations.

       oct2dec:
	   octal_int1,...

	 Convert specified octal integers into their decimal representations.

       padint:
	   number,_size>0

	 Return a integer with 'size' digits (eventually left-padded with '0').

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

       remove_copymark:
	   "image_name"

	 Remove copy mark from names of selected images.

       reset:

	 Reset global parameters of the interpreter environment.

       rgb:

	 Return a random int-valued RGB color.

       rgba:

	 Return a random int-valued RGBA color.

       shell_cols:

	 Return the estimated number of columns of the current shell.

       size_value:

	 Return the size (in bytes) of image values.

       std_noise:

	 Return  the estimated noise standard deviation of the last selected im-
     age.

       str:
	   string

	 Print specified string into its binary, octal, decimal and  hexadecimal
     representations.

       str2hex:
	   "string"

	 Convert specified string argument into a sequence of hexadecimal values
     (returned as a string).
	 See also: hex2str.

	 Example:
	   [#1] hex=${"str2hex

	   [gmic]-0./ Start G'MIC interpreter.
	   [gmic]-0./ 48656c6c6f206d7920667269656e6473
	   [gmic]-0./ End G'MIC interpreter.

       strcapitalize:
	   string

	 Capitalize specified string.

       strcontains:
	   string1,string2

	 Return 1 if the first string contains the second one.

       strlen:
	   string1

	 Return the length of specified string argument.

       strreplace:
	   string,search,replace

	 Search and replace substrings in an input string.

       strlowercase:
	   string

	 Return a lower-case version of the specified string.

       struppercase:
	   string

	 Return an upper-case version of the specified string.

       strvar:
	   "string"

	 Return  a  simplified version of the specified string, that can be used
     as a variable name.
	 (version that creates a lowercase result, no longer than 128 chars).

       strcasevar:
	   "string"

	 Return a simplified version of the specified string, that can	be  used
     as a variable name.
	 (version  that  keeps original case of specified string, no longer than
     128 chars).

       strver:
	   _version,_prerelease

	 Return the specified version number of  the  G'MIC  interpreter,  as  a
     string.

	 Default value: 'version=$_version' and 'prerelease='.

       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 specified
     input string.

       uint82base64:
	   _encoding={ 0=base64 | 1=base64url }

	 Encode the values of the latest of the selected images as a  base64-en-
     coded string.
	 The string can be decoded using command 'base642uint8'.
	 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 circles,
     using the rules described at https://tixy.land.

       x_2048:

	 Launch the 2048 game.

       x_blobs:

	 Launch the blobs editor.
	 ../img/x_blobs.jpg [image: 'x_blobs']

       x_bouncing:

	 Launch the bouncing balls demo.

       x_color_curves:
	   _colorspace={  rgb | cmy | cmyk | hsi | hsl | hsv | lab | lch | ycbcr
     | last }

	 Apply color curves on selected RGB[A] images, using an interactive win-
     dow.
	 Set 'colorspace' to 'last' to apply last defined color  curves  without
     opening interactive windows.

	 Default value: 'colorspace=rgb'.

       x_colorize:
	   _is_lineart={  0  |	1  },_max_resolution={	0  | >=128 },_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 resolution
     used in the interactive window.

	 Default values: 'is_lineart=1', 'max_resolution=1024'	and  'multichan-
     nels_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 se-
     lected color values at any time.
	 Assigning '-1' to it forces the interactive window to close.

	 Default values: 'variable_name=xgc_variable'.

       x_hanoi:

	 Launch the Tower of Hanoi game.

       x_histogram:

	 Launch the histogram demo.

       x_hough:

	 Launch the hough transform demo.

       x_jawbreaker:
	   0<_width<20,0<_height<20,0<_balls<=8

	 Launch the Jawbreaker game.

       x_landscape:

	 Launch the virtual landscape demo.

       x_life:

	 Launch the game of life.

       x_light:

	 Launch the light effect demo.

       x_mandelbrot:
	   _julia={ 0 | 1 },_c0r,_c0i

	 Launch Mandelbrot/Julia explorer.

       x_mask_color:
	   _colorspace={ all | rgb | lrgb | ycbcr | lab | lch | hsv | hsi |  hsl
     | cmy | cmyk | yiq },_spatial_tolerance>=0,_color_tolerance>=0

	 Interactively	select	a color, and add an alpha channel containing the
     corresponding color mask.
	 Argument 'colorspace' refers to the color metric used to compute  color
     similarities, and can be basically
	 one  of { rgb | lrgb | ycbcr | lab | lch | hsv | hsi | hsl | cmy | cmyk
     | yiq }.
	 You can also select one one particular channel of this  colorspace,  by
     setting 'colorspace' as
	 'colorspace_channel' (e.g. 'hsv_h' for the hue).

	 Default values: 'colorspace=all', 'spatial_tolerance=5' and 'color_tol-
     erance=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=normal |
     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,  in-
     teractively.
	 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 se-
     lected 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 func-
     tion.
	 If an image is selected, it is used to display additional information :
	    -	The first row defines the values of a background curve displayed
     on the window (e.g. an histogram).
	    -  The 2nd, 3rd and 4th rows define the R,G,B color components  dis-
     played beside the X and Y axes.
	 Argument  'variable_name'  specifies the variable that contains the se-
     lected function keypoints at any time.
	 Assigning '-1' to it forces the interactive window to close.

	 Default values: 'variable_name=xsf_variable', 'background_curve_R=220',
     'background_curve_G=background_curve_B=background_curve_T'.

       x_select_palette:
	   _variable_name,_number_of_columns={ 0=auto | >0 }

	 Open a RGB or RGBA color selector widget from a palette.
	 The palette is given as a selected image.
	 Argument 'variable_name' specifies the variable that contains	the  se-
     lected color values (as R,G,B,[A])
	 at any time.
	 Assigning '-1' to it forces the interactive window to close.

	 Default values: 'variable_name=xsp_variable' and 'number_of_columns=2'.

       x_shadebobs:

	 Launch the shade bobs demo.

       x_spline:

	 Launch spline curve editor.

       x_starfield3d:

	 Launch the 3D starfield demo.

       x_tetris:

	 Launch tetris game.

       x_threshold:

	 Threshold selected images interactively.

       x_tictactoe:

	 Launch tic-tac-toe game.

       x_warp:
	   _nb_keypoints_xgrid>=2,_nb_keypoints_ygrid>=2,_nb_keypoints_con-
     tours>=0,_preview_fidelity={  0=coarsest  |  1=coarse | 2=normal | 3=fine |
     4=finest },_[background_image],0<=_background_opacity<=1

	 Launch the interactive image warper.

	 Default  values:  'nb_keypoints_xgrid=nb_keypoints_ygrid=2',	'nb_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 va-
     riety  of	situations.  The  few examples below illustrate possible uses of
     this tool:

       ### View a list of images:

	 $ gmic file1.bmp file2.jpeg

       ### Convert an image file:

	 $ gmic input.bmp output output.jpg

       ### Create a volumetric image from a movie sequence:

	 $ gmic input.mpg append z output output.hdr

       ### Compute image gradient norm:

	 $ gmic input.bmp gradient_norm

       ### Denoise a color image:

	 $ gmic image.jpg denoise 30,10 output denoised.jpg

       ### Compose two images using overlay layer blending:

	 $ gmic image1.jpg image2.jpg blend overlay output blended.jpg

       ### Evaluate a mathematical expression:

	 $ gmic echo "cos(pi/4)^2+sin(pi/4)^2={cos(pi/4)^2+sin(pi/4)^2}"

       ### Plot a 2D function:

	 $		   gmic 		1000,1,1,2		    fill
     "X=3*(x-500)/500;X^2*sin(3*X^2)+if(c==0,u(0,-1),cos(X*10))" plot

							    ../img/exam-
     ple_plot.png [image: '']

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

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

							    ../img/example_ele-
     vation3d.png [image: '']

       ### Plot the isosurface of a 3D volume:

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

							    ../img/example_iso-
     surface3d.png [image: '']

       ### Render a G'MIC 3D logo:

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

							    ../img/exam-
     ple_logo.png [image: '']

       ### Generate a 3D ring of torii:

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

							    ../img/exam-
     ple_torii.png [image: '']

       ### Create a vase from a 3D isosurface:

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

							    ../img/exam-
     ple_vase.png [image: '']

       ### Launch a set of interactive demos:

	 $ gmic demos

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

									G'MIC(1)

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

home | help