FreeBSD Manual Pages

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

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

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

	       Copyright (c) Since 2008, David Tschumperl / 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 3.1.6.

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

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

	  *  At	 any  time, G'MIC manages one list of numbered (and optionally
       named)
	  pixel-based images,  entirely	 stored	 in  computer  memory  (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'.

	  * 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
       buffers.	For
	  instance,   saving   an   image  that	 was  initially	 loaded	 as  a
       16bits/channel image,
	  as a '.jpg' file will	result in a loss of information. Use the
	  G'MIC-specific file extension	'.gmz' to ensure that all data	preci-
       sion is
	  preserved when saving	images.
	  * Sometimes, file options may/must be	set for	file formats:
	    -	Video  files:  Only  sub-frames	 of  an	 image sequence	may be
       loaded,
	  using	the input expression 'filename.ext,[first_frame[,last_frame[,
	  step]]]'. Set	'last_frame==-1' to tell it must be the	last frame of
	  the video. Set 'step'	to '0' to force	an opened video	file to	be
	  opened/closed. Output	framerate and codec can	be also	set  by	 using
       the output
	  expression 'filename.avi,_fps,_codec,_keep_open' where 'keep_open'
	  can be { 0 | 1 }. 'codec' is a 4-char	string (see
	  http://www.fourcc.org/codecs.php ) or	'0' for	the default codec.
	  'keep_open' tells if the output video	file must be kept open for
	  appending new	frames afterwards.
	    -  '.cimg[z]' files: Only crops and	sub-images of .cimg files
	  can be loaded, using the input expressions 'filename.cimg,N0,N1',
	  'filename.cimg,N0,N1,x0,x1', 'filename.cimg,N0,N1,x0,y0,x1,y1',
	  'filename.cimg,N0,N1,x0,y0,z0,x1,y1,z1'	    or		'file-
       name.cimg,N0,N1,x0,y0,
	  z0,c0,x1,y1,z1,c1'. Specifying '-1' for one coordinates  stands  for
       the
	  maximum     possible	   value.     Output	 expression	'file-
       name.cimg[z][,datatype]'
	  can be used to force the output pixel	type. 'datatype' can be	{ auto
       |
	  bool | uint8 | int8 |	uint16 | int16 | uint32	|  int32  |  uint64  |
       int64 |
	  float32 | float64 }.
	    -  '.raw' binary files: Image dimensions and input pixel type
	  may be specified when	loading	'.raw' files with input	expression
	  'filename.raw[,datatype][,width][,height[,depth[,dim[,offset]]]]]'.
       If no
	  dimensions are specified, the	resulting image	is a one-column	vector
       with
	  maximum  possible  height. Pixel type	can also be specified with the
       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
	  an image list).
	    -  '$_pid':	The current process identifier,	as an integer.
	    -  '$_pixeltype': The type of image	pixels (default: 'float32').
	    -  '$_prerelease': For pre-releases, the date of  the  pre-release
       as
	  'yymmdd'. For	stable releases, this variable is set to '0'.
	    -	'$_version':  A	3-digits number	telling	about the current ver-
       sion of
	  the G'MIC interpreter	 (e.g. '316').
	    -  '$_vt100': Set to '1' if	colored	text output is allowed on
	  the console. Otherwise, set to '0'.

	  * '$$name' and '$${name}' are	both substituted by the	G'MIC script
	  code of the specified	named 'custom command',	or by an empty	string
       if no
	  custom command with specified	name exists.
	  * '${"-pipeline"}' is	substituted by the status value	after the
	  execution of the specified G'MIC pipeline (see command status).
	  Expression '${}' thus	stands for the current status value.
	  * '{``string}' (starting with	two backquotes)	is substituted by a
	  double-quoted	version	of the specified string.
	  * '{/string}'	is substituted by the escaped version of the specified
	  string.
	  * '{'string'[:delimiter]}' (between single quotes) is	substituted by
       the
	  sequence of character	codes that composes the	specified string, 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:
	    -  'u': screen width (actually independent on the window size).
	    -  'v': screen height (actually independent	on the window size).
	    -  'uv': screen width x screen height.
	    -  'd': window width (i.e. width of	the window widget).
	    -  'e': window height (i.e.	height of the window widget).
	    -  'de': window width x window height.
	    -  'w': display width (i.e.	width of the display area  managed  by
       the
	  window).
	    -  'h': display height (i.e. height	of the display area managed by
       the
	  window).
	    -  'wh': display width x display height.
	    -  'i': X-coordinate of the	display	window.
	    -  'j': Y-coordinate of the	display	window.
	    -  'n': current normalization type of the instant display.
	    -  't': window title of the	instant	display.
	    -  'x': X-coordinate of the	mouse position (or -1, if outside the
	  display area).
	    -  'y': Y-coordinate of the	mouse position (or -1, if outside the
	  display area).
	    -  'b': state of the mouse buttons { 1=left-but. | 2=right-but. |
	  4=middle-but.	}.
	    -  'o': state of the mouse wheel.
	    -  'k': decimal code of the	pressed	key if any, 0 otherwise.
	    -  'c': boolean (0 or 1) telling if	the instant display has	been
	  closed recently.
	    -  'r': boolean telling if the instant display has been resized
	  recently.
	    -	'm': boolean telling if	the instant display has	been moved re-
       cently.
	    -  Any other 'feature' stands for a	keycode	name (in capital  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()'.

	  * 'cov(A,B,_avgA,_avgB)' estimates the covariance between vectors
	  'A' and 'B' (estimated averages of these vectors may be specified
	  as arguments).
	  * 'mse(A,B)' returns the mean-squared	error between vectors 'A'
	  and 'B'.
	  * 'atan2(y,x)' is the	version	of 'atan()' with two arguments
	  'y' and 'x' (as in C/C++).
	  * 'permut(k,n,with_order)' computes the number of permutations of
	  'k' objects from a set of 'n'	objects.
	  * 'gauss(x,_sigma,_is_normalized)' returns
	  'exp(-x^2/(2*s^2))/(is_normalized?sqrt(2*pi*sigma^2):1)'.
	  * 'cut(value,min,max)' returns 'value' if it is in range '[min,
	  max]', or 'min' or 'max' otherwise.
	  *  'narg(a_1,...,a_N)'  returns  the	number	of specified arguments
       (here,
	  'N').
	  * 'arg(i,a_1,..,a_N)'	returns	the 'i'-th argument 'a_i'.
	  * 'isnum()', 'isnan()', 'isinf()', 'isint()',
	  'isbool()' test the type of the given	number or expression, and  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.
	  * 'isvarname('str')' returns '0' (false) or '1' (true)
	  whether  its	string argument	would be a valid to name a variable or
       not.
	  * 'isin(v,a_1,...,a_n)' returns '0' (false) or '1' (true)
	  whether the first argument 'v' appears in the	set of other argument
	  'a_i'.
	  * 'inrange(value,m,M,include_m,include_M)' returns '0' (false) or
	  '1' (true) whether the specified value lies in range '[m,M]' or not
	  ('include_m' and 'includeM' tells how	boundaries 'm' and
	  'M' are considered).
	  * 'argkth()',	'argmin()', 'argmax()',	'argminabs()',
	  'argmaxabs()'', 'avg()', 'kth()', 'min()',
	  'max()', 'minabs()', 'maxabs()', 'med()',
	  'prod()', 'std()', 'sum()' and 'var()' can be	called
	  with an arbitrary number of scalar/vector arguments.
	  * 'vargkth()', 'vargmin()', 'vargmax()',
	  'vargminabs()', 'vargmaxabs()', 'vavg()', 'vkth()',
	  'vmin()', 'vmax()', 'vminabs()', 'vmaxabs()',
	  'vmed()', 'vprod()', 'vstd()', 'vsum()' and
	  'vvar()' are the versions of the previous function with  vector-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', 'id', 'is',
	  'ip',	'ic', 'in': Respectively the minimum, maximum, average,
	  variance, standard deviation,	sum, product, median value and L2-norm
       of the
	  associated image, if any ('0'	otherwise).
	  * 'xm', 'ym',	'zm', 'cm': The	pixel coordinates of the
	  minimum value	in the associated image, if any	('0' otherwise).
	  * 'xM', 'yM',	'zM', 'cM': The	pixel coordinates of the
	  maximum value	in the associated image, if any	('0' otherwise).
	  * All	these variables	are considered as constant values by the math
	  parser (for optimization purposes) which is indeed the case most  of
       the time.
	  Anyway, this might not be the	case, if function 'resize(#ind,..)' is
       used
	  in  the  math	 expression.  If  so,  it is safer to invoke functions
       'l()',
	  'w(_#ind)', 'h(_#ind)', ... 's(_#ind)' and 'in(_#ind)'
	  instead of the corresponding named variables.
	  * 'i': current processed pixel value (i.e. value located at '(x,y,z,
	  c)') in the associated image,	if any ('0' otherwise).
	  * 'iN': N-th channel value of	current	processed pixel	(i.e. value
	  located at '(x,y,z,N)' in the	associated image, if any ('0'
	  otherwise). 'N' must be an integer in	range '[0,9]'.
	  * 'R', 'G', 'B' and 'A' are equivalent to 'i0',
	  'i1',	'i2' and 'i3' respectively.
	  * 'I': current vector-valued processed pixel in the  associated  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 'resize(A,ow,oh,od,os,nw,_nh,_nd,_ns,_interpolation,
	  _boundary_conditions,_ax,_ay,_az,_ac)' is an extended	version	of the
	  previous function. It	allows to resize the vector 'A',  seen	as  an
       image
	  of  size  'ow	x oh x od x os'	as a new image of size 'nw x nh	x nd x
       ns', with
	  specified resizing options.
	  * Function 'find(A,B,_starting_index,_search_step)' returns the  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.

	 ## Dynamic arrays:

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

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

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

	 ## Special operators:

	  * ';': expression separator. The returned value is always the	last
	  encountered expression. For instance expression '1;2;pi'  is	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[_#ind,offset,_boundary_conditions]' and 'I/J(_#ind,_x,_y,_z,
	  _interpolation,_boundary_conditions)'	do the same as 'i/j[_#ind,off-
       set,
	  _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 block	(loop, init or main environment).
	  * 'fsize('filename')'	returns	the size of the	specified 'filename'
	  (or '-1' if file does	not exist).
	  * 'date(attr,'path')'	returns	the date attribute for the given
	  'path' (file or directory), with 'attr' being	{ 0=year | 1=month
	  | 2=day | 3=day of week | 4=hour | 5=minute |	6=second }, or a  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('variable_name',A)' set the G'MIC variable '$variable_name'
	  with the value of expression 'A'. If 'A' is a	vector-valued
	  variable, it is assumed to encode a string.
	  *  'store('variable_name',A,_w,_h,_d,_s,_is_compressed)'   transfers
       the
	  data of vector 'A' as	a 'w x h x d x s' image	to the G'MIC variable
	  '$variable_name'. Thus, the data becomes available outside the math
	  expression  (that  is	equivalent to using the	regular	command	store,
       but
	  directly in the math expression).
	  * 'get('variable_name',_size,_return_as_string)' returns  the	 value
       of
	  the specified	variable, as a vector of 'size'	values,	or as a	scalar
       (if
	  'size' is zero or not	specified).
	  * 'name(_#ind,size)' returns a vector	of size	'size',	whose values
	  are  the  characters	codes of the name of image '[ind]' (or default
       image
	  selected if 'ind' is not specified).
	  * 'correlate(I,wI,hI,dI,sI,K,wK,hK,dK,sK,_boundary_conditions,
	  _is_normalized,_channel_mode,_xcenter,_ycenter,_zcenter,_xstart,_ys-
       tart,_zstart,
	  _xend,_yend,_zend,_xstride,_ystride,_zstride,_xdilation,_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#'];

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

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

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

	 ## Multi-threaded and in-place	evaluation:

	  * If your image data are large enough	 and  you  have	 several  CPUs
       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 invocation	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,_cap-
       ture_width>=0,_capture_height>=0

	   Insert one or several frames	from specified camera.
	   When	'nb_frames==0',	the camera stream is released instead of  cap-
       turing new images.
	   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  |	adven-
       ture_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  |
       arabica_12 |
	    atomic_pink	| autumn | ava_614 | avalanche | azrael_93 | bboyz_2 |
       bc_darkum  |  beach_aqua_orange	|  beach_faded_analog  |  berlin_sky |
       black_and_white | black_star | black_white_01 | black_white_02 |
	    black_white_03 | black_white_04 | black_white_05 |	black_white_06
       |  blade_runner	|  bleach_bypass  |  bleachbypass_1 | bleachbypass_2 |
       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 | cinematic-4 | cinematic-5 | cinematic-6 | cinematic-7 |
	    cinematic-8	 |  cinematic-9	 | cinematic_01	| cinematic_02 | cine-
       matic_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 | clas-
       sic_films_05 | classic_teal_and_orange |	clayton_33 | clear_teal_fade |
       clouseau_54 | cobi_3 | coffee_44	| cold_clear_blue |
	    cold_clear_blue_1 |	cold_ice | cold_simplicity_2  |	 color_rich  |
       colorful_0209  |	 colornegative	|  conflict_01	|  contrail_35	| con-
       trast_with_highlights_protection	  |   contrasty_afternoon    |	  con-
       trasty_green |
	    crispromance  |  crispwarm	| crispwinter |	cross_process_cp_130 |
       cross_process_cp_14  |  cross_process_cp_15  |  cross_process_cp_16   |
       cross_process_cp_18 | cross_process_cp_3	| cross_process_cp_4 |
	    cross_process_cp_6	  |   crushin	|   cubicle_99	 |   d_o_1   |
       dark_blues_in_sunlight |	dark_green_02 |	dark_green_1  |	 dark_man_x  |
       dark_orange_teal	 |  dark_place_01  |  darkness | date_39 | day_4nite |
       day_for_night
	    | day_to_night_kings_blue |	deep | deep_blue  |  deep_dark_warm  |
       deep_high_contrast  | deep_teal_fade | deep_warm_fade | deepskintones_2
       | deepskintones_3 | delicatessen	| denoiser_simple_40 |
	    desert_gold_37  |  dimension  |  directions_23   |	 django_25   |
       domingo_145  |  dream_1	|  dream_85 | drop_green_tint_14 | dropblues |
       duotone_blue_red	| earth_tone_boost | edgyember	|  elegance_38	|  en-
       chanted |
	    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_in-
       frared_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 | fgcinevibrant | fgcinewarm | film_0987 | film_9879
	    | film_gb-19 | film_high_contrast |	film_print_01 |	 film_print_02
       | filmic	| flat_30 | flat_blue_moon | flavin | foggynight | folger_50 |
       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_su-
       peria_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_su-
       peria_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_per-
       fect_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_in-
       door |
	    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 | hiddenite	 |  highlights_protec-
       tion  | hilutite	| hitman | hlg_1_1 | honey_light | hong_kong | horror-
       blue | howlite |	hydracore | hyla_68 | hypersthene | hypnosis |
	    hypressen	|   ilford_delta_100   |   ilford_delta_3200   |   il-
       ford_delta_3200_+  |  ilford_delta_3200_++  | ilford_delta_3200_- | il-
       ford_delta_400 |	ilford_fp_4_plus_125 | ilford_hp_5 | ilford_hp_5_+ |
	    ilford_hp_5_++  |  ilford_hp_5_-  |	 ilford_hp_5_plus_400  |   il-
       ford_hps_800  |	ilford_pan_f_plus_50 | ilford_xp_2 | indoor_blue | in-
       dustrial_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_ek-
       tachrome_100_vs_generic | kodak_ektar_100 | kodak_elite_100_xpro	|
	    kodak_elite_chrome_200     |    kodak_elite_chrome_400    |	   ko-
       dak_elite_color_200  |	kodak_elite_color_400	|   kodak_elite_extra-
       color_100  |  kodak_hie_hs_infra	 |  kodak_kodachrome_200  |  kodak_ko-
       dachrome_25 |
	    kodak_kodachrome_64	 |  kodak_kodachrome_64_generic	 |  kodak_por-
       tra_160 | kodak_portra_160_+ | kodak_portra_160_++ | kodak_portra_160_-
       | kodak_portra_160_nc | kodak_portra_160_nc_+ |
	    kodak_portra_160_nc_++   |	 kodak_portra_160_nc_-	 |  kodak_por-
       tra_160_vc  |  kodak_portra_160_vc_+  |	kodak_portra_160_vc_++	|  ko-
       dak_portra_160_vc_- | kodak_portra_400 |	kodak_portra_400_+ |
	    kodak_portra_400_++	 |  kodak_portra_400_- | kodak_portra_400_nc |
       kodak_portra_400_nc_+ | kodak_portra_400_nc_++ |	 kodak_portra_400_nc_-
       | kodak_portra_400_uc | kodak_portra_400_uc_+ |
	    kodak_portra_400_uc_++   |	 kodak_portra_400_uc_-	 |  kodak_por-
       tra_400_vc  |  kodak_portra_400_vc_+  |	kodak_portra_400_vc_++	|  ko-
       dak_portra_400_vc_- | kodak_portra_800 |	kodak_portra_800_+ |
	    kodak_portra_800_++	 |  kodak_portra_800_- | kodak_portra_800_hc |
       kodak_t-max_100 | kodak_t-max_3200 | kodak_t-max_400 |  kodak_tmax_3200
       | kodak_tmax_3200_+ | kodak_tmax_3200_++	| kodak_tmax_3200_- |
	    kodak_tmax_3200_alt	 |  kodak_tri-x_400  | kodak_tri-x_400_+ | ko-
       dak_tri-x_400_++	| kodak_tri-x_400_- | kodak_tri-x_400_alt | korben_214
       | landscape_01 |	landscape_02 | landscape_03 | landscape_04 |
	    landscape_05 | landscape_1 | landscape_10 |	 landscape_2  |	 land-
       scape_3 | landscape_4 | landscape_5 | landscape_6 | landscape_7 | land-
       scape_8 | landscape_9 | lateafternoonwanderlust | latesunset | lc_1 |
	    lc_10  |  lc_2  | lc_3 | lc_4 | lc_5 | lc_6	| lc_7 | lc_8 |	lc_9 |
       lenox_340 | life_giving_tree | light_blown  |  lomo  |  lomography_red-
       scale_100 | lomography_x-pro_slide_200 |	london_nights |	louetta	|
	    low_contrast_blue  | low_key_01 | lucky_64 | lushgreensummer | ma-
       genta_day | magenta_day_01 | magenta_dream | magenta_yellow |  magenta-
       coffee |	matrix | mckinnon_75 | memories	| metropolis | milo_5 |
	    minimalistcaffeination  |  modern_film  |  modern_films_01	| mod-
       ern_films_02 | modern_films_03 |	modern_films_04	 |  modern_films_05  |
       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  |
       moonlight | moonlight_01	| moonrise | morning_6 | morroco_16 |
	    mostly_blue	 | moviz_1 | moviz_10 |	moviz_11 | moviz_12 | moviz_13
       | moviz_14 | moviz_15 | moviz_16	| moviz_17 |  moviz_18	|  moviz_19  |
       moviz_2 | moviz_20 | moviz_21 | moviz_22	| moviz_23 | moviz_24 |
	    moviz_25  |	 moviz_26 | moviz_27 | moviz_28	| moviz_29 | moviz_3 |
       moviz_30	| moviz_31 | moviz_32 |	 moviz_33  |  moviz_34	|  moviz_35  |
       moviz_36	| moviz_37 | moviz_38 |	moviz_39 | moviz_4 | moviz_40 |
	    moviz_41  |	moviz_42 | moviz_43 | moviz_44 | moviz_45 | moviz_46 |
       moviz_47	| moviz_48 | moviz_5 | moviz_6 | moviz_7 | moviz_8 | moviz_9 |
       mute_shift | muted_01 | muted_fade | mysticpurplesunset | nah |
	    natural_vivid  |  nemesis  |  neon_770  |  neutral_pump   |	  neu-
       tral_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_--   |   po-
       laroid_665_negative | polaroid_665_negative_+ | polaroid_665_negative_-
       |   polaroid_665_negative_hc   |	 polaroid_667  |  polaroid_669	|  po-
       laroid_669_+ |
	    polaroid_669_++  |	polaroid_669_+++  |   polaroid_669_-   |   po-
       laroid_669_--   |   polaroid_669_cold   |   polaroid_669_cold_+	|  po-
       laroid_669_cold_- | polaroid_669_cold_--	| polaroid_672 |  polaroid_690
       |
	    polaroid_690_+   |	 polaroid_690_++   |   polaroid_690_-	|  po-
       laroid_690_--  |	 polaroid_690_cold   |	 polaroid_690_cold_+   |   po-
       laroid_690_cold_++  |  polaroid_690_cold_- | polaroid_690_cold_-- | po-
       laroid_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_-	|  po-
       laroid_px-100uv+_cold_--	   |	 polaroid_px-100uv+_warm     |	   po-
       laroid_px-100uv+_warm_+	   |	polaroid_px-100uv+_warm_++    |	   po-
       laroid_px-100uv+_warm_+++ |
	    polaroid_px-100uv+_warm_-  |  polaroid_px-100uv+_warm_--   |   po-
       laroid_px-680   |   polaroid_px-680_+   |   polaroid_px-680_++	|  po-
       laroid_px-680_-	|  polaroid_px-680_--  |  polaroid_px-680_cold	|  po-
       laroid_px-680_cold_+
	    |  polaroid_px-680_cold_++	|  polaroid_px-680_cold_++_alt	|  po-
       laroid_px-680_cold_- | polaroid_px-680_cold_-- |	polaroid_px-680_warm |
       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_+++	 | po-
       laroid_px-70_- |	polaroid_px-70_-- | polaroid_px-70_cold	|
	    polaroid_px-70_cold_+    |	  polaroid_px-70_cold_++     |	   po-
       laroid_px-70_cold_-  |  polaroid_px-70_cold_--  | polaroid_px-70_warm |
       polaroid_px-70_warm_+ | polaroid_px-70_warm_++ |	 polaroid_px-70_warm_-
       |
	    polaroid_px-70_warm_--    |	  polaroid_time_zero_expired   |   po-
       laroid_time_zero_expired_+  |   polaroid_time_zero_expired_++   |   po-
       laroid_time_zero_expired_- | polaroid_time_zero_expired_-- |
	    polaroid_time_zero_expired_--- | polaroid_time_zero_expired_cold |
       polaroid_time_zero_expired_cold_-  | polaroid_time_zero_expired_cold_--
       | polaroid_time_zero_expired_cold_--- | portrait_1 | portrait_10
	    | portrait_2 | portrait_3 |	portrait_4 | portrait_5	| portrait_6 |
       portrait_7 | portrait_8	|  portrait_9  |  progressen  |	 protect_high-
       lights_01 | prussian_blue | pseudogrey |	purple | purple_2 |
	    red_afternoon_01  |	 red_day_01  |	red_dream_01 | redblueyellow |
       reds | reds_oranges_yellows | reeve_38 |	remy_24	| rest_33  |  retro  |
       retro_brown_01 |	retro_magenta_01 | retro_summer_3 | retro_yellow_01 |
	    rollei_ir_400   |	rollei_ortho_25	  |  rollei_retro_100_tonal  |
       rollei_retro_80s	|  rotate_muted	 |  rotate_vibrant  |  rotated	|  ro-
       tated_crush | saturated_blue | saving_private_damon | science_fiction |
       sea |
	    serenity  |	 seringe_4  |  serpent | seventies_magazine | sevsuz |
       shade_kings_ink | shadow_king_39	| shine	| skin_tones |	smart_contrast
       | smokey	| smooth_clear | smooth_cromeish | smooth_fade |
	    smooth_green_orange	  |   smooth_sailing  |	 smooth_teal_orange  |
       soft_fade | softwarming | solarized_color | solarized_color_2 | spring-
       morning | sprocket_231 |	spy_29 | street	| studio_skin_tone_shaper |
	    subtle_blue	| subtle_green | subtle_yellow | summer	| summer_alt |
       sunlightlove | sunny | sunny_alt	 |  sunny_rich	|  sunny_warm  |  sun-
       set_aqua_orange | sunset_intense_violet_blue | sunset_violet_mood |
	    super_warm	|  super_warm_rich  |  sutro_fx	 |  sweet_bubblegum  |
       sweet_gelatto | taiga | tarraco | teal_fade | teal_moonlight |  tealma-
       gentagold | tealorange |	tealorange_1 | tealorange_2 | tealorange_3 |
	    technicalfx_backlight_filter  |  teigen_28 | tensiongreen_1	| ten-
       siongreen_2 | tensiongreen_3 | tensiongreen_4 | terra_4 |  the_matrices
       | thriller_2 | toastedgarden | trent_18 | true_colors_8 |
	    turkiest_42	| tweed_71 | ultra_water | undeniable |	undeniable_2 |
       unknown	|  urban_01  | urban_02	| urban_03 | urban_04 |	urban_05 | ur-
       ban_cowboy | uzbek_bukhara | uzbek_marriage | uzbek_samarcande |
	    velvetia | very_warm_greenish | vfb_21 | vibrant | 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 | yellow_55b | yellow_film_01 | yellowstone |
	    you_can_do_it | zed_32 | zeke_39 | zilverfx_bw_solarization	| zil-
       verfx_infrared |	 zilverfx_vintage_bw  }	 :  Default  values:  'resolu-
       tion=33'	and 'cut_and_round=1'.

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

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

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

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

	   Imported  commands are available directly after the 'command' invo-
       cation.

	   Default value: 'add_debug_info=1'.

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

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

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

	   Default value: 'mode=1'.

	 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=cir-
       cles | 6,7=squares }.
	   'xmin','xmax','ymin','ymax'	set  the  coordinates of the displayed
       xy-axes.
	   if specified	'width'	or 'height' is '0', then image size is set  to
       half the	screen size.

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

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

	 dh:
	     Shortcut for command 'display_histogram'.

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

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

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

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

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

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

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

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

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

	 dp:
	     Shortcut for command 'display_parallel'.

	 display_parallel:

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

	 dp0:
	     Shortcut for command 'display_parallel0'.

	 display_parallel0:

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

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

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

	   Default   values:  'width=500',  'height=width',  'outline_type=1',
       'fill_R=fill_G=fill_B=200',  'theta_start=0',  'theta_end=360',	 'xla-
       bel="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	 +dis-
       play_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)]'	 +dis-
       play_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).

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

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

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

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

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

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

	 input (+):
	     [type:]filename |
	     [type:]http://URL |
	     [selection]x_nb_copies>0 |
	     {	width>0[%]  |  [image_w]  },{  _height>0[%]  |	[image_h]  },{
       _depth>0[%]  |  [image_d]   },{	 _spectrum>0[%]	  |   [image_s]	  },_{
       value1,_value2,... | '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,'(x>w/2?x:y)*c'

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

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

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

	   Default value: 'reverse_endianness=0'.

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

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

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

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

	   Default value: 'try_downloading_from_gmic_server=1'.

	 input_obj:
	     filename

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

	 it:
	     Shortcut for command 'input_text'.

	 input_text:
	     filename

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

	 lorem:
	     _width>0,_height>0

	   Input random	image of specified size, retrieved from	Internet.

	   Default values: 'width=height=800'.

	 network (+):
	     mode={ -1=disabled	| 0=enabled w/o	timeout	| >0=enabled w/	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 | uint8 | int8 | uint16 | int16 | uint32 |
       int32 | uint64 |	int64 |	float32	| float64 }.

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

	   Output selected 3D meshes as	Wavefront 3D object files.
	   Set	'save_materials'  to  '1'  to produce a	corresponding material
       file ('.mtl') and eventually texture files.
	   Beware, the export to '.obj'	files may be quite slow	for  large  3D
       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 re-
       peat...done loops.
	   (equivalent to shortcut command 'on').

	 op:
	     Shortcut for command 'outputp'.

	 outputp:
	     prefix

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

	   Default value: 'prefix=_'.

	 ow:
	     Shortcut for command 'outputw'.

	 outputw:

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

	 ox:
	     Shortcut for command 'outputx'.

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

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

	   Default value: 'output_at_same_location=0'.

	 parse_cli:
	     _output_mode,_{ * | command_name }

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

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

	 parse_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=Tutor-
       ial | 3=News } |
	     (no arg)

	   Convert selected gmd-formatted text images to html format.

	   Default values: 'include_default_header_footer=1'.

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

	   Convert selected gmd-formatted text images to ascii format.

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

	 parse_gui:
	     _outputmode,_{ * |	filter_name}

	   Parse selected filter definitions and generate info	about  filters
       in selected output mode.
	   'outputmode'	 can be	{ gmicol | json	| list | print | strings | up-
       date | zart }.
	   It is possible to define a custom output mode, by implementing  the
       following commands
	   ('outputmode'  must be replaced by the name of the custom user out-
       put mode):
	   . 'parse_gui_outputmode' : A	command	that outputs the  parsing  in-
       formation with a	custom format.
	   .  'parse_gui_parseparams_outputmode'  (optional): A	simple command
       that returns 0 or 1. It tells the parser	whether	parameters of matching
       filter must be analyzed (slower)	or not.
	   . 'parse_gui_trigger_outputmode'  (optional):  A  command  that  is
       called  by the parser just before parsing the set of each matching fil-
       ters.
	   Here	is the list of global variables	set by the parser,  accessible
       in command 'parse_gui_outputmode':
	   '$_nb_filters': Number of matching filters.
	   '$_nongui'  (stored as an image): All merged	lines in the file that
       do not correspond to '#@gui' lines.
	   For each filter '	 * '$_fF_name' : Filter	name.
	    * '$_fF_path' : Full path.
	    * '$_fF_locale' : Filter locale (empty, if not specified).
	    * '$_fF_command' : Filter command.
	    * '$_fF_command_preview' : Filter preview command (empty,  if  not
       specified).
	    *  '$_fF_zoom_factor'  : Default zoom factor (empty, if not	speci-
       fied).
	    * '$_fF_preview_accuracy' :	Preview	accuracy (can be { 0=does  not
       support zoom in/out | 1=support zoom in/out | 2=pixel-perfect }).
	    *  '$_fF_input_mode' : Default preferred input mode	(empty,	if not
       specified).
	    * '$_fF_hide' : Path of filter hid by current filter  (for	local-
       ized filters, empty if not specified).
	    * '$_fF_nb_params' : Number	of parameters.
	   For each parameter '	    * '$_fF_pP_name' : Parameter name.
	    * '$_fF_pP_type' : Parameter type.
	    *  '$_fF_pP_responsivity' :	Parameter responsivity (can be { 0 | 1
       }).
	    * '$_fF_pP_visibility' : Parameter visibility.
	    * '$_fF_pP_propagation' : Propagation of the parameter visibility.
	    * '$_fF_pP_nb_args'	: Number of parameter arguments.
	   For each argument '	   * '$_fF_pP_aA' : Argument value
	   Default parameters: 'filter_name=*' and 'output_format=print'.

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

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

	   Default value: 'shared_state=2'.

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

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

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

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

	 portrait:
	     _size>0

	   Input  random  portrait image of specified size, retrieved from In-
       ternet.

	   Default values: 'size=800'.

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

	 print (+):

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

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

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

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

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

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

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

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

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

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

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

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

	   Serialize  selected	list of	images into a single image, optionally
       in a compressed form.
	   'datatype' can be { auto | uint8 | int8 | uint16 | int16 | uint32 |
       int32 | uint64 |	int64 |	float32	| float64 }.
	   Specify 'datatype' if all selected images have a  range  of	values
       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 uint8 +unserialize[-1]

	 shape_circle:
	     _size>=0

	   Input a 2D circle binary shape with specified size.

	   Default value: 'size=512'.

	   Example:
	     [#1] shape_circle ,

	 shape_cupid:
	     _size>=0

	   Input a 2D cupid binary shape with specified	size.

	   Default value: 'size=512'.

	   Example:
	     [#1] shape_cupid ,

	 shape_diamond:
	     _size>=0

	   Input a 2D diamond binary shape with	specified size.

	   Default value: 'size=512'.

	   Example:
	     [#1] shape_diamond	,

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

	   Input a 2D Dragon curve with	specified size.

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

	   Example:
	     [#1] shape_dragon ,

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

	   Input a 2D Barnsley fern with specified size.

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

	   Example:
	     [#1] shape_fern ,

	 shape_gear:
	     _size>=0,_nb_teeth>0,0<=_height_teeth<=100,0<=_off-
       set_teeth<=100,0<=_inner_radius<=100

	   Input a 2D gear binary shape	with specified size.

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

	   Example:
	     [#1] shape_gear ,

	 shape_heart:
	     _size>=0

	   Input a 2D heart binary shape with specified	size.

	   Default value: 'size=512'.

	   Example:
	     [#1] shape_heart ,

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

	   Input a 2D polygonal	binary shape with specified geometry.

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

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

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

	   Input a 2D snowflake	binary shape with specified size.

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

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

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

	   Input a 2D star binary shape	with specified size.

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

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

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

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

	   Insert shared buffers from  (opt.  points/rows/planes/channels  of)
       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]	}

	   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 }

	 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 'ti-
       tle=(undefined)'.

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

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

	 keep (+):

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

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

	 kn:
	     Shortcut for command 'keep_named'.

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

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

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

	 move (+):
	     position[%]

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

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

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

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

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

	   Set names of	selected images.
	    * If selection is empty or not explicitely	specified,  it	repre-
       sents the last 'N' images of the	list, where'N' is the number of	speci-
       fied arguments to the command 'name'.
	    * If the selection contains	a single image,	then it	is assumed the
       command	has  a single name argument (possibly containing multiple com-
       mas).
	    * 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 '=>').

	   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% } add
       div 10

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

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

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

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

	 argmax:

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

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

	 argmaxabs:

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

	 argmin:

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

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

	 argminabs:

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

	 asin (+):

	   Compute the pointwise arcsine of selected images.

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

	   Tutorial:	  https://gmic.eu/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 se-
       quential	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 se-
       quential	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	equal-
       ity 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  be-
       tween 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 be-
       tween 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 in-
       equality	of selected images.
	   (equivalent to shortcut command '!=').

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

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

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

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

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

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

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

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

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

	 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  se-
       quential	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
       sequential 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
       bitwise XOR of selected images.

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

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

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

	   Apply curve transformation to image values.

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

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

	 apply_gamma:
	     gamma>=0

	   Apply gamma correction to selected images.

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

	 balance_gamma:
	     _ref_color1,...

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

	   Default value: 'ref_color1=128'.

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

	 cast:
	     datatype_source,datatype_target

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

	 complex2polar:

	   Compute complex to polar transforms of selected images.

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

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

	   Compress selected color LUTs	as sequences of	colored	keypoints.

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

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

	   Compress selected images as 2xN data	matrices, using	RLE algorithm.
	   Set 'maximum_sequence_length=0'  to	disable	 maximum  length  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_color-
       space=0'.

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

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

	   Default  value:  'width=height=depth=33' and	'reconstruction_color-
       space=0'.

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

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

	   Default  values: 'width=height=depth=33' and	'reconstruction_color-
       space=0'.

	 decompress_rle:

	   Decompress selected data vectors, using RLE algorithm.

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

	   Discard specified values in selected	images or discard  neighboring
       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 | uint8 | int8 | uint16 | int16 | uint32 |
       int32 | uint64 |	int64 |	float32	| float64 }.
	   This	command	does nothing for 'bool', 'uint8' and 'int8' datatypes.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	 ir:
	     Shortcut for command 'inrange'.

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

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

	   Default value: 'boundary_conditions=0'.

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

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

	 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 co-
       ordinates.
	   The Perlin noise is a specific type of smooth noise,
	   described here : https://en.wikipedia.org/wiki/Perlin_noise.

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

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

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

	   Example:
	     [#1] 300,300 noise_poissondisk 8

	 normp:
	     p>=0

	   Compute the pointwise Lp-norm norm of vector-valued pixels  in  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] re-
       verse[-2,-1]

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

	 oneminus:

	   For each selected image, compute one	minus image.

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

	 otsu:
	     _nb_levels>0

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

	   Default value: 'nb_levels=256'.

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

	 polar2complex:

	   Compute polar to complex transforms of selected images.

	 quantize:
	     nb_levels>=1,_keep_values={ 0 | 1	},_quantization_type={	-1=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} }	append
       c display_graph 400,300

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

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

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

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

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

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

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

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

	   Default value: 'is_soft=0'.

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

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

	 vector2tensor:

	   Convert selected vector fields to corresponding tensor fields.

	 12.6. Colors
	       ------

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

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

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

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

	 ac:
	     Shortcut for command 'apply_channels'.

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

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

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

	   Default value: 'value_action=0'.

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

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

	   Index selected vector-valued	images by adapted colormaps.

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

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

	 bayer2rgb:
	     _GM_smoothness,_RB_smoothness1,_RB_smoothness2

	   Transform selected RGB-Bayer	sampled	images to color	images.

	   Default  values:  'GM_smoothness=RB_smoothness=1'  and  'RB_smooth-
       ness2=0.5'.

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

	 deltaE:
	     [image],_metric={	0=deltaE_1976  | 1=deltaE_2000 },"_to_Lab_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.
	   Simulation method of	Vienot,	Brettel	& Mollon 1999, "Digital	 video
       colourmaps for checking the legibility of displays by dichromats".
	   The	 dichromacy  matrices  of  the	paper  were  adapted  to  sRGB
       (RGB->XYZ).
	   Anomalous trichromacy simulated via linear interpolation  with  the
       identity	and a factor of	0.6.

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

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

	   Estimate  best-fitting  colormap with 'nb_colors' entries, to index
       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.

	 ipremula:

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

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

	   Convert color representation	of selected images from	RGB to Jzazbz.

	   Default value: 'illuminant=2'.

	 jzazbz2xyz:

	   Convert color representation	of selected images from	RGB to XYZ.

	 lab2lch:

	   Convert color representation	of selected images from	Lab to Lch.

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

	   Convert color representation	of selected images from	Lab to RGB.

	   Default value: 'illuminant=2'.

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

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

	   Convert color representation	of selected images from	Lab to sRGB.

	   Default value: 'illuminant=2'.

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

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

	   Convert color representation	of selected images from	Lab8 to	sRGB.

	   Default value: 'illuminant=2'.

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

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

	   Convert color representation	of selected images from	Lab to XYZ.

	   Default value: 'illuminant=2'.

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

	   Convert color representation	of selected images from	Lab8 to	RGB.

	   Default value: 'illuminant=2'.

	 lch2lab:

	   Convert color representation	of selected images from	Lch to Lab.

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

	   Convert color representation	of selected images from	Lch to RGB.

	   Default value: 'illuminant=2'.

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

	   Convert color representation	of selected images from	Lch8 to	RGB.

	   Default value: 'illuminant=2'.

	 luminance:

	   Compute luminance of	selected sRGB images.

	   Example:
	     [#1] image.jpg +luminance

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

	 lightness:

	   Compute lightness of	selected sRGB images.

	   Example:
	     [#1] image.jpg +lightness

	 lut_contrast:
	     _nb_colors>1,_min_rgb_value

	   Generate a RGB colormap where consecutive  colors  have  high  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/ ).
	   See also: rgb2oklab.

	 palette:
	     palette_name | palette_number

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

	 premula:

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

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

	   Generate pseudogray colormap	with specified increment  and  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/ ).
	   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.
	   This	command	returns	1 or 2 images for each selected	image, whether
       it has an opacity channel or not.

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

	   Convert color representation	of selected images from	sRGB to	Lab.

	   Default value: 'illuminant=2'.

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

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

	   Convert color representation	of selected images from	sRGB to	Lab8.

	   Default value: 'illuminant=2'.

	 srgb2rgb:

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

	 to_a:

	   Force selected images to have an alpha channel.

	 to_color:

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

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

	   Force selected images to be in a given color	mode.

	   Default value: 'mode=0'.

	 to_gray:

	   Force selected images to be in GRAY mode.

	   Example:
	     [#1] image.jpg +to_gray

	 to_graya:

	   Force selected images to be in GRAYA	mode.

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

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

	   Default  values:  'max_step=5',  'is_perceptual_constraint=1'   and
       'bits_depth=8'.
	   The	original  pseudo-gray  technique  has  been introduced by Rich
       Franzen http://r0k.us/graphics/pseudoGrey.html.
	   Extension of	this technique to arbitrary increments for more	tones,
       has been	done by	David 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_chan-
       nels'.

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

	   Default value: 'color_channels=all'.

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

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

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

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

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

	 xyz2jzazbz:

	   Convert color representation	of selected images from	XYZ to RGB.

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

	   Convert color representation	of selected images from	XYZ to Lab.

	   Default value: 'illuminant=2'.

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

	   Convert color representation	of selected images from	XYZ to RGB.

	   Default value: 'illuminant=2'.

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

	   Convert color representation	of selected images from	XYZ8 to	RGB.

	   Default value: 'illuminant=2'.

	 ycbcr2rgb:

	   Convert color representation	of selected images from	YCbCr to RGB.

	 yiq2rgb:

	   Convert color representation	of selected images from	YIQ to RGB.

	 yiq82rgb:

	   Convert color representation	of selected images from	YIQ8 to	RGB.

	 yuv2rgb:

	   Convert color representation	of selected images from	YUV to RGB.

	 yuv82rgb:

	   Convert selected images from	YUV8 to	RGB color bases.

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

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

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

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

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

	   Default value: 'centering=0'.

	   Example:
	     [#1] image.jpg split y,10 reverse append y
	     [#2] image.jpg repeat 5 { +rows[0]	0,{10+18*$>}% }	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",num-
       ber_of_scales>0,_min_scale[%]>=0,_max_scale[%]>=0,_scale_gamma>0,_in-
       terpolation

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

	   Default  value:  'min_scale=25%',  'max_scale=100%' and 'interpola-
       tion=3'.

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

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

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

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

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

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

	   Default  values:  'threshold=0%', 'min_area=0.1%', 'is_high_connec-
       tivity=0' and 'output_type=1'.

	   Example:
	     [#1] 256,256 noise	0.1,2 eq 1 dilate_circ 20 label_fg 0,1 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  au-
       tocrop_seq 0

	 channels:
	     c0[%],_c1[%]

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

	   Default value: 'c1=c0'.

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

	 columns:
	     x0[%],_x1[%]

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

	   Default value: 'x1=x0'.

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

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

	 crop (+):
	     x0[%],x1[%],_boundary_conditions |
	     x0[%],y0[%],x1[%],y1[%],_boundary_conditions |
	     x0[%],y0[%],z0[%],x1[%],y1[%],z1[%],_boundary_conditions |
	     x0[%],y0[%],z0[%],c0[%],x1[%],y1[%],z1[%],c1[%],_boundary_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

	 edgels:
	     x0,y0 |
	     (no arg)

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

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

	   Elevate selected 2D images into 3D volumes.

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

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

	   Expand selected images along	the x-axis.

	   Default value: 'boundary_conditions=0'.

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

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

	   Expand selected images along	the xy-axes.

	   Default value: 'boundary_conditions=0'.

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

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

	   Expand selected images along	the xyz-axes.

	   Default value: 'boundary_conditions=0'.

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

	   Expand selected images along	the y-axis.

	   Default value: 'boundary_conditions=0'.

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

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

	   Expand selected images along	the z-axis.

	   Default value: 'boundary_conditions=0'.

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

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

	   Default values: 'output_type=0'.

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

	 extract_region:
	     [label_image],_extract_xyz_coordinates={	 0    |	   1	},_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_com-
       mand"

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

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

	   Example:
	     [#1] image.jpg sample  ?  +plasma[0]  shape_cupid	256  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_con-
       ditions,_ax,_ay,_az,_ac

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

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

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

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

	 ri:
	     Shortcut for command 'resize_as_image'.

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

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

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

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

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

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

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

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

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

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

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

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

	 rr2d:
	     Shortcut for command 'resize_ratio2d'.

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

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

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

	 r2din:
	     Shortcut for command 'resize2din'.

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

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

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

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

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

	 r3din:
	     Shortcut for command 'resize3din'.

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

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

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

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

	 r2dout:
	     Shortcut for command 'resize2dout'.

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

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

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

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

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

	 r3dout:
	     Shortcut for command 'resize3dout'.

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

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

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

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

	 r2dx:
	     Shortcut for command 'resize2dx'.

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

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

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

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

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

	 r2dy:
	     Shortcut for command 'resize2dy'.

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

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

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

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

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

	 r3dx:
	     Shortcut for command 'resize3dx'.

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

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

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

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

	 r3dy:
	     Shortcut for command 'resize3dy'.

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

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

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

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

	 r3dz:
	     Shortcut for command 'resize3dz'.

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

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

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

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

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

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

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

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

	 rotate_tileable:
	     angle,_max_size_factor>=0

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

	   Default values: 'max_size_factor=8'.

	 rows:
	     y0[%],_y1[%]

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

	   Default value: 'y1=y0'.

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

	 scale2x:

	   Resize selected images using	the Scale2x algorithm.

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

	 scale3x:

	   Resize selected images using	the Scale3x algorithm.

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

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

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

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

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

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

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

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

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

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

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

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

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

	 shrink_x:
	     size_x>=0

	   Shrink selected images along	the x-axis.

	   Example:
	     [#1] image.jpg shrink_x 30

	 shrink_xy:
	     size>=0

	   Shrink selected images along	the xy-axes.

	   Example:
	     [#1] image.jpg shrink_xy 30

	 shrink_xyz:
	     size>=0

	   Shrink selected images along	the xyz-axes.

	 shrink_y:
	     size_y>=0

	   Shrink selected images along	the y-axis.

	   Example:
	     [#1] image.jpg shrink_y 30

	 shrink_z:
	     size_z>=0

	   Shrink selected images along	the z-axis.

	 slices:
	     z0[%],_z1[%]

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

	   Default value: 'z1=z0'.

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

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

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

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

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

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

	   Split selected images along specified axes, or regarding to	a  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 done

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

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

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

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

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

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

	   Default value: 'axis=y'.

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

	 upscale_smart:
	     width[%],_height[%],_depth,_smooth-
       ness>=0,_anisotropy=[0,1],sharpening>=0

	   Upscale selected images with	an edge-preserving algorithm.

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

	   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=for-
       ward-absolute | 3=forward-relative }.
	   'interpolation' can be { 0=nearest-neighbor | 1=linear | 2=cubic }.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann | 2=periodic
       | 3=mirror }.

	   Default   values:   'mode=0',  'interpolation=1',  'boundary_condi-
       tions=0'	and 'nb_frames=1'.

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

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

	 warp_patch:
	     [warp-
       ing_field],patch_width>=1,_patch_height>=1,_patch_depth>=1,_std_fac-
       tor>0,_boundary_conditions.

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

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

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

	   Warp	selected images	using RBF-based	interpolation.
	   Each	argument (xsk,ysk)-(xtk,ytk) corresponds to the	coordinates of
       a keypoint
	   respectively	 on  the source	and target images. The set of all 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 }

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

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

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

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

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

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

	   Apply angular blur on selected images.

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

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

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

	 blur_bloom:
	     _amplitude>=0,_ratio>=0,_nb_iter>=0,_blend_operator={  +  | max |
       min },_kernel={ 0=deriche | 1=gaussian |	2=box |	 3=triangle  |	4=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_oper-
       ator=+',	'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_condi-
       tions=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_se-
       lective , } done

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

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

	   Blur	selected images	along the x-axis.

	   Default value: 'boundary_conditions=1'.

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

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

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

	   Blur	selected images	along the X and	Y axes.

	   Default value: 'boundary_conditions=1'.

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

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

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

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

	   Default value: 'boundary_conditions=1'.

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

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

	   Blur	selected images	along the y-axis.

	   Default value: 'boundary_conditions=1'.

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

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

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

	   Blur	selected images	along the z-axis.

	   Default value: 'boundary_conditions=1'.

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

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

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

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

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

	 bump2normal:

	   Convert selected bumpmaps to	normalmaps.

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

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

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

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

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

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

	   Apply circular dilation of selected images by specified size.

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

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

	 compose_freq:

	   Compose selected low	and high frequency parts into new images.

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

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

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

	   Default  values: 'boundary_conditions=1', 'is_normalized=0',	'chan-
       nel_mode=1', 'xcenter=ycenter=zcenter=(undefined)',  'xstart=ystart=zs-
       tart=0',
	    'xend=yend=zend=(max-coordinates)',	  'xstride=ystride=zstride=1',
       '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,_zs-
       tart,_xend,_yend,_zend,_xstride,_ystride,_zstride,_xdilation,_ydila-
       tion,_zdilation,
	       interpolation_type

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

	   Default values: 'boundary_conditions=1', 'is_normalized=0',	'chan-
       nel_mode=1', 'xcenter=ycenter=zcenter=-1', 'xstart=ystart=zstart=0',
	    'xend=yend=zend=(max-coordinates)',	  'xstride=ystride=zstride=1',
       '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=mo-
       tion-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_spin-
       ning=10'.

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

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

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

	   Default value: 'patch_size=64'.

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

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

	   Denoise selected images using the patch-pca algorithm.

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

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

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

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

	   Default value: 'boundary_conditions=1'.

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

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

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

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

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

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

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

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

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

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

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

	   Apply octagonal dilation of selected	images by specified size.

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

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

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

	   Dilate selected images in the (X,Y,Z,I) space.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann | 2=periodic
       | 3=mirror }.

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

	 divergence:

	   Compute divergence of selected vector fields.

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

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

	   Compute difference of gaussian on selected images.

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

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

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

	   Compute  the	diffusion tensors of selected images for edge-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 | 2=periodic
       | 3=mirror }.

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

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

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

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

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

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

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

	   Apply octagonal erosion of selected images by specified size.

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

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

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

	   Erode selected images in the	(X,Y,Z,I) space.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann | 2=periodic
       | 3=mirror }.

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

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

	   Compute the direct fourier transform	(real and imaginary parts)  of
       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 | c	}...{ x	| y | z	| c },_scheme,_boundary_condi-
       tions |
	     (no arg)

	   Compute the gradient	components (first derivatives) of selected im-
       ages, along specified axes.
	   (equivalent to shortcut command 'g').

	   'scheme' can	be { -1=backward | 0=centered |	1=forward | 2=sobel  |
       3=rotation-invariant (default) |	4=deriche | 5=vanvliet }.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann | 2=periodic
       | 3=mirror }.
	   (no arg) compute all	significant components.

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

	   Example:
	     [#1] image.jpg gradient

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

	 gradient_norm:

	   Compute gradient norm of selected images.

	   Example:
	     [#1] image.jpg gradient_norm equalize

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

	 gradient_orientation:
	     _dimension={ 1 | 2	| 3 }

	   Compute N-d gradient	orientation of selected	images.

	   Default value: 'dimension=3'.

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

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

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

	   Example:
	     [#1] image.jpg +guided 5,400

	 haar:
	     scale>0

	   Compute  the	 direct	 haar multiscale wavelet transform of selected
       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
       },_boundary_conditions |
	     (no arg) :

	   Compute the hessian components (second derivatives) of selected im-
       ages along specified axes.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann | 2=periodic
       | 3=mirror }.
	   (no arg) compute all	significant components.

	   Default value: 'boundary_conditions=1'.

	   Example:
	     [#1] image.jpg hessian

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

	   Compute  the	 inverse discrete cosine transform of selected images,
       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	possi-
       ble/approximated	solutions.

	   Default values: 'nb_iterations=0'  and  '[initial_estimated]=(unde-
       fined)'.

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

	 inn:

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

	   Example:
	     [#1] image.jpg inn

	 inpaint (+):
	     [mask] |
	     [mask],0,_fast_method |
	     [mask],_patch_size>=1,_lookup_size>=1,_lookup_fac-
       tor>=0,_lookup_increment!=0,_blend_size>=0,0<=_blend_thresh-
       old<=1,_blend_decay>=0,_blend_scales>=1,_is_blend_outer={ 0 | 1 }

	   Inpaint selected images by specified	mask.
	   If  no  patch  size (or 0) is specified, inpainting is done using a
       fast average or median algorithm.
	   Otherwise, it used a	patch-based reconstruction method, that	can be
       very time consuming.
	   'fast_method' can be	{ 0=low-connectivity average |	1=high-connec-
       tivity average |	2=low-connectivity median | 3=high-connectivity	median
       }.

	   Default  values: 'patch_size=0', 'fast_method=1', 'lookup_size=22',
       'lookup_factor=0.5',	  'lookup_increment=1',	       'blend_size=0',
       'blend_threshold=0',
	    'blend_decay=0.05',	'blend_scales=10' and 'is_blend_outer=1'.

	   Example:
	     [#1]  image.jpg  100%,100%	 ellipse 50%,50%,30,30,0,1,255 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	trans-
       port-diffusion algorithm.
	   If 'diffusion type==3', non-zero values of the mask	(e.g.  a  dis-
       tance function) are used
	   to guide the	diffusion process.

	   Default  values:  'nb_scales=75%',  'diffusion_type=1'  and 'diffu-
       sion_iter=20'.

	   Example:
	     [#1] image.jpg 100%,100% ellipse[-1]  30%,30%,40,30,0,1,255  +in-
       paint_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  in-
       paint_flow[0] [1]

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

	   Inpaint  all	 connected  regions having an area less	than specified
       value.

	   Default values: 'maximal_area=4', 'tolerance=0'  and	 'is_high_con-
       nectivity=0'.

	   Example:
	     [#1] image.jpg noise 5%,2 +inpaint_holes 8,40

	 inpaint_morpho:
	     [mask]

	   Inpaint selected images by specified	mask using morphological oper-
       ators.

	   Example:
	     [#1]  image.jpg  100%,100%	ellipse[-1] 30%,30%,40,30,0,1,255 +in-
       paint_morpho[0] [1]

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

	   Inpaint selected images by specified	binary mask,  using  a	multi-
       scale matchpatch	algorithm.

	   Default    values:	 'nb_scales=0',	  'patch_size=9',   'nb_itera-
       tions_per_scale=10',    'blend_size=5','allow_outer_blending=1'	   and
       'is_already_initialized=0'.

	   Example:
	     [#1]  image.jpg  100%,100%	ellipse[-1] 30%,30%,40,30,0,1,255 +in-
       paint_matchpatch[0] [1]

	 kuwahara:
	     size>0

	   Apply Kuwahara filter of specified size on selected images.

	   Example:
	     [#1] image.jpg kuwahara 9

	 laplacian:

	   Compute Laplacian of	selected images.

	   Example:
	     [#1] image.jpg laplacian

	 lic:
	     _amplitude>0,_channels>0

	   Render LIC representation of	selected vector	fields.

	   Default values: 'amplitude=30' and 'channels=1'.

	   Example:
	     [#1]  400,400,1,2,'if(c==0,x-w/2,y-h/2)'  +lic  200,3  quiver[-2]
       [-2],10,1,1,1,255

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

	   Apply  tone	mapping	 operator on selected images, based on Poisson
       equation.

	   Default values: 'threshold=0.1', 'gamma=0.8', 'smoothness=0.5'  and
       'nb_iter=30'.

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

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

	   Apply fast tone mapping operator on selected	images.

	   Default values: 'radius=3%' and 'power=0.3'.

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

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

	   Apply iterations of the mean	curvature flow on selected images.

	   Default values: 'nb_iter=10', 'dt=30' and 'keep_sequence=0'.

	   Example:
	     [#1] image.jpg +meancurvature_flow	20

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

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

	   Example:
	     [#1] image.jpg +median 5

	 nlmeans:
	     [guide],_patch_radius>0,_spatial_bandwidth>0,_tonal_band-
       width>0,_patch_measure_command |
	     _patch_radius>0,_spatial_bandwidth>0,_tonal_band-
       width>0,_patch_measure_command

	   Apply non local means denoising of Buades et	al, 2005. on  selected
       images.
	   The patch is	a gaussian function of 'std_patch_radius'.
	   The spatial kernel is a rectangle of	radius 'spatial_bandwidth'.
	   The tonal kernel is exponential ('exp(-d^2/_tonal_bandwidth^2)')
	   with	'd' the	euclidean distance between image patches.

	   Default     values:	   'patch_radius=4',	'spatial_bandwidth=4',
       'tonal_bandwidth=10' and	'patch_measure_command=-norm'.

	   Example:
	     [#1] image.jpg +noise 10 nlmeans[-1] 4,4,{0.6*${-std_noise}}

	 nlmeans_core:
	     _reference_image,_scaling_map,_patch_radius>0,_spatial_band-
       width>0

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

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

	   Normalize selected images locally.

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

	   Example:
	     [#1] image.jpg normalize_local 8,10

	 normalized_cross_correlation:
	     [mask]

	   Compute normalized cross-correlation	of selected images with	speci-
       fied mask.

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

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

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

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

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

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

	   Apply circular opening of selected images by	specified size.

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

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

	 percentile:
	     [mask],0<=_min_percentile[%]<=100,0<=_max_percentile[%]<=100.

	   Apply percentile averaging filter to	selected images.

	   Default values: 'min_percentile=0' and 'max_percentile=100'.

	   Example:
	     [#1] image.jpg shape_circle 11,11 +percentile[0] [1],25,75

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

	   Apply iterations of the Perona-Malik	flow on	selected images.

	   Default  values:  'K_factor=20',  'nb_iter=5', 'dt=5' and 'keep_se-
       quence=0'.

	   Example:
	     [#1] image.jpg +heat_flow 20

	 phase_correlation:
	     [destination]

	   Estimate translation	vector	between	 selected  source  images  and
       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  key-
       point 'k'.
	   Values  'f1(k),..,fN(k)' are	the 'N'	components of the vector value
       of keypoint 'k'.
	   The	 command   reconstructs	  an   image   with   specified	  size
       'dx'x'dy'x'dz', with 'N'	channels.

	   Default  values:  'x0=y0=z0=0',  'x1=dx-1',	'y1=dy-1',  'z1=dz-1',
       'phi(r)=r^2*log(1e-5+r)'.

	   Example:
	     [#1]  sp  colorful	 r2dx  400  100%,100%  noise_poissondisk.   10
       1,{is},1,5  eval[-2]  "begin(p=0);i?(I[#-1,p++]=[x,y,I(#0)])" to_rgb[1]
       mul[0,1]	dilate_circ[0] 5 +rbf[-1] {0,[w,h]} c[-1] 0,255
	     [#2] 32,1,1,5,u([400,400,255,255,255]) rbf	400,400	c 0,255

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

	   Attenuate red-eye effect in selected	images.

	   Default  values:  'threshold=75',  'smoothness=3.5'	and  'attenua-
       tion=0.1'.

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

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

	   Remove hot pixels in	selected images.

	   Default values: 'mask_size=3' and 'threshold=10%'.

	   Example:
	     [#1] image.jpg noise 10,2 +remove_hotpixels ,

	 remove_pixels:
	     number_of_pixels[%]>=0

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

	   Example:
	     [#1] image.jpg +remove_pixels 50%

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

	   Apply the rolling guidance filter on	selected image.
	   Rolling  guidance  filter  is  a fast image abstraction filter, de-
       scribed in:
	   "Rolling Guidance Filter", Qi Zhang Xiaoyong,  Shen	Li,  Xu	 Jiaya
       Jia, ECCV'2014.

	   Default values: 'std_deviation_s=4',	'std_deviation_r=10' and 'pre-
       cision=0.5'.

	   Example:
	     [#1] image.jpg +rolling_guidance ,	+-

	 sharpen:
	     amplitude>=0 |
	     amplitude>=0,edge>=0,_alpha[%],_sigma[%]

	   Sharpen selected images by inverse diffusion	or shock filters meth-
       ods.
	   'edge' must be specified to enable shock-filter method.

	   Default values: 'edge=0', 'alpha=0' and 'sigma=0'.

	   Example:
	     [#1] image.jpg sharpen 300
	     [#2] image.jpg blur 5 sharpen 300,1

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

	   Smooth  selected images anisotropically using diffusion PDE's, with
       specified field of
	   diffusion tensors.
	   'interpolation' can be { 0=nearest |	1=linear | 2=runge-kutta }.

	   Default  values:  'sharpness=0.7',  'anisotropy=0.3',  'alpha=0.6',
       'sigma=1.1', 'dl=0.8', 'da=30', 'precision=2', 'interpolation=0'	and
	    'fast_approx=1'.

	   Example:
	     [#1] image.jpg repeat 3 smooth 40,0,1,1,2 done
	     [#2]   image.jpg	100%,100%,1,2	rand[-1]   -100,100  repeat  2
       smooth[-1] 100,0.2,1,4,4	done warp[0] [-1],1,1,1

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

	 split_freq:
	     smoothness>0[%]

	   Split selected images into low and high frequency parts.

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

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

	   Solve Poisson equation so that applying 'laplacian[n]' is close  to
       the result of 'laplacian_command[n]'.
	   Solving  is	performed  using  a multi-scale	gradient descent 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=0'.

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

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

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

	   Solidify selected transparent images.

	   Default values: 'smoothness=75%',  'diffusion_type=1'  and  'diffu-
       sion_iter=20'.

	   Example:
	     [#1]  image.jpg  100%,100%	 circle[-1] 50%,50%,25%,1,255 append c
       +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  'thresh-
       old=0'.

	   Example:
	     [#1] image.jpg blur 3 +unsharp_octave 4,5,15 cut 0,255

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

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

	   Default value: 'boundary_conditions=1'.

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

	 voronoi:

	   Compute the discrete	Voronoi	diagram	of non-zero pixels in selected
       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[%],_interpola-
       tion,_boundary_conditions |
	     x0[%],y0[%],z0[%],x1[%],y1[%],z1[%],x2[%],y2[%],z2[%],x3[%],y3[%],z3[%],_in-
       terpolation,_boundary_conditions

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

	   Example:
	     [#1] image.jpg params=5%,5%,95%,5%,60%,95%,40%,95%	+at_quadrangle
       $params polygon.. 4,$params,0.5,255

	 barycenter:

	   Compute the barycenter vector of pixel values.

	   Example:
	     [#1]  256,256 ellipse 50%,50%,20%,20%,0,1,1 deform	20 +barycenter
       +ellipse[-2] {@0,1},5,5,0,10

	 delaunay:
	     _output_type={ 0=image | 1=coordinates/triangles }

	   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 100%,100% noise. 2,2 eq. 1 delaunay.  +blend  sha-
       peaverage0

	 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 dis-
       tance[0]	1,0 mod	32 threshold 16	append c

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

	 fftpolar:

	   Compute fourier transform of	selected images,  as  centered	magni-
       tude/phase images.

	   Example:
	     [#1] image.jpg fftpolar ellipse 50%,50%,10,10,0,1,0 ifftpolar

	 histogram (+):
	     nb_levels>0[%],_min_value[%],_max_value[%]

	   Compute the histogram of selected images.
	   If  value  range is set, the	histogram is estimated only for	pixels
       in the specified
	   value range.	Argument 'max_value' must be specified if  'min_value'
       is set.

	   Default values: 'min_value=0%' and 'max_value=100%'.

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

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

	   Compute the 1D,2D or	3D histogram of	selected multi-channels	images
       (having 1,2 or 3	channels).
	   If  value  range is set, the	histogram is estimated only for	pixels
       in the specified
	   value range.

	   Default values: 'value0=0%' and 'value1=100%'.

	   Example:
	     [#1] image.jpg channels 0,1 +histogram_nd 256

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

	   Compute cumulative histogram	of selected images.

	   Default values: 'nb_levels=256', 'is_normalized=0',	'val0=0%'  and
       'val1=100%'.

	   Example:
	     [#1]   image.jpg	+histogram_cumul  256  histogram[0]  256  dis-
       play_graph 400,300,3

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

	   Compute the histogram of each vector-valued point of	 selected  im-
       ages.
	   If  value  range is set, the	histogram is estimated only for	values
       in the specified
	   value range.

	   Default values: 'value0=0%' and 'value1=100%'.

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

	   Compute hough transform (theta,rho) of selected images.

	   Default values: 'width=512',	'height=width' and 'gradient_norm_vot-
       ing=1'.

	   Example:
	     [#1] image.jpg +blur 1.5 hough[-1]	400,400	blur[-1] 0.5 add[-1] 1
       log[-1]

	 ifftpolar:

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

	 img2patches:
	     patch_size>0,_overlap[%]>0,_boundary_conditions

	   Decompose selected 2D images	into  (possibly	 overlapping)  patches
       and stack them along the	z-axis.
	   'overlap' must be in	range '[0,patch_size-1]'.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann | 2=periodic
       | 3=mirror }.

	   Default values: 'overlap=0' and 'boundary_conditions=0'.
	   See also: patches2img.
	   image.jpg img2patches 64

	 isophotes:
	     _nb_levels>0

	   Render isophotes of selected	images on a transparent	background.

	   Default value: 'nb_levels=64'

	   Example:
	     [#1] image.jpg blur 2 isophotes 6 dilate_circ 5 display_rgba

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

	   Label connected components in selected images.

	   Default   values:   'tolerance=0',	'is_high_connectivity=0'   and
       'is_L2_norm=1'.

	   Example:
	     [#1]  image.jpg luminance threshold 60% label normalize 0,255 map
       0
	     [#2] 400,400 set 1,50%,50%	distance 1 mod 16  threshold  8	 label
       mod 255 map 2

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

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

	   Label  connected components for non-zero values (foreground)	in 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_con-
       nectivity={ 0 | 1 }

	   Compute minimal path	between	two points on selected potential maps.

	   Default value: 'is_high_connectivity=0'.

	   Example:
	     [#1]  image.jpg  +gradient_norm fill[-1] 1/(1+i) minimal_path[-1]
       0,0,0,100%,100%,0 pointcloud[-1]	0 *[-1]	280 to_rgb[-1]	ri[-1]	[-2],0
       or

	 mse:
	     [reference]

	   Compute MSE (Mean-Squared Error) between selected images and	speci-
       fied reference image.
	   This	command	does not modify	the images, it just returns a value or
       a list of values	in the status.

	 mse_matrix:

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

	   Example:
	     [#1]  image.jpg  +noise  30  +noise[0] 35 +noise[0] 38 cut. 0,255
       +mse_matrix

	 patches2img:
	     width>0,height>0,_overlap[%]>0,_overlap_std[%]

	   Recompose 2D	images from their selected patch representations.
	   'overlap' must be in	range '[0,patch_size-1]' where 'patch_size' is
       the width/height	of the selected	image.
	   'overlap_std' is the	standard deviation  of	the  gaussian  weights
       used for	reconstructing overlapping patches.
	   If  'overlap_std'  is  set to '-1', uniform weights are used	rather
       than gaussian.

	   Default value: 'overlap=0' and 'overlap_std=-1'.
	   See also: img2patches.
	   image.jpg  +img2patches  32,0,3   mirror[-1]	  xy   patches2img[-1]
       {0,[w,h]}

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

	   Extract N+1 patches from selected images, centered at specified lo-
       cations.

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

	 matchpatch (+):
	     [patch_im-
       age],patch_width>=1,_patch_height>=1,_patch_depth>=1,_nb_itera-
       tions>=0,_nb_randoms>=0,_patch_penalization,_output_score={   0	 |   1
       },_[guide]

	   Estimate  correspondence  map between selected images and specified
       patch image, using
	   a patch-matching algorithm.
	   Each	pixel of the returned correspondence map  gives	 the  location
       (p,q) of	the closest patch in
	   the	specified  patch image.	If 'output_score=1', the third channel
       also gives the corresponding
	   matching score for each patch as well.
	   If 'patch_penalization' is >=0, SSD is penalized with patch	occur-
       rences.
	   If  'patch_penalization'  is	<0, SSD	is inf-penalized when distance
       between patches are less	than '-patch_penalization'.

	   Default   values:   'patch_height=patch_width',    'patch_depth=1',
       'nb_iterations=5',    'nb_randoms=5',   'patch_penalization=0',	 'out-
       put_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:
	     [reference],_max_value>0

	   Compute PSNR	(Peak Signal-to-Noise Ratio) between  selected	images
       and specified reference image.
	   This	command	does not modify	the images, it just returns a value or
       a list of values	in the status.

	   Default value: 'max_value=255'.

	 psnr_matrix:
	     _max_value>0

	   Compute  PSNR  (Peak	Signal-to-Noise	Ratio) matrix between selected
       images.

	   Default value: 'max_value=255'.

	   Example:
	     [#1] image.jpg +noise 30 +noise[0]	35  +noise[0]  38  cut.	 0,255
       +psnr_matrix

	 segment_watershed:
	     _threshold>=0

	   Apply watershed segmentation	on selected images.

	   Default values: 'threshold=2'.

	   Example:
	     [#1] image.jpg segment_watershed 2

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

	   Estimate bumpmap from binary	shape in selected images.

	   Default   value:  'resolution=256',	'weight_std_max=0.75',	'dila-
       tion=0' and 'smoothness=100'.

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

	   Compute skeleton of binary shapes using distance transform and con-
       strained	thinning.

	   Default value: 'boundary_conditions=1'.

	   Example:
	     [#1] shape_cupid 320 +skeleton 0

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

	   Segment selected 2D images with superpixels,	using the  SLIC	 algo-
       rithm (Simple Linear Iterative Clustering).
	   Scalar images of increasingly labeled pixels	are returned.
	   Reference  paper:  Achanta,	R.,  Shaji, A.,	Smith, K., Lucchi, A.,
       Fua, P.,	 &  Susstrunk,	S.  (2010).  SLIC  Superpixels	(No.  EPFL-RE-
       PORT-149300).

	   Default values: 'size=16', 'regularity=10' and 'nb_iterations=10'.

	   Example:
	     [#1]  image.jpg  +srgb2lab	 slic[-1] 16 +blend shapeaverage f[-2]
       "j(1,0)==i && j(0,1)==i"	*[-1] [-2]

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

	   Compute fields of SSD between selected images and specified patch.
	   Argument 'boundary_conditions' is valid only	when 'use_fourier=0'.
	   'boundary_conditions' can be	{ 0=dirichlet |	1=neumann | 2=periodic
       | 3=mirror }.

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

	   Example:
	     [#1] image.jpg +crop 20%,20%,35%,35% +ssd_patch[0]	[1],0,0

	 ssim:
	     [reference],_patch_size>0,_max_value>0

	   Compute the Structural Similarity Index Measure (SSIM) between  se-
       lected images and specified reference image.
	   This	command	does not modify	the images, it just returns a value or
       a list of values	in the status.
	   When	 'downsampling_factor'	is  specified  with  a ending '%', its
       value is	equal to '1+(patch_size-1)*spatial_factor%'.

	   SSIM	is a measure introduced	int the	following paper:
	   Wang, Zhou, et al., "Image quality assessment: from error  visibil-
       ity to structural similarity.",
	   in IEEE transactions	on image processing 13.4 (2004): 600-612.

	   The	implementation	of this	command	is a direct translation	of the
       reference code (in Matlab), found at :
	   https://ece.uwaterloo.ca/~z70wang/research/ssim/

	   Default values: 'patch_size=11', and	'max_value=255'.

	 ssim_matrix:
	     _patch_size>0,_max_value>0

	   Compute SSIM	(Structural Similarity Index Measure)  matrix  between
       selected	images.

	   Default values: 'patch_size=11', and	'max_value=255'.

	   Example:
	     [#1]  image.jpg  +noise  30  +noise[0] 35 +noise[0] 38 cut. 0,255
       +ssim_matrix

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

	   Compute skeleton of binary shapes using morphological thinning
	   (beware, this is a quite slow iterative process)

	   Default value: 'boundary_conditions=1'.

	   Example:
	     [#1] shape_cupid 320 +thinning

	 tones:
	     N>0

	   Get N tones masks from selected images.

	   Example:
	     [#1] image.jpg +tones 3

	 topographic_map:
	     _nb_levels>0,_smoothness

	   Render selected images as topographic maps.

	   Default values: 'nb_levels=16' and 'smoothness=2'.

	   Example:
	     [#1] image.jpg topographic_map 10

	 tsp:
	     _precision>=0

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

	   Default values: 'precision=256'.

	   Example:
	     [#1] 256,1,1,2 rand 0,512 tsp , 512,512,1,3 repeat	w#0 circle[-1]
       {0,I[$>]},2,1,255,255,255	      line[-1]		     {0,bound-
       ary=2;[I[$>],I[$>+1]]},1,255,128,0 done keep[-1]

	 variance_patch:
	     _patch_size>=1

	   Compute  variance  of  each	images patch centered at (x,y),	in se-
       lected images.

	   Default value: 'patch_size=16'

	   Example:
	     [#1] image.jpg +variance_patch

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

	 arrow:
	     x0[%],y0[%],x1[%],y1[%],_thick-
       ness[%]>=0,_head_length[%]>=0,_head_thickness[%]>=0,_opacity,_pat-
       tern,_color1,...

	   Draw	specified arrow	on selected images.
	   'pattern' is	an hexadecimal number starting with '0x' which can  be
       omitted
	   even	 if a color is specified. If a pattern is specified, the arrow
       is
	   drawn outlined instead of filled.

	   Default  values:  'thickness=1%',  'head_length=10%',  'head_thick-
       ness=3%', 'opacity=1', 'pattern=(undefined)' and	'color1=0'.

	   Example:
	     [#1]	  400,400,1,3	      repeat	     100	 arrow
       50%,50%,{u(100)}%,{u(100)}%,3,20,10,0.3,${-rgb} done

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

	   Draw	xy-axes	on selected images.
	   'pattern' is	an hexadecimal number starting with '0x' which can  be
       omitted
	   even	if a color is specified.
	   To draw only	one x-axis at row Y, set both 'y0' and 'y1' to Y.
	   To draw only	one y-axis at column X,	set both 'x0' and 'x1' to X.

	   Default   values:  'font_height=14',	 'opacity=1',  'pattern=(unde-
       fined)' and 'color1=0'.

	   Example:
	     [#1] 400,400,1,3,255 axes -1,1,1,-1

	 ball:
	     _size>0,		     _R,_G,_B,0<=_specular_light<=8,0<=_specu-
       lar_size<=8,_shadow>=0

	   Input a 2D RGBA colored ball	sprite.

	   Default   values:   'size=64',   'R=255',   'G=R',  'B=R',  'specu-
       lar_light=0.8', 'specular_size=1' and 'shading=1.5'.

	   Example:
	     [#1] repeat 9 { ball {1.5^($>+2)},${-rgb} } 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=cir-
       cles | 6,7=squares }.
	   'pattern'  is an hexadecimal	number starting	with '0x' which	can be
       omitted
	   even	if a color is specified.

	   Default  values:   'plot_type=1',   'vertex_type=1',	  'ymin=ymax=0
       (auto)',	'opacity=1', 'pattern=(undefined)'
	   and 'color1=0'.

	   Example:
	     [#1]  image.jpg  +rows  50%  blur[-1]  3  split[-1]  c div[0] 1.5
       graph[0]	[1],2,0,0,0,1,255,0,0 graph[0] [2],2,0,0,0,1,0,255,0  graph[0]
       [3],2,0,0,0,1,0,0,255 keep[0]

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

	   Draw	xy-grid	on selected images.
	   'pattern'  is an hexadecimal	number starting	with '0x' which	can be
       omitted
	   even	if a color is specified.

	   Default values: 'offset_x=offset_y=0', 'opacity=1', 'pattern=(unde-
       fined)' and 'color1=0'.

	   Example:
	     [#1] image.jpg grid 10%,10%,0,0,0.5,255
	     [#2] 400,400,1,3,255 grid 10%,10%,0,0,0.3,0xCCCCCCCC,128,32,16

	 j (+):
	     Shortcut for command 'image'.

	 image (+):
	     [sprite],_x[%|~],_y[%|~],_z[%|~],_c[%|~],_opacity,_[opac-
       ity_mask],_max_opacity_mask

	   Draw	specified sprite image on selected images.
	   (equivalent to shortcut command 'j').

	   If one of the x,y,z or c argument ends with a '~', its value	is ex-
       pected to be
	   a centering ratio (in [0,1])	rather than a position.
	   Usual centering ratio  are  {  0=left-justified  |  0.5=centered  |
       1=right-justified }.

	   Default   values:  'x=y=z=c=0',  'opacity=1',  'opacity_mask=(unde-
       fined)' and 'max_opacity_mask=1'.

	   Example:
	     [#1] image.jpg +crop 40%,40%,60%,60%  resize[-1]  200%,200%,1,3,5
       frame[-1] 2,2,0 image[0]	[-1],30%,30% keep[0]

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

	   Draw	specified colored line on selected images.
	   'pattern'  is an hexadecimal	number starting	with '0x' which	can be
       omitted
	   even	if a color is specified.

	   Default values: 'opacity=1',	'pattern=(undefined)' and 'color1=0'.

	   Example:
	     [#1] image.jpg repeat 500 line  50%,50%,{u(w)},{u(h)},0.5,${-rgb}
       done  line 0,0,100%,100%,1,0xCCCCCCCC,255 line 100%,0,0,100%,1,0xCCCCC-
       CCC,255

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

	   Draw	specified colored thick	line on	selected images.

	   Default values: 'thickness=2', 'opacity=1' and 'color1=0'.

	   Example:
	     [#1]	 400,400,1,3	    repeat	  100	     thickline
       {u([w,h,w,h,5])},0.5,${-rgb} done

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

	   Draw	mandelbrot/julia fractal on selected images.

	   Default values: 'iteration_max=100',	'is_julia=0', 'c0r=c0i=0'  and
       'opacity=1'.

	   Example:
	     [#1]  400,400  mandelbrot	-2.5,-2,2,2,1024  map 0	+blur 2	eleva-
       tion3d[-1] -0.2

	 marble:
	     _image_weight,_pattern_weight,_angle,_amplitude,_sharp-
       ness>=0,_anisotropy>=0,_alpha,_sigma,_cut_low>=0,_cut_high>=0

	   Render marble like pattern on selected images.

	   Default  values:  'image_weight=0.2',  'pattern_weight=0.1',	  'an-
       gle=45',	'amplitude=0', 'sharpness=0.4' and 'anisotropy=0.8',
	   'alpha=0.6',	'sigma=1.1' and	'cut_low=cut_high=0'.

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

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

	   Input maze with specified size.

	   Example:
	     [#1] maze 30,20 negate normalize 0,255

	 maze_mask:
	     _cellsize>0

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

	   Example:
	     [#1]  0  text  "G'MIC",0,0,53,1,1 dilate 3	autocrop 0 frame 1,1,0
       maze_mask 8 dilate 3 negate mul 255

	 newton_fractal:
	     z0r,z0i,z1r,z1i,_angle,0<=_descent_method<=2,_itera-
       tion_max>=0,_convergence_preci-
       sion>0,_expr_p(z),_expr_dp(z),_expr_d2p(z)

	   Draw	newton fractal on selected  images,  for  complex  numbers  in
       range (z0r,z0i) - (z1r,z1i).
	   Resulting  images  have  3  channels	 whose	meaning	 is [ last_zr,
       last_zi,	nb_iter_used_for_convergence ].
	   'descent_method' can	be { 0=secant |	1=newton | 2=householder }.

	   Default values: 'angle=0', 'descent_method=1', 'iteration_max=200',
       'convergence_precision=0.01',  'expr_p(z)=z^^3-1',  'expr_dp(z)=3*z^^2'
       and
	    'expr_d2z(z)=6*z'.

	   Example:
	     [#1]  400,400 newton_fractal -1.5,-1.5,1.5,1.5,0,2,200,0.01,"z^^6
       +   z^^3	  -   1","6*z^^5   +   3*z^^2","30*z^^4	  +    6*z"    f    "[
       atan2(i1,i0)*90+20,1,cut(i2/30,0.2,0.7) ]" hsl2rgb

	 j3d (+):
	     Shortcut for command 'object3d'.

	 object3d (+):
	     [object3d],_x[%],_y[%],_z,_opacity,_rendering_mode,_is_dou-
       ble_sided={     0    |	 1    },_is_zbuffer={	 0    |	   1	},_fo-
       cale,_light_x,_light_y,_light_z,_specular_lightness,_specular_shininess

	   Draw	specified 3D object on selected	images.
	   (equivalent to shortcut command 'j3d').

	   'rendering_mode' can	be { 0=dots | 1=wireframe | 2=flat  |  3=flat-
       shaded |	4=gouraud-shaded | 5=phong-shaded }.

	   Default  values:  'x=y=z=0',	 'opacity=1'  and  'is_zbuffer=1'. All
       other arguments take their default values
	   from	the 3D environment variables.

	   Example:
	     [#1] image.jpg torus3d 100,10  cone3d  30,-120  add3d[-2,-1]  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_itera-
       tions>=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',	'opac-
       ity=1', 'pattern=(undefined)'
	   and 'color1=0'.

	   Example:
	     [#1]      100,100,1,2,'if(c==0,x-w/2,y-h/2)'      500,500,1,3,255
       quiver[-1] [-2],10
	     [#2] image.jpg +resize2dy 600 luminance[0]	gradient[0] mul[1]  -1
       reverse[0,1]   append[0,1]   c	blur[0]	  8  orientation[0]  quiver[1]
       [0],20,1,1,0.8,255

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

	   Draw	specified colored rectangle on selected	images.
	   'pattern' is	an hexadecimal number starting with '0x' which can  be
       omitted
	   even	 if  a color is	specified. If a	pattern	is specified, the rec-
       tangle is
	   drawn outlined instead of filled.

	   Default values: 'opacity=1',	'pattern=(undefined)' and 'color1=0'.

	   Example:
	     [#1]      image.jpg       repeat	    30	     {	     rectangle
       {u(100)}%,{u(100)}%,{u(100)}%,{u(100)}%,0.3,${-rgb} }

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

	   Render rorschach-like inkblots on selected images.

	   Default values: 'smoothness=5%' and 'mirroring=1'.

	   Example:
	     [#1] 400,400 rorschach 3%

	 sierpinski:
	     recursion_level>=0

	   Draw	Sierpinski triangle on selected	images.

	   Default value: 'recursion_level=7'.

	   Example:
	     [#1] image.jpg sierpinski 7

	 spiralbw:
	     width>0,_height>0,_is_2dcoords={ 0	| 1 }

	   Input a 2D rectangular spiral image with specified size.

	   Default values: 'height=width' and 'is_2dcoords=0'.

	   Example:
	     [#1] spiralbw 16
	     [#2]  image.jpg  spiralbw	{[w,h]},1  +warp[0] [1],0,1,1 +warp[2]
       [1],2,1,1

	 spline:
	     x0[%],y0[%],u0[%],v0[%],x1[%],y1[%],u1[%],v1[%],_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
       }

	 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*$>} }
	     [#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

	 eye:
	     _size>0

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

	   Example:
	     [#1] eye 3	eye 7 eye 10

	 invert	(+):
	     solver={ 0=SVD | 1=LU }

	   Compute the inverse of the selected matrices.
	   SVD solver is slower	but less numerically instable than LU.

	   Default value: 'solver=1'.

	   Example:
	     [#1] (0,1,0;0,0,1;1,0,0) +invert

	 orthogonalize:
	     _mode = { 0=orthogonalize | 1=orthonormalize }

	   Orthogonalize or orthonormalize selected matrices,  using  Modified
       Gram-Schmidt process.

	   Default value: 'mode=0'.

	 meigen:
	     m>=1

	   Compute  an approximation of	the 'm'	largest	eigenvalues and	eigen-
       vectors of selected symmetric matrices,
	   using	 the	     Arnoldi	     iteration		method
       (https://en.wikipedia.org/wiki/Arnoldi_iteration).
	   A larger 'm'	goes with better numerical precision.

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

	 mproj (+):
	     [dictionary],_method,_max_iter={ 0=auto | >0 },_max_residual>=0

	   Find	best matching projection of selected matrices onto the span of
       an over-complete
	   dictionary  D,  using the orthogonal	projection or Matching Pursuit
       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} } add3d
	     [#2] repeat 20 { torus3d 15,2 color3d[-1] ${-rgb} mul3d[-1] 0.5,1
       if  $>%2	 rotate3d[-1]  0,1,0,90	 fi  add3d[-1]	70  add3d rotate3d[-1]
       0,0,1,18	} double3d 0

	 animate3d:
	     nb_frames>0,_step_angle_x,_step_angle_y,_step_angle_z,_zoom_fac-
       tor,0<=_fake_shadow_level<=100,_[background]

	   Generate 3D animation frames	of rotating 3D objects.
	   Frames are stacked along the	z-axis (volumetric image).
	   Frame size is the same as the size of the '[background]' image  (or
       800x800 if no background	specified).

	   Default values: 'filename=(undefined)'.

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

	   Apply 3D camera matrix to selected 3D objects.

	   Default values: 'target_x=0', 'target_y=0', 'target_z=0', 'up_x=0',
       'up_y=-1' and 'up_z=0'.

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

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

	   Example:
	     [#1]	     torus3d		10,1	       +apply_matrix3d
       {mul(rot(1,0,1,-15),[1,0,0,0,2,0,0,0,8],3)} double3d 0

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

	   Duplicate a 3D object along the X,Y and Z axes.

	   Default values: 'size_y=1', 'size_z=1' and  'offset_x=offset_y=off-
       set_z=100%'.

	   Example:
	     [#1] torus3d 10,1 +array3d	5,5,5,110%,110%,300%

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

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

	   Default   values:   'radius=5%',  'head_length=25%'	and  'head_ra-
       dius=15%'.

	   Example:
	     [#1]      repeat	   10	   {	  a={$>*2*pi/10}       arrow3d
       0,0,0,{cos($a)},{sin($a)},-0.5 }	+3d

	 axes3d:
	     _size_x,_size_y,_size_z,_font_size>0,_label_x,_label_y,_la-
       bel_z,_is_origin={ 0=no | 1=yes }

	   Input  3D  axes  with  specified sizes along	the x,y	and z orienta-
       tions.

	   Default  values:  'size_x=size_y=size_z=1',	'font_size=23',	  'la-
       bel_x=X', 'label_y=Y', 'label_z=Z' and 'is_origin=1'

	   Example:
	     [#1] axes3d ,

	 boundingbox3d:

	   Replace selected 3D objects by their	3D bounding boxes.

	   Example:
	     [#1] torus3d 100,30 +boundingbox3d	+3d[-1]	[-2]

	 box3d:
	     _size_x,_size_y,_size_z

	   Input 3D box	at (0,0,0), with specified geometry.

	   Default values: 'size_x=1' and 'size_z=size_y=size_x'.

	   Example:
	     [#1] box3d	100,40,30 +primitives3d	1 color3d[-2] ${-rgb}

	 c3d:
	     Shortcut for command 'center3d'.

	 center3d:

	   Center selected 3D objects at (0,0,0).
	   (equivalent to shortcut command 'c3d').

	   Example:
	     [#1]  repeat  100 { circle3d {u(100)},{u(100)},{u(100)},2 } add3d
       color3d[-1] 255,0,0 +center3d color3d[-1] 0,255,0 add3d

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

	   Input 3D circle at specified	coordinates.

	   Default values: 'x0=y0=z0=0'	and 'radius=1'.

	   Example:
	     [#1]      repeat	   500	    {	   a={$>*pi/250}      circle3d
       {cos(3*$a)},{sin(2*$a)},0,{$a/50} color3d[-1] ${-rgb},0.4 } add3d

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

	   Convert  specified  3D objects to sets of 3D	circles	with specified
       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} } 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=1'.

	   Example:
	     [#1] torus3d 5,2 repeat  5	 {  +add3d[-1]	12,0,0	div3d[-1]  1.2
       color3d[-1] ${-rgb} } add3d

	 db3d (+):
	     Shortcut for command 'double3d'.

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

	   Enable/disable double-sided mode for	3D rendering.
	   (equivalent to shortcut command 'db3d').

	   Default value: 'is_double_sided=1'.

	   Example:
	     [#1]  mode3d  1  repeat  2	{ torus3d 100,30 rotate3d[-1] 1,1,0,60
       double3d	$> snapshot3d[-1] 400 }

	 elevation3d:
	     { z-factor	| [elevation_map] | 'formula' },base_height={ -1 | >=0
       } |
	     (no arg)

	   Generate 3D elevation of selected images, opt. with a specified el-
       evation map.
	   When	invoked	with (no arg) or 'z-factor', the elevation map is com-
       puted as	the pointwise L2 norm of the
	   pixel values. Otherwise, the	elevation map is taken from the	speci-
       fied image or formula.

	   Example:
	     [#1] image.jpg +blur 5 elevation3d. 0.75
	     [#2] 128,128,1,3,u(255) plasma 10,3 blur 4	sharpen	10000 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  'smooth-
       ness=0.5%'.

	   Example:
	     [#1] image.jpg threshold 50% extrude3d 16

	 f3d (+):
	     Shortcut for command 'focale3d'.

	 focale3d (+):
	     focale

	   Set 3D focale.
	   (equivalent to shortcut command 'f3d').

	   Set 'focale'	to 0 to	enable parallel	projection  (instead  of  per-
       spective).
	   Set negative	'focale' will disable 3D sprite	zooming.

	   Default value: 'focale=700'.

	   Example:
	     [#1]  repeat  5  {	 torus3d 100,30	rotate3d[-1] 1,1,0,60 focale3d
       {$<*90} snapshot3d[-1] 400 } remove[0]

	 gaussians3d:
	     _size>0,_opacity

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

	   Example:
	     [#1] image.jpg r2dy 32 distribution3d gaussians3d 20  colorcube3d
       primitives3d[-1]	1 +3d

	 gmic3d:

	   Input a 3D G'MIC logo.

	   Example:
	     [#1] gmic3d +primitives3d 1

	 gyroid3d:
	     _resolution>0,_zoom

	   Input 3D gyroid at (0,0,0), with specified resolution.

	   Default values: 'resolution=32' and 'zoom=5'.

	   Example:
	     [#1] gyroid3d 48 +primitives3d 1

	 histogram3d:

	   Get 3D color	histogram of selected images.

	   Example:
	     [#1]  image.jpg  resize2dx	 64 histogram3d	circles3d 3 opacity3d.
       0.75 colorcube3d	primitives3d[-1] 1 add3d

	 image6cube3d:

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

	   Example:
	     [#1] image.jpg animate flower,"30,0","30,5",6 image6cube3d

	 imageblocks3d:
	     _maximum_elevation,_smoothness[%]>=0

	   Generate 3D blocks from selected images.
	   Transparency	of selected images is taken into account.

	   Default values: 'maximum_elevation=10' and 'smoothness=0'.

	   Example:
	     [#1] image.jpg resize2dy 32 imageblocks3d -20 mode3d 3

	 imagecube3d:

	   Generate 3D mapped cubes from selected images.

	   Example:
	     [#1] image.jpg imagecube3d

	 imageplane3d:

	   Generate 3D mapped planes from selected images.

	   Example:
	     [#1] image.jpg imageplane3d

	 imagepyramid3d:

	   Generate 3D mapped pyramids from selected images.

	   Example:
	     [#1] image.jpg imagepyramid3d

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

	   Generate 3D mapped rubik's cubes from selected images.

	   Default values: 'xy_tiles=3', 'xy_shift=5' and 'z_shift=5'.

	   Example:
	     [#1] image.jpg imagerubik3d ,

	 imagesphere3d:
	     _resolution1>=3,_resolution2>=3

	   Generate 3D mapped sphere from selected images.

	   Default values: 'resolution1=32' and	'resolutions2=16'.

	   Example:
	     [#1] image.jpg imagesphere3d 32,16

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

	   Extract 3D isolines with specified value from  selected  images  or
       from specified formula.

	   Default values: 'x0=y0=-3', 'x1=y1=3' and 'size_x=size_y=256'.

	   Example:
	     [#1] image.jpg blur 1 isoline3d 50%
	     [#2] isoline3d 'X=x-w/2;Y=y-h/2;(X^2+Y^2)%20',10,-10,-10,10,10

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

	   Extract 3D isosurfaces with specified value from selected images or
       from specified formula.

	   Default	values:	     'x0=y0=z0=-3',	 'x1=y1=z1=3'	   and
       'size_x=size_y=size_z=32'.

	   Example:
	     [#1] image.jpg resize2dy 128 luminance threshold 50% expand_z 2,0
       blur 1 isosurface3d 50% mul3d 1,1,30
	     [#2] isosurface3d 'x^2+y^2+abs(z)^abs(4*cos(x*y*z*3))',3

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

	   Generate 3D text label.

	   Default     values:	   'font_height=13',	  'opacity=1'	   and
       'color=255,255,255'.

	 label_points3d:
	     _label_size>0,_opacity

	   Add a numbered label	to all vertices	of selected 3D objects.

	   Default values: 'label_size=13' and 'opacity=0.8'.

	   Example:
	     [#1] torus3d 100,40,6,6 label_points3d 23,1 mode3d	1

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

	   Generate 3D object from selected binary XY-profiles.

	   Default  values:  'resolution=128',	'smoothness=0.5%' and 'max_an-
       gle=361'.

	   Example:
	     [#1] 300,300 rand -1,1 blur 40 sign normalize 0,255 lathe3d ,

	 l3d (+):
	     Shortcut for command 'light3d'.

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

	   Set the light coordinates or	the light texture for 3D rendering.
	   (equivalent to shortcut command 'l3d').

	   (no arg) resets the 3D light	to default.

	   Example:
	     [#1] torus3d 100,30 double3d 0 specs3d 1.2	 repeat	 5  {  light3d
       {$>*100},0,-300 +snapshot3d[0] 400 } remove[0]

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

	   Input 3D line at specified coordinates.

	   Example:
	     [#1]	repeat	     100       {      a={$>*pi/50}	line3d
       0,0,0,{cos(3*$a)},{sin(2*$a)},0 color3d.	${-rgb}	} add3d

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

	   Input 3D lissajous curves (x(t)=sin(at+A*2pi),  y(t)=sin(bt+B*2pi),
       z(t)=sin(ct+C*2pi)).

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

	   Example:
	     [#1] lissajous3d ,

	 m3d (+):
	     Shortcut for command 'mode3d'.

	 mode3d	(+):
	     _mode

	   Set static 3D rendering mode.
	   (equivalent to shortcut command 'm3d').

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

	   Default value: 'mode=4'.

	   Example:
	     [#1] (0,1,2,3,4,5)	double3d 0  repeat  w  {  torus3d  100,30  ro-
       tate3d[-1] 1,1,0,60 mode3d {0,@$>} snapshot3d[-1] 300 } remove[0]

	 md3d (+):
	     Shortcut for command 'moded3d'.

	 moded3d (+):
	     _mode

	   Set dynamic 3D rendering mode for interactive 3D viewer.
	   (equivalent to shortcut command 'md3d').

	   'mode'  can	be { -1=bounding-box | 0=dots |	1=wireframe | 2=flat |
       3=flat-shaded | 4=gouraud-shaded	| 5=phong-shaded }.

	   Default value: 'mode=-1'.

	 *3d (+):
	     Shortcut for command 'mul3d'.

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

	   Scale selected 3D objects isotropically  or	anisotropically,  with
       specified factors.
	   (equivalent to shortcut command '*3d').

	   Default value: 'factor_z=1'.

	   Example:
	     [#1]  torus3d  5,2	 repeat	 5  {  +add3d[-1] 10,0,0 mul3d[-1] 1.2
       color3d[-1] ${-rgb} } add3d

	 n3d:
	     Shortcut for command 'normalize3d'.

	 normalize3d:

	   Normalize selected 3D objects to unit size.
	   (equivalent to shortcut command 'n3d').

	   Example:
	     [#1] repeat  100  {  circle3d  {u(3)},{u(3)},{u(3)},0.1  }	 add3d
       color3d[-1] 255,0,0 +normalize3d[-1] color3d[-1]	0,255,0	add3d

	 o3d (+):
	     Shortcut for command 'opacity3d'.

	 opacity3d (+):
	     _opacity

	   Set opacity of selected 3D objects.
	   (equivalent to shortcut command 'o3d').

	   Default value: 'opacity=1'.

	   Example:
	     [#1]  torus3d 100,10 double3d 0 repeat 7 {	+rotate3d[-1] 1,0,0,20
       opacity3d[-1] {u} } add3d

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

	   Input  3D  object  from   specified	 parametric   surface	'(a,b)
       (x(a,b),y(a,b),z(a,b))'.

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

	   Example:
	     [#1] parametric3d ,

	 pca_patch3d:
	     _patch_size>0,_M>0,_N>0,_normalize_input={	 0  |	1   },_normal-
       ize_output={ 0 |	1 },_lambda_xy

	   Get 3D patch-pca representation of selected images.
	   The	3D  patch-pca  is estimated from M patches on the input	image,
       and displayed as	a cloud	of N 3D	points.

	   Default values: 'patch_size=7', 'M=1000', 'N=3000',	'normalize_in-
       put=1', 'normalize_output=0', and 'lambda_xy=0'.

	   Example:
	     [#1] image.jpg pca_patch3d	7

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

	   Input 3D plane at (0,0,0), with specified geometry.

	   Default   values:   'size_x=1',  'size_y=size_x'  and  'nb_subdivi-
       sions_x=nb_subdivisions_y=24'.

	   Example:
	     [#1] plane3d 50,30	+primitives3d 1	color3d[-2] ${-rgb}

	 point3d:
	     x0,y0,z0

	   Input 3D point at specified coordinates.

	   Example:
	     [#1]      repeat	   1000	     {	    a={$>*pi/500}      point3d
       {cos(3*$a)},{sin(2*$a)},0 color3d[-1] ${-rgb} } 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 } 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
       } add3d

	 rotation3d:
	     u,v,w,angle

	   Input 3x3 rotation matrix with specified axis and angle (in deg).

	   Example:
	     [#1] rotation3d 1,0,0,0 rotation3d	1,0,0,90 rotation3d 1,0,0,180

	 sierpinski3d:
	     _recursion_level>=0,_width,_height

	   Input 3d Sierpinski pyramid.

	   Example:
	     [#1] sierpinski3d 3,100,-100 +primitives3d	1 color3d[-2] ${-rgb}

	 size3d:

	   Return bounding box size of the last	selected 3D object.

	 skeleton3d:
	     _metric,_frame_type={ 0=squares | 1=diamonds | 2=circles |	3=auto
       },_skeleton_opacity,_frame_opacity,_is_frame_wireframe={	0 | 1 }

	   Build 3D skeletal structure object from 2d binary shapes located in
       selected	images.
	   'metric' can	be { 0=chebyshev | 1=manhattan | 2=euclidean }.

	   Default values:  'metric=2',	 'bones_type=3',  'skeleton_opacity=1'
       and 'frame_opacity=0.1'.

	   Example:
	     [#1] shape_cupid 480 +skeleton3d ,

	 snapshot3d:
	     _size>0,_zoom>=0,_backgroundR,_backgroundG,_backgroundB,_back-
       groundA |
	     [background_image],zoom>=0

	   Take	2d snapshots of	selected 3D objects.
	   Set 'zoom' to 0 to disable object auto-scaling.

	   Default  values:  'size=512', 'zoom=1' and '[background_image]=(de-
       fault)'.

	   Example:
	     [#1]    torus3d	100,20	  rotate3d     1,1,0,60	    snapshot3d
       400,1.2,128,64,32
	     [#2]  torus3d  100,20  rotate3d  1,1,0,60 sample ?	+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 } re-
       move[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 } re-
       move[0]

	 sphere3d (+):
	     radius,_nb_recursions>=0

	   Input 3D sphere at (0,0,0), with specified geometry.

	   Default value: 'nb_recursions=3'.

	   Example:
	     [#1] sphere3d 100 +primitives3d 1 color3d[-2] ${-rgb}

	 spherical3d:
	     _nb_azimuth>=3,_nb_zenith>=3,_radius_function(phi,theta)

	   Input 3D spherical object at	(0,0,0), with specified	geometry.

	   Default   values:   'nb_zenith=nb_azimut=64'	  and	 'radius_func-
       tion="abs(1+0.5*cos(3*phi)*sin(4*theta))"'.

	   Example:
	     [#1] spherical3d 64 +primitives3d 1

	 spline3d:
	     x0[%],y0[%],z0[%],u0[%],v0[%],w0[%],x1[%],y1[%],z1[%],u1[%],v1[%],w1[%],_nb_ver-
       tices>=2

	   Input 3D spline with	specified geometry.

	   Default values: 'nb_vertices=128'.

	   Example:
	     [#1]	    repeat	     100	   {	      spline3d
       {u},{u},{u},{u},{u},{u},{u},{u},{u},{u},{u},{u},128 color3d[-1] ${-rgb}
       } box3d 1 primitives3d[-1] 1 add3d

	 s3d (+):
	     Shortcut for command 'split3d'.

	 split3d (+):
	     _full_split={ 0 | 1 }

	   Split selected 3D objects into feature vectors :
	    * If 'full_split==0', { header, sizes, vertices, primitives,  col-
       ors, 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  dis-
       play_rgba[-2]

	 star3d:
	     _nb_branches>0,0<=_thickness<=1

	   Input 3D star at position '(0,0,0)',	with specified geometry.

	   Default values: 'nb_branches=5' and 'thickness=0.38'.

	   Example:
	     [#1] star3d , +primitives3d 1 color3d[-2] ${-rgb}

	 streamline3d (+):
	     x[%],y[%],z[%],_L>=0,_dl>0,_interpolation,_is_backward={  0  |  1
       },_is_oriented={	0 | 1 }	|
	     'formula',x,y,z,_L>=0,_dl>0,_interpolation,_is_backward={ 0  |  1
       },_is_oriented={	0 | 1 }

	   Extract  3D	streamlines from selected vector fields	or from	speci-
       fied formula.
	   'interpolation' can be { 0=nearest integer |	1=1st-order  |	2=2nd-
       order | 3=4th-order }.

	   Default  values:  'dl=0.1',	'interpolation=2', 'is_backward=0' and
       'is_oriented=0'.

	   Example:
	     [#1] 100,100,100,3	rand -10,10  blur  3  repeat  300  {  +stream-
       line3d[0] {u(100)},{u(100)},{u(100)},1000,1,1 color3d[-1] ${-rgb} } re-
       move[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} } add3d

	 superformula3d:
	     resolution>1,m>=1,n1,n2,n3

	   Input 2D superformula curve as a 3D object.

	   Default   values:  'resolution=1024',  'm=8',  'n1=1',  'n2=5'  and
       'n3=8'.

	   Example:
	     [#1] superformula3d ,

	 surfels3d:
	     0<=_left_right_attenuation<=1,0<=_top_bottom_attenua-
       tion<=1,0<=_closer_further_attenuation<=1

	   Convert selected images to 3d objects composed of 3D	surfels	(or 2D
       edgels for 2D images).
	   Selected images must	contain	binary shapes, where each value	 0  is
       an exterior voxel, and each value !=0 is	an interior voxel.
	   The	resulting  3D  object is colored according to the color	of non
       zero voxels.

	   Default  values:  'left_right_attenuation=1',  'top_bottom_attenua-
       tion=1' and 'closer_further_attenuation=1'.

	   Example:
	     [#1]  100,100,100	=  1,40%,40%,40% = 1,60%,60%,60% distance 1 lt
       30% blur	3 gt 50% surfels3d 0.5,0.75,1

	 tensors3d:
	     _radius_factor>=0,_shape={	0=box |	>=N=ellipsoid },_radius_min>=0

	   Generate 3D tensor fields from selected images.
	   when	'shape'>0, it gives the	ellipsoid shape	precision.

	   Default values: 'radius_factor=1', 'shape=2'	and 'radius_min=0.05'.

	   Example:
	     [#1] 6,6,6,9,"U = [x,y,z] - [w,h,d]/2; U/=norm(U);	 mul(U,U,3)  +
       0.3*eye(3)" tensors3d 0.8

	 text_pointcloud3d:
	     _"text1",_"text2",_smoothness

	   Input 3D text pointcloud from the two specified strings.

	   Default   values:  'text1="text1"',	'text2="text2"'	 and  'smooth-
       ness=1'.

	   Example:
	     [#1] text_pointcloud3d "G'MIC","Rocks!"

	 text3d:
	     text,_font_height>0,_depth>0,_smoothness

	   Input a 3D text object from specified text.

	   Default values: 'font_height=53', 'depth=10'	and 'smoothness=1.5'.

	   Example:
	     [#1] text3d "G'MIC	as 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} } 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.	Flow Control
		------------

	 ap:
	     Shortcut for command 'apply_parallel'.

	 apply_parallel:
	     "command"

	   Apply  specified  command on	each of	the selected images, by	paral-
       lelizing	it for all image of the	list.
	   (equivalent to shortcut command 'ap').

	   Example:
	     [#1] image.jpg +mirror x +mirror y	apply_parallel "blur 3"

	 apc:
	     Shortcut for command 'apply_parallel_channels'.

	 apply_parallel_channels:
	     "command"

	   Apply specified command on each of the selected images,  by	paral-
       lelizing	it for all channel
	   of the images independently.
	   (equivalent to shortcut command 'apc').

	   Example:
	     [#1] image.jpg apply_parallel_channels "blur 3"

	 apo:
	     Shortcut for command 'apply_parallel_overlap'.

	 apply_parallel_overlap:
	     "command",overlap[%],nb_threads={ 0=auto |	1 | 2 |	4 | 8 |	16 }

	   Apply  specified  command on	each of	the selected images, by	paral-
       lelizing	it on 'nb_threads'
	   overlapped sub-images.
	   (equivalent to shortcut command 'apo').

	   'nb_threads'	must be	a power	of 2.

	   Default values: 'overlap=0','nb_threads=0'.

	   Example:
	     [#1] image.jpg +apply_parallel_overlap "smooth 500,0,1",1

	 at:
	     Shortcut for command 'apply_tiles'.

	 apply_tiles:
	     "com-
       mand",_tile_width[%]>0,_tile_height[%]>0,_tile_depth[%]>0,_over-
       lap_width[%]>=0,_overlap_height[%]>=0,_overlap_depth[%]>=0,_bound-
       ary_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%','over-
       lap_width=overlap_height=overlap_depth=0' and 'boundary_conditions=1'.

	   Example:
	     [#1]   image.jpg	+equalize[0]   256  +apply_tiles[0]  "equalize
       256",16,16,1,50%,50%

	 apply_timeout:
	     "command",_timeout={ 0=no timeout | >0=with specified timeout (in
       seconds)	}

	   Apply a command with	a timeout.
	   Set variable	'$_is_timeout' to '1' if timeout occurred, '0'	other-
       wise.

	   Default value: 'timeout=20'.

	 check (+):
	     condition

	   Evaluate specified condition	and display an error message if	evalu-
       ated to false.

	 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	'do...while', 'for...done',  'foreach...done',
       'local...done' or 'repeat...done' block.

	   Example:
	     [#1]  image.jpg  repeat  10  blur 1 if 1==1 continue fi deform 10
       done

	 break (+):

	   Break current 'do...while',	'for...done',  'foreach...done',  'lo-
       cal...done' or 'repeat...done' block.

	   Example:
	     [#1] image.jpg repeat 10 blur 1 if	1==1 break fi deform 10	done

	 do (+):

	   Start a 'do...while'	block.

	   Example:
	     [#1]  image.jpg luminance i={ia+2}	do set 255,{u(100)}%,{u(100)}%
       while ia<$i

	 } (+):
	     Shortcut for command 'done'.

	 done (+):

	   End a 'for/foreach/local/repeat...done' block, and go to associated
       'for/foreach/repeat' if iterations remain.
	   (equivalent to shortcut command '}').

	 elif (+):
	     condition

	   Start a 'elif...[else]...fi'	block if previous 'if' was  not	 veri-
       fied
	   and test if specified condition holds
	   'condition'	is  a mathematical expression, whose evaluation	is in-
       terpreted as { 0=false |	other=true }..

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

	 else (+):

	   Execute following commands if previous 'if'	or  'elif'  conditions
       failed.

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

	 fi (+):

	   End a 'if...[elif]...[else]...fi' block.
	   (equivalent to shortcut command 'fi').

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

	 error (+):
	     message

	   Print  specified  error  message on the standard error (stderr) and
       exit interpreter, except
	   if error is caught by a 'onfail' command.
	   Command selection (if any) stands for displayed call	 stack	subset
       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 assign-
       ing the image values).

	 x (+):
	     Shortcut for command 'exec'.

	 exec (+):
	     _is_verbose={ 0 | 1 },"command"

	   Execute external command using a system call.
	   The status value is then set	to the error code returned by the sys-
       tem call.
	   If 'is_verbose=1', the executed command is  allowed	to  output  on
       stdout/stderr.
	   (equivalent to shortcut command 'x').

	   Default value: 'is_verbose=1'.

	 xo:
	     Shortcut for command 'exec_out'.

	 exec_out:
	     _mode,"command"

	   Execute  external command using a system call, and return resulting
       'stdout'	and/or 'stderr'.
	   'mode' can be { 0=stdout | 1=stderr | 2=stdout+stderr }.

	 for (+):
	     condition

	   Start a 'for...done'	block.

	   Example:
	     [#1] image.jpg resize2dy 32 400,400,1,3 x=0 for  $x<400  image[1]
       [0],$x,$x x+=40 done

	 foreach (+):

	   Start  a  'foreach...[onfail]...done' block,	that iterates over all
       images in the selection,	with a separate	 local	environment  for  each
       one.

	   Example:
	     [#1] sample colorful,earth,duck,dog foreach[^2] +blur 10 sub nor-
       malize 0,255 done

	 if (+):
	     condition

	   Start  a  'if...[elif]...[else]...fi'  block	 and test if specified
       condition holds.
	   'condition' is a mathematical expression, whose evaluation  is  in-
       terpreted as { 0=false |	other=true }.

	   Example:
	     [#1]  image.jpg  if ia<64 add 50% elif ia<128 add 25% elif	ia<192
       sub 25% else sub	50% fi cut 0,255

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

	 l (+):
	     Shortcut for command 'local'.

	 local (+):

	   Start a 'local...[onfail]...done' block, with selected images.
	   (equivalent to shortcut command 'l').

	   Example:
	     [#1] image.jpg local[] 300,300,1,3	rand[0]	0,255 blur  4  sharpen
       1000 done
	     [#2] image.jpg +local repeat 3 { deform 20	} done

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

	 mutex (+):
	     index,_action={ 0=unlock |	1=lock }

	   Lock	or unlock specified mutex for multi-threaded programming.
	   A locked mutex can be unlocked only by the same thread. All mutexes
       are unlocked by default.
	   'index' designates the mutex	index, in [0,255].

	   Default value: 'action=1'.

	 noarg (+):

	   Used	 in a custom command, 'noarg' tells the	command	that its argu-
       ment list have not been used
	   finally, and	so they	must be	evaluated next in the G'MIC  pipeline,
       just as if the custom
	   command takes no arguments at all.
	   Use	this  command to write a custom	command	which can decide if it
       takes arguments or not.

	 onfail	(+):

	   Execute following commands when an error is encountered in the body
       of the 'local...done' block.
	   The status value is set with	the corresponding error	message.

	   Example:
	     [#1] image.jpg +local blur	-3 onfail mirror x done

	 parallel (+):
	     _wait_threads,"command1","command2",...

	   Execute specified commands in parallel, each	in a different thread.
	   Parallel threads share the list of images.
	   'wait_threads' can be { 0=when current environment ends | 1=immedi-
       ately }.

	   Default value: 'wait_threads=1'.

	   Example:
	     [#1] image.jpg [0]	parallel "blur[0] 3","mirror[1]	c"

	 progress (+):
	     0<=value<=100 |
	     -1

	   Set the progress index of the current processing pipeline.
	   This	command	is useful only when G'MIC is used by an	embedding  ap-
       plication.

	 q (+):
	     Shortcut for command 'quit'.

	 quit (+):

	   Quit	G'MIC interpreter.
	   (equivalent to shortcut command 'q').

	 repeat	(+):
	     nb_iterations

	   Start 'nb_iterations' iterations of a 'repeat...done' block.
	   'nb_iterations'  is	a  mathematical	expression that	will be	evalu-
       ated.

	   Example:
	     [#1] image.jpg split y repeat $! n=$> shift[$n]  $<,0,0,0,2  done
       append y
	     [#2]  image.jpg  mode3d  2	repeat 4 imagecube3d rotate3d 1,1,0,40
       snapshot3d 400,1.4 done

	   Tutorial: https://gmic.eu/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	speci-
       fied condition holds.
	   'condition'	is  a mathematical expression, whose evaluation	is in-
       terpreted as { 0=false |	other=true }.

	 12.14.	Neural Networks
		---------------

	 nn_lib	::

	   Return the list of library functions	that has to be included	 in  a
       math expression,in order	to use the neural network library.

	 nn_init:

	   Initialize a	new network.

	 nn_check_layer:
	     name

	   Check that the layer	with specified name exists in the network.

	 nn_layer_input:
	     name,width,_height,_depth,_spectrum

	   Add an 'input' layer	to the network.

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

	 nn_layer_add:
	     name,in0,in1

	   Add an 'add'	layer to the network.

	 nn_layer_append:
	     name,in0,in1

	   Add an 'append' layer to the	network.

	 nn_layer_avgpool2d:
	     name,in

	   Add a 'avgpool2d' layer (2d average pooling)	to the network.

	 nn_layer_batchnorm:
	     name,in,_learning_mode.

	   Add a 'batchnorm' layer to the network.
	   'learning_mode'  can	 be  { 0=learn no parameters | 1=learn gamma |
       2=learn beta | 3=learn gamma and	beta}.

	   Default value: 'learning_mode=3'.

	 nn_layer_clone:
	     name0,name1,in

	   Add a 'clone' layer to the network.

	 nn_layer_conv2d:
	     name,in,nb_channels>0,_kernel_size>0,_stride>0,_dila-
       tion,_is_learned={ 0 | 1	}

	   Add a 'conv2d' layer	(2D convolutional layer) to the	network.

	   Default  values:  'kernel_size=3',  'stride=1',  'dilation=1'   and
       'is_learned=1'.

	 nn_layer_conv2dbnnl:
	     name,in,nb_channels>0,_kernel_size>0,_stride>0,_dilation>0,_acti-
       vation,_is_learned={ 0 |	1 }

	   Add	a 'con2dbnnl' (2D convolutional	layer followed by a batchnorm,
       then a non-linearity), to the network.

	   Default values: 'kernel_size=3', 'stride=1',	'dilation=1', 'activa-
       tion=leakyrelu' and 'is_learned=1'.

	 nn_layer_conv2dnl:
	     name,in,nb_channels>0,_kernel_size>0,_stride>0,_dilation>0,_acti-
       vation,_is_learned={ 0 |	1 }

	   Add a 'con2dnl' (2D convolutional layer followed by	a  non-linear-
       ity), to	the network.

	   Default values: 'kernel_size=3', 'stride=1',	'dilation=1', 'activa-
       tion=leakyrelu' and 'is_learned=1'.

	 nn_layer_resconv2d:
	     name,in,_kernel_size>0,_stride>0,_dilation>0,_is_learned={	 0 | 1
       }

	   Add a 'rescon2d' (residual 2D convolutional layer), to the network.

	   Default  values:  'kernel_size=3',  'stride=1',  'dilation=1'   and
       'is_learned=1'.

	 nn_layer_resconv2dnl:
	     name,in,_kernel_size>0,_stride>0,_dilation>0,_activa-
       tion,_is_learned={ 0 | 1	}

	   Add	a  'rescon2dnl'	(residual 2D convolutional layer followed by a
       non-linearity), to the network.

	   Default values: 'kernel_size=3', 'stride=1',	'dilation=1',  activa-
       tion='leakyrelu'	and 'is_learned=1'.

	 nn_layer_crop:
	     name,in,x0,y0,z0,x1,y1,z1

	   Add a 'crop'	layer to the network.

	 nn_layer_fc:
	     name,in,nb_channels>0,_is_learned={ 0 | 1 }

	   Add a 'fc' layer (fully connected layer) to the network.

	   Default value: 'is_learned=1'.

	 nn_layer_fcbnnl:
	     name,in,nb_neurons>0,_activation,_is_learned={ 0 |	1 }

	   Add	a 'fcbnnl' layer (fully	connected layer	followed by batchnorm,
       then a non-linearity), to the network.

	   Default value: 'activation=leakyrelu' and 'is_learned=1'.

	 nn_layer_fcnl:
	     name,in,nb_neurons>0,_activation,_is_learned={ 0 |	1 }

	   Add a 'fcnl'	layer (fully connected layer followed by a non-linear-
       ity), to	the network.

	   Default value: 'activation=leakyrelu' and 'is_learned=1'.

	 nn_layer_maxpool2d:
	     name,in

	   Add a 'maxpool2d' layer (2d max pooling) to the network.

	 nn_layer_nl:
	     name,in,_activation

	   Add a 'nl' (nonlinearity) layer to the network.
	   'activation'	can be { elu | gelu | leakyrelu	| linear | relu	| sig-
       moid | softmax |	sqr | sqrt | swish | tanh }.

	   Default value: 'activation=leakyrelu'.

	 nn_layer_rename:
	     name,in

	   Add a 'rename' layer	to the network.

	 nn_layer_reshape:
	     name,in,width>0,height>0,depth>0,spectrum>0

	   Add a 'reshape' layer to the	network.

	 nn_layer_resize:
	     name,in,width[%]>0,_height[%]>0,_depth[%]>0,_spectrum[%]>0,_in-
       terpolation

	   Add a 'resize' layer	to the network.

	   Default values: 'height=depth=spectrum=100%'.

	 nn_layer_run:
	     name,in,"command",_width[%]>0,_height[%]>0,_depth[%]>0,_spec-
       trum[%]>0

	   Add a 'run' layer to	the network.

	   Default values: 'width=height=depth=spectrum=100%'.

	 nn_layer_split:
	     name0,name1,in,nb_channels0

	   Add a 'split' layer to the network.

	 nn_loss_bce:
	     name,in,ground_truth

	   Add a 'bce' loss to the network (binary cross entropy).

	 nn_loss_mse:
	     name,in,ground_truth

	   Add a 'mse' loss to the network (mean-squared error).

	 nn_trainer:
	     name,loss,_learning_rate>0,_optimizer,_scheduler

	   Add a network trainer to the	network.
	   'optimizer' can be {	sgd | rmsprop |	adam | adamax }.
	   'scheduler' can be {	constant | linear | exponential	| adaptive }.

	   Default value: 'learning_rate=1e-6',	'optimizer=adam'  and  'sched-
       uler=constant'.

	 nn_load:
	     'filename.gmz'

	   Load	and initialize network saved as	a .gmz file.
	   Neural network files	can be only loaded in .gmz format.

	 nn_save:
	     'filename.gmz'

	   Save	current	network	as a .gmz file.
	   Neural network files	can be only saved in .gmz format.

	 12.15.	Arrays,	Tiles and Frames
		------------------------

	 array:
	     M>0,_N>0,_expand_type={ 0=min | 1=max | 2=all }

	   Create MxN array from selected images.

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

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

	 array_fade:
	     M>0,_N>0,0<=_fade_start<=100,0<=_fade_end<=100,_ex-
       pand_type={0=min	| 1=max	| 2=all}

	   Create MxN array from selected images.

	   Default  values:  'N=M',  'fade_start=60',  'fade_end=90'  and 'ex-
       pand_type=1'.

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

	 array_mirror:
	     N>=0,_dir={ 0=x | 1=y | 2=xy | 3=tri-xy },_expand_type={ 0	| 1 }

	   Create 2^Nx2^N array	from selected images.

	   Default values: 'dir=2' and 'expand_type=0'.

	   Example:
	     [#1] image.jpg array_mirror 2

	 array_random:
	     Ms>0,_Ns>0,_Md>0,_Nd>0

	   Create MdxNd	array of tiles from selected MsxNs source arrays.

	   Default values: 'Ns=Ms', 'Md=Ms' and	'Nd=Ns'.

	   Example:
	     [#1] image.jpg +array_random 8,8,15,10

	 frame:
	     Shortcut for command 'frame_xy'.

	 frame_blur:
	     _sharpness>0,_size>=0,_smoothness,_shading,_blur

	   Draw	RGBA-colored round frame in selected images.

	   Default values: 'sharpness=10', 'size=30',  'smoothness=0',	'shad-
       ing=1' and 'blur=3%'.

	   Example:
	     [#1] image.jpg frame_blur 3,30,8,10%

	 frame_cube:
	     _depth>=0,_centering_x,_centering_y,_left_side={0=normal |	1=mir-
       ror-x | 2=mirror-y | 3=mirror-xy},_right_side,_lower_side,_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_smooth-
       ness[%]>=0,_R,_G,_B,_vignette_size[%]>=0,_vignette_contrast>=0,_de-
       fects_contrast>=0,0<=_defects_density<=100,_defects_size>=0,_de-
       fects_smoothness[%]>=0,
	       _serial_number

	   Add a painting frame	to selected images.

	   Default   values:   'size=10%',   'contrast=0.4',  'profile_smooth-
       ness=6%', 'R=225', 'G=200', 'B=120', 'vignette_size=2%',	'vignette_con-
       trast=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:
	     frame_size[%]>=0,radius[%]>=0,_smoothness[%]>=0,_col1,...,_colN

	   Insert an inner round frame in selected images.

	   Default   values:   'size=1,	  'radius=30%',	  'smoothness=0'   and
       'col=0,0,0,255'.

	 frame_seamless:
	     frame_size>=0,_patch_size>0,_blend_size>=0,_frame_direction={
       0=inner (preserve image size) | 1=outer }

	   Insert frame	in selected images, so that tiling the resulting image
       makes less visible seams.

	   Default values: 'patch_size=7',  'blend_size=5'  and	 'frame_direc-
       tion=1'.

	   Example:
	     [#1] image.jpg +frame_seamless 30 array 2,2

	 frame_x:
	     size_x[%],_col1,...,_colN

	   Insert outer	frame along the	x-axis in selected images.

	   Default values: 'col1=col2=col3=255'	and 'col4=255'.

	   Example:
	     [#1] image.jpg frame_x 20,255,0,255

	 frame_xy:
	     size_x[%],_size_y[%],_col1,...,_colN

	   Insert outer	frame along the	x-axis in selected images.

	   Default    values:	 'size_y=size_x',   'col1=col2=col3=255'   and
       'col4=255'.
	   (equivalent to shortcut command 'frame').

	   Example:
	     [#1] image.jpg frame_xy 1,1,0 frame_xy 20,10,255,0,255

	 frame_xyz:
	     size_x[%],_size_y[%],_size_z[%]_col1,...,_colN

	   Insert outer	frame along the	x-axis in selected images.

	   Default values:  'size_y=size_x=size_z',  'col1=col2=col3=255'  and
       'col4=255'.

	 frame_y:
	     size_y[%],_col1,...,_colN

	   Insert outer	frame along the	y-axis in selected images.

	   Default values: 'col1=col2=col3=255'	and 'col4=255'.

	   Example:
	     [#1] image.jpg frame_y 20,255,0,255

	 img2ascii:
	     _charset,_analysis_scale>0,_analysis_smoothness[%]>=0,_synthe-
       sis_scale>0,_output_ascii_filename

	   Render selected images as binary ascii art.
	   This	 command  returns  the	corresponding  the  list of widths and
       heights (expressed as a number of characters)
	   for each selected image.

	   Default  values:  'charset=[ascii  charset]',  'analysis_scale=16',
       'analysis_smoothness=20%',      'synthesis_scale=16'	and	'_out-
       put_ascii_filename=[undefined]'.

	   Example:
	     [#1] image.jpg img2ascii ,

	 imagegrid:
	     M>0,_N>0

	   Create MxN image grid from selected images.

	   Default value: 'N=M'.

	   Example:
	     [#1] image.jpg imagegrid 16

	 imagegrid_hexagonal:
	     _resolution>0,0<=_outline<=1

	   Create hexagonal grids from selected	images.

	   Default  values:   'resolution=32',	 'outline=0.1'	 and   'is_an-
       tialiased=1'.

	   Example:
	     [#1] image.jpg imagegrid_hexagonal	24

	 imagegrid_triangular:
	     pattern_width>=1,_pattern_height>=1,_pattern_type,0<=_out-
       line_opacity<=1,_outline_color1,...

	   Create triangular grids from	selected images.
	   'pattern  type'  can	 be  { 0=horizontal | 1=vertical | 2=crossed |
       3=cube |	4=decreasing | 5=increasing }.

	   Default values: 'pattern_width=24', 'pattern_height=pattern_width',
       'pattern_type=0', 'outline_opacity=0.1' and 'outline_color1=0'.

	   Example:
	     [#1] image.jpg imagegrid_triangular 6,10,3,0.5

	 linearize_tiles:
	     M>0,_N>0

	   Linearize MxN tiles on selected images.

	   Default value: 'N=M'.

	   Example:
	     [#1] image.jpg +linearize_tiles 16

	 map_sprites:
	     _nb_sprites>=1,_allow_rotation={ 0=none | 1=90 deg. | 2=180  deg.
       }

	   Map	set  of	 sprites (defined as the 'nb_sprites' latest images of
       the selection) to other selected	images,
	   according to	the luminosity of their	pixel values.

	   Example:
	     [#1] image.jpg  resize2dy	48  repeat  16	ball  {8+2*$>},${-rgb}
       mul[-1] {(1+$>)/16} done	map_sprites 16

	 pack:
	     is_ratio_constraint={ 0 | 1 },_sort_criterion

	   Pack	selected images	into a single image.
	   The returned	status contains	the list of new	(x,y) offsets for each
       input image.
	   Parameter  'is_ratio_constraint'  tells if the resulting image must
       tend to a square	image.

	   Default   values:	'is_ratio_constraint=0'	   and	  'sort_crite-
       rion=max(w,h)'.

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

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

	   Input puzzle	binary mask with specified size	and geometry.

	   Default values: 'width=height=512', 'M=N=5',	'curvature=0.5', 'cen-
       tering=0.5', 'connectors_variability=0.5' and 'resolution=64'.

	   Example:
	     [#1] puzzle ,

	 quadratize_tiles:
	     M>0,_N>0

	   Quadratize MxN tiles	on selected images.

	   Default value: 'N=M'.

	   Example:
	     [#1] image.jpg +quadratize_tiles 16

	 rotate_tiles:
	     angle,_M>0,N>0

	   Apply MxN tiled-rotation effect on selected images.

	   Default values: 'M=8' and 'N=M'.

	   Example:
	     [#1] image.jpg to_rgba rotate_tiles 10,8 drop_shadow  10,10  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',	 'bor-
       der_outline=0' and 'remove_tile=0'.

	   Example:
	     [#1] image.jpg +taquin 8

	 tunnel:
	     _level>=0,_factor>0,_centering_x,_centering_y,_opacity,_angle

	   Apply tunnel	effect on selected images.

	   Default   values:   'level=9',  'factor=80%',  'centering_x=center-
       ing_y=0.5', 'opacity=1' and 'angle=0'

	   Example:
	     [#1] image.jpg tunnel 20

	 12.16.	Artistic
		--------

	 boxfitting:
	     _min_box_size>=1,_max_box_size>=0,_initial_density>=0,_min_spac-
       ing>0

	   Apply box fitting effect on selected	images,	as displayed  the  web
       page:
	   http://www.complexification.net/gallery/machines/boxFittingImg/.

	   Default  values:  'min_box_size=1', 'max_box_size=0', 'initial_den-
       sity=0.25' and 'min_spacing=1'.

	   Example:
	     [#1] image.jpg boxfitting ,

	 brushify:
	     [brush],_brush_nb_sizes>=1,0<=_brush_min_size_fac-
       tor<=1,_brush_nb_orienta-
       tions>=1,_brush_light_type,0<=_brush_light_strength<=1,_brush_opac-
       ity,_painting_density[%]>=0,0<=_painting_contours_coherence<=1,
	       0<=_painting_orientation_coherence<=1,_painting_coherence_al-
       pha[%]>=0,_painting_coherence_sigma[%]>=0,_painting_primary_an-
       gle,0<=_painting_angle_dispersion<=1

	   Apply specified brush to create painterly versions of specified 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_coherence=0.9',	 'painting_coherence_alpha=1',
       'painting_coherence_sigma=1',
	    'painting_primary_angle=0',	'painting_angle_dispersion=0.2'

	   Example:
	     [#1]   image.jpg	40,40	gaussian[-1]   10,4   spread[-1]  10,0
       brushify[0] [1],1

	 cartoon:
	     _smoothness,_sharpening,_threshold>=0,_thick-
       ness>=0,_color>=0,quantization>0

	   Apply cartoon effect	on selected images.

	   Default values: 'smoothness=3',  'sharpening=150',  'threshold=20',
       'thickness=0.25', 'color=1.5' and 'quantization=8'.

	   Example:
	     [#1] image.jpg cartoon 3,50,10,0.25,3,16

	 color_ellipses:
	     _count>0,_radius>=0,_opacity>=0

	   Add random color ellipses to	selected images.

	   Default values: 'count=400',	'radius=5' and 'opacity=0.1'.

	   Example:
	     [#1] image.jpg +color_ellipses ,,0.15

	 cubism:
	     _density>=0,0<=_thickness<=50,_max_angle,_opacity,_smoothness>=0

	   Apply cubism	effect on selected images.

	   Default   values:   'density=50',  'thickness=10',  'max_angle=75',
       'opacity=0.7' and 'smoothness=0'.

	   Example:
	     [#1] image.jpg cubism ,

	 draw_whirl:
	     _amplitude>=0

	   Apply whirl drawing effect on selected images.

	   Default value: 'amplitude=100'.

	   Example:
	     [#1] image.jpg draw_whirl ,

	 drawing:
	     _amplitude>=0

	   Apply drawing effect	on selected images.

	   Default value: 'amplitude=200'.

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

	 drop_shadow:
	     _offset_x[%],_offset_y[%],_smoothness[%]>=0,0<=_curvature<=1,_ex-
       pand_size={ 0 | 1 }

	   Drop	shadow behind selected images.

	   Default values: 'offset_x=20', 'offset_y=offset_x', 'smoothness=5',
       'curvature=0' and 'expand_size=1'.

	   Example:
	     [#1]  image.jpg  drop_shadow  10,20,5,0.5	expand_xy  20,0	  dis-
       play_rgba

	 ellipsionism:
	     _R>0[%],_r>0[%],_smoothness>=0[%],_opacity,_outline>0,_density>0

	   Apply ellipsionism filter to	selected images.

	   Default  values:  'R=10',  'r=3',  'smoothness=1%',	'opacity=0.7',
       'outline=8' and 'density=0.6'.

	   Example:
	     [#1] image.jpg ellipsionism ,

	 fire_edges:
	     _edges>=0,0<=_attenuation<=1,_smoothness>=0,_thresh-
       old>=0,_nb_frames>0,_starting_frame>=0,frame_skip>=0

	   Generate fire effect	from edges of selected images.

	   Default values: 'edges=0.7',	'attenuation=0.25',  'smoothness=0.5',
       'threshold=25', 'nb_frames=1', 'starting_frame=20' and 'frame_skip=0'.

	   Example:
	     [#1] image.jpg fire_edges ,

	 fractalize:
	     0<=detail_level<=1

	   Randomly fractalize selected	images.

	   Default value: 'detail_level=0.8'

	   Example:
	     [#1] image.jpg fractalize ,

	 glow:
	     _amplitude>=0

	   Add soft glow on selected images.

	   Default value: 'amplitude=1%'.

	   Example:
	     [#1] image.jpg glow ,

	 halftone:
	     nb_levels>=2,_size_dark>=2,_size_bright>=2,_shape={   0=square  |
       1=diamond | 2=circle |  3=inv-square  |	4=inv-diamond  |  5=inv-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 done

	 hearts:
	     _density>=0

	   Apply heart effect on selected images.

	   Default value: 'density=10'.

	   Example:
	     [#1] image.jpg hearts ,

	 houghsketchbw:
	     _density>=0,_radius>0,0<=_threshold<=100,0<=_opacity<=1,_vote-
       size[%]>0

	   Apply hough B&W sketch effect on selected images.

	   Default values: 'density=100', 'radius=3', 'threshold=100',	'opac-
       ity=0.1'	and 'votesize=100%'.

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

	 lightrays:
	     100<=_density<=0,_center_x[%],_cen-
       ter_y[%],_ray_length>=0,_ray_attenuation>=0

	   Generate ray	lights from the	edges of selected images.

	   Default   values:  'density=50%',  'center_x=50%',  'center_y=50%',
       'ray_length=0.9'	and 'ray_attenuation=0.5'.

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

	 light_relief:
	     _ambient_light,_specular_lightness,_specular_size,_dark-
       ness,_light_smoothness,_xl,_yl,_zl,_zscale,_opacity_is_heightmap={ 0  |
       1 }

	   Apply relief	light to selected images.
	   Default  values(s) :	'ambient_light=0.3', 'specular_lightness=0.5',
       'specular_size=0.2', 'darkness=0', 'xl=0.2', 'yl=zl=0.5',
	   'zscale=1', 'opacity=1' and 'opacity_is_heightmap=0'.

	   Example:
	     [#1] image.jpg blur 2 light_relief	0.3,4,0.1,0

	 linify:
	     0<=_density<=100,_spreading>=0,_resolution[%]>0,_line_opac-
       ity>=0,_line_precision>0,_mode={	0=subtractive |	1=additive }

	   Apply linify	effect on selected images.
	   The algorithm is inspired from the one  described  on  the  webpage
       http://linify.me/about.

	   Default   values:  'density=50',  'spreading=2',  'resolution=40%',
       'line_opacity=10', 'line_precision=24' and 'mode=0'.

	   Example:
	     [#1] image.jpg linify 60

	 mosaic:
	     0<=_density<=100

	   Create random mosaic	from selected images.

	   Default values: 'density=30'.

	   Example:
	     [#1] image.jpg mosaic , +fill "I!=J(1) || I!=J(0,1)?[0,0,0]:I"

	 old_photo:

	   Apply old photo effect on selected images.

	   Example:
	     [#1] image.jpg old_photo

	 pencilbw:
	     _size>=0,_amplitude>=0

	   Apply B&W pencil effect on selected images.

	   Default values: 'size=0.3' and 'amplitude=60'.

	   Example:
	     [#1] image.jpg pencilbw ,

	 pixelsort:
	     _ordering={ + | - },_axis={ x | y | z | xy	| yx  },_[sorting_cri-
       terion],_[mask]

	   Apply  a 'pixel sorting' algorithm on selected images, as described
       in the page :
	   http://satyarth.me/articles/pixel-sorting/.

	   Default  values:   'ordering=+',   'axis=x'	 and   'sorting_crite-
       rion=mask=(undefined)'.

	   Example:
	     [#1] image.jpg +norm +ge[-1] 30% +pixelsort[0] +,y,[1],[2]

	 polaroid:
	     _size1>=0,_size2>=0

	   Create polaroid effect in selected images.

	   Default values: 'size1=10' and 'size2=20'.

	   Example:
	     [#1]  image.jpg  to_rgba  polaroid	 5,30  rotate 20 drop_shadow ,
       drgba

	 polygonize:
	     _warp_amplitude>=0,_smoothness[%]>=0,_min_area[%]>=0,_resolu-
       tion_x[%]>0,_resolution_y[%]>0

	   Apply polygon effect	on selected images.

	   Default     values:	   'warp_amplitude=300',      'smoothness=2%',
       'min_area=0.1%',	'resolution_x=resolution_y=10%'.

	   Example:
	     [#1]  image.jpg  image.jpg	 polygonize  100,10  +fill "I!=J(1) ||
       I!=J(0,1)?[0,0,0]:I"

	 poster_edges:
	     0<=_edge_threshold<=100,0<=_edge_shade<=100,_edge_thick-
       ness>=0,_edge_antialiasing>=0,0<=_posterization_level<=15,_posteriza-
       tion_antialiasing>=0

	   Apply poster	edges effect on	selected images.

	   Default values: 'edge_threshold=40',	 'edge_shade=5',  'edge_thick-
       ness=0.5',  'edge_antialiasing=10',  'posterization_level=12' and 'pos-
       terization_antialiasing=0'.

	   Example:
	     [#1] image.jpg poster_edges ,

	 poster_hope:
	     _smoothness>=0

	   Apply Hope stencil poster effect on selected	images.

	   Default value: 'smoothness=3'.

	   Example:
	     [#1] image.jpg poster_hope	,

	 rodilius:
	     0<=_amplitude<=100,_0<=thickness<=100,_sharpness>=0,_nb_orienta-
       tions>0,_offset,_color_mode={ 0=darker |	1=brighter }

	   Apply rodilius (fractalius-like) filter on selected images.

	   Default values:  'amplitude=10',  'thickness=10',  'sharpness=400',
       'nb_orientations=7', 'offset=0' and 'color_mode=1'.

	   Example:
	     [#1] image.jpg rodilius 12,10,300,10 normalize_local 10,6
	     [#2]  image.jpg normalize_local 10,16 rodilius 10,4,400,16	smooth
       60,0,1,1,4 normalize_local 10,16

	 sketchbw:
	     _nb_angles>0,_start_angle,_angle_range>=0,_length>=0,_thresh-
       old>=0,_opacity,_bgfactor>=0,_density>0,_sharp-
       ness>=0,_anisotropy>=0,_smoothness>=0,_coherence>=0,_is_boost={ 0  |  1
       },_is_curved={ 0	| 1 }

	   Apply sketch	effect to selected images.

	   Default values: 'nb_angles=2', 'start_angle=45', 'angle_range=180',
       'length=30',   'threshold=3',   'opacity=0.03',	 'bgfactor=0',	 'den-
       sity=0.6',
	    'sharpness=0.1',  'anisotropy=0.6',	  'smoothness=0.25',   'coher-
       ence=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,_fi-
       delity_smoothness_finest>=0,_fidelity_smoothnes_coarsest>=0,0<=_fi-
       delity_chroma<=1,_init_type,_init_resolution>=0,init_max_gradient>=0,
	       _patchsize_analysis>0,_patchsize_synthesis>0,_patchsize_synthe-
       sis_final>0,_nb_matches_finest>=0,_nb_matches_coarsest>=0,_penal-
       ize_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',  'fi-
       delity_smoothness_finest=3',  'fidelity_smoothness_coarsest=0.5',  'fi-
       delity_chroma=0.1',
	    'init_type=0',    'init_resolution=16',	'init_max_gradient=0',
       'patchsize_analysis=5',	 'patchsize_synthesis=5',   'patchsize_synthe-
       sis_final=5',
	    'nb_matches_finest=2', 'nb_matchesc_coarsest=30',  'penalize_repe-
       titions=2',	   'matching_precision=2',	  'scale_factor=1.85',
       'skip_finest_scales=0' and
	    'image_matching_command'="s	c,-3 transfer_pca[0] [2] b[0,2]	xy,0.7
       n[0,2] 0,255 n[1,2] 0,200 a[0,1]	c a[1,2] c"'.

	 tetris:
	     _scale>0

	   Apply tetris	effect on selected images.

	   Default value: 'scale=10'.

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

	 warhol:
	     _M>0,_N>0,_smoothness>=0,_color>=0

	   Create MxN Andy Warhol-like artwork from selected images.

	   Default values: 'M=3', 'N=M', 'smoothness=2'	and 'color=20'.

	   Example:
	     [#1] image.jpg warhol 3,3,3,40

	 weave:
	     _density>=0,0<=_thickness<=100,0<=_shadow<=100,_shad-
       ing>=0,_fibers_amplitude>=0,_fibers_smoothness>=0,_angle,-1<=_x_curva-
       ture<=1,-1<=_y_curvature<=1

	   Apply weave effect to the selected images.
	   'angle' can be { 0=0	deg. | 1=22.5 deg. | 2=45 deg. |  3=67.5  deg.
       }.

	   Default  values:  'density=6',  'thickness=65', 'shadow=40',	'shad-
       ing=0.5', 'fibers_amplitude=0', _'fibers_smoothness=0', 'angle=0' and
	    'curvature_x=curvature_y=0'

	   Example:
	     [#1] image.jpg weave ,

	 whirls:
	     _texture>=0,_smoothness>=0,_darkness>=0,_lightness>=0

	   Add random whirl texture to selected	images.

	   Default values:  'texture=3',  'smoothness=6',  'darkness=0.5'  and
       '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=3'.

	   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}

	   Apply flower	deformation on selected	images.

	   Default  values:  'amplitude=30', 'frequency=6', 'offset_r=0', 'an-
       gle=0', 'center_x=center_y=50%' and 'boundary_conditions=3'.

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

	 kaleidoscope:
	     _center_x[%],_center_y[%],_radius,_angle,_boundary_conditions={
       0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	   Create kaleidoscope effect from selected images.

	   Default values: 'center_x=center_y=50%',  'radius=100',  'angle=30'
       and 'boundary_conditions=3'.

	   Example:
	     [#1] image.jpg kaleidoscope ,

	 map_sphere:
	     _width>0,_height>0,_radius,_dilation>0,_fading>=0,_fad-
       ing_power>=0

	   Map selected	images on a sphere.

	   Default  values:  'width=height=512', 'radius=100', 'dilation=0.5',
       'fading=0' and 'fading_power=0.5'.

	   Example:
	     [#1] image.jpg map_sphere ,

	 nadirzenith2equirectangular:

	   Transform selected nadir/zenith rectilinear projections to equirec-
       tangular	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=3'.

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

	 raindrops:
	     _amplitude,_density>=0,_wavelength>=0,_merging_steps>=0

	   Apply raindrops deformation on selected images.

	   Default  values:  'amplitude=80','density=0.1',  'wavelength=1' and
       'merging_steps=0'.

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

	 ripple:
	     _amplitude,_bandwidth,_shape={ 0=block | 1=triangle  |  2=sine  |
       3=sine+ | 4=random },_angle,_offset

	   Apply ripple	deformation on selected	images.

	   Default  values:  'amplitude=10',  'bandwidth=10',  'shape=2', 'an-
       gle=0' and 'offset=0'.

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

	 rotoidoscope:
	     _center_x[%],_center_y[%],_tiles>0,_smoothness[%]>=0,_bound-
       ary_conditions={	0=dirichlet | 1=neumann	| 2=periodic | 3=mirror	}

	   Create rotational kaleidoscope effect from selected images.

	   Default values: 'center_x=center_y=50%', 'tiles=10',	'smoothness=1'
       and 'boundary_conditions=3'.

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

	 spherize:
	     _radius[%]>=0,_strength,_smoothness[%]>=0,_center_x[%],_cen-
       ter_y[%],_ratio_x/y>0,_angle,_interpolation

	   Apply spherize effect on selected images.

	   Default values: 'radius=50%', 'strength=1',	'smoothness=0',	 'cen-
       ter_x=center_y=50%', 'ratio_x/y=1', 'angle=0' and 'interpolation=1'.

	   Example:
	     [#1] image.jpg grid 5%,5%,0,0,0.6,255 spherize ,

	 symmetrize:
	     _x[%],_y[%],_angle,_boundary_conditions={ 0=dirichlet | 1=neumann
       |  2=periodic | 3=mirror	},_is_antisymmetry={ 0 | 1 },_swap_sides={ 0 |
       1 }

	   Symmetrize selected images regarding	specified axis.

	   Default  values:  'x=y=50%',	 'angle=90',  'boundary_conditions=3',
       'is_antisymmetry=0' and 'swap_sides=0'.

	   Example:
	     [#1] image.jpg +symmetrize	50%,50%,45 +symmetrize[-1] 50%,50%,-45

	 transform_polar:
	     "expr_radius",_"expr_angle",_center_x[%],_center_y[%],_bound-
       ary_conditions={	0=dirichlet | 1=neumann	| 2=periodic | 3=mirror	}

	   Apply  user-defined	transform  on polar representation of selected
       images.

	   Default values: 'expr_radius=R-r', 'expr_rangle=a',	'center_x=cen-
       ter_y=50%' and 'boundary_conditions=3'.

	   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  'bound-
       ary_conditions=3'.

	   Example:
	     [#1] image.jpg twirl 0.6

	 warp_perspective:
	     _x-angle,_y-angle,_zoom>0,_x-center,_y-center,_boundary_condi-
       tions={ 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

	   Warp	selected images	with perspective deformation.

	   Default  values: 'x-angle=1.5', 'y-angle=0',	'zoom=1', 'x-center=y-
       center=50' and 'boundary_conditions=2'.

	   Example:
	     [#1] image.jpg warp_perspective ,

	 water:
	     _amplitude,_smoothness>=0,_angle

	   Apply water deformation on selected images.

	   Default values: 'amplitude=30', 'smoothness=1.5' and	'angle=45'.

	   Example:
	     [#1] image.jpg water ,

	 wave:
	     _amplitude>=0,_frequency>=0,_center_x,_center_y

	   Apply wave deformation on selected images.

	   Default values: 'amplitude=4', 'frequency=0.4'  and	'center_x=cen-
       ter_y=50'.

	   Example:
	     [#1] image.jpg wave ,

	 wind:
	     _amplitude>=0,_angle,0<=_attenuation<=1,_threshold

	   Apply wind effect on	selected images.

	   Default  values:  'amplitude=20',  'angle=0', 'attenuation=0.7' and
       'threshold=20'.

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

	 zoom:
	     _factor,_cx,_cy,_cz,_boundary_conditions={	0=dirichlet  |	1=neu-
       mann | 2=periodic | 3=mirror }

	   Apply zoom factor to	selected images.

	   Default  values:  'factor=1',  'cx=cy=cz=0.5'  and 'boundary_condi-
       tions=0'.

	   Example:
	     [#1] image.jpg +zoom[0] 0.6 +zoom[0] 1.5

	 12.18.	Degradations
		------------

	 cracks:
	     0<=_density<=100,_is_relief={ 0 | 1 },_opacity,_color1,...

	   Draw	random cracks on selected images with specified	color.

	   Default  values:  'density=25',  'is_relief=0',   'opacity=1'   and
       'color1=0'.

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

	 light_patch:
	     _density>0,_darkness>=0,_lightness>=0

	   Add light patches to	selected images.

	   Default values: 'density=10', 'darkness=0.9'	and 'lightness=1.7'.

	   Example:
	     [#1] image.jpg +light_patch 20,0.9,4

	 noise_hurl:
	     _amplitude>=0

	   Add hurl noise to selected images.

	   Default value: 'amplitude=10'.

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

	 pixelize:
	     _scale_x>0,_scale_y>0,_scale_z>0

	   Pixelize selected images with specified scales.

	   Default values: 'scale_x=20'	and 'scale_y=scale_z=scale_x'.

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

	 scanlines:
	     _amplitude,_bandwidth,_shape={  0=block  |	 1=triangle | 2=sine |
       3=sine+ | 4=random },_angle,_offset

	   Apply ripple	deformation on selected	images.

	   Default values: 'amplitude=60', 'bandwidth=2', 'shape=0', 'angle=0'
       and 'offset=0'.

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

	 shade_stripes:
	     _frequency>=0,_direction={	 0=horizontal  |  1=vertical  },_dark-
       ness>=0,_lightness>=0

	   Add shade stripes to	selected images.

	   Default  values:  'frequency=5',  'direction=1', 'darkness=0.8' and
       'lightness=2'.

	   Example:
	     [#1] image.jpg +shade_stripes 30

	 shadow_patch:
	     _opacity>=0

	   Add shadow patches to selected images.

	   Default value: 'opacity=0.7'.

	   Example:
	     [#1] image.jpg +shadow_patch 0.4

	 spread:
	     _dx>=0,_dy>=0,_dz>=0

	   Spread pixel	values of selected images randomly along x,y and z.

	   Default values: 'dx=3', 'dy=dx' and 'dz=0'.

	   Example:
	     [#1] image.jpg +spread 3

	 stripes_y:
	     _frequency>=0

	   Add vertical	stripes	to selected images.

	   Default value: 'frequency=10'.

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

	 texturize_canvas:
	     _amplitude>=0,_fibrousness>=0,_emboss_level>=0

	   Add paint canvas texture to selected	images.

	   Default   values:   'amplitude=20',	 'fibrousness=3'   and	  'em-
       boss_level=0.6'.

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

	 texturize_paper:

	   Add paper texture to	selected images.

	   Example:
	     [#1] image.jpg +texturize_paper

	 vignette:
	     _strength>=0,0<=_radius_min<=100,0<=_radius_max<=100

	   Add vignette	effect to selected images.

	   Default    values:	'strength=100',	  'radius_min=70'   and	  'ra-
       dius_max=90'.

	   Example:
	     [#1] image.jpg vignette ,

	 watermark_visible:
	     _text,0<_opacity<1,_size>0,_angle,_mode={	 0=remove   |	 1=add
       },_smoothness>=0

	   Add	or  remove a visible watermark on selected images (value range
       must be [0,255]).

	   Default values: 'text=(c) G'MIC',  'opacity=0.3',  'size=53',  'an-
       gle=25',	'mode=1' and 'smoothness=0'.

	   Example:
	     [#1] image.jpg watermark_visible ,0.7

	 12.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 |
	   screen | seamless | seamless_mixed |	shapeareamax | shapeareamax0 |
       shapeareamin | shapeareamin0 |
	   shapeaverage	  |  shapeaverage0  |  shapemedian  |  shapemedian0  |
       shapemin	| shapemin0 | shapemax | shapemax0 |
	   softburn | softdodge	| softlight |  stamp  |	 subtract  |  value  |
       vividlight | xor	}.
	   'opacity' must be in	range '[0,1]' (or '[0%,100%]').

	   Default  values:  'blending_mode=alpha',  'opacity=1'  and  'selec-
       tion_is=0'.

	   Example:
	     [#1] image.jpg +drop_shadow ,  resize2dy[-1]  200	rotate[-1]  20
       +blend alpha display_rgba[-2]
	     [#2] image.jpg testimage2d	{w},{h}	blend overlay
	     [#3]  command  "ex	: $""=arg repeat $""# +blend[0,1] ${arg{$>+1}}
       text_outline[-1]	Mode:
	     [#4] command "ex :	$""=arg	repeat $""#  +blend[0,1]  ${arg{$>+1}}
       text_outline[-1]	Mode:
	      grainextract,grainmerge
	     [#5]  command  "ex	: $""=arg repeat $""# +blend[0,1] ${arg{$>+1}}
       text_outline[-1]	Mode:
	      lighten,lightness
	     [#6] command "ex :	$""=arg	repeat $""#  +blend[0,1]  ${arg{$>+1}}
       text_outline[-1]	Mode:
	      negation,or,overlay
	     [#7]  command  "ex	: $""=arg repeat $""# +blend[0,1] ${arg{$>+1}}
       text_outline[-1]	Mode:
	      shapeaverage,softburn
	     [#8] command "ex :	$""=arg	repeat $""#  +blend[0,1]  ${arg{$>+1}}
       text_outline[-1]	Mode:
	      vividlight,xor

	 blend:
	     [layer],blending_mode,_opacity[%],_selection_is={ 0=base-layers |
       1=top-layers } |
	     blending_mode,_opacity[%]

	 blend_edges:
	     smoothness[%]>=0

	   Blend selected images togethers using 'edges' mode.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+blend_edges 0.8

	 blend_fade:
	     [fading_shape]

	   Blend selected images together using	specified fading shape.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	100%,100%,1,1,'cos(y/10)' nor-
       malize[-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_fad-
       ing=100%'.

	 fade_diamond:
	     0<=_start<=100,0<=_end<=100

	   Create diamond fading from selected images.

	   Default values: 'start=80' and 'end=90'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+fade_diamond 80,85

	 fade_linear:
	     _angle,0<=_start<=100,0<=_end<=100

	   Create linear fading	from selected images.

	   Default values: 'angle=45', 'start=30' and 'end=70'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+fade_linear 45,48,52

	 fade_radial:
	     0<=_start<=100,0<=_end<=100

	   Create radial fading	from selected images.

	   Default values: 'start=30' and 'end=70'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+fade_radial 30,70

	 fade_x:
	     0<=_start<=100,0<=_end<=100

	   Create horizontal fading from selected images.

	   Default values: 'start=30' and 'end=70'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+fade_x	30,70

	 fade_y:
	     0<=_start<=100,0<=_end<=100

	   Create vertical fading from selected	images.

	   Default values: 'start=30' and 'end=70'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+fade_y	30,70

	 fade_z:
	     0<=_start<=100,0<=_end<=100

	   Create transversal fading from selected images.

	   Default values: 'start=30' and 'end=70'.

	 sub_alpha:
	     [base_image],_opacity_gain>=1

	   Compute  the	 minimal  alpha-channel	 difference (opposite of alpha
       blending) between the selected images
	   and the specified base image.
	   The alpha difference	A-B is defined as  the	image  having  minimal
       opacity,	such that alpha_blend(B,A-B) = A.

	   Default value: 'opacity_gain=1'.

	   Example:
	     [#1] image.jpg testimage2d	{w},{h}	+sub_alpha[0] [1] display_rgba

	 12.20.	Image Sequences	and Videos
		--------------------------

	 animate:
	     fil-
       ter_name,"param1_start,...,paramN_start","param1_end,...,paramN_end",nb_frames>=0,_out-
       put_frames={ 0 |	1 },_output_filename |
	     delay>0,_back and forth={ 0 | 1 }

	   Animate filter from starting	parameters to ending parameters	or 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',  'preci-
       sion=4',	 'first_frame=0',  'last_frame=-1',  'frame_step=1'  and 'out-
       put_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,_preci-
       sion>=0,_first_frame>=0,_last_frame={	   >=0	      |	       -1=last
       },_frame_step>=1,_output_filename

	   Generate  a temporal	morphing from specified	input video file, in a
       streamed	way.
	   If a	display	window is opened, rendered frames are displayed	in  it
       during processing.
	   The output filename may have	extension '.avi' 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',  'preci-
       sion=4',	'first_frame=0',  'last_frame=-1',  'frame_step=1'  and	 'out-
       put_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_an-
       tialias={ 0 | 1 }

	   Create 3D transition	sequence between selected consecutive images.
	   'axis_x',  'axis_y' and 'axis_z' can	be set as mathematical expres-
       sions, depending	on 'x' and 'y'.

	   Default    values:	  'nb_frames=10',     'nb_xtiles=nb_ytiles=3',
       'axis_x=1', 'axis_y=1', 'axis_z=0' and 'is_antialias=1'.

	   Example:
	     [#1] image.jpg +blur 5 transition3d 9 display_rgba

	 video2files:
	     input_filename,_output_filename,_first_frame>=0,_last_frame={ >=0
       | -1=last },_frame_step>=1

	   Split  specified  input  video  file	into image files, one for each
       frame.
	   First and last frames as well as step between frames	can be	speci-
       fied.

	   Default   values:   'output_filename=frame.png',   'first_frame=0',
       'last_frame=-1' and 'frame_step=1'.

	 12.21.	Convenience Functions
		---------------------

	 alert:
	     _title,_message,_label_button1,_label_button2,...

	   Display an alert box	and wait for user's choice.
	   If a	single image is	in the selection, it is	used as	 an  icon  for
       the alert box.

	   Default values: 'title=[G'MIC Alert]' and 'message=This is an alert
       box.'.

	 arg:
	     n>=1,_arg1,...,_argN

	   Return the n-th argument of the specified argument list.

	 arg0:
	     n>=0,_arg0,...,_argN

	   Return  the n-th argument of	the specified argument list (where 'n'
       starts from '0').

	 arg2img:
	     argument_1,...,argument_N

	   Split specified list	of arguments and return	each as	 a  new	 image
       (as a null-terminated string).

	 arg2var:
	     variable_name,argument_1,...,argument_N

	   For each i in [1...N], set 'variable_name$i=argument_i'.
	   The	variable  name	should	be  global to make this	command	useful
       (i.e. starts by an underscore).

	 autocrop_coords:
	     value1,value2,... | auto

	   Return coordinates (x0,y0,z0,x1,y1,z1) of the autocrop  that	 could
       be performed on the latest
	   of the selected images.

	   Default value: 'auto'

	 average_vectors:

	   Return  the vector-valued average of	the latest of the selected 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'.

	 base642uint8:
	     "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
       'uint82base64'.

	 basename:
	     file_path,_variable_name_for_folder

	   Return the basename of a file path, and opt.	its folder location.
	   When	specified 'variable_name_for_folder' must starts by an	under-
       score
	   (global variable accessible from calling function).

	 bin:
	     binary_int1,...

	   Print specified binary integers into	their octal, decimal, hexadec-
       imal and	string representations.

	 bin2dec:
	     binary_int1,...

	   Convert  specified  binary  integers	into their decimal representa-
       tions.

	 covariance_vectors:
	     _avg_outvarname

	   Return the covariance matrix	of the	vector-valued  colors  in  the
       latest of the selected images
	   (for	arbitrary number of channels).
	   Parameter  'avg_outvarname'	is  used as a variable name that takes
       the value of the	average	vector-value.

	 dec:
	     decimal_int1,...

	   Print specified decimal integers into their binary, octal, 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'.

	 files2img:
	     _mode,path

	   Insert  a  new image	where each vector-valued pixel is a string en-
       coding the filenames returned by	command	files.
	   Useful to manage list of filenames containing characters that  have
       a special meaning in the	G'MIC language,such as spaces or commas.

	 fitratio_wh:
	     min_width,min_height,ratio_wh

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

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

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

	   Default   values:   'depth=1',   'minimal_size=128'	 and	'maxi-
       mal_size=85%'.

	 fontchart:

	   Insert G'MIC	font chart at the end of the image list.

	   Example:
	     [#1] fontchart

	 fps:

	   Return the number of	time this function is called per second, or -1
       if this info is not yet available.
	   Useful to display the framerate when	displaying animations.

	 gcd:
	     a,b

	   Return the GCD (greatest common divisor) between a and b.

	 hex:
	     hexadecimal_int1,...

	   Print specified hexadecimal integers	into their binary, octal, dec-
       imal and	string representations.

	 hex2dec:
	     hexadecimal_int1,...

	   Convert specified hexadecimal integers into their decimal represen-
       tations.

	 hex2img:
	     "hexadecimal_string"

	   Insert  new	image 1xN at the end of	the list with values specified
       by the given hexadecimal-encoded	string.

	 hex2str:
	     hexadecimal_string

	   Convert specified hexadecimal string	into a string.
	   See also: str2hex.

	 img2base64:
	     _encoding={ 0=base64 | 1=base64url	},_store_names={ 0 | 1 }

	   Encode selected images as a base64-encoded string.
	   The images can be then decoded using	command	'base642img'.

	   Default values: 'encoding=0'	and 'store_names=1'.

	 img2hex:

	   Return representation  of  last  image  as  an  hexadecimal-encoded
       string.
	   Input image must have values	that are integers in [0,255].

	 img2str:

	   Return  the	content	of the latest of the selected images as	a spe-
       cial G'MIC input	string.

	 img2text:
	     _line_separator

	   Return text contained in a multi-line image.

	   Default value: 'line_separator= '.

	 img82hex:

	   Convert selected 8bits-valued vectors into their hexadecimal	repre-
       sentations (ascii-encoded).

	 hex2img8:

	   Convert selected hexadecimal	representations	 (ascii-encoded)  into
       8bits-valued vectors.

	 is_3d:

	   Return 1 if all of the selected images are 3D objects, 0 otherwise.

	 is_change:
	     _value={ 0=false |	1=true }

	   Set or unset	the 'is_change'	flag associated	to the image list.
	   This	 flag  tells  the  interpreter	whether	 or not	the image list
       should be displayed when	the pipeline ends.

	   Default value: 'value=1'.

	 is_half:

	   Return 1 if the type	of image pixels	is limited to half-float.

	 is_ext:
	     filename,_extension

	   Return 1 if specified filename has a	given extensioin.

	 is_image_arg:
	     string

	   Return 1 if specified string	looks like '[ind]'.

	 is_pattern:
	     string

	   Return  1  if  specified  string  looks  like  a  drawing   pattern
       '0x......'.

	 is_percent:
	     string

	   Return 1 if specified string	ends with a '%', 0 otherwise.

	 is_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_vectors:

	   Return the median vector value of the last selected	image  (median
       computed	channel	by channel)

	 min_w:

	   Return the minimal width between selected images.

	 min_h:

	   Return the minimal height between selected images.

	 min_d:

	   Return the minimal depth between selected images.

	 min_s:

	   Return the minimal s	size of	selected images.

	 min_wh:

	   Return the minimal wxh size of selected images.

	 min_whd:

	   Return the minimal wxhxd size of selected images.

	 min_whds:

	   Return the minimal wxhxdxs size of selected images.

	 nmd (+):
	     Shortcut for command 'named'.

	 named (+):
	     _mode,"name1","name2",...

	   Return  the set of indices corresponding to images of the selection
       with specified names.
	   After this command returns, the status contains a list  of  indices
       (unsigned integers),
	   separated  by  commas  (or  an empty	string if no images with those
       names have been found).
	   (equivalent to shortcut command 'nmd').

	   'mode' can be { 0=all indices (default) | 1=lowest index |  2=high-
       est index | 3 = all indices (case insensitive) |	4 = lowest index (case
       insensitive) | 5	= highest index	(case insensitive)}

	 normalize_filename:
	     filename

	   Return  a  "normalized"  version of the specified filename, without
       spaces and capital letters.

	 oct:
	     octal_int1,...

	   Print specified octal integers into their binary, decimal, hexadec-
       imal and	string representations.

	 oct2dec:
	     octal_int1,...

	   Convert specified octal integers  into  their  decimal  representa-
       tions.

	 padint:
	     number,_size>0

	   Return  a  integer  with 'size' digits (eventually left-padded with
       '0').

	 path_cache:

	   Return a path to store G'MIC	data files for one user	 (whose	 value
       is OS-dependent).

	 path_current:

	   Return current folder from where G'MIC has been run.

	 path_gimp:

	   Return a path to store GIMP configuration files for one user	(whose
       value is	OS-dependent).

	 path_tmp:

	   Return  a  path  to store temporary files (whose value is OS-depen-
       dent).

	 remove_copymark:
	     "image_name"

	   Remove copy mark from names of selected images.

	 reset:

	   Reset global	parameters of the interpreter environment.

	 rgb:

	   Return a random int-valued RGB color.

	 rgba:

	   Return a random int-valued RGBA color.

	 shell_cols:

	   Return the estimated	number of columns of the current shell.

	 size_value:

	   Return the size (in bytes) of image values.

	 std_noise:

	   Return the estimated	noise standard deviation of the	last  selected
       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,_prerelease

	   Return the specified	version	number of the G'MIC interpreter, as  a
       string.

	   Default value: 'version=$_version' and 'prerelease='.

	 tic:

	   Initialize tic-toc timer.
	   Use it in conjunction with 'toc'.

	 toc:

	   Display  elapsed  time  of the tic-toc timer	since the last call to
       'tic'.
	   This	command	returns	the elapsed time in the	status value.
	   Use it in conjunction with 'tic'.

	 to_clutname:
	     "string"

	   Return simplified name that can be used as a	CLUT name, from	speci-
       fied input string.

	 uint82base64:
	     _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 'base642uint8'.
	   Selected images must	have values that are integers in [0,255].

	   Default values: 'encoding=0'.

	 12.22.	Other Interactive Commands
		--------------------------

	 demos:
	     _run_in_parallel={	0=no | 1=yes | 2=auto }

	   Show	a menu to select and view all G'MIC interactive	demos.

	 tixy:
	     "expression"

	   Animate specified mathematical expression with a 16x16 grid of 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 with-
       out opening interactive windows.

	   Default value: 'colorspace=rgb'.

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

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

	   Default  values:  'is_lineart=1', 'max_resolution=1024' and 'multi-
       channels_output=0'.

	 x_connect4:

	   Launch the Connect Four game.

	 xz:
	     Shortcut for command 'x_crop'.

	 x_crop:

	   Crop	selected images	interactively.
	   (equivalent to shortcut command 'xz').

	 x_cut:

	   Cut selected	images interactively.

	 x_fire:

	   Launch the fire effect demo.

	 x_fireworks:

	   Launch the fireworks	demo.

	 x_fisheye:

	   Launch the fish-eye effect demo.

	 x_fourier:

	   Launch the fourier filtering	demo.

	 x_grab_color:
	     _variable_name

	   Open	a color	grabber	widget from the	first selected image.
	   Argument 'variable_name' specifies the variable that	 contains  the
       selected	color values at	any time.
	   Assigning '-1' to it	forces the interactive window to close.

	   Default values: 'variable_name=xgc_variable'.

	 x_hanoi:

	   Launch the Tower of Hanoi game.

	 x_histogram:

	   Launch the histogram	demo.

	 x_hough:

	   Launch the hough transform demo.

	 x_jawbreaker:
	     0<_width<20,0<_height<20,0<_balls<=8

	   Launch the Jawbreaker game.

	 x_landscape:

	   Launch the virtual landscape	demo.

	 x_life:

	   Launch the game of life.

	 x_light:

	   Launch the light effect demo.

	 x_mandelbrot:
	     _julia={ 0	| 1 },_c0r,_c0i

	   Launch Mandelbrot/Julia explorer.

	 x_mask_color:
	     _colorspace={  all	| rgb |	lrgb | ycbcr | lab | lch | hsv | hsi |
       hsl | cmy | cmyk	| yiq },_spatial_tolerance>=0,_color_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',	'back-
       ground_curve_R=220',	  'background_curve_G=background_curve_B=back-
       ground_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	 'num-
       ber_of_columns=2'.

	 x_shadebobs:

	   Launch the shade bobs demo.

	 x_spline:

	   Launch spline curve editor.

	 x_starfield3d:

	   Launch the 3D starfield demo.

	 x_tetris:

	   Launch tetris game.

	 x_threshold:

	   Threshold selected images interactively.

	 x_tictactoe:

	   Launch tic-tac-toe game.

	 x_warp:
	     _nb_keypoints_xgrid>=2,_nb_keypoints_ygrid>=2,_nb_keypoints_con-
       tours>=0,_preview_fidelity={ 0=coarsest | 1=coarse | 2=normal |	3=fine
       | 4=finest },_[background_image],0<=_background_opacity<=1

	   Launch the interactive image	warper.

	   Default values: 'nb_keypoints_xgrid=nb_keypoints_ygrid=2', 'nb_key-
       points_contours=0' and 'preview_fidelity=1'.

	 x_waves:

	   Launch the image waves demo.

	 x_whirl:
	     _opacity>=0

	   Launch the fractal whirls demo.

	   Default values: 'opacity=0.2'.

	 13. Examples of Use
	     ---------------

	 'gmic'	is a generic image processing tool which can be	used in	a wide
       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/exam-
       ple_plot.png [image: '']

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

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

							      ../img/exam-
       ple_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/exam-
       ple_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/exam-
       ple_logo.png [image: '']

	 ### Generate a	3D ring	of torii:

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

							      ../img/exam-
       ple_torii.png [image: '']

	 ### Create a vase from	a 3D isosurface:

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

							      ../img/exam-
       ple_vase.png [image: '']

	 ### Launch a set of interactive demos:

	   $ gmic demos

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

								      G'MIC(1)
NAME | HELP
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=gmic&sektion=1&manpath=FreeBSD+Ports+14.3.quarterly>
home | help
Header And Logo

Peripheral Links

Site Navigation

FreeBSD Manual Pages
