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

FreeBSD Manual Pages

  
 
  

home | help
G'MIC(1)		    General Commands Manual		      G'MIC(1)

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

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

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

	 1. Usage
	    -----

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	  * A G'MIC item that is not a filename	nor a special input string
	  designates a 'command' most of the time. Generally, commands perform
	  image	 processing  operations	 on one	or several available images of
       the list.
	  * Reccurent commands have two	equivalent names ('regular' and
	  'short'). For	instance, command names	'resize' and 'r' refer
	  to the same image resizing action.
	  * A G'MIC command may	have mandatory or optional arguments. Command
	  arguments must be specified in the next item on  the	command	 line.
       Commas ',
	  '  are used to separate multiple arguments of	a single command, when
       required.
	  * The	execution of a G'MIC command may be restricted only to a  sub-
       set of
	  the  image list, by appending	'[selection]' to the command name. Ex-
       amples
	  of valid syntaxes for	'selection' are:
	    -  'command[-2]': Apply command only on the	penultimate image
	  '[-2]' of the	list.
	    -  'command[0,1,3]': Apply command only on images '[0]',
	  '[1]'	and '[3]'.
	    -  'command[3-6]': Apply command only on images '[3]' to
	  '[6]'	(i.e, '[3]', '[4]', '[5]' and '[6]').
	    -  'command[50%-100%]': Apply command only on the second  half  of
       the
	  image	list.
	    -	'command[0,-4--1]':  Apply command only	on the first image and
       the
	  last four images.
	    -  'command[0-9:3]': Apply command only on images '[0]' to
	  '[9]', with a	step of	3 (i.e.	on images '[0]', '[3]',
	  '[6]'	and '[9]').
	    -  'command[0-9:25%]': Apply command only on images	'[0]' to
	  '[9]', with a	step of	25% (i.e. on images '[0]', '[3]',
	  '[6]'	and '[9]').
	    -  'command[0--1:2]': Apply	command	only on	 images	 of  the  list
       with
	  even indices.
	    -  'command[0,2-4,50%--1]':	Apply command on images	'[0]',
	  '[2]', '[3]',	'[4]' and on the second	half of	the image list.
	    -	'command[^0,1]':  Apply	command	on all images except the first
       two.
	    -  'command[name1,name2]': Apply command on	named images 'name1'
	  and 'name2'.

	  * Indices in selections are always sorted in increasing  order,  and
       duplicate
	  indices  are	discarded.  For	 instance,  selections '[3-1,1-3]' and
       '[1,1,
	  1,3,2]' are both equivalent to '[1-3]'. If you want to repeat	a sin-
       gle
	  command  multiple  times  on an image, use a 'repeat..done' loop in-
       stead.
	  Inverting the	order of images	for a command is achieved  by  explic-
       itly inverting
	  the  order  of  the images in	the list, with command 'reverse[selec-
       tion]'.
	  * Command selections '[-1]', '[-2]' and '[-3]' are so	often
	  used they have their own shortcuts, respectively '.',	'..' and
	  '...'. For instance, command 'blur..'	is equivalent to
	  'blur[-2]'. These shortcuts work also	when specifying	command	 argu-
       ments.
	  *  G'MIC  commands  invoked without '[selection]' are	applied	on all
       images
	  of the list, i.e. the	default	selection is '[0--1]' (except for com-
       mand
	  input	whose default selection	is '[-1]'').
	  * Prepending a single	hyphen '-' to a	G'MIC command is allowed. This
       may
	  be useful to recognize command items	more  easily  in  a  one-liner
       pipeline
	  (typically invoked from a shell).
	  * A G'MIC command prepended with a plus sign '+' does	not act
	  in-place  but	inserts	its result as one or several new images	at the
       end
	  of the image list.
	  * There are two different types of commands that can be run  by  the
       G'MIC
	  interpreter:
	    -  Built-in	commands are the hard-coded functionalities in the
	  interpreter  core.  They  are	 thus  compiled	as binary code and run
       fast, most of
	  the time. Omitting an	argument when invoking a built-in  command  is
       not
	  permitted,  except  if all following arguments are also omitted. For
       instance,
	  invoking 'plasma 10,,5' is invalid but 'plasma 10' is	correct.
	    -  Custom commands,	are defined as G'MIC pipelines of built-in or
	  other	custom commands. They are parsed by the	G'MIC interpreter, and
       thus run	a
	  bit  slower than built-in commands. Omitting arguments when invoking
       a custom
	  command is permitted.	For instance, expressions  'flower  ,,,100,,2'
       or
	  'flower ,' are correct.

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

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

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

	  * When dealing with color images, G'MIC generally reads, writes  and
       displays
	  data using the usual sRGB color space.
	  * 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  buf-
       fers. For
	  instance,   saving   an   image  that	 was  initially	 loaded	 as  a
       16bits/channel image,
	  as a '.jpg' file will	result in a loss of information. Use the
	  G'MIC-specific file extension	'.gmz' to ensure that all data	preci-
       sion is
	  preserved when saving	images.
	  * Sometimes, file options may/must be	set for	file formats:
	    -	Video  files:  Only  sub-frames	 of  an	 image sequence	may be
       loaded,
	  using	the input expression 'filename.ext,[first_frame[,last_frame[,
	  step]]]'. Set	'last_frame==-1' to tell it must be the	last frame of
	  the video. Set 'step'	to '0' to force	an opened video	file to	be
	  opened/closed. Output	framerate and codec can	be also	set  by	 using
       the output
	  expression 'filename.avi,_fps,_codec,_keep_open' where 'keep_open'
	  can be { 0 | 1 }. 'codec' is a 4-char	string (see
	  http://www.fourcc.org/codecs.php ) or	'0' for	the default codec.
	  'keep_open' tells if the output video	file must be kept open for
	  appending new	frames afterwards.
	    -  '.cimg[z]' files: Only crops and	sub-images of .cimg files
	  can be loaded, using the input expressions 'filename.cimg,N0,N1',
	  'filename.cimg,N0,N1,x0,x1', 'filename.cimg,N0,N1,x0,y0,x1,y1',
	  'filename.cimg,N0,N1,x0,y0,z0,x1,y1,z1'	    or		'file-
       name.cimg,N0,N1,x0,y0,
	  z0,c0,x1,y1,z1,c1'. Specifying '-1' for one coordinates  stands  for
       the
	  maximum     possible	   value.     Output	 expression	'file-
       name.cimg[z][,datatype]'
	  can be used to force the output pixel	type. 'datatype' can be	{ auto
       |
	  bool | uchar | char |	ushort | short | uint |	int | uint64 | int64 |
       float |
	  double }.
	    -  '.raw' binary files: Image dimensions and input pixel type
	  may be specified when	loading	'.raw' files with input	expression
	  'filename.raw[,datatype][,width][,height[,depth[,dim[,offset]]]]]'.
       If no
	  dimensions are specified, the	resulting image	is a one-column	vector
       with
	  maximum possible height. Pixel type can also be specified  with  the
       output
	  expression 'filename.raw[,datatype]'.	'datatype' can be the same as
	  for '.cimg[z]' files.
	    -  '.yuv' files: Image dimensions must be specified	when loading,
	   and	only  sub-frames of an image sequence may be loaded, using the
       input
	  expression		    'filename.yuv,width,height[,chroma_subsam-
       pling[,first_frame[,
	  last_frame[,step]]]'.	'chroma_subsampling' can be { 420 | 422	| 444
	  }. When saving, chroma subsampling mode can be specified with	output
	  expression 'filename.yuv[,chroma_subsampling]'.
	    -  '.tiff' files: Only sub-images of multi-pages tiff files	can
	  be	 loaded,     using     the     input	 expression	'file-
       name.tif,_first_frame,_last_frame,
	  _step'. Output expression 'filename.tiff,_datatype,_compression,
	  _force_multipage,_use_bigtiff' can be	used  to  specify  the	output
       pixel type,
	  as well as the compression method. 'datatype'	can be the same	as for
	  '.cimg[z]' files. 'compression' can be  { none (default) | lzw |
	  jpeg }. 'force_multipage' can	be { 0=no (default) | 1=yes }.
	  'use_bigtiff'	can be { 0=no |	1=yes (default)	}.
	    -  '.pdf' files: When loading a file, the rendering	resolution
	  can  be  specified  using the	input expression 'filename.pdf,resolu-
       tion',
	  where	'resolution' is	an unsigned integer value.
	    -  '.gif' files: Animated gif files	can be saved, using the
	  input	expression 'filename.gif,fps>0,nb_loops'. Specify
	  'nb_loops=0' to get an infinite number of animation loops  (this  is
       the
	  default behavior).
	    -  '.jpeg' files: The output quality may be	specified (in %),
	  using	 the  output  expression 'filename.jpg,30' (here, to get a 30%
       quality
	  output). '100' is the	default.
	    -  '.mnc' files: The output	header can set from another file,
	  using	the output expression 'filename.mnc,header_template.mnc'.
	    -  '.pan', '.cpp', '.hpp', '.c' and	'.h'
	  files: The output datatype can be selected with output expression
	  'filename[,datatype]'. 'datatype' can	be the same as for
	  '.cimg[z]' files.
	    -  '.gmic' files: These filenames are assumed to be	G'MIC custom
	  commands files. Loading such a file will add the commands it defines
       to the
	  interpreter.	Debug information can be enabled/disabled by the input
       expression
	  'filename.gmic[,add_debug_info' where	'debug_info' can be {
	  0=false | 1=true }.
	    -  Inserting 'ext:'	on the beginning of a filename (e.g.
	  'jpg:filename') forces G'MIC to read/write the file as it would have
       been
	  done if it had the specified extension '.ext'.

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

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

	  * G'MIC items	containing '$' or '{}' are substituted before
	  being	interpreted. Use these substituting expressions	to access var-
       ious data
	  from the interpreter environment.
	  * '$name' and	'${name}' are both substituted by the value of the
	  specified named variable (set	previously by the item	'name=value').
       If
	  this	variable  has  not been	already	set, the expression is substi-
       tuted by	the
	  highest positive index of the	named image '[name]'. If no image  has
       this
	  name,	 the expression	is substituted by the value of the OS environ-
       ment variable
	  with same name (it may be thus an empty string  if  it  is  not  de-
       fined).
	  *  The  following reserved variables are predefined by the G'MIC in-
       terpreter:
	    -  '$!': 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
	  a list-valued	variable).
	    -  '$_pid':	The current process identifier,	as an integer.
	    -  '$_pixeltype': The type of image	pixels (default: 'float').
	    -	'$_prerelease':	 For pre-releases, the date of the pre-release
       as
	  'yymmdd'. For	stable releases, this variable is set to '0'.
	    -  '$_version': A 3-digits number telling about the	 current  ver-
       sion of
	  the G'MIC interpreter	 (e.g. '299').
	    -  '$_vt100': Set to '1' if	colored	text output is allowed on
	  the console. Otherwise, set to '0'.

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

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

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

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

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

	 ## Usual operators:

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

	 ## Usual math functions:

	 'abs()', 'acos()', 'acosh()', 'arg()',	'arg0()',
	  'argkth()', 'argmax()', 'argmaxabs()', 'argmin()',
	  'argminabs()', 'asin()', 'asinh()', 'atan()',
	  'atan2()', 'atanh()',	'avg()', 'bool()', 'cbrt()',
	   'ceil()', 'cos()', 'cosh()',	'cut()',
	  '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()'.

	  * '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 re-
       turn
	  '0' (false) or '1' (true).
	  * 'isfile('path')' (resp. 'isdir('path')') returns '0'
	  (false) or '1' (true)	whether	its string argument is a path to an
	  existing file	(resp. to a directory) or not.
	  * 'isin(v,a_1,...,a_n)' returns '0' (false) or '1' (true)
	  whether the first value 'v' appears in the set of other values
	  'a_i'.
	  * 'inrange(value,m,M,include_m,include_M)' returns '0' (false) or
	  '1' (true) whether the specified value lies in range '[m,M]' or not
	  ('include_m' and 'includeM' tells how	boundaries 'm' and
	  'M' are considered).
	  * 'argkth()',	'argmin()', 'argmax()',	'argminabs()',
	  'argmaxabs()'', 'avg()', 'kth()', 'min()',
	  'max()', 'minabs()', 'maxabs()', 'med()',
	  'prod()', 'std()', 'sum()' and 'var()' can be	called
	  with an arbitrary number of scalar/vector arguments.
	  * 'vargkth()', 'vargmin()', 'vargmax()',
	  'vargminabs()', 'vargmaxabs()', 'vavg()', 'vkth()',
	  'vmin()', 'vmax()', 'vminabs()', 'vmaxabs()',
	  'vmed()', 'vprod()', 'vstd()', 'vsum()' and
	  'vvar()' are the versions of the previous function with  vector-val-
       ued
	  arguments.
	  * 'round(value,rounding_value,direction)' returns a rounded value.
	  'direction' can be { -1=to-lowest | 0=to-nearest | 1=to-highest }.
	  * 'lerp(a,b,t)' returns 'a*(1-t)+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. num-
       ber of
	  image	values).
	  * 'im', 'iM',	'ia', 'iv', 'is', 'ip',
	  'ic',	'in': Respectively the minimum,	maximum, average, variance,
	  sum, product,	median value and L2-norm of the	associated  image,  if
       any
	  ('0' otherwise).
	  * 'xm', 'ym',	'zm', 'cm': The	pixel coordinates of the
	  minimum value	in the associated image, if any	('0' otherwise).
	  * 'xM', 'yM',	'zM', 'cM': The	pixel coordinates of the
	  maximum value	in the associated image, if any	('0' otherwise).
	  * All	these variables	are considered as constant values by the math
	  parser  (for optimization purposes) which is indeed the case most of
       the time.
	  Anyway, this might not be the	case, if function 'resize(#ind,..)' is
       used
	  in  the  math	 expression.  If  so,  it is safer to invoke functions
       'l()',
	  'w(_#ind)', 'h(_#ind)', ... 's(_#ind)' and 'in(_#ind)'
	  instead of the corresponding named variables.
	  * 'i': current processed pixel value (i.e. value located at '(x,y,z,
	  c)') in the associated image,	if any ('0' otherwise).
	  * 'iN': N-th channel value of	current	processed pixel	(i.e. value
	  located at '(x,y,z,N)' in the	associated image, if any ('0'
	  otherwise). 'N' must be an integer in	range '[0,9]'.
	  * 'R', 'G', 'B' and 'A' are equivalent to 'i0',
	  'i1',	'i2' and 'i3' respectively.
	  * 'I': current vector-valued processed pixel in the  associated  im-
       age, 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
       operators
	  '==' and '!='.
	  * Some vector-specific functions  can	 be  used  on  vector  values:
       'cross(X,
	  Y)' (cross product), 'dot(X,Y)' (dot product), 'size(X)' (vector
	  dimension), 'sort(X,_is_increasing,_nb_elts,_size_elt)' (sorted val-
       ues),
	  'reverse(A)' (reverse	order of components), 'shift(A,_length,
	  _boundary_conditions)' and 'same(A,B,_nb_vals,_is_case_sensitive)'
	  (vector equality test).
	  * Function 'normP(u1,...,un)'	computes the LP-norm of	the specified
	  vector ('P' being an 'unsigned integer' constant or 'inf').
	  If 'P' is omitted, the L2 norm is calculated.
	  * Function 'resize(A,size,_interpolation,_boundary_conditions)'  re-
       turns
	  a resized version of a vector	'A' with specified interpolation mode.
	  'interpolation' can be { -1=none (memory content) | 0=none | 1=near-
       est
	  | 2=average |	3=linear | 4=grid | 5=bicubic |	6=lanczos }, and
	  'boundary_conditions'	can be { 0=dirichlet | 1=neumann |  2=periodic
       |
	  3=mirror }.
	  *  Function 'find(A,B,_starting_index,_search_step)' returns the in-
       dex
	  where	sub-vector 'B' appears in vector 'A', (or '-1' if
	  'B' is not contained in 'A').	Argument 'A' can be also
	  replaced by an image index '#ind'.
	  * A '2'-dimensional vector may be seen as a complex number and  used
       in
	  those	particular functions/operators:	'**' (complex multiplication),
	  '//' (complex	division), '^^'	(complex exponentiation), '**='
	  (complex self-multiplication), '//=' (complex	self-division),	'^^='
	  (complex self-exponentiation), 'cabs()' (complex modulus), 'carg()'
	  (complex argument), 'cconj()'	(complex conjugate), 'cexp()'
	  (complex exponential), 'clog()' (complex logarithm),	'ccos()'
	  (complex cosine), 'csin()' (complex sine), 'ctan()' (complex
	  tangent), 'ccosh()' (complex hyperpolic cosine), 'csinh()' (complex
	  hyperbolic sine) and 'ctanh()' (complex hyperbolic tangent).
	  * A 'MN'-dimensional vector may be seen as a 'M' x 'N'
	  matrix and used in those particular functions/operators: '*'
	  (matrix-vector multiplication), 'det(A)' (determinant), 'diag(V)'
	  (diagonal  matrix  from  a  vector), 'eig(A)'	(eigenvalues/eigenvec-
       tors),
	  'eye(n)' (n x	n identity matrix), 'invert(A,_solver)'	(matrix
	  inverse), 'mul(A,B,_nb_colsB)' (matrix-matrix	multiplication),
	  'pseudoinvert(A,_nb_colsA,_solver)', 'rot(u,v,w,angle)' (3D
	  rotation matrix), 'rot(angle)' (2D rotation matrix), 'solve(A,B,
	  _nb_colsB)' (solver of linear	system A.X = B), 'svd(A,_nb_colsA)'
	  (singular value decomposition), 'trace(A)' (matrix trace) and
	  'transpose(A,nb_colsA)' (matrix transpose). Argument 'nb_colsB' may
	  be omitted if	it is equal to '1'.
	  *	   'mproj(S,nb_colsS,D,nb_colsD,method,max_iter,max_residual)'
       projects	a
	  matrix 'S' onto a dictionary (matrix)	'D'. Equivalent	to command
	  mproj	but inside the math evaluator.
	  *  Specifying	 a  vector-valued  math	expression as an argument of a
       command that
	  operates on image values (e.g. 'fill') modifies the  whole  spectrum
       range
	  of  the  processed image(s), for each	spatial	coordinates '(x,y,z)'.
       The
	  command does not loop	over the 'c'-axis in this case.

	 ## String manipulation:

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

	 ## Special operators:

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

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

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

	 ## Specific functions:

	  *  'addr(expr)': return the pointer address to the specified expres-
       sion
	  'expr'.
	  * 'fill(target,expr)'	or 'fill(target,index_name,expr)' fill the
	  content of the specified target (often vector-valued)	using a	 given
       expression,
	  e.g.	'V  = vector16(); fill(V,k,k^2 + k + 1);'. For a vector-valued
       target,
	   it is basically equivalent to: 'for (index_name = 0,
	  index_name<size(target), ++index_name, target[index_name] = expr);'.
	  * 'u(max)' or	'u(min,max)': return a random value between '[0,
	  max]'	or '[min,max]',	following a uniform distribution.
	  * 'f2ui(value)' and 'ui2f(value)': Convert a large unsigned
	  integer as a negative	floating point value (and vice-versa), so that
       32bits
	  floats  can  be used to store	large integers while keeping a unitary
       precision.
	  * 'i(_a,_b,_c,_d,_interpolation_type,_boundary_conditions)':	return
       the
	  value	of the pixel located at	position '(a,b,c,d)' in	the associated
	  image, if any	('0' otherwise). 'interpolation_type' can be {
	  0=nearest neighbor | 1=linear	| 2=cubic }. 'boundary_conditions' can
	  be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }. Omitted
	  coordinates  are  replaced by	their default values which are respec-
       tively
	  'x', 'y', 'z', 'c', 'interpolation' and
	  'boundary'. For instance command

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

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

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

	  and

	   fill	x%10?i:255

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

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

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

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

	  returns the 'N'-th value of the Fibonacci sequence, for 'N>=0'
	  (e.g., '46368' for 'N=24').
	  * 'while(condition,expression)' is exactly the same as 'for(init,
	  condition,expression)' without the specification of an initializing
	  expression.
	  * '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 bloc (loop, init or main environment).
	  * 'fsize('filename')'	returns	the size of the	specified 'filename'
	  (or '-1' if file does	not exist).
	  * 'date(attr,'path')'	returns	the date attribute for the given
	  'path' (file or directory), with 'attr' being	{ 0=year | 1=month
	  | 2=day | 3=day of week | 4=hour | 5=minute |	6=second }, or a  vec-
       tor of
	  those	values.
	  * 'date(_attr)' returns the specified	attribute for the current (lo-
       cale)
	  date (attributes being { 0...6=same meaning as above	|  7=millisec-
       onds }).
	  * 'print(expr1,expr2,...)' or	'print(#ind)' prints the value of
	  the specified	expressions (or	image information) on the console, and
       returns
	  the value of the last	expression (or 'nan' in	 case  of  an  image).
       Function
	  'prints(expr)'  also	prints	the  string  composed of the character
       codes
	  defined by the vector-valued expression (e.g.	'prints('Hello')').
	  * 'debug(expression)'	prints detailed	debug info about the  sequence
       of
	  operations  done  by the math	parser to evaluate the expression (and
       returns its
	  value).
	  * 'display(_X,_w,_h,_d,_s)' or 'display(#ind)' display the
	  contents of the vector 'X' (or specified image) and  wait  for  user
       events.
	  if  no  arguments are	provided, a memory snapshot of the math	parser
       environment
	  is displayed instead.
	  * 'begin(expression)'	and 'end(expression)' evaluates	the
	  specified expressions	only once, respectively	at the	beginning  and
       end of the
	  evaluation  procedure,  and this, even when multiple evaluations are
       required
	  (e.g.	in 'fill ">begin(foo = 0); ++foo"').
	  * 'copy(dest,src,_nb_elts,_inc_d,_inc_s,_opacity)' copies an entire
	  memory block of 'nb_elts' elements starting from a source value
	  'src'	to a specified destination 'dest', with	increments defined by
	  'inc_d' and 'inc_s' respectively for the destination and source
	  pointers.
	  * 'stats(_#ind)' returns the statistics vector of the	running	image
	  '[ind]', i.e the vector '[ im,iM,ia,iv,xm,ym,zm,cm,xM,yM,zM,cM,is,ip
	  ]' (14 values).
	  * 'ref(expr,a)' references specified expression 'expr' as variable
	  name 'a'.
	  * 'unref(a,b,...)' destroys references to the	named  variable	 given
       as
	  arguments.
	  *  'breakpoint()' inserts a possible computation breakpoint (useless
       with
	  the cli interface).
	  * '_(comment)	expr' just returns expression 'expr' (useful  for  in-
       serting
	  inline comments in math expressions).
	  *  'run('pipeline')'	executes the specified G'MIC pipeline as if it
       was
	  called outside the currently evaluated expression.
	  * 'set(A,'variable_name')' 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(A,'variable_name',_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,_ydila-
       tion,_zdilation,
	  _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  ef-
       fect.
	  * Overloading	macros with different number of	arguments is possible.
	  Re-defining a	previously defined macro with the same number of argu-
       ments
	  discards its previous	definition.
	  * Macro functions are	indeed processed as macros by the mathematical
	  evaluator. You should	avoid invoking them with  arguments  that  are
       themselves
	  results of assignments or self-operations. For instance,

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

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

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

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

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

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

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

	 ## Multi-threaded and in-place	evaluation:

	  *  If	 your  image  data  are	large enough and you have several CPUs
       available, it
	  is likely that the math expression passed to a 'fill', 'eval'	or
	  'input' commands is evaluated	in parallel, using  multiple  computa-
       tion
	  threads.
	  * Starting an	expression with	':' or '*' forces the evaluations
	  required  for	 an image to be	run in parallel, even if the amount of
       data to
	  process is small (beware, it may  be	slower	to  evaluate  in  this
       case!). Specify
	  ':' (rather than '*')	to avoid possible image	copy done before
	  evaluating  the  expression  (this saves memory, but do this only if
       you are sure
	  this step is not required!)
	  * If the specified expression	starts with '>'	or '<',	the pixel
	  access operators 'i()', 'i[]', 'j()' and 'j[]' return
	  values of the	image being currently modified,	in forward ('>') or
	  backward ('<') order.	The multi-threading evaluation of the  expres-
       sion is
	  disabled in this case.
	  *  Function  'critical(expr)'	 forces	the execution of the given ex-
       pression
	  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  ei-
       ther by

	   command_name: command_definition

	  or

	   command_definition (continuation)

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

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

	   flower ,,3

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

	   +command_name: command_definition

	  * A +-specialization takes priority over the regular command defini-
       tion 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  ar-
       gument
	  specified between '[]' or starting by	'_' is optional	except when
	  standing for an existing image '[image]', where 'image' can be
	  either an index number or an image name. In this case, the '[]'
	  characters are mandatory when	writing	the item. Note that all	images
       that serve
	  as illustrations in this reference documentation are	normalized  in
       range '[0,
	  255]'	 before	 being	displayed.  You	may need to do this explicitly
       (command
	  'normalize 0,255') if	you want to save and view images with the same
       aspect
	  than those illustrated in the	example	codes.

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

	 debug (+):

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

	 h:
	     Shortcut for command 'help'.

	 help:
	     command |
	     (no arg)

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

	 version:

	   Display current version number on stdout.

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

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

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

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

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

	   Insert one of the 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_re-
       covery_
	    5 |	alberto_street | alien_green | amstragram | amstragram+	|
	    analog_film_1 | analogfx_anno_1870_color | analogfx_old_style_i |
	    analogfx_old_style_ii	|	analogfx_old_style_iii	     |
       analogfx_sepia_color
	    | analogfx_soft_sepia_i | analogfx_soft_sepia_ii | anime |
	    apocalypse_this_very_moment	 |  aqua | aqua_and_orange_dark	| ara-
       bica_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 |
	    bleachbypass_3 | bleachbypass_4 | bleech_bypass_green |
	    bleech_bypass_yellow_01 | blue_cold_fade | blue_dark |  blue_house
       |
	    blue_ice  |	blue_mono | blue_shadows_01 | blues | bob_ford | bour-
       bon_64
	    | bright_green_01 |	bright_teal_orange | bright_warm | brightgreen
       |
	    brown_mobster  | brownbm | brownish	| bw_1 | bw_10 | bw_2 |	bw_3 |
       bw_4
	    | bw_5 | bw_6 | bw_7 | bw_8	| bw_9 | bw_but_yellow | byers_11 |
	    candlelight	| caribe |  chemical_168  |  chrome_01	|  cineblue  |
       cinebm_4k
	    | cinema | cinema_2	| cinema_3 | cinema_4 |	cinema_5 | cinema_noir
       |
	    cinematic-1	| cinematic-10 | cinematic-2  |	 cinematic-3  |	 cine-
       matic-4 |
	    cinematic-5	 |  cinematic-6	 |  cinematic-7	 | cinematic-8 | cine-
       matic-9 |
	    cinematic_01 | cinematic_02	| cinematic_03 | cinematic_for_flog |
	    cinematic_forest | cinematic_lady_bird | cinematic_mexico |	city |
	    city_7 | city_dust | classic_films_01 | classic_films_02 |
	    classic_films_03 | classic_films_04	| classic_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 | colorful_0209 | colornegative |
	    conflict_01	| contrail_35 |	contrast_with_highlights_protection |
	    contrasty_afternoon	| contrasty_green | crispromance | crispwarm |
	    crispwinter	| cross_process_cp_130 | cross_process_cp_14 |
	    cross_process_cp_15	| cross_process_cp_16 |	cross_process_cp_18 |
	    cross_process_cp_3 |  cross_process_cp_4  |	 cross_process_cp_6  |
       crushin
	    | cubicle_99 | d_o_1 | dark_blues_in_sunlight | dark_green_02 |
	    dark_green_1 | dark_man_x |	dark_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 | deepskin-
       tones_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 |
	    extreme | fade | fade_to_green | faded | faded_47 |	faded_alt |
	    faded_analog | faded_extreme | faded_green | faded_pink-ish	|
	    faded_print	| faded_retro_01 | faded_retro_02 | faded_vivid	|
	    fadedlook |	fallcolors | faux_infrared | faux_infrared_bw_1	|
	    faux_infrared_color_p_2 | faux_infrared_color_p_3 |
	    faux_infrared_color_r_0a | faux_infrared_color_r_0b	|
	    faux_infrared_color_yp_1 | fgcinebasic | fgcinebright | fgcinecold
       |
	    fgcinedrama	| fgcinetealorange_1 | fgcinetealorange_2 |  fgcinevi-
       brant
	    | fgcinewarm | film_0987 | film_9879 | film_gb-19 |	film_high_con-
       trast
	    |  film_print_01  |	  film_print_02	  |   filmic   |   flat_30   |
       flat_blue_moon |
	    flavin  |  foggynight  |  folger_50	 | formula_b | french_comedy |
       frosted
	    | frostedbeachpicnic | fuji_160c | fuji_160c_+ | fuji_160c_++ |
	    fuji_160c_-	| fuji_3510_constlclip | fuji_3510_constlmap |
	    fuji_3510_cuspclip | fuji_3513_constlclip |	fuji_3513_constlmap |
	    fuji_3513_cuspclip | fuji_400h | fuji_400h_+ | fuji_400h_++	|
	    fuji_400h_-	| fuji_800z | fuji_800z_+ | fuji_800z_++ | fuji_800z_-
       |
	    fuji_astia_100_generic | fuji_astia_100f | fuji_fp-100c |
	    fuji_fp-100c_+ | fuji_fp-100c_++ | fuji_fp-100c_+++	|
	    fuji_fp-100c_++_alt	| fuji_fp-100c_- | fuji_fp-100c_-- |
	    fuji_fp-100c_alt | fuji_fp-100c_cool | fuji_fp-100c_cool_+ |
	    fuji_fp-100c_cool_++  | fuji_fp-100c_cool_-	| fuji_fp-100c_cool_--
       |
	    fuji_fp-100c_negative | fuji_fp-100c_negative_+ |
	    fuji_fp-100c_negative_++ | fuji_fp-100c_negative_+++ |
	    fuji_fp-100c_negative_++_alt | fuji_fp-100c_negative_- |
	    fuji_fp-100c_negative_-- | fuji_fp-3000b | fuji_fp-3000b_+ |
	    fuji_fp-3000b_++ | fuji_fp-3000b_+++ | fuji_fp-3000b_- |
	    fuji_fp-3000b_-- | fuji_fp-3000b_hc	| fuji_fp-3000b_negative |
	    fuji_fp-3000b_negative_+ | fuji_fp-3000b_negative_++ |
	    fuji_fp-3000b_negative_+++ | fuji_fp-3000b_negative_- |
	    fuji_fp-3000b_negative_-- |	fuji_fp-3000b_negative_early |
	    fuji_fp_100c | fuji_hdr | fuji_neopan_1600 | fuji_neopan_1600_+ |
	    fuji_neopan_1600_++	| fuji_neopan_1600_- | fuji_neopan_acros_100 |
	    fuji_provia_100_generic | fuji_provia_100f | fuji_provia_400f |
	    fuji_provia_400x | fuji_sensia_100 | fuji_superia_100 |
	    fuji_superia_100_+ | fuji_superia_100_++ | fuji_superia_100_- |
	    fuji_superia_1600 |	fuji_superia_1600_+ | fuji_superia_1600_++ |
	    fuji_superia_1600_-	| fuji_superia_200 | fuji_superia_200_xpro |
	    fuji_superia_400 | fuji_superia_400_+ | fuji_superia_400_++	|
	    fuji_superia_400_- | fuji_superia_800 | fuji_superia_800_+ |
	    fuji_superia_800_++	| fuji_superia_800_- | fuji_superia_hg_1600 |
	    fuji_superia_reala_100 | fuji_superia_x-tra_800 |
	    fuji_velvia_100_generic | fuji_velvia_50 | fuji_xtrans_iii_acros |
	    fuji_xtrans_iii_acros+g | fuji_xtrans_iii_acros+r |
	    fuji_xtrans_iii_acros+ye | fuji_xtrans_iii_astia |
	    fuji_xtrans_iii_classic_chrome | fuji_xtrans_iii_mono |
	    fuji_xtrans_iii_mono+g | fuji_xtrans_iii_mono+r |
	    fuji_xtrans_iii_mono+ye | fuji_xtrans_iii_pro_neg_hi |
	    fuji_xtrans_iii_pro_neg_std	| fuji_xtrans_iii_provia |
	    fuji_xtrans_iii_sepia | fuji_xtrans_iii_velvia | fusion_88 |
	    futuristicbleak_1 |	futuristicbleak_2 | futuristicbleak_3 |
	    futuristicbleak_4 |	going_for_a_walk | golden | golden_bright |
	    golden_fade	  |   golden_mono    |	  golden_night_softner_43    |
       golden_sony_37 |
	    golden_vibrant	|      goldengate      |      goldentime     |
       goldfx_bright_spring_breeze
	    | goldfx_bright_summer_heat	| goldfx_hot_summer_heat |
	    goldfx_perfect_sunset_01min	| goldfx_perfect_sunset_05min |
	    goldfx_perfect_sunset_10min	| goldfx_spring_breeze |
	    goldfx_summer_heat | good_morning |	green_15 | green_2025 |
	    green_action | green_afternoon | green_and_orange |	green_blues |
	    green_conflict | green_day_01 | green_day_02 | green_g_09 |
	    green_indoor | green_light | green_mono | green_yellow |
	    greenish_contrasty | greenish_fade | greenish_fade_1 | gremerta |
	    hackmanite | hallowen_dark | happyness_133 | hard_teal_orange |
	    harsh_day |	harsh_sunset | helios |	herderite | heulandite |  hid-
       denite
	    |	highlights_protection	|   hilutite  |	 hitman	 |  hlg_1_1  |
       honey_light |
	    hong_kong |	horrorblue | howlite | hydracore | hyla_68  |  hypers-
       thene |
	    hypnosis | hypressen | ilford_delta_100 | ilford_delta_3200	|
	    ilford_delta_3200_+	| ilford_delta_3200_++ | ilford_delta_3200_- |
	    ilford_delta_400   |  ilford_fp_4_plus_125	|  ilford_hp_5	|  il-
       ford_hp_5_+
	    | ilford_hp_5_++ | ilford_hp_5_- | ilford_hp_5_plus_400 |
	    ilford_hps_800 | ilford_pan_f_plus_50 | ilford_xp_2	|  indoor_blue
       |
	    industrial_33 | infrared_-_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 | kodak_2383_constlmap | kodak_2383_cuspclip
       |
	    kodak_2393_constlclip | kodak_2393_constlmap | kodak_2393_cuspclip
       |
	    kodak_bw_400_cn | kodak_e-100_gx_ektachrome_100 |
	    kodak_ektachrome_100_vs | kodak_ektachrome_100_vs_generic |
	    kodak_ektar_100 | kodak_elite_100_xpro | kodak_elite_chrome_200 |
	    kodak_elite_chrome_400    |	   kodak_elite_color_200     |	   ko-
       dak_elite_color_400
	    | kodak_elite_extracolor_100 | kodak_hie_hs_infra |
	    kodak_kodachrome_200 | kodak_kodachrome_25 | kodak_kodachrome_64 |
	    kodak_kodachrome_64_generic	  |   kodak_portra_160	 |  kodak_por-
       tra_160_+ |
	    kodak_portra_160_++	| kodak_portra_160_- | kodak_portra_160_nc |
	    kodak_portra_160_nc_+  |   kodak_portra_160_nc_++	|   kodak_por-
       tra_160_nc_-
	    |	kodak_portra_160_vc   |	  kodak_portra_160_vc_+	 |  kodak_por-
       tra_160_vc_++
	    | kodak_portra_160_vc_- | kodak_portra_400 | kodak_portra_400_+ |
	    kodak_portra_400_++	| kodak_portra_400_- | kodak_portra_400_nc |
	    kodak_portra_400_nc_+  |   kodak_portra_400_nc_++	|   kodak_por-
       tra_400_nc_-
	    |	kodak_portra_400_uc   |	  kodak_portra_400_uc_+	 |  kodak_por-
       tra_400_uc_++
	    |  kodak_portra_400_uc_-  |	  kodak_portra_400_vc	|   kodak_por-
       tra_400_vc_+
	    |  kodak_portra_400_vc_++  |  kodak_portra_400_vc_-	 |  kodak_por-
       tra_800 |
	    kodak_portra_800_+ | kodak_portra_800_++ | kodak_portra_800_- |
	    kodak_portra_800_hc	| kodak_t-max_100 | kodak_t-max_3200 |
	    kodak_t-max_400 | kodak_tmax_3200 |	kodak_tmax_3200_+ |
	    kodak_tmax_3200_++ | kodak_tmax_3200_- | kodak_tmax_3200_alt |
	    kodak_tri-x_400 | kodak_tri-x_400_+	| kodak_tri-x_400_++ |
	    kodak_tri-x_400_-  |  kodak_tri-x_400_alt  |  korben_214  |	 land-
       scape_01	|
	    landscape_02 | landscape_03	| landscape_04 | landscape_05 |
	    landscape_1	 |  landscape_10  |  landscape_2 | landscape_3 | land-
       scape_4 |
	    landscape_5	| landscape_6 |	 landscape_7  |	 landscape_8  |	 land-
       scape_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_giv-
       ing_tree
	    | light_blown | lomo | lomography_redscale_100 |
	    lomography_x-pro_slide_200 | london_nights | louetta |
	    low_contrast_blue |	low_key_01 | lucky_64 |	lushgreensummer	|
	    magenta_day	| magenta_day_01 | magenta_dream | magenta_yellow |
	    magentacoffee  |  matrix  |	 mckinnon_75 | memories	| metropolis |
       milo_5
	    | minimalistcaffeination | modern_film | modern_films_01 |
	    modern_films_02  |	modern_films_03	 |  modern_films_04   |	  mod-
       ern_films_05
	    | modern_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 |	 moon-
       light
	    | 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_orange	| neutral_warm_fade | newspaper	| night_01 |
	    night_blade_4  |  night_king_141  |	 night_spy  |  nightfromday  |
       nightlife
	    | nostalgiahoney | nostalgic | nw-1	| nw-10	| nw-2 | nw-3 |	nw-4 |
	    nw-5 | nw-6	| nw-7 | nw-8 |	nw-9 | old_west	| once_upon_a_time |
	    only_red | only_red_and_blue | operation_yellow | orange_dark_4 |
	    orange_dark_7 | orange_dark_look | orange_tone  |  orange_underex-
       posed |
	    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
       |
	    pmnight_05 | polaroid_664 |	polaroid_665 | polaroid_665_+ |
	    polaroid_665_++ | polaroid_665_- | polaroid_665_-- |
	    polaroid_665_negative | polaroid_665_negative_+ |
	    polaroid_665_negative_-  | polaroid_665_negative_hc	| polaroid_667
       |
	    polaroid_669 | polaroid_669_+ | polaroid_669_++ | polaroid_669_+++
       |
	    polaroid_669_- | polaroid_669_-- | polaroid_669_cold |
	    polaroid_669_cold_+	| polaroid_669_cold_- |	polaroid_669_cold_-- |
	    polaroid_672 | polaroid_690	| polaroid_690_+ | polaroid_690_++ |
	    polaroid_690_- | polaroid_690_-- | polaroid_690_cold |
	    polaroid_690_cold_+	| polaroid_690_cold_++ | polaroid_690_cold_- |
	    polaroid_690_cold_-- | polaroid_690_warm | polaroid_690_warm_+ |
	    polaroid_690_warm_++  | polaroid_690_warm_-	| polaroid_690_warm_--
       |
	    polaroid_polachrome	| polaroid_px-100uv+_cold |
	    polaroid_px-100uv+_cold_+ |	polaroid_px-100uv+_cold_++ |
	    polaroid_px-100uv+_cold_+++	| polaroid_px-100uv+_cold_- |
	    polaroid_px-100uv+_cold_-- | polaroid_px-100uv+_warm |
	    polaroid_px-100uv+_warm_+ |	polaroid_px-100uv+_warm_++ |
	    polaroid_px-100uv+_warm_+++	| polaroid_px-100uv+_warm_- |
	    polaroid_px-100uv+_warm_-- | polaroid_px-680 | polaroid_px-680_+ |
	    polaroid_px-680_++ | polaroid_px-680_- | polaroid_px-680_--	|
	    polaroid_px-680_cold | polaroid_px-680_cold_+ |
	    polaroid_px-680_cold_++ | polaroid_px-680_cold_++_alt |
	    polaroid_px-680_cold_- | polaroid_px-680_cold_-- |
	    polaroid_px-680_warm | polaroid_px-680_warm_+ |
	    polaroid_px-680_warm_++ | polaroid_px-680_warm_- |
	    polaroid_px-680_warm_-- | polaroid_px-70 | polaroid_px-70_+	|
	    polaroid_px-70_++ |	polaroid_px-70_+++ | polaroid_px-70_- |
	    polaroid_px-70_-- |	polaroid_px-70_cold | polaroid_px-70_cold_+ |
	    polaroid_px-70_cold_++ | polaroid_px-70_cold_- |
	    polaroid_px-70_cold_--     |     polaroid_px-70_warm     |	   po-
       laroid_px-70_warm_+ |
	    polaroid_px-70_warm_++ | polaroid_px-70_warm_- |
	    polaroid_px-70_warm_-- | polaroid_time_zero_expired	|
	    polaroid_time_zero_expired_+ | polaroid_time_zero_expired_++ |
	    polaroid_time_zero_expired_- | polaroid_time_zero_expired_-- |
	    polaroid_time_zero_expired_--- | polaroid_time_zero_expired_cold |
	    polaroid_time_zero_expired_cold_-	  |	polaroid_time_zero_ex-
       pired_cold_--
	    | polaroid_time_zero_expired_cold_--- | portrait_1 | portrait_10 |
	    portrait_2 | portrait_3 | portrait_4 | portrait_5 |	portrait_6 |
	    portrait_7 | portrait_8 | portrait_9 | progressen |
	    protect_highlights_01 | prussian_blue | pseudogrey | purple	| pur-
       ple_2
	    |  red_afternoon_01	 | red_day_01 |	red_dream_01 | redblueyellow |
       reds
	    | reds_oranges_yellows | reeve_38 |	remy_24	| rest_33 | retro |
	    retro_brown_01 | retro_magenta_01 |	 retro_summer_3	 |  retro_yel-
       low_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_sail-
       ing |
	    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_yel-
       low |
	    summer   |	summer_alt  |  sunlightlove  |	sunny  |  sunny_alt  |
       sunny_rich |
	    sunny_warm | sunset_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 | tealmagentagold | tealorange | tealorange_1 |
	    tealorange_2  |  tealorange_3  |  technicalfx_backlight_filter   |
       teigen_28
	    |  tensiongreen_1  |  tensiongreen_2  |  tensiongreen_3 | tension-
       green_4 |
	    terra_4 | the_matrices | thriller_2	| toastedgarden	| trent_18 |
	    true_colors_8 | turkiest_42	| tweed_71 | ultra_water |  undeniable
       |
	    undeniable_2 | unknown | urban_01 |	urban_02 | urban_03 | urban_04
       |
	    urban_05 | urban_cowboy | uzbek_bukhara | uzbek_marriage |
	    uzbek_samarcande | velvetia	| very_warm_greenish |	vfb_21	|  vi-
       brant |
	    vibrant_alien | vibrant_contrast | vibrant_cromeish	| victory |
	    vintage | vintage_01 | vintage_02 |	vintage_03 | vintage_04	|
	    vintage_05 | vintage_163 | vintage_alt | vintage_brighter |
	    vintage_chrome | vintage_mob | vintage_warmth_1 | violet_taste |
	    vireo_37 | 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	| yel-
       low_55b
	    | yellow_film_01 | yellowstone | you_can_do_it | zed_32 |  zeke_39
       |
	    zilverfx_bw_solarization | zilverfx_infrared | zilverfx_vintage_bw
	    } :	Default	values:	'resolution=33'	and
	    'cut_and_round=1'.

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

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

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

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

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

	   Default value: 'add_debug_info=1'.

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

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

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

	   Default value: 'mode=1'.

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

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

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

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

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

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

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

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

	 d0:
	     Shortcut for command 'display0'.

	 display0:

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

	 d2d:
	     Shortcut for command 'display2d'.

	 display2d:

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

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

	 d3d:
	     Shortcut for command 'display3d'.

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

	   Display selected 3D objects in an interactive viewer	(use  the  in-
       stant
	   display window [0] if opened).
	   (equivalent to shortcut command 'd3d').

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

	 da:
	     Shortcut for command 'display_array'.

	 display_array:
	     _width>0,_height>0

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

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

	 dc:
	     Shortcut for command 'display_camera'.

	 display_camera:

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

	 dfft:
	     Shortcut for command 'display_fft'.

	 display_fft:

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

	   Example:
	     [#1] image.jpg +display_fft

	 dg:
	     Shortcut for command 'display_graph'.

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

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

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

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

	 dh:
	     Shortcut for command 'display_histogram'.

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

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

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

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

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

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

	   Render 2D or	3D parametric curve or point clouds from selected  im-
       age data.
	   Curve points	are defined as pixels of a 2 or	3-channel image.
	   If  the point image contains	more than 3 channels, additional chan-
       nels
	   define the (R,G,B) color for	each vertex.
	   If 'outline_opacity>1', the outline is colored according to the
	   specified vertex colors and
	   'outline_opacity-1' is used as the actual drawing opacity.

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

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

	 dp:
	     Shortcut for command 'display_parallel'.

	 display_parallel:

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

	 dp0:
	     Shortcut for command 'display_parallel0'.

	 display_parallel0:

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

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

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

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

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

	 dq:
	     Shortcut for command 'display_quiver'.

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

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

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

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

	 drgba:
	     Shortcut for command 'display_rgba'.

	 display_rgba:
	     _background_RGB_color

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

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

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

	 dt:
	     Shortcut for command 'display_tensors'.

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

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

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

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

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

	 dw:
	     Shortcut for command 'display_warp'.

	 display_warp:
	     _cell_size>0

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

	   Default value: 'cell_size=15'.

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

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

	 echo (+):
	     message

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

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

	 echo_file:
	     filename,message

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

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

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

	   Default values: 'smoothness=1' and 'x0=y0=0'.

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

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

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

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

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

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

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

	 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 (start-
       ing
	   from	'0').
	   Otherwise, a	'WxH' image is inserted	at the end of the list,	with
	   each	vector-valued pixel 'I(x,y)' encoding the number or the	string
	   of each cell.
	   This	command	returns	the 'W,H' dimension of the read	array, as the
	   status.

	   Default value: 'read_data_as=1'.

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

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

	   Default value: 'convert_1d_cluts_to_3d=1'.

	 input_flo:
	     "filename"

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

	 ig:
	     Shortcut for command 'input_glob'.

	 input_glob:
	     pattern

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

	 input_gpl:
	     filename

	   Input specified filename as a .gpl palette data file.

	 it:
	     Shortcut for command 'input_text'.

	 input_text:
	     filename

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

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

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

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

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

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

	   Default value: 'format_options'=(undefined).

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

	   Output selected images as raw RGB-565 files.

	   Default value: 'reverse_endianness=0'.

	 output_cube:
	     "filename"

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

	 output_flo:
	     "filename"

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

	 output_ggr:
	     filename,_gradient_name

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

	 output_gmz:
	     filename,_datatype

	   Output selected images as .gmz files	(G'MIC native file format).
	   'datatype' can be { bool | uchar | char | ushort | short | uint |
	   int | uint64	| int64	| float	| double }.

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

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

	   Default value: 'save_materials=1'.

	 ot:
	     Shortcut for command 'output_text'.

	 output_text:
	     filename

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

	 on:
	     Shortcut for command 'outputn'.

	 outputn:
	     filename,_index

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

	 op:
	     Shortcut for command 'outputp'.

	 outputp:
	     prefix

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

	   Default value: 'prefix=_'.

	 ow:
	     Shortcut for command 'outputw'.

	 outputw:

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

	 ox:
	     Shortcut for command 'outputx'.

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

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

	   Default value: 'output_at_same_location=0'.

	 parse_cli:
	     _output_mode,_{ * | command_name }

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

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

	 parse_gmd:

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

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

	   Convert selected gmd-formatted text images to html format.

	   Default values: 'include_default_header_footer=1'.

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

	   Convert selected gmd-formatted text images to ascii format.

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

	 parse_gui:
	     _outputmode,_{ * |	filter_name}

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

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

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

	   Default value: 'shared_state=2'.

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

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

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

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

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

	 print (+):

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

	   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 done

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

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

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

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

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

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

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

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

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

	 shape_circle:
	     _size>=0

	   Input a 2D circle binary shape with specified size.

	   Default value: 'size=512'.

	   Example:
	     [#1] shape_circle ,

	 shape_cupid:
	     _size>=0

	   Input a 2D cupid binary shape with specified	size.

	   Default value: 'size=512'.

	   Example:
	     [#1] shape_cupid ,

	 shape_diamond:
	     _size>=0

	   Input a 2D diamond binary shape with	specified size.

	   Default value: 'size=512'.

	   Example:
	     [#1] shape_diamond	,

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

	   Input a 2D Dragon curve with	specified size.

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

	   Example:
	     [#1] shape_dragon ,

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

	   Input a 2D Barnsley fern with specified size.

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

	   Example:
	     [#1] shape_fern ,

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

	   Input a 2D gear binary shape	with specified size.

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

	   Example:
	     [#1] shape_gear ,

	 shape_heart:
	     _size>=0

	   Input a 2D heart binary shape with specified	size.

	   Default value: 'size=512'.

	   Example:
	     [#1] shape_heart ,

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

	   Input a 2D polygonal	binary shape with specified geometry.

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

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

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

	   Input a 2D snowflake	binary shape with specified size.

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

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

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

	   Input a 2D star binary shape	with specified size.

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

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

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

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

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

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

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

	 sp:
	     Shortcut for command 'sample'.

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

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

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

	   Example:
	     [#1] repeat 6 sample done

	 srand (+):
	     value |
	     (no arg)

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

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

	   Store selected images into one or several named variables.
	   Selected  images  are  transferred to the variables,	and are	so re-
       moved from
	   the image list.
	   (except if the prepended variant of the command '+store[selection]'
	   is used).
	   If a	single variable	name is	specified, all images of the selection
       are
	   assigned
	   to  the  named  variable. Otherwise,	there must be as many variable
       names as
	   images
	   in the selection, and each selected image is	assigned to each spec-
       ified
	   named variable.
	   Use	command	'input $variable_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]^spec-
       trum.

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

	 unserialize (+):

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

	 up:
	     Shortcut for command 'update'.

	 update:

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

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

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

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

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

	   Default value: 'level=1'.

	 wait (+):
	     delay |
	     (no arg)

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

	   Default value: 'delay=0'.

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

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

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

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

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

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

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

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

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

	 keep (+):

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

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

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

	 move (+):
	     position[%]

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

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

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

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

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

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

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

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

	 remove	(+):

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

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

	 remove_duplicates:

	   Remove duplicates images in the selected images list.

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

	 remove_empty:

	   Remove empty	images in the selected image list.

	 rmn:
	     Shortcut for command 'remove_named'.

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

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

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

	 reverse (+):

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

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

	 sort_list:
	     _ordering={ + | - },_criterion

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

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

	   Example:
	     [#1]  (1;4;7;3;9;2;4;7;6;3;9;1;0;3;3;2) split y sort_list +,i ap-
       pend 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-
       trigometric-commands

	 acosh (+):

	   Compute the pointwise hyperbolic arccosine of selected images.

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

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

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

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

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

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

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

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

	 argmax:

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

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

	 argmaxabs:

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

	 argmin:

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

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

	 argminabs:

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

	 asin (+):

	   Compute the pointwise arcsine of selected images.

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

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

	 asinh (+):

	   Compute the pointwise hyperbolic arcsine of selected	images.

	 atan (+):

	   Compute the pointwise arctangent of selected	images.

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

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

	 atan2 (+):
	     [x_argument]

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

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

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

	 atanh (+):

	   Compute the pointwise hyperbolic arctangent of selected images.

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

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

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

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

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

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

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

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

	 cos (+):

	   Compute the pointwise cosine	of selected images.

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

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

	 cosh (+):

	   Compute the pointwise hyperbolic cosine of selected images.

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

	 deg2rad:

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

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

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

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

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

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

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

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

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

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

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

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

	 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	speci-
       fied value,
	    image or mathematical expression, or compute the boolean  'greater
       than' of
	   selected images.
	   (equivalent to shortcut command '>').

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

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

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

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

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

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

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

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

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

	 log (+):

	   Compute the pointwise base-e	logarithm of selected images.

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

	 log10 (+):

	   Compute the pointwise base-10 logarithm of selected images.

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

	 log2 (+):

	   Compute the pointwise base-2	logarithm of selected images

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

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

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

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

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

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

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

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

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

	 med:

	   Compute the median of selected images.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	   See also: add, sub, div.

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

	 mul_channels:
	     value1,_value2,...,_valueN

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

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

	 mul_complex:
	     [multiplier_real,multiplier_imag]

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

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

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

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

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

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

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

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

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

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

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

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

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

	 rad2deg:

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

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

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

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

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

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

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

	 sign (+):

	   Compute the pointwise sign of selected images.

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

	 sin (+):

	   Compute the pointwise sine of selected images.

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

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

	 sinc (+):

	   Compute the pointwise sinc function of selected images.

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

	 sinh (+):

	   Compute the pointwise hyperbolic sine of selected images.

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

	 sqr (+):

	   Compute the pointwise square	function of selected images.

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

	 sqrt (+):

	   Compute the pointwise square	root of	selected images.

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

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

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

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

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

	 tan (+):

	   Compute the pointwise tangent of selected images.

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

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

	 tanh (+):

	   Compute the pointwise hyperbolic tangent of selected	images.

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

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

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

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

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

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

	   Apply curve transformation to image values.

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

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

	 apply_gamma:
	     gamma>=0

	   Apply gamma correction to selected images.

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

	 balance_gamma:
	     _ref_color1,...

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

	   Default value: 'ref_color1=128'.

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

	 cast:
	     datatype_source,datatype_target

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

	 complex2polar:

	   Compute complex to polar transforms of selected images.

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

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

	   Compress selected color LUTs	as sequences of	colored	keypoints.

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

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

	   Compress selected images as 2xN data	matrices, using	RLE algorithm.
	   Set 'maximum_sequence_length=0'  to	disable	 maximum  length  con-
       straint.

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

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

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

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

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

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

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

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

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

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

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

	 decompress_rle:

	   Decompress selected data vectors, using RLE algorithm.

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

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

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

	 eigen2tensor:

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

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

	 endian	(+):
	     _datatype

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	 ir:
	     Shortcut for command 'inrange'.

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

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

	   Default value: 'include_min_boundary=include_max_boundary=1'.

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

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

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

	   Default value: 'boundary_conditions=0'.

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

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

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

	   Apply specified matrix to channels of selected images.

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

	 negate:
	     base_value	|
	     (no arg)

	   Negate image	values.

	   Default value: 'base_value=(undefined)'.

	   Example:
	     [#1] image.jpg +negate

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

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

	   Default value: 'noise_type=0'.

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

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

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

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

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

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

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

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

	   Example:
	     [#1] 300,300 noise_poissondisk 8

	 normp:
	     p>=0

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

	   Default value: 'p=2'.

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

	 norm:

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

	   Example:
	     [#1] image.jpg +norm

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

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

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

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

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

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

	 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 se-
       lected
	   images.

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

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

	 oneminus:

	   For each selected image, compute one	minus image.

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

	 otsu:
	     _nb_levels>0

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

	   Default value: 'nb_levels=256'.

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

	 polar2complex:

	   Compute polar to complex transforms of selected images.

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

	   Quantize selected images.

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

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

	 quantize_area:
	     _min_area>0

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

	   Default value: 'min_area=10'.

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

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

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

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

	 replace:
	     source,target

	   Replace pixel values	in selected images.

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

	 replace_inf:
	     _expression

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

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

	 replace_nan:
	     _expression

	   Replace all NaN values in selected images by	specified expression.

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

	 replace_naninf:
	     _expression

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

	 replace_seq:
	     "search_seq","replace_seq"

	   Search and replace a	sequence of values in selected images.

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

	 replace_str:
	     "search_str","replace_str"

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

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

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

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

	   Default value: 'rounding_type=0'.

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

	 roundify:
	     gamma>=0

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

	   Default value: 'gamma=0'.

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

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

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

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

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

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

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

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

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

	   Default value: 'is_soft=0'.

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

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

	 vector2tensor:

	   Convert selected vector fields to corresponding tensor fields.

	 12.6. Colors
	       ------

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

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

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

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

	 ac:
	     Shortcut for command 'apply_channels'.

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

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

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

	   Default value: 'value_action=0'.

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

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

	   Index selected vector-valued	images by adapted colormaps.

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

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

	 bayer2rgb:
	     _GM_smoothness,_RB_smoothness1,_RB_smoothness2

	   Transform selected RGB-Bayer	sampled	images to color	images.

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

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

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

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

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

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

	 cmy2rgb:

	   Convert color representation	of selected images from	CMY to RGB.

	 cmyk2rgb:

	   Convert color representation	of selected images from	CMYK to	RGB.

	 colorblind:
	     type={ 0=protanopia | 1=protanomaly | 2=deuteranopia | 3=deutera-
       nomaly |
	       4=tritanopia  |	5=tritanomaly  |  6=achromatopsia  |  7=achro-
       matomaly	}

	   Simulate color blindness vision.

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

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

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

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

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

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

	 compose_channels:

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

	   Default value: '1=+'.

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

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

	 direction2rgb:

	   Compute RGB representation of selected 2D direction fields.

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

	 ditheredbw:

	   Create dithered B&W version of selected images.

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

	 fc:
	     Shortcut for command 'fill_color'.

	 fill_color:
	     col1,...,colN

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

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

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

	 gradient2rgb:
	     _is_orientation={ 0 | 1 }

	   Compute RGB representation of 2D gradient of	selected images.

	   Default value: 'is_orientation=0'.

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

	 hcy2rgb:

	   Convert color representation	of selected images from	HCY to RGB.

	 hsi2rgb:

	   Convert color representation	of selected images from	HSI to RGB.

	 hsi82rgb:

	   Convert color representation	of selected images from	HSI8 to	RGB.

	 hsl2rgb:

	   Convert color representation	of selected images from	HSL to RGB.

	 hsl82rgb:

	   Convert color representation	of selected images from	HSL8 to	RGB.

	 hsv2rgb:

	   Convert color representation	of selected images from	HSV to RGB.

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

	 hsv82rgb:

	   Convert color representation	of selected images from	HSV8 to	RGB.

	 int2rgb:

	   Convert color representation	of selected images from	INT24 to RGB.

	 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 con-
       trast.
	   This	function performs a specific score  maximization  to  generate
       the
	   result, so
	   it may take some time when 'nb_colors' is high.

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

	 map_clut:
	     [clut] | "clut_name"

	   Map specified RGB color LUT to selected images.

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

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

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

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

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

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

	 oklab2rgb:

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

	 palette:
	     palette_name | palette_number

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

	   Example:
	     [#1] palette hsv

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

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

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

	   Example:
	     [#1] pseudogray 5

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

	   Replace pixels from/to specified colors in selected images.

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

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

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

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

	 rgb2bayer:
	     _start_pattern=0,_color_grid=0

	   Transform selected color images to RGB-Bayer	sampled	images.

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

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

	 rgb2cmy:

	   Convert color representation	of selected images from	RGB to CMY.

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

	 rgb2cmyk:

	   Convert color representation	of selected images from	RGB to CMYK.

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

	 rgb2hcy:

	   Convert color representation	of selected images from	RGB to HCY.

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

	 rgb2hsi:

	   Convert color representation	of selected images from	RGB to HSI.

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

	 rgb2hsi8:

	   Convert color representation	of selected images from	RGB to HSI8.

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

	 rgb2hsl:

	   Convert color representation	of selected images from	RGB to HSL.

	   Example:
	     [#1] image.jpg rgb2hsl split c
	     [#2] image.jpg rgb2hsl +split  c  add[-3]	100  mod[-3]  360  ap-
       pend[-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 ap-
       pend[-3--1] c
	      hsv2rgb

	 rgb2hsv8:

	   Convert color representation	of selected images from	RGB to HSV8.

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

	 rgb2int:

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

	   Example:
	     [#1] image.jpg rgb2int

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

	   Convert color representation	of selected images from	RGB to Jzazbz.

	   Default value: 'illuminant=2'.

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

	   Convert color representation	of selected images from	RGB to Lab.

	   Default value: 'illuminant=2'.

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

	   Convert color representation	of selected images from	RGB to Lab8.

	   Default value: 'illuminant=2'.

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

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

	   Convert color representation	of selected images from	RGB to Lch.

	   Default value: 'illuminant=2'.

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

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

	   Convert color representation	of selected images from	RGB to Lch8.

	   Default value: 'illuminant=2'.

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

	 rgb2luv:

	   Convert color representation	of selected images from	RGB to LUV.

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

	 rgb2oklab:

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

	 rgb2ryb:

	   Convert color representation	of selected images from	RGB to RYB.

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

	 rgb2srgb:

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

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

	   Convert color representation	of selected images from	RGB to XYZ.

	   Default value: 'illuminant=2'.

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

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

	   Convert color representation	of selected images from	RGB to XYZ8.

	   Default value: 'illuminant=2'.

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

	 rgb2yiq:

	   Convert color representation	of selected images from	RGB to YIQ.

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

	 rgb2yiq8:

	   Convert color representation	of selected images from	RGB to YIQ8.

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

	 rgb2ycbcr:

	   Convert color representation	of selected images from	RGB to YCbCr.

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

	 rgb2yuv:

	   Convert color representation	of selected images from	RGB to YUV.

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

	 rgb2yuv8:

	   Convert color representation	of selected images from	RGB to YUV8.

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

	 remove_opacity:

	   Remove opacity channel of selected images.

	 ryb2rgb:

	   Convert color representation	of selected images from	RYB to RGB.

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

	   Select pixels with specified	color in selected images.

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

	   Tutorial: https://gmic.eu/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 re-
       gions and
	   have	an additional alpha-channel.

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

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

	 split_opacity:

	   Split color and opacity parts of selected images.

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

	   Convert color representation	of selected images from	sRGB to	Lab.

	   Default value: 'illuminant=2'.

	   Example:
	     [#1] image.jpg srgb2lab split c
	     [#2] image.jpg srgb2lab +split c mul[-2,-1] 2.5  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 Tschumperl.

	 to_rgb:

	   Force selected images to be in RGB mode.

	 to_rgba:

	   Force selected images to be in RGBA mode.

	 transfer_histogram:
	     [reference_image],_nb_levels>0,_color_channels

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

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

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

	 transfer_pca:
	     [reference_image],_color_channels

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

	   Default value: 'color_channels=all'.

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

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

	   Transfer colors from	selected source	images to  selected  reference
       image
	   (given as argument).
	   'gamma' determines the importance of	color occurrences in the
	   matching process (0=none to 1=huge).
	   'regularization' determines the number of guided filter iterations
	   to remove quantization effects.
	   'luminosity_constraints' tells if luminosity	constraints must be
	   applied on non-confident matched colors.
	   'is_constraints' tells if additional	hard color constraints must be
	   set (opens an interactive window).

	   Default values: 'gamma=0.3','regularization=8',
	    'luminosity_constraints=0.1', 'rgb_resolution=64' and
	    'is_constraints=0'.

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

	 xyz2jzazbz:

	   Convert color representation	of selected images from	XYZ to RGB.

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

	   Convert color representation	of selected images from	XYZ to Lab.

	   Default value: 'illuminant=2'.

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

	   Convert color representation	of selected images from	XYZ to RGB.

	   Default value: 'illuminant=2'.

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

	   Convert color representation	of selected images from	XYZ8 to	RGB.

	   Default value: 'illuminant=2'.

	 ycbcr2rgb:

	   Convert color representation	of selected images from	YCbCr to RGB.

	 yiq2rgb:

	   Convert color representation	of selected images from	YIQ to RGB.

	 yiq82rgb:

	   Convert color representation	of selected images from	YIQ8 to	RGB.

	 yuv2rgb:

	   Convert color representation	of selected images from	YUV to RGB.

	 yuv82rgb:

	   Convert selected images from	YUV8 to	RGB color bases.

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

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

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

	   Append  specified  image to selected	images,	or all selected	images
       together,
	    along specified axis.
	   (equivalent to shortcut command 'a').

	   'axis' can be { x | y | z | c }.
	   Usual 'centering' values are	{ 0=left-justified | 0.5=centered |
	   1=right-justified }.

	   Default value: 'centering=0'.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	   Default values: 'threshold=0%', 'min_area=0.1%',
	    'is_high_connectivity=0' and 'output_type=1'.

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

	 autocrop_seq:
	     value1,value2,... | auto

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

	   Default value: auto mode.

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

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

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

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

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

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

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

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

	 crop (+):
	     x0[%],x1[%],_boundary_conditions |
	     x0[%],y0[%],x1[%],y1[%],_boundary_conditions |
	     x0[%],y0[%],z0[%],x1[%],y1[%],z1[%],_boundary_conditions |
	     x0[%],y0[%],z0[%],c0[%],x1[%],y1[%],z1[%],c1[%],_boundary_condi-
       tions

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

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

	   Default value: 'boundary_conditions=0'.

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

	 diagonal:

	   Transform selected vectors as diagonal matrices.

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

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

	   Elevate selected 2D images into 3D volumes.

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

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

	   Expand selected images along	the x-axis.

	   Default value: 'boundary_conditions=1'.

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

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

	   Expand selected images along	the xy-axes.

	   Default value: 'boundary_conditions=1'.

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

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

	   Expand selected images along	the xyz-axes.

	   Default value: 'boundary_conditions=1'.

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

	   Expand selected images along	the y-axis.

	   Default value: 'boundary_conditions=1'.

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

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

	   Expand selected images along	the z-axis.

	   Default value: 'boundary_conditions=1'.

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

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

	   Default values: 'output_type=0'.

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

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

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

	   Default value: 'extract_xyz_coordinates=0'.

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

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

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

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

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

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

	   Mirror selected images along	specified axes.

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

	 permute (+):
	     permutation_string

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

	   Example:
	     [#1] image.jpg permute yxzc

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

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

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

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

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

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

	 ri:
	     Shortcut for command 'resize_as_image'.

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

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

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

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

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

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

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

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

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

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

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

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

	 rr2d:
	     Shortcut for command 'resize_ratio2d'.

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

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

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

	 r2dx:
	     Shortcut for command 'resize2dx'.

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

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

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

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

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

	 r2dy:
	     Shortcut for command 'resize2dy'.

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

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

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

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

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

	 r3dx:
	     Shortcut for command 'resize3dx'.

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

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

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

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

	 r3dy:
	     Shortcut for command 'resize3dy'.

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

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

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

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

	 r3dz:
	     Shortcut for command 'resize3dz'.

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

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

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

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

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

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

	   Default values: 'interpolation=1',
	    'boundary_conditions=0' and	'center_x=center_y=(undefined)'
	    .

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

	 rotate_tileable:
	     angle,_max_size_factor>=0

	   Rotate selected images by specified angle and make them tileable.
	   If resulting	size of	an image is too	big, the image is replaced  by
       a 1x1
	   image.

	   Default values: 'max_size_factor=8'.

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

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

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

	 scale2x:

	   Resize selected images using	the Scale2x algorithm.

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

	 scale3x:

	   Resize selected images using	the Scale3x algorithm.

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

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

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

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

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

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

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

	   Default values: 'height=100%', 'is_priority_channel=0',
	    'is_antialiasing=1'	and 'maximum_seams=25%'.

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

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

	   Shift selected images by specified displacement vector.
	   Displacement	 vector	can be non-integer in which case linear	inter-
       polation
	   should be chosen.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann |
	   2=periodic |	3=mirror }.

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

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

	 shrink_x:
	     size_x>=0

	   Shrink selected images along	the x-axis.

	   Example:
	     [#1] image.jpg shrink_x 30

	 shrink_xy:
	     size>=0

	   Shrink selected images along	the xy-axes.

	   Example:
	     [#1] image.jpg shrink_xy 30

	 shrink_xyz:
	     size>=0

	   Shrink selected images along	the xyz-axes.

	 shrink_y:
	     size_y>=0

	   Shrink selected images along	the y-axis.

	   Example:
	     [#1] image.jpg shrink_y 30

	 shrink_z:
	     size_z>=0

	   Shrink selected images along	the z-axis.

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

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

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

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

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

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

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

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

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

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

	   Default value: 'split_mode=-1'.

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

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

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

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

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

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

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

	   Default values: 'amplitude=0.25', 'aspect_ratio=0',
	    'zoom=0', 'center_x=center_y=50%' and
	    'boundary_conditions=0'.

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

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

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

	   Default value: 'axis=y'.

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

	 upscale_smart:
	     width[%],_height[%],_depth,_smoothness>=0,_anisot-
       ropy=[0,1],sharpening>=0

	   Upscale selected images with	an edge-preserving algorithm.

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

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

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

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

	   Default values: 'mode=0', 'interpolation=1',
	    'boundary_conditions=1' and	'nb_frames=1'.

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

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

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

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

	   Default values: 'std_factor=0.3' and
	    'boundary_conditions=3'.

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

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

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

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

	 bandpass:
	     _min_freq[%],_max_freq[%]

	   Apply bandpass filter to selected images.

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

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

	   Tutorial: https://gmic.eu/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)	bilat-
       eral
	   filtering.
	   If  a  guide	 image is provided, it is used for drive the smoothing
       filter.
	   A guide image must be of the	same xyz-size as the selected images.
	   Set 'sampling' arguments to '0' for automatic adjustment.

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

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

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

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

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

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

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

	   Tutorial: https://gmic.eu/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=qua-
       dratic
	       },_normalize_scales={ 0 | 1 },_axes

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

	   Default values: 'amplitude=1', 'ratio=2',
	    'nb_iter=5', 'blend_operator=+', 'kernel=1',
	    'normalize_scales=0' and 'axes=(all)'

	   Example:
	     [#1] image.jpg blur_bloom ,

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

	   Apply  linear blur on selected images, with specified angle and am-
       plitudes.

	   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 endlocal

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

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

	   Blur	selected images	along the x-axis.

	   Default value: 'boundary_conditions=1'.

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

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

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

	   Blur	selected images	along the X and	Y axes.

	   Default value: 'boundary_conditions=1'.

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

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

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

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

	   Default value: 'boundary_conditions=1'.

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

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

	   Blur	selected images	along the y-axis.

	   Default value: 'boundary_conditions=1'.

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

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

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

	   Blur	selected images	along the z-axis.

	   Default value: 'boundary_conditions=1'.

	   Tutorial: https://gmic.eu/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	recur-
       sive
	   implementation).
	   'order' can be { 0=smooth | 1=1st-derivative	| 2=2nd-derivative
	   }.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann }.
	   When	specified, argument 'axes' is a	sequence of { x	| y | z	| c
	   }.
	   Specifying  one  axis  multiple  times apply	also the blur multiple
       times.

	   Default values: 'order=0', 'boundary_conditions=1' and
	    'nb_iter=1'.

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

	 bump2normal:

	   Convert selected bumpmaps to	normalmaps.

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

	 compose_freq:

	   Compose selected low	and high frequency parts into new images.

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

	 convolve (+):
	     [mask],_boundary_conditions,_is_normalized={  0  |	  1   },_chan-
       nel_mode,
	       _xcenter,_ycenter,_zcenter,_xstart,_ystart,_zstart,_xend,_yend,
	       _zend,_xstride,_ystride,_zstride,_xdilation,_ydilation,_zdila-
       tion,
	       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', 'channel_mode=1',
	    'xcenter=ycenter=zcenter=-1' (-1=centered),
	    'xstart=ystart=zstart=0', 'xend=yend=zend=-1' (-1=max
	    coordinates), 'xstride=ystride=zstride=1',
	    'xdilation=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  do-
       main.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann |
	   2=periodic |	3=mirror }.

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

	 correlate (+):
	     [mask],_boundary_conditions,_is_normalized={  0  |	  1   },_chan-
       nel_mode,
	       _xcenter,_ycenter,_zcenter,_xstart,_ystart,_zstart,_xend,_yend,
	       _zend,_xstride,_ystride,_zstride,_xdilation,_ydilation,_zdila-
       tion,
	       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', 'channel_mode=1',
	    'xcenter=ycenter=zcenter=-1' (-1=centered),
	    'xstart=ystart=zstart=0', 'xend=yend=zend=-1' (-1=max
	    coordinates), 'xstride=ystride=zstride=1',
	    'xdilation=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,  option-
       ally along
	   the specified axes only.
	   Output  images  are always evenly sized, so this command may	change
       the size
	   of the selected images.

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

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

	   Tutorial: https://gmic.eu/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]  +decon-
       volve_fft[-1] [1]

	 deinterlace:
	     _method={ 0 | 1 }

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

	   Default value: 'method=0'.

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

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

	   Denoise selected images by non-local	patch averaging.

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

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

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

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

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

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

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

	   Denoise selected images using the patch-pca algorithm.

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

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

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

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

	   Default value: 'boundary_conditions=1'.

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

	   Tutorial: https://gmic.eu/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 structur-
       ing
	   element.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann }.

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

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

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

	   Apply circular dilation of selected images by specified size.

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

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

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

	   Apply octagonal dilation of selected	images by specified size.

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

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

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

	   Dilate selected images in the (X,Y,Z,I) space.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann }.

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

	 divergence:

	   Compute divergence of selected vector fields.

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

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

	   Compute difference of gaussian on selected images.

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

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

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

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

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

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

	   Tutorial: https://gmic.eu/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
	   element.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann }.

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

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

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

	   Apply circular erosion of selected images by	specified size.

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

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

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

	   Apply octagonal erosion of selected images by specified size.

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

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

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

	   Erode selected images in the	(X,Y,Z,I) space.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann }.

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

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

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

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

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

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

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

	   Compute the gradient	components (first derivatives) of selected im-
       ages.
	   (equivalent to shortcut command 'g').

	   'scheme' can	be { -1=backward | 0=centered |	1=forward | 2=sobel
	   | 3=rotation-invariant (default) | 4=deriche	| 5=vanvliet }.
	   (no arg) compute all	significant components.

	   Default value: 'scheme=0'.

	   Example:
	     [#1] image.jpg gradient

	   Tutorial: https://gmic.eu/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
       images.
	   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 }
       |
	     (no arg)

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

	   Example:
	     [#1] image.jpg hessian

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

	   Compute the inverse discrete	cosine transform of selected images,
	   optionally along the	specified axes only.
	   Output images are always evenly sized, so this command  may	change
       the size
	   of the selected images.
	   (dct	 images	 obtained with the 'dct' command are evenly sized any-
       way).

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

	   Tutorial: https://gmic.eu/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
	   selected 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
       images.
	   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/approximated solutions.

	   Default values: 'nb_iterations=0' and
	    '[initial_estimated]=(undefined)'.

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

	 inn:

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

	   Example:
	     [#1] image.jpg inn

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

	   Inpaint selected images by specified	mask.
	   If  no  patch  size (or 0) is specified, inpainting is done using a
       fast
	   average or median algorithm.
	   Otherwise, it used a	patch-based reconstruction method, that	can be
       very
	   time	consuming.
	   'fast_method' can be	{ 0=low-connectivity average |
	   1=high-connectivity average | 2=low-connectivity median |
	   3=high-connectivity median }.

	   Default values: 'patch_size=0', 'fast_method=1',
	    'lookup_size=22', 'lookup_factor=0.5',
	    'lookup_increment=1', 'blend_size=0',
	    'blend_threshold=0', 'blend_decay=0.05',
	    'blend_scales=10' and 'is_blend_outer=1'.

	   Example:
	     [#1]  image.jpg  100%,100%	 ellipse 50%,50%,30,30,0,1,255 ellipse
       20%,20%,
	      30,10,0,1,255 +inpaint[-2] [-1] remove[-2]
	     [#2] image.jpg  100%,100%	circle	30%,30%,30,1,255,0,255	circle
       70%,70%,
	      50,1,255,0,255 +inpaint[0] [1],5,15,0.5,1,9,0 remove[1]

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

	   Inpaint selected images by specified	mask using a multiscale
	   transport-diffusion algorithm.
	   If 'diffusion type==3', non-zero values of the mask	(e.g.  a  dis-
       tance
	   function) are used
	   to guide the	diffusion process.

	   Default values: 'nb_scales=75%', 'diffusion_type=1' and
	    'diffusion_iter=20'.

	   Example:
	     [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255
	      +inpaint_pde[0] [1]

	 inpaint_flow:
	     [mask],_nb_global_iter>=0,_nb_local_iter>=0,_dt>0,_al-
       pha>=0,_sigma>=0

	   Apply iteration of the inpainting flow on selected images.

	   Default values: 'nb_global_iter=10',	'nb_local_iter=100',
	     'dt=5', 'alpha=1' and 'sigma=3'.

	   Example:
	     [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255
	      inpaint_flow[0] [1]

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

	   Inpaint all connected regions having	an area	 less  than  specified
       value.

	   Default values: 'maximal_area=4', 'tolerance=0' and
	    'is_high_connectivity=0'.

	   Example:
	     [#1] image.jpg noise 5%,2 +inpaint_holes 8,40

	 inpaint_morpho:
	     [mask]

	   Inpaint selected images by specified	mask using morphological oper-
       ators.

	   Example:
	     [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255
	      +inpaint_morpho[0] [1]

	 inpaint_matchpatch:
	     [mask],_nb_scales={  0=auto   |   >0   },_patch_size>0,_nb_itera-
       tions_per_scale>0,
	       _blend_size>=0,_allow_outer_blending={ 0	| 1 },
	       _is_already_initialized={ 0 | 1 }

	   Inpaint  selected  images  by specified binary mask,	using a	multi-
       scale
	   matchpatch algorithm.

	   Default values: 'nb_scales=0', 'patch_size=9',
	    'nb_iterations_per_scale=10', 'blend_size=5',
	    'allow_outer_blending=1' and 'is_already_initialized=0'.

	   Example:
	     [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255
	      +inpaint_matchpatch[0] [1]

	 kuwahara:
	     size>0

	   Apply Kuwahara filter of specified size on selected images.

	   Example:
	     [#1] image.jpg kuwahara 9

	 laplacian:

	   Compute Laplacian of	selected images.

	   Example:
	     [#1] image.jpg laplacian

	 lic:
	     _amplitude>0,_channels>0

	   Render LIC representation of	selected vector	fields.

	   Default values: 'amplitude=30' and 'channels=1'.

	   Example:
	     [#1]  400,400,1,2,'if(c==0,x-w/2,y-h/2)'  +lic  200,3  quiver[-2]
       [-2],10,1,
	      1,1,255

	 map_tones:
	     _threshold>=0,_gamma>=0,_smoothness>=0,nb_iter>=0

	   Apply  tone	mapping	 operator on selected images, based on Poisson
       equation.

	   Default values: 'threshold=0.1', 'gamma=0.8',
	    'smoothness=0.5' and 'nb_iter=30'.

	   Example:
	     [#1] image.jpg +map_tones ,

	 map_tones_fast:
	     _radius[%]>=0,_power>=0

	   Apply fast tone mapping operator on selected	images.

	   Default values: 'radius=3%' and 'power=0.3'.

	   Example:
	     [#1] image.jpg +map_tones_fast ,

	 meancurvature_flow:
	     _nb_iter>=0,_dt,_keep_sequence={ 0	| 1 }

	   Apply iterations of the mean	curvature flow on selected images.

	   Default values: 'nb_iter=10', 'dt=30' and
	    'keep_sequence=0'.

	   Example:
	     [#1] image.jpg +meancurvature_flow	20

	 median	(+):
	     size>=0,_threshold>0

	   Apply (opt. thresholded) median  filter  on	selected  images  with
       structuring
	   element size	x size.

	   Example:
	     [#1] image.jpg +median 5

	 nlmeans:
	     [guide],_patch_radius>0,_spatial_bandwidth>0,_tonal_bandwidth>0,
	       _patch_measure_command |
	     _patch_radius>0,_spatial_bandwidth>0,_tonal_bandwidth>0,
	       _patch_measure_command

	   Apply  non local means denoising of Buades et al, 2005. on selected
       images.
	   The patch is	a gaussian function of 'std_patch_radius'.
	   The spatial kernel is a rectangle of	radius 'spatial_bandwidth'.
	   The tonal kernel is exponential ('exp(-d^2/_tonal_bandwidth^2)')
	   with	'd' the	euclidean distance between image patches.

	   Default values: 'patch_radius=4', 'spatial_bandwidth=4',
	    'tonal_bandwidth=10' and 'patch_measure_command=-norm'.

	   Example:
	     [#1] image.jpg +noise 10 nlmeans[-1] 4,4,{0.6*${-std_noise}}

	 nlmeans_core:
	     _reference_image,_scaling_map,_patch_radius>0,_spatial_band-
       width>0

	   Apply  non local means denoising using a image for weight and a map
       for
	   scaling

	 normalize_local:
	     _amplitude>=0,_radius>0,_n_smooth>=0[%],_a_smooth>=0[%],_is_cut={
       0 | 1 },
	       _min=0,_max=255

	   Normalize selected images locally.

	   Default values: 'amplitude=3', 'radius=16',
	    'n_smooth=4%', 'a_smooth=2%', 'is_cut=1',
	    'min=0' and	'max=255'.

	   Example:
	     [#1] image.jpg normalize_local 8,10

	 normalized_cross_correlation:
	     [mask]

	   Compute normalized cross-correlation	of selected images with	speci-
       fied
	   mask.

	   Example:
	     [#1] image.jpg  +shift  -30,-20  +normalized_cross_correlation[0]
       [1]

	 percentile:
	     [mask],0<=_min_percentile[%]<=100,0<=_max_percentile[%]<=100.

	   Apply percentile averaging filter to	selected images.

	   Default values: 'min_percentile=0' and
	    'max_percentile=100'.

	   Example:
	     [#1] image.jpg shape_circle 11,11 +percentile[0] [1],25,75

	 peronamalik_flow:
	     K_factor>0,_nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }

	   Apply iterations of the Perona-Malik	flow on	selected images.

	   Default values: 'K_factor=20', 'nb_iter=5', 'dt=5'
	    and	'keep_sequence=0'.

	   Example:
	     [#1] image.jpg +heat_flow 20

	 phase_correlation:
	     [destination]

	   Estimate  translation  vector  between  selected  source images and
       specified
	   destination.

	   Example:
	     [#1]  image.jpg  +shift  -30,-20  +phase_correlation[0]  [1]  un-
       roll[-1]	y

	 pde_flow:
	     _nb_iter>=0,_dt,_velocity_command,_keep_sequence={	0 | 1 }

	   Apply iterations of a generic PDE flow on selected images.

	   Default values: 'nb_iter=10', 'dt=30',
	    'velocity_command=laplacian' and 'keep_sequence=0'.

	   Example:
	     [#1] image.jpg +pde_flow 20

	 periodize_poisson:

	   Periodize selected images using a Poisson solver in Fourier space.

	   Example:
	     [#1] image.jpg +periodize_poisson array 2,2,2

	 rbf:
	     dx,_x0,_x1,_phi(r)	|
	     dx,dy,_x0,_y0,_x1,_y1,_phi(r) |
	     dx,dy,dz,x0,y0,z0,x1,y1,z1,phi(r)

	   Reconstruct 1D/2D or	3D image from selected sets of keypoints, by
	   RBF-interpolation.
	   A  set  of keypoints	is represented by a vector-valued image, where
       each
	   pixel represents a single keypoint.
	   Vector components of	a keypoint have	the following meaning:
	      -	 For 1D	reconstruction:	[ x_k, f1(k),...fN(k) ].
	      -	 For 2D	reconstruction:	[ x_k,y_k, f1(k),...,fN(k) ].
	      -	 For 3D	reconstruction:	[ x_k,y_k,z_k, f1(k),...,fN(k) ].
	   Values 'x_k','y_k' and 'z_k'	are the	spatial	coordinates
	   of keypoint 'k'.
	   Values 'f1(k),..,fN(k)' are the 'N' components of the vector
	   value of keypoint 'k'.
	   The	 command   reconstructs	  an   image   with   specified	  size
       'dx'x'dy'x'dz',
	    with 'N' channels.

	   Default values: 'x0=y0=z0=0', 'x1=dx-1', 'y1=dy-1',
	     'z1=dz-1',	'phi(r)=r^2*log(1e-5+r)'.

	   Example:
	     [#1]   sp	colorful  r2dx	400  100%,100%	noise_poissondisk.  10
       1,{is},1,5
	      eval[-2] "begin(p=0);i?(I[#-1,p++]=[x,y,I(#0)])" to_rgb[1]
	      mul[0,1] dilate_circ[0] 5	+rbf[-1] {0,[w,h]} c[-1] 0,255
	     [#2] 32,1,1,5,u([400,400,255,255,255]) rbf	400,400	c 0,255

	 red_eye:
	     0<=_threshold<=100,_smoothness>=0,0<=attenuation<=1

	   Attenuate red-eye effect in selected	images.

	   Default values: 'threshold=75', 'smoothness=3.5' and
	    'attenuation=0.1'.

	   Example:
	     [#1] image.jpg +red_eye ,

	 remove_hotpixels:
	     _mask_size>0, _threshold[%]>0

	   Remove hot pixels in	selected images.

	   Default values: 'mask_size=3' and 'threshold=10%'.

	   Example:
	     [#1] image.jpg noise 10,2 +remove_hotpixels ,

	 remove_pixels:
	     number_of_pixels[%]>=0

	   Remove specified number of pixels (i.e. set them to 0) from the set
       of
	   non-zero pixels in selected images.

	   Example:
	     [#1] image.jpg +remove_pixels 50%

	 rolling_guidance:
	     std_deviation_s[%]>=0,std_deviation_r[%]>=0,_precision>=0

	   Apply the rolling guidance filter on	selected image.
	   Rolling  guidance  filter  is  a fast image abstraction filter, de-
       scribed in:
	   "Rolling Guidance Filter", Qi Zhang Xiaoyong,  Shen	Li,  Xu	 Jiaya
       Jia,
	   ECCV'2014.

	   Default values: 'std_deviation_s=4',
	    'std_deviation_r=10' and 'precision=0.5'.

	   Example:
	     [#1] image.jpg +rolling_guidance ,	+-

	 sharpen (+):
	     amplitude>=0 |
	     amplitude>=0,edge>=0,_alpha,_sigma

	   Sharpen selected images by inverse diffusion	or shock filters meth-
       ods.
	   'edge' must be specified to enable shock-filter method.

	   Default values: 'alpha=0' and 'sigma=0'.

	   Example:
	     [#1] image.jpg sharpen 300
	     [#2] image.jpg blur 5 sharpen 300,1

	 smooth	(+):
	     amplitude[%]>=0,_sharpness>=0,0<=_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

	   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	 algo-
       rithm.
	   If 'nb_scales=0', the number	of scales is automatically determined.

	   Default values: 'nb_iterations=60', 'dt=5' and
	    'nb_scales=0'.

	   Example:
	     [#1]  image.jpg  command  "foo  :	gradient x" +solve_poisson foo
       +foo[0]
	      +laplacian[1]

	 split_details:
	     _nb_scales>0,_base_scale[%]>=0,_detail_scale[%]>=0

	   Split selected images into 'nb_scales' detail scales.
	   If 'base_scale''detail_scale'0, the	image  decomposition  is  done
       with
	   'a trous' wavelets.
	   Otherwise,  it  uses	laplacian pyramids with	linear standard	devia-
       tions.

	   Default values: 'nb_scales=4', 'base_scale=0' and
	    'detail_scale=0'.

	   Example:
	     [#1] image.jpg split_details ,

	 structuretensors (+):
	     _scheme={ 0=centered | 1=forward/backward }

	   Compute the structure tensor	field of selected images.

	   Default value: 'scheme=1'.

	   Example:
	     [#1] image.jpg structuretensors abs pow 0.2

	   Tutorial: https://gmic.eu/oldtutorial/_structuretensors

	 solidify:
	     _smoothness[%]>=0,_diffusion_type={ 0=isotropic | 1=delaunay-ori-
       ented |
	       2=edge-oriented },_diffusion_iter>=0

	   Solidify selected transparent images.

	   Default values: 'smoothness=75%', 'diffusion_type=1'	and
	    'diffusion_iter=20'.

	   Example:
	     [#1] image.jpg 100%,100% circle[-1] 50%,50%,25%,1,255 append c
	      +solidify	, display_rgba

	 syntexturize:
	     _width[%]>0,_height[%]>0

	   Resynthetize	 'width'x'height'  versions of selected	micro-textures
       by
	   phase randomization.
	   The texture synthesis algorithm is a	straightforward	implementation
       of the
	   method described in :
	   http://www.ipol.im/pub/art/2011/ggm_rpn/.

	   Default values: 'width=height=100%'.

	   Example:
	     [#1] image.jpg crop 2,282,50,328 +syntexturize 320,320

	 syntexturize_matchpatch:
	     _width[%]>0,_height[%]>0,_nb_scales>=0,_patch_size>0,_blend-
       ing_size>=0,
	       _precision>=0

	   Resynthetize	'width'x'height' versions of selected micro-textures
	   using a patch-matching algorithm.
	   If 'nbscales==0', the number	of scales used is estimated from the
	   image size.

	   Default values: 'width=height=100%',	'nb_scales=0',
	    'patch_size=7', 'blending_size=5' and 'precision=1'.

	   Example:
	     [#1]  image.jpg  crop   25%,25%,75%,75%   syntexturize_matchpatch
       512,512

	 tv_flow:
	     _nb_iter>=0,_dt,_keep_sequence={ 0	| 1 }

	   Apply iterations of the total variation flow	on selected images.

	   Default values: 'nb_iter=10', 'dt=30' and
	    'keep_sequence=0'.

	   Example:
	     [#1] image.jpg +tv_flow 40

	 unsharp:
	     radius[%]>=0,_amount>=0,_threshold[%]>=0

	   Apply unsharp mask on selected images.

	   Default values: 'amount=2' and 'threshold=0'.

	   Example:
	     [#1] image.jpg blur 3 +unsharp 1.5,15 cut 0,255

	 unsharp_octave:
	     _nb_scales>0,_radius[%]>=0,_amount>=0,threshold[%]>=0

	   Apply octave	sharpening on selected images.

	   Default values: 'nb_scales=4', 'radius=1',
	    'amount=2' and 'threshold=0'.

	   Example:
	     [#1] image.jpg blur 3 +unsharp_octave 4,5,15 cut 0,255

	 vanvliet (+):
	     std_deviation>=0[%],order={  0 | 1	| 2 | 3	},axis={ x | y | z | c
       },
	       _boundary_conditions

	   Apply Vanvliet recursive filter on selected images, along specified
       axis
	   and with
	   specified standard deviation, order and boundary conditions.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann }.

	   Default value: 'boundary_conditions=1'.

	   Example:
	     [#1] image.jpg +vanvliet 3,1,x
	     [#2] image.jpg +vanvliet 30,0,x vanvliet[-2] 30,0,y add

	 voronoi:

	   Compute the discrete	Voronoi	diagram	of non-zero pixels in selected
       images.

	   Example:
	     [#1] 400,400 noise	0.2,2 eq 1  +label_fg  0  voronoi[-1]  +gradi-
       ent[-1] xy,
	      1	append[-2,-1] c	norm[-1] ==[-1]	0 map[-2] 2,2 mul[-2,-1]
	      normalize[-2] 0,255 dilate_circ[-2] 4 reverse max

	 watermark_fourier:
	     text,_size>0

	   Add a textual watermark in the frequency domain of selected images.

	   Default value: 'size=33'.

	   Example:
	     [#1] image.jpg +watermark_fourier "Watermarked!" +display_fft 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]
	      watershed[-2] [-1] mod[-2] 256 map[-2] 0 reverse

	 12.9. Features	Extraction
	       -------------------

	 area:
	     tolerance>=0,is_high_connectivity={ 0 | 1 }

	   Compute area	of connected components	in selected images.

	   Default values: 'is_high_connectivity=0'.

	   Example:
	     [#1] image.jpg luminance stencil[-1] 1 +area 0

	   Tutorial: https://gmic.eu/oldtutorial/_area

	 area_fg:
	     tolerance>=0,is_high_connectivity={ 0 | 1 }

	   Compute area	of connected components	for  non-zero  values  in  se-
       lected
	   images.
	   Similar to 'area' except that 0-valued pixels are not considered.

	   Default values: 'is_high_connectivity=0'.

	   Example:
	     [#1] image.jpg luminance stencil[-1] 1 +area_fg 0

	 at_line:
	     x0[%],y0[%],z0[%],x1[%],y1[%],z1[%]

	   Retrieve  pixels  of	the selected images belonging to the specified
       line (x0,
	   y0,z0)-(x1,y1,z1).

	   Example:
	     [#1]     image.jpg	    +at_line	 0,0,0,100%,100%,0     line[0]
       0,0,100%,100%,1,
	      0xFF00FF00,255,0,0

	 at_quadrangle:
	     x0[%],y0[%],x1[%],y1[%],x2[%],y2[%],x3[%],y3[%],_interpolation,
	       _boundary_conditions |
	     x0[%],y0[%],z0[%],x1[%],y1[%],z1[%],x2[%],y2[%],z2[%],x3[%],y3[%],z3[%],
	       _interpolation,_boundary_conditions

	   Retrieve pixels of the selected images belonging to	the  specified
       2D or 3D
	   quadrangle.
	   'interpolation' can be { 0=nearest-neighbor | 1=linear | 2=cubic
	   }.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann |
	   2=periodic |	3=mirror }.

	   Example:
	     [#1] image.jpg params=5%,5%,95%,5%,60%,95%,40%,95%	+at_quadrangle
	      $params polygon..	4,$params,0.5,255

	 barycenter:

	   Compute the barycenter vector of pixel values.

	   Example:
	     [#1] 256,256 ellipse 50%,50%,20%,20%,0,1,1	deform 20 +barycenter
	      +ellipse[-2] {@0,1},5,5,0,10

	 delaunay:

	   Generate  discrete  2D Delaunay triangulation of non-zero pixels in
       selected
	   images.
	   Input images	must be	scalar.
	   Each	pixel of the output image is a	triplet	 (a,b,c)  meaning  the
       pixel
	   belongs to
	   the Delaunay	triangle 'ABC' where 'a','b','c' are
	   the labels of the pixels 'A','B','C'.

	   Example:
	     [#1] 400,400 rand 32,255 100%,100%	noise. 0.4,2 eq. 1 mul +delau-
       nay
	     [#2] image.jpg b 1% 100%,100% noise. 0.8,2	eq.  1	mul  +delaunay
       channels
	      0,2

	 detect_skin:
	     0<=tolerance<=1,_skin_x,_skin_y,_skin_radius>=0

	   Detect skin in selected color images	and output an appartenance
	   probability map.
	   Detection is	performed using	CbCr chromaticity data of skin pixels.
	   If arguments	'skin_x', 'skin_y' and 'skin_radius' are
	   provided, skin pixels are learnt
	   from	the sample pixels inside the circle located at ('skin_x',
	   'skin_y') with radius 'skin_radius'.

	   Default value: 'tolerance=0.5' and
	    'skin_x=skiny=radius=-1'.

	 displacement (+):
	     [source_image],_smoothness,_precision>=0,_nb_scales>=0,_itera-
       tion_max>=0,
	       is_backward={ 0 | 1 },_[guide]

	   Estimate displacement field between specified source	 and  selected
       target
	   images.
	   If  'smoothness>=0',	 regularization	type is	set to isotropic, else
       to
	   anisotropic.
	   If 'nbscales==0', the number	of scales used is estimated from the
	   image size.

	   Default values: 'smoothness=0.1', 'precision=5',
	    'nb_scales=0', 'iteration_max=10000',
	    'is_backward=1' and	'[guide]=(unused)'.

	   Example:
	     [#1]  image.jpg  +rotate  3,1,0,50%,50%  +displacement[-1]	  [-2]
       quiver[-1]
	      [-1],15,1,1,1,{1.5*iM}

	 distance (+):
	     isovalue[%],_metric |
	     isovalue[%],[metric],_method

	   Compute the unsigned	distance function to specified isovalue, opt.
	   according to	a custom metric.
	   'metric' can	be { 0=chebyshev | 1=manhattan | 2=euclidean |
	   3=squared-euclidean }.
	   'method' can	be { 0=fast-marching | 1=low-connectivity dijkstra |
	   2=high-connectivity dijkstra	| 3=1+return path | 4=2+return path }.

	   Default value: 'metric=2' and 'method=0'.

	   Example:
	     [#1] image.jpg threshold 20% distance 0 pow 0.3
	     [#2] 400,400 set 1,50%,50%	+distance[0] 1,2 +distance[0] 1,1
	      distance[0] 1,0 mod 32 threshold 16 append c

	   Tutorial: https://gmic.eu/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	  dis-
       play_graph 400,
	      300,3

	 histogram_pointwise:
	     nb_levels>0[%],_value0[%],_value1[%]

	   Compute  the	 histogram of each vector-valued point of selected im-
       ages.
	   If value range is set, the histogram	is estimated only  for	values
       in the
	   specified
	   value range.

	   Default values: 'value0=0%' and 'value1=100%'.

	 hough:
	     _width>0,_height>0,gradient_norm_voting={ 0 | 1 }

	   Compute hough transform (theta,rho) of selected images.

	   Default values: 'width=512',	'height=width' and
	    'gradient_norm_voting=1'.

	   Example:
	     [#1] image.jpg +blur 1.5 hough[-1]	400,400	blur[-1] 0.5 add[-1] 1
	      log[-1]

	 ifftpolar:

	   Compute inverse fourier transform of	selected images, from centered
	   magnitude/phase images.

	 isophotes:
	     _nb_levels>0

	   Render isophotes of selected	images on a transparent	background.

	   Default value: 'nb_levels=64'

	   Example:
	     [#1] image.jpg blur 2 isophotes 6 dilate_circ 5 display_rgba

	 label (+):
	     _tolerance>=0,is_high_connectivity={  0 | 1 },_is_L2_norm={ 0 | 1
       }

	   Label connected components in selected images.

	   Default values: 'tolerance=0', 'is_high_connectivity=0'
	    and	'is_L2_norm=1'.

	   Example:
	     [#1] image.jpg luminance threshold	60% label normalize 0,255  map
       0
	     [#2]  400,400  set	 1,50%,50% distance 1 mod 16 threshold 8 label
       mod 255
	      map 2

	   Tutorial: https://gmic.eu/oldtutorial/_label

	 label_fg:
	     tolerance>=0,is_high_connectivity={ 0 | 1 }

	   Label connected components for non-zero values (foreground) in  se-
       lected
	   images.
	   Similar to 'label' except that 0-valued pixels are not labeled.

	   Default value: 'is_high_connectivity=0'.

	 laar:

	   Extract the largest axis-aligned rectangle in non-zero areas	of se-
       lected
	   images.
	   Rectangle coordinates are returned in status, as a sequence of num-
       bers x0,
	   y0,x1,y1.

	   Example:
	     [#1]  shape_cupid 256 coords=${-laar} normalize 0,255 to_rgb rec-
       tangle
	      $coords,0.5,0,128,0

	 max_patch:
	     _patch_size>=1

	   Return locations of maximal values in local	patch-based  neighbor-
       hood of
	   given size for selected images.

	   Default value: 'patch_size=16'.

	   Example:
	     [#1] image.jpg norm +max_patch 16

	 min_patch:
	     _patch_size>=1

	   Return  locations  of minimal values	in local patch-based neighbor-
       hood of
	   given size for selected images.

	   Default value: 'patch_size=16'.

	   Example:
	     [#1] image.jpg norm +min_patch 16

	 minimal_path:
	     x0[%]>=0,y0[%]>=0,z0[%]>=0,x1[%]>=0,y1[%]>=0,z1[%]>=0,
	       _is_high_connectivity={ 0 | 1 }

	   Compute minimal path	between	two points on selected potential maps.

	   Default value: 'is_high_connectivity=0'.

	   Example:
	     [#1] image.jpg +gradient_norm fill[-1]  1/(1+i)  minimal_path[-1]
       0,0,0,
	      100%,100%,0 pointcloud[-1] 0 *[-1] 280 to_rgb[-1]	ri[-1]
	      [-2],0 or

	 mse:

	   Compute MSE (Mean-Squared Error) matrix between selected images.

	   Example:
	     [#1] image.jpg +noise 30 +noise[0]	35 +noise[0] 38	cut. 0,255 mse

	 patches:
	     patch_width>0,patch_height>0,patch_depth>0,x0,y0,z0,_x1,_y1,_z1,...,_xN,
	       _yN,_zN

	   Extract N+1 patches from selected images, centered at specified lo-
       cations.

	   Example:
	     [#1]		       image.jpg		      +patches
       64,64,1,153,124,0,184,240,0,217,126,0,275,38,0

	 matchpatch (+):
	     [patch_image],patch_width>=1,_patch_height>=1,_patch_depth>=1,
	       _nb_iterations>=0,_nb_randoms>=0,_patch_penalization,
	       _output_score={ 0 | 1 },_[guide]

	   Estimate correspondence map between selected	images	and  specified
       patch
	   image, using
	   a patch-matching algorithm.
	   Each	 pixel	of  the	returned correspondence	map gives the location
       (p,q) of
	   the closest patch in
	   the specified patch image. If 'output_score=1', the third channel
	   also	gives the corresponding
	   matching score for each patch as well.
	   If 'patch_penalization' is >=0, SSD is penalized with patch
	   occurrences.
	   If 'patch_penalization' is <0, SSD is inf-penalized when distance
	   between patches are less than '-patch_penalization'.

	   Default values: 'patch_height=patch_width',
	    'patch_depth=1', 'nb_iterations=5',	'nb_randoms=5',
	    'patch_penalization=0', 'output_score=0' and
	    'guide=(undefined)'.

	   Example:
	     [#1] image.jpg sample  colorful  +matchpatch[0]  [1],3  +warp[-2]
       [-1],0

	 plot2value:

	   Retrieve values from	selected 2D graph plots.

	   Example:
	     [#1] 400,300,1,1,'if(y>300*abs(cos(x/10+2*u)),1,0)' +plot2value
	      +display_graph[-1] 400,300

	 pointcloud:
	     _type  =  {  -X=-X-opacity	 | 0=binary | 1=cumulative | 2=label |
       3=retrieve
	       coordinates },_width,_height>0,_depth>0

	   Render a set	of point coordinates, as a point cloud in a  1D/2D  or
       3D
	   binary image
	   (or	do  the	 reverse, i.e. retrieve	coordinates of non-zero	points
       from a
	   rendered point cloud).
	   Input point coordinates can be a NxMx1x1, Nx1x1xM or	1xNx1xM	image,
       where
	   'N' is the number of	points,
	   and M the point coordinates.
	   If 'M'>3, the 3-to-M	components sets	the (M-3)-dimensional color at
       each
	   point.
	   Parameters 'width','height' and 'depth' are related to
	   the size of the final image :
	      -	 If set	to 0, the size is automatically	set along  the	speci-
       fied axis.
	      -	 If set	to N>0,	the size along the specified axis is N.
	      -	  If  set to N<0, the size along the specified axis is at most
       N.
	   Points with coordinates that	are negative or	higher than specified
	   ('width','height','depth')
	   are not plotted.

	   Default values: 'type=0' and	'max_width=max_height=max_depth
	    =0'.

	   Example:
	     [#1] 3000,2 rand 0,400 +pointcloud	0 dilate[-1] 3
	     [#2] 3000,2 rand 0,400 {w}	{w},3 rand[-1] 0,255 append y  +point-
       cloud 0
	      dilate[-1] 3

	 psnr:
	     _max_value

	   Compute  PSNR  (Peak	Signal-to-Noise	Ratio) matrix between selected
       images.

	   Default value: 'max_value=255'.

	   Example:
	     [#1] image.jpg +noise 30 +noise[0]	35 +noise[0] 38	cut[-1]	 0,255
       psnr
	      255 replace_inf 0

	 segment_watershed:
	     _threshold>=0

	   Apply watershed segmentation	on selected images.

	   Default values: 'threshold=2'.

	   Example:
	     [#1] image.jpg segment_watershed 2

	 shape2bump:
	     _resolution>=0,0<=_weight_avg_max_avg<=1,_dilation,_smoothness>=0

	   Estimate bumpmap from binary	shape in selected images.

	   Default value: 'resolution=256', 'weight_avg_max=0.75',
	    'dilation=0' and 'smoothness=100'.

	 skeleton:
	     _boundary_conditions={ 0=dirichlet	| 1=neumann }

	   Compute skeleton of binary shapes using distance transform and con-
       strained
	   thinning.

	   Default value: 'boundary_conditions=1'.

	   Example:
	     [#1] shape_cupid 320 +skeleton 0

	 slic:
	     size>0,_regularity>=0,_nb_iterations>0

	   Segment selected 2D images with superpixels,	using the  SLIC	 algo-
       rithm
	   (Simple Linear Iterative Clustering).
	   Scalar images of increasingly labeled pixels	are returned.
	   Reference  paper:  Achanta,	R.,  Shaji, A.,	Smith, K., Lucchi, A.,
       Fua, P.,	&
	   Susstrunk, S. (2010). SLIC Superpixels (No. EPFL-REPORT-149300).

	   Default values: 'size=16', 'regularity=10' and
	    'nb_iterations=10'.

	   Example:
	     [#1] image.jpg +srgb2lab slic[-1] 16  +blend  shapeaverage	 f[-2]
       "j(1,
	      0)==i && j(0,1)==i" *[-1]	[-2]

	 ssd_patch:
	     [patch],_use_fourier={ 0 |	1 },_boundary_conditions={ 0=dirichlet
       |
	       1=neumann }

	   Compute fields of SSD between selected images and specified patch.
	   Argument 'boundary_conditions' is valid only	when
	   'use_fourier=0'.

	   Default value: 'use_fourier=0' and
	    'boundary_conditions=0'.

	   Example:
	     [#1] image.jpg +crop 20%,20%,35%,35% +ssd_patch[0]	[1],0,0

	 thinning:
	     _boundary_conditions={ 0=dirichlet	| 1=neumann }

	   Compute skeleton of binary shapes using morphological thinning
	   (beware, this is a quite slow iterative process)

	   Default value: 'boundary_conditions=1'.

	   Example:
	     [#1] shape_cupid 320 +thinning

	 tones:
	     N>0

	   Get N tones masks from selected images.

	   Example:
	     [#1] image.jpg +tones 3

	 topographic_map:
	     _nb_levels>0,_smoothness

	   Render selected images as topographic maps.

	   Default values: 'nb_levels=16' and 'smoothness=2'.

	   Example:
	     [#1] image.jpg topographic_map 10

	 tsp:
	     _precision>=0

	   Try to solve	the 'travelling	salesman' problem, using a combination
       of
	   greedy search and 2-opt algorithms.
	   Selected  images must have dimensions Nx1x1xC to represent N	cities
       each
	   with	C-dimensional coordinates.
	   This	command	re-order the selected data along the  x-axis  so  that
       the point
	   sequence becomes a shortest path.

	   Default values: 'precision=256'.

	   Example:
	     [#1] 256,1,1,2 rand 0,512 tsp , 512,512,1,3 repeat	w#0 circle[-1]
       {0,
	      I[$>]},2,1,255,255,255 line[-1] {0,boundary=2;[I[$>],
	      I[$>+1]]},1,255,128,0 done keep[-1]

	 variance_patch:
	     _patch_size>=1

	   Compute variance of each images patch centered  at  (x,y),  in  se-
       lected
	   images.

	   Default value: 'patch_size=16'

	   Example:
	     [#1] image.jpg +variance_patch

	 12.10.	Image Drawing
		-------------

	 arrow:
	     x0[%],y0[%],x1[%],y1[%],_thickness[%]>=0,_head_length[%]>=0,
	       _head_thickness[%]>=0,_opacity,_pattern,_color1,...

	   Draw	specified arrow	on selected images.
	   'pattern' is	an hexadecimal number starting with '0x' which
	   can be omitted
	   even	 if a color is specified. If a pattern is specified, the arrow
       is
	   drawn outlined instead of filled.

	   Default values: 'thickness=1%', 'head_length=10%',
	    'head_thickness=3%', 'opacity=1',
	    'pattern=(undefined)' and 'color1=0'.

	   Example:
	     [#1]	  400,400,1,3	      repeat	     100	 arrow
       50%,50%,{u(100)}%,{u(100)}%,3,20,10,
	      0.3,${-rgb} done

	 axes:
	     x0,x1,y0,y1,_font_height>=0,_opacity,_pattern,_color1,...

	   Draw	xy-axes	on selected images.
	   'pattern' is	an hexadecimal number starting with '0x' which
	   can be omitted
	   even	if a color is specified.
	   To draw only	one x-axis at row Y, set both 'y0' and 'y1' to Y.
	   To draw only	one y-axis at column X,	set both 'x0' and 'x1' to
	   X.

	   Default values: 'font_height=14', 'opacity=1',
	    'pattern=(undefined)' and 'color1=0'.

	   Example:
	     [#1] 400,400,1,3,255 axes -1,1,1,-1

	 ball:
	     _size>0,		     _R,_G,_B,0<=_specular_light<=8,0<=_specu-
       lar_size<=8,_shadow>=0

	   Input a 2D RGBA colored ball	sprite.

	   Default values: 'size=64', 'R=255', 'G=R',
	    'B=R', 'specular_light=0.8', 'specular_size=1' and
	    'shading=1.5'.

	   Example:
	     [#1] repeat 9 ball	{1.5^($>+2)},${-rgb} done append x

	 chessboard:
	     size1>0,_size2>0,_offset1,_offset2,_angle,_opac-
       ity,_color1,...,_color2,...

	   Draw	chessboard on selected images.

	   Default values: 'size2=size1', 'offset1=offset2=0',
	    'angle=0', 'opacity=1', 'color1=0' and
	    'color2=255'.

	   Example:
	     [#1] image.jpg chessboard 32,32,0,0,25,0.3,255,128,0,0,128,255

	 cie1931:

	   Draw	CIE-1931 chromaticity diagram on selected images.

	   Example:
	     [#1] 500,400,1,3 cie1931

	 circle:
	     x[%],y[%],R[%],_opacity,_pattern,_color1,...

	   Draw	specified colored circle on selected images.
	   A radius of '100%' stands for 'sqrt(width^2+height^2)'.
	   'pattern' is	an hexadecimal number starting with '0x' which
	   can be omitted
	   even	if a color is specified. If a pattern is specified, the	circle
       is
	   drawn outlined instead of filled.

	   Default values: 'opacity=1',	'pattern=(undefined)' and
	    'color1=0'.

	   Example:
	     [#1] image.jpg repeat 300 circle {u(100)}%,{u(100)}%,{u(30)},0.3,
	      ${-rgb} done circle 50%,50%,100,0.7,255

	 close_binary:
	     0<=_endpoint_rate<=100,_endpoint_connectivity>=0,_spline_dist-
       max>=0,
	       _segment_distmax>=0,0<=_spline_anglemax<=180,_spline_round-
       ness>=0,
	       _area_min>=0,_allow_self_intersection={ 0 | 1 }

	   Automatically close open shapes in binary  images  (defining	 white
       strokes
	   on black background).

	   Default values: 'endpoint_rate=75',
	    'endpoint_connectivity=2', 'spline_distmax=80',
	    'segment_distmax=20', 'spline_anglemax=90',
	    'spline_roundness=1','area_min=100',
	    'allow_self_intersection=1'.

	 ellipse (+):
	     x[%],y[%],R[%],r[%],_angle,_opacity,_pattern,_color1,...

	   Draw	specified colored ellipse on selected images.
	   A radius of '100%' stands for 'sqrt(width^2+height^2)'.
	   'pattern' is	an hexadecimal number starting with '0x' which
	   can be omitted
	   even	 if  a	color is specified. If a pattern is specified, the el-
       lipse is
	   drawn outlined instead of filled.

	   Default values: 'opacity=1',	'pattern=(undefined)' and
	    'color1=0'.

	   Example:
	     [#1]	  image.jpg	    repeat	   300	       ellipse
       {u(100)}%,{u(100)}%,{u(30)},{u(30)},
	      {u(180)},0.3,${-rgb} done	ellipse	50%,50%,100,100,0,0.7,255

	 flood (+):
	     x[%],_y[%],_z[%],_tolerance>=0,_is_high_connectivity={   0	  |  1
       },_opacity,
	       _color1,...

	   Flood-fill selected images using specified value and	tolerance.

	   Default values: 'y=z=0', 'tolerance=0',
	    'is_high_connectivity=0', 'opacity=1' and 'color1=0'.

	   Example:
	     [#1]	  image.jpg	    repeat	   1000		 flood
       {u(100)}%,{u(100)}%,0,20,0,1,${-rgb}
	      done

	 gaussian:
	     _sigma1[%],_sigma2[%],_angle

	   Draw	 a  centered gaussian on selected images, with specified stan-
       dard
	   deviations and orientation.

	   Default values: 'sigma1=3', 'sigma2=sigma1' and
	    'angle=0'.

	   Example:
	     [#1] 400,400 gaussian 100,30,45

	   Tutorial: https://gmic.eu/oldtutorial/_gaussian

	 graph (+):
	     [function_image],_plot_type,_vertex_type,_ymin,_ymax,_opac-
       ity,_pattern,
	       _color1,... |
	     'formula',_resolution>=0,_plot_type,_ver-
       tex_type,_xmin,xmax,_ymin,_ymax,
	       _opacity,_pattern,_color1,...

	   Draw	specified function graph on selected images.
	   'plot_type' can be {	0=none | 1=lines | 2=splines | 3=bar }.
	   'vertex_type' can be	{ 0=none | 1=points | 2,3=crosses | 4,
	   5=circles | 6,7=squares }.
	   'pattern' is	an hexadecimal number starting with '0x' which
	   can be omitted
	   even	if a color is specified.

	   Default values: 'plot_type=1', 'vertex_type=1',
	    'ymin=ymax=0 (auto)', 'opacity=1', 'pattern=(undefined)'
	   and 'color1=0'.

	   Example:
	     [#1] image.jpg +rows  50%	blur[-1]  3  split[-1]	c  div[0]  1.5
       graph[0]	[1],
	      2,0,0,0,1,255,0,0	graph[0] [2],2,0,0,0,1,0,255,0 graph[0]
	      [3],2,0,0,0,1,0,0,255 keep[0]

	 grid:
	     size_x[%]>=0,size_y[%]>=0,_offset_x[%],_offset_y[%],_opac-
       ity,_pattern,
	       _color1,...

	   Draw	xy-grid	on selected images.
	   'pattern' is	an hexadecimal number starting with '0x' which
	   can be omitted
	   even	if a color is specified.

	   Default values: 'offset_x=offset_y=0', 'opacity=1',
	    'pattern=(undefined)' and 'color1=0'.

	   Example:
	     [#1] image.jpg grid 10%,10%,0,0,0.5,255
	     [#2] 400,400,1,3,255 grid 10%,10%,0,0,0.3,0xCCCCCCCC,128,32,16

	 j (+):
	     Shortcut for command 'image'.

	 image (+):
	     [sprite],_x[%|~],_y[%|~],_z[%|~],_c[%|~],_opacity,_[opac-
       ity_mask],
	       _max_opacity_mask

	   Draw	specified sprite image on selected images.
	   (equivalent to shortcut command 'j').

	   If one of the x,y,z or c argument ends with a '~', its value	is
	   expected to be
	   a centering ratio (in [0,1])	rather than a position.
	   Usual centering ratio are { 0=left-justified	| 0.5=centered |
	   1=right-justified }.

	   Default values: 'x=y=z=c=0',	'opacity=1',
	    'opacity_mask=(undefined)' and 'max_opacity_mask=1'.

	   Example:
	     [#1] image.jpg +crop 40%,40%,60%,60% resize[-1] 200%,200%,1,3,5
	      frame[-1]	2,2,0 image[0] [-1],30%,30% keep[0]

	 line (+):
	     x0[%],y0[%],x1[%],y1[%],_opacity,_pattern,_color1,...

	   Draw	specified colored line on selected images.
	   'pattern' is	an hexadecimal number starting with '0x' which
	   can be omitted
	   even	if a color is specified.

	   Default values: 'opacity=1',	'pattern=(undefined)' and
	    'color1=0'.

	   Example:
	     [#1]  image.jpg repeat 500	line 50%,50%,{u(w)},{u(h)},0.5,${-rgb}
       done
	      line 0,0,100%,100%,1,0xCCCCCCCC,255 line 100%,0,0,100%,1,
	      0xCCCCCCCC,255

	 linethick:
	     x0[%],y0[%],x1[%],y1[%],_thickness,_opacity,_color1

	   Draw	specified colored thick	line on	selected images.

	   Default values: 'thickness=2', 'opacity=1' and
	    'color1=0'.

	   Example:
	     [#1]	 400,400,1,3	    repeat	  100	     linethick
       {u([w,h,w,h,5])},0.5,${-rgb} done

	 mandelbrot (+):
	     z0r,z0i,z1r,z1i,_iteration_max>=0,_is_julia={	0      |     1
       },_c0r,_c0i,_opacity

	   Draw	mandelbrot/julia fractal on selected images.

	   Default values: 'iteration_max=100',	'is_julia=0',
	    'c0r=c0i=0'	and 'opacity=1'.

	   Example:
	     [#1] 400,400 mandelbrot -2.5,-2,2,2,1024 map  0  +blur  2	eleva-
       tion3d[-1]
	      -0.2

	 marble:
	     _image_weight,_pattern_weight,_angle,_amplitude,_sharpness>=0,
	       _anisotropy>=0,_alpha,_sigma,_cut_low>=0,_cut_high>=0

	   Render marble like pattern on selected images.

	   Default values: 'image_weight=0.2', 'pattern_weight=0.1',
	     'angle=45', 'amplitude=0',	'sharpness=0.4'	and
	    'anisotropy=0.8',
	   'alpha=0.6',	'sigma=1.1' and	'cut_low=cut_high=0'.

	   Example:
	     [#1] image.jpg +marble ,

	 maze:
	     _width>0,_height>0,_cell_size>0

	   Input maze with specified size.

	   Example:
	     [#1] maze 30,20 negate normalize 0,255

	 maze_mask:
	     _cellsize>0

	   Input maze according	to size	and shape of selected mask images.
	   Mask	may contain disconnected shapes.

	   Example:
	     [#1] 0 text "G'MIC",0,0,53,1,1 dilate 3 autocrop 0	frame 1,1,0
	      maze_mask	8 dilate 3 negate mul 255

	 newton_fractal:
	     z0r,z0i,z1r,z1i,_angle,0<=_descent_method<=2,_iteration_max>=0,
	       _convergence_precision>0,_expr_p(z),_expr_dp(z),_expr_d2p(z)

	   Draw	 newton	 fractal  on  selected	images,	for complex numbers in
       range (z0r,
	   z0i)	- (z1r,z1i).
	   Resulting images have  3  channels  whose  meaning  is  [  last_zr,
       last_zi,
	   nb_iter_used_for_convergence	].
	   'descent_method' can	be { 0=secant |	1=newton | 2=householder
	   }.

	   Default values: 'angle=0', 'descent_method=1',
	    'iteration_max=200', 'convergence_precision=0.01',
	    'expr_p(z)=z^^3-1',	'expr_dp(z)=3*z^^2' and
	    'expr_d2z(z)=6*z'.

	   Example:
	     [#1]  400,400 newton_fractal -1.5,-1.5,1.5,1.5,0,2,200,0.01,"z^^6
       + z^^3
	      -	1","6*z^^5 + 3*z^^2","30*z^^4 +	6*z" f "[ atan2(i1,
	      i0)*90+20,1,cut(i2/30,0.2,0.7) ]"	hsl2rgb

	 j3d (+):
	     Shortcut for command 'object3d'.

	 object3d (+):
	     [object3d],_x[%],_y[%],_z,_opacity,_rendering_mode,_is_dou-
       ble_sided={ 0 |
	       1 },_is_zbuffer={ 0 | 1 },_focale,_light_x,_light_y,_light_z,
	       _specular_lightness,_specular_shininess

	   Draw	specified 3D object on selected	images.
	   (equivalent to shortcut command 'j3d').

	   'rendering_mode' can	be { 0=dots | 1=wireframe | 2=flat |
	   3=flat-shaded | 4=gouraud-shaded | 5=phong-shaded }.

	   Default values: 'x=y=z=0', 'opacity=1' and
	    'is_zbuffer=1'. All	other arguments	take their default values
	   from	the 3D environment variables.

	   Example:
	     [#1]  image.jpg  torus3d  100,10  cone3d 30,-120 add3d[-2,-1] ro-
       tate3d. 1,1,
	      0,60 object3d[0] [-1],50%,50% keep[0]

	 pack_sprites:
	     _nb_scales>=0,0<=_min_scale<=100,_allow_rotation={	 0=0  deg.   |
       1=180 deg. |
	       2=90 deg. | 3=any },_spacing,_precision>=0,max_iterations>=0

	   Try to randomly pack	as many	sprites	as possible onto the 'empty'
	   areas of an image.
	   Sprites  can	 be  eventually	 rotated and scaled during the packing
       process.
	   First selected image	is the canvas that will	 be  filled  with  the
       sprites.
	   Its last channel must be a binary mask whose	zero values represent
	   potential locations for drawing the sprites.
	   All	other  selected	 images	 represent  the	sprites	considered for
       packing.
	   Their last channel must be a	binary mask that represents the	sprite
       shape
	   (i.e. a 8-connected component).
	   The	order of sprite	packing	follows	the order of specified sprites
       in the
	   image list.
	   Sprite packing is done on random locations and iteratively with de-
       creasing
	   scales.
	   'nb_scales' sets the	number of decreasing scales considered for all
	   specified sprites to	be packed.
	   'min_scale' (in %) sets the minimal size considered for packing
	   (specified as a percentage of the
	   original sprite size).
	   'spacing' can be positive or	negative.
	   'precision' tells about the desired number of failed	trials before
	   ending the filling process.

	   Default values: 'nb_scales=5', 'min_scale=25',
	    'allow_rotation=3',	'spacing=1', 'precision=7' and
	    'max_iterations=256'.

	   Example:
	     [#1]      512,512,1,3,"min(255,y*c/2)"	 100%,100%	circle
       50%,50%,100,1,255
	      append c image.jpg resize2dy[-1] 24 to_rgba pack_sprites 3,25

	 piechart:
	     label_height>=0,label_R,label_G,label_B,"la-
       bel1",value1,R1,G1,B1,...,
	       "labelN",valueN,RN,GN,BN

	   Draw	pie chart on selected (RGB) images.

	   Example:
	     [#1]		       image.jpg		      piechart
       25,0,0,0,"Red",55,255,0,0,"Green",40,0,255,0,
	      "Blue",30,128,128,255,"Other",5,128,128,128

	 plasma	(+):
	     _alpha,_beta,_scale>=0

	   Draw	a random colored plasma	fractal	on selected images.
	   This	command	implements the so-called 'Diamond-Square' algorithm.

	   Default values: 'alpha=1', 'beta=1' and 'scale=8'.

	   Example:
	     [#1] 400,400,1,3 plasma

	   Tutorial: https://gmic.eu/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', 'aliasing=10', 'shading=1',
	    'opacity=1'	and 'color=255'.

	   Example:
	     [#1] image.jpg polka_dots 10,15,0,0,20,10,1,0.5,0,128,255

	 polygon (+):
	     N>=1,x1[%],y1[%],...,xN[%],yN[%],_opacity,_pattern,_color1,...

	   Draw	specified colored N-vertices polygon on	selected images.
	   'pattern' is	an hexadecimal number starting with '0x' which
	   can be omitted
	   even	if a color is specified. If a pattern is specified, the	 poly-
       gon is
	   drawn outlined instead of filled.

	   Default values: 'opacity=1',	'pattern=(undefined)' and
	    'color1=0'.

	   Example:
	     [#1]			image.jpg		       polygon
       4,20%,20%,80%,30%,80%,70%,20%,80%,0.3,0,255,0
	      polygon 4,20%,20%,80%,30%,80%,70%,20%,80%,1,0xCCCCCCCC,255
	     [#2]    image.jpg	   2,16,1,1,'u(if(x,{h},{w}))'	   polygon[-2]
       {h},{^},0.6,255,
	      0,255 remove[-1]

	 quiver:
	     [function_image],_sampling[%]>0,_factor>=0,_is_arrow={   0	  |  1
       },_opacity,
	       _color1,...

	   Draw	specified 2D vector/orientation	field on selected images.

	   Default values: 'sampling=5%', 'factor=1',
	    'is_arrow=1', 'opacity=1', 'pattern=(undefined)'
	   and 'color1=0'.

	   Example:
	     [#1]      100,100,1,2,'if(c==0,x-w/2,y-h/2)'      500,500,1,3,255
       quiver[-1] [-2],
	      10
	     [#2] image.jpg +resize2dy 600 luminance[0]	gradient[0] mul[1] -1
	      reverse[0,1] append[0,1] c blur[0] 8 orientation[0]
	      quiver[1]	[0],20,1,1,0.8,255

	 rectangle:
	     x0[%],y0[%],x1[%],y1[%],_opacity,_pattern,_color1,...

	   Draw	specified colored rectangle on selected	images.
	   'pattern' is	an hexadecimal number starting with '0x' which
	   can be omitted
	   even	 if  a color is	specified. If a	pattern	is specified, the rec-
       tangle is
	   drawn outlined instead of filled.

	   Default values: 'opacity=1',	'pattern=(undefined)' and
	    'color1=0'.

	   Example:
	     [#1] image.jpg repeat 30 rectangle	{u(100)}%,{u(100)}%,{u(100)}%,
	      {u(100)}%,0.3,${-rgb} done

	 rorschach:
	     'smoothness[%]>=0','mirroring={ 0=none | 1=x | 2=y	| 3=xy }

	   Render rorschach-like inkblots on selected images.

	   Default values: 'smoothness=5%' and 'mirroring=1'.

	   Example:
	     [#1] 400,400 rorschach 3%

	 sierpinski:
	     recursion_level>=0

	   Draw	Sierpinski triangle on selected	images.

	   Default value: 'recursion_level=7'.

	   Example:
	     [#1] image.jpg sierpinski 7

	 spiralbw:
	     width>0,_height>0,_is_2dcoords={ 0	| 1 }

	   Input a 2D rectangular spiral image with specified size.

	   Default values: 'height=width' and 'is_2dcoords=0'.

	   Example:
	     [#1] spiralbw 16
	     [#2] image.jpg spiralbw {[w,h]},1 +warp[0]	[1],0 +warp[2] [1],2

	 spline:
	     x0[%],y0[%],u0[%],v0[%],x1[%],y1[%],u1[%],v1[%],_opac-
       ity,_color1,...

	   Draw	 specified colored spline curve	on selected images (cubic her-
       mite
	   spline).

	   Default values: 'opacity=1' and 'color1=0'.

	   Example:
	     [#1]	  image.jpg	    repeat	    30		spline
       {u(100)}%,{u(100)}%,{u(-600,600)},
	      {u(-600,600)},{u(100)}%,{u(100)}%,{u(-600,600)},{u(-600,
	      600)},0.6,255 done

	 tetraedron_shade:
	     x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3,R0,G0,B0,...,R1,G1,B1,...,R2,G2,B2,...,
	       R3,G3,B3,...

	   Draw	tetraedron with	interpolated colors on	selected  (volumetric)
       images.

	 t (+):
	     Shortcut for command 'text'.

	 text (+):
	     text,_x[%|~],_y[%|~],_font_height[%]>=0,_opacity,_color1,...

	   Draw	specified colored text string on selected images.
	   (equivalent to shortcut command 't').

	   If  one  of	the  x or y argument ends with a '~', its value	is ex-
       pected
	   to be
	   a centering ratio (in [0,1])	rather than a position.
	   Usual centering ratio are { 0=left-justified	| 0.5=centered |
	   1=right-justified }.
	   Sizes '13' and '128'	are special and	correspond to binary
	   fonts (no-antialiasing).
	   Any other font size is rendered with	anti-aliasing.
	   Specifying an empty target image resizes it to new dimensions  such
       that
	   the image contains
	   the entire text string.

	   Default values: 'x=y=0.01~',	'font_height=16',
	    'opacity=1'	and 'color1=0'.

	   Example:
	     [#1] image.jpg resize2dy 600 y=0 repeat 30	text {2*$>}" : This is
       a
	      nice text, isn't it ?",10,$y,{2*$>},0.9,255 y+={2*$>} done
	     [#2] 0 text "G'MIC",0,0,23,1,255

	 to:
	     Shortcut for command 'text_outline'.

	 text_outline:
	     text,_x[%|~],_y[%|~],_font_height[%]>0,_outline>=0,_opac-
       ity,_color1,...

	   Draw	specified colored and outlined text string on selected images.
	   If  one  of	the  x or y argument ends with a '~', its value	is ex-
       pected
	   to be
	   a centering ratio (in [0,1])	rather than a position.
	   Usual centering ratio are { 0=left-justified	| 0.5=centered |
	   1=right-justified }.

	   Default values: 'x=y=0.01~',	'font_height=7.5%',
	    'outline=2', 'opacity=1', 'color1=color2=color3=255'
	    and	'color4=255'.

	   Example:
	     [#1] image.jpg text_outline "Hi there!",10,10,63,3

	 triangle_shade:
	     x0,y0,x1,y1,x2,y2,R0,G0,B0,...,R1,G1,B1,...,R2,G2,B2,...

	   Draw	triangle with interpolated colors on selected images.

	   Example:
	     [#1]		    image.jpg			triangle_shade
       20,20,400,100,120,200,255,0,0,0,255,0,0,0,
	      255

	 truchet:
	     _scale>0,_radius>=0,_pattern_type={ 0=straight | 1=curved }

	   Fill	selected images	with random truchet patterns.

	   Default values: 'scale=32', 'radius=5' and
	    'pattern_type=1'.

	   Example:
	     [#1] 400,300 truchet ,

	 turbulence:
	     _radius>0,_octaves={1,2,3...,12},_alpha>0,_differ-
       ence={-10,10},_mode={0,1,
	       2,3}

	   Render fractal noise	or turbulence on selected images.

	   Default values: 'radius=32',	'octaves=6',
	    'alpha=3', 'difference=0' and 'mode=0'.

	   Example:
	     [#1] 400,400,1,3 turbulence 16

	   Tutorial: https://gmic.eu/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	matri-
       ces by
	   the Dijkstra	algorithm.

	 eigen (+):

	   Compute  the	eigenvalues and	eigenvectors of	selected symmetric ma-
       trices or
	   matrix fields.
	   If one selected image has 3 or 6 channels,  it  is  regarded	 as  a
       field of
	   2x2 or 3x3 symmetric	matrices,
	   whose eigen elements	are computed at	each point of the field.

	   Example:
	     [#1] (1,0,0;0,2,0;0,0,3) +eigen
	     [#2] image.jpg structuretensors blur 2 eigen split[0] c

	   Tutorial: https://gmic.eu/oldtutorial/_eigen

	 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
	   eigenvectors	of selected symmetric matrices,
	   using	  the	      Arnoldi	      iteration		method
       (https://en.wikipedia.org/wiki/Arnoldi_i
	   teration).
	   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
	   algorithm.
	   Selected  images  are  2D-matrices in which each column represent a
       signal to
	   project.
	   '[dictionary]' is a matrix in which each column is  an  element  of
       the
	   dictionary D.
	   'method'  tells  what  projection algorithm must be applied.	It can
       be:
	      -	0 = orthogonal projection (least-squares  solution  using  LU-
       based
	   solver).
	      -	1 = matching pursuit.
	      -	2 = matching pursuit, with a single orthogonal projection step
       at
	   the end.
	      -	>=3 = orthogonal matching pursuit where	an orthogonal  projec-
       tion
	   step	is performed
		      every 'method-2' iterations.
	   'max_iter' sets the max number of iterations	processed for each
	   signal.
	   If set to '0' (default), 'max_iter' is equal	to the number of
	   columns in D.
	   (only meaningful for	matching pursuit and its variants).
	   'max_residual' gives	a stopping criterion on	signal reconstruction
	   accuracy.
	   (only meaningful for	matching pursuit and its variants).
	   For each selected image, the	result is returned as a	matrix W
	   whose  columns  correspond to the weights associated	to each	column
       of D,
	   such	that the matrix	product	D*W is an approximation	of  the	 input
       matrix.

	   Default values: 'method=0', 'max_iter=0' and
	    'max_residual=1e-6'.

	 solve (+):
	     [image]

	   Solve linear	system AX = B for selected B-matrices and specified A-
       matrix.
	   If the system is under- or over-determined, the least squares solu-
       tion is
	   returned
	   (using SVD-based solver).

	   Example:
	     [#1] (0,1,0;1,0,0;0,0,1) (1;2;3) +solve[-1] [-2]

	 svd (+):

	   Compute SVD decomposition of	selected matrices.

	   Example:
	     [#1] 10,10,1,1,'if(x==y,x+u(-0.2,0.2),0)' +svd

	 transpose:

	   Transpose selected matrices.

	   Example:
	     [#1] image.jpg +transpose

	 trisolve (+):
	     [image]

	   Solve  tridiagonal  system AX = B for selected B-vectors and	speci-
       fied
	   tridiagonal A-matrix.
	   Tridiagonal matrix must be stored as	a 3 column vector,  where  2nd
       column
	   contains the
	   diagonal  coefficients,  while 1st and 3rd columns contain the left
       and
	   right coefficients.

	   Example:
	     [#1] (0,0,1;1,0,0;0,1,0) (1;2;3) +trisolve[-1] [-2]

	 12.12.	3D Meshes
		---------

	 +3d (+):
	     Shortcut for command 'add3d'.

	 add3d (+):
	     tx,_ty,_tz	|
	     [object3d]	|
	     (no arg)

	   Shift selected 3D objects with specified  displacement  vector,  or
       merge
	   them	with specified
	   3D object, or merge all selected 3D objects together.
	   (equivalent to shortcut command '+3d').

	   Default values: 'ty=tz=0'.

	   Example:
	     [#1] sphere3d 10 repeat 5 +add3d[-1] 10,{u(-10,10)},0 color3d[-1]
	      ${-rgb} done add3d
	     [#2]  repeat  20 torus3d 15,2 color3d[-1] ${-rgb} mul3d[-1] 0.5,1
       if $>%2
	      rotate3d[-1] 0,1,0,90 fi add3d[-1] 70 add3d rotate3d[-1] 0,0,
	      1,18 done	double3d 0

	 animate3d:
	     _width>0,_height>0,_angle_dx,_angle_dy,_angle_dz,_zoom_fac-
       tor>=0,_filename

	   Animate selected 3D objects in a window.
	   If argument 'filename' is provided, each frame of the animation is
	   saved as a numbered filename.

	   Default values: 'width=640',	'height=480',
	    'angle_dx=0', 'angle_dy=1',	'angle_dz=0',
	    'zoom_factor=1' and	'filename=(undefined)'.

	 apply_camera3d:
	     pos_x,pos_y,pos_z,target_x,target_y,target_z,up_x,up_y,up_z

	   Apply 3D camera matrix to selected 3D objects.

	   Default values: 'target_x=0', 'target_y=0',
	    'target_z=0', 'up_x=0', 'up_y=-1' and 'up_z=0'.

	 apply_matrix3d:
	     a11,a12,a13,...,a31,a32,a33

	   Apply specified 3D rotation matrix to selected 3D objects.

	   Example:
	     [#1]	     torus3d		10,1	       +apply_matrix3d
       {mul(rot(1,0,1,-15),[1,0,0,0,2,0,0,
	      0,8],3)} double3d	0

	 array3d:
	     size_x>=1,_size_y>=1,_size_z>=1,_offset_x[%],_offset_y[%],_off-
       set_y[%]

	   Duplicate a 3D object along the X,Y and Z axes.

	   Default values: 'size_y=1', 'size_z=1' and
	    'offset_x=offset_y=offset_z=100%'.

	   Example:
	     [#1] torus3d 10,1 +array3d	5,5,5,110%,110%,300%

	 arrow3d:
	     x0,y0,z0,x1,y1,z1,_radius[%]>=0,_head_length[%]>=0,_head_ra-
       dius[%]>=0

	   Input 3D arrow with specified starting and ending 3D	points.

	   Default values: 'radius=5%',	'head_length=25%' and
	    'head_radius=15%'.

	   Example:
	     [#1]	 repeat	       10	 a={$>*2*pi/10}	       arrow3d
       0,0,0,{cos($a)},{sin($a)},-0.5
	      done +3d

	 axes3d:
	     _size_x,_size_y,_size_z,_font_size>0,_label_x,_label_y,_label_z,
	       _is_origin={ 0=no | 1=yes }

	   Input  3D  axes  with  specified sizes along	the x,y	and z orienta-
       tions.

	   Default values: 'size_x=size_y=size_z=1', 'font_size=23',
	     'label_x=X', 'label_y=Y', 'label_z=Z' and
	    'is_origin=1'

	   Example:
	     [#1] axes3d ,

	 boundingbox3d:

	   Replace selected 3D objects by their	3D bounding boxes.

	   Example:
	     [#1] torus3d 100,30 +boundingbox3d	+3d[-1]	[-2]

	 box3d:
	     _size_x,_size_y,_size_z

	   Input 3D box	at (0,0,0), with specified geometry.

	   Default values: 'size_x=1' and 'size_z=size_y=size_x'.

	   Example:
	     [#1] box3d	100,40,30 +primitives3d	1 color3d[-2] ${-rgb}

	 c3d:
	     Shortcut for command 'center3d'.

	 center3d:

	   Center selected 3D objects at (0,0,0).
	   (equivalent to shortcut command 'c3d').

	   Example:
	     [#1] repeat 100 circle3d {u(100)},{u(100)},{u(100)},2 done	add3d
	      color3d[-1] 255,0,0 +center3d color3d[-1]	0,255,0	add3d

	 circle3d:
	     _x0,_y0,_z0,_radius>=0

	   Input 3D circle at specified	coordinates.

	   Default values: 'x0=y0=z0=0'	and 'radius=1'.

	   Example:
	     [#1] repeat 500 a={$>*pi/250} circle3d {cos(3*$a)},{sin(2*$a)},0,
	      {$a/50} color3d[-1] ${-rgb},0.4 done add3d

	 circles3d:
	     _radius>=0,_is_wireframe={	0 | 1 }

	   Convert specified 3D	objects	to sets	of 3D circles  with  specified
       radius.

	   Default values: 'radius=1' and 'is_wireframe=1'.

	   Example:
	     [#1]  image.jpg luminance resize2dy 40 threshold 50% * 255	point-
       cloud3d
	      color3d[-1] 255,255,255 circles3d	0.7

	 col3d (+):
	     Shortcut for command 'color3d'.

	 color3d (+):
	     R,_G,_B,_opacity |
	     (no arg)

	   Set color and opacity of selected 3D	objects.
	   (equivalent to shortcut command 'col3d').

	   Default value: 'B=G=R' and 'opacity=(undefined)'.

	   Example:
	     [#1] torus3d 100,10 double3d 0 repeat 7 +rotate3d[-1] 1,0,0,20
	      color3d[-1] ${-rgb} done add3d

	 colorcube3d:

	   Input 3D color cube.

	   Example:
	     [#1] colorcube3d mode3d 2 +primitives3d 1

	 cone3d:
	     _radius,_height,_nb_subdivisions>0

	   Input 3D cone at (0,0,0), with specified geometry.

	   Default value: 'radius=1','height=1'	and
	    'nb_subdivisions=24'.

	   Example:
	     [#1] cone3d 10,40 +primitives3d 1 color3d[-2] ${-rgb}

	 cubes3d:
	     _size>=0

	   Convert specified 3D	objects	to sets	of  3D	cubes  with  specified
       size.

	   Default value: 'size=1'.

	   Example:
	     [#1]  image.jpg luminance resize2dy 40 threshold 50% * 255	point-
       cloud3d
	      color3d[-1] 255,255,255 cubes3d 1

	 cup3d:
	     _resolution>0

	   Input 3D cup	object.

	   Default value: 'resolution=128'.

	   Example:
	     [#1] cup3d	,

	 cylinder3d:
	     _radius,_height,_nb_subdivisions>0

	   Input 3D cylinder at	(0,0,0), with specified	geometry.

	   Default value: 'radius=1','height=1'	and
	    'nb_subdivisions=24'.

	   Example:
	     [#1] cylinder3d 10,40 +primitives3d 1 color3d[-2] ${-rgb}

	 delaunay3d:

	   Generate 3D delaunay	triangulations from selected images.
	   One assumes that the	selected input images are binary  images  con-
       taining
	   the set of points to	mesh.
	   The output 3D object	is a mesh composed of non-oriented triangles.

	   Example:
	     [#1]  500,500  noise  0.05,2  eq  1  * 255	+delaunay3d color3d[1]
       255,128,0
	      dilate_circ[0] 5 to_rgb[0] +object3d[0] [1],0,0,0,1,1
	      max[-1] [0]

	 distribution3d:

	   Get 3D color	distribution of	selected images.

	   Example:
	     [#1]  image.jpg  distribution3d  colorcube3d  primitives3d[-1]  1
       add3d

	 /3d (+):
	     Shortcut for command 'div3d'.

	 div3d (+):
	     factor |
	     factor_x,factor_y,_factor_z

	   Scale  selected  3D	objects	isotropically or anisotropically, with
       the
	   inverse of specified
	   factors.
	   (equivalent to shortcut command '/3d').

	   Default value: 'factor_z=0'.

	   Example:
	     [#1]  torus3d  5,2	 repeat	 5  +add3d[-1]	12,0,0	div3d[-1]  1.2
       color3d[-1]
	      ${-rgb} done add3d

	 db3d (+):
	     Shortcut for command 'double3d'.

	 double3d (+):
	     _is_double_sided={	0 | 1 }

	   Enable/disable double-sided mode for	3D rendering.
	   (equivalent to shortcut command 'db3d').

	   Default value: 'is_double_sided=1'.

	   Example:
	     [#1]  mode3d 1 repeat 2 torus3d 100,30 rotate3d[-1] 1,1,0,60 dou-
       ble3d $>
	      snapshot3d[-1] 400 done

	 elevation3d:
	     { z-factor	| [elevation_map] | 'formula' },base_height={ -1 | >=0
       } |
	     (no arg)

	   Generate 3D elevation of selected images, opt. with a specified el-
       evation
	   map.
	   When	invoked	with (no arg) or 'z-factor', the elevation map is
	   computed as the pointwise L2	norm of	the
	   pixel values. Otherwise, the	elevation map is taken from the	speci-
       fied
	   image or formula.

	   Example:
	     [#1] image.jpg +blur 5 elevation3d. 0.75
	     [#2] 128,128,1,3,u(255) plasma 10,3 blur 4	sharpen	10000 n	0,255
	      elevation3d[-1] 'X=(x-64)/6;Y=(y-64)/6;-100*exp(-(X^2+Y^2)/30
	      )*abs(cos(X)*sin(Y))'

	 empty3d:

	   Input empty 3D object.

	   Example:
	     [#1] empty3d

	 extrude3d:
	     _depth>0,_resolution>0,_smoothness[%]>=0

	   Generate extruded 3D	object from selected binary XY-profiles.

	   Default values: 'depth=16', 'resolution=1024' and
	    'smoothness=0.5%'.

	   Example:
	     [#1] image.jpg threshold 50% extrude3d 16

	 f3d (+):
	     Shortcut for command 'focale3d'.

	 focale3d (+):
	     focale

	   Set 3D focale.
	   (equivalent to shortcut command 'f3d').

	   Set 'focale'	to 0 to	enable parallel	projection (instead of
	   perspective).
	   Set negative	'focale' will disable 3D sprite	zooming.

	   Default value: 'focale=700'.

	   Example:
	     [#1]  repeat  5  torus3d  100,30  rotate3d[-1]  1,1,0,60 focale3d
       {$<*90}
	      snapshot3d[-1] 400 done remove[0]

	 gaussians3d:
	     _size>0,_opacity

	   Convert selected 3D objects into set	of 3D gaussian-shaped sprites.

	   Example:
	     [#1] image.jpg r2dy 32 distribution3d gaussians3d 20 colorcube3d
	      primitives3d[-1] 1 +3d

	 gmic3d:

	   Input a 3D G'MIC logo.

	   Example:
	     [#1] gmic3d +primitives3d 1

	 gyroid3d:
	     _resolution>0,_zoom

	   Input 3D gyroid at (0,0,0), with specified resolution.

	   Default values: 'resolution=32' and 'zoom=5'.

	   Example:
	     [#1] gyroid3d 48 +primitives3d 1

	 histogram3d:

	   Get 3D color	histogram of selected images.

	   Example:
	     [#1] image.jpg resize2dx 64 histogram3d  circles3d	 3  opacity3d.
       0.75
	      colorcube3d primitives3d[-1] 1 add3d

	 image6cube3d:

	   Generate 3D mapped cubes from 6-sets	of selected images.

	   Example:
	     [#1] image.jpg animate flower,"30,0","30,5",6 image6cube3d

	 imageblocks3d:
	     _maximum_elevation,_smoothness[%]>=0

	   Generate 3D blocks from selected images.
	   Transparency	of selected images is taken into account.

	   Default values: 'maximum_elevation=10' and
	    'smoothness=0'.

	   Example:
	     [#1] image.jpg resize2dy 32 imageblocks3d -20 mode3d 3

	 imagecube3d:

	   Generate 3D mapped cubes from selected images.

	   Example:
	     [#1] image.jpg imagecube3d

	 imageplane3d:

	   Generate 3D mapped planes from selected images.

	   Example:
	     [#1] image.jpg imageplane3d

	 imagepyramid3d:

	   Generate 3D mapped pyramids from selected images.

	   Example:
	     [#1] image.jpg imagepyramid3d

	 imagerubik3d:
	     _xy_tiles>=1,0<=xy_shift<=100,0<=z_shift<=100

	   Generate 3D mapped rubik's cubes from selected images.

	   Default values: 'xy_tiles=3', 'xy_shift=5' and
	    'z_shift=5'.

	   Example:
	     [#1] image.jpg imagerubik3d ,

	 imagesphere3d:
	     _resolution1>=3,_resolution2>=3

	   Generate 3D mapped sphere from selected images.

	   Default values: 'resolution1=32' and	'resolutions2=16'.

	   Example:
	     [#1] image.jpg imagesphere3d 32,16

	 isoline3d (+):
	     isovalue[%] |
	     'formula',value,_x0,_y0,_x1,_y1,_size_x>0[%],_size_y>0[%]

	   Extract  3D	isolines  with specified value from selected images or
       from
	   specified formula.

	   Default values: 'x0=y0=-3', 'x1=y1=3' and
	    'size_x=size_y=256'.

	   Example:
	     [#1] image.jpg blur 1 isoline3d 50%
	     [#2] isoline3d 'X=x-w/2;Y=y-h/2;(X^2+Y^2)%20',10,-10,-10,10,10

	 isosurface3d (+):
	     isovalue[%] |
	     'for-
       mula',value,_x0,_y0,_z0,_x1,_y1,_z1,_size_x>0[%],_size_y>0[%],
	       _size_z>0[%]

	   Extract 3D isosurfaces with specified value from selected images or
       from
	   specified formula.

	   Default values: 'x0=y0=z0=-3', 'x1=y1=z1=3' and
	    'size_x=size_y=size_z=32'.

	   Example:
	     [#1] image.jpg resize2dy 128 luminance threshold 50% expand_z 2,0
       blur
	      1	isosurface3d 50% mul3d 1,1,30
	     [#2] isosurface3d 'x^2+y^2+abs(z)^abs(4*cos(x*y*z*3))',3

	 label3d:
	     "text",font_height>=0,_opacity,_color1,...

	   Generate 3D text label.

	   Default values: 'font_height=13', 'opacity=1' and
	    'color=255,255,255'.

	 label_points3d:
	     _label_size>0,_opacity

	   Add a numbered label	to all vertices	of selected 3D objects.

	   Default values: 'label_size=13' and 'opacity=0.8'.

	   Example:
	     [#1] torus3d 100,40,6,6 label_points3d 23,1 mode3d	1

	 lathe3d:
	     _resolution>0,_smoothness[%]>=0,_max_angle>=0

	   Generate 3D object from selected binary XY-profiles.

	   Default values: 'resolution=128', 'smoothness=0.5%' and
	    'max_angle=361'.

	   Example:
	     [#1] 300,300 rand -1,1 blur 40 sign normalize 0,255 lathe3d ,

	 l3d (+):
	     Shortcut for command 'light3d'.

	 light3d (+):
	     position_x,position_y,position_z |
	     [texture] |
	     (no arg)

	   Set the light coordinates or	the light texture for 3D rendering.
	   (equivalent to shortcut command 'l3d').

	   (no arg) resets the 3D light	to default.

	   Example:
	     [#1]  torus3d  100,30  double3d  0	 specs3d  1.2 repeat 5 light3d
       {$>*100},0,
	      -300 +snapshot3d[0] 400 done remove[0]

	 line3d:
	     x0,y0,z0,x1,y1,z1

	   Input 3D line at specified coordinates.

	   Example:
	     [#1]	 repeat	       100	   a={$>*pi/50}		line3d
       0,0,0,{cos(3*$a)},{sin(2*$a)},0
	      color3d. ${-rgb} done add3d

	 lissajous3d:
	     resolution>1,a,A,b,B,c,C

	   Input 3D lissajous curves (x(t)=sin(at+A*2pi), y(t)=sin(bt+B*2pi),
	    z(t)=sin(ct+C*2pi)).

	   Default values: 'resolution=1024', 'a=2', 'A=0',
	    'b=1', 'B=0', 'c=0'	and 'C=0'.

	   Example:
	     [#1] lissajous3d ,

	 m3d (+):
	     Shortcut for command 'mode3d'.

	 mode3d	(+):
	     _mode

	   Set static 3D rendering mode.
	   (equivalent to shortcut command 'm3d').

	   'mode' can be { -1=bounding-box | 0=dots | 1=wireframe | 2=flat |
	   3=flat-shaded | 4=gouraud-shaded | 5=phong-shaded }.");
	   Bounding-box	 mode  ('mode==-1') is active only for the interactive
       3D
	   viewer.

	   Default value: 'mode=4'.

	   Example:
	     [#1]  (0,1,2,3,4,5)  double3d  0  repeat  w  torus3d  100,30  ro-
       tate3d[-1] 1,1,
	      0,60 mode3d {0,@$>} snapshot3d[-1] 300 done remove[0]

	 md3d (+):
	     Shortcut for command 'moded3d'.

	 moded3d (+):
	     _mode

	   Set dynamic 3D rendering mode for interactive 3D viewer.
	   (equivalent to shortcut command 'md3d').

	   'mode' can be { -1=bounding-box | 0=dots | 1=wireframe | 2=flat |
	   3=flat-shaded | 4=gouraud-shaded | 5=phong-shaded }.

	   Default value: 'mode=-1'.

	 *3d (+):
	     Shortcut for command 'mul3d'.

	 mul3d (+):
	     factor |
	     factor_x,factor_y,_factor_z

	   Scale  selected  3D	objects	isotropically or anisotropically, with
       specified
	   factors.
	   (equivalent to shortcut command '*3d').

	   Default value: 'factor_z=0'.

	   Example:
	     [#1]  torus3d  5,2	 repeat	 5  +add3d[-1]	10,0,0	mul3d[-1]  1.2
       color3d[-1]
	      ${-rgb} done add3d

	 n3d:
	     Shortcut for command 'normalize3d'.

	 normalize3d:

	   Normalize selected 3D objects to unit size.
	   (equivalent to shortcut command 'n3d').

	   Example:
	     [#1] repeat 100 circle3d {u(3)},{u(3)},{u(3)},0.1 done add3d
	      color3d[-1] 255,0,0 +normalize3d[-1] color3d[-1] 0,255,0
	      add3d

	 o3d (+):
	     Shortcut for command 'opacity3d'.

	 opacity3d (+):
	     _opacity

	   Set opacity of selected 3D objects.
	   (equivalent to shortcut command 'o3d').

	   Default value: 'opacity=1'.

	   Example:
	     [#1] torus3d 100,10 double3d 0 repeat 7 +rotate3d[-1] 1,0,0,20
	      opacity3d[-1] {u}	done add3d

	 parametric3d:
	     _x(a,b),_y(a,b),_z(a,b),_amin,_amax,_bmin,_bmax,_res_a>0,_res_b>0,_res_x>0,
	       _res_y>0,_res_z>0,_smoothness>=0,_isovalue>=0

	   Input  3D  object  from   specified	 parametric   surface	'(a,b)
       (x(a,b),y(a,
	   b),z(a,b))'.

	   Default values: 'x=(2+cos(b))*sin(a)',
	    'y=(2+cos(b))*cos(a)', 'c=sin(b)', 'amin=-pi',
	    'amax=pi', 'bmin=-pi', 'bmax=pi', 'res_a=512',
	    'res_b=res_a', 'res_x=64', 'res_y=res_x',
	    'res_z=res_y', 'smoothness=2%' and 'isovalue=10%'.

	   Example:
	     [#1] parametric3d ,

	 pca_patch3d:
	     _patch_size>0,_M>0,_N>0,_normalize_input={	  0   |	 1  },_normal-
       ize_output={ 0 |
	       1 },_lambda_xy

	   Get 3D patch-pca representation of selected images.
	   The 3D patch-pca is estimated from M	patches	on  the	 input	image,
       and
	   displayed as	a cloud	of N 3D	points.

	   Default values: 'patch_size=7', 'M=1000', 'N=3000',
	     'normalize_input=1', 'normalize_output=0',	and
	    'lambda_xy=0'.

	   Example:
	     [#1] image.jpg pca_patch3d	7

	 plane3d:
	     _size_x,_size_y,_nb_subdivisions_x>0,_nb_subdisivions_y>0

	   Input 3D plane at (0,0,0), with specified geometry.

	   Default values: 'size_x=1', 'size_y=size_x' and
	    'nb_subdivisions_x=nb_subdivisions_y=24'.

	   Example:
	     [#1] plane3d 50,30	+primitives3d 1	color3d[-2] ${-rgb}

	 point3d:
	     x0,y0,z0

	   Input 3D point at specified coordinates.

	   Example:
	     [#1] repeat 1000 a={$>*pi/500} point3d {cos(3*$a)},{sin(2*$a)},0
	      color3d[-1] ${-rgb} done add3d

	 pointcloud3d:

	   Convert selected planar or volumetric images	to 3D point clouds.

	   Example:
	     [#1] image.jpg luminance resize2dy	100 threshold 50% mul 255
	      pointcloud3d color3d[-1] 255,255,255

	 pose3d:
	     p1,...,p12

	   Apply 3D pose matrix	to selected 3D objects.

	   Example:
	     [#1]	       torus3d		    100,20		pose3d
       0.152437,1.20666,-0.546366,0,-0.535962,
	      0.559129,1.08531,0,1.21132,0.0955431,0.548966,0,0,0,-206,1
	      snapshot3d 400

	 p3d:
	     Shortcut for command 'primitives3d'.

	 primitives3d:
	     mode

	   Convert primitives of selected 3D objects.
	   (equivalent to shortcut command 'p3d').

	   'mode' can be { 0=points | 1=outlines | 2=non-textured }.

	   Example:
	     [#1] sphere3d 30 primitives3d 1 torus3d 50,10 color3d[-1] ${-rgb}
       add3d

	 projections3d:
	     _x[%],_y[%],_z[%],_is_bounding_box={ 0 | 1	}

	   Generate  3D	 xy,xz,yz  projection planes from specified volumetric
       images.

	 pyramid3d:
	     width,height

	   Input 3D pyramid at (0,0,0),	with specified geometry.

	   Example:
	     [#1] pyramid3d 100,-100 +primitives3d 1 color3d[-2] ${-rgb}

	 quadrangle3d:
	     x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3

	   Input 3D quadrangle at specified coordinates.

	   Example:
	     [#1] quadrangle3d -10,-10,10,10,-10,10,10,10,10,-10,10,10	repeat
       10
	      +rotate3d[-1] 0,1,0,30 color3d[-1] ${-rgb},0.6 done add3d
	      mode3d 2

	 random3d:
	     nb_points>=0

	   Input random	3D point cloud in [0,1]^3.

	   Example:
	     [#1] random3d 100 circles3d 0.1 opacity3d 0.5

	 rv3d (+):
	     Shortcut for command 'reverse3d'.

	 reverse3d (+):

	   Reverse primitive orientations of selected 3D objects.
	   (equivalent to shortcut command 'rv3d').

	   Example:
	     [#1] torus3d 100,40 double3d 0 +reverse3d

	 r3d (+):
	     Shortcut for command 'rotate3d'.

	 rotate3d (+):
	     u,v,w,angle

	   Rotate selected 3D objects around specified axis with specified an-
       gle (in
	   deg.).
	   (equivalent to shortcut command 'r3d').

	   Example:
	     [#1] torus3d 100,10 double3d 0 repeat  7  +rotate3d[-1]  1,0,0,20
       done
	      add3d

	 rotation3d:
	     u,v,w,angle

	   Input 3x3 rotation matrix with specified axis and angle (in deg).

	   Example:
	     [#1] rotation3d 1,0,0,0 rotation3d	1,0,0,90 rotation3d 1,0,0,180

	 sierpinski3d:
	     _recursion_level>=0,_width,_height

	   Input 3d Sierpinski pyramid.

	   Example:
	     [#1] sierpinski3d 3,100,-100 +primitives3d	1 color3d[-2] ${-rgb}

	 size3d:

	   Return bounding box size of the last	selected 3D object.

	 skeleton3d:
	     _metric,_frame_type={ 0=squares | 1=diamonds | 2=circles |	3=auto
       },
	       _skeleton_opacity,_frame_opacity,_is_frame_wireframe={ 0	| 1 }

	   Build 3D skeletal structure object from 2d binary shapes located in
	   selected images.
	   'metric' can	be { 0=chebyshev | 1=manhattan | 2=euclidean }.

	   Default values: 'metric=2', 'bones_type=3',
	    'skeleton_opacity=1' and 'frame_opacity=0.1'.

	   Example:
	     [#1] shape_cupid 480 +skeleton3d ,

	 snapshot3d:
	     _size>0,_zoom>=0,_backgroundR,_backgroundG,_backgroundB,_back-
       groundA |
	     [background_image],zoom>=0

	   Take	2d snapshots of	selected 3D objects.
	   Set 'zoom' to 0 to disable object auto-scaling.

	   Default values: 'size=512', 'zoom=1'	and
	    '[background_image]=(default)'.

	   Example:
	     [#1]     torus3d	  100,20    rotate3d	1,1,0,60    snapshot3d
       400,1.2,128,64,32
	     [#2] torus3d 100,20 rotate3d  1,1,0,60  sample  ?	+snapshot3d[0]
       [1],1.2

	 sl3d (+):
	     Shortcut for command 'specl3d'.

	 specl3d (+):
	     value>=0

	   Set lightness of 3D specular	light.
	   (equivalent to shortcut command 'sl3d').

	   Default value: 'value=0.15'.

	   Example:
	     [#1]  (0,0.3,0.6,0.9,1.2)	repeat	w  torus3d 100,30 rotate3d[-1]
       1,1,0,60
	      color3d[-1] 255,0,0 specl3d {0,@$>} snapshot3d[-1] 400 done
	      remove[0]

	 ss3d (+):
	     Shortcut for command 'specs3d'.

	 specs3d (+):
	     value>=0

	   Set shininess of 3D specular	light.
	   (equivalent to shortcut command 'ss3d').

	   Default value: 'value=0.8'.

	   Example:
	     [#1] (0,0.3,0.6,0.9,1.2) repeat  w	 torus3d  100,30  rotate3d[-1]
       1,1,0,60
	      color3d[-1] 255,0,0 specs3d {0,@$>} snapshot3d[-1] 400 done
	      remove[0]

	 sphere3d (+):
	     radius,_nb_recursions>=0

	   Input 3D sphere at (0,0,0), with specified geometry.

	   Default value: 'nb_recursions=3'.

	   Example:
	     [#1] sphere3d 100 +primitives3d 1 color3d[-2] ${-rgb}

	 spherical3d:
	     _nb_azimuth>=3,_nb_zenith>=3,_radius_function(phi,theta)

	   Input 3D spherical object at	(0,0,0), with specified	geometry.

	   Default values: 'nb_zenith=nb_azimut=64' and
	    'radius_function="abs(1+0.5*cos(3*phi)*sin(4*theta))"'.

	   Example:
	     [#1] spherical3d 64 +primitives3d 1

	 spline3d:
	     x0[%],y0[%],z0[%],u0[%],v0[%],w0[%],x1[%],y1[%],z1[%],u1[%],v1[%],w1[%],
	       _nb_vertices>=2

	   Input 3D spline with	specified geometry.

	   Default values: 'nb_vertices=128'.

	   Example:
	     [#1]	       repeat		    100		      spline3d
       {u},{u},{u},{u},{u},{u},{u},{u},{u},{u},{u},
	      {u},128 color3d[-1] ${-rgb} done box3d 1 primitives3d[-1]	1
	      add3d

	 s3d (+):
	     Shortcut for command 'split3d'.

	 split3d (+):
	     _full_split={ 0 | 1 }

	   Split selected 3D objects into feature vectors :
	    * If 'full_split==0', { header, sizes, vertices, primitives,
	   colors, opacities }.
	    * If 'full_split==1', { header, sizes, vertices, p0,...,pP,	c0,
	   ...,cP, o0,...,oP }.
	   (equivalent to shortcut command 's3d').

	   To  recreate	the 3D object, append all produced images along	the y-
       axis.

	   Default value: 'full_split=0'.

	   Example:
	     [#1] box3d	100 +split3d

	 sprite3d:

	   Convert selected images as 3D sprites.
	   Selected images with	alpha channels are managed.

	   Example:
	     [#1] image.jpg sprite3d

	 sprites3d:
	     [sprite],_sprite_has_alpha_channel={ 0 | 1	}

	   Convert selected 3D objects as a sprite cloud.
	   Set 'sprite_has_alpha_channel' to 1 to make the last	channel	of the
	   selected sprite be a	transparency mask.

	   Default value: 'mask_has_alpha_channel=0'.

	   Example:
	     [#1] torus3d 100,20 image.jpg resize2dy[-1] 64  100%,100%	gauss-
       ian[-1]
	      30%,30% *[-1] 255	append[-2,-1] c	+sprites3d[0] [1],1
	      display_rgba[-2]

	 star3d:
	     _nb_branches>0,0<=_thickness<=1

	   Input 3D star at position '(0,0,0)',	with specified geometry.

	   Default values: 'nb_branches=5' and 'thickness=0.38'.

	   Example:
	     [#1] star3d , +primitives3d 1 color3d[-2] ${-rgb}

	 streamline3d (+):
	     x[%],y[%],z[%],_L>=0,_dl>0,_interpolation,_is_backward={ 0	| 1 },
	       _is_oriented={ 0	| 1 } |
	     'formula',x,y,z,_L>=0,_dl>0,_interpolation,_is_backward={	0  | 1
       },
	       _is_oriented={ 0	| 1 }

	   Extract 3D streamlines from selected	vector fields or  from	speci-
       fied
	   formula.
	   'interpolation' can be { 0=nearest integer |	1=1st-order |
	   2=2nd-order | 3=4th-order }.

	   Default values: 'dl=0.1', 'interpolation=2',
	    'is_backward=0' and	'is_oriented=0'.

	   Example:
	     [#1] 100,100,100,3	rand -10,10 blur 3 repeat 300 +streamline3d[0]
	      {u(100)},{u(100)},{u(100)},1000,1,1 color3d[-1] ${-rgb} done
	      remove[0]	box3d 100 primitives3d[-1] 1 add3d

	 -3d (+):
	     Shortcut for command 'sub3d'.

	 sub3d (+):
	     tx,_ty,_tz

	   Shift  selected 3D objects with the opposite	of specified displace-
       ment
	   vector.
	   (equivalent to shortcut command '3d').

	   Default values: 'ty=tz=0'.

	   Example:
	     [#1] sphere3d 10 repeat 5 +sub3d[-1] 10,{u(-10,10)},0 color3d[-1]
	      ${-rgb} done add3d

	 superformula3d:
	     resolution>1,m>=1,n1,n2,n3

	   Input 2D superformula curve as a 3D object.

	   Default values: 'resolution=1024', 'm=8', 'n1=1',
	    'n2=5' and 'n3=8'.

	   Example:
	     [#1] superformula3d ,

	 tensors3d:
	     _radius_factor>=0,_shape={	0=box |	>=N=ellipsoid },_radius_min>=0

	   Generate 3D tensor fields from selected images.
	   when	'shape'>0, it gives the	ellipsoid shape	precision.

	   Default values: 'radius_factor=1', 'shape=2'	and
	    'radius_min=0.05'.

	   Example:
	     [#1] 6,6,6,9,"U = [x,y,z] - [w,h,d]/2; U/=norm(U);	mul(U,U,3) +
	      0.3*eye(3)" tensors3d 0.8

	 text_pointcloud3d:
	     _"text1",_"text2",_smoothness

	   Input 3D text pointcloud from the two specified strings.

	   Default values: 'text1="text1"', 'text2="text2"' and
	    'smoothness=1'.

	   Example:
	     [#1] text_pointcloud3d "G'MIC","Rocks!"

	 text3d:
	     text,_font_height>0,_depth>0,_smoothness

	   Input a 3D text object from specified text.

	   Default values: 'font_height=53', 'depth=10'	and
	    'smoothness=1.5'.

	   Example:
	     [#1] text3d "G'MIC	as a0D logo!"

	 t3d:
	     Shortcut for command 'texturize3d'.

	 texturize3d:
	     [ind_texture],_[ind_coords]

	   Texturize selected 3D objects with specified	 texture  and  coordi-
       nates.
	   (equivalent to shortcut command 't3d').

	   When	'[ind_coords]' is omitted, default XY texture projection is
	   performed.

	   Default value: 'ind_coords=(undefined)'.

	   Example:
	     [#1] image.jpg torus3d 100,30 texturize3d[-1] [-2]	keep[-1]

	 torus3d:
	     _radius1,_radius2,_nb_subdivisions1>2,_nb_subdivisions2>2

	   Input 3D torus at (0,0,0), with specified geometry.

	   Default values: 'radius1=1',	'radius2=0.3',
	    'nb_subdivisions1=24' and 'nb_subdivisions2=12'.

	   Example:
	     [#1] torus3d 10,3 +primitives3d 1 color3d[-2] ${-rgb}

	 triangle3d:
	     x0,y0,z0,x1,y1,z1,x2,y2,z2

	   Input 3D triangle at	specified coordinates.

	   Example:
	     [#1] repeat 100 a={$>*pi/50} triangle3d 0,0,0,0,0,3,{cos(3*$a)},
	      {sin(2*$a)},0 color3d[-1]	${-rgb}	done add3d

	 volume3d:

	   Transform  selected 3D volumetric images as 3D parallelepipedic ob-
       jects.

	   Example:
	     [#1] image.jpg animate blur,0,5,30	append z volume3d

	 weird3d:
	     _resolution>0

	   Input 3D weird object at (0,0,0), with specified resolution.

	   Default value: 'resolution=32'.

	   Example:
	     [#1] weird3d 48 +primitives3d 1 color3d[-2] ${-rgb}

	 12.13.	Control	Flow
		------------

	 ap:
	     Shortcut for command 'apply_parallel'.

	 apply_parallel:
	     "command"

	   Apply specified command on each of the selected images,  by	paral-
       lelizing
	   it for all image of the list.
	   (equivalent to shortcut command 'ap').

	   Example:
	     [#1] image.jpg +mirror x +mirror y	apply_parallel "blur 3"

	 apc:
	     Shortcut for command 'apply_parallel_channels'.

	 apply_parallel_channels:
	     "command"

	   Apply  specified  command on	each of	the selected images, by	paral-
       lelizing
	   it for all channel
	   of the images independently.
	   (equivalent to shortcut command 'apc').

	   Example:
	     [#1] image.jpg apply_parallel_channels "blur 3"

	 apo:
	     Shortcut for command 'apply_parallel_overlap'.

	 apply_parallel_overlap:
	     "command",overlap[%],nb_threads={ 0=auto |	1 | 2 |	4 | 8 |	16 }

	   Apply specified command on each of the selected images,  by	paral-
       lelizing
	   it on 'nb_threads'
	   overlapped sub-images.
	   (equivalent to shortcut command 'apo').

	   'nb_threads'	must be	a power	of 2.

	   Default values: 'overlap=0','nb_threads=0'.

	   Example:
	     [#1] image.jpg +apply_parallel_overlap "smooth 500,0,1",1

	 at:
	     Shortcut for command 'apply_tiles'.

	 apply_tiles:
	     "command",_tile_width[%]>0,_tile_height[%]>0,_tile_depth[%]>0,
	       _overlap_width[%]>=0,_overlap_height[%]>=0,_over-
       lap_depth[%]>=0,
	       _boundary_conditions={ 0=dirichlet | 1=neumann |	2=periodic |
	       3=mirror	}

	   Apply specified command on each tile	(neighborhood) of the selected
       images,
	    eventually with overlapping	tiles.
	   (equivalent to shortcut command 'at').

	   Default values: 'tile_width=tile_height=tile_depth=10%',
	    'overlap_width=overlap_height=overlap_depth=0' and
	    'boundary_conditions=1'.

	   Example:
	     [#1]   image.jpg	+equalize[0]   256  +apply_tiles[0]  "equalize
       256",16,16,1,
	      50%,50%

	 apply_timeout:
	     "command",_timeout={ 0=no timeout | >0=with specified timeout (in
       seconds)
	       }

	   Apply a command with	a timeout.
	   Set variable	'$_is_timeout' to '1' if timeout occurred,
	   '0' otherwise.

	   Default value: 'timeout=20'.

	 check (+):
	     condition

	   Evaluate specified condition	and display an error message if	evalu-
       ated to
	   false.
	   If 'expression' is not a math expression, it	is regarded as a
	   filename and	checked	if it exists.

	 check3d (+):
	     _is_full_check={ 0	| 1 }

	   Check validity of selected 3D vector	objects, and display an	 error
       message
	   if one of the selected images is not	a valid	3D vector object.
	   Full	3D object check	is slower but more precise.

	   Default value: 'is_full_check=1'.

	 continue (+):

	   Go to end of	current	'repeat...done', 'do...while' or
	   'local...endlocal' block.

	   Example:
	     [#1]  image.jpg  repeat  10  blur 1 if 1==1 continue fi deform 10
       done

	 break (+):

	   Break current 'repeat...done', 'do...while' or
	   'local...endlocal' block.

	   Example:
	     [#1] image.jpg repeat 10 blur 1 if	1==1 break fi deform 10	done

	 do (+):

	   Start a 'do...while'	block.

	   Example:
	     [#1] image.jpg luminance i={ia+2} do set  255,{u(100)}%,{u(100)}%
       while
	      ia<$i

	 done (+):

	   End a 'repeat/for...done' block, and	go to associated
	   'repeat/for'	position, if iterations	remain.

	 elif (+):
	     condition

	   Start a 'elif...[else]...fi'	block if previous 'if' was not
	   verified
	   and test if specified condition holds
	   'condition' is a mathematical expression, whose evaluation is
	   interpreted as { 0=false | other=true }..

	   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

	 endl (+):
	     Shortcut for command 'endlocal'.

	 endlocal (+):

	   End a 'local...endlocal' block.
	   (equivalent to shortcut command 'endl').

	 error (+):
	     message

	   Print  specified  error  message on the standard error (stderr) and
       exit
	   interpreter,	except
	   if error is caught by a 'onfail' command.
	   Command selection (if any) stands for displayed call	 stack	subset
       instead
	   of image indices.

	 eval (+):
	     expression

	   Evaluate specified math expression.
	    *  If  no command selection	is specified, the expression is	evalu-
       ated once
	   and its result is set to status.
	    * If command selection is specified, the evaluation	is looped over
	   selected images. Status is not modified.
	     (in this latter case, 'eval' is similar to	'fill' without
	   assigning the image values).

	 x (+):
	     Shortcut for command 'exec'.

	 exec (+):
	     _is_verbose={ 0 | 1 },"command"

	   Execute external command using a system call.
	   The status value is then set	to the error code returned by the sys-
       tem call.
	   If 'is_verbose=1', the executed command is allowed to output	on
	   stdout/stderr.
	   (equivalent to shortcut command 'x').

	   Default value: 'is_verbose=1'.

	 xo:
	     Shortcut for command 'exec_out'.

	 exec_out:
	     _mode,"command"

	   Execute external command using a system call, and return resulting
	   'stdout' and/or 'stderr'.
	   'mode' can be { 0=stdout | 1=stderr | 2=stdout+stderr }.

	 for (+):
	     condition

	   Start a 'for...done'	block.

	   Example:
	     [#1]  image.jpg  resize2dy	32 400,400,1,3 x=0 for $x<400 image[1]
       [0],$x,
	      $x x+=40 done

	 if (+):
	     condition

	   Start a 'if...[elif]...[else]...fi' block and test if specified
	   condition holds.
	   'condition' is a mathematical expression, whose evaluation is
	   interpreted as { 0=false | other=true }.

	   Example:
	     [#1] image.jpg if ia<64 add 50% elif ia<128 add 25%  elif	ia<192
       sub 25%
	      else sub 50% fi cut 0,255

	   Tutorial: https://gmic.eu/tutorial/iffi

	 l (+):
	     Shortcut for command 'local'.

	 local (+):

	   Start a 'local...[onfail]...endlocal' block,	with selected images.
	   (equivalent to shortcut command 'l').

	   Example:
	     [#1]  image.jpg  local[] 300,300,1,3 rand[0] 0,255	blur 4 sharpen
       1000
	      endlocal
	     [#2] image.jpg +local repeat 3 deform 20 done endlocal

	   Tutorial: https://gmic.eu/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...endlocal' block.
	   The status value is set with	the corresponding error	message.

	   Example:
	     [#1] image.jpg +local blur	-3 onfail mirror x endlocal

	 parallel (+):
	     _wait_threads,"command1","command2",...

	   Execute specified commands in parallel, each	in a different thread.
	   Parallel threads share the list of images.
	   'wait_threads' can be { 0=when current environment ends |
	   1=immediately }.

	   Default value: 'wait_threads=1'.

	   Example:
	     [#1] image.jpg [0]	parallel "blur[0] 3","mirror[1]	c"

	 progress (+):
	     0<=value<=100 |
	     -1

	   Set the progress index of the current processing pipeline.
	   This	command	is useful only when G'MIC is used by an	embedding  ap-
       plication.

	 q (+):
	     Shortcut for command 'quit'.

	 quit (+):

	   Quit	G'MIC interpreter.
	   (equivalent to shortcut command 'q').

	 repeat	(+):
	     nb_iterations,_variable_name

	   Start 'nb_iterations' iterations of a 'repeat...done' block.
	   'nb_iterations'  is	a  mathematical	expression that	will be	evalu-
       ated.

	   Example:
	     [#1] image.jpg split y repeat $!,n	shift[$n] $<,0,0,0,2 done  ap-
       pend y
	     [#2] image.jpg mode3d 2 repeat 4 imagecube3d rotate3d 1,1,0,40
	      snapshot3d 400,1.4 done

	   Tutorial: https://gmic.eu/oldtutorial/_repeat

	 return	(+):

	   Return from current custom command.

	 rprogress:
	     0<=value<=100	     |		 -1	      |		 "com-
       mand",0<=value_min<=100,0<=value_max<=100

	   Set the progress index of the current  processing  pipeline	(rela-
       tively to
	   previously  defined progress	bounds), or call the specified command
       with
	   specified progress bounds.

	 run:
	     "G'MIC pipeline"

	   Run specified G'MIC pipeline.
	   This	is only	useful when used from a	shell, e.g. to avoid shell
	   substitutions to happen in argument.

	 skip (+):
	     item

	   Do nothing but skip specified item.

	 u (+):
	     Shortcut for command 'status'.

	 status	(+):
	     status_string

	   Set the current status. Used	to define a  returning	value  from  a
       function.
	   (equivalent to shortcut command 'u').

	   Example:
	     [#1]   image.jpg	command	  "foo	 :  u0=Dark  u1=Bright	status
       ${u{ia>=128}}"
	      text_outline ${-foo},2,2,23,2,1,255

	 while (+):
	     condition

	   End a 'do...while' block and	go back	to associated 'do' if
	   specified condition holds.
	   'condition' is a mathematical expression, whose evaluation is
	   interpreted as { 0=false | other=true }.

	 12.14.	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_save:
	     'filename.gmz'

	   Save	current	network	as a .gmz file.
	   Neural network files	can be only saved in .gmz format.

	 nn_load:
	     'filename.gmz'

	   Load	and initialize network saved as	a .gmz file.
	   Neural network files	can be only loaded in .gmz format.

	 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=no parameters learnt | 1=gamma-only |
	   2=beta-only | 3=gamma & beta}.

	 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,_dilation>0

	   Add a 'conv2d' layer	(2D convolutional layer) to the	network.

	   Default values: 'kernel_size=3', 'stride=1' and
	    'dilation=1'.

	 nn_layer_conv2dnl:
	     name,in,nb_channels>0,_kernel_size>0,_stride>0,_dilation>0,_acti-
       vation

	   Add a 'con2dnl' (2D convolutional layer followed by	a  non-linear-
       ity),
	    to the network.

	   Default values: 'kernel_size=3', 'stride=1',
	    'dilation=1' and 'activation=leakyrelu'.

	 nn_layer_fc:
	     name,in,nb_channels>0

	   Add a 'fc' layer (fully connected layer) to the network.

	 nn_layer_fcnl:
	     name,in,nb_neurons>0,_activation

	   Add a 'fcnl'	layer (fully connected layer followed by a
	   non-linearity), to the network.

	   Default value: 'activation=leakyrelu'.

	 nn_layer_maxpool2d:
	     name,in

	   Add a 'maxpool2d' layer (2d max pooling) to the network.

	 nn_layer_nl:
	     name,in,activation

	   Add a 'nl' layer (non-linearity) to the network.

	   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_split:
	     name0,name1,in,nb_channels0

	   Add a 'split' layer to the network.

	 nn_layer_upsample2d:
	     name,in,_interpolation_type = { 0=nearest-neighbor	| 1=linear }

	   Add a 'upsample2d' layer to the network.

	 nn_loss_mse:
	     name,in,ground_truth,_learning_rate,_is_adaptive_learning_rate={
       0=false |
	       1=true }

	   Add a 'mse' loss to the network.

	   Default value: 'learning_rate=1e-6' and
	    'is_adaptive_learning_rate=1'.

	 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,_ex-
       pand_type={0=min	| 1=max
	       | 2=all}

	   Create MxN array from selected images.

	   Default values: 'N=M', 'fade_start=60',
	    'fade_end=90' and 'expand_type=1'.

	   Example:
	     [#1] image.jpg array_fade 3,2

	 array_mirror:
	     N>=0,_dir={ 0=x | 1=y | 2=xy | 3=tri-xy },_expand_type={ 0	| 1 }

	   Create 2^Nx2^N array	from selected images.

	   Default values: 'dir=2' and 'expand_type=0'.

	   Example:
	     [#1] image.jpg array_mirror 2

	 array_random:
	     Ms>0,_Ns>0,_Md>0,_Nd>0

	   Create MdxNd	array of tiles from selected MsxNs source arrays.

	   Default values: 'Ns=Ms', 'Md=Ms' and	'Nd=Ns'.

	   Example:
	     [#1] image.jpg +array_random 8,8,15,10

	 frame:
	     Shortcut for command 'frame_xy'.

	 frame_blur:
	     _sharpness>0,_size>=0,_smoothness,_shading,_blur

	   Draw	RGBA-colored round frame in selected images.

	   Default values: 'sharpness=10', 'size=30',
	    'smoothness=0', 'shading=1'	and 'blur=3%'.

	   Example:
	     [#1] image.jpg frame_blur 3,30,8,10%

	 frame_cube:
	     _depth>=0,_centering_x,_centering_y,_left_side={0=normal |	1=mir-
       ror-x |
	       2=mirror-y | 3=mirror-xy},_right_side,_lower_side,_upper_side

	   Insert 3D frames in selected	images.

	   Default values: 'depth=1', 'centering_x=centering_y=0'
	    and	'left_side=right_side,lower_side=upper_side=0'.

	   Example:
	     [#1] image.jpg frame_cube ,

	 frame_fuzzy:
	     size_x[%]>=0,_size_y[%]>=0,_fuzzyness>=0,_smooth-
       ness[%]>=0,_R,_G,_B,_A

	   Draw	RGBA-colored fuzzy frame in selected images.

	   Default values: 'size_y=size_x', 'fuzzyness=5',
	    'smoothness=1' and 'R=G=B=A=255'.

	   Example:
	     [#1] image.jpg frame_fuzzy	20

	 frame_painting:
	     _size[%]>=0,0<=_contrast<=1,_profile_smoothness[%]>=0,_R,_G,_B,
	       _vignette_size[%]>=0,_vignette_contrast>=0,_defects_con-
       trast>=0,
	       0<=_defects_density<=100,_defects_size>=0,_defects_smooth-
       ness[%]>=0,
	       _serial_number

	   Add a painting frame	to selected images.

	   Default values: 'size=10%', 'contrast=0.4',
	    'profile_smoothness=6%', 'R=225', 'G=200',
	    'B=120', 'vignette_size=2%', 'vignette_contrast=400',
	     'defects_contrast=50', 'defects_density=10',
	    'defects_size=1', 'defects_smoothness=0.5%'	and
	    'serial_number=123456789'.

	   Example:
	     [#1] image.jpg frame_painting ,

	 frame_pattern:
	     M>=3,_constrain_size={ 0 |	1 } |
	     M>=3,_[frame_image],_constrain_size={ 0 | 1 }

	   Insert selected pattern frame in selected images.

	   Default values: 'pattern=0' and 'constrain_size=0'.

	   Example:
	     [#1] image.jpg frame_pattern 8

	 frame_round:
	     _sharpness>0,_size>=0,_smoothness,_shading,_R,_G,_B,_A

	   Draw	RGBA-colored round frame in selected images.

	   Default values: 'sharpness=10', 'size=10',
	    'smoothness=0', 'shading=0'	and 'R=G=B=A=255'.

	   Example:
	     [#1] image.jpg frame_round	10

	 frame_seamless:
	     frame_size>=0,_patch_size>0,_blend_size>=0,_frame_direction={
       0=inner
	       (preserve image size) | 1=outer }

	   Insert frame	in selected images, so that tiling the resulting image
       makes
	   less	visible	seams.

	   Default values: 'patch_size=7', 'blend_size=5' and
	    'frame_direction=1'.

	   Example:
	     [#1] image.jpg +frame_seamless 30 array 2,2

	 frame_x:
	     size_x[%],_col1,...,_colN

	   Insert colored frame	along the x-axis in selected images.

	   Default values: 'col1=col2=col3=255'	and 'col4=255'.

	   Example:
	     [#1] image.jpg frame_x 20,255,0,255

	 frame_xy:
	     size_x[%],_size_y[%],_col1,...,_colN

	   Insert colored frame	along the x-axis in selected images.

	   Default values: 'size_y=size_x', 'col1=col2=col3=255'
	    and	'col4=255'.
	   (equivalent to shortcut command 'frame').

	   Example:
	     [#1] image.jpg frame_xy 1,1,0 frame_xy 20,10,255,0,255

	 frame_xyz:
	     size_x[%],_size_y[%],_size_z[%]_col1,...,_colN

	   Insert colored frame	along the x-axis in selected images.

	   Default values: 'size_y=size_x=size_z',
	    'col1=col2=col3=255' and 'col4=255'.

	 frame_y:
	     size_y[%],_col1,...,_colN

	   Insert colored frame	along the y-axis in selected images.

	   Default values: 'col1=col2=col3=255'	and 'col4=255'.

	   Example:
	     [#1] image.jpg frame_y 20,255,0,255

	 img2ascii:
	     _charset,_analysis_scale>0,_analysis_smoothness[%]>=0,_synthe-
       sis_scale>0,
	       _output_ascii_filename

	   Render selected images as binary ascii art.
	   This	command	returns	the  corresponding  the	 list  of  widths  and
       heights
	   (expressed as a number of characters)
	   for each selected image.

	   Default values: 'charset=[ascii charset]', 'analysis_scale=16',
	     'analysis_smoothness=20%',	'synthesis_scale=16' and
	    '_output_ascii_filename=[undefined]'.

	   Example:
	     [#1] image.jpg img2ascii ,

	 imagegrid:
	     M>0,_N>0

	   Create MxN image grid from selected images.

	   Default value: 'N=M'.

	   Example:
	     [#1] image.jpg imagegrid 16

	 imagegrid_hexagonal:
	     _resolution>0,0<=_outline<=1

	   Create hexagonal grids from selected	images.

	   Default values: 'resolution=32', 'outline=0.1' and
	    'is_antialiased=1'.

	   Example:
	     [#1] image.jpg imagegrid_hexagonal	24

	 imagegrid_triangular:
	     pattern_width>=1,_pattern_height>=1,_pattern_type,0<=_out-
       line_opacity<=1,
	       _outline_color1,...

	   Create triangular grids from	selected images.
	   'pattern type' can be { 0=horizontal	|  1=vertical  |  2=crossed  |
       3=cube
	   | 4=decreasing | 5=increasing }.

	   Default values: 'pattern_width=24',
	    'pattern_height=pattern_width', 'pattern_type=0',
	    'outline_opacity=0.1' and 'outline_color1=0'.

	   Example:
	     [#1] image.jpg imagegrid_triangular 6,10,3,0.5

	 linearize_tiles:
	     M>0,_N>0

	   Linearize MxN tiles on selected images.

	   Default value: 'N=M'.

	   Example:
	     [#1] image.jpg +linearize_tiles 16

	 map_sprites:
	     _nb_sprites>=1,_allow_rotation={  0=none |	1=90 deg. | 2=180 deg.
       }

	   Map set of sprites (defined as the 'nb_sprites'  latest  images  of
       the
	   selection) to other selected	images,
	   according to	the luminosity of their	pixel values.

	   Example:
	     [#1]  image.jpg  resize2dy	 48  repeat  16	 ball {8+2*$>},${-rgb}
       mul[-1]
	      {(1+$>)/16} done map_sprites 16

	 pack:
	     is_ratio_constraint={ 0 | 1 },_sort_criterion

	   Pack	selected images	into a single image.
	   The returned	status contains	the list of new	(x,y) offsets for each
       input
	   image.
	   Parameter 'is_ratio_constraint' tells if the	resulting image	must
	   tend	to a square image.

	   Default values: 'is_ratio_constraint=0' and
	    'sort_criterion=max(w,h)'.

	   Example:
	     [#1]  image.jpg  repeat  10  +resize2dx[-1] 75% balance_gamma[-1]
       ${-rgb}
	      done pack	0

	 puzzle:
	     _width>0,_height>0,_M>=1,_N>=1,_curvature,_centering,
	       _connectors_variability,_resolution>=1

	   Input puzzle	binary mask with specified size	and geometry.

	   Default values: 'width=height=512', 'M=N=5',
	    'curvature=0.5', 'centering=0.5',
	    'connectors_variability=0.5' and 'resolution=64'.

	   Example:
	     [#1] puzzle ,

	 quadratize_tiles:
	     M>0,_N>0

	   Quadratize MxN tiles	on selected images.

	   Default value: 'N=M'.

	   Example:
	     [#1] image.jpg +quadratize_tiles 16

	 rotate_tiles:
	     angle,_M>0,N>0

	   Apply MxN tiled-rotation effect on selected images.

	   Default values: 'M=8' and 'N=M'.

	   Example:
	     [#1] image.jpg to_rgba rotate_tiles 10,8 drop_shadow  10,10  dis-
       play_rgba

	 shift_tiles:
	     M>0,_N>0,_amplitude

	   Apply MxN tiled-shift effect	on selected images.

	   Default values: 'N=M' and 'amplitude=20'.

	   Example:
	     [#1] image.jpg +shift_tiles 8,8,10

	 taquin:
	     M>0,_N>0,_remove_tile={  0=none  |	 1=first  |  2=last | 3=random
       },_relief,
	       _border_thickness[%],_border_outline[%],_outline_color

	   Create MxN taquin puzzle from selected images.

	   Default value: 'N=M', 'relief=50',
	    'border_thickness=5', 'border_outline=0' and
	    'remove_tile=0'.

	   Example:
	     [#1] image.jpg +taquin 8

	 tunnel:
	     _level>=0,_factor>0,_centering_x,_centering_y,_opacity,_angle

	   Apply tunnel	effect on selected images.

	   Default values: 'level=9', 'factor=80%',
	    'centering_x=centering_y=0.5', 'opacity=1' and
	    'angle=0'

	   Example:
	     [#1] image.jpg tunnel 20

	 12.16.	Artistic
		--------

	 boxfitting:
	     _min_box_size>=1,_max_box_size>=0,_initial_density>=0,_nb_at-
       tempts>=1

	   Apply  box  fitting effect on selected images, as displayed the web
       page:
	   http://www.complexification.net/gallery/machines/boxFittingImg/.

	   Default values: 'min_box_size=1', 'max_box_size=0',
	    'initial_density=0.1' and 'nb_attempts=3'.

	   Example:
	     [#1] image.jpg boxfitting ,

	 brushify:
	     [brush],_brush_nb_sizes>=1,0<=_brush_min_size_factor<=1,
	       _brush_nb_orienta-
       tions>=1,_brush_light_type,0<=_brush_light_strength
	       <=1,_brush_opacity,_painting_density[%]>=0,0<=_painting_con-
       tours_coh
	       erence<=1,0<=_painting_orientation_coherence<=1,
	       _painting_coherence_alpha[%]>=0,_painting_coher-
       ence_sigma[%]>=0,
	       _painting_primary_angle,0<=_painting_angle_dispersion<=1

	   Apply specified brush to create painterly versions of specified im-
       ages.
	   'brush_light_type' can be { 0=none |	1=flat | 2=darken |
	   3=lighten | 4=full }.

	   Default values: 'brush_nb_sizes=3',
	    'brush_min_size_factor=0.66', 'brush_nb_orientations=12',
	    'brush_light_type=0', 'brush_light_strength=0.25',
	    'brush_opacity=0.8', 'painting_density=20%',
	    'painting_contours_coherence=0.9', 'painting_orientation_coher
	    ence=0.9', 'painting_coherence_alpha=1',
	    'painting_coherence_sigma=1', 'painting_primary_angle=0',
	    'painting_angle_dispersion=0.2'

	   Example:
	     [#1]  image.jpg   40,40   gaussian[-1]   10,4   spread[-1]	  10,0
       brushify[0] [1],1

	 cartoon:
	     _smoothness,_sharpening,_threshold>=0,_thickness>=0,_color>=0,
	       quantization>0

	   Apply cartoon effect	on selected images.

	   Default values: 'smoothness=3', 'sharpening=150',
	    'threshold=20', 'thickness=0.25', 'color=1.5' and
	    'quantization=8'.

	   Example:
	     [#1] image.jpg cartoon 3,50,10,0.25,3,16

	 color_ellipses:
	     _count>0,_radius>=0,_opacity>=0

	   Add random color ellipses to	selected images.

	   Default values: 'count=400',	'radius=5' and
	    'opacity=0.1'.

	   Example:
	     [#1] image.jpg +color_ellipses ,,0.15

	 cubism:
	     _density>=0,0<=_thickness<=50,_max_angle,_opacity,_smoothness>=0

	   Apply cubism	effect on selected images.

	   Default values: 'density=50', 'thickness=10',
	    'max_angle=75', 'opacity=0.7' and 'smoothness=0'.

	   Example:
	     [#1] image.jpg cubism ,

	 draw_whirl:
	     _amplitude>=0

	   Apply whirl drawing effect on selected images.

	   Default value: 'amplitude=100'.

	   Example:
	     [#1] image.jpg draw_whirl ,

	 drawing:
	     _amplitude>=0

	   Apply drawing effect	on selected images.

	   Default value: 'amplitude=200'.

	   Example:
	     [#1] image.jpg +drawing ,

	 drop_shadow:
	     _offset_x[%],_offset_y[%],_smoothness[%]>=0,0<=_curvature<=1,
	       _expand_size={ 0	| 1 }

	   Drop	shadow behind selected images.

	   Default values: 'offset_x=20', 'offset_y=offset_x',
	    'smoothness=5', 'curvature=0' and 'expand_size=1'.

	   Example:
	     [#1]   image.jpg  drop_shadow  10,20,5,0.5	 expand_xy  20,0  dis-
       play_rgba

	 ellipsionism:
	     _R>0[%],_r>0[%],_smoothness>=0[%],_opacity,_outline>0,_density>0

	   Apply ellipsionism filter to	selected images.

	   Default values: 'R=10', 'r=3', 'smoothness=1%',
	    'opacity=0.7', 'outline=8' and 'density=0.6'.

	   Example:
	     [#1] image.jpg ellipsionism ,

	 fire_edges:
	     _edges>=0,0<=_attenuation<=1,_smoothness>=0,_thresh-
       old>=0,_nb_frames>0,
	       _starting_frame>=0,frame_skip>=0

	   Generate fire effect	from edges of selected images.

	   Default values: 'edges=0.7',	'attenuation=0.25',
	    'smoothness=0.5', 'threshold=25', 'nb_frames=1',
	    'starting_frame=20'	and 'frame_skip=0'.

	   Example:
	     [#1] image.jpg fire_edges ,

	 fractalize:
	     0<=detail_level<=1

	   Randomly fractalize selected	images.

	   Default value: 'detail_level=0.8'

	   Example:
	     [#1] image.jpg fractalize ,

	 glow:
	     _amplitude>=0

	   Add soft glow on selected images.

	   Default value: 'amplitude=1%'.

	   Example:
	     [#1] image.jpg glow ,

	 halftone:
	     nb_levels>=2,_size_dark>=2,_size_bright>=2,_shape={   0=square  |
       1=diamond |
	       2=circle	| 3=inv-square | 4=inv-diamond | 5=inv-circle },
	       _smoothness[%]>=0

	   Apply halftone dithering to selected	images.

	   Default values: 'nb_levels=5', 'size_dark=8',
	    'size_bright=8', 'shape=5' and 'smoothnesss=0'.

	   Example:
	     [#1] image.jpg halftone ,

	 hardsketchbw:
	     _amplitude>=0,_density>=0,_opacity,0<=_edge_thresh-
       old<=100,_is_fast={ 0 |
	       1 }

	   Apply hard B&W sketch effect	on selected images.

	   Default values: 'amplitude=1000', 'sampling=3',
	    'opacity=0.1', 'edge_threshold=20' and 'is_fast=0'.

	   Example:
	     [#1]  image.jpg  +hardsketchbw  200,70,0.1,10 median[-1] 2	+local
       reverse
	      blur[-1] 3 blend[-2,-1] overlay endlocal

	 hearts:
	     _density>=0

	   Apply heart effect on selected images.

	   Default value: 'density=10'.

	   Example:
	     [#1] image.jpg hearts ,

	 houghsketchbw:
	     _density>=0,_radius>0,0<=_threshold<=100,0<=_opacity<=1,_vote-
       size[%]>0

	   Apply hough B&W sketch effect on selected images.

	   Default values: 'density=100', 'radius=3',
	    'threshold=100', 'opacity=0.1' and 'votesize=100%'.

	   Example:
	     [#1] image.jpg +houghsketchbw ,

	 lightrays:
	     100<=_density<=0,_center_x[%],_center_y[%],_ray_length>=0,
	       _ray_attenuation>=0

	   Generate ray	lights from the	edges of selected images.

	   Default values: 'density=50%', 'center_x=50%',
	    'center_y=50%', 'ray_length=0.9' and
	    'ray_attenuation=0.5'.

	   Example:
	     [#1] image.jpg +lightrays , + cut 0,255

	 light_relief:
	     _ambient_light,_specular_lightness,_specular_size,_darkness,
	       _light_smoothness,_xl,_yl,_zl,_zscale,_opacity_is_heightmap={ 0
       | 1
	       }

	   Apply relief	light to selected images.
	   Default values(s) : 'ambient_light=0.3',
	   'specular_lightness=0.5', 'specular_size=0.2',
	   'darkness=0', 'xl=0.2', 'yl=zl=0.5',
	   'zscale=1', 'opacity=1' and 'opacity_is_heightmap=0'.

	   Example:
	     [#1] image.jpg blur 2 light_relief	0.3,4,0.1,0

	 linify:
	     0<=_density<=100,_spreading>=0,_resolution[%]>0,_line_opacity>=0,
	       _line_precision>0,_mode={ 0=subtractive | 1=additive }

	   Apply linify	effect on selected images.
	   The algorithm is inspired from the one described on the webpage
	   http://linify.me/about.

	   Default values: 'density=50', 'spreading=2',
	    'resolution=40%', 'line_opacity=10',
	    'line_precision=24'	and 'mode=0'.

	   Example:
	     [#1] image.jpg linify 60

	 mosaic:
	     0<=_density<=100

	   Create random mosaic	from selected images.

	   Default values: 'density=30'.

	   Example:
	     [#1] image.jpg mosaic , +fill "I!=J(1) || I!=J(0,1)?[0,0,0]:I"

	 old_photo:

	   Apply old photo effect on selected images.

	   Example:
	     [#1] image.jpg old_photo

	 pencilbw:
	     _size>=0,_amplitude>=0

	   Apply B&W pencil effect on selected images.

	   Default values: 'size=0.3' and 'amplitude=60'.

	   Example:
	     [#1] image.jpg pencilbw ,

	 pixelsort:
	     _ordering={ + | - },_axis={ x | y | z | xy	| yx  },_[sorting_cri-
       terion],
	       _[mask]

	   Apply  a 'pixel sorting' algorithm on selected images, as described
       in the
	   page	:
	   http://satyarth.me/articles/pixel-sorting/.

	   Default values: 'ordering=+', 'axis=x' and
	    'sorting_criterion=mask=(undefined)'.

	   Example:
	     [#1] image.jpg +norm +ge[-1] 30% +pixelsort[0] +,y,[1],[2]

	 polaroid:
	     _size1>=0,_size2>=0

	   Create polaroid effect in selected images.

	   Default values: 'size1=10' and 'size2=20'.

	   Example:
	     [#1] image.jpg to_rgba polaroid  5,30  rotate  20	drop_shadow  ,
       drgba

	 polygonize:
	     _warp_amplitude>=0,_smoothness[%]>=0,_min_area[%]>=0,_resolu-
       tion_x[%]>0,
	       _resolution_y[%]>0

	   Apply polygon effect	on selected images.

	   Default values: 'warp_amplitude=300', 'smoothness=2%',
	    'min_area=0.1%', 'resolution_x=resolution_y=10%'.

	   Example:
	     [#1] image.jpg image.jpg  polygonize  100,10  +fill  "I!=J(1)  ||
       I!=J(0,
	      1)?[0,0,0]:I"

	 poster_edges:
	     0<=_edge_threshold<=100,0<=_edge_shade<=100,_edge_thickness>=0,
	       _edge_antialiasing>=0,0<=_posterization_level<=15,
	       _posterization_antialiasing>=0

	   Apply poster	edges effect on	selected images.

	   Default values: 'edge_threshold=40',	'edge_shade=5',
	    'edge_thickness=0.5', 'edge_antialiasing=10',
	    'posterization_level=12' and 'posterization_antialiasing=0'
	    .

	   Example:
	     [#1] image.jpg poster_edges ,

	 poster_hope:
	     _smoothness>=0

	   Apply Hope stencil poster effect on selected	images.

	   Default value: 'smoothness=3'.

	   Example:
	     [#1] image.jpg poster_hope	,

	 rodilius:
	     0<=_amplitude<=100,_0<=thickness<=100,_sharpness>=0,_nb_orienta-
       tions>0,
	       _offset,_color_mode={ 0=darker |	1=brighter }

	   Apply rodilius (fractalius-like) filter on selected images.

	   Default values: 'amplitude=10', 'thickness=10',
	    'sharpness=400', 'nb_orientations=7', 'offset=0' and
	    'color_mode=1'.

	   Example:
	     [#1] image.jpg rodilius 12,10,300,10 normalize_local 10,6
	     [#2] image.jpg normalize_local 10,16 rodilius 10,4,400,16	smooth
       60,0,1,
	      1,4 normalize_local 10,16

	 sketchbw:
	     _nb_angles>0,_start_angle,_angle_range>=0,_length>=0,_thresh-
       old>=0,
	       _opacity,_bgfactor>=0,_density>0,_sharpness>=0,_anisotropy>=0,
	       _smoothness>=0,_coherence>=0,_is_boost={	0 | 1 },_is_curved={ 0
       | 1
	       }

	   Apply sketch	effect to selected images.

	   Default values: 'nb_angles=2', 'start_angle=45',
	    'angle_range=180', 'length=30', 'threshold=3',
	    'opacity=0.03', 'bgfactor=0', 'density=0.6',
	    'sharpness=0.1', 'anisotropy=0.6', 'smoothness=0.25',
	     'coherence=1', 'is_boost=0' and 'is_curved=1'.

	   Example:
	     [#1]  image.jpg +sketchbw 1 reverse blur[-1] 3 blend[-2,-1] over-
       lay

	 sponge:
	     _size>0

	   Apply sponge	effect on selected images.

	   Default value: 'size=13'.

	   Example:
	     [#1] image.jpg sponge ,

	 stained_glass:
	     _edges[%]>=0, shading>=0, is_thin_separators={ 0 |	1 }

	   Generate stained glass from selected	images.

	   Default values: 'edges=40%',	'shading=0.2' and
	    'is_precise=0'.

	   Example:
	     [#1] image.jpg stained_glass 20%,1	cut 0,20

	 stars:
	     _density[%]>=0,_depth>=0,_size>0,_nb_branches>=1,0<=_thick-
       ness<=1,
	       _smoothness[%]>=0,_R,_G,_B,_opacity

	   Add random stars to selected	images.

	   Default values: 'density=10%', 'depth=1',
	    'size=32', 'nb_branches=5',	'thickness=0.38',
	    'smoothness=0.5', 'R=G=B=200' and 'opacity=1'.

	   Example:
	     [#1] image.jpg stars ,

	 stencil:
	     _radius[%]>=0,_smoothness>=0,_iterations>=0

	   Apply stencil filter	on selected images.

	   Default values: 'radius=3', 'smoothness=1' and
	    'iterations=8'.

	   Example:
	     [#1] image.jpg +norm stencil. 2,1,4 +mul rm[0]

	 stencilbw:
	     _edges>=0,_smoothness>=0

	   Apply B&W stencil effect on selected	images.

	   Default values: 'edges=15' and 'smoothness=10'.

	   Example:
	     [#1] image.jpg +stencilbw 40,4

	 stylize:
	     [style_image],_fidelity_finest,_fidelity_coarsest,
	       _fidelity_smoothness_finest>=0,_fidelity_smoothnes_coarsest>=0,
	       0<=_fidelity_chroma<=1,_init_type,_init_resolution>=0,
	       init_max_gradient>=0,_patchsize_analysis>0,_patchsize_synthe-
       sis>0,
	       _patchsize_synthesis_final>0,_nb_matches_finest>=0,
	       _nb_matches_coarsest>=0,_penalize_repetitions>=0,
	       _matching_precision>=0,_scale_factor>1,_skip_finest_scales>=0,
	       _"image_matching_command"

	   Transfer colors and textures	from specified style image to selected
       images,
	    using a multi-scale	patch-mathing algorithm.
	   If instant display window[0]	is opened, the steps of	the image syn-
       thesis
	   are displayed on it.
	   'init_type' can be {	0=best-match | 1=identity | 2=randomized
	   }.

	   Default values: 'fidelity_finest=0.5',
	    'fidelity_coarsest=2', 'fidelity_smoothness_finest=3',
	    'fidelity_smoothness_coarsest=0.5',	'fidelity_chroma=0.1',
	    'init_type=0', 'init_resolution=16',
	    'init_max_gradient=0', 'patchsize_analysis=5',
	    'patchsize_synthesis=5', 'patchsize_synthesis_final=5',
	    'nb_matches_finest=2', 'nb_matchesc_coarsest=30',
	    'penalize_repetitions=10', 'matching_precision=2',
	    'scale_factor=1.85', 'skip_finest_scales=0'	and
	    'image_matching_command'="s	c,-3 transfer_pca[0] [2] b[0,2]	xy,0.7
       n[0,
	    2] 0,255 n[1,2] 0,200 a[0,1] c a[1,2] c"'.

	 tetris:
	     _scale>0

	   Apply tetris	effect on selected images.

	   Default value: 'scale=10'.

	   Example:
	     [#1] image.jpg +tetris 10

	 warhol:
	     _M>0,_N>0,_smoothness>=0,_color>=0

	   Create MxN Andy Warhol-like artwork from selected images.

	   Default values: 'M=3', 'N=M', 'smoothness=2'	and
	    'color=20'.

	   Example:
	     [#1] image.jpg warhol 3,3,3,40

	 weave:
	     _density>=0,0<=_thickness<=100,0<=_shadow<=100,_shading>=0,
	       _fibers_amplitude>=0,_fibers_smoothness>=0,_angle,
	       -1<=_x_curvature<=1,-1<=_y_curvature<=1

	   Apply weave effect to the selected images.
	   'angle' can be { 0=0	deg. | 1=22.5 deg. | 2=45 deg. | 3=67.5	deg.
	   }.

	   Default values: 'density=6',	'thickness=65',
	    'shadow=40', 'shading=0.5',	'fibers_amplitude=0',
	    _'fibers_smoothness=0', 'angle=0' and 'curvature_x=curvature_y
	    =0'

	   Example:
	     [#1] image.jpg weave ,

	 whirls:
	     _texture>=0,_smoothness>=0,_darkness>=0,_lightness>=0

	   Add random whirl texture to selected	images.

	   Default values: 'texture=3',	'smoothness=6',
	    'darkness=0.5' and 'lightness=1.8'.

	   Example:
	     [#1] image.jpg whirls ,

	 12.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_condi-
       tions={
	       0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	   Apply euclidean to polar transform on selected images.

	   Default values: 'center_x=center_y=50%',
	    'stretch_factor=1' and 'boundary_conditions=1'.

	   Example:
	     [#1] image.jpg +euclidean2polar ,

	 equirectangular2nadirzenith:

	   Transform selected equirectangular images to	nadir/zenith rectilin-
       ear
	   projections.

	 fisheye:
	     _center_x,_center_y,0<=_radius<=100,_amplitude>=0

	   Apply fish-eye deformation on selected images.

	   Default values: 'x=y=50', 'radius=50' and
	    'amplitude=1.2'.

	   Example:
	     [#1] image.jpg +fisheye ,

	 flower:
	     _amplitude,_frequency,_offset_r[%],_angle,_center_x[%],_cen-
       ter_y[%],
	       _boundary_conditions={ 0=dirichlet | 1=neumann |	2=periodic |
	       3=mirror}

	     toto
	   Apply flower	deformation on selected	images.

	   Default values: 'amplitude=30', 'frequency=6',
	    'offset_r=0', 'angle=0', 'center_x=center_y=50%' and
	    'boundary_conditions=3'.

	   Example:
	     [#1] image.jpg +flower ,

	 kaleidoscope:
	     _center_x[%],_center_y[%],_radius,_angle,_boundary_conditions={
	       0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	   Create kaleidoscope effect from selected images.

	   Default values: 'center_x=center_y=50%', 'radius=100',
	    'angle=30' and 'boundary_conditions=3'.

	   Example:
	     [#1] image.jpg kaleidoscope ,

	 map_sphere:
	     _width>0,_height>0,_radius,_dilation>0,_fading>=0,_fad-
       ing_power>=0

	   Map selected	images on a sphere.

	   Default values: 'width=height=512', 'radius=100',
	    'dilation=0.5', 'fading=0' and 'fading_power=0.5'.

	   Example:
	     [#1] image.jpg map_sphere ,

	 nadirzenith2equirectangular:

	   Transform   selected	  nadir/zenith	 rectilinear   projections  to
       equirectangular
	   images.

	 polar2euclidean:
	     _center_x[%],_center_y[%],_stretch_factor>0,_boundary_condi-
       tions={
	       0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	   Apply euclidean to polar transform on selected images.

	   Default values: 'center_x=center_y=50%',
	    'stretch_factor=1' and 'boundary_conditions=1'.

	   Example:
	     [#1] image.jpg +euclidean2polar ,

	 raindrops:
	     _amplitude,_density>=0,_wavelength>=0,_merging_steps>=0

	   Apply raindrops deformation on selected images.

	   Default values: 'amplitude=80','density=0.1',
	    'wavelength=1' and 'merging_steps=0'.

	   Example:
	     [#1] image.jpg +raindrops ,

	 ripple:
	     _amplitude,_bandwidth,_shape={  0=bloc  |	1=triangle  | 2=sine |
       3=sine+ |
	       4=random	},_angle,_offset

	   Apply ripple	deformation on selected	images.

	   Default values: 'amplitude=10', 'bandwidth=10',
	    'shape=2', 'angle=0' and 'offset=0'.

	   Example:
	     [#1] image.jpg +ripple ,

	 rotoidoscope:
	     _center_x[%],_center_y[%],_tiles>0,_smoothness[%]>=0,
	       _boundary_conditions={ 0=dirichlet | 1=neumann |	2=periodic |
	       3=mirror	}

	   Create rotational kaleidoscope effect from selected images.

	   Default values: 'center_x=center_y=50%', 'tiles=10',
	    'smoothness=1' and 'boundary_conditions=3'.

	   Example:
	     [#1] image.jpg +rotoidoscope ,

	 spherize:
	     _radius[%]>=0,_strength,_smoothness[%]>=0,_center_x[%],_cen-
       ter_y[%],
	       _ratio_x/y>0,_angle,_interpolation

	   Apply spherize effect on selected images.

	   Default values: 'radius=50%', 'strength=1',
	    'smoothness=0', 'center_x=center_y=50%',
	    'ratio_x/y=1', 'angle=0' and 'interpolation=1'.

	   Example:
	     [#1] image.jpg grid 5%,5%,0,0,0.6,255 spherize ,

	 symmetrize:
	     _x[%],_y[%],_angle,_boundary_conditions={ 0=dirichlet | 1=neumann
       |
	       2=periodic   |	3=mirror   },_is_antisymmetry={	   0	|    1
       },_swap_sides={ 0
	       | 1 }

	   Symmetrize selected images regarding	specified axis.

	   Default values: 'x=y=50%', 'angle=90',
	    'boundary_conditions=3', 'is_antisymmetry=0' and
	    'swap_sides=0'.

	   Example:
	     [#1] image.jpg +symmetrize	50%,50%,45 +symmetrize[-1] 50%,50%,-45

	 transform_polar:
	     "expr_radius",_"expr_angle",_center_x[%],_center_y[%],
	       _boundary_conditions={ 0=dirichlet | 1=neumann }

	   Apply  user-defined	transform  on polar representation of selected
       images.

	   Default values: 'expr_radius=R-r', 'expr_rangle=a',
	    'center_x=center_y=50%' and	'boundary_conditions=1'.

	   Example:
	     [#1]  image.jpg  +transform_polar[0]  R*(r/R)^2,a	+transform_po-
       lar[0] r,2*a

	 twirl:
	     _amplitude,_center_x[%],_center_y[%],_boundary_conditions={
       0=dirichlet |
	       1=neumann | 2=periodic |	3=mirror }

	   Apply twirl deformation on selected images.

	   Default values: 'amplitude=1', 'center_x=center_y=50%'
	    and	'boundary_conditions=3'.

	   Example:
	     [#1] image.jpg twirl 0.6

	 warp_perspective:
	     _x-angle,_y-angle,_zoom>0,_x-center,_y-center,_boundary_condi-
       tions={
	       0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	   Warp	selected images	with perspective deformation.

	   Default values: 'x-angle=1.5', 'y-angle=0',
	    'zoom=1', 'x-center=y-center=50' and
	    'boundary_conditions=2'.

	   Example:
	     [#1] image.jpg warp_perspective ,

	 water:
	     _amplitude,_smoothness>=0,_angle

	   Apply water deformation on selected images.

	   Default values: 'amplitude=30', 'smoothness=1.5' and
	    'angle=45'.

	   Example:
	     [#1] image.jpg water ,

	 wave:
	     _amplitude>=0,_frequency>=0,_center_x,_center_y

	   Apply wave deformation on selected images.

	   Default values: 'amplitude=4', 'frequency=0.4' and
	    'center_x=center_y=50'.

	   Example:
	     [#1] image.jpg wave ,

	 wind:
	     _amplitude>=0,_angle,0<=_attenuation<=1,_threshold

	   Apply wind effect on	selected images.

	   Default values: 'amplitude=20', 'angle=0',
	    'attenuation=0.7' and 'threshold=20'.

	   Example:
	     [#1] image.jpg +wind ,

	 zoom:
	     _factor,_cx,_cy,_cz,_boundary_conditions={	 0=dirichlet  |	1=neu-
       mann |
	       2=periodic | 3=mirror }

	   Apply zoom factor to	selected images.

	   Default values: 'factor=1', 'cx=cy=cz=0.5' and
	    'boundary_conditions=0'.

	   Example:
	     [#1] image.jpg +zoom[0] 0.6 +zoom[0] 1.5

	 12.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=bloc |  1=triangle  |  2=sine  |
       3=sine+ |
	       4=random	},_angle,_offset

	   Apply ripple	deformation on selected	images.

	   Default values: 'amplitude=60', 'bandwidth=2',
	    'shape=0', 'angle=0' and 'offset=0'.

	   Example:
	     [#1] image.jpg +scanlines ,

	 shade_stripes:
	     _frequency>=0,_direction={	 0=horizontal  |  1=vertical  },_dark-
       ness>=0,
	       _lightness>=0

	   Add shade stripes to	selected images.

	   Default values: 'frequency=5', 'direction=1',
	    'darkness=0.8' and 'lightness=2'.

	   Example:
	     [#1] image.jpg +shade_stripes 30

	 shadow_patch:
	     _opacity>=0

	   Add shadow patches to selected images.

	   Default value: 'opacity=0.7'.

	   Example:
	     [#1] image.jpg +shadow_patch 0.4

	 spread:
	     _dx>=0,_dy>=0,_dz>=0

	   Spread pixel	values of selected images randomly along x,y and z.

	   Default values: 'dx=3', 'dy=dx' and 'dz=0'.

	   Example:
	     [#1] image.jpg +spread 3

	 stripes_y:
	     _frequency>=0

	   Add vertical	stripes	to selected images.

	   Default value: 'frequency=10'.

	   Example:
	     [#1] image.jpg +stripes_y ,

	 texturize_canvas:
	     _amplitude>=0,_fibrousness>=0,_emboss_level>=0

	   Add paint canvas texture to selected	images.

	   Default values: 'amplitude=20', 'fibrousness=3' and
	    'emboss_level=0.6'.

	   Example:
	     [#1] image.jpg +texturize_canvas ,

	 texturize_paper:

	   Add paper texture to	selected images.

	   Example:
	     [#1] image.jpg +texturize_paper

	 vignette:
	     _strength>=0,0<=_radius_min<=100,0<=_radius_max<=100

	   Add vignette	effect to selected images.

	   Default values: 'strength=100', 'radius_min=70' and
	    'radius_max=90'.

	   Example:
	     [#1] image.jpg vignette ,

	 watermark_visible:
	     _text,0<_opacity<1,_size>0,_angle,_mode={	 0=remove   |	 1=add
       },_smoothness>=0

	   Add	or  remove a visible watermark on selected images (value range
       must be
	   [0,255]).

	   Default values: 'text=(c) G'MIC', 'opacity=0.3',
	    'size=53', 'angle=25', 'mode=1' and
	    'smoothness=0'.

	   Example:
	     [#1] image.jpg watermark_visible ,0.7

	 12.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 |	grain-
       merge |
	   green | hardlight |
	   hardmix  | hue | interpolation | lchlightness | lighten | lightness
       |
	   linearburn |	linearlight | luminance	|
	   multiply | negation | or | overlay |	pinlight |  red	 |  reflect  |
       saturation
	   | seamless |	seamless_mixed |
	   screen  |  shapeareamax  |  shapeareamax0  |	 shapeareamin  |  sha-
       peareamin0 |
	   shapeaverage	| shapeaverage0	|
	   shapemedian | shapemedian0 |	shapemin  |  shapemin0	|  shapemax  |
       shapemax0 |
	   softburn | softdodge	|
	   softlight | stamp | subtract	| value	| vividlight | xor }.
	   'opacity' should be in '[0,1]', or '[0,100]'	if
	   expressed with a '%'.

	   Default values: 'blending_mode=alpha', 'opacity=1' and
	    'selection_is=0'.

	   Example:
	     [#1]  image.jpg  +drop_shadow  ,  resize2dy[-1] 200 rotate[-1] 20
       +blend
	      alpha display_rgba[-2]
	     [#2] image.jpg testimage2d	{w},{h}	blend overlay
	     [#3] command "ex :	$""=arg	repeat $""# +blend[0,1]	${arg{$>+1}}
	      text_outline[-1] Mode:
	      image.jpg	testimage2d {w},{h} ex add,alpha,and,average,blue,
	      burn,darken
	     [#4] command "ex :	$""=arg	repeat $""# +blend[0,1]	${arg{$>+1}}
	      text_outline[-1] Mode:
	      image.jpg	testimage2d {w},{h} ex difference,divide,dodge,
	      exclusion,freeze,grainextract,grainmerge
	     [#5] command "ex :	$""=arg	repeat $""# +blend[0,1]	${arg{$>+1}}
	      text_outline[-1] Mode:
	      image.jpg	testimage2d {w},{h} ex green,hardlight,hardmix,hue,
	      interpolation,lighten,lightness
	     [#6] command "ex :	$""=arg	repeat $""# +blend[0,1]	${arg{$>+1}}
	      text_outline[-1] Mode:
	      image.jpg	testimage2d {w},{h} ex linearburn,linearlight,
	      luminance,multiply,negation,or,overlay
	     [#7] command "ex :	$""=arg	repeat $""# +blend[0,1]	${arg{$>+1}}
	      text_outline[-1] Mode:
	      image.jpg	testimage2d {w},{h} ex pinlight,red,reflect,
	      saturation,screen,shapeaverage,softburn
	     [#8] command "ex :	$""=arg	repeat $""# +blend[0,1]	${arg{$>+1}}
	      text_outline[-1] Mode:
	      image.jpg	testimage2d {w},{h} ex softdodge,softlight,stamp,
	      subtract,value,vividlight,xor

	 blend_edges:
	     smoothness[%]>=0

	   Blend selected images togethers using 'edges' mode.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+blend_edges 0.8

	 blend_fade:
	     [fading_shape]

	   Blend selected images together using	specified fading shape.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	100%,100%,1,1,'cos(y/10)'
	      normalize[-1] 0,1	+blend_fade[0,1] [2]

	 blend_median:

	   Blend selected images together using	'median' mode.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+mirror[0] y +blend_median

	 blend_seamless:
	     _is_mixed_mode={ 0	| 1 },_inner_fading[%]>=0,_outer_fading[%]>=0

	   Blend selected images using	a  seamless  blending  mode  (Poisson-
       based).

	   Default values: 'is_mixed=0', 'inner_fading=0' and
	    'outer_fading=100%'.

	 fade_diamond:
	     0<=_start<=100,0<=_end<=100

	   Create diamond fading from selected images.

	   Default values: 'start=80' and 'end=90'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+fade_diamond 80,85

	 fade_linear:
	     _angle,0<=_start<=100,0<=_end<=100

	   Create linear fading	from selected images.

	   Default values: 'angle=45', 'start=30' and
	    'end=70'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+fade_linear 45,48,52

	 fade_radial:
	     0<=_start<=100,0<=_end<=100

	   Create radial fading	from selected images.

	   Default values: 'start=30' and 'end=70'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+fade_radial 30,70

	 fade_x:
	     0<=_start<=100,0<=_end<=100

	   Create horizontal fading from selected images.

	   Default values: 'start=30' and 'end=70'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+fade_x	30,70

	 fade_y:
	     0<=_start<=100,0<=_end<=100

	   Create vertical fading from selected	images.

	   Default values: 'start=30' and 'end=70'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+fade_y	30,70

	 fade_z:
	     0<=_start<=100,0<=_end<=100

	   Create transversal fading from selected images.

	   Default values: 'start=30' and 'end=70'.

	 sub_alpha:
	     [base_image],_opacity_gain>=1

	   Compute  the	 minimal  alpha-channel	 difference (opposite of alpha
       blending)
	   between the selected	images
	   and the specified base image.
	   The alpha difference	A-B is defined as  the	image  having  minimal
       opacity,
	   such	that alpha_blend(B,A-B)	= A.

	   Default value: 'opacity_gain=1'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+sub_alpha[0] [1] display_rgba

	 12.20.	Image Sequences	and Videos
		--------------------------

	 animate:
	     fil-
       ter_name,"param1_start,...,paramN_start","param1_end,...,paramN_end",
	       nb_frames>=0,_output_frames={ 0 | 1 },_output_filename |
	     delay>0,_back and forth={ 0 | 1 }

	   Animate filter from starting	parameters to ending parameters	or an-
       imate
	   selected images
	   in a	display	window.

	   Default value: 'delay=30'.

	   Example:
	     [#1] image.jpg animate flower,"0,3","20,8",9

	 apply_camera:
	     _"command",_camera_index>=0,_skip_frames>=0,_output_filename

	   Apply  specified  command  on live camera stream, and display it on
       display
	   window [0].
	   This	command	requires features from the OpenCV library (not enabled
       in
	   G'MIC by default).

	   Default values: 'command=""', 'camera_index=0' (default
	    camera), 'skip_frames=0' and 'output_filename=""'.

	 apply_files:
	     "filename_pattern",_"command",_first_frame>=0,_last_frame={ >=0 |
       -1=last
	       },_frame_step>=1,_output_filename

	   Apply a G'MIC command on specified input image files, in a streamed
       way.
	   If  a display window	is opened, rendered frames are displayed in it
       during
	   processing.
	   The output filename may have	extension '.avi' or '.mp4' (saved
	   as a	video),	or any other usual image file
	   extension (saved as a sequence of images).

	   Default values: 'command=(undefined)', 'first_frame=0',
	    'last_frame=-1', 'frame_step=1' and
	    'output_filename=(undefined)'.

	 apply_video:
	     video_filename,_"command",_first_frame>=0,_last_frame={   >=0   |
       -1=last },
	       _frame_step>=1,_output_filename

	   Apply  a  G'MIC  command on all frames of the specified input video
       file, in
	   a streamed way.
	   If a	display	window is opened, rendered frames are displayed	in  it
       during
	   processing.
	   The output filename may have	extension '.avi' or '.mp4' (saved
	   as a	video),	or any other usual image
	   file	extension (saved as a sequence of images).
	   This	command	requires features from the OpenCV library (not enabled
       in
	   G'MIC by default).

	   Default values: 'first_frame=0', 'last_frame=-1',
	    'frame_step=1' and 'output_filename=(undefined)'.

	 average_files:
	     "filename_pattern",_first_frame>=0,_last_frame={ >=0 | -1=last },
	       _frame_step>=1,_output_filename

	   Average specified input image files,	in a streamed way.
	   If a	display	window is opened, rendered frames are displayed	in  it
       during
	   processing.
	   The output filename may have	extension '.avi' or '.mp4' (saved
	   as a	video),	or any other usual image
	   file	extension (saved as a sequence of images).

	   Default values: 'first_frame=0', 'last_frame=-1',
	    'frame_step=1' and 'output_filename=(undefined)'.

	 average_video:
	     video_filename,_first_frame>=0,_last_frame={ >=0 |	-1=last	},
	       _frame_step>=1,_output_filename

	   Average frames of specified input video file, in a streamed way.
	   If  a display window	is opened, rendered frames are displayed in it
       during
	   processing.
	   The output filename may have	extension '.avi' or '.mp4' (saved
	   as a	video),	or any other usual image
	   file	extension (saved as a sequence of images).
	   This	command	requires features from the OpenCV library (not enabled
       in
	   G'MIC by default).

	   Default values: 'first_frame=0', 'last_frame=-1',
	    'frame_step=1' and 'output_filename=(undefined)'.

	 fade_files:
	     "filename_pattern",_nb_in-
       ner_frames>0,_first_frame>=0,_last_frame={ >=0 |
	       -1=last },_frame_step>=1,_output_filename

	   Generate a temporal fading from specified input image files,	 in  a
       streamed
	   way.
	   If  a display window	is opened, rendered frames are displayed in it
       during
	   processing.
	   The output filename may have	extension 'avi'	or 'mp4' (saved
	   as a	video),	or any other usual image
	   file	extension (saved as a sequence of images).

	   Default values: 'nb_inner_frames=10', 'first_frame=0',
	    'last_frame=-1', 'frame_step=1' and
	    'output_filename=(undefined)'.

	 fade_video:
	     video_filename,_nb_inner_frames>0,_first_frame>=0,_last_frame={
       >=0 |
	       -1=last },_frame_step>=1,_output_filename

	   Create  a temporal fading sequence from specified input video file,
       in a
	   streamed way.
	   If a	display	window is opened, rendered frames are displayed	in  it
       during
	   processing.
	   This	command	requires features from the OpenCV library (not enabled
       in
	   G'MIC by default).

	   Default values: 'nb_inner_frames=10', 'first_frame=0',
	    'last_frame=-1', 'frame_step=1' and
	    'output_filename=(undefined)'.

	 files2video:
	     "filename_pattern",_output_filename,_fps>0,_codec

	   Convert several files into a	single video file.

	   Default values: 'output_filename=output.mp4', 'fps=25'
	    and	'codec=mp4v'.

	 median_files:
	     "filename_pattern",_first_frame>=0,_last_frame={ >=0 | -1=last },
	       _frame_step>=1,_frame_rows[%]>=1,_is_fast_approximation={ 0 | 1
       }

	   Compute  the	 median	 frame	of  specified  input image files, in a
       streamed	way.
	   If a	display	window is opened, rendered frame is  displayed	in  it
       during
	   processing.

	   Default values: 'first_frame=0', 'last_frame=-1',
	    'frame_step=1', 'frame_rows=20%' and
	    'is_fast_approximation=0'.

	 median_video:
	     video_filename,_first_frame>=0,_last_frame={ >=0 |	-1=last	},
	       _frame_step>=1,_frame_rows[%]>=1,_is_fast_approximation={ 0 | 1
       }

	   Compute the median of all frames of	an  input  video  file,	 in  a
       streamed	way.
	   If  a  display  window is opened, rendered frame is displayed in it
       during
	   processing.
	   This	command	requires features from the OpenCV library (not enabled
       in
	   G'MIC by default).

	   Default values: 'first_frame=0', 'last_frame=-1',
	    'frame_step=1', 'frame_rows=100%' and
	    'is_fast_approximation=1'.

	 morph:
	     nb_inner_frames>=1,_smoothness>=0,_precision>=0

	   Create morphing sequence between selected images.

	   Default values: 'smoothness=0.1' and	'precision=4'.

	   Example:
	     [#1] image.jpg +rotate 20,1,1,50%,50% morph 9

	 morph_files:
	     "filename_pattern",_nb_inner_frames>0,_smoothness>=0,_preci-
       sion>=0,
	       _first_frame>=0,_last_frame={ >=0 | -1=last },_frame_step>=1,
	       _output_filename

	   Generate a temporal morphing	from specified input image files, in a
	   streamed way.
	   If a	display	window is opened, rendered frames are displayed	in  it
       during
	   processing.
	   The output filename may have	extension '.avi' or '.mp4' (saved
	   as a	video),	or any other usual image
	   file	extension (saved as a sequence of images).

	   Default values: 'nb_inner_frames=10', 'smoothness=0.1',
	    'precision=4', 'first_frame=0', 'last_frame=-1',
	    'frame_step=1' and 'output_filename=(undefined)'.

	 morph_rbf:
	     nb_in-
       ner_frames>=1,xs0[%],ys0[%],xt0[%],yt0[%],...,xsN[%],ysN[%],xtN[%],
	       ytN[%]

	   Create morphing sequence between selected images, using RBF-based
	   interpolation.
	   Each	argument (xsk,ysk)-(xtk,ytk) corresponds to the	coordinates of
       a
	   keypoint
	   respectively	 on  the source	and target images. The set of all key-
       points
	   define the overall image deformation.

	 morph_video:
	     video_filename,_nb_inner_frames>0,_smoothness>=0,_precision>=0,
	       _first_frame>=0,_last_frame={ >=0 | -1=last },_frame_step>=1,
	       _output_filename

	   Generate a temporal morphing	from specified input video file, in a
	   streamed way.
	   If a	display	window is opened, rendered frames are displayed	in  it
       during
	   processing.
	   The output filename may have	extension '.avi' or '.mp4' (saved
	   as a	video),	or any other usual image
	   file	extension (saved as a sequence of images).
	   This	command	requires features from the OpenCV library (not enabled
       in
	   G'MIC by default).

	   Default values: 'nb_inner_frames=10', 'smoothness=0.1',
	    'precision=4', 'first_frame=0', 'last_frame=-1',
	    'frame_step=1' and 'output_filename=(undefined)'.

	 register_nonrigid:
	     [destination],_smoothness>=0,_precision>0,_nb_scale>=0

	   Register selected source images with	specified  destination	image,
       using
	   non-rigid warp.

	   Default values: 'smoothness=0.2', 'precision=6' and
	    'nb_scale=0(auto)'.

	   Example:
	     [#1] image.jpg +rotate 20,1,1,50%,50% +register_nonrigid[0] [1]

	 register_rigid:
	     [destination],_smoothness>=0,_boundary_conditions={ 0=dirichlet |
	       1=neumann | 2=periodic |	3=mirror }

	   Register  selected  source images with specified destination	image,
       using
	   rigid warp (shift).

	   Default values: 'smoothness=0.1%' and
	    'boundary_conditions=0'.

	   Example:
	     [#1] image.jpg +shift 30,20 +register_rigid[0] [1]

	 transition:
	     [transition_shape],nb_added_frames>=0,100>=shading>=0,_sin-
       gle_frame_only={
	       -1=disabled | >=0 }

	   Generate a transition sequence between selected images.

	   Default values: 'shading=0' and 'single_frame_only=-1'.

	   Example:
	     [#1]  image.jpg  +mirror  c  100%,100%  plasma[-1]	 1,1,6 transi-
       tion[0,1] [2],
	      5

	 transition3d:
	     _nb_frames>=2,_nb_xtiles>0,_nb_ytiles>0,_axis_x,_axis_y,_axis_z,
	       _is_antialias={ 0 | 1 }

	   Create 3D transition	sequence between selected consecutive images.
	   'axis_x', 'axis_y' and 'axis_z' can be set as
	   mathematical	expressions, depending on 'x' and 'y'.

	   Default values: 'nb_frames=10', 'nb_xtiles=nb_ytiles=3',
	    'axis_x=1',	'axis_y=1', 'axis_z=0' and
	    'is_antialias=1'.

	   Example:
	     [#1] image.jpg +blur 5 transition3d 9 display_rgba

	 video2files:
	     input_filename,_output_filename,_first_frame>=0,_last_frame={ >=0
       |
	       -1=last },_frame_step>=1

	   Split  specified  input  video  file	into image files, one for each
       frame.
	   First and last frames as well as step between frames	can be	speci-
       fied.

	   Default values: 'output_filename=frame.png',
	    'first_frame=0', 'last_frame=-1' and 'frame_step=1'.

	 12.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_colors:

	   Return  the	average	vector-value of	the latest of the selected im-
       ages.

	 base642img:
	     "base64_string"

	   Decode given	base64-encoded string as a newly inserted image	at the
       end of
	   the list.
	   The argument	string must have been generated	using command
	   'img2base64'.

	 base642uchar:
	     "base64_string"

	   Decode given	base64-encoded string as a newly inserted 1-column im-
       age at
	   the end of the list.
	   The argument	string must have been generated	using command
	   'uchar2base64'.

	 basename:
	     file_path,_variable_name_for_folder

	   Return the basename of a file path, and opt.	its folder location.
	   When	specified 'variable_name_for_folder' must starts by an
	   underscore
	   (global variable accessible from calling function).

	 bin:
	     binary_int1,...

	   Print specified binary integers into	their octal, decimal, hexadec-
       imal and
	   string representations.

	 bin2dec:
	     binary_int1,...

	   Convert  specified  binary  integers	into their decimal representa-
       tions.

	 covariance_colors:
	     _avg_outvarname

	   Return the covariance matrix	of the	vector-valued  colors  in  the
       latest of
	   the selected	images
	   (for	arbitrary number of channels).
	   Parameter  'avg_outvarname'	is  used as a variable name that takes
       the
	   value of the	average	vector-value.

	 dec:
	     decimal_int1,...

	   Print specified decimal integers into their binary, octal, hexadec-
       imal and
	   string representations.

	 dec2str:
	     decimal_int1,...

	   Convert specifial decimal integers into its string representation.

	 dec2bin:
	     decimal_int1,...

	   Convert  specified  decimal	integers into their binary representa-
       tions.

	 dec2hex:
	     decimal_int1,...

	   Convert specified decimal integers into their hexadecimal represen-
       tations.

	 dec2oct:
	     decimal_int1,...

	   Convert  specified  decimal	integers  into their octal representa-
       tions.

	 fact:
	     value

	   Return the factorial	of the specified value.

	 fibonacci:
	     N>=0

	   Return the Nth number of the	Fibonacci sequence.

	   Example:
	     [#1] echo ${"fibonacci 10"}

	     [gmic]-0./	Start G'MIC interpreter.
	     [gmic]-0./	55
	     [gmic]-0./	End G'MIC interpreter.

	 file_mv:
	     filename_src,filename_dest

	   Rename or move a file from a	location $1 to another location	$2.

	 file_rand:

	   Return a random filename for	storing	temporary data.

	 filename:
	     filename,_number1,_number2,...,_numberN

	   Return a filename numbered with specified indices.

	 files (+):
	     _mode,path

	   Return the list of files and/or subfolders from specified path.
	   'path' can be eventually a matching pattern.
	   'mode' can be { 0=files only	| 1=folders only | 2=files + folders
	   }.
	   Add '3' to 'mode' to	return full paths instead of filenames
	   only.

	   Default value: 'mode=5'.

	 fitratio_wh:
	     min_width,min_height,ratio_wh

	   Return a 2D size 'width,height' which is bigger than	'min_width,
	   min_height' and has the specified w/h ratio.

	 fitscreen:
	     width,height,_depth,_minimal_size[%],_maximal_size[%] |
	     [image],_minimal_size[%],_maximal_size[%]

	   Return the 'ideal' size WxH for a window intended to	display	an
	   image of specified size on screen.

	   Default values: 'depth=1', 'minimal_size=128' and
	    'maximal_size=85%'.

	 fontchart:

	   Insert G'MIC	font chart at the end of the image list.

	   Example:
	     [#1] fontchart

	 fps:

	   Return the number of	time this function is called per second, or -1
       if
	   this	info is	not yet	available.
	   Useful to display the framerate when	displaying animations.

	 gcd:
	     a,b

	   Return the GCD (greatest common divisor) between a and b.

	 hex:
	     hexadecimal_int1,...

	   Print specified hexadecimal integers	into their binary, octal, dec-
       imal and
	   string representations.

	 hex2dec:
	     hexadecimal_int1,...

	   Convert specified hexadecimal integers into their decimal represen-
       tations.

	 hex2img:
	     "hexadecimal_string"

	   Insert  new	image 1xN at the end of	the list with values specified
       by the
	   given hexadecimal-encoded string.

	 hex2str:
	     hexadecimal_string

	   Convert specified hexadecimal string	into a string.
	   See also: str2hex.

	 img2base64:
	     _encoding={ 0=base64 | 1=base64url	},_store_names={ 0 | 1 }

	   Encode selected images as a base64-encoded string.
	   The images can be then decoded using	command	'base642img'.

	   Default values: 'encoding=0'.

	 img2hex:

	   Return representation  of  last  image  as  an  hexadecimal-encoded
       string.
	   Input image must have values	that are integers in [0,255].

	 img2str:

	   Return  the	content	of the latest of the selected images as	a spe-
       cial G'MIC
	   input string.

	 img2text:
	     _line_separator

	   Return text contained in a multi-line image.

	   Default value: 'line_separator= '.

	 img82hex:

	   Convert selected 8bits-valued vectors into their hexadecimal
	   representations (ascii-encoded).

	 hex2img8:

	   Convert selected hexadecimal	representations	(ascii-encoded)	into
	   8bits-valued	vectors.

	 is_3d:

	   Return 1 if all of the selected images are 3D objects, 0 otherwise.

	 is_change:
	     _value={ 0=false |	1=true }

	   Set or unset	the 'is_change'	flag associated	to the image list.
	   This	flag tells the interpreter  whether  or	 not  the  image  list
       should be
	   displayed when the pipeline ends.

	   Default value: 'value=1'.

	 is_half:

	   Return 1 if the type	of image pixels	is limited to half-float.

	 is_ext:
	     filename,_extension

	   Return 1 if specified filename has a	given extensioin.

	 is_image_arg:
	     string

	   Return 1 if specified string	looks like '[ind]'.

	 is_pattern:
	     string

	   Return   1  if  specified  string  looks  like  a  drawing  pattern
       '0x......'.

	 is_percent:
	     string

	   Return 1 if specified string	ends with a '%', 0 otherwise.

	 is_variable_name:
	     "str"

	   Returns 1 if	specified argument can be  considered  as  a  variable
       name, 0
	   otherwise.

	 is_videofilename:

	   Return  1  if extension of specified	filename is typical from video
       files.

	 is_macos:

	   Return 1 if current computer	OS is Darwin (MacOS), 0	otherwise.

	 is_windows:

	   Return 1 if current computer	OS is Windows, 0 otherwise.

	 math_lib:

	   Return string that defines a	set of several useful macros  for  the
       embedded
	   math	evaluator.

	 mad:

	   Return  the	MAD  (Maximum Absolute Deviation) of the last selected
       image.
	   The MAD is defined as MAD = med_i|x_i-med_j(x_j)|

	 max_w:

	   Return the maximal width between selected images.

	 max_h:

	   Return the maximal height between selected images.

	 max_d:

	   Return the maximal depth between selected images.

	 max_s:

	   Return the maximal spectrum between selected	images.

	 max_wh:

	   Return the maximal wxh size of selected images.

	 max_whd:

	   Return the maximal wxhxd size of selected images.

	 max_whds:

	   Return the maximal wxhxdxs size of selected images.

	 median_color:

	   Return the median color value of the	last selected image.

	 min_w:

	   Return the minimal width between selected images.

	 min_h:

	   Return the minimal height between selected images.

	 min_d:

	   Return the minimal depth between selected images.

	 min_s:

	   Return the minimal s	size of	selected images.

	 min_wh:

	   Return the minimal wxh size of selected images.

	 min_whd:

	   Return the minimal wxhxd size of selected images.

	 min_whds:

	   Return the minimal wxhxdxs size of selected images.

	 nmd (+):
	     Shortcut for command 'named'.

	 named (+):
	     _mode,"name1","name2",...

	   Return the set of indices corresponding to images of	the  selection
       with
	   specified names.
	   After this command returns, the status contains a list of indices
	   (unsigned integers),
	   separated  by  commas  (or  an empty	string if no images with those
       names have
	   been	found).
	   (equivalent to shortcut command 'nmd').

	   'mode' can be { 0=all indices (default) | 1=lowest index |
	   2=highest index | 3 = all indices (case insensitive)	| 4  =	lowest
       index
	   (case insensitive) |	5 = highest index (case	insensitive)}

	 normalize_filename:
	     filename

	   Return  a  "normalized"  version of the specified filename, without
       spaces
	   and capital letters.

	 oct:
	     octal_int1,...

	   Print specified octal integers into their binary, decimal, hexadec-
       imal and
	   string representations.

	 oct2dec:
	     octal_int1,...

	   Convert  specified  octal  integers	into their decimal representa-
       tions.

	 padint:
	     number,_size>0

	   Return a integer with 'size'	digits (eventually left-padded with
	   '0').

	 path_cache:

	   Return a path to store G'MIC	data files for one user	 (whose	 value
       is
	   OS-dependent).

	 path_current:

	   Return current folder from where G'MIC has been run.

	 path_gimp:

	   Return a path to store GIMP configuration files for one user	(whose
       value
	   is OS-dependent).

	 path_tmp:

	   Return a path to store temporary files (whose  value	 is  OS-depen-
       dent).

	 remove_copymark:
	     "image_name"

	   Remove copy mark from names of selected images.

	 reset:

	   Reset global	parameters of the interpreter environment.

	 rgb:

	   Return a random int-valued RGB color.

	 rgba:

	   Return a random int-valued RGBA color.

	 shell_cols:

	   Return the estimated	number of columns of the current shell.

	 size_value:

	   Return the size (in bytes) of an image value.

	 std_noise:

	   Return  the estimated noise standard	deviation of the last selected
       image.

	 str:
	     string

	   Print specified string into its binary, octal, decimal and hexadec-
       imal
	   representations.

	 str2hex:
	     "string"

	   Convert  specified  string  argument	into a sequence	of hexadecimal
       values
	   (returned as	a string).
	   See also: hex2str.

	   Example:
	     [#1] hex=${"str2hex

	     [gmic]-0./	Start G'MIC interpreter.
	     [gmic]-0./	48656c6c6f206d7920667269656e6473
	     [gmic]-0./	End G'MIC interpreter.

	 strcapitalize:
	     string

	   Capitalize specified	string.

	 strcontains:
	     string1,string2

	   Return 1 if the first string	contains the second one.

	 strlen:
	     string1

	   Return the length of	specified string argument.

	 strreplace:
	     string,search,replace

	   Search and replace substrings in an input string.

	 strlowercase:
	     string

	   Return a lower-case version of the specified	string.

	 struppercase:
	     string

	   Return an upper-case	version	of the specified string.

	 strvar:
	     "string"

	   Return a simplified version of the specified	string,	 that  can  be
       used as a
	   variable name.
	   (version  that  creates  a  lowercase  result,  no  longer than 128
       chars).

	 strcasevar:
	     "string"

	   Return a simplified version of the specified	string,	 that  can  be
       used as a
	   variable name.
	   (version  that  keeps  original case	of specified string, no	longer
       than 128
	   chars).

	 strver:
	     _version

	   Return the specified	version	number of the G'MIC interpreter, as  a
       string.

	   Default value: 'version=$_version'.

	 tic:

	   Initialize tic-toc timer.
	   Use it in conjunction with 'toc'.

	 toc:

	   Display elapsed time	of the tic-toc timer since the last call to
	   'tic'.
	   This	command	returns	the elapsed time in the	status value.
	   Use it in conjunction with 'tic'.

	 to_clutname:
	     "string"

	   Return simplified name that can be used as a	CLUT name, from	speci-
       fied
	   input string.

	 uchar2base64:
	     _encoding={ 0=base64 | 1=base64url	}

	   Encode the values of	 the  latest  of  the  selected	 images	 as  a
       base64-encoded
	   string.
	   The string can be decoded using command 'base642uchar'.
	   Selected images must	have values that are integers in [0,255].

	   Default values: 'encoding=0'.

	 12.22.	Other Interactive Commands
		--------------------------

	 demos:
	     _run_in_parallel={	0=no | 1=yes | 2=auto }

	   Show	a menu to select and view all G'MIC interactive	demos.

	 tixy:
	     "expression"

	   Animate specified mathematical expression with a 16x16 grid of cir-
       cles,
	   using the rules described at	https://tixy.land.

	 x_2048:

	   Launch the 2048 game.

	 x_blobs:

	   Launch the blobs editor.
	   ../img/x_blobs.jpg [image: 'x_blobs']

	 x_bouncing:

	   Launch the bouncing balls demo.

	 x_color_curves:
	     _colorspace={ rgb | cmy | cmyk | hsi | hsl	| hsv |	lab  |	lch  |
       ycbcr |
	       last }

	   Apply  color	curves on selected RGB[A] images, using	an interactive
       window.
	   Set 'colorspace' to 'last' to apply last defined color curves
	   without opening interactive windows.

	   Default value: 'colorspace=rgb'.

	 x_colorize:
	     _is_lineart={ 0 | 1 },_max_resolution={ 0 | >=128 },
	       _multichannels_output={ 0 | 1 },_[palette1],_[palette2],_[grab-
       ber1]

	   Colorized selected B&W images, using	an interactive window.
	   When	>0, argument 'max_resolution' defines the maximal image
	   resolution used in the interactive window.

	   Default values: 'is_lineart=1', 'max_resolution=1024'
	    and	'multichannels_output=0'.

	 x_connect4:

	   Launch the Connect Four game.

	 xz:
	     Shortcut for command 'x_crop'.

	 x_crop:

	   Crop	selected images	interactively.
	   (equivalent to shortcut command 'xz').

	 x_cut:

	   Cut selected	images interactively.

	 x_fire:

	   Launch the fire effect demo.

	 x_fireworks:

	   Launch the fireworks	demo.

	 x_fisheye:

	   Launch the fish-eye effect demo.

	 x_fourier:

	   Launch the fourier filtering	demo.

	 x_grab_color:
	     _variable_name

	   Open	a color	grabber	widget from the	first selected image.
	   Argument 'variable_name' specifies the variable that	contains the
	   selected color values at any	time.
	   Assigning '-1' to it	forces the interactive window to close.

	   Default values: 'variable_name=xgc_variable'.

	 x_hanoi:

	   Launch the Tower of Hanoi game.

	 x_histogram:

	   Launch the histogram	demo.

	 x_hough:

	   Launch the hough transform demo.

	 x_jawbreaker:
	     0<_width<20,0<_height<20,0<_balls<=8

	   Launch the Jawbreaker game.

	 x_landscape:

	   Launch the virtual landscape	demo.

	 x_life:

	   Launch the game of life.

	 x_light:

	   Launch the light effect demo.

	 x_mandelbrot:
	     _julia={ 0	| 1 },_c0r,_c0i

	   Launch Mandelbrot/Julia explorer.

	 x_mask_color:
	     _colorspace={  all	| rgb |	lrgb | ycbcr | lab | lch | hsv | hsi |
       hsl | cmy
	       | cmyk |	yiq },_spatial_tolerance>=0,_color_tolerance>=0

	   Interactively select	a color, and add an alpha  channel  containing
       the
	   corresponding color mask.
	   Argument 'colorspace' refers	to the color metric used to compute
	   color similarities, and can be basically
	   one	of  { rgb | lrgb | ycbcr | lab | lch | hsv | hsi | hsl | cmy |
       cmyk
	   | yiq }.
	   You can also	select one one particular channel of this  colorspace,
       by
	   setting 'colorspace'	as
	   'colorspace_channel'	(e.g. 'hsv_h' for the hue).

	   Default values: 'colorspace=all', 'spatial_tolerance=5'
	    and	'color_tolerance=5'.

	 x_metaballs3d:

	   Launch the 3D metaballs demo.

	 x_minesweeper:
	     8<=_width=<20,8<=_height<=20

	   Launch the Minesweeper game.

	 x_minimal_path:

	   Launch the minimal path demo.

	 x_morph:
	     _nb_frames>=2,_preview_fidelity={	0=coarsest | 1=coarse |	2=nor-
       mal |
	       3=fine |	4=finest }

	   Launch the interactive image	morpher.

	   Default values: 'nb_frames=16' and 'preview_fidelity=3'.

	 x_pacman:

	   Launch pacman game.

	 x_paint:

	   Launch the interactive painter.

	 x_plasma:

	   Launch the plasma effect demo.

	 x_quantize_rgb:
	     _nbcolors>=2

	   Launch the RGB color	quantization demo.

	 x_reflection3d:

	   Launch the 3D reflection demo.

	 x_rubber3d:

	   Launch the 3D rubber	object demo.

	 x_segment:
	     _max_resolution={ 0 | >=128 }

	   Segment foreground from background in selected opaque RGB images,
	   interactively.
	   Return RGBA images with binary alpha-channels.

	   Default value: 'max_resolution=1024'.

	 x_select_color:
	     _variable_name

	   Display a RGB or RGBA color selector.
	   Argument 'variable_name' specifies the variable that	contains the
	   selected color values (as R,G,B,[A])
	   at any time.
	   Its value specifies the initial selected color. Assigning  '-1'  to
       it
	   forces the interactive window to close.

	   Default value: 'variable_name=xsc_variable'.

	 x_select_function1d:
	     _variable_name,_background_curve_R,_background_curve_G,_back-
       ground_curve_B

	   Open	an interactive window, where the user can defined its  own  1D
       function.
	   If  an image	is selected, it	is used	to display additional informa-
       tion :
	      -	 The first row defines the values of a background  curve  dis-
       played on
	   the window (e.g. an histogram).
	      -	 The 2nd, 3rd and 4th rows define the R,G,B color components
	   displayed beside the	X and Y	axes.
	   Argument 'variable_name' specifies the variable that	contains the
	   selected function keypoints at any time.
	   Assigning '-1' to it	forces the interactive window to close.

	   Default values: 'variable_name=xsf_variable',
	    'background_curve_R=220', 'background_curve_G=background_curve
	    _B=background_curve_T'.

	 x_select_palette:
	     _variable_name,_number_of_columns={ 0=auto	| >0 }

	   Open	a RGB or RGBA color selector widget from a palette.
	   The palette is given	as a selected image.
	   Argument 'variable_name' specifies the variable that	contains the
	   selected color values (as R,G,B,[A])
	   at any time.
	   Assigning '-1' to it	forces the interactive window to close.

	   Default values: 'variable_name=xsp_variable'	and
	    'number_of_columns=2'.

	 x_shadebobs:

	   Launch the shade bobs demo.

	 x_spline:

	   Launch spline curve editor.

	 x_starfield3d:

	   Launch the 3D starfield demo.

	 x_tetris:

	   Launch tetris game.

	 x_threshold:

	   Threshold selected images interactively.

	 x_tictactoe:

	   Launch tic-tac-toe game.

	 x_warp:
	     _nb_keypoints_xgrid>=2,_nb_keypoints_ygrid>=2,_nb_keypoints_con-
       tours>=0,
	       _preview_fidelity={ 0=coarsest |	1=coarse | 2=normal | 3=fine |
	       4=finest	},_[background_image],0<=_background_opacity<=1

	   Launch the interactive image	warper.

	   Default values: 'nb_keypoints_xgrid=nb_keypoints_ygrid=2',
	    'nb_keypoints_contours=0' and 'preview_fidelity=1'.

	 x_waves:

	   Launch the image waves demo.

	 x_whirl:
	     _opacity>=0

	   Launch the fractal whirls demo.

	   Default values: 'opacity=0.2'.

	 13. Examples of Use
	     ---------------

	 'gmic'	is a generic image processing tool which can be	used in	a wide
	  variety of situations. The few examples  below  illustrate  possible
       uses of
	  this tool:

	 ### View a list of images:

	   $ gmic file1.bmp file2.jpeg

	 ### Convert an	image file:

	   $ gmic input.bmp output output.jpg

	 ### Create a volumetric image from a movie sequence:

	   $ gmic input.mpg append z output output.hdr

	 ### Compute image gradient norm:

	   $ gmic input.bmp gradient_norm

	 ### Denoise a color image:

	   $ gmic image.jpg denoise 30,10 output denoised.jpg

	 ### Compose two images	using overlay layer blending:

	   $ gmic image1.jpg image2.jpg	blend overlay output blended.jpg

	 ### Evaluate a	mathematical expression:

	   $ gmic echo "cos(pi/4)^2+sin(pi/4)^2={cos(pi/4)^2+sin(pi/4)^2}"

	 ### Plot a 2D function:

	   $		    gmic		1000,1,1,2		  fill
       "X=3*(x-500)/500;X^2*sin(3*X^2)+if(c==0,u(0,-1),
	  cos(X*10))" plot

			     ../img/example_plot.png [image: '']

	 ### Plot a 3D elevated	function in random colors:

	   $ gmic 128,128,1,3,"u(0,255)" plasma	10,3 blur 4  sharpen  10000  n
       0,255
	  elevation3d[-1]
       "'X=(x-64)/6;Y=(y-64)/6;100*exp(-(X^2+Y^2)/30)*abs(cos(X)*s
	  in(Y))'"

			     ../img/example_elevation3d.png [image: '']

	 ### Plot the isosurface of a 3D volume:

	   $ gmic mode3d 5 moded3d 5 double3d 0	isosurface3d
	  "'x^2+y^2+abs(z)^abs(4*cos(x*y*z*3))'",3

			     ../img/example_isosurface3d.png [image: '']

	 ### Render a G'MIC 3D logo:

	   $ gmic 0 text G'MIC,0,0,53,1,1,1,1 expand_xy	10,0 blur 1  normalize
       0,
	  100 +plasma 0.4 add blur 1 elevation3d -0.1 moded3d 4

			     ../img/example_logo.png [image: '']

	 ### Generate a	3D ring	of torii:

	   $	  gmic	    repeat     20     torus3d	  15,2	   color3d[-1]
       "{u(60,255)},{u(60,255)},{u(60,
	  255)}" *3d[-1] 0.5,1 if "{$>%2}" rotate3d[-1]	0,1,0,90 fi  add3d[-1]
       70
	  add3d	rotate3d 0,0,1,18 done moded3d 3 mode3d	5 double3d 0

			     ../img/example_torii.png [image: '']

	 ### Create a vase from	a 3D isosurface:

	   $ gmic moded3d 4 isosurface3d "'x^2+2*abs(y/2)*sin(2*y)^2+z^2-3',0"
	  sphere3d 1.5 sub3d[-1] 0,5 plane3d 15,15 rotate3d[-1]	1,0,0,90
	  center3d[-1]	add3d[-1]  0,3.2  color3d[-1]  180,150,255 color3d[-2]
       128,255,0
	  color3d[-3] 255,128,0	add3d

			     ../img/example_vase.png [image: '']

	 ### Launch a set of interactive demos:

	   $ gmic demos

	 ** G'MIC comes	 with  ABSOLUTELY  NO  WARRANTY;  for  details	visit:
       https://gmic.eu **

								      G'MIC(1)

NAME | HELP

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=gmic&sektion=1&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help