gmic(1)
Perform image processing operations using the G'MIC framework.
Description
G’MIC
NAME
gmic - Perform image processing operations using the G’MIC framework.
HELP
gmic:
GREYC’s Magic for Image Computing: command-line
interface
Version 2.9.4
(https://gmic.eu)
Copyright (c)
2008-2020, 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 possibly complex image processing
pipelines and operators.
It can be used to convert, manipulate, filter and visualize
image datasets made of one or several
1D/2D or 3D multi-spectral images.
This reference documentation describes all the technical
aspects of the G’MIC framework, in its
current version 2.9.4.
As a starting point, you may want to visit our detailed
tutorial pages, at:
https://gmic.eu/tutorial/
2. Overall
Context
---------------
* At any time,
G’MIC manages one list of numbered (and
optionally named) pixel-based images,
entirely stored in computer memory (uncompressed).
* The first
image of the list has index ’0’ and is
denoted by ’[0]’. The second image of the
list
is denoted by ’[1]’, the third by
’[2]’ and so on.
* Negative
indices are treated in a periodic way:
’[-1]’ refers to the last image of the
list,
’[-2]’ to the penultimate one, etc. Thus,
if the list has 4 images, ’[1]’ and
’[-3]’ both designate
the second image of the list.
* A named image
may be also indicated by ’[name]’, if
’name’ uses the character set
[a-zA-Z0-9_]
and does not start with a number. Image names can be set or
reassigned at any moment during the
processing pipeline (see command name for this
purpose).
*
G’MIC defines a set of various commands and
substitution mechanisms to allow the design of
complex pipelines and operators managing this list of
images, in a very flexible way: You can
insert or remove images in the list, rearrange image order,
process images (individually or
grouped), merge image data together, display and output
image files, etc.
* Such a
pipeline can define a new custom G’MIC command
(stored in a user command file), and
re-used afterwards as a regular command, in a larger
pipeline if necessary.
3. Image
Definition and Terminology
--------------------------------
* In
G’MIC, each image is modeled as a 1D, 2D, 3D or
4D array of scalar values, uniformly
discretized on a rectangular/parallelepipedic domain.
* The four dimensions of this array are respectively denoted by:
- width,
the number of image columns (size along the x-axis).
- height, the number of image rows (size along the
y-axis).
- depth, the number of image slices (size along the
z-axis). The depth is equal to ’1’
for
usual color or grayscale 2D images.
- spectrum, the number of image channels (size along
the c-axis). The spectrum is
respectively equal to ’3’ and
’4’ for usual RGB and RGBA
color images.
* There are no hard limitations on the size of the image
along each dimension. For instance, the
number of image slices or channels can be of arbitrary size
within the limits of the available
memory.
* The
width, height and depth of an image are
considered as spatial dimensions, while the
spectrum has a multi-spectral meaning. Thus, a 4D image
in G’MIC should be most often regarded as
a 3D dataset of multi-spectral voxels. Most of the
G’MIC commands will stick with this idea (e.g.
command blur blurs images only along the spatial
xyz-axes).
*
G’MIC stores all the image data as buffers of
float values (32 bits, value range
’[-3.4E38,+3.4E38]’. It performs all its
image processing operations with floating point numbers.
Each image pixel takes then 32bits/channel (except if
double-precision buffers have been enabled
during the compilation of the software, in which case
64bits/channel can be the default).
* Considering
float-valued pixels ensure to keep the numerical
precision when executing image
processing pipelines. For image input/output operations, you
may want to prescribe the image
datatype to be different than float (like
bool, char, int, etc.). This is
possible by
specifying it as a file option when using I/O commands. (see
section Input/Output Properties to
learn more about file options).
4. Items of a
Processing Pipeline
------------------------------
* In
G’MIC, an image processing pipeline is
described as a sequence of items separated by the space
character. Such items are interpreted and executed from the
left to the right. For instance, the
expression:
filename.jpg blur 3,0 sharpen 10 resize 200%,200% output file_out.jpg
defines a valid
pipeline composed of nine G’MIC items.
* Each G’MIC item is a string that is either a
command, a list of command arguments, a
filename or a special input string.
* Escape
characters ’’ and double quotes
’"’ can be used to define items
containing spaces or
other special characters. For instance, the two strings
single item and "single item"
both
define the same single item, with a space in it.
5. Input Data
Items
----------------
* If a specified
G’MIC item appears to be an existing filename,
the corresponding image data are
loaded and inserted at the end of the image list (which is
equivalent to the use of ‘input
filename‘).
* Special
filenames - and -.ext stand for the standard
input/output streams, optionally forced
to be in a specific ’ext’ file format
(e.g. -.jpg or -.png).
* The following
special input strings may be used as G’MIC
items to create and insert new images
with prescribed values, at the end of the image list:
-
’[selection]’ or
’[selection]xN’: Insert 1 or N copies of
already existing images. ’selection’
may represent one or several images (see section Command
Items and Selections to learn more
about selections).
-
’width[%],_height[%],_depth[%],_spectrum[%],_values[xN]’:
Insert one or N images with specified
size and values (adding ’%’ to a
dimension means "percentage of the size along the same
axis",
taken from the last image ’[-1]’). Any
specified dimension can be also written as
’[image]’, and is
then set to the size (along the same axis) of the existing
specified image ’[image]’.
’values’ can
be either a sequence of numbers separated by commas
’,’, or a mathematical expression, as
e.g. in
input item ’256,256,1,3,[x,y,128]’ which
creates a 256x256 RGB color image with a spatial
shading
on the red and green channels. (see section Mathematical
Expressions to learn more about
mathematical expressions).
- ’(v1,v2,..)[xN]’: Insert one or
N new images from specified prescribed values. Value
separator inside parentheses can be ’,’
(column separator), ’;’ (row separator),
’/’ (slice
separator) or ’ˆ’ (channel separator).
For instance, expression
’(1,2,3;4,5,6;7,8,9)’ creates a 3x3
matrix (scalar image), with values running from 1 to 9.
-
’(’string’[:delimiter])[xN]’:
Insert one or N new images from specified string, by filling
the
images with the character codes composing the string. When
specified, ’delimiter’ tells about the
main orientation of the image. Delimiter can be
’x’ (eq. to ’,’ which
is the default), ’y’ (eq. to
’;’), ’z’ (eq. to
’/’) or ’c’ (eq. to
’ˆ’). When specified delimiter is
’,’, ’;’,
’/’ or ’ˆ’, the
expression is actually equivalent to
’({’string’[:delimiter]})[xN]’
(see section ’’Substitution
Rules’’ for more information on the syntax).
- ’0[xN]’: Insert one or N new
empty images, containing no pixel data. Empty images
are used
only in rare occasions.
* Input item ’name=value’ declares a new
variable ’name’, or assign a new string
value to an
existing variable. Variable names must use the character set
[a-zA-Z0-9_] and cannot start with a
number.
* A variable
definition is always local to the current command except
when it starts by the
underscore character ’_’. In that case,
it becomes also accessible by any command invoked outside
the current command scope (global variable).
* If a variable
name starts with two underscores __, the global
variable is also shared among
different threads and can be read/set by commands running in
parallel (see command parallel for
this purpose). Otherwise, it remains local to the thread
that defined it.
* Numerical
variables can be updated with the use of these special
operators: ’+=’ (addition),
’-=’
(subtraction), ’*=’ (multiplication),
’/=’ (division), ’%=’
(modulo), ’&=’ (bitwise and),
’|=’
(bitwise or), ’ˆ=’ (power),
’<<=’ and
’>>’ (bitwise left and right
shifts). For instance, ’foo=1’
’foo+=3’.
* Input item ’name.=string’ concatenates specified string to the end of variable ’name’.
* Multiple
variable assignments and updates are allowed, with
expressions:
’name1,name2,...,nameN=value’ or
’name1,name2,...,nameN=value1,value2,...,valueN’
where assignment
operator ’=’ can be replaced by one of
the allowed operators (e.g. ’+=’).
* Variables
usually store numbers or strings. Use command
’store’ to assign variables from image
data (and syntax input $variable to bring them back
on the image list afterwards).
6. Command
Items and Selections
----------------------------
* A
G’MIC item that is not a filename nor a special
input string designates a ’command’ most
of the
time. Generally, commands perform image processing
operations on one or several available images of
the list.
* Reccurent
commands have two equivalent names
(’regular’ and
’short’). For instance, command names
’resize’ and ’r’ refer
to the same image resizing action.
* A
G’MIC command may have mandatory or optional
arguments. Command arguments must be specified
in the next item on the command line. Commas
’,’ are used to separate multiple
arguments of a
single command, when required.
* The execution
of a G’MIC command may be restricted only to a
subset of the image list, by
appending ’[selection]’ to the command
name. Examples of valid syntaxes for
’selection’ are:
-
’command[-2]’: Apply command only on the
penultimate image ’[-2]’ of the list.
- ’command[0,1,3]’: Apply command only on
images ’[0]’, ’[1]’
and ’[3]’.
- ’command[3-6]’: Apply command only on
images ’[3]’ to ’[6]’
(i.e, ’[3]’, ’[4]’,
’[5]’ and
’[6]’).
- ’command[50%-100%]’: Apply command only
on the second half of the image list.
- ’command[0,-4--1]’: Apply command only
on the first image and the last four images.
- ’command[0-9:3]’: Apply command only on
images ’[0]’ to ’[9]’,
with a step of 3 (i.e. on images
’[0]’, ’[3]’,
’[6]’ and ’[9]’).
- ’command[0-9:25%]’: Apply command only
on images ’[0]’ to
’[9]’, with a step of 25% (i.e. on
images ’[0]’, ’[3]’,
’[6]’ and ’[9]’).
- ’command[0--1:2]’: Apply command only
on images of the list with even indices.
- ’command[0,2-4,50%--1]’: Apply command
on images ’[0]’,
’[2]’, ’[3]’,
’[4]’ and on the second
half of the image list.
- ’command[ˆ0,1]’: Apply command on all
images except the first two.
- ’command[name1,name2]’: Apply command
on named images ’name1’ and
’name2’.
* Indices in selections are always sorted in increasing
order, and duplicate indices are discarded.
For instance, selections ’[3-1,1-3]’ and
’[1,1,1,3,2]’ are both equivalent to
’[1-3]’. If you want
to repeat a single command multiple times on an image, use a
’repeat..done’ loop instead. Inverting
the order of images for a command is achieved by explicitly
inverting the order of the images in
the list, with command
’reverse[selection]’.
* Command
selections ’[-1]’,
’[-2]’ and ’[-3]’ are
so often used they have their own shortcuts,
respectively ’.’, ’..’
and ’...’. For instance, command
’blur..’ is equivalent to
’blur[-2]’. These
shortcuts work also when specifying command arguments.
*
G’MIC commands invoked without
’[selection]’ are applied on all images
of the list, i.e. the
default selection is ’[0--1]’ (except for
command ’input’ whose default selection
is ’[-1]’’).
* Prepending a
single hyphen ’-’ to a G’MIC
command is allowed. This may be useful to recognize
command items more easily in a one-liner pipeline (typically
invoked from a shell).
* A
G’MIC command prepended with a plus sign
’+’ does not act in-place but inserts its
result
as one or several new images at the end of the image
list.
* There are two different types of commands that can be run by the G’MIC interpreter:
- Built-in
commands are the hard-coded functionalities in the
interpreter core. They are thus
compiled as binary code and run fast, most of the time.
Omitting an argument when invoking a
built-in command is not permitted, except if all following
arguments are also omitted. For
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
interpreter (see section ’’Adding
Custom Commands’’ for more details). New
built-in commands cannot be added (unless you modify the
G’MIC interpreter source code and recompile
it).
7.
Input/Output Properties
-----------------------
* G’MIC is able to read/write most of the classical image file formats, including:
- 2D
grayscale/color files: .png, .jpeg,
.gif, .pnm, .tif, .bmp, ...
- 3D volumetric files: .dcm, .hdr,
.nii, .pan, .inr, .pnk, ...
- Video files: .mpeg, .avi, .mov,
.ogg, .flv, ...
- Generic text or binary data files: .gmz,
.cimg, .cimgz, .dlm, .asc,
.pfm, .raw,
.txt, .h.
- 3D object files: .off
* When dealing with color images, G’MIC
generally reads, writes and displays data using the usual
sRGB color space.
*
G’MIC is able to manage 3D objects that may be
read from files or generated by G’MIC
commands. A 3D object is stored as a one-column scalar image
containing the object data, in the
following order: { magic_number; sizes; vertices;
primitives; colors; opacities }. These 3D
representations can be then processed as regular images (see
command split3d for accessing each
of these 3D object data separately).
* Be aware that
usual file formats may be sometimes not adapted to store all
the available image
data, since G’MIC uses float-valued image
buffers. For instance, saving an image that was initially
loaded as a 16bits/channel image, as a .jpg file will
result in a loss of information. Use the
G’MIC-specific file extension .gmz to
ensure that all data precision is preserved when saving
images.
* Sometimes, file options may/must be set for file formats:
- Video
files: Only sub-frames of an image sequence may be
loaded, using the input expression
’filename.ext,[first_frame[,last_frame[,step]]]’.
Set ’last_frame==-1’ to tell it must be
the last
frame of the video. Set ’step’ to
’0’ to force an opened video file to be
opened/closed. Output
framerate and codec can be also set by using the output
expression
’filename.avi,_fps,_codec,_keep_open’
where ’keep_open’ can be { 0 | 1
}. ’codec’ is a 4-char
string (see http://www.fourcc.org/codecs.php ) or
’0’ for the default codec.
’keep_open’ tells if
the output video file must be kept open for appending new
frames afterwards.
- .cimg[z] files: Only crops and sub-images of .cimg
files can be loaded, using the input
expressions ’filename.cimg,N0,N1’,
’filename.cimg,N0,N1,x0,x1’,
’filename.cimg,N0,N1,x0,y0,x1,y1’,
’filename.cimg,N0,N1,x0,y0,z0,x1,y1,z1’
or
’filename.cimg,N0,N1,x0,y0,z0,c0,x1,y1,z1,c1’.
Specifying ’-1’ for one coordinates
stands for the maximum possible value. Output expression
’filename.cimg[z][,datatype]’ can be used
to force the output pixel type.
’datatype’ can be { auto
| uchar | char | ushort | short | uint | int | uint64 |
int64 | float | double }.
- .raw binary files: Image dimensions and input pixel
type may be specified when loading
.raw files with input expression
’filename.raw[,datatype][,width][,height[,depth[,dim[,offset]]]]]
’. If no dimensions are specified, the resulting image
is a one-column vector with maximum possible
height. Pixel type can also be specified with the output
expression ’filename.raw[,datatype]’.
’datatype’ can be the same as for
.cimg[z] files.
- .yuv files: Image dimensions must be specified when
loading, and only sub-frames of an
image sequence may be loaded, using the input expression
’filename.yuv,width,height[,chroma_subsampl
ing[,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
’filename.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) }.
- .gif files: Animated gif files can be saved, using
the input expression
’filename.gif,fps>0,nb_loops’. Specify
’nb_loops=0’ to get an infinite number of
animation loops
(this is the default behavior).
- .jpeg files: The output quality may be specified
(in %), using the output expression
’filename.jpg,30’ (here, to get a 30%
quality output). ’100’ is the default.
- .mnc files: The output header can set from another
file, using the output expression
’filename.mnc,header_template.mnc’.
- .pan, .cpp, .hpp, .c and .h
files: The output datatype can be selected with
output expression ’filename[,datatype]’.
’datatype’ can be the same as for
.cimg[z] files.
- .gmic files: These filenames are assumed to be
G’MIC custom commands files. Loading such
a file will add the commands it defines to the interpreter.
Debug information can be
enabled/disabled by the input expression
’filename.gmic[,add_debug_info’ where
’debug_info’ can be
{ 0=false | 1=true }.
- Inserting ’ext:’ on the beginning of a
filename (e.g. ’jpg:filename’) forces
G’MIC to
read/write the file as it would have been done if it had the
specified extension .ext.
* Some input/output formats and options may not be
supported, depending on the configuration flags
that have been set during the build of the
G’MIC software.
8.
Substitution Rules
------------------
*
G’MIC items containing ’$’
or ’{}’ are substituted before being
interpreted. Use these
substituting expressions to access various data from the
interpreter environment.
*
’$name’ and ’${name}’
are both substituted by the value of the specified named
variable (set
previously by the item ’name=value’). If
this variable has not been already set, the expression is
substituted by the highest positive index of the named image
’[name]’. If no image has this name,
the expression is substituted by the value of the OS
environment variable with same name (it may be
thus an empty string if it is not defined).
* The following reserved variables are predefined by the G’MIC interpreter:
-
’$!’: The current number of images in the
list.
- ’$>’ and ’$<’:
The increasing/decreasing index of the latest (currently
running)
’repeat...done’ loop.
’$>’ goes from 0 (first loop
iteration) to nb_iterations - 1 (last
iteration). ’$<’ does the opposite.
- ’$/’: The current call stack. Stack
items are separated by slashes ’/’.
- ’$|’: The current value (expressed in
seconds) of a millisecond precision timer.
- ’$ˆ’: The current verbosity level.
- ’$_cpus’: The number of computation
cores available on your machine.
- ’$_pid’: The current process
identifier, as an integer.
- ’$_prerelease’: For pre-releases, the
date of the pre-release as yymmdd. For stable
releases,
this variable is set to 0.
- ’$_version’: A 3-digits number telling
about the current version of the G’MIC
interpreter
(e.g. ’294’).
- ’$_host’: A string telling about the
host running the G’MIC interpreter (e.g.
cli or gimp).
- ’$_vt100’: Set to 1 if colored
text output is allowed on the console. Otherwise, set to
0.
- ’$_path_rc’: The path to the
G’MIC folder used to store configuration files
(its value is
OS-dependent).
- ’$_path_user’: The path to the
G’MIC user file .gmic or
user.gmic (its value is
OS-dependent).
- ’$_path_commands’: A list of all
imported command files (stored as a list-valued variable).
* ’$$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, separated by
specified delimiter. Possible delimiters are
’,’ (default), ’;’,
’/’, ’ˆ’ or ’
’. For instance, item
’{’foo’}’ is substituted by
’102,111,111’
and ’{’foo’:;}’ by
’102;111;111’.
*
’{image,feature[:delimiter]}’ is
substituted by a specific feature of the image
’[image]’.
’image’ can be either an image number or
an image name. It can be also eluded, in which case, the
last image ’[-1]’ of the list is
considered for the requested feature. Specified
’feature’ can be
one of:
-
’b’: The image basename (i.e. filename
without the folder path nor extension).
- ’f’: The image folder name.
- ’n’: The image name or filename (if the
image has been read from a file).
- ’t’: The text string from the image
values regarded as character codes.
- ’x’: The image extension (i.e the
characters after the last . in the image name).
- ’ˆ’: The sequence of all image values,
separated by commas ,.
- ’@subset’: The sequence of image values
corresponding to the specified subset, and separated by
commas ,.
- Any other ’feature’ is considered as a
mathematical expression associated to the image
’[image]’ and is substituted by the
result of its evaluation (float value). For instance,
expression ’{0,w+h}’ is substituted by
the sum of the width and height of the first image (see
section Mathematical Expressions for more details).
If a mathematical expression starts with an
underscore _, the resulting value is truncated to a
readable format. For instance, item
’{_pi}’
is substituted by ’3.14159’ (while
’{pi}’ is substituted by
’3.141592653589793’).
- A ’feature’ delimited by backquotes is
replaced by a string whose character codes correspond to
the list of values resulting from the evaluation of the
specified mathematical expression. For
instance, item ’{[102,111,111]}’ is
substituted by ’foo’ and item
’{vector8(65)}’ by
’AAAAAAAA’.
* ’{*}’ is substituted by the visibility
state of the instant display window ’#0]’
(can be {
0=closed | 1=visible }.
*
’{*[index],feature1,...,featureN[:delimiter]}’
is substituted by a specific set of features of
the instant display window ’#0’ (or
’#index’, if specified). Requested
’features’ can be:
-
’w’: display width (i.e. width of the
display area managed by the window).
- ’h’: display height (i.e. height of the
display area managed by the window).
- ’wh’: display width x display height.
- ’d’: window width (i.e. width of the
window widget).
- ’e’: window height (i.e. height of the
window widget).
- ’de’: window width x window height.
- ’u’: screen width (actually independent
on the window size).
- ’v’: screen height (actually
independent on the window size).
- ’uv’: screen width x screen height.
- ’n’: current normalization type of the
instant display.
- ’t’: window title of the instant
display.
- ’x’: X-coordinate of the mouse position
(or -1, if outside the display area).
- ’y’: Y-coordinate of the mouse position
(or -1, if outside the display area).
- ’b’: state of the mouse buttons {
1=left-but. | 2=right-but. | 4=middle-but. }.
- ’o’: state of the mouse wheel.
- ’k’: decimal code of the pressed key if
any, 0 otherwise.
- ’c’: boolean (0 or 1) telling if the
instant display has been closed recently.
- ’r’: boolean telling if the instant
display has been resized recently.
- ’m’: boolean telling if the instant
display has been moved recently.
- Any other ’feature’ stands for a
keycode name (in capital letters), and is substituted by a
boolean describing the current key state { 0=pressed |
1=released }.
- You can also prepend a hyphen ’-’ to a
’feature’ (that supports it) to flush the
corresponding
event immediately after reading its state (works for keys,
mouse and window events).
* Item substitution is never performed in items
between double quotes. One must break the
quotes to enable substitution if needed, as in
’"3+8 kg = "{3+8}"
kg"’. Using double quotes is then
a convenient way to disable the substitutions mechanism in
items, when necessary.
* One can also
disable the substitution mechanism on items outside 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’).
* When the
context allows it, a formula is evaluated for each pixel of
the selected images
(e.g. ’fill’).
* A math
expression may return a scalar or a vector-valued result
(with a fixed number of
components).
The mathematical parser understands the following set of functions, operators and variables:
# Usual operators:
’||’
(logical or), ’&&’ (logical and),
’|’ (bitwise or),
’&’ (bitwise and),
’!=’, ’==’,
’<=’, ’>=’,
’<’, ’>’,
’<<’ (left bitwise shift),
’>>’ (right bitwise shift),
’-’, ’+’,
’*’, ’/’,
’%’ (modulo),
’ˆ’ (power), ’!’
(logical not), ’˜’ (bitwise not),
’++’, ’--’,
’+=’, ’-=’,
’*=’, ’/=’,
’%=’, ’&=’,
’|=’, ’ˆ=’,
’>>’,
’<<=’ (in-place operators).
# Usual math functions:
’abs()’,
’acos()’, ’acosh()’,
’arg()’, ’arg0()’,
’argkth()’,
’argmax()’,
’argmaxabs()’,
’argmin()’,
’argminabs()’,
’asin()’, ’asinh()’,
’atan()’, ’atan2()’,
’atanh()’, ’avg()’,
’bool()’, ’cbrt()’,
’ceil()’, ’cos()’,
’cosh()’, ’cut()’,
’exp()’, ’fact()’,
’fibo()’, ’floor()’,
’gauss()’, ’gcd()’,
’int()’, ’isnan()’,
’isnum()’, ’isinf()’,
’isint()’, ’isbool()’,
’isexpr()’,
’isfile()’, ’isdir()’,
’isin()’, ’kth()’,
’log()’, ’log2()’,
’log10()’, ’max()’,
’maxabs()’, ’med()’,
’min()’, ’minabs()’,
’narg()’, ’prod()’,
’rol()’ (left bit rotation),
’ror()’ (right bit rotation),
’round()’, ’sign()’,
’sin()’, ’sinc()’,
’sinh()’, ’sqrt()’,
’std()’,
’srand(_seed)’,
’sum()’, ’tan()’,
’tanh()’,
’var()’, ’xor()’.
* ’atan2(y,x)’ is the version of
’atan()’ with two arguments
’y’ and ’x’ (as in
C/C++).
*
’permut(k,n,with_order)’ computes the
number of permutations of ’k’ objects
from a set of ’n’
objects.
* ’gauss(x,_sigma,_is_normalized)’ returns exp(-xˆ2/(2*sˆ2))/(is_normalized?sqrt(2*pi*sigmaˆ2):1).
* ’cut(value,min,max)’ returns ’value’ if it is in range ’[min,max]’, or ’min’ or ’max’ otherwise.
* ’narg(a_1,...,a_N)’ returns the number of specified arguments (here, ’N’).
* ’arg(i,a_1,..,a_N)’ returns the i-th argument ’a_i’.
*
’isnum()’, ’isnan()’,
’isinf()’, ’isint()’,
’isbool()’ test the type of the given
number or
expression, and return ’0’ (false) or
’1’ (true).
*
’isfile(’path’)’ (resp.
’isdir(’path’)’) returns
’0’ (false) or ’1’
(true) whether its string
argument is a path to an existing file (resp. to a
directory) or not.
*
’isin(v,a_1,...,a_n)’ returns
’0’ (false) or ’1’
(true) whether the first value ’v’
appears in
the set of other values ’a_i’.
*
’inrange(value,m,M,include_m,include_M)’
returns ’0’ (false) or
’1’ (true) whether the specified
value lies in range ’[m,M]’ or not
(’include_m’ and
’includeM’ tells how boundaries
’m’ and ’M’ are
considered).
*
’argkth()’,
’argmin()’,
’argmax()’,
’argminabs()’,
’argmaxabs()’’,
’avg()’, ’kth()’,
’min()’,
’max()’, ’minabs()’,
’maxabs()’, ’med()’,
’prod()’, ’std()’,
’sum()’ and ’var()’
can be called with
an arbitrary number of scalar/vector arguments.
*
’vargkth()’,
’vargmin()’,
’vargmax()’,
’vargminabs()’,
’vargmaxabs()’,
’vavg()’, ’vkth()’,
’vmin()’, ’vmax()’,
’vminabs()’,
’vmaxabs()’, ’vmed()’,
’vprod()’, ’vstd()’,
’vsum()’ and ’vvar()’
are the versions of the previous function with vector-valued
arguments.
*
’round(value,rounding_value,direction)’
returns a rounded value. ’direction’ can
be {
-1=to-lowest | 0=to-nearest | 1=to-highest }.
* ’lerp(a,b,t)’ returns ’a*(1-t) + b*t’.
* ’swap(a,b)’ swaps the values of the given arguments.
# Variable names:
Variable names
below are pre-defined. They can be overridden.
* ’l’: length of the associated list of
images.
* ’k’: index of the associated image, in ’[0,l-1]’.
* ’w’: width of the associated image, if any (’0’ otherwise).
* ’h’: height of the associated image, if any (’0’ otherwise).
* ’d’: depth of the associated image, if any (’0’ otherwise).
* ’s’: spectrum of the associated image, if any (’0’ otherwise).
* ’r’: shared state of the associated image, if any (’0’ otherwise).
* ’wh’: shortcut for width x height.
* ’whd’: shortcut for width x height x depth.
* ’whds’: shortcut for width x height x depth x spectrum (i.e. number of image values).
*
’im’, ’iM’,
’ia’, ’iv’,
’is’, ’ip’,
’ic’, ’in’:
Respectively the minimum, maximum, average,
variance, sum, product, median value and L2-norm of the
associated image, if any (’0’
otherwise).
*
’xm’, ’ym’,
’zm’, ’cm’: The pixel
coordinates of the minimum value in the associated image, if
any (’0’ otherwise).
*
’xM’, ’yM’,
’zM’, ’cM’: The pixel
coordinates of the maximum value in the associated image, if
any (’0’ otherwise).
* All these
variables are considered as constant values by the
math parser (for optimization
purposes) which is indeed the case most of the time. Anyway,
this might not be the case, if
function ’resize(#ind,..)’ is used in the
math expression. If so, it is safer to invoke functions
’l()’, ’w(_#ind)’,
’h(_#ind)’, ...
’s(_#ind)’ and
’in(_#ind)’ instead of the corresponding
named
variables.
*
’i’: current processed pixel value (i.e.
value located at (x,y,z,c)) in the associated image,
if any (’0’ otherwise).
*
’iN’: N-th channel value of current
processed pixel (i.e. value located at (x,y,z,N) in
the
associated image, if any (’0’ otherwise).
’N’ must be an integer in range
’[0,9]’.
* ’R’, ’G’, ’B’ and ’A’ are equivalent to ’i0’, ’i1’, ’i2’ and ’i3’ respectively.
*
’I’: current vector-valued processed
pixel in the associated image, if any
(’0’ otherwise). The
number of vector components is equal to the number of image
channels (e.g. ’I’ = [ R,G,B ] for
a
RGB image).
* You may add
’#ind’ to any of the variable name above
to retrieve the information for any numbered
image ’[ind]’ of the list (when this
makes sense). For instance ’ia#0’ denotes
the average value of
the first image of the list).
* ’x’: current processed column of the associated image, if any (’0’ otherwise).
* ’y’: current processed row of the associated image, if any (’0’ otherwise).
* ’z’: current processed slice of the associated image, if any (’0’ otherwise).
* ’c’: current processed channel of the associated image, if any (’0’ otherwise).
*
’t’: thread id when an expression is
evaluated with multiple threads (’0’
means __master
thread__).
* ’e’: value of e, i.e. 2.71828....
* ’pi’: value of pi, i.e. 3.1415926....
* ’u’: a random value between ’[0,1]’, following a uniform distribution.
* ’g’: a random value, following a gaussian distribution of variance 1 (roughly in ’[-6,6]’).
*
’interpolation’: value of the default
interpolation mode used when reading pixel values with the
pixel access operators (i.e. when the interpolation argument
is not explicitly specified, see below
for more details on pixel access operators). Its initial
default value is ’0’.
*
’boundary’: value of the default boundary
conditions used when reading pixel values with the
pixel access operators (i.e. when the boundary condition
argument is not explicitly specified, see
below for more details on pixel access operators). Its
initial default value is ’0’.
# Vector calculus:
Most operators
are also able to work with vector-valued elements.
* ’[a0,a1,...,aN-1]’ defines a
’N’-dimensional vector with scalar
coefficients ’ak’.
*
’vectorN(a0,a1,,...,aN-1)’ does the same,
with the ’ak’ being repeated periodically
if only a few
are specified.
* ’vector(#N,a0,a1,,...,aN-1)’ does the same, and can be used for any constant expression ’N’.
* In previous
expressions, the ’ak’ can be vectors
themselves, to be concatenated into a single
vector.
* The scalar element ’ak’ of a vector ’X’ is retrieved by ’X[k]’.
* The sub-vector
’[X[p],X[p+s]...X[p+s*(q-1)]]’ (of size
’q’) of a vector ’X’
is retrieved by
’X[p,q,s]’.
*
’expr(’formula’,_w,_h,_d,_s)’
outputs a vector of size ’w*h*d*s’ with
values generated from the
specified formula, as if one were filling an image with
dimensions ’(w,h,d,s)’.
* Equality/inequality comparisons between two vectors is done with operators ’==’ and ’!=’.
* Some
vector-specific functions can be used on vector values:
’cross(X,Y)’ (cross product),
’dot(X,Y)’ (dot product),
’size(X)’ (vector dimension),
’sort(X,_is_increasing,_nb_elts,_size_elt)’
(sorted values), ’reverse(A)’ (reverse
order of components),
’shift(A,_length,_boundary_conditions)’
and
’same(A,B,_nb_vals,_is_case_sensitive)’
(vector
equality test).
* Function
’normP(u1,...,un)’ computes the LP-norm
of the specified vector (’P’ being an
‘unsigned
integer‘ constant or ’inf’). If
’P’ is omitted, the L2 norm is
calculated.
* Function
’resize(A,size,_interpolation,_boundary_conditions)’
returns a resized version of a
vector ’A’ with specified interpolation
mode. ’interpolation’ can be { -1=none
(memory content) |
0=none | 1=nearest | 2=average | 3=linear | 4=grid |
5=bicubic | 6=lanczos }, and
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
* Function
’find(A,B,_starting_index,_search_step)’
returns the index where sub-vector ’B’
appears
in vector ’A’, (or
’-1’ if ’B’ is not
contained in ’A’). Argument
’A’ can be also replaced by an
image index ’#ind’.
* A
2-dimensional vector may be seen as a complex number
and used in those particular
functions/operators: ’**’ (complex
multiplication), ’//’ (complex division),
’ˆˆ’ (complex
exponentiation), ’**=’ (complex
self-multiplication), ’//=’ (complex
self-division), ’ˆˆ=’ (complex
self-exponentiation), ’cabs()’ (complex
modulus), ’carg()’ (complex argument),
’cconj()’ (complex
conjugate), ’cexp()’ (complex
exponential), ’clog()’ (complex
logarithm), ’ccos()’ (complex
cosine), ’csin()’ (complex sine),
’ctan()’ (complex tangent),
’ccosh()’ (complex hyperpolic
cosine), ’csinh()’ (complex hyperbolic
sine) and ’ctanh()’ (complex hyperbolic
tangent).
* A
MN-dimensional vector may be seen as a M x
N matrix and used in those particular
functions/operators: ’*’ (matrix-vector
multiplication), ’det(A)’ (determinant),
’diag(V)’
(diagonal matrix from a vector), ’eig(A)’
(eigenvalues/eigenvectors), ’eye(n)’ (n x
n identity
matrix), ’invert(A,_solver)’ (matrix
inverse), ’mul(A,B,_nb_colsB)’
(matrix-matrix multiplication),
’pseudoinvert(A,_nb_colsA,_solver)’,
’rot(u,v,w,angle)’ (3D rotation matrix),
’rot(angle)’ (2D
rotation matrix), ’solve(A,B,_nb_colsB)’
(solver of linear system A.X = B),
’svd(A,_nb_colsA)’
(singular value decomposition),
’trace(A)’ (matrix trace) and
’transpose(A,nb_colsA)’ (matrix
transpose). Argument ’nb_colsB’ may be
omitted if it is equal to 1.
*
’mproj(S,nb_colsS,D,nb_colsD,method,max_iter,max_residual)’
projects a matrix ’S’ onto a
dictionary (matrix) ’D’. Equivalent to
command mproj but inside the math evaluator.
* Specifying a
vector-valued math expression as an argument of a command
that operates on image
values (e.g. ’fill’) modifies the whole
spectrum range of the processed image(s), for each spatial
coordinates (x,y,z). The command does not loop over
the c-axis in this case.
# String manipulation:
Character
strings are defined and managed as vectors objects.
Dedicated functions and initializers
to manage strings are:
* [’string’] and
’string’ define a vector whose values are
the character codes of the specified
character string (e.g. ’foo’ is equal
to [ 102,111,111 ]).
*
_’character’ returns the (scalar) byte
code of the specified character (e.g.
_’A’ is equal to
’65’).
* A special case happens for empty strings: Values of both expressions [’’] and ’’ are ’0’.
* Functions
’lowercase()’ and
’uppercase()’ return string with all
string characters lowercased or
uppercased.
* Function
’stov(str,_starting_index,_is_strict)’
parses specified string ’str’ and returns
the
value contained in it.
* Function
’vtos(expr,_nb_digits,_siz)’ returns a
vector of size ’siz’ which contains the
character
representation of values described by expression
’expr’. ’nb_digits’
can be { -1=auto-reduced |
0=all | >0=max number of digits }.
* Function
’echo(str1,str2,...,strN)’ prints the
concatenation of given string arguments on the
console.
* Function
’string(_#siz,str1,str2,...,strN)’
generates a vector corresponding to the concatenation
of given string/number arguments.
# Special operators:
*
’;’: expression separator. The returned
value is always the last encountered expression. For
instance expression ’1;2;pi’ is evaluated
as ’pi’.
*
’=’: variable assignment. Variables in
mathematical parser can only refer to numerical values
(vectors or scalars). Variable names are case-sensitive. Use
this operator in conjunction with ’;’
to define more complex evaluable expressions, such as
t = cos(x); 3*tˆ2 + 2*t + 1
These variables
remain local to the mathematical parser and cannot be
accessed outside the
evaluated expression.
* Variables
defined in math parser may have a constant property, by
specifying keyword ’const’
before the variable name (e.g. ’const foo =
pi/4;’). The value set to such a variable must be
indeed a constant scalar. Constant variables allows certain
types of optimizations in the math
JIT compiler.
# Specific functions:
*
’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 respectively ’x’,
’y’, ’z’,
’c’, ’interpolation’
and ’boundary’. For instance command
fill 0.5*(i(x+1)-i(x-1))
will estimate the X-derivative of an image with a classical finite difference scheme.
*
’j(_dx,_dy,_dz,_dc,_interpolation_type,_boundary_conditions)’
does the same for the pixel located
at position (x+dx,y+dy,z+dz,c+dc) (pixel access
relative to the current coordinates).
*
’i[offset,_boundary_conditions]’ returns
the value of the pixel located at specified
’offset’ in
the associated image buffer (or ’0’ if
offset is out-of-bounds).
*
’j[offset,_boundary_conditions]’ does the
same for an offset relative to the current pixel
coordinates (x,y,z,c).
*
’i(#ind,_x,_y,_z,_c,_interpolation,_boundary_conditions)’,
’j(#ind,_dx,_dy,_dz,_dc,_interpolation,_boundary_conditions)’,
’i[#ind,offset,_boundary_conditions]’ and
’i[offset,_boundary_conditions]’ are
similar expressions
used to access pixel values for any numbered image
’[ind]’ of the list.
*
’I/J[offset,_boundary_conditions]’ and
’I/J(#ind,_x,_y,_z,_interpolation,_boundary_conditions)’
do the same as
’i/j[offset,_boundary_conditions]’ and
’i/j(#ind,_x,_y,_z,_c,_interpolation,_boundary
_conditions)’ but return a vector instead of a scalar
(e.g. a vector [ R,G,B ] for a pixel at
(a,b,c) in a color image).
*
’crop(_#ind,_x,_y,_z,_c,_dx,_dy,_dz,_dc,_boundary_conditions)’
returns a vector whose values come
from the cropped region of image ’[ind]’
(or from default image selected if ’ind’
is not
specified). Cropped region starts from point
(x,y,z,c) and has a size of dx x dy x dz x dc.
Arguments for coordinates and sizes can be omitted if they
are not ambiguous (e.g.
’crop(#ind,x,y,dx,dy)’ is a valid
invocation of this function).
*
’draw(_#ind,S,x,y,z,c,dx,_dy,_dz,_dc,_opacity,_M,_max_M)’
draws a sprite ’S’ in image
’[ind]’ (or
in default image selected if ’ind’ is not
specified) at coordinates (x,y,z,c). The size of the
sprite dx x dy x dz x dc must be specified. You can
also specify a corresponding opacity mask
’M’
if its size matches ’S’.
*
’polygon(_#ind,nb_vertices,coords,_opacity,_color)’
draws a filled polygon in image ’[ind]’
(or
in default image selected if ’ind’ is not
specified) at specified coordinates. It draws a single
line if ’nb_vertices’ is set to 2.
*
’polygon(_#ind,-nb_vertices,coords,_opacity,_pattern,_color)’
draws a outlined polygon in image
’[ind]’ (or in default image selected if
’ind’ is not specified) at specified
coordinates and with
specified line pattern. It draws a single line if
’nb_vertices’ is set to 2.
*
’ellipse(_#ind,xc,yc,radius1,_radius2,_angle,_opacity,_color)’
draws a filled ellipse in image
’[ind]’ (or in default image selected if
’ind’ is not specified) with specified
coordinates.
*
’ellipse(_#ind,xc,yc,-radius1,-_radius2,_angle,_opacity,_pattern,_color)’
draws an outlined
ellipse in image ’[ind]’ (or in default
image selected if ’ind’ is not
specified).
*
’resize(#ind,w,_h,_d,_s,_interp,_boundary_conditions,_cx,_cy,_cz,_cc)’
resizes an image of the
associated list with specified dimension and interpolation
method. When using this function, you
should consider 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 expression ’init’,
then iteratively
evaluates ’body’ (followed by
’procedure’ if specified) while
’condition’ holds (i.e. not zero). It
may happen that no iterations are done, in which case the
function returns ’nan’. Otherwise, it
returns the last value of ’body’. For
instance, the expression:
if(N<2,N,for(n=N;F0=0;F1=1,n=n-1,F2=F0+F1;F0=F1;F1=F2))
returns the ’N’-th value of the Fibonacci sequence, for ’N>=0’ (e.g., ’46368’ for ’N=24’).
*
’while(condition,expression)’ is exactly
the same as
’for(init,condition,expression)’ without
the
specification of an initializing expression.
*
’break()’ and
’continue()’ respectively breaks and
continues the current running bloc (loop, init
or main environment).
* ’fsize(’filename’)’ returns the size of the specified ’filename’ (or ’-1’ if file does not exist).
*
’date(attr,’path’)’ returns
the date attribute for the given ’path’
(file or directory), with
’attr’ being { 0=year | 1=month |
2=day | 3=day of week | 4=hour | 5=minute | 6=second },
or a
vector of those values.
*
’date(_attr)’ returns the specified
attribute for the current (locale) date (attributes being {
0...6=same meaning as above | 7=milliseconds }).
*
’print(expr1,expr2,...)’ or
’print(#ind)’ prints the value of the
specified expressions (or image
information) on the console, and returns the value of the
last expression (or ’nan’ in case of an
image). Function ’prints(expr)’ also
prints the string composed of the character codes defined by
the vector-valued expression (e.g.
’prints(’Hello’)’).
*
’debug(expression)’ prints detailed debug
info about the sequence of operations done by the math
parser to evaluate the expression (and returns its
value).
*
’display(_X,_w,_h,_d,_s)’ or
’display(#ind)’ display the contents of
the vector ’X’ (or specified
image) and wait for user events. if no arguments are
provided, a memory snapshot of the math parser
environment is displayed instead.
*
’begin(expression)’ and
’end(expression)’ evaluates the specified
expressions only once,
respectively at the beginning and end of the evaluation
procedure, and this, even when multiple
evaluations are required (e.g. in ’fill
">begin(foo = 0); ++foo"’).
*
’copy(dest,src,_nb_elts,_inc_d,_inc_s,_opacity)’
copies an entire memory block of
’nb_elts’
elements starting from a source value
’src’ to a specified destination
’dest’, with increments
defined by ’inc_d’ and
’inc_s’ respectively for the destination
and source pointers.
*
’stats(_#ind)’ returns the statistics
vector of the running image ’[ind]’, i.e
the vector ‘[
im,iM,ia,iv,xm,ym,zm,cm,xM,yM,zM,cM,is,ip ]‘ (14
values).
* ’ref(expr,a)’ references specified expression ’expr’ as variable name ’a’.
* ’unref(a,b,...)’ destroys references to the named variable given as arguments.
* ’breakpoint()’ inserts a possible computation breakpoint (useless with the cli interface).
* ’_(expr)’ just ignores its arguments (useful for inserting inline comments in math expressions).
*
’run(’pipeline’)’ executes
the specified G’MIC pipeline as if it was
called outside the currently
evaluated expression.
*
’store(A,’varname’,_w,_h,_d,_s,_is_compressed)’
transfers the data of vector ’A’ as a
‘w x h x d
x s‘ image to the G’MIC variable
’$varname’. Thus, the data becomes
available outside the math
expression (that is equivalent to using the regular command
’store’, but directly in the math
expression).
*
’get(’variable_name’,_size,_to_numbers)’
returns the value of the specified variable, as a vector
of ’size’ values, or as a scalar (if
’size’ is zero or not 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,_ystart,_zstart,_xend,_yend,_zend,_xstride,_ystride,_zstride,_xdilation,_y
dilation,_zdilation)’ returns the correlation,
unrolled as a vector, of the ‘wI x hI x dI x
sI-sized image ’I’ with the wK x hK x dK
x sK‘-sized kernel ’K’ (the meaning
of the other
arguments are the same as in command
’correlate’). Similar function
’convolve(...)’ is also defined
for computing the convolution between ’I’
and ’K’.
# User-defined macros:
* Custom macro
functions can be defined in a math expression, using the
assignment operator ’=’,
e.g.
foo(x,y) = cos(x + y); result = foo(1,2) + foo(2,3)
* Trying to override a built-in function (e.g. ’abs()’) has no effect.
* Overloading
macros with different number of arguments is possible.
Re-defining a previously
defined macro with the same number of arguments discards its
previous definition.
* Macro
functions are indeed processed as macros by the
mathematical evaluator. You should
avoid invoking them with arguments that are themselves
results of assignments or self-operations.
For instance,
foo(x) = x + x; z = 0; foo(++z)
returns ’4’ rather than expected value ’2’.
* When
substituted, macro arguments are placed inside parentheses,
except if a number sign ’#’ is
located just before or after the argument name. For
instance, expression
foo(x,y) = x*y; foo(1+2,3)
returns ’9’ (being substituted as ’(1+2)*(3)’), while expression
foo(x,y) = x#*y#; foo(1+2,3)
returns ’7’ (being substituted as ’1+2*3’).
* Number signs
appearing between macro arguments function actually count
for empty separators.
They may be used to force the substitution of macro
arguments in unusual places, e.g. as in
str(N) = [’I like N#’];
# Multi-threaded and in-place evaluation:
* If your image
data are large enough and you have several CPUs available,
it is likely that the
math expression passed to a ’fill’,
’eval’ or ’input’
commands is evaluated in parallel, using
multiple computation threads.
* Starting an
expression with ’:’ or
’*’ forces the evaluations required for
an image to be run in
parallel, even if the amount of data to process is small
(beware, it may be slower to evaluate in
this case!). Specify ’:’ (rather than
’*’) to avoid possible image copy done
before evaluating the
expression (this saves memory, but do this only if you are
sure this step is not required!)
* If the
specified expression starts with ’>’
or ’<’, the pixel access operators
’i()’, ’i[]’,
’j()’ and ’j[]’ return
values of the image being currently modified, in forward
(’>’) or backward
(’<’) order. The multi-threading
evaluation of the expression is disabled in this case.
* Function
’critical(expr)’ forces the execution of
the given expression in a single thread at a
time.
*
’begin_t(expr)’ and
’end_t(expr)’ evaluates the specified
expression once for each running thread
(so possibly several times) at the beginning and the end of
the evaluation procedure.
*
’merge(variable,operator)’ tells to merge
the local variable value computed by threads, with the
specified operator, when all threads have finished
computing.
* Expressions
’i(_#ind,x,_y,_z,_c)=value’,
’j(_#ind,x,_y,_z,_c)=value’,
’i[_#ind,offset]=value’ and
’j[_#ind,offset]=value’ set a pixel value
at a different location than the running one in the image
’[ind]’ (or in the associated image if
argument ’#ind’ is omitted), either with
global
coordinates/offsets (with ’i(...)’ and
’i[...]’), or relatively to the current
position (x,y,z,c)
(with ’j(...)’ and
’j[...]’). These expressions always
return ’value’.
* The last image
of the list is always associated to the evaluations of
’expressions’, e.g. G’MIC
sequence
256,128 fill {w}
will create a 256x128 image filled with value 256.
10. Image and
Data Viewers
----------------------
*
G’MIC has some very handy embedded
visualization modules, for 1D signals (command
’plot’),
1D/2D/3D images (command ’display’) and
3D vector objects (command ’display3d’).
It manages
interactive views of the selected image data.
* The following actions are available in the interactive viewers:
-
(mousewheel): Zoom in/out.
- ESC: Close window.
- CTRL+D: Increase window size.
- CTRL+C: Decrease window size.
- CTRL+R: Reset window size.
- CTRL+F: Toggle fullscreen mode.
- CTRL+S: Save current view as a numbered file
’gmic_xxxx.ext’.
- CTRL+O: Save copy of the viewed data, as a numbered
file ’gmic_xxxx.ext’.
* Actions specific to the 1D/2D image viewer (command
’display’) are:
- Left mouse
button: Create an image selection and zoom into it.
- Middle mouse button, or CTRL+left mouse
button: Move image.
- Mouse wheel or PADD+/-: Zoom in/out.
- Arrow keys: Move image left/right/up/down.
- CTRL+A: Enable/disable transparency (show alpha
channel).
- CTRL+N: Change normalization mode (can be { none
| normal | channel-by-channel }).
- CTRL+SPACE: Reset view.
- CTRL+X: Show/hide axes.
- CTRL+Z: Hold/release aspect ratio.
* Actions specific to the 3D volumetric image viewer
(command ’display’) are:
- CTRL+P:
Play z-stack of frames as a movie.
- CTRL+V: Show/hide 3D view on bottom right zone.
- CTRL+X: Show/hide axes.
- CTRL+(mousewheel): Go up/down.
- SHIFT+(mousewheel): Go left/right.
- Numeric PAD: Zoom in/out (+/-) and
move through zoomed image (digits).
- BACKSPACE: Reset zoom scale.
* Actions specific to the 3D object viewer (command
’display3d’) are:
-
(mouse)+(left mouse button): Rotate 3D object.
- (mouse)+(right mouse button): Zoom 3D object.
- (mouse)+(middle mouse button): Shift 3D object.
- F1 ... F6: Toggle between different 3D rendering
modes.
- F7/F8: Decrease/increase focale.
- F9: Select animation mode.
- F10: Select animation speed.
- SPACE: Start/stop animation.
- CTRL+A: Show/hide 3D axes.
- CTRL+B: Switch between available background.
- CTRL+G: Save 3D object, as numbered file
’gmic_xxxx.off’.
- CTRL+L: Show/hide outline.
- CTRL+P: Print current 3D pose on stderr.
- CTRL+T: Switch between single/double-sided 3D
modes.
- CTRL+V: Start animation with video output.
- CTRL+X: Show/hide 3D bounding box.
- CTRL+Z: Enable/disable z-buffered rendering.
11. Adding
Custom Commands
----------------------
* New custom commands can be added by the user, through the use of G’MIC custom commands files.
* A command file is a simple text file, where each line starts either by
command_name: command_definition
or
command_definition (continuation)
* At startup,
G’MIC automatically includes user’s
command file ’$HOME/.gmic’ (on Unix) or
’%APPDATA%/user.gmic’ (on Windows). The
CLI tool ’gmic’ automatically runs the
command
’cli_start’ if defined.
* Custom command names must use character set [a-zA-Z0-9_] and cannot start with a number.
* Any
’# comment’ expression found in a custom
commands file is discarded by the G’MIC parser,
wherever it is located in a line.
* In a custom command, the following ’$-expressions’ are recognized and substituted:
-
’$*’ is substituted by a copy of the
specified string of arguments.
- ’$"*"’ is substituted by a
copy of the specified string of arguments, each being
double-quoted.
- ’$#’ is substituted by the maximum
index of known arguments (either specified by the user or
set to a default value in the custom command).
- ’$[]’ is substituted by the list of
selected image indices that have been specified in the
command invocation.
- ’$?’ is substituted by a printable
version of ’$[]’ to be used in command
descriptions.
- ’$i’ and ’${i}’ are
both substituted by the i-th specified argument.
Negative indices such as
’${-j}’ are allowed and refer to the
j-th latest argument. ’$0’ is
substituted by the custom
command name.
- ’${i=default}’ is substituted by the
value of ’$i’ (if defined) or by its new
value set to
’default’ otherwise
(’default’ may be a $-expression
as well).
- ’${subset}’ is substituted by the
argument values (separated by commas ’,’)
of a specified
argument subset. For instance expression
’${2--2}’ is substituted by all specified
command
arguments except the first and the last one. Expression
’${ˆ0}’ is then substituted by all
arguments of the invoked command (eq. to
’$*’ if all arguments have been indeed
specified).
- ’$=var’ is substituted by the set of
instructions that will assign each argument
’$i’ to the
named variable ’var$i’ (for i in
’[0...$#]’. This is particularly useful
when a custom command want
to manage variable numbers of arguments. Variables names
must use character set [a-zA-Z0-9_] and
cannot start with a number.
* These particular $-expressions for custom commands
are always substituted, even in
double-quoted items or when the dollar sign
’$’ is escaped with a backslash
’fR’. To avoid
substitution, place an empty double quoted string just after
the ’$’ (as in
’$""1’).
* Specifying
arguments may be skipped when invoking a custom command, by
replacing them by commas
’,’ as in expression
flower ,,3
Omitted
arguments are set to their default values, which must be
thus explicitly defined in the
code of the corresponding custom command (using default
argument expressions as
’${1=default}’).
* If one
numbered argument required by a custom command misses a
value, an error is thrown by the
G’MIC interpreter.
12. List of
Commands
----------------
All available
G’MIC commands are listed below, by categories.
An argument specified between ’[]’ or
starting by ’_’ is optional except when
standing for an existing image ’[image]’,
where ’image’ can
be either an index number or an image name. In this case,
the ’[]’ characters are mandatory when
writing the item. Note that all images that serve as
illustrations in this reference documentation
are normalized in range [0,255] before being
displayed. You may need to do this explicitly
(command ’normalize 0,255’) if you want
to save and view images with the same aspect than those
illustrated in the example codes.
12.1. Global
Options
--------------
debug (+):
Activate debug
mode.
When activated, the G’MIC interpreter becomes
very verbose and outputs additional log
messages about its internal state on the standard output
(stdout).
This option is useful for developers or to report possible
bugs of the interpreter.
h:
Shortcut for command ’help’.
help:
command |
(no arg)
Display help
(optionally for specified command only) and exit.
(equivalent to shortcut command ’h’).
version:
Display current version number on stdout.
12.2. Input /
Output
--------------
camera
(+):
_camera_index>=0,_nb_frames>0,_skip_frames>=0,_capture_width>=0,_capture_height>=0
Insert one or
several frames from specified camera.
When ’nb_frames==0’, the camera stream is
released instead of capturing new images.
Default
values: ’camera_index=0’ (default
camera), ’nb_frames=1’,
’skip_frames=0’ and
’capture_width=capture_height=0’ (default
size).
clut:
"clut_name",_resolution>0,_cut_and_round={ 0=no
| 1=yes }
Insert one of
the 862 pre-defined CLUTs at the end of the image list.
’clut_name’ can be { 2-strip-process |
60s | 60s_faded | 60s_faded_alt | action_magenta_01 |
action_red_01 | adventure_1453 | agfa_apx_100 | agfa_apx_25
| agfa_precisa_100 |
agfa_ultra_color_100 | agfa_vista_200 |
agressive_highligjtes_recovery_5 | alberto_street |
alien_green | amstragram | amstragram+ |
analogfx_anno_1870_color | analogfx_old_style_i |
analogfx_old_style_ii | analogfx_old_style_iii |
analogfx_sepia_color | analogfx_soft_sepia_i |
analogfx_soft_sepia_ii | anime | apocalypse_this_very_moment
| aqua | aqua_and_orange_dark |
arabica_12 | autumn | ava_614 | avalanche | azrael_93 |
bboyz_2 | berlin_sky | black_and_white |
black_star | blade_runner | bleach_bypass | bleachbypass_1 |
bleachbypass_2 | bleachbypass_3 |
bleachbypass_4 | bleech_bypass_green |
bleech_bypass_yellow_01 | blue_cold_fade | blue_dark |
blue_house | blue_ice | blue_mono | blue_shadows_01 | blues
| bob_ford | bourbon_64 |
bright_green_01 | bright_teal_orange | bright_warm |
brightgreen | brownish | bw_1 | bw_10 | bw_2 |
bw_3 | bw_4 | bw_5 | bw_6 | bw_7 | bw_8 | bw_9 | byers_11 |
candlelight | caribe | chemical_168 |
chrome_01 | cinema | cinema_2 | cinema_3 | cinema_4 |
cinema_5 | cinema_noir | cinematic-1 |
cinematic-10 | cinematic-2 | cinematic-3 | cinematic-4 |
cinematic-5 | cinematic-6 | cinematic-7 |
cinematic-8 | cinematic-9 | cinematic_01 | cinematic_02 |
cinematic_03 | cinematic_for_flog |
cinematic_lady_bird | cinematic_mexico | city_7 |
classic_teal_and_orange | clayton_33 |
clear_teal_fade | clouseau_54 | cobi_3 | coffee_44 |
cold_clear_blue | cold_clear_blue_1 |
cold_simplicity_2 | color_rich | colorful_0209 |
colornegative | conflict_01 | contrail_35 |
contrast_with_highlights_protection | contrasty_afternoon |
contrasty_green | crispromance |
crispwarm | crispwinter | cross_process_cp_130 |
cross_process_cp_14 | cross_process_cp_15 |
cross_process_cp_16 | cross_process_cp_18 |
cross_process_cp_3 | cross_process_cp_4 |
cross_process_cp_6 | crushin | cubicle_99 | d_o_1 |
dark_blues_in_sunlight | dark_green_02 |
dark_green_1 | dark_place_01 | date_39 | day_4nite |
day_for_night | deep | deep_blue |
deep_dark_warm | deep_high_contrast | deep_teal_fade |
deep_warm_fade | delicatessen |
denoiser_simple_40 | desert_gold_37 | dimension |
directions_23 | django_25 | domingo_145 | dream_1
| dream_85 | drop_green_tint_14 | dropblues |
earth_tone_boost | edgyember | elegance_38 |
enchanted | eterna_for_flog | expired_69 | expired_fade |
expired_polaroid | extreme | fade |
fade_to_green | faded | faded_47 | faded_alt | faded_analog
| faded_extreme | faded_green |
faded_print | faded_retro_01 | faded_retro_02 | faded_vivid
| fadedlook | fallcolors |
faux_infrared | faux_infrared_bw_1 | faux_infrared_color_p_2
| faux_infrared_color_p_3 |
faux_infrared_color_r_0a | faux_infrared_color_r_0b |
faux_infrared_color_yp_1 | fgcinebasic |
fgcinebright | fgcinecold | fgcinedrama | fgcinetealorange_1
| fgcinetealorange_2 | fgcinevibrant |
fgcinewarm | film_0987 | film_9879 | film_high_contrast |
film_print_01 | film_print_02 | filmic |
flat_30 | flavin | foggynight | folger_50 | french_comedy |
frosted | frostedbeachpicnic |
fuji_160c | fuji_160c_+ | fuji_160c_++ | fuji_160c_- |
fuji_3510_constlclip | fuji_3510_constlmap |
fuji_3510_cuspclip | fuji_3513_constlclip |
fuji_3513_constlmap | fuji_3513_cuspclip | fuji_400h |
fuji_400h_+ | fuji_400h_++ | fuji_400h_- | fuji_800z |
fuji_800z_+ | fuji_800z_++ | fuji_800z_- |
fuji_astia_100_generic | fuji_astia_100f | fuji_fp-100c |
fuji_fp-100c_+ | fuji_fp-100c_++ |
fuji_fp-100c_+++ | fuji_fp-100c_++_alt | fuji_fp-100c_- |
fuji_fp-100c_-- | fuji_fp-100c_alt |
fuji_fp-100c_cool | fuji_fp-100c_cool_+ |
fuji_fp-100c_cool_++ | fuji_fp-100c_cool_- |
fuji_fp-100c_cool_-- | fuji_fp-100c_negative |
fuji_fp-100c_negative_+ | fuji_fp-100c_negative_++ |
fuji_fp-100c_negative_+++ | fuji_fp-100c_negative_++_alt |
fuji_fp-100c_negative_- |
fuji_fp-100c_negative_-- | fuji_fp-3000b | fuji_fp-3000b_+ |
fuji_fp-3000b_++ | fuji_fp-3000b_+++ |
fuji_fp-3000b_- | fuji_fp-3000b_-- | fuji_fp-3000b_hc |
fuji_fp-3000b_negative |
fuji_fp-3000b_negative_+ | fuji_fp-3000b_negative_++ |
fuji_fp-3000b_negative_+++ |
fuji_fp-3000b_negative_- | fuji_fp-3000b_negative_-- |
fuji_fp-3000b_negative_early | fuji_fp_100c
| fuji_hdr | fuji_neopan_1600 | fuji_neopan_1600_+ |
fuji_neopan_1600_++ | fuji_neopan_1600_- |
fuji_neopan_acros_100 | fuji_provia_100_generic |
fuji_provia_100f | fuji_provia_400f |
fuji_provia_400x | fuji_sensia_100 | fuji_superia_100 |
fuji_superia_100_+ | fuji_superia_100_++ |
fuji_superia_100_- | fuji_superia_1600 | fuji_superia_1600_+
| fuji_superia_1600_++ |
fuji_superia_1600_- | fuji_superia_200 |
fuji_superia_200_xpro | fuji_superia_400 |
fuji_superia_400_+ | fuji_superia_400_++ |
fuji_superia_400_- | fuji_superia_800 |
fuji_superia_800_+ | fuji_superia_800_++ |
fuji_superia_800_- | fuji_superia_hg_1600 |
fuji_superia_reala_100 | fuji_superia_x-tra_800 |
fuji_velvia_100_generic | fuji_velvia_50 |
fuji_xtrans_iii_acros | fuji_xtrans_iii_acros+g |
fuji_xtrans_iii_acros+r |
fuji_xtrans_iii_acros+ye | fuji_xtrans_iii_astia |
fuji_xtrans_iii_classic_chrome |
fuji_xtrans_iii_mono | fuji_xtrans_iii_mono+g |
fuji_xtrans_iii_mono+r | fuji_xtrans_iii_mono+ye |
fuji_xtrans_iii_pro_neg_hi | fuji_xtrans_iii_pro_neg_std |
fuji_xtrans_iii_provia |
fuji_xtrans_iii_sepia | fuji_xtrans_iii_velvia | fusion_88 |
futuristicbleak_1 | futuristicbleak_2
| futuristicbleak_3 | futuristicbleak_4 | going_for_a_walk |
golden | golden_bright | golden_fade |
golden_mono | golden_night_softner_43 | golden_sony_37 |
golden_vibrant | goldengate |
goldfx_bright_spring_breeze | goldfx_bright_summer_heat |
goldfx_hot_summer_heat |
goldfx_perfect_sunset_01min | goldfx_perfect_sunset_05min |
goldfx_perfect_sunset_10min |
goldfx_spring_breeze | goldfx_summer_heat | good_morning |
green_15 | green_2025 | green_action |
green_afternoon | green_blues | green_conflict |
green_day_01 | green_day_02 | green_g_09 |
green_indoor | green_light | green_mono | green_yellow |
greenish_contrasty | greenish_fade |
greenish_fade_1 | hackmanite | happyness_133 |
hard_teal_orange | harsh_day | harsh_sunset | helios
| herderite | heulandite | hiddenite | highlights_protection
| hilutite | hlg_1_1 | hong_kong |
horrorblue | howlite | hydracore | hyla_68 | hypersthene |
hypnosis | hypressen | ilford_delta_100
| ilford_delta_3200 | ilford_delta_3200_+ |
ilford_delta_3200_++ | ilford_delta_3200_- |
ilford_delta_400 | ilford_fp_4_plus_125 | ilford_hp_5 |
ilford_hp_5_+ | ilford_hp_5_++ |
ilford_hp_5_- | ilford_hp_5_plus_400 | ilford_hps_800 |
ilford_pan_f_plus_50 | ilford_xp_2 |
indoor_blue | industrial_33 | instantc | justpeachy |
k_tone_vintage_kodachrome | kh_1 | kh_10 |
kh_2 | kh_3 | kh_4 | kh_5 | kh_6 | kh_7 | kh_8 | kh_9 |
killstreak | kodak_2383_constlclip |
kodak_2383_constlmap | kodak_2383_cuspclip |
kodak_2393_constlclip | kodak_2393_constlmap |
kodak_2393_cuspclip | kodak_bw_400_cn |
kodak_e-100_gx_ektachrome_100 | kodak_ektachrome_100_vs |
kodak_ektachrome_100_vs_generic | kodak_ektar_100 |
kodak_elite_100_xpro | kodak_elite_chrome_200 |
kodak_elite_chrome_400 | kodak_elite_color_200 |
kodak_elite_color_400 | kodak_elite_extracolor_100
| kodak_hie_hs_infra | kodak_kodachrome_200 |
kodak_kodachrome_25 | kodak_kodachrome_64 |
kodak_kodachrome_64_generic | kodak_portra_160 |
kodak_portra_160_+ | kodak_portra_160_++ |
kodak_portra_160_- | kodak_portra_160_nc |
kodak_portra_160_nc_+ | kodak_portra_160_nc_++ |
kodak_portra_160_nc_- | kodak_portra_160_vc |
kodak_portra_160_vc_+ | kodak_portra_160_vc_++ |
kodak_portra_160_vc_- | kodak_portra_400 |
kodak_portra_400_+ | kodak_portra_400_++ |
kodak_portra_400_- | kodak_portra_400_nc |
kodak_portra_400_nc_+ | kodak_portra_400_nc_++ |
kodak_portra_400_nc_- | kodak_portra_400_uc |
kodak_portra_400_uc_+ | kodak_portra_400_uc_++ |
kodak_portra_400_uc_- | kodak_portra_400_vc |
kodak_portra_400_vc_+ | kodak_portra_400_vc_++ |
kodak_portra_400_vc_- | kodak_portra_800 |
kodak_portra_800_+ | kodak_portra_800_++ |
kodak_portra_800_- | kodak_portra_800_hc | kodak_t-max_100 |
kodak_t-max_3200 | kodak_t-max_400 |
kodak_tmax_3200 | kodak_tmax_3200_+ | kodak_tmax_3200_++ |
kodak_tmax_3200_- | kodak_tmax_3200_alt
| kodak_tri-x_400 | kodak_tri-x_400_+ | kodak_tri-x_400_++ |
kodak_tri-x_400_- |
kodak_tri-x_400_alt | korben_214 | landscape_1 |
landscape_10 | landscape_2 | landscape_3 |
landscape_4 | landscape_5 | landscape_6 | landscape_7 |
landscape_8 | landscape_9 |
lateafternoonwanderlust | latesunset | lc_1 | lc_10 | lc_2 |
lc_3 | lc_4 | lc_5 | lc_6 | lc_7 |
lc_8 | lc_9 | lenox_340 | life_giving_tree | light_blown |
lomo | lomography_redscale_100 |
lomography_x-pro_slide_200 | low_contrast_blue | low_key_01
| lucky_64 | lushgreensummer |
magenta_day | magenta_day_01 | magenta_dream |
magenta_yellow | magentacoffee | matrix |
mckinnon_75 | memories | metropolis | milo_5 |
minimalistcaffeination | modern_film | mono_tinted |
monochrome_1 | monochrome_2 | moody_1 | moody_10 | moody_2 |
moody_3 | moody_4 | moody_5 | moody_6
| moody_7 | moody_8 | moody_9 | moonlight | moonlight_01 |
moonrise | morning_6 | morroco_16 |
mostly_blue | moviz_1 | moviz_10 | moviz_11 | moviz_12 |
moviz_13 | moviz_14 | moviz_15 | moviz_16
| moviz_17 | moviz_18 | moviz_19 | moviz_2 | moviz_20 |
moviz_21 | moviz_22 | moviz_23 | moviz_24 |
moviz_25 | moviz_26 | moviz_27 | moviz_28 | moviz_29 |
moviz_3 | moviz_30 | moviz_31 | moviz_32 |
moviz_33 | moviz_34 | moviz_35 | moviz_36 | moviz_37 |
moviz_38 | moviz_39 | moviz_4 | moviz_40 |
moviz_41 | moviz_42 | moviz_43 | moviz_44 | moviz_45 |
moviz_46 | moviz_47 | moviz_48 | moviz_5 |
moviz_6 | moviz_7 | moviz_8 | moviz_9 | mute_shift |
muted_01 | muted_fade | mysticpurplesunset |
nah | natural_vivid | nemesis | neon_770 |
neutral_teal_orange | neutral_warm_fade | newspaper |
night_01 | night_blade_4 | night_king_141 | night_spy |
nightfromday | nostalgiahoney | nostalgic |
nw-1 | nw-10 | nw-2 | nw-3 | nw-4 | nw-5 | nw-6 | nw-7 |
nw-8 | nw-9 | old_west | once_upon_a_time
| only_red | only_red_and_blue | operation_yellow |
orange_dark_4 | orange_dark_7 |
orange_dark_look | orange_tone | orange_underexposed |
oranges | paladin | paladin_1875 |
pasadena_21 | passing_by | pink_fade | pitaya_15 |
polaroid_664 | polaroid_665 | polaroid_665_+ |
polaroid_665_++ | polaroid_665_- | polaroid_665_-- |
polaroid_665_negative |
polaroid_665_negative_+ | polaroid_665_negative_- |
polaroid_665_negative_hc | polaroid_667 |
polaroid_669 | polaroid_669_+ | polaroid_669_++ |
polaroid_669_+++ | polaroid_669_- |
polaroid_669_-- | polaroid_669_cold | polaroid_669_cold_+ |
polaroid_669_cold_- |
polaroid_669_cold_-- | polaroid_672 | polaroid_690 |
polaroid_690_+ | polaroid_690_++ |
polaroid_690_- | polaroid_690_-- | polaroid_690_cold |
polaroid_690_cold_+ | polaroid_690_cold_++ |
polaroid_690_cold_- | polaroid_690_cold_-- |
polaroid_690_warm | polaroid_690_warm_+ |
polaroid_690_warm_++ | polaroid_690_warm_- |
polaroid_690_warm_-- | polaroid_polachrome |
polaroid_px-100uv+_cold | polaroid_px-100uv+_cold_+ |
polaroid_px-100uv+_cold_++ |
polaroid_px-100uv+_cold_+++ | polaroid_px-100uv+_cold_- |
polaroid_px-100uv+_cold_-- |
polaroid_px-100uv+_warm | polaroid_px-100uv+_warm_+ |
polaroid_px-100uv+_warm_++ |
polaroid_px-100uv+_warm_+++ | polaroid_px-100uv+_warm_- |
polaroid_px-100uv+_warm_-- |
polaroid_px-680 | polaroid_px-680_+ | polaroid_px-680_++ |
polaroid_px-680_- | polaroid_px-680_-- |
polaroid_px-680_cold | polaroid_px-680_cold_+ |
polaroid_px-680_cold_++ |
polaroid_px-680_cold_++_alt | polaroid_px-680_cold_- |
polaroid_px-680_cold_-- |
polaroid_px-680_warm | polaroid_px-680_warm_+ |
polaroid_px-680_warm_++ | polaroid_px-680_warm_- |
polaroid_px-680_warm_-- | polaroid_px-70 | polaroid_px-70_+
| polaroid_px-70_++ |
polaroid_px-70_+++ | polaroid_px-70_- | polaroid_px-70_-- |
polaroid_px-70_cold |
polaroid_px-70_cold_+ | polaroid_px-70_cold_++ |
polaroid_px-70_cold_- | polaroid_px-70_cold_-- |
polaroid_px-70_warm | polaroid_px-70_warm_+ |
polaroid_px-70_warm_++ | polaroid_px-70_warm_- |
polaroid_px-70_warm_-- | polaroid_time_zero_expired |
polaroid_time_zero_expired_+ |
polaroid_time_zero_expired_++ | polaroid_time_zero_expired_-
| polaroid_time_zero_expired_-- |
polaroid_time_zero_expired_--- |
polaroid_time_zero_expired_cold |
polaroid_time_zero_expired_cold_- |
polaroid_time_zero_expired_cold_-- |
polaroid_time_zero_expired_cold_--- | portrait_1 |
portrait_10 | portrait_2 | portrait_3 |
portrait_4 | portrait_5 | portrait_6 | portrait_7 |
portrait_8 | portrait_9 | progressen |
protect_highlights_01 | prussian_blue | pseudogrey | purple
| purple_2 | red_afternoon_01 |
red_day_01 | red_dream_01 | redblueyellow | reds |
reds_oranges_yellows | reeve_38 | remy_24 |
rest_33 | retro | retro_brown_01 | retro_magenta_01 |
retro_summer_3 | retro_yellow_01 |
rollei_ir_400 | rollei_ortho_25 | rollei_retro_100_tonal |
rollei_retro_80s | rotate_muted |
rotate_vibrant | rotated | rotated_crush | saturated_blue |
saving_private_damon | science_fiction
| serenity | seringe_4 | serpent | seventies_magazine |
shadow_king_39 | shine | skin_tones |
smart_contrast | smokey | smooth_clear | smooth_cromeish |
smooth_fade | smooth_green_orange |
smooth_sailing | smooth_teal_orange | soft_fade |
softwarming | solarized_color | solarized_color_2
| springmorning | sprocket_231 | spy_29 | street |
studio_skin_tone_shaper | subtle_blue |
subtle_green | subtle_yellow | summer | summer_alt | sunny |
sunny_alt | sunny_rich | sunny_warm |
super_warm | super_warm_rich | sutro_fx | sweet_bubblegum |
sweet_gelatto | taiga | tarraco |
teal_fade | teal_moonlight | tealmagentagold | tealorange |
tealorange_1 | tealorange_2 |
tealorange_3 | technicalfx_backlight_filter | teigen_28 |
tensiongreen_1 | tensiongreen_2 |
tensiongreen_3 | tensiongreen_4 | terra_4 | the_matrices |
thriller_2 | toastedgarden | trent_18 |
true_colors_8 | turkiest_42 | tweed_71 | ultra_water |
undeniable | undeniable_2 | unknown |
urban_cowboy | uzbek_bukhara | uzbek_marriage |
uzbek_samarcande | velvetia | very_warm_greenish |
vibrant | vibrant_alien | vibrant_contrast |
vibrant_cromeish | victory | vintage | vintage_163 |
vintage_alt | vintage_brighter | vintage_chrome |
vintage_warmth_1 | vireo_37 | warm |
warm_dark_contrasty | warm_fade | warm_fade_1 |
warm_highlight | warm_neutral | warm_sunset_red |
warm_teal | warm_vintage | warm_yellow | well_see |
whiter_whites | winterlighthouse | wipe |
wooden_gold_20 | yellow_55b | yellow_film_01 | yellowstone |
you_can_do_it | zed_32 | zeke_39 |
zilverfx_bw_solarization | zilverfx_infrared |
zilverfx_vintage_bw }
Default values: ’resolution=33’ and ’cut_and_round=1’.
Example: [#1] clut summer clut alien_green,17 clut orange_dark4,48
m (+):
Shortcut for command ’command’.
command
(+):
_add_debug_info={ 0 | 1 },{ filename | http[s]://URL |
"string" }
Import
G’MIC custom commands from specified file, URL
or string.
(equivalent to shortcut command ’m’).
Imported commands are available directly after the ’command’ invocation.
Default value: ’add_debug_info=1’.
Example: [#1] image.jpg command "foo : mirror y deform $""1" +foo[0] 5 +foo[0] 15
cursor
(+):
_mode = { 0=hide | 1=show }
Show or hide
mouse cursor for selected instant display windows.
Command selection (if any) stands for instant display window
indices instead of image indices.
Default value: ’mode=1’.
d (+):
Shortcut for command ’display’.
display
(+):
_X[%]>=0,_Y[%]>=0,_Z[%]>=0,_exit_on_anykey={ 0 | 1
}
Display selected
images in an interactive viewer (use the instant display
window [0] if opened).
(equivalent to shortcut command ’d’).
Arguments ’X’,’Y’,’Z’ determine the initial selection view, for 3D volumetric images.
Default value: ’X=Y=Z=0’ and ’exit_on_anykey=0’.
Tutorial: https://gmic.eu/tutorial/_display.shtml
d0:
Shortcut for command ’display0’.
display0:
Display selected
images without value normalization.
(equivalent to shortcut command
’d0’).
d2d:
Shortcut for command ’display2d’.
display2d:
Display selected
2d images in an interactive window.
(equivalent to shortcut command
’d2d’).
This command is
used by default by command ’display’ when
displaying 2d images.
If selected image is a volumetric image, each slice is
displayed on a separate display
window (up to 10 images can be displayed simultaneously this
way), with synchronized moves.
When interactive window is opened, the following actions are
possible:
* Left mouse button: Create an image selection and zoom into
it.
* Middle mouse button, or CTRL+left mouse button: Move
image.
* Mouse wheel or PADD+/-: Zoom in/out.
* Arrow keys: Move image left/right/up/down.
* CTRL + A: Enable/disable transparency (show/hide alpha
channel).
* CTRL + C: Decrease window size.
* CTRL + D: Increase window size.
* CTRL + F: Toggle fullscreen mode.
* CTRL + N: Change normalization mode (can be { none |
normal | channel-by-channel }).
* CTRL + O: Save a copy of the input image, as a numbered
file ’gmic_xxxxxx.gmz’.
* CTRL + R: Reset both window size and view.
* CTRL + S: Save a screenshot of the current view, as a
numbered file ’gmic_xxxxxx.png’.
* CTRL + SPACE: Reset view.
* CTRL + X: Show/hide axes.
* CTRL + Z: Hold/release aspect ratio.
d3d:
Shortcut for command ’display3d’.
display3d:
_[background_image],_exit_on_anykey={ 0 | 1 } |
_exit_on_anykey={ 0 | 1 }
Display selected
3D objects in an interactive viewer (use the instant display
window [0] if opened).
(equivalent to shortcut command
’d3d’).
Default values: ’[background_image]=(default)’ and ’exit_on_anykey=0’.
da:
Shortcut for command ’display_array’.
display_array:
_width>0,_height>0
Display images in interactive windows where pixel neighborhoods can be explored.
Default values: ’width=13’ and ’height=width’.
dc:
Shortcut for command
’display_camera’.
display_camera:
Open camera viewer.
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,_vertex_type,_xmin,_xmax,_ymin,_ymax,_xlabel,_ylabel
Render graph
plot from selected image data.
’plot_type’ can be { 0=none | 1=lines
| 2=splines | 3=bar }.
’vertex_type’ can be { 0=none |
1=points | 2,3=crosses | 4,5=circles | 6,7=squares }.
’xmin’,’xmax’,’ymin’,’ymax’
set the coordinates of the displayed xy-axes.
if specified ’width’ or
’height’ is ’0’, then
image size is set to half the screen size.
Default
values: ’width=0’,
’height=0’,
’plot_type=1’,
’vertex_type=1’,
’xmin=xmax=ymin=ymax=0
(auto)’,
’xlabel="x-axis"’ and
’ylabel="y-axis"’.
Example: [#1] 128,1,1,1,’cos(x/10+u)’ +display_graph 400,300,3
dh:
Shortcut for command
’display_histogram’.
display_histogram:
_width>=0,_height>=0,_clusters>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_antialiased={
0 | 1 },_is_decorated={ 0 | 1 },_xlabel,_ylabel
Render 2D or 3D
parametric curve or point clouds from selected image data.
Curve points are defined as pixels of a 2 or 3-channel
image.
If the point image contains more than 3 channels, additional
channels 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 window.
(equivalent to shortcut command
’dp’).
dp0:
Shortcut for command
’display_parallel0’.
display_parallel0:
Display each
selected image in a separate interactive display window,
without value normalization.
(equivalent to shortcut command
’dp0’).
display_polar:
_width>32,_height>32,_outline_type,_fill_R,_fill_G,_fill_B,_theta_start,_theta_end,_xlabel,_ylabel
Render polar
curve from selected image data.
’outline_type’ can be { r<0=dots
with radius -r | 0=no outline | r>0=lines+dots with
radius r }.
’fill_color’ can be { -1=no fill |
R,G,B=fill with specified color }.
Default
values: ’width=500’,
’height=width’,
’outline_type=1’,
’fill_R=fill_G=fill_B=200’,
’theta_start=0’,
’theta_end=360’,
’xlabel="x-axis"’ and
’ylabel="y-axis"’.
Example:
[#1] 300,1,1,1,’0.3+abs(cos(10*pi*x/w))+u(0.4)’
display_polar 512,512,4,200,255,200
[#2] 3000,1,1,1,’xˆ3/1e10’ display_polar
400,400,1,-1,,,0,{15*360}
dq:
Shortcut for command
’display_quiver’.
display_quiver:
_size_factor>0,_arrow_size>=0,_color_mode={
0=monochrome | 1=grayscale | 2=color }
Render selected
images of 2D vectors as a field of 2D arrows.
(equivalent to shortcut command
’dq’).
Default values: ’size_factor=16’, ’arrow_size=1.5’ and ’color_mode=1’.
Example: [#1] image.jpg +luminance gradient[-1] xy rv[-2,-1] *[-2] -1 a[-2,-1] c crop 60,10,90,30 +display_quiver[1] ,
drgba:
Shortcut for command ’display_rgba’.
display_rgba:
_background_RGB_color
Render selected
RGBA images over a checkerboard or colored background.
(equivalent to shortcut command
’drgba’).
Default values: ’background_RGB_color=undefined’ (checkerboard).
Example: [#1] image.jpg +norm threshold[-1] 40% blur[-1] 3 normalize[-1] 0,255 append c display_rgba
dt:
Shortcut for command
’display_tensors’.
display_tensors:
_size_factor>0,_ellipse_size>=0,_color_mode={
0=monochrome | 1=grayscale | 2=color },_outline>=0
Render selected
images of tensors as a field of 2D ellipses.
(equivalent to shortcut command
’dt’).
Default values: ’size_factor=16’, ’ellipse_size=1.5’, ’color_mode=2’ and ’outline=2’.
Example: [#1] image.jpg +diffusiontensors 0.1,0.9 resize2dx. 32 +display_tensors. 64,2
Tutorial: https://gmic.eu/tutorial/_display_tensors.shtml
dw:
Shortcut for command ’display_warp’.
display_warp:
_cell_size>0
Render selected
2D warping fields.
(equivalent to shortcut command
’dw’).
Default value: ’cell_size=15’.
Example: [#1] 400,400,1,2,’x=x-w/2;y=y-h/2;r=sqrt(x*x+y*y);a=atan2(y,x);5*sin(r/10)*[cos(a),sin(a)]’ +display_warp 10
e (+):
Shortcut for command ’echo’.
echo (+):
message
Output specified
message on the error output.
(equivalent to shortcut command ’e’).
Command selection (if any) stands for displayed call stack subset instead of image indices.
echo_file:
filename,message
Output specified
message, appending it to specified output file.
(similar to ’echo’ for specified output
file stream).
echo_stdout:
message
Output specified
message, on the standard output (stdout).
(similar to ’echo’ for output on standard
output instead of standard error).
function1d:
0<=smoothness<=1,x0>=0,y0,x1>=0,y1,...,xn>=0,yn
Insert
continuous 1D function from specified list of keypoints
(xk,yk)
in range [0,max(xk)] (xk are positive integers).
Default values: ’smoothness=1’ and ’x0=y0=0’.
Example: [#1] function1d 1,0,0,10,30,40,20,70,30,80,0 +display_graph 400,300
funny_oneliners:
This commands shows examples of funny oneliners that produce cool results!
Example:
[#1] 729,729,1,3,"c(x,y,l) = (S = round(w/3ˆl);
(int(x/S)%3)*(int(y/S)%3)==1?255:l<6?c(x,y,l + 1):0);
c(x,y,1)" nm "Sierpinski Carpet"
[#2]
1024,1024,1,1,">x>y?0:y<2?1:xor(j(0,-1),j(-1,-1))"
f. "255*j(-w/2+y/2,0)" nm "Sierpinksi
Triangle"
[#3] 500,500 repeat 10 +noise_poissondisk[0] {3+$>} done
rm[0] a z f "!z?(R=cut(norm(x-w/2,
y-h/2)/20,0,d-1);i(x,y,R)):0" slices 0 to_rgb f
"max(I)?u([255,255,255]):I" blur_radial 0.6%
equalize n 0,255 nm "Light Speed"
[#4] 100000,1,1,1,0.6180339887498948482*x round f i-j[-1]
(1,-1) * cumulate mod 4 + 1 +f arg(i, 1,1,-1,-1) f..
arg(i,-1,1,1,-1) cumulate -[0] {0,im} -[1] {1,im} a y
pointcloud 0 b 1 nm "Fibonacci Word, by James
Prichard"
[#5]
1000,1000,1,1,f(x,y,l)=l?f(max(x,y)%3,abs(min(x,y))*3,l-1):x;f(x/w-.7,y/w,6)
nm "Recursive macro, by James Prichard"
i (+):
Shortcut for command ’input’.
input
(+):
[type:]filename |
[type:]http://URL |
[selection]x_nb_copies>0 |
{ width>0[%] | [image_w] },{ _height>0[%] | [image_h]
},{ _depth>0[%] | [image_d] },{ _spectrum>0[%] |
[image_s] },_{ value1,_value2,... | ’formula’ }
|
(value1{,|;|/|ˆ}value2{,|;|/|ˆ}...[:{x|y|z|c|,|;|/|ˆ}]) |
0
Insert a new
image taken from a filename or from a copy of an existing
image [index],
or insert new image with specified dimensions and values.
Single quotes may be omitted in
’formula’. Specifying argument
’0’ inserts an ’empty’
image.
(equivalent to shortcut command ’i’).
Default values: ’nb_copies=1’, ’height=depth=spectrum=1’ and ’value1=0’.
Example:
[#1] input image.jpg
[#2] input (1,2,3;4,5,6;7,8,9ˆ9,8,7;6,5,4;3,2,1)
[#3] image.jpg (1,2,3;4,5,6;7,8,9) (255ˆ128ˆ64)
400,400,1,3,’if(x>w/2,x,y)*c’
Tutorial: https://gmic.eu/tutorial/_input.shtml
input_565:
filename,width>0,height>0,reverse_endianness={ 0 | 1
}
Insert image data from a raw RGB-565 file, at the end of the list.
Default value: ’reverse_endianness=0’.
input_cube:
"filename",_convert_1d_cluts_to_3d={ 0 | 1 }.
Insert CLUT data from a .cube filename (Adobe CLUT file format).
Default value: ’convert_1d_cluts_to_3d=1’.
input_flo:
"filename"
Insert optical flow data from a .flo filename (vision.middlebury.edu file format).
ig:
Shortcut for command ’input_glob’.
input_glob:
pattern
Insert new
images from several filenames that match the specified glob
pattern.
(equivalent to shortcut command
’ig’).
input_gpl:
filename
Input specified filename as a .gpl palette data file.
it:
Shortcut for command ’input_text’.
input_text:
filename
Input specified
text-data filename as a new image.
(equivalent to shortcut command
’it’).
network
(+):
mode={ -1=disabled | 0=enabled w/o timeout | >0=enabled
w/ specified timeout in seconds }
Enable/disable
load-from-network and set corresponding timeout.
(Default mode is ’enabled w/o
timeout’).
o (+):
Shortcut for command ’output’.
output
(+):
[type:]filename,_format_options
Output selected
images as one or several numbered file(s).
(equivalent to shortcut command ’o’).
Default value: ’format_options’=(undefined).
output_565:
"filename",reverse_endianness={ 0=false | 1=true
}
Output selected images as raw RGB-565 files.
Default value: ’reverse_endianness=0’.
output_cube:
"filename"
Output selected CLUTs as a .cube file (Adobe CLUT format).
output_flo:
"filename"
Output selected optical flow as a .flo file (vision.middlebury.edu file format).
output_ggr:
filename,_gradient_name
Output selected
images as .ggr gradient files (GIMP).
If no gradient name is specified, it is deduced from the
filename.
ot:
Shortcut for command ’output_text’.
output_text:
filename
Output selected
images as text-data filenames.
(equivalent to shortcut command
’ot’).
on:
Shortcut for command ’outputn’.
outputn:
filename,_index
Output selected
images as automatically numbered filenames in repeat...done
loops.
(equivalent to shortcut command
’on’).
op:
Shortcut for command ’outputp’.
outputp:
prefix
Output selected
images as prefixed versions of their original filenames.
(equivalent to shortcut command
’op’).
Default value: ’prefix=_’.
ow:
Shortcut for command ’outputw’.
outputw:
Output selected
images by overwriting their original location.
(equivalent to shortcut command
’ow’).
ox:
Shortcut for command ’outputx’.
outputx:
extension1,_extension2,_...,_extensionN,_output_at_same_location={
0 | 1 }
Output selected
images with same base filenames but for N different
extensions.
(equivalent to shortcut command
’ox’).
Default value: ’output_at_same_location=0’.
parse_cli:
_output_mode,_{ * | command_name }
Parse definition
of ’’-documented commands and output info about
them in specified output mode.
’output_mode’ can be { ascii |
bashcompletion | html | images | print }.
Default values: ’output_mode=print’ and ’command_name=*’.
parse_gui:
_outputmode,_{ * | filter_name}
Parse selected
filter definitions and generate info about filters in
selected output mode.
’outputmode’ can be { json | list |
print | strings | update | zart }.
It is possible to define a custom output mode, by
implementing the following commands
(’outputmode’ must be replaced by the
name of the custom user output mode):
* ’parse_gui_outputmode’ : A command that
outputs the parsing information with a custom format.
* ’parse_gui_parseparams_outputmode’
(optional): A simple command that returns 0 or 1. It tells
the
parser whether parameters of matching filter must be
analyzed (slower) or not.
* ’parse_gui_trigger_outputmode’
(optional): A command that is called by the parser just
before
parsing the set of each matching filters.
Here is the list of global variables set by the parser,
accessible in command
’parse_gui_outputmode’:
’$_nbfilters’: Number of matching
filters.
’$_nongui’ (stored as an image): All
merged lines in the file that do not correspond to
’#@gui’
lines.
For each filter * ’$_fF_name’ : Filter
name.
* ’$_fF_path’ : Full path.
* ’$_fF_locale’ : Filter locale (empty,
if not specified).
* ’$_fF_command’ : Filter command.
* ’$_fF_commandpreview’ : Filter preview
command (empty, if not specified).
* ’$_fF_zoomfactor’ : Default zoom factor
(empty, if not specified).
* ’$_fF_zoomaccurate’ : Is preview
accurate when zoom changes ? (can be { 0=false | 1=true
}).
* ’$_fF_inputmode’ : Default preferred
input mode (empty, if not specified).
* ’$_fF_hide’ : Path of filter hid by
current filter (for localized filters, empty if not
specified).
* ’$_fF_nbparams’ : Number of parameters.
For each parameter * ’$_fF_pP_name’ :
Parameter name.
* ’$_fF_pP_type’ : Parameter type.
* ’$_fF_pP_responsivity’ : Parameter
responsivity (can be { 0 | 1 }).
* ’$_fF_pP_visibility’ : Parameter
visibility.
* ’$_fF_pP_propagation’ : Propagation of
the parameter visibility.
* ’$_fF_pP_nbargs’ : Number of parameter
arguments.
For each argument * ’$_fF_pP_aA’ :
Argument value
Default parameters: ’filter_name=*’ and
’output_format=print’.
pass (+):
_shared_state={ -1=status only | 0=non-shared (copy) |
1=shared | 2=adaptive }
Insert images
from parent context of a custom command or a local
environment.
Command selection (if any) stands for a selection of images
in the parent context.
By default (adaptive shared state), selected images are
inserted in a shared state if they do not
belong
to the context (selection) of the current custom command or
local environment as well.
Typical use of command ’pass’ concerns
the design of custom commands that take images as arguments.
This commands return the list of corresponding indices in
the status.
Default value: ’shared_state=2’.
Example: [#1] command "average : pass$""1 add[ˆ-1] [-1] remove[-1] div 2" 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,_vertex_type,_xmin,xmax,_ymin,_ymax,_exit_on_anykey={
0 | 1 }
Display selected
images or formula in an interactive viewer (use the instant
display window [0] if
opened).
’plot_type’ can be { 0=none | 1=lines
| 2=splines | 3=bar }.
’vertex_type’ can be { 0=none |
1=points | 2,3=crosses | 4,5=circles | 6,7=squares }.
’xmin’, ’xmax’,
’ymin’, ’ymax’ set the
coordinates of the displayed xy-axes.
Default
values: ’plot_type=1’,
’vertex_type=1’,
’xmin=xmax=ymin=ymax=0 (auto)’ and
’exit_on_anykey=0’.
p (+):
Shortcut for command ’print’.
print (+):
Output
information on selected images, on the standard error
(stderr).
(equivalent to shortcut command ’p’).
random_pattern:
_width>0,_height>0,_min_detail_level>=0
Insert a new RGB
image of specified size at the end of the image list,
rendered with a random
pattern.
Default values: ’width=height=512’ and ’min_detail_level=2’.
Example: [#1] repeat 6 random_pattern 256 done
screen
(+):
_x0[%],_y0[%],_x1[%],_y1[%]
Take screenshot,
optionally grabbed with specified coordinates, and insert it
at the end of the image list.
select
(+):
feature_type,_X[%]>=0,_Y[%]>=0,_Z[%]>=0,_exit_on_anykey={
0 | 1 },_is_deep_selection={ 0 | 1 }
Interactively
select a feature from selected images (use the instant
display window [0] if opened).
’feature_type’ can be { 0=point |
1=segment | 2=rectangle | 3=ellipse }.
Arguments
’X’,’Y’,’Z’
determine the initial selection view, for 3D volumetric
images.
The retrieved feature is returned as a 3D vector (if
’feature_type==0’) or as a 6d vector
(if ’feature_type!=0’) containing the
feature coordinates.
Default values: ’X=Y=Z=(undefined)’, ’exit_on_anykey=0’ and ’is_deep_selection=0’.
serialize
(+):
_datatype,_is_compressed={ 0 | 1 },_store_names={ 0 | 1
}
Serialize
selected list of images into a single image, optionnally in
a compressed form.
’datatype’ can be { auto | uchar | char |
ushort | short | uint | int | uint64 | int64 | float |
double }.
Specify ’datatype’ if all selected images
have a range of values constrained to a particular
datatype,
in order to minimize the memory footprint.
The resulting image has only integers values in [0,255] and
can then be saved as a raw image of
unsigned chars (doing so will output a valid .cimg[z] or
.gmz file).
If ’store_names’ is set to
’1’, serialization uses the .gmz format
to store data in memory
(otherwise the .cimg[z] format).
Default values: ’datatype=auto’, ’is_compressed=1’ and ’store_names=1’.
Example: [#1] image.jpg +serialize uchar +unserialize[-1]
shape_circle:
_size>=0
Input a 2D circle binary shape with specified size.
Default value: ’size=512’.
Example: [#1] shape_circle ,
shape_cupid:
_size>=0
Input a 2D cupid binary shape with specified size.
Default value: ’size=512’.
Example: [#1] shape_cupid ,
shape_diamond:
_size>=0
Input a 2D diamond binary shape with specified size.
Default value: ’size=512’.
Example: [#1] shape_diamond ,
shape_dragon:
_size>=0,_recursion_level>=0,_angle
Input a 2D Dragon curve with specified size.
Default value: ’size=512’, ’recursion_level=18’ and ’angle=0’.
Example: [#1] shape_dragon ,
shape_fern:
_size>=0,_density[%]>=0,_angle,0<=_opacity<=1,_type={
0=Asplenium adiantum-nigrum | 1=Thelypteridaceae }
Input a 2D Barnsley fern with specified size.
Default value: ’size=512’, ’density=50%’, ’angle=30’, ’opacity=0.3’ and ’type=0’.
Example: [#1] shape_fern ,
shape_gear:
_size>=0,_nb_teeth>0,0<=_height_teeth<=100,0<=_offset_teeth<=100,0<=_inner_radius<=100
Input a 2D gear binary shape with specified size.
Default
value: ’size=512’,
’nb_teeth=12’,
’height_teeth=20’,
’offset_teeth=0’ and
’inner_radius=40’.
Example: [#1] shape_gear ,
shape_heart:
_size>=0
Input a 2D heart binary shape with specified size.
Default value: ’size=512’.
Example: [#1] shape_heart ,
shape_polygon:
_size>=0,_nb_vertices>=3,_angle
Input a 2D polygonal binary shape with specified geometry.
Default value: ’size=512’, ’nb_vertices=5’ and ’angle=0’.
Example: [#1] repeat 6 shape_polygon 256,{3+$>} done
shape_snowflake:
size>=0,0<=_nb_recursions<=6
Input a 2D snowflake binary shape with specified size.
Default values: ’size=512’ and ’nb_recursions=5’.
Example: [#1] repeat 6 shape_snowflake 256,$> done
shape_star:
_size>=0,_nb_branches>0,0<=_thickness<=1
Input a 2D star binary shape with specified size.
Default values: ’size=512’, ’nb_branches=5’ and ’thickness=0.38’.
Example: [#1] repeat 9 shape_star 256,{$>+2} done
sh (+):
Shortcut for command ’shared’.
shared
(+):
x0[%],x1[%],y[%],z[%],c[%] |
y0[%],y1[%],z[%],c[%] |
z0[%],z1[%],c[%] |
c0[%],c1[%] |
c0[%] |
(no arg)
Insert shared
buffers from (opt. points/rows/planes/channels of) selected
images.
Shared buffers cannot be returned by a command, nor a local
environment.
(equivalent to shortcut command
’sh’).
Example:
[#1] image.jpg shared 1 blur[-1] 3 remove[-1]
[#2] image.jpg repeat s shared 25%,75%,0,$> mirror[-1] x
remove[-1] done
Tutorial: https://gmic.eu/tutorial/_shared.shtml
sp:
Shortcut for command ’sample’.
sample:
_name1={ ? | apples | balloons | barbara | boats | bottles |
butterfly | cameraman | car | cat | cliff | chick | colorful
| david | dog | duck | eagle | elephant | earth | flower |
fruits | gmicky | gmicky_mahvin | gmicky_wilber | greece |
gummy | house | inside | landscape | leaf | lena | leno |
lion | mandrill | monalisa | monkey | parrots | pencils |
peppers | portrait0 | portrait1 | portrait2 | portrait3 |
portrait4 | portrait5 | portrait6 | portrait7 | portrait8 |
portrait9 | roddy | rooster | rose | square | swan | teddy |
tiger | tulips | wall | waterfall | zelda },_name2,
...,_nameN,_width={ >=0 | 0 (auto) },_height = { >=0 |
0 (auto) } |
(no arg)
Input a new
sample RGB image (opt. with specified size).
(equivalent to shortcut command
’sp’).
Argument ’name’ can be replaced by an integer which serves as a sample index.
Example: [#1] repeat 6 sample done
srand
(+):
value |
(no arg)
Set random
generator seed.
If no argument is specified, a random value is used as the
random generator seed.
store
(+):
_is_compressed={ 0 | 1
},variable_name1,_variable_name2,...
Store selected
images into one or several named variables.
Selected images are transferred to the variables, and are so
removed from the image list.
(except if the prepended variant of the command
’+store[selection]’ is used).
If a single variable name is specified, all images of the
selection are assigned
to the named variable. Otherwise, there must be as many
variable names as images
in the selection, and each selected image is assigned to
each specified named variable.
Use command ’input $variable’ to bring
the stored images back in the list.
Default value: ’is_compressed=0’.
Example: [#1] sample eagle,earth store img1,img2 input $img2 $img1
testimage2d:
_width>0,_height>0,_spectrum>0
Input a 2D synthetic image.
Default values: ’width=512’, ’height=width’ and ’spectrum=3’.
Example: [#1] testimage2d 512
um:
Shortcut for command ’uncommand’.
uncommand
(+):
command_name[,_command_name2,...] |
*
Discard
definition of specified custom commands.
Set argument to ’*’ for discarding all
existing custom commands.
(equivalent to shortcut command
’um’).
uniform_distribution:
nb_levels>=1,spectrum>=1
Input set of uniformly distributed spectrum-d points in [0,1]ˆspectrum.
Example: [#1] uniform_distribution 64,3 * 255 +distribution3d circles3d[-1] 10
unserialize (+):
Recreate lists of images from serialized image buffers, obtained with command ’serialize’.
up:
Shortcut for command ’update’.
update:
Update commands
from the latest definition file on the G’MIC
server.
(equivalent to shortcut command
’up’).
v (+):
Shortcut for command ’verbose’.
verbose
(+):
level |
{ + | - }
Set or
increment/decrement the verbosity level. Default level is 0.
(equivalent to shortcut command ’v’).
When ’level’>0, G’MIC log messages are displayed on the standard error (stderr).
Default value: ’level=1’.
wait (+):
delay |
(no arg)
Wait for a given
delay (in ms), optionally since the last call to
’wait’.
or wait for a user event occurring on the selected instant
display windows.
’delay’ can be { <0=delay+flush
events | 0=event | >0=delay }.
Command selection (if any) stands for instant display window
indices instead of image indices.
If no window indices are specified and if
’delay’ is positive, the command results
in a ’hard’ sleep during specified
delay.
Default value: ’delay=0’.
warn (+):
_force_visible={ 0 | 1 },_message
Print specified
warning message, on the standard error (stderr).
Command selection (if any) stands for displayed call stack
subset instead of image indices.
w (+):
Shortcut for command ’window’.
window
(+):
_width[%]>=-1,_height[%]>=-1,_normalization,_fullscreen,_pos_x[%],_pos_y[%],_title
Display selected
images into an instant display window with specified size,
normalization type,
fullscreen mode and title.
(equivalent to shortcut command ’w’).
If
’width’ or ’height’ is
set to -1, the corresponding dimension is adjusted to the
window
or image size.
Specify ’pos_x’ and
’pos_y’ arguments only if the window has
to be moved to the specified
coordinates. Otherwise, they can be avoided.
’width’=0 or
’height’=0 closes the instant display
window.
’normalization’ can be { -1=keep same
| 0=none | 1=always | 2=1st-time | 3=auto }.
’fullscreen’ can be { -1=keep same |
0=no | 1=yes }.
You can manage up to 10 different instant display windows by
using the numbered variants
’w0’ (default, eq. to
’w’),’w1’,...,’w9’
of the command ’w’.
Invoke ’window’ with no selection to make
the window visible, if is has been closed by the user.
Default values: ’width=height=normalization=fullscreen=-1’ and ’title=(undefined)’.
12.3. List
Manipulation
-----------------
k (+):
Shortcut for command ’keep’.
keep (+):
Keep only
selected images.
(equivalent to shortcut command ’k’).
Example:
[#1] image.jpg split x keep[0-50%:2] append x
[#2] image.jpg split x keep[ˆ30%-70%] append x
mv (+):
Shortcut for command ’move’.
move (+):
position[%]
Move selected
images at specified position.
(equivalent to shortcut command
’mv’).
Example:
[#1] image.jpg split x,3 move[1] 0
[#2] image.jpg split x move[50%--1:2] 0 append x
nm (+):
Shortcut for command ’name’.
name (+):
"name1","name2",...
Set names of
selected images.
* If the selection contains a single image, then it is
assumed the command has a single name
argument (possibly containing multiple comas).
* If the selection contains more than one image, each
command argument defines a single image
name for each image of the selection.
(equivalent to shortcut command
’nm’).
Example: [#1] image.jpg name image blur[image] 2
Tutorial: https://gmic.eu/tutorial/_name.shtml
rm (+):
Shortcut for command ’remove’.
remove (+):
Remove selected
images.
(equivalent to shortcut command
’rm’).
Example:
[#1] image.jpg split x remove[30%-70%] append x
[#2] image.jpg split x remove[0-50%:2] append x
remove_duplicates:
Remove duplicates images in the selected images list.
Example: [#1] (1,2,3,4,2,4,3,1,3,4,2,1) split x remove_duplicates append x
remove_empty:
Remove empty images in the selected image list.
rmn:
Shortcut for command ’remove_named’.
remove_named:
"name1","name2",...
Remove all
images with specified names from the list of images.
Does nothing if no images with those names exist.
(equivalent to shortcut command
’rmn’).
rv (+):
Shortcut for command ’reverse’.
reverse (+):
Reverse
positions of selected images.
(equivalent to shortcut command
’rv’).
Example:
[#1] image.jpg split x,3 reverse[-2,-1]
[#2] image.jpg split x,-16 reverse[50%-100%] append x
sort_list:
_ordering={ + | - },_criterion
Sort list of selected images according to the specified image criterion.
Default values: ’ordering=+’, ’criterion=i’.
Example: [#1] (1;4;7;3;9;2;4;7;6;3;9;1;0;3;3;2) split y sort_list +,i append y
12.4.
Mathematical Operators
----------------------
abs (+):
Compute the pointwise absolute values of selected images.
Example:
[#1] image.jpg +sub {ia} abs[-1]
[#2] 300,1,1,1,’cos(20*x/w)’ +abs display_graph
400,300
acos (+):
Compute the pointwise arccosine of selected images.
Example:
[#1] image.jpg +normalize -1,1 acos[-1]
[#2] 300,1,1,1,’cut(x/w+0.1*u,0,1)’ +acos
display_graph 400,300
Tutorial: https://gmic.eu/tutorial/trigometric-and-inverse-trigometric-commands.shtml
acosh (+):
Compute the pointwise hyperbolic arccosine of selected images.
+ (+):
Shortcut for command ’add’.
add (+):
value[%] |
[image] |
’formula’ |
(no arg)
Add specified
value, image or mathematical expression to selected images,
or compute the pointwise
sum of selected images.
(equivalent to shortcut command ’+’).
Example:
[#1] image.jpg +add 30% cut 0,255
[#2] image.jpg +blur 5 normalize 0,255 add[1] [0]
[#3] image.jpg add
’80*cos(80*(x/w-0.5)*(y/w-0.5)+c)’ cut 0,255
[#4] image.jpg repeat 9 +rotate[0] {$>*36},1,0,50%,50%
done add div 10
&
(+):
Shortcut for command ’and’.
and (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
bitwise AND of selected images with specified value, image
or mathematical expression,
or compute the pointwise sequential bitwise AND of selected
images.
(equivalent to shortcut command
’&’).
Example:
[#1] image.jpg and {128+64}
[#2] image.jpg +mirror x and
argmax:
Compute the
argmax of selected images. Returns a single image
with each pixel value being the index of the input image
with maximal value.
Example: [#1] image.jpg sample lena,lion,square +argmax
argmaxabs:
Compute the
argmaxabs of selected images. Returns a single image
with each pixel value being the index of the input image
with maxabs value.
argmin:
Compute the
argmin of selected images. Returns a single image
with each pixel value being the index of the input image
with minimal value.
Example: [#1] image.jpg sample lena,lion,square +argmin
argminabs:
Compute the
argminabs of selected images. Returns a single image
with each pixel value being the index of the input image
with minabs value.
asin (+):
Compute the pointwise arcsine of selected images.
Example:
[#1] image.jpg +normalize -1,1 asin[-1]
[#2] 300,1,1,1,’cut(x/w+0.1*u,0,1)’ +asin
display_graph 400,300
Tutorial: https://gmic.eu/tutorial/trigometric-and-inverse-trigometric-commands.shtml
asinh (+):
Compute the pointwise hyperbolic arcsine of selected images.
atan (+):
Compute the pointwise arctangent of selected images.
Example:
[#1] image.jpg +normalize 0,8 atan[-1]
[#2] 300,1,1,1,’4*x/w+u’ +atan display_graph
400,300
Tutorial: https://gmic.eu/tutorial/trigometric-and-inverse-trigometric-commands.shtml
atan2
(+):
[x_argument]
Compute the
pointwise oriented arctangent of selected images.
Each selected image is regarded as the y-argument of the
arctangent function, while the
specified image gives the corresponding x-argument.
Example: [#1] (-1,1) (-1;1) resize 400,400,1,1,3 atan2[1] [0] keep[1] mod {pi/8}
Tutorial: https://gmic.eu/tutorial/trigometric-and-inverse-trigometric-commands.shtml
atanh (+):
Compute the pointwise hyperbolic arctangent of selected images.
<<
(+):
Shortcut for command ’bsl’.
bsl (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
bitwise left shift of selected images with specified value,
image or mathematical
expression, or compute the pointwise sequential bitwise left
shift of selected images.
(equivalent to shortcut command
’<<’).
Example: [#1] image.jpg bsl ’round(3*x/w,0)’ cut 0,255
>>
(+):
Shortcut for command ’bsr’.
bsr (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
bitwise right shift of selected images with specified value,
image or mathematical
expression, or compute the pointwise sequential bitwise
right shift of selected images.
(equivalent to shortcut command
’>>’).
Example: [#1] image.jpg bsr ’round(3*x/w,0)’ cut 0,255
cos (+):
Compute the pointwise cosine of selected images.
Example:
[#1] image.jpg +normalize 0,{2*pi} cos[-1]
[#2] 300,1,1,1,’20*x/w+u’ +cos display_graph
400,300
Tutorial: https://gmic.eu/tutorial/trigometric-and-inverse-trigometric-commands.shtml
cosh (+):
Compute the pointwise hyperbolic cosine of selected images.
Example:
[#1] image.jpg +normalize -3,3 cosh[-1]
[#2] 300,1,1,1,’4*x/w+u’ +cosh display_graph
400,300
/ (+):
Shortcut for command ’div’.
div (+):
value[%] |
[image] |
’formula’ |
(no arg)
Divide selected
images by specified value, image or mathematical expression,
or compute the
pointwise quotient of selected images.
(equivalent to shortcut command ’/’).
Example:
[#1] image.jpg div ’1+abs(cos(x/10)*sin(y/10))’
[#2] image.jpg +norm add[-1] 1 +div
div_complex:
[divider_real,divider_imag],_epsilon>=0
Perform division
of the selected complex pairs (real1,imag1,...,realN,imagN)
of images by
specified complex pair of images
(divider_real,divider_imag).
In complex pairs, the real image must be always located
before the imaginary image in the image
list.
Default value: ’epsilon=1e-8’.
== (+):
Shortcut for command ’eq’.
eq (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
boolean equality of selected images with specified value,
image or mathematical
expression, or compute the boolean equality of selected
images.
(equivalent to shortcut command
’==’).
Example:
[#1] image.jpg round 40 eq {round(ia,40)}
[#2] image.jpg +mirror x eq
exp (+):
Compute the pointwise exponential of selected images.
Example:
[#1] image.jpg +normalize 0,2 exp[-1]
[#2] 300,1,1,1,’7*x/w+u’ +exp display_graph
400,300
>=
(+):
Shortcut for command ’ge’.
ge (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
boolean ’greater or equal than’ of
selected images with specified value, image
or mathematical expression, or compute the boolean
’greater or equal than’ of selected
images.
(equivalent to shortcut command
’>=’).
Example:
[#1] image.jpg ge {ia}
[#2] image.jpg +mirror x ge
> (+):
Shortcut for command ’gt’.
gt (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
boolean ’greater than’ of selected images
with specified value, image or mathematical
expression, or compute the boolean ’greater
than’ of selected images.
(equivalent to shortcut command
’>’).
Example:
[#1] image.jpg gt {ia}
[#2] image.jpg +mirror x gt
<=
(+):
Shortcut for command ’le’.
le (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
boolean ’less or equal than’ of selected
images with specified value, image or
mathematical expression, or compute the boolean
’less or equal than’ of selected images.
(equivalent to shortcut command
’<=’).
Example:
[#1] image.jpg le {ia}
[#2] image.jpg +mirror x le
< (+):
Shortcut for command ’lt’.
lt (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
boolean ’less than’ of selected images
with specified value, image or mathematical
expression, or compute the boolean ’less
than’ of selected images.
(equivalent to shortcut command
’<’).
Example:
[#1] image.jpg lt {ia}
[#2] image.jpg +mirror x lt
log (+):
Compute the pointwise base-e logarithm of selected images.
Example:
[#1] image.jpg +add 1 log[-1]
[#2] 300,1,1,1,’7*x/w+u’ +log display_graph
400,300
log10 (+):
Compute the pointwise base-10 logarithm of selected images.
Example:
[#1] image.jpg +add 1 log10[-1]
[#2] 300,1,1,1,’7*x/w+u’ +log10 display_graph
400,300
log2 (+):
Compute the pointwise base-2 logarithm of selected images
Example:
[#1] image.jpg +add 1 log2[-1]
[#2] 300,1,1,1,’7*x/w+u’ +log2 display_graph
400,300
max (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
maximum between selected images and specified value, image
or mathematical expression,
or compute the pointwise maxima between selected images.
Example:
[#1] image.jpg +mirror x max
[#2] image.jpg max
’R=((x/w-0.5)ˆ2+(y/h-0.5)ˆ2)ˆ0.5;255*R’
maxabs
(+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
maxabs between selected images and specified value, image or
mathematical expression,
or compute the pointwise maxabs between selected images.
m/ (+):
Shortcut for command ’mdiv’.
mdiv (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
matrix division of selected matrices/vectors by specified
value, image or mathematical
expression, or compute the matrix division of selected
images.
(equivalent to shortcut command
’m/’).
med:
Compute the median of selected images.
Example: [#1] image.jpg sample lena,lion,square +med
min (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
minimum between selected images and specified value, image
or mathematical expression,
or compute the pointwise minima between selected images.
Example:
[#1] image.jpg +mirror x min
[#2] image.jpg min
’R=((x/w-0.5)ˆ2+(y/h-0.5)ˆ2)ˆ0.5;255*R’
minabs
(+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
minabs between selected images and specified value, image or
mathematical expression,
or compute the pointwise minabs between selected images.
% (+):
Shortcut for command ’mod’.
mod (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
modulo of selected images with specified value, image or
mathematical expression, or
compute the pointwise sequential modulo of selected images.
(equivalent to shortcut command ’%’).
Example:
[#1] image.jpg +mirror x mod
[#2] image.jpg mod
’R=((x/w-0.5)ˆ2+(y/h-0.5)ˆ2)ˆ0.5;255*R’
m* (+):
Shortcut for command ’mmul’.
mmul (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
matrix right multiplication of selected matrices/vectors by
specified value, image or
mathematical expression, or compute the matrix right
multiplication of selected images.
(equivalent to shortcut command
’m*’).
Example: [#1] (0,1,0;0,0,1;1,0,0) (1;2;3) +mmul
* (+):
Shortcut for command ’mul’.
mul (+):
value[%] |
[image] |
’formula’ |
(no arg)
Multiply
selected images by specified value, image or mathematical
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 values.
Example: [#1] image.jpg +mul_channels 1,0.5,0.8
mul_complex:
[multiplier_real,multiplier_imag]
Perform
multiplication of the selected complex pairs
(real1,imag1,...,realN,imagN) of images by
specified complex pair of images
(multiplier_real,multiplier_imag).
In complex pairs, the real image must be always located
before the imaginary image in the image
list.
!= (+):
Shortcut for command ’neq’.
neq (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
boolean inequality of selected images with specified value,
image or mathematical
expression, or compute the boolean inequality of selected
images.
(equivalent to shortcut command
’!=’).
Example: [#1] image.jpg round 40 neq {round(ia,40)}
| (+):
Shortcut for command ’or’.
or (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
bitwise OR of selected images with specified value, image or
mathematical expression,
or compute the pointwise sequential bitwise OR of selected
images.
(equivalent to shortcut command ’|’).
Example:
[#1] image.jpg or 128
[#2] image.jpg +mirror x or
ˆ (+):
Shortcut for command ’pow’.
pow (+):
value[%] |
[image] |
’formula’ |
(no arg)
Raise selected
images to the power of specified value, image or
mathematical expression, or compute
the pointwise sequential powers of selected images.
(equivalent to shortcut command
’ˆ’).
Example:
[#1] image.jpg div 255 +pow 0.5 mul 255
[#2] image.jpg gradient pow 2 add pow 0.2
rol (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
bitwise left rotation of selected images with specified
value, image or mathematical
expression, or compute the pointwise sequential bitwise left
rotation of selected images.
Example: [#1] image.jpg rol ’round(3*x/w,0)’ cut 0,255
ror (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
bitwise right rotation of selected images with specified
value, image or mathematical
expression, or compute the pointwise 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/tutorial/trigometric-and-inverse-trigometric-commands.shtml
sinc (+):
Compute the pointwise sinc function of selected images.
Example:
[#1] image.jpg +normalize {-2*pi},{2*pi} sinc[-1]
[#2] 300,1,1,1,’20*x/w+u’ +sinc display_graph
400,300
sinh (+):
Compute the pointwise hyperbolic sine of selected images.
Example:
[#1] image.jpg +normalize -3,3 sinh[-1]
[#2] 300,1,1,1,’4*x/w+u’ +sinh display_graph
400,300
sqr (+):
Compute the pointwise square function of selected images.
Example:
[#1] image.jpg +sqr
[#2] 300,1,1,1,’40*x/w+u’ +sqr display_graph
400,300
sqrt (+):
Compute the pointwise square root of selected images.
Example:
[#1] image.jpg +sqrt
[#2] 300,1,1,1,’40*x/w+u’ +sqrt display_graph
400,300
- (+):
Shortcut for command ’sub’.
sub (+):
value[%] |
[image] |
’formula’ |
(no arg)
Subtract
specified value, image or mathematical expression to
selected images, or compute the
pointwise difference of selected images.
(equivalent to shortcut command ’-’).
Example:
[#1] image.jpg +sub 30% cut 0,255
[#2] image.jpg +mirror x sub[-1] [0]
[#3] image.jpg sub ’i(w/2+0.9*(x-w/2),y)’
[#4] image.jpg +mirror x sub
tan (+):
Compute the pointwise tangent of selected images.
Example:
[#1] image.jpg +normalize {-0.47*pi},{0.47*pi} tan[-1]
[#2] 300,1,1,1,’20*x/w+u’ +tan display_graph
400,300
Tutorial: https://gmic.eu/tutorial/trigometric-and-inverse-trigometric-commands.shtml
tanh (+):
Compute the pointwise hyperbolic tangent of selected images.
Example:
[#1] image.jpg +normalize -3,3 tanh[-1]
[#2] 300,1,1,1,’4*x/w+u’ +tanh display_graph
400,300
xor (+):
value[%] |
[image] |
’formula’ |
(no arg)
Compute the
bitwise XOR of selected images with specified value, image
or mathematical expression,
or compute the pointwise sequential bitwise XOR of selected
images.
Example:
[#1] image.jpg xor 128
[#2] image.jpg +mirror x xor
12.5. Values
Manipulation
-------------------
apply_curve:
0<=smoothness<=1,x0,y0,x1,y1,x2,y2,...,xN,yN
Apply curve transformation to image values.
Default values: ’smoothness=1’, ’x0=0’, ’y0=100’.
Example: [#1] image.jpg +apply_curve 1,0,0,128,255,255,0
apply_gamma:
gamma>=0
Apply gamma correction to selected images.
Example: [#1] image.jpg +apply_gamma 2
balance_gamma:
_ref_color1,...
Compute gamma-corrected color balance of selected image, with respect to specified reference color.
Default value: ’ref_color1=128’.
Example: [#1] image.jpg +balance_gamma 128,64,64
cast:
datatype_source,datatype_target
Cast datatype of
image buffer from specified source type to specified target
type.
’datatype_source’ and
’datatype_target’ can be { uchar | char |
ushort | short | uint | int |
uint64 | int64 | float | double }.
complex2polar:
Compute complex to polar transforms of selected images.
Example: [#1] image.jpg +fft complex2polar[-2,-1] log[-2] shift[-2] 50%,50%,0,0,2 remove[-1]
compress_clut:
_max_error>0,_avg_error>0,_max_nbpoints>=8 | 0
(unlimited),_error_metric={ 0=L2-norm | 1=deltaE_1976 |
2=deltaE_2000 },_reconstruction_colorspace={ 0=srgb | 1=rgb
| 2=lab }, _try_rbf_first={ 0 | 1 }
Compress selected color LUTs as sequences of colored keypoints.
Default
values: ’max_error=1.5’,
’avg_error=0.75’,
’max_nb_points=2048’,
’error_metric=2’,
’reconstruction_colorspace=0’ and
’try_rbf_first=1’.
compress_rle:
_is_binary_data={ 0 | 1 },_maximum_sequence_length>=0
Compress
selected images as 2xN data matrices, using RLE algorithm.
Set ’maximum_sequence_length=0’ to
disable maximum length constraint.
Default values: ’is_binary_data=0’ and ’maximum_sequence_length=0’.
Example: [#1] image.jpg resize2dy 100 quantize 4 round +compress_rle , +decompress_rle[-1]
cumulate
(+):
{ x | y | z | c }...{ x | y | z | c } |
(no arg)
Compute the cumulative function of specified image data, optionally along the specified axes.
Example: [#1] image.jpg +histogram +cumulate[-1] display_graph[-2,-1] 400,300,3
c (+):
Shortcut for command ’cut’.
cut (+):
{ value0[%] | [image0] },{ value1[%] | [image1] } |
[image]
Cut values of
selected images in specified range.
(equivalent to shortcut command ’c’).
Example:
[#1] image.jpg +add 30% cut[-1] 0,255
[#2] image.jpg +cut 25%,75%
decompress_clut:
_width>0,_height>0,_depth>0,_reconstruction_colorspace={
0=srgb | 1=rgb | 2=lab }
Decompress selected colored keypoints into 3D CLUTs, using a mixed RBF/PDE approach.
Default values: ’width=height=depth=33’ and ’reconstruction_colorspace=0’.
decompress_clut_rbf:
_width>0,_height>0,_depth>0,_reconstruction_colorspace={
0=srgb | 1=rgb | 2=lab }
Decompress selected colored keypoints into 3D CLUTs, using RBF thin plate spline interpolation.
Default value: ’width=height=depth=33’ and ’reconstruction_colorspace=0’.
decompress_clut_pde:
_width>0,_height>0,_depth>0,_reconstruction_colorspace={
0=srgb | 1=rgb | 2=lab }
Decompress selected colored keypoints into 3D CLUTs, using multiscale diffusion PDE’s.
Default values: ’width=height=depth=33’ and ’reconstruction_colorspace=0’.
decompress_rle:
Decompress selected data vectors, using RLE algorithm.
discard
(+):
_value1,_value2,... |
{ x | y | z | c}...{ x | y | z | c},_value1,_value2,... |
(no arg)
Discard
specified values in selected images or discard neighboring
duplicate values,
optionally only for the values along the first of a
specified axis.
If no arguments are specified, neighboring duplicate values
are discarded.
If all pixels of a selected image are discarded, an empty
image is returned.
Example:
[#1] (1;2;3;4;3;2;1) +discard 2
[#2] (1,2,2,3,3,3,4,4,4,4) +discard x
eigen2tensor:
Recompose selected pairs of eigenvalues/eigenvectors as 2x2 or 3x3 tensor fields.
Tutorial: https://gmic.eu/tutorial/_eigen2tensor.shtml
endian
(+):
_datatype
Reverse data
endianness of selected images, eventually considering the
pixel being of the specified
datatype.
’datatype’ can be { uchar | char |
ushort | short | uint | int | uint64 | int64 | float |
double }.
equalize
(+):
_nb_levels>0[%],_value_min[%],_value_max[%]
Equalize
histograms of selected images.
If value range is specified, the equalization is done only
for pixels in the specified
value range.
Default values: ’nb_levels=256’, ’value_min=0%’ and ’value_max=100%’.
Example:
[#1] image.jpg +equalize
[#2] image.jpg +equalize 4,0,128
f (+):
Shortcut for command ’fill’.
fill (+):
value1,_value2,... |
[image] |
’formula’
Fill selected
images with values read from the specified value list,
existing image
or mathematical expression. Single quotes may be omitted in
’formula’.
(equivalent to shortcut command ’f’).
Example:
[#1] 4,4 fill 1,2,3,4,5,6,7
[#2] 4,4 (1,2,3,4,5,6,7) fill[-2] [-1]
[#3] 400,400,1,3 fill "X=x-w/2; Y=y-h/2;
R=sqrt(Xˆ2+Yˆ2); a=atan2(Y,X); if(R<=180,
255*abs(cos(c+200*(x/w-0.5)*(y/h-0.5))),850*(a%(0.1*(c+1))))"
Tutorial: https://gmic.eu/tutorial/_fill.shtml
index
(+):
{ [palette] | palette_name
},0<=_dithering<=1,_map_palette={ 0 | 1 }
Index selected
vector-valued images by specified vector-valued palette.
’palette_name’ can be { default | hsv |
lines | hot | cool | jet | flag | cube | rainbow | algae |
amp |balance | curl | deep | delta | dense | diff | haline |
ice | matter | oxy | phase | rain |
solar | speed | tarn |tempo | thermal | topo | turbid |
aurora | hocuspocus | srb2 | uzebox }
Default values: ’dithering=0’ and ’map_palette=0’.
Example:
[#1] image.jpg +index 1,1,1
[#2] image.jpg (0;255;255ˆ0;128;255ˆ0;0;255) +index[-2]
[-1],1,1
Tutorial: https://gmic.eu/tutorial/_index.shtml
ir:
Shortcut for command ’inrange’.
inrange:
min[%],max[%],_include_min_boundary={ 0=no | 1=yes
},_include_max_boundary={ 0=no | 1=yes }
Detect pixels
whose values are in specified range [min,max], in selected
images.
(equivalent to shortcut command
’ir’).
Default value: ’include_min_boundary=include_max_boundary=1’.
Example: [#1] image.jpg +inrange 25%,75%
map (+):
[palette],_boundary_conditions |
palette_name,_boundary_conditions
Map specified
vector-valued palette to selected indexed scalar images.
’palette_name’ can be { default | hsv |
lines | hot | cool | jet | flag | cube | rainbow | algae |
amp | balance | curl | deep | delta | dense | diff | gray |
haline | ice | matter | oxy | phase |
rain | solar | speed | tarn | tempo | thermal | topo |
turbid | aurora | hocuspocus | srb2 | uzebox
}
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
Default value: ’boundary_conditions=0’.
Example:
[#1] image.jpg +luminance map[-1] 3
[#2] image.jpg +rgb2ycbcr split[-1] c (0,255,0) resize[-1]
256,1,1,1,3 map[-4] [-1] remove[-1] append[-3--1] c
ycbcr2rgb[-1]
Tutorial: https://gmic.eu/tutorial/_map.shtml
mix_channels:
(a00,...,aMN) |
[matrix]
Apply specified matrix to channels of selected images.
Example: [#1] image.jpg +mix_channels (0,1,0;1,0,0;0,0,1)
negate:
base_value |
(no arg)
Negate image values.
Default value: ’base_value=(undefined)’.
Example: [#1] image.jpg +negate
noise
(+):
std_deviation>=0[%],_noise_type
Add random noise
to selected images.
’noise_type’ can be { 0=gaussian |
1=uniform | 2=salt&pepper | 3=poisson | 4=rice
}.
Default value: ’noise_type=0’.
Example:
[#1] image.jpg +noise[0] 50,0 +noise[0] 50,1 +noise[0] 10,2
cut 0,255
[#2] 300,300,1,3 [0] noise[0] 20,0 noise[1] 20,1 +histogram
100 display_graph[-2,-1] 400,300,3
noise_perlin:
_scale_x[%]>0,_scale_y[%]>0,_scale_z[%]>0,_seed_x,_seed_y,_seed_z
Render 2D or 3D
Perlin noise on selected images, from specified coordinates.
The Perlin noise is a specific type of smooth noise,
described here :
’https://en.wikipedia.org/wiki/Perlin_noise’.
Default values: ’scale_x=scale_y=scale_z=16’ and ’seed_x=seed_y=seed_z=0’.
Example: [#1] 500,500,1,3 noise_perlin ,
noise_poissondisk:
_radius[%]>0,_max_sample_attempts>0
Add poisson disk
sampling noise to selected images.
Implements the algorithm from the article "Fast Poisson
Disk Sampling in Arbitrary Dimensions",
by Robert Bridson (SIGGRAPH’2007).
Default values: ’radius=8’ and ’max_sample_attempts=30’.
Example: [#1] 300,300 noise_poissondisk 8
normp:
p>=0
Compute the pointwise Lp-norm norm of vector-valued pixels in selected images.
Default value: ’p=2’.
Example: [#1] image.jpg +normp[0] 0 +normp[0] 1 +normp[0] 2 +normp[0] inf
norm:
Compute the pointwise euclidean norm of vector-valued pixels in selected images.
Example: [#1] image.jpg +norm
Tutorial: https://gmic.eu/tutorial/_norm.shtml
n (+):
Shortcut for command ’normalize’.
normalize
(+):
{ value0[%] | [image0] },{ value1[%] | [image1]
},_constant_case_ratio |
[image]
Linearly
normalize values of selected images in specified range.
(equivalent to shortcut command ’n’).
Example: [#1] image.jpg split x,2 normalize[-1] 64,196 append x
Tutorial: https://gmic.eu/tutorial/_normalize.shtml
normalize_sum:
Normalize selected images with a unitary sum.
Example: [#1] image.jpg +histogram normalize_sum[-1] display_graph[-1] 400,300
not:
Apply boolean not operation on selected images.
Example: [#1] image.jpg +ge 50% +not[-1]
orientation:
Compute the pointwise orientation of vector-valued pixels in selected images.
Example: [#1] image.jpg +orientation +norm[-2] negate[-1] mul[-2] [-1] reverse[-2,-1]
Tutorial: https://gmic.eu/tutorial/_orientation.shtml
oneminus:
For each selected image, compute one minus image.
Example: [#1] image.jpg normalize 0,1 +oneminus
otsu:
_nb_levels>0
Hard-threshold
selected images using Otsu’s method.
The computed thresholds are returned as a list of values in
the status.
Default value: ’nb_levels=256’.
Example: [#1] image.jpg luminance +otsu ,
polar2complex:
Compute polar to complex transforms of selected images.
quantize:
nb_levels>=1,_keep_values={ 0 | 1 },_quantization_type={
-1=median-cut | 0=k-means | 1=uniform }
Quantize selected images.
Default value: ’keep_values=1’ and ’quantization_type=0’.
Example:
[#1] image.jpg luminance +quantize 3
[#2] 200,200,1,1,’cos(x/10)*sin(y/10)’
+quantize[0] 6 +quantize[0] 4 +quantize[0] 3 +quantize[0]
2
quantize_area:
_min_area>0
Quantize selected images such that each flat region has an area greater or equal to ’min_area’.
Default value: ’min_area=10’.
Example: [#1] image.jpg quantize 3 +blur 1 round[-1] +quantize_area[-1] 2
rand (+):
{ value0[%] | [image0] },_{ value1[%] | [image1] } |
[image]
Fill selected images with random values uniformly distributed in the specified range.
Example: [#1] 400,400,1,3 rand -10,10 +blur 10 sign[-1]
replace:
source,target
Replace pixel values in selected images.
Example: [#1] (1;2;3;4) +replace 2,3
replace_inf:
_expression
Replace all infinite values in selected images by specified expression.
Example: [#1] (0;1;2) log +replace_inf 2
replace_nan:
_expression
Replace all NaN values in selected images by specified expression.
Example: [#1] (-1;0;2) sqrt +replace_nan 2
replace_naninf:
_expression
Replace all NaN and infinite values in selected images by specified expression.
replace_seq:
"search_seq","replace_seq"
Search and replace a sequence of values in selected images.
Example: [#1] (1;2;3;4;5) +replace_seq "2,3,4","7,8"
replace_str:
"search_str","replace_str"
Search and
replace a string in selected images (viewed as strings, i.e.
sequences of character
codes).
Example: [#1] (’"Hello there, how are you ?"’) +replace_str "Hello there","Hi David"
round
(+):
rounding_value>=0,_rounding_type |
(no arg)
Round values of
selected images.
’rounding_type’ can be { -1=backward |
0=nearest | 1=forward }.
Default value: ’rounding_type=0’.
Example:
[#1] image.jpg +round 100
[#2] image.jpg mul {pi/180} sin +round
roundify:
gamma>=0
Apply roundify transformation on float-valued data, with specified gamma.
Default value: ’gamma=0’.
Example: [#1] 1000 fill ’4*x/w’ repeat 5 +roundify[0] {$>*0.2} done append c display_graph 400,300
= (+):
Shortcut for command ’set’.
set (+):
value,_x[%],_y[%],_z[%],_c[%]
Set pixel value
in selected images, at specified coordinates.
(equivalent to shortcut command ’=’).
If specified coordinates are outside the image bounds, no action is performed.
Default values: ’x=y=z=c=0’.
Example:
[#1] 2,2 set 1,0,0 set 2,1,0 set 3,0,1 set 4,1,1
[#2] image.jpg repeat 10000 set
255,{u(100)}%,{u(100)}%,0,{u(100)}% done
threshold:
value[%],_is_soft={ 0 | 1 } :
Threshold values
of selected images.
’soft’ can be { 0=hard-thresholding |
1=soft-thresholding }.
Default value: ’is_soft=0’.
Example: [#1] image.jpg +threshold[0] 50% +threshold[0] 50%,1
Tutorial: https://gmic.eu/tutorial/_threshold.shtml
vector2tensor:
Convert selected vector fields to corresponding tensor fields.
12.6. Colors
------
adjust_colors:
-100<=_brightness<=100,-100<=_contrast<=100,-100<=_gamma<=100,-100<=_hue_shift<=100,
-100<=_saturation<=100,_value_min,_value_max
Perform a global
adjustment of colors on selected images.
Range of correct image values are considered to be in
[value_min,value_max] (e.g. [0,255]).
If ’value_min==value_max==0’, value range
is estimated from min/max values of selected images.
Processed images have pixel values constrained in
[value_min,value_max].
Default
values: ’brightness=0’,
’contrast=0’,
’gamma=0’,
’hue_shift=0’,
’saturation=0’,
’value_min=value_max=0’.
Example: [#1] image.jpg +adjust_colors 0,30,0,0,30
ac:
Shortcut for command
’apply_channels’.
apply_channels:
"command",color_channels,_value_action={ 0=none |
1=cut | 2=normalize }
Apply specified
command on the chosen color channel(s) of each selected
images.
(equivalent to shortcut command
’ac’).
Argument
’color_channels’ refers to a colorspace,
and can be basically one of
{ all | rgba | [s]rgb | ryb | lrgb | ycbcr | lab | lch | hsv
| hsi | hsl | cmy | cmyk | yiq }.
You can also make the processing focus on a few particular
channels of this colorspace,
by setting ’color_channels’ as
’colorspace_channel’ (e.g.
’hsv_h’ for the hue).
All channel values are considered to be provided in the
[0,255] range.
Default value: ’value_action=0’.
Example: [#1] image.jpg +apply_channels "equalize blur 2",ycbcr_cbcr
autoindex:
nb_colors>0,0<=_dithering<=1,_method={ 0=median-cut
| 1=k-means }
Index selected vector-valued images by adapted colormaps.
Default values: ’dithering=0’ and ’method=1’.
Example: [#1] image.jpg +autoindex[0] 4 +autoindex[0] 8 +autoindex[0] 16
bayer2rgb:
_GM_smoothness,_RB_smoothness1,_RB_smoothness2
Transform selected RGB-Bayer sampled images to color images.
Default values: ’GM_smoothness=RB_smoothness=1’ and ’RB_smoothness2=0.5’.
Example: [#1] image.jpg rgb2bayer 0 +bayer2rgb 1,1,0.5
deltaE:
[image],_metric={ 0=deltaE_1976 | 1=deltaE_2000
},"_to_Lab_command"
Compute the CIE
DeltaE color difference between selected images and
specified [image].
Argument ’to_Lab_command’ is a command
able to convert colors of [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=deuteranomaly | 4=tritanopia | 5=tritanomaly |
6=achromatopsia | 7=achromatomaly }
Simulate color blindness vision.
Example: [#1] image.jpg +colorblind 0
colormap:
nb_levels>=0,_method={ 0=median-cut | 1=k-means
},_sort_vectors
Estimate
best-fitting colormap with ’nb_colors’
entries, to index selected images.
Set ’nb_levels==0’ to extract all
existing colors of an image.
’sort_vectors’ can be { 0=unsorted |
1=by increasing norm | 2=by decreasing occurrence }.
Default value: ’method=1’ and ’sort_vectors=1’.
Example: [#1] image.jpg +colormap[0] 4 +colormap[0] 8 +colormap[0] 16
Tutorial: https://gmic.eu/tutorial/_colormap.shtml
compose_channels:
Compose all channels of each selected image, using specified arithmetic operator (+,-,or,min,...).
Default value: ’1=+’.
Example: [#1] image.jpg +compose_channels and
Tutorial: https://gmic.eu/tutorial/_compose_channels.shtml
direction2rgb:
Compute RGB representation of selected 2D direction fields.
Example: [#1] image.jpg luminance gradient append c blur 2 orientation +direction2rgb
ditheredbw:
Create dithered B&W version of selected images.
Example: [#1] image.jpg +equalize ditheredbw[-1]
fc:
Shortcut for command ’fill_color’.
fill_color:
col1,...,colN
Fill selected
images with specified color.
(equivalent to shortcut command
’fc’).
Example: [#1] image.jpg +fill_color 255,0,255
Tutorial: https://gmic.eu/tutorial/_fill_color.shtml
gradient2rgb:
_is_orientation={ 0 | 1 }
Compute RGB representation of 2D gradient of selected images.
Default value: ’is_orientation=0’.
Example: [#1] image.jpg +gradient2rgb 0 equalize[-1]
hcy2rgb:
Convert color representation of selected images from HCY to RGB.
hsi2rgb:
Convert color representation of selected images from HSI to RGB.
hsi82rgb:
Convert color representation of selected images from HSI8 to RGB.
hsl2rgb:
Convert color representation of selected images from HSL to RGB.
hsl82rgb:
Convert color representation of selected images from HSL8 to RGB.
hsv2rgb:
Convert color representation of selected images from HSV to RGB.
Example: [#1] (0,360;0,360ˆ0,0;1,1ˆ1,1;1,1) resize 400,400,1,3,3 hsv2rgb
hsv82rgb:
Convert color representation of selected images from HSV8 to RGB.
int2rgb:
Convert color representation of selected images from INT24 to RGB.
jzazbz2rgb:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from RGB to Jzazbz.
Default value: ’illuminant=2’.
jzazbz2xyz:
Convert color representation of selected images from RGB to XYZ.
lab2lch:
Convert color representation of selected images from Lab to Lch.
lab2rgb:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from Lab to RGB.
Default value: ’illuminant=2’.
Example: [#1] (50,50;50,50ˆ-3,3;-3,3ˆ-3,-3;3,3) resize 400,400,1,3,3 lab2rgb
lab2srgb:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from Lab to sRGB.
Default value: ’illuminant=2’.
Example: [#1] (50,50;50,50ˆ-3,3;-3,3ˆ-3,-3;3,3) resize 400,400,1,3,3 lab2rgb
lab82srgb:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from Lab8 to sRGB.
Default value: ’illuminant=2’.
Example: [#1] (50,50;50,50ˆ-3,3;-3,3ˆ-3,-3;3,3) resize 400,400,1,3,3 lab2rgb
lab2xyz:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from Lab to XYZ.
Default value: ’illuminant=2’.
lab82rgb:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from Lab8 to RGB.
Default value: ’illuminant=2’.
lch2lab:
Convert color representation of selected images from Lch to Lab.
lch2rgb:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from Lch to RGB.
Default value: ’illuminant=2’.
lch82rgb:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from Lch8 to RGB.
Default value: ’illuminant=2’.
luminance:
Compute luminance of selected sRGB images.
Example: [#1] image.jpg +luminance
lightness:
Compute lightness of selected sRGB images.
Example: [#1] image.jpg +lightness
lut_contrast:
_nb_colors>1,_min_rgb_value
Generate a RGB
colormap where consecutive colors have high contrast.
This function performs a specific score maximization to
generate the result, so
it may take some time when ’nb_colors’ is
high.
Default values: ’nb_colors=256’ and ’min_rgb_value=64’.
map_clut:
[clut] | "clut_name"
Map specified RGB color LUT to selected images.
Example: [#1] image.jpg uniform_distribution {2ˆ6},3 mirror[-1] x +map_clut[0] [1]
mix_rgb:
a11,a12,a13,a21,a22,a23,a31,a32,a33
Apply 3x3 specified matrix to RGB colors of selected images.
Default values: ’a11=1’, ’a12=a13=a21=0’, ’a22=1’, ’a23=a31=a32=0’ and ’a33=1’.
Example: [#1] image.jpg +mix_rgb 0,1,0,1,0,0,0,0,1
Tutorial: https://gmic.eu/tutorial/_mix_rgb.shtml
palette:
palette_name | palette_number
Input specified
color palette at the end of the image list.
’palette_name’ can be { default | hsv |
lines | hot | cool | jet | flag | cube | rainbow | parula |
spring | summer | autumn | winter | bone | copper | pink |
vga | algae | amp | balance | curl |
deep | delta | dense | diff | gray | haline | ice | matter |
oxy | phase | rain | solar | speed |
tarn | tempo | thermal | topo | turbid | aurora | hocuspocus
| srb2 | uzebox | amiga7800 |
amiga7800mess | fornaxvoid1 }
Example: [#1] palette hsv
pseudogray:
_max_increment>=0,_JND_threshold>=0,_bits_depth>0
Generate
pseudogray colormap with specified increment and perceptual
threshold.
If ’JND_threshold’ is 0, no perceptual
constraints are applied.
Default values: ’max_increment=5’, ’JND_threshold=2.3’ and ’bits_depth=8’.
Example: [#1] pseudogray 5
replace_color:
tolerance[%]>=0,smoothness[%]>=0,src1,src2,...,dest1,dest2,...
Replace pixels from/to specified colors in selected images.
Example: [#1] image.jpg +replace_color 40,3,204,153,110,255,0,0
retinex:
_value_offset>0,_colorspace={ hsi | hsv | lab | lrgb |
rgb | ycbcr },0<=_min_cut<=100,
0<=_max_cut<=100,_sigma_low>0,_sigma_mid>0,_sigma_high>0
Apply
multi-scale retinex algorithm on selected images to improve
color consistency.
(as described in the page
http://www.ipol.im/pub/art/2014/107/).
Default
values: ’offset=1’,
’colorspace=hsv’,
’min_cut=1’,
’max_cut=1’,
’sigma_low=15’,
’sigma_mid=80’ and
’sigma_high=250’.
rgb2bayer:
_start_pattern=0,_color_grid=0
Transform selected color images to RGB-Bayer sampled images.
Default values: ’start_pattern=0’ and ’color_grid=0’.
Example: [#1] image.jpg +rgb2bayer 0
rgb2cmy:
Convert color representation of selected images from RGB to CMY.
Example: [#1] image.jpg rgb2cmy split c
rgb2cmyk:
Convert color representation of selected images from RGB to CMYK.
Example:
[#1] image.jpg rgb2cmyk split c
[#2] image.jpg rgb2cmyk split c fill[3] 0 append c
cmyk2rgb
rgb2hcy:
Convert color representation of selected images from RGB to HCY.
Example: [#1] image.jpg rgb2hcy split c
rgb2hsi:
Convert color representation of selected images from RGB to HSI.
Example: [#1] image.jpg rgb2hsi split c
rgb2hsi8:
Convert color representation of selected images from RGB to HSI8.
Example: [#1] image.jpg rgb2hsi8 split c
rgb2hsl:
Convert color representation of selected images from RGB to HSL.
Example:
[#1] image.jpg rgb2hsl split c
[#2] image.jpg rgb2hsl +split c add[-3] 100 mod[-3] 360
append[-3--1] c hsl2rgb
rgb2hsl8:
Convert color representation of selected images from RGB to HSL8.
Example: [#1] image.jpg rgb2hsl8 split c
rgb2hsv:
Convert color representation of selected images from RGB to HSV.
Example:
[#1] image.jpg rgb2hsv split c
[#2] image.jpg rgb2hsv +split c add[-2] 0.3 cut[-2] 0,1
append[-3--1] c hsv2rgb
rgb2hsv8:
Convert color representation of selected images from RGB to HSV8.
Example: [#1] image.jpg rgb2hsv8 split c
rgb2int:
Convert color representation of selected images from RGB to INT24 scalars.
Example: [#1] image.jpg rgb2int
rgb2jzazbz:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from RGB to Jzazbz.
Default value: ’illuminant=2’.
rgb2lab:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from RGB to Lab.
Default value: ’illuminant=2’.
rgb2lab8:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from RGB to Lab8.
Default value: ’illuminant=2’.
Example: [#1] image.jpg rgb2lab8 split c
rgb2lch:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from RGB to Lch.
Default value: ’illuminant=2’.
Example: [#1] image.jpg rgb2lch split c
rgb2lch8:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from RGB to Lch8.
Default value: ’illuminant=2’.
Example: [#1] image.jpg rgb2lch8 split c
rgb2luv:
Convert color representation of selected images from RGB to LUV.
Example: [#1] image.jpg rgb2luv split c
rgb2ryb:
Convert color representation of selected images from RGB to RYB.
Example: [#1] image.jpg rgb2ryb split c
rgb2srgb:
Convert color representation of selected images from linear RGB to sRGB.
rgb2xyz:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from RGB to XYZ.
Default value: ’illuminant=2’.
Example: [#1] image.jpg rgb2xyz split c
rgb2xyz8:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from RGB to XYZ8.
Default value: ’illuminant=2’.
Example: [#1] image.jpg rgb2xyz8 split c
rgb2yiq:
Convert color representation of selected images from RGB to YIQ.
Example: [#1] image.jpg rgb2yiq split c
rgb2yiq8:
Convert color representation of selected images from RGB to YIQ8.
Example: [#1] image.jpg rgb2yiq8 split c
rgb2ycbcr:
Convert color representation of selected images from RGB to YCbCr.
Example: [#1] image.jpg rgb2ycbcr split c
rgb2yuv:
Convert color representation of selected images from RGB to YUV.
Example: [#1] image.jpg rgb2yuv split c
rgb2yuv8:
Convert color representation of selected images from RGB to YUV8.
Example: [#1] image.jpg rgb2yuv8 split c
remove_opacity:
Remove opacity channel of selected images.
ryb2rgb:
Convert color representation of selected images from RYB to RGB.
select_color:
tolerance[%]>=0,col1,...,colN
Select pixels with specified color in selected images.
Example: [#1] image.jpg +select_color 40,204,153,110
Tutorial: https://gmic.eu/tutorial/_select_color.shtml
sepia:
Apply sepia tones effect on selected images.
Example: [#1] image.jpg sepia
solarize:
Solarize selected images.
Example: [#1] image.jpg solarize
split_colors:
_tolerance>=0,_max_nb_outputs>0,_min_area>0
Split selected
images as several image containing a single color.
One selected image can be split as at most
’max_nb_outputs’ images.
Output images are sorted by decreasing area of extracted
color regions and have an additional
alpha-channel.
Default values: ’tolerance=0’, ’max_nb_outputs=256’ and ’min_area=8’.
Example: [#1] image.jpg quantize 5 +split_colors , display_rgba
split_opacity:
Split color and opacity parts of selected images.
srgb2lab:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from sRGB to Lab.
Default value: ’illuminant=2’.
Example:
[#1] image.jpg srgb2lab split c
[#2] image.jpg srgb2lab +split c mul[-2,-1] 2.5
append[-3--1] c lab2srgb
srgb2lab8:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from sRGB to Lab8.
Default value: ’illuminant=2’.
srgb2rgb:
Convert color representation of selected images from sRGB to linear RGB.
to_a:
Force selected images to have an alpha channel.
to_color:
Force selected images to be in color mode (RGB or RGBA).
to_colormode:
mode={ 0=adaptive | 1=G | 2=GA | 3=RGB | 4=RGBA }
Force selected images to be in a given color mode.
Default value: ’mode=0’.
to_gray:
Force selected images to be in GRAY mode.
Example: [#1] image.jpg +to_gray
to_graya:
Force selected images to be in GRAYA mode.
to_pseudogray:
_max_step>=0,_is_perceptual_constraint={ 0 | 1
},_bits_depth>0
Convert selected scalar images ([0-255]-valued) to pseudo-gray color images.
Default
values: ’max_step=5’,
’is_perceptual_constraint=1’ and
’bits_depth=8’.
The original pseudo-gray technique has been introduced by
Rich Franzen
[http://r0k.us/graphics/pseudoGrey.html].
Extension of this technique to arbitrary increments for more
tones, has been done by David
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
images.
Argument ’color channels’ is the same as
with command ’apply_channels’.
Default value: ’nb_levels=256’ and ’color_channels=all’.
Example: [#1] image.jpg 100,100,1,3,"u([256,200,100])" +transfer_histogram[0] [1]
transfer_pca:
[reference_image],_color_channels
Transfer mean
and covariance matrix of specified vector-valued reference
image to selected images.
Argument ’color channels’ is the same as
with command ’apply_channels’.
Default value: ’color_channels=all’.
Example: [#1] sample lena,earth +transfer_pca[0] [1]
transfer_rgb:
[target],_gamma>=0,_regularization>=0,_luminosity_constraints>=0,_rgb_resolution>=0,
_is_constraints={ 0 | 1 }
Transfer colors
from selected source images to selected reference image
(given as argument).
’gamma’ determines the importance of
color occurrences in the matching process (0=none to
1=huge).
’regularization’ determines the number of
guided filter iterations to remove quantization effects.
’luminosity_constraints’ tells if
luminosity constraints must be applied on non-confident
matched
colors.
’is_constraints’ tells if additional hard
color constraints must be set (opens an interactive
window).
Default
values:
’gamma=0.3’,’regularization=8’,
’luminosity_constraints=0.1’,
’rgb_resolution=64’ and
’is_constraints=0’.
Example: [#1] sample pencils,wall +transfer_rgb[0] [1],0,0.01
xyz2jzazbz:
Convert color representation of selected images from XYZ to RGB.
xyz2lab:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from XYZ to Lab.
Default value: ’illuminant=2’.
xyz2rgb:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from XYZ to RGB.
Default value: ’illuminant=2’.
xyz82rgb:
illuminant={ 0=D50 | 1=D65 | 2=E } |
(no arg)
Convert color representation of selected images from XYZ8 to RGB.
Default value: ’illuminant=2’.
ycbcr2rgb:
Convert color representation of selected images from YCbCr to RGB.
yiq2rgb:
Convert color representation of selected images from YIQ to RGB.
yiq82rgb:
Convert color representation of selected images from YIQ8 to RGB.
yuv2rgb:
Convert color representation of selected images from YUV to RGB.
yuv82rgb:
Convert selected images from YUV8 to RGB color bases.
12.7.
Geometry Manipulation
---------------------
a (+):
Shortcut for command ’append’.
append
(+):
[image],axis,_centering |
axis,_centering
Append specified
image to selected images, or all selected images together,
along specified axis.
(equivalent to shortcut command ’a’).
’axis’
can be { x | y | z | c }.
Usual ’centering’ values are {
0=left-justified | 0.5=centered | 1=right-justified
}.
Default value: ’centering=0’.
Example:
[#1] image.jpg split y,10 reverse append y
[#2] image.jpg repeat 5 +rows[0] 0,{10+18*$>}% done
remove[0] append x,0.5
[#3] image.jpg append[0] [0],y
append_tiles:
_M>=0,_N>=0,0<=_centering_x<=1,0<=_centering_y<=1
Append MxN
selected tiles as new images.
If ’N’ is set to 0, number of rows is
estimated automatically.
If ’M’ is set to 0, number of columns is
estimated automatically.
If ’M’ and ’N’ are
both set to ’0’, auto-mode is used.
If ’M’ or ’N’ is set
to 0, only a single image is produced.
’centering_x’ and
’centering_y’ tells about the centering
of tiles when they have different sizes.
Default values: ’M=0’, ’N=0’, ’centering_x=centering_y=0.5’.
Example: [#1] image.jpg split xy,4 append_tiles ,
apply_scales:
"command",number_of_scales>0,_min_scale[%]>=0,_max_scale[%]>=0,_scale_gamma>0,_interpolation
Apply specified
command on different scales of selected images.
’interpolation’ can be { 0=none |
1=nearest | 2=average | 3=linear | 4=grid | 5=bicubic |
6=lanczos
}.
Default value: ’min_scale=25%’, ’max_scale=100%’ and ’interpolation=3’.
Example: [#1] image.jpg apply_scales "blur 5 sharpen 1000",4
autocrop
(+):
value1,value2,... |
(no arg)
Autocrop
selected images by specified vector-valued intensity.
If no arguments are provided, cropping value is guessed.
Example: [#1] 400,400,1,3 fill_color 64,128,255 ellipse 50%,50%,120,120,0,1,255 +autocrop
autocrop_components:
_threshold[%],_min_area[%]>=0,_is_high_connectivity={ 0 |
1 },_output_type={ 0=crop | 1=segmentation | 2=coordinates
}
Autocrop and
extract connected components in selected images, according
to a mask given as the last
channel of
each of the selected image (e.g. alpha-channel).
Default values: ’threshold=0%’, ’min_area=0.1%’, ’is_high_connectivity=0’ and ’output_type=1’.
Example: [#1] 256,256 noise 0.1,2 eq 1 dilate_circ 20 label_fg 0,1 normalize 0,255 +neq 0 *[-1] 255 append c +autocrop_components ,
autocrop_seq:
value1,value2,... | auto
Autocrop
selected images using the crop geometry of the last one by
specified vector-valued
intensity,
or by automatic guessing the cropping value.
Default value: auto mode.
Example: [#1] image.jpg +fill[-1] 0 ellipse[-1] 50%,50%,30%,20%,0,1,1 autocrop_seq 0
channels
(+):
{ [image0] | c0[%] },_{ [image1] | c1[%] }
Keep only
specified channels of selected images.
Dirichlet boundary is used when specified channels are out
of range.
Example:
[#1] image.jpg channels 0,1
[#2] image.jpg luminance channels 0,2
columns
(+):
{ [image0] | x0[%] },_{ [image1] | x1[%] }
Keep only
specified columns of selected images.
Dirichlet boundary is used when specified columns are out of
range.
Example: [#1] image.jpg columns -25%,50%
z (+):
Shortcut for command ’crop’.
crop (+):
x0[%],x1[%],_boundary_conditions |
x0[%],y0[%],x1[%],y1[%],_boundary_conditions |
x0[%],y0[%],z0[%],x1[%],y1[%],z1[%],_boundary_conditions |
x0[%],y0[%],z0[%],c0[%],x1[%],y1[%],z1[%],c1[%],_boundary_conditions
Crop selected
images with specified region coordinates.
(equivalent to shortcut command ’z’).
’boundary_conditions’ can be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
Default value: ’boundary_conditions=0’.
Example:
[#1] image.jpg +crop -230,-230,280,280,1 crop[0]
-230,-230,280,280,0
[#2] image.jpg crop 25%,25%,75%,75%
diagonal:
Transform selected vectors as diagonal matrices.
Example: [#1] 1,10,1,1,’y’ +diagonal
elevate:
_depth,_is_plain={ 0 | 1 },_is_colored={ 0 | 1 }
Elevate selected 2D images into 3D volumes.
Default values: ’depth=64’, ’is_plain=1’ and ’is_colored=1’.
expand_x:
size_x>=0,_boundary_conditions={ 0=dirichlet | 1=neumann
| 2=periodic | 3=mirror }
Expand selected images along the x-axis.
Default value: ’boundary_conditions=1’.
Example: [#1] image.jpg expand_x 30,0
expand_xy:
size>=0,_boundary_conditions={ 0=dirichlet | 1=neumann |
2=periodic | 3=mirror }
Expand selected images along the xy-axes.
Default value: ’boundary_conditions=1’.
Example: [#1] image.jpg expand_xy 30,0
expand_xyz:
size>=0,_boundary_conditions={ 0=dirichlet | 1=neumann |
2=periodic | 3=mirror }
Expand selected images along the xyz-axes.
Default value: ’boundary_conditions=1’.
expand_y:
size_y>=0,_boundary_conditions={ 0=dirichlet | 1=neumann
| 2=periodic | 3=mirror }
Expand selected images along the y-axis.
Default value: ’boundary_conditions=1’.
Example: [#1] image.jpg expand_y 30,0
expand_z:
size_z>=0,_boundary_conditions={ 0=dirichlet | 1=neumann
| 2=periodic | 3=mirror }
Expand selected images along the z-axis.
Default value: ’boundary_conditions=1’.
extract:
"condition",_output_type={ 0=xyzc-coordinates |
1=xyz-coordinates | 2=scalar-values | 3=vector-values }
Extract a list
of coordinates or values from selected image, where
specified mathematical condition holds.
For N coordinates matching, result is a 1xNx1x4 image.
Default values: ’output_type=0’.
Example: [#1] sp lena +extract "norm(I)>128",3
extract_region:
[label_image],_extract_xyz_coordinates={ 0 | 1
},_label_1,...,_label_M
Extract all
pixels of selected images whose corresponding label in
’[label_image]’ is equal to
’label_m’,
and output them as M column images.
Default value: ’extract_xyz_coordinates=0’.
Example: [#1] image.jpg +blur 3 quantize. 4,0 +extract_region[0] [1],0,1,3
montage:
"_layout_code",_montage_mode={
0<=centering<=1 | 2<=scale+2<=3 },_output_mode={
0=single layer | 1=multiple layers
},"_processing_command"
Create a single
image montage from selected images, according to specified
layout code :
* ’X’ to assemble all images using an
automatically estimated layout.
* ’H’ to assemble all images
horizontally.
* ’V’ to assemble all images vertically.
* ’A’ to assemble all images as an
horizontal array.
* ’B’ to assemble all images as a
vertical array.
* ’Ha:b’ to assemble two blocks
’a’ and ’b’
horizontally.
* ’Va:b’ to assemble two blocks
’a’ and ’b’
vertically.
* ’Ra’ to rotate a block
’a’ by 90 deg. (’RRa’
for 180 deg. and ’RRRa’ for 270 deg.).
* ’Ma’ to mirror a block
’a’ along the X-axis
(’MRRa’ for the Y-axis).
A block ’a’ can be an image index
(treated periodically) or a nested layout expression
’Hb:c’,’Vb:c’,’Rb’
or
’Mb’ itself.
For example, layout code ’H0:V1:2’
creates an image where image [0] is on the left, and images
[1]
and [2]
vertically packed on the right.
Default
values: ’layout_code=X’,
’montage_mode=2’,
output_mode=’0’ and
’processing_command=""’.
Example: [#1] image.jpg sample ? +plasma[0] shape_cupid 256 normalize 0,255 frame 3,3,0 frame 10,10,255 to_rgb +montage A +montage[ˆ-1] H1:V0:VH2:1H0:3
mirror
(+):
{ x | y | z }...{ x | y | z }
Mirror selected images along specified axes.
Example:
[#1] image.jpg +mirror y +mirror[0] c
[#2] image.jpg +mirror x +mirror y append_tiles 2,2
permute
(+):
permutation_string
Permute selected
image axes by specified permutation.
’permutation’ is a combination of the
character set {x|y|z|c},
e.g. ’xycz’, ’cxyz’,
...
Example: [#1] image.jpg permute yxzc
r (+):
Shortcut for command ’resize’.
resize
(+):
{[image_w] | width>0[%]},_{[image_h] |
height>0[%]},_{[image_d] | depth>0[%]},_{[image_s] |
spectrum>0[%]},_interpolation,_boundary_conditions,_ax,_ay,_az,_ac
Resize selected
images with specified geometry.
(equivalent to shortcut command ’r’).
’interpolation’
can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
’boundary_conditions’ has different
meanings, according to the chosen
’interpolation’ mode :
* When ’interpolation=={ -1 | 1 | 2 | 4
}’, ’boundary_conditions’ is
meaningless.
* When ’interpolation==0’,
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic |
3=mirror }.
* When ’interpolation=={ 3 | 5 | 6 }’,
’boundary_conditions’ can be { 0=none
| 1=neumann }.
’ax,ay,az,ac’ set the centering along
each axis when ’interpolation=0 or 4’
(set to ’0’ by default, must be defined
in range [0,1]).
Default values: ’interpolation=1’, ’boundary_conditions=0’ and ’ax=ay=az=ac=0’.
Example: [#1] image.jpg +resize[-1] 256,128,1,3,2 +resize[-1] 120%,120%,1,3,0,1,0.5,0.5 +resize[-1] 120%,120%,1,3,0,0,0.2,0.2 +resize[-1] [0],[0],1,3,4
ri:
Shortcut for command
’resize_as_image’.
resize_as_image:
[reference],_interpolation,_boundary_conditions,_ax,_ay,_az,_ac
Resize selected
images to the geometry of specified [reference] image.
(equivalent to shortcut command
’ri’).
Default values: ’interpolation=1’, ’boundary_conditions=0’ and ’ax=ay=az=ac=0’.
Example: [#1] image.jpg sample duck +resize_as_image[-1] [-2]
resize_mn:
width[%]>=0,_height[%]>=0,_depth[%]>=0,_B_value,_C_value
Resize selected
images with Mitchell-Netravali filter (cubic).
For details about the method, see:
https://de.wikipedia.org/wiki/Mitchell-Netravali-Filter
Default values: ’height=100%’, ’depth=100%’, ’B=0.3333’ and ’C=0.3333’.
Example: [#1] image.jpg resize2dx 32 resize_mn 800%,800%
resize_pow2:
_interpolation,_boundary_conditions,_ax,_ay,_az,_ac
Resize selected
images so that each dimension is a power of 2.
’interpolation’ can be { -1=none (memory
content) | 0=none | 1=nearest | 2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
’boundary_conditions’ has different
meanings, according to the chosen
’interpolation’ mode :
* When ’interpolation=={ -1 | 1 | 2 | 4
}’, ’boundary_conditions’ is
meaningless.
* When ’interpolation==0’,
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic |
3=mirror }.
* When ’interpolation=={ 3 | 5 | 6 }’,
’boundary_conditions’ can be { 0=none
| 1=neumann }.
’ax,ay,az,ac’ set the centering along
each axis when ’interpolation=0’
(set to ’0’ by default, must be defined
in range [0,1]).
Default values: ’interpolation=0’, ’boundary_conditions=0’ and ’ax=ay=az=ac=0’.
Example: [#1] image.jpg +resize_pow2[-1] 0
rr2d:
Shortcut for command
’resize_ratio2d’.
resize_ratio2d:
width>0,height>0,_mode={ 0=inside | 1=outside |
2=padded },0=<_interpolation<=6
Resize selected
images while preserving their aspect ratio.
(equivalent to shortcut command
’rr2d’).
Default values: ’mode=0’ and ’interpolation=6’.
r2dx:
Shortcut for command ’resize2dx’.
resize2dx:
width[%]>0,_interpolation,_boundary_conditions,_ax,_ay,_az,_ac
Resize selected
images along the x-axis, preserving 2D ratio.
(equivalent to shortcut command
’r2dx’).
’interpolation’
can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
’boundary_conditions’ has different
meanings, according to the chosen
’interpolation’ mode :
* When ’interpolation=={ -1 | 1 | 2 | 4
}’, ’boundary_conditions’ is
meaningless.
* When ’interpolation==0’,
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic |
3=mirror }.
* When ’interpolation=={ 3 | 5 | 6 }’,
’boundary_conditions’ can be { 0=none
| 1=neumann }.
’ax,ay,az,ac’ set the centering along
each axis when ’interpolation=0’
(set to ’0’ by default, must be defined
in range [0,1]).
Default values: ’interpolation=3’, ’boundary_conditions=0’ and ’ax=ay=az=ac=0’.
Example: [#1] image.jpg +resize2dx 100,2 append x
r2dy:
Shortcut for command ’resize2dy’.
resize2dy:
height[%]>=0,_interpolation,_boundary_conditions,_ax,_ay,_az,_ac
Resize selected
images along the y-axis, preserving 2D ratio.
(equivalent to shortcut command
’r2dy’).
’interpolation’
can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
’boundary_conditions’ has different
meanings, according to the chosen
’interpolation’ mode :
* When ’interpolation=={ -1 | 1 | 2 | 4
}’, ’boundary_conditions’ is
meaningless.
* When ’interpolation==0’,
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic |
3=mirror }.
* When ’interpolation=={ 3 | 5 | 6 }’,
’boundary_conditions’ can be { 0=none
| 1=neumann }.
’ax,ay,az,ac’ set the centering along
each axis when ’interpolation=0’
(set to ’0’ by default, must be defined
in range [0,1]).
Default values: ’interpolation=3’, ’boundary_conditions=0’ and ’ax=ay=az=ac=0’.
Example: [#1] image.jpg +resize2dy 100,2 append x
r3dx:
Shortcut for command ’resize3dx’.
resize3dx:
width[%]>0,_interpolation,_boundary_conditions,_ax,_ay,_az,_ac
Resize selected
images along the x-axis, preserving 3D ratio.
(equivalent to shortcut command
’r3dx’).
’interpolation’
can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
’boundary_conditions’ has different
meanings, according to the chosen
’interpolation’ mode :
* When ’interpolation=={ -1 | 1 | 2 | 4
}’, ’boundary_conditions’ is
meaningless.
* When ’interpolation==0’,
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic |
3=mirror }.
* When ’interpolation=={ 3 | 5 | 6 }’,
’boundary_conditions’ can be { 0=none
| 1=neumann }.
’ax,ay,az,ac’ set the centering along
each axis when ’interpolation=0’
(set to ’0’ by default, must be defined
in range [0,1]).
Default values: ’interpolation=3’, ’boundary_conditions=0’ and ’ax=ay=az=ac=0’.
r3dy:
Shortcut for command ’resize3dy’.
resize3dy:
height[%]>0,_interpolation,_boundary_conditions,_ax,_ay,_az,_ac
Resize selected
images along the y-axis, preserving 3D ratio.
(equivalent to shortcut command
’r3dy’).
’interpolation’
can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
’boundary_conditions’ has different
meanings, according to the chosen
’interpolation’ mode :
* When ’interpolation=={ -1 | 1 | 2 | 4
}’, ’boundary_conditions’ is
meaningless.
* When ’interpolation==0’,
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic |
3=mirror }.
* When ’interpolation=={ 3 | 5 | 6 }’,
’boundary_conditions’ can be { 0=none
| 1=neumann }.
’ax,ay,az,ac’ set the centering along
each axis when ’interpolation=0’
(set to ’0’ by default, must be defined
in range [0,1]).
Default values: ’interpolation=3’, ’boundary_conditions=0’ and ’ax=ay=az=ac=0’.
r3dz:
Shortcut for command ’resize3dz’.
resize3dz:
depth[%]>0,_interpolation,_boundary_conditions,_ax,_ay,_az,_ac
Resize selected
images along the z-axis, preserving 3D ratio.
(equivalent to shortcut command
’r3dz’).
’interpolation’
can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
’boundary_conditions’ has different
meanings, according to the chosen
’interpolation’ mode :
* When ’interpolation=={ -1 | 1 | 2 | 4
}’, ’boundary_conditions’ is
meaningless.
* When ’interpolation==0’,
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic |
3=mirror }.
* When ’interpolation=={ 3 | 5 | 6 }’,
’boundary_conditions’ can be { 0=none
| 1=neumann }.
’ax,ay,az,ac’ set the centering along
each axis when ’interpolation=0’
(set to ’0’ by default, must be defined
in range [0,1]).
Default values: ’interpolation=3’, ’boundary_conditions=0’ and ’ax=ay=az=ac=0’.
rotate
(+):
angle,_interpolation,_boundary_conditions,_center_x[%],_center_y[%]
|
u,v,w,angle,interpolation,boundary_conditions,_center_x[%],_center_y[%],_center_z[%]
Rotate selected
images with specified angle (in deg.), and optionally 3D
axis (u,v,w).
’interpolation’ can be { 0=none |
1=linear | 2=bicubic }.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
When a rotation center (cx,cy,_cz) is specified, the size of
the image is preserved.
Default
values: ’interpolation=1’,
’boundary_conditions=0’ and
’center_x=center_y=(undefined)’.
Example: [#1] image.jpg +rotate -25,1,2,50%,50% rotate[0] 25
rotate_tileable:
angle,_max_size_factor>=0
Rotate selected
images by specified angle and make them tileable.
If resulting size of an image is too big, the image is
replaced by a 1x1 image.
Default values: ’max_size_factor=8’.
rows (+):
{ [image0] | y0[%] },_{ [image1] | y1[%] }
Keep only
specified rows of selected images.
Dirichlet boundary conditions are used when specified rows
are out of range.
Example: [#1] image.jpg rows -25%,50%
scale2x:
Resize selected images using the Scale2x algorithm.
Example: [#1] image.jpg threshold 50% resize 50%,50% +scale2x
scale3x:
Resize selected images using the Scale3x algorithm.
Example: [#1] image.jpg threshold 50% resize 33%,33% +scale3x
scale_dcci2x:
_edge_threshold>=0,_exponent>0,_extend_1px={ 0=false |
1=true }
Double image
size using directional cubic convolution interpolation,
as described in
https://en.wikipedia.org/wiki/Directional_Cubic_Convolution_Interpolation.
Default values: ’edge_threshold=1.15’, ’exponent=5’ and ’extend_1px=0’.
Example: [#1] image.jpg +scale_dcci2x ,
seamcarve:
_width[%]>=0,_height[%]>=0,_is_priority_channel={ 0 |
1 },_is_antialiasing={ 0 | 1 }, _maximum_seams[%]>=0
Resize selected images with specified 2D geometry, using the seam-carving algorithm.
Default
values: ’height=100%’,
’is_priority_channel=0’,
’is_antialiasing=1’ and
’maximum_seams=25%’.
Example: [#1] image.jpg seamcarve 60%
shift
(+):
vx[%],_vy[%],_vz[%],_vc[%],_boundary_conditions,_interpolation={
0=nearest_neighbor | 1=linear }
Shift selected
images by specified displacement vector.
Displacement vector can be non-integer in which case linear
interpolation should be chosen.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
Default value: ’boundary_conditions=0’ and ’interpolation=0’.
Example: [#1] image.jpg +shift[0] 50%,50%,0,0,0 +shift[0] 50%,50%,0,0,1 +shift[0] 50%,50%,0,0,2
shrink_x:
size_x>=0
Shrink selected images along the x-axis.
Example: [#1] image.jpg shrink_x 30
shrink_xy:
size>=0
Shrink selected images along the xy-axes.
Example: [#1] image.jpg shrink_xy 30
shrink_xyz:
size>=0
Shrink selected images along the xyz-axes.
shrink_y:
size_y>=0
Shrink selected images along the y-axis.
Example: [#1] image.jpg shrink_y 30
shrink_z:
size_z>=0
Shrink selected images along the z-axis.
slices
(+):
{ [image0] | z0[%] },_{ [image1] | z1[%] }
Keep only
specified slices of selected images.
Dirichlet boundary conditions are used when specified slices
are out of range.
sort (+):
_ordering={ + | - },_axis={ x | y | z | c }
Sort pixel
values of selected images.
If ’axis’ is specified, the sorting is
done according to the data of the first
column/row/slice/channel
of selected images.
Default values: ’ordering=+’ and ’axis=(undefined)’.
Example: [#1] 64 rand 0,100 +sort display_graph 400,300,3
s (+):
Shortcut for command ’split’.
split
(+):
{ x | y | z | c }...{ x | y | z | c },_split_mode |
keep_splitting_values={ + | - },_{ x | y | z | c }...{ x | y
| z | c },value1,_value2,... |
(no arg)
Split selected
images along specified axes, or regarding to a sequence of
scalar values
(optionally along specified axes too).
(equivalent to shortcut command ’s’).
’split_mode’
can be { 0=split according to constant values | >0=split
in N parts | <0=split in
parts of size -N }.
Default value: ’split_mode=-1’.
Example:
[#1] image.jpg split c
[#2] image.jpg split y,3
[#3] image.jpg split x,-128
[#4] 1,20,1,1,"1,2,3,4" +split -,2,3 append[1--1]
y
[#5] (1,2,2,3,3,3,4,4,4,4) +split x,0 append[1--1] y
split_tiles:
M!=0,_N!=0,_is_homogeneous={ 0 | 1 }
Split selected
images as a MxN array of tiles.
If M or N is negative, it stands for the tile size
instead.
Default values: ’N=M’ and ’is_homogeneous=0’.
Example: [#1] image.jpg +local split_tiles 5,4 blur 3,0 sharpen 700 append_tiles 4,5 endlocal
undistort:
-1<=_amplitude<=1,_aspect_ratio,_zoom,_center_x[%],_center_y[%],_boundary_conditions
Correct
barrel/pincushion distortions occurring with wide-angle
lens.
References:
[1] Zhang Z. (1999). Flexible camera calibration by viewing
a plane from unknown orientation.
[2] Andrew W. Fitzgibbon (2001). Simultaneous linear
estimation of multiple view geometry and lens
distortion.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
Default
values: ’amplitude=0.25’,
’aspect_ratio=0’,
’zoom=0’,
’center_x=center_y=50%’ and
’boundary_conditions=0’.
y (+):
Shortcut for command ’unroll’.
unroll
(+):
_axis={ x | y | z | c }
Unroll selected
images along specified axis.
(equivalent to shortcut command ’y’).
Default value: ’axis=y’.
Example: [#1] (1,2,3;4,5,6;7,8,9) +unroll y
upscale_smart:
width[%],_height[%],_depth,_smoothness>=0,_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_conditions,_nb_frames>0
Warp selected
images with specified displacement field.
’mode’ can be { 0=backward-absolute |
1=backward-relative | 2=forward-absolute |
3=forward-relative
}.
’interpolation’ can be {
0=nearest-neighbor | 1=linear | 2=cubic }.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
Default values: ’mode=0’, ’interpolation=1’, ’boundary_conditions=1’ and ’nb_frames=1’.
Example: [#1] image.jpg 100%,100%,1,2,’X=x/w-0.5;Y=y/h-0.5;R=(X*X+Y*Y)ˆ0.5;A=atan2(Y,X);130*R*if(c==0, cos(4*A),sin(8*A))’ warp[-2] [-1],1,1,0 quiver[-1] [-1],10,1,1,1,100
Tutorial: https://gmic.eu/tutorial/_warp.shtml
warp_patch:
[warping_field],patch_width>=1,_patch_height>=1,_patch_depth>=1,_std_factor>0,_boundary_conditions.
Patch-warp
selected images, with specified 2D or 3D displacement field
(in backward-absolute mode).
Argument ’std_factor’ sets the std of the
gaussian weights for the patch overlap,
equal to ’std = std_factor*patch_size’.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
Default values: ’std_factor=0.3’ and ’boundary_conditions=3’.
warp_rbf:
xs0[%],ys0[%],xt0[%],yt0[%],...,xsN[%],ysN[%],xtN[%],ytN[%]
Warp selected
images using RBF-based interpolation.
Each argument (xsk,ysk)-(xtk,ytk) corresponds to the
coordinates of a keypoint
respectively on the source and target images. The set of all
keypoints define the overall image
deformation.
Example: [#1] image.jpg +warp_rbf 0,0,0,0,100%,0,100%,0,100%,100%,100%,100%,0,100%,0,100%,50%,50%,70%, 50%,25%,25%,25%,75%
12.8.
Filtering
---------
bandpass:
_min_freq[%],_max_freq[%]
Apply bandpass filter to selected images.
Default values: ’min_freq=0’ and ’max_freq=20%’.
Example: [#1] image.jpg bandpass 1%,3%
Tutorial: https://gmic.eu/tutorial/_bandpass.shtml
bilateral
(+):
[guide],std_deviation_s[%]>=0,std_deviation_r[%]>=0,_sampling_s>=0,_sampling_r>=0
|
std_deviation_s[%]>=0,std_deviation_r[%]>=0,_sampling_s>=0,_sampling_r>=0
Blur selected
images by anisotropic (eventually joint/cross) bilateral
filtering.
If a guide image is provided, it is used for drive the
smoothing filter.
A guide image must be of the same xyz-size as the selected
images.
Set ’sampling’ arguments to
’0’ for automatic adjustment.
Example: [#1] image.jpg repeat 5 bilateral 10,10 done
b (+):
Shortcut for command ’blur’.
blur (+):
std_deviation>=0[%],_boundary_conditions,_kernel |
axes,std_deviation>=0[%],_boundary_conditions,_kernel
Blur selected
images by a quasi-gaussian or gaussian filter (recursive
implementation).
(equivalent to shortcut command ’b’).
’boundary_conditions’
can be { 0=dirichlet | 1=neumann }.
’kernel’ can be { 0=quasi-gaussian
(faster) | 1=gaussian }.
When specified, argument ’axes’ is a
sequence of { x | y | z | c }.
Specifying one axis multiple times apply also the blur
multiple times.
Default values: ’boundary_conditions=1’ and ’kernel=0’.
Example:
[#1] image.jpg +blur 5,0 +blur[0] 5,1
[#2] image.jpg +blur y,10%
Tutorial: https://gmic.eu/tutorial/_blur.shtml
blur_angular:
amplitude[%],_center_x[%],_center_y[%]
Apply angular blur on selected images.
Default values: ’center_x=center_y=50%’.
Example: [#1] image.jpg blur_angular 2%
Tutorial: https://gmic.eu/tutorial/_blur_angular.shtml
blur_bloom:
_amplitude>=0,_ratio>=0,_nb_iter>=0,_blend_operator={
+ | max | min },_kernel={ 0=quasi-gaussian (faster) |
1=gaussian | 2=box | 3=triangle | 4=quadratic
},_normalize_scales={ 0 | 1 },_axes
Apply a bloom
filter that blend multiple blur filters of different radii,
resulting in a larger but sharper glare than a simple blur.
When specified, argument ’axes’ is a
sequence of { x | y | z | c }.
Specifying one axis multiple times apply also the blur
multiple times.
Reference: Masaki Kawase, "Practical Implementation of
High Dynamic Range Rendering", GDC 2004.
Default
values: ’amplitude=1’,
’ratio=2’,
’nb_iter=5’,
’blend_operator=+’,
’kernel=0’,
’normalize_scales=0’ and
’axes=(all)’
Example: [#1] image.jpg blur_bloom ,
blur_linear:
amplitude1[%],_amplitude2[%],_angle,_boundary_conditions={
0=dirichlet | 1=neumann }
Apply linear blur on selected images, with specified angle and amplitudes.
Default values: ’amplitude2=0’, ’angle=0’ and ’boundary_conditions=1’.
Example: [#1] image.jpg blur_linear 10,0,45
Tutorial: https://gmic.eu/tutorial/_blur_linear.shtml
blur_radial:
amplitude[%],_center_x[%],_center_y[%]
Apply radial blur on selected images.
Default values: ’center_x=center_y=50%’.
Example: [#1] image.jpg blur_radial 2%
Tutorial: https://gmic.eu/tutorial/_blur_radial.shtml
blur_selective:
sigma>=0,_edges>0,_nb_scales>0
Blur selected images using selective gaussian scales.
Default values: ’sigma=5’, ’edges=0.5’ and ’nb_scales=5’.
Example: [#1] image.jpg noise 20 cut 0,255 +local[-1] repeat 4 blur_selective , done endlocal
Tutorial: https://gmic.eu/tutorial/_blur_selective.shtml
blur_x:
amplitude[%]>=0,_boundary_conditions={ 0=dirichlet |
1=neumann }
Blur selected images along the x-axis.
Default value: ’boundary_conditions=1’.
Example: [#1] image.jpg +blur_x 6
Tutorial: https://gmic.eu/tutorial/_blur_x.shtml
blur_xy:
amplitude_x[%],amplitude_y[%],_boundary_conditions={
0=dirichlet | 1=neumann }
Blur selected images along the X and Y axes.
Default value: ’boundary_conditions=1’.
Example: [#1] image.jpg +blur_xy 6
Tutorial: https://gmic.eu/tutorial/_blur_xy.shtml
blur_xyz:
amplitude_x[%],amplitude_y[%],amplitude_z,_boundary_conditions={
0=dirichlet | 1=neumann }
Blur selected images along the X, Y and Z axes.
Default value: ’boundary_conditions=1’.
Tutorial: https://gmic.eu/tutorial/_blur_xyz.shtml
blur_y:
amplitude[%]>=0,_boundary_conditions={ 0=dirichlet |
1=neumann }
Blur selected images along the y-axis.
Default value: ’boundary_conditions=1’.
Example: [#1] image.jpg +blur_y 6
Tutorial: https://gmic.eu/tutorial/_blur_y.shtml
blur_z:
amplitude[%]>=0,_boundary_conditions={ 0=dirichlet |
1=neumann }
Blur selected images along the z-axis.
Default value: ’boundary_conditions=1’.
Tutorial: https://gmic.eu/tutorial/_blur_z.shtml
boxfilter
(+):
size>=0[%],_order,_boundary_conditions,_nb_iter>=0 |
axes,size>=0[%],_order,_boundary_conditions,_nb_iter>=0
Blur selected
images by a box filter of specified size (fast recursive
implementation).
’order’ can be { 0=smooth |
1=1st-derivative | 2=2nd-derivative }.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann }.
When specified, argument ’axes’ is a
sequence of { x | y | z | c }.
Specifying one axis multiple times apply also the blur
multiple times.
Default values: ’order=0’, ’boundary_conditions=1’ and ’nb_iter=1’.
Example:
[#1] image.jpg +boxfilter 5%
[#2] image.jpg +boxfilter y,3,1
bump2normal:
Convert selected bumpmaps to normalmaps.
Example: [#1] 300,300 circle 50%,50%,128,1,1 blur 5% bump2normal
compose_freq:
Compose selected low and high frequency parts into new images.
Example: [#1] image.jpg split_freq 2% mirror[-1] x compose_freq
convolve
(+):
[mask],_boundary_conditions,_is_normalized={ 0 | 1
},_channel_mode,_xcenter,_ycenter,_zcenter,
_xstart,_ystart,_zstart,_xend,_yend,_zend,_xstride,_ystride,_zstride,_xdilation,_ydilation,
_zdilation
Convolve
selected images by specified mask.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
’channel_mode’ can be { 0=sum input
channels | 1=one-for-one | 2=expand }.
Default
values: ’boundary_conditions=1’,
’is_normalized=0’,
’channel_mode=1’,
’xcenter=ycenter=zcenter=-1’
(-1=centered), ’xstart=ystart=zstart=0’,
’xend=yend=zend=-1’ (-1=max
coordinates), ’xstride=ystride=zstride=1’
and
’xdilation=ydilation=zdilation=1’.
Example:
[#1] image.jpg (0,1,0;1,-4,1;0,1,0) convolve[-2] [-1]
keep[-2]
[#2] image.jpg (0,1,0) resize[-1] 130,1,1,1,3 +convolve[0]
[1]
Tutorial: https://gmic.eu/tutorial/_convolve.shtml
convolve_fft:
[mask],_boundary_conditions
Convolve
selected images with specified mask, in the fourier domain.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
Example: [#1] image.jpg 100%,100% gaussian[-1] 20,1,45 +convolve_fft[0] [1]
correlate
(+):
[mask],_boundary_conditions,_is_normalized={ 0 | 1
},_channel_mode,_xcenter,_ycenter,_zcenter,
_xstart,_ystart,_zstart,_xend,_yend,_zend,_xstride,_ystride,_zstride,_xdilation,_ydilation,
_zdilation
Correlate
selected images by specified mask.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
’channel_mode’ can be { 0=sum input
channels | 1=one-for-one | 2=expand }.
Default
values: ’boundary_conditions=1’,
’is_normalized=0’,
’channel_mode=1’,
’xcenter=ycenter=zcenter=-1’
(-1=centered), ’xstart=ystart=zstart=0’,
’xend=yend=zend=-1’ (-1=max
coordinates), ’xstride=ystride=zstride=1’
and
’xdilation=ydilation=zdilation=1’.
Example:
[#1] image.jpg (0,1,0;1,-4,1;0,1,0) correlate[-2] [-1]
keep[-2]
[#2] image.jpg +crop 40%,40%,60%,60% +correlate[0]
[-1],0,1
cross_correlation:
[mask]
Compute cross-correlation of selected images with specified mask.
Example: [#1] image.jpg +shift -30,-20 +cross_correlation[0] [1]
curvature:
Compute isophote curvatures on selected images.
Example: [#1] image.jpg blur 10 curvature
dct:
_{ x | y | z }...{ x | y | z } |
(no arg)
Compute the
discrete cosine transform of selected images, optionally
along the specified axes only.
Output images are always evenly sized, so this command may
change the size of the selected images.
Default
values: (no arg)
See also: idct.
Example: [#1] image.jpg +dct +idct[-1] abs[-2] +[-2] 1 log[-2]
Tutorial: https://gmic.eu/tutorial/_dct-and-idct.shtml
deblur:
amplitude[%]>=0,_nb_iter>=0,_dt>=0,_regul>=0,_regul_type={
0=Tikhonov | 1=meancurv. | 2=TV }
Deblur image using a regularized Jansson-Van Cittert algorithm.
Default values: ’nb_iter=10’, ’dt=20’, ’regul=0.7’ and ’regul_type=1’.
Example: [#1] image.jpg blur 3 +deblur 3,40,20,0.01
deblur_goldmeinel:
sigma>=0,_nb_iter>=0,_acceleration>=0,_kernel_type={
0=quasi-gaussian (faster) | 1=gaussian }.
Deblur selected images using Gold-Meinel algorithm
Default values: ’nb_iter=8’, ’acceleration=1’ and ’kernel_type=1’.
Example: [#1] image.jpg +blur 1 +deblur_goldmeinel[-1] 1
deblur_richardsonlucy:
sigma>=0, nb_iter>=0, _kernel_type={ 0=quasi-gaussian
(faster) | 1=gaussian }.
Deblur selected images using Richardson-Lucy algorithm.
Default values: ’nb_iter=50’ and ’kernel_type=1’.
Example: [#1] image.jpg +blur 1 +deblur_richardsonlucy[-1] 1
deconvolve_fft:
[kernel],_regularization>=0
Deconvolve selected images by specified mask in the fourier space.
Default value: ’regularization>=0’.
Example: [#1] image.jpg +gaussian 5 +convolve_fft[0] [1] +deconvolve_fft[-1] [1]
deinterlace:
_method={ 0 | 1 }
Deinterlace selected images (’method’ can be { 0=standard or 1=motion-compensated }).
Default value: ’method=0’.
Example: [#1] image.jpg +rotate 3,1,1,50%,50% resize 100%,50% resize 100%,200%,1,3,4 shift[-1] 0,1 add +deinterlace 1
denoise
(+):
[guide],std_deviation_s[%]>=0,_std_deviation_r[%]>=0,_patch_size>0,_lookup_size>0,_smoothness,
_fast_approx={ 0 | 1 } |
std_deviation_s[%]>=0,_std_deviation_r[%]>=0,_patch_size>0,_lookup_size>0,_smoothness,
_fast_approx={ 0 | 1 }
Denoise selected images by non-local patch averaging.
Default values: ’std_deviation_p=10’, ’patch_size=5’, ’lookup_size=6’ and ’smoothness=1’.
Example: [#1] image.jpg +denoise 5,5,8
denoise_haar:
_threshold>=0,_nb_scales>=0,_cycle_spinning>0
Denoise selected
images using haar-wavelet thresholding with cycle spinning.
Set ’nb_scales==0’ to automatically
determine the optimal number of scales.
Default values: ’threshold=1.4’, ’nb_scale=0’ and ’cycle_spinning=10’.
Example: [#1] image.jpg noise 20 cut 0,255 +denoise_haar[-1] 0.8
denoise_patchpca:
_strength>=0,_patch_size>0,_lookup_size>0,_spatial_sampling>0
Denoise selected images using the patch-pca algorithm.
Default values: ’patch_size=7’, ’lookup_size=11’, ’details=1.8’ and ’spatial_sampling=5’.
Example: [#1] image.jpg +noise 20 cut[-1] 0,255 +denoise_patchpca[-1] ,
deriche
(+):
std_deviation>=0[%],order={ 0 | 1 | 2 },axis={ x | y | z
| c },_boundary_conditions
Apply Deriche
recursive filter on selected images, along specified axis
and with
specified standard deviation, order and boundary conditions.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann }.
Default value: ’boundary_conditions=1’.
Example:
[#1] image.jpg deriche 3,1,x
[#2] image.jpg +deriche 30,0,x deriche[-2] 30,0,y add
Tutorial: https://gmic.eu/tutorial/_deriche.shtml
dilate
(+):
size>=0 |
size_x>=0,size_y>=0,size_z>=0 |
[kernel],_boundary_conditions,_is_real={ 0=binary-mode |
1=real-mode }
Dilate selected
images by a rectangular or the specified structuring
element.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann }.
Default values: ’size_z=1’, ’boundary_conditions=1’ and ’is_real=0’.
Example: [#1] image.jpg +dilate 10
dilate_circ:
_size>=0,_boundary_conditions,_is_normalized={ 0 | 1
}
Apply circular dilation of selected images by specified size.
Default values: ’boundary_conditions=1’ and ’is_normalized=0’.
Example: [#1] image.jpg +dilate_circ 7
dilate_oct:
_size>=0,_boundary_conditions,_is_normalized={ 0 | 1
}
Apply octagonal dilation of selected images by specified size.
Default values: ’boundary_conditions=1’ and ’is_normalized=0’.
Example: [#1] image.jpg +dilate_oct 7
dilate_threshold:
size_x>=1,size_y>=1,size_z>=1,_threshold>=0,_boundary_conditions
Dilate selected
images in the (X,Y,Z,I) space.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann }.
Default values: ’size_y=size_x’, ’size_z=1’, ’threshold=255’ and ’boundary_conditions=1’.
divergence:
Compute divergence of selected vector fields.
Example: [#1] image.jpg luminance +gradient append[-2,-1] c divergence[-1]
dog:
_sigma1>=0[%],_sigma2>=0[%]
Compute difference of gaussian on selected images.
Default values: ’sigma1=2%’ and ’sigma2=3%’.
Example: [#1] image.jpg dog 2,3
diffusiontensors:
_sharpness>=0,0<=_anisotropy<=1,_alpha[%],_sigma[%],is_sqrt={
0 | 1 }
Compute the diffusion tensors of selected images for edge-preserving smoothing algorithms.
Default values: ’sharpness=0.7’, ’anisotropy=0.3’, ’alpha=0.6’, ’sigma=1.1’ and ’is_sqrt=0’.
Example: [#1] image.jpg diffusiontensors 0.8 abs pow 0.2
Tutorial: https://gmic.eu/tutorial/_diffusiontensors.shtml
edges:
_threshold[%]>=0
Estimate contours of selected images.
Default value: ’edges=15%’
Example: [#1] image.jpg +edges 15%
erode
(+):
size>=0 |
size_x>=0,size_y>=0,_size_z>=0 |
[kernel],_boundary_conditions,_is_real={ 0=binary-mode |
1=real-mode }
Erode selected
images by a rectangular or the specified structuring
element.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann }.
Default values: ’size_z=1’, ’boundary_conditions=1’ and ’is_real=0’.
Example: [#1] image.jpg +erode 10
erode_circ:
_size>=0,_boundary_conditions,_is_normalized={ 0 | 1
}
Apply circular erosion of selected images by specified size.
Default values: ’boundary_conditions=1’ and ’is_normalized=0’.
Example: [#1] image.jpg +erode_circ 7
erode_oct:
_size>=0,_boundary_conditions,_is_normalized={ 0 | 1
}
Apply octagonal erosion of selected images by specified size.
Default values: ’boundary_conditions=1’ and ’is_normalized=0’.
Example: [#1] image.jpg +erode_oct 7
erode_threshold:
size_x>=1,size_y>=1,size_z>=1,_threshold>=0,_boundary_conditions
Erode selected
images in the (X,Y,Z,I) space.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann }.
Default values: ’size_y=size_x’, ’size_z=1’, ’threshold=255’ and ’boundary_conditions=1’.
fft (+):
_{ x | y | z }...{ x | y | z }
Compute the
direct fourier transform (real and imaginary parts) of
selected images,
optionally along the specified axes only.
See also: ifft.
Example:
[#1] image.jpg luminance +fft append[-2,-1] c norm[-1]
log[-1] shift[-1] 50%,50%,0,0,2
[#2] image.jpg w2={int(w/2)} h2={int(h/2)} fft shift
$w2,$h2,0,0,2 ellipse $w2,$h2,30,30,0,1,0 shift
-$w2,-$h2,0,0,2 ifft remove[-1]
Tutorial: https://gmic.eu/tutorial/_fft.shtml
g (+):
Shortcut for command ’gradient’.
gradient
(+):
{ x | y | z }...{ x | y | z },_scheme |
(no arg)
Compute the
gradient components (first derivatives) of selected images.
(equivalent to shortcut command ’g’).
’scheme’
can be { -1=backward | 0=centered | 1=forward | 2=sobel |
3=rotation-invariant (default) |
4=deriche | 5=vanvliet }.
(no arg) compute all significant components.
Default value: ’scheme=0’.
Example: [#1] image.jpg gradient
Tutorial: https://gmic.eu/tutorial/_gradient.shtml
gradient_norm:
Compute gradient norm of selected images.
Example: [#1] image.jpg gradient_norm equalize
Tutorial: https://gmic.eu/tutorial/_gradient_norm.shtml
gradient_orientation:
_dimension={1,2,3}
Compute N-d gradient orientation of selected images.
Default value: ’dimension=3’.
Example: [#1] image.jpg +gradient_orientation 2
guided
(+):
[guide],radius[%]>=0,regularization[%]>=0 |
radius[%]>=0,regularization[%]>=0
Blur selected
images by guided image filtering.
If a guide image is provided, it is used to drive the
smoothing process.
A guide image must be of the same xyz-size as the selected
images.
This command implements the filtering algorithm described
in:
He, Kaiming; Sun, Jian; Tang, Xiaoou, "Guided Image
Filtering",
IEEE Transactions on Pattern Analysis and Machine
Intelligence, vol.35, no.6, pp.1397,1409, June
2013
Example: [#1] image.jpg +guided 5,400
haar:
scale>0
Compute the
direct haar multiscale wavelet transform of selected images.
See also: ihaar.
Tutorial: https://gmic.eu/tutorial/_haar.shtml
heat_flow:
_nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }
Apply iterations of the heat flow on selected images.
Default values: ’nb_iter=10’, ’dt=30’ and ’keep_sequence=0’.
Example: [#1] image.jpg +heat_flow 20
hessian
(+):
{ xx | xy | xz | yy | yz | zz }...{ xx | xy | xz | yy | yz |
zz } |
(no arg)
Compute the
hessian components (second derivatives) of selected images.
(no arg) compute all significant components.
Example: [#1] image.jpg hessian
idct:
_{ x | y | z }...{ x | y | z } |
(no arg)
Compute the
inverse discrete cosine transform of selected images,
optionally along the specified
axes only.
Output images are always evenly sized, so this command may
change the size of the selected images.
(dct images obtained with the ’dct’
command are evenly sized anyway).
Default
values: (no arg)
See also: dct.
Tutorial: https://gmic.eu/tutorial/_dct-and-idct.shtml
iee:
Compute gradient-orthogonal-directed 2nd derivative of image(s).
Example: [#1] image.jpg iee
ifft (+):
_{ x | y | z }...{ x | y | z }
Compute the
inverse fourier transform (real and imaginary parts) of
selected images.
optionally along the specified axes only.
See also: fft.
Tutorial: https://gmic.eu/tutorial/_fft.shtml
ihaar:
scale>0
Compute the
inverse haar multiscale wavelet transform of selected
images.
See also: haar.
ilaplacian:
{ nb_iterations>0 | 0
},_time_step>0,_[initial_estimate]
Invert selected
Laplacian images.
If given ’nb_iterations’ is
’0’, inversion is done in Fourier space
(single iteration),
otherwise, by applying ’nb_iterations’ of
a Laplacian-inversion PDE flow (with specified
’time_step’).
Note that the resulting inversions are just estimation of
possible/approximated solutions.
Default values: ’nb_iterations=0’,’time_step=10’ and ’[initial_estimated]=(undefined)’.
Example: [#1] image.jpg +laplacian +ilaplacian[-1] 0
inn:
Compute gradient-directed 2nd derivative of image(s).
Example: [#1] image.jpg inn
inpaint
(+):
[mask] |
[mask],0,_fast_method |
[mask],_patch_size>=1,_lookup_size>=1,_lookup_factor>=0,_lookup_increment!=0,_blend_size>=0,
0<=_blend_threshold<=1,_blend_decay>=0,_blend_scales>=1,_is_blend_outer={
0 | 1 }
Inpaint selected
images by specified mask.
If no patch size (or 0) is specified, inpainting is done
using a fast average or median algorithm.
Otherwise, it used a patch-based reconstruction method, that
can be very time consuming.
’fast_method’ can be { 0=low-connectivity
average | 1=high-connectivity average |
2=low-connectivity median | 3=high-connectivity median
}.
Default
values: ’patch_size=0’,
’fast_method=1’,
’lookup_size=22’,
’lookup_factor=0.5’,
’lookup_increment=1’,
’blend_size=0’,
’blend_threshold=0’,
’blend_decay=0.05’,
’blend_scales=10’
and ’is_blend_outer=1’.
Example:
[#1] image.jpg 100%,100% ellipse 50%,50%,30,30,0,1,255
ellipse 20%,20%,30,10,0,1,255 +inpaint[-2] [-1] remove[-2]
[#2] image.jpg 100%,100% circle 30%,30%,30,1,255,0,255
circle 70%,70%,50,1,255,0,255 +inpaint[0] [1],5,15,0.5,1,9,0
remove[1]
inpaint_pde:
[mask],_nb_scales[%]>=0,_diffusion_type={ 0=isotropic |
1=delaunay-guided | 2=edge-guided | 3=mask-guided
},_diffusion_iter>=0
Inpaint selected
images by specified mask using a multiscale
transport-diffusion algorithm.
If ’diffusion type==3’, non-zero values
of the mask (e.g. a distance function) are used
to guide the diffusion process.
Default values: ’nb_scales=75%’, ’diffusion_type=1’ and ’diffusion_iter=20’.
Example: [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255 +inpaint_pde[0] [1]
inpaint_flow:
[mask],_nb_global_iter>=0,_nb_local_iter>=0,_dt>0,_alpha>=0,_sigma>=0
Apply iteration of the inpainting flow on selected images.
Default values: ’nb_global_iter=10’, ’nb_local_iter=100’, ’dt=5’, ’alpha=1’ and ’sigma=3’.
Example: [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255 inpaint_flow[0] [1]
inpaint_holes:
maximal_area[%]>=0,_tolerance>=0,_is_high_connectivity={
0 | 1 }
Inpaint all connected regions having an area less than specified value.
Default values: ’maximal_area=4’, ’tolerance=0’ and ’is_high_connectivity=0’.
Example: [#1] image.jpg noise 5%,2 +inpaint_holes 8,40
inpaint_morpho:
[mask]
Inpaint selected images by specified mask using morphological operators.
Example: [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255 +inpaint_morpho[0] [1]
inpaint_matchpatch:
[mask],_nb_scales={ 0=auto | >0
},_patch_size>0,_nb_iterations_per_scale>0,_blend_size>=0,
_allow_outer_blending={ 0 | 1 },_is_already_initialized={ 0
| 1 }
Inpaint selected images by specified binary mask, using a multi-scale matchpatch algorithm.
Default
values: ’nb_scales=0’,
’patch_size=9’,
’nb_iterations_per_scale=10’,
’blend_size=5’,
’allow_outer_blending=1’ and
’is_already_initialized=0’.
Example: [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255 +inpaint_matchpatch[0] [1]
kuwahara:
size>0
Apply Kuwahara filter of specified size on selected images.
Example: [#1] image.jpg kuwahara 9
laplacian:
Compute Laplacian of selected images.
Example: [#1] image.jpg laplacian
lic:
_amplitude>0,_channels>0
Render LIC representation of selected vector fields.
Default values: ’amplitude=30’ and ’channels=1’.
Example: [#1] 400,400,1,2,’if(c==0,x-w/2,y-h/2)’ +lic 200,3 quiver[-2] [-2],10,1,1,1,255
map_tones:
_threshold>=0,_gamma>=0,_smoothness>=0,nb_iter>=0
Apply tone mapping operator on selected images, based on Poisson equation.
Default values: ’threshold=0.1’, ’gamma=0.8’, ’smoothness=0.5’ and ’nb_iter=30’.
Example: [#1] image.jpg +map_tones ,
map_tones_fast:
_radius[%]>=0,_power>=0
Apply fast tone mapping operator on selected images.
Default values: ’radius=3%’ and ’power=0.3’.
Example: [#1] image.jpg +map_tones_fast ,
meancurvature_flow:
_nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }
Apply iterations of the mean curvature flow on selected images.
Default values: ’nb_iter=10’, ’dt=30’ and ’keep_sequence=0’.
Example: [#1] image.jpg +meancurvature_flow 20
median
(+):
size>=0,_threshold>0
Apply (opt. thresholded) median filter on selected images with structuring element size x size.
Example: [#1] image.jpg +median 5
nlmeans:
[guide],_patch_radius>0,_spatial_bandwidth>0,_tonal_bandwidth>0,_patch_measure_command
|
_patch_radius>0,_spatial_bandwidth>0,_tonal_bandwidth>0,_patch_measure_command
Apply non local
means denoising of Buades et al, 2005. on selected images.
The patch is a gaussian function of
’std_patch_radius’.
The spatial kernel is a rectangle of radius
’spatial_bandwidth’.
The tonal kernel is exponential
(exp(-dˆ2/_tonal_bandwidthˆ2))
with d the euclidean distance between image patches.
Default
values: ’patch_radius=4’,
’spatial_bandwidth=4’,
’tonal_bandwidth=10’ and
’patch_measure_command=-norm’.
Example: [#1] image.jpg +noise 10 nlmeans[-1] 4,4,{0.6*${-std_noise}}
nlmeans_core:
_reference_image,_scaling_map,_patch_radius>0,_spatial_bandwidth>0
Apply non local means denoising using a image for weight and a map for scaling
normalize_local:
_amplitude>=0,_radius>0,_n_smooth>=0[%],_a_smooth>=0[%],_is_cut={
0 | 1 },_min=0,_max=255
Normalize selected images locally.
Default
values: ’amplitude=3’,
’radius=16’,
’n_smooth=4%’,
’a_smooth=2%’,
’is_cut=1’, ’min=0’
and ’max=255’.
Example: [#1] image.jpg normalize_local 8,10
normalized_cross_correlation:
[mask]
Compute normalized cross-correlation of selected images with specified mask.
Example: [#1] image.jpg +shift -30,-20 +normalized_cross_correlation[0] [1]
percentile:
[mask],0<=_min_percentile[%]<=100,0<=_max_percentile[%]<=100.
Apply percentile averaging filter to selected images.
Default values: ’min_percentile=0’ and ’max_percentile=100’.
Example: [#1] image.jpg shape_circle 11,11 +percentile[0] [1],25,75
peronamalik_flow:
K_factor>0,_nb_iter>=0,_dt,_keep_sequence={ 0 | 1
}
Apply iterations of the Perona-Malik flow on selected images.
Default values: ’K_factor=20’, ’nb_iter=5’, ’dt=5’ and ’keep_sequence=0’.
Example: [#1] image.jpg +heat_flow 20
phase_correlation:
[destination]
Estimate translation vector between selected source images and specified destination.
Example: [#1] image.jpg +shift -30,-20 +phase_correlation[0] [1] unroll[-1] y
pde_flow:
_nb_iter>=0,_dt,_velocity_command,_keep_sequence={ 0 | 1
}
Apply iterations of a generic PDE flow on selected images.
Default values: ’nb_iter=10’, ’dt=30’, ’velocity_command=laplacian’ and ’keep_sequence=0’.
Example: [#1] image.jpg +pde_flow 20
periodize_poisson:
Periodize selected images using a Poisson solver in Fourier space.
Example: [#1] image.jpg +periodize_poisson array 2,2,2
rbf:
dx,_x0,_x1,_phi(r) |
dx,dy,_x0,_y0,_x1,_y1,_phi(r) |
dx,dy,dz,x0,y0,z0,x1,y1,z1,phi(r)
Reconstruct
1D/2D or 3D image from selected sets of keypoints, by
RBF-interpolation.
A set of keypoints is represented by a vector-valued image,
where each pixel represents a single
keypoint.
Vector components of a keypoint have the following meaning:
- For 1D reconstruction: [ x_k, f1(k),...fN(k) ].
- For 2D reconstruction: [ x_k,y_k, f1(k),...,fN(k) ].
- For 3D reconstruction: [ x_k,y_k,z_k, f1(k),...,fN(k) ].
Values ’x_k’,’y_k’ and
’z_k’ are the spatial coordinates of
keypoint ’k’.
Values ’f1(k),..,fN(k)’ are the
’N’ components of the vector value of
keypoint ’k’.
The command reconstructs an image with specified size
’dx’x’dy’x’dz’,
with ’N’ channels.
Default values: ’x0=y0=z0=0’, ’x1=dx-1’, ’y1=dy-1’, ’z1=dz-1’, ’phi(r)=rˆ2*log(1e-5+r)’.
Example:
[#1] sp colorful r2dx 400 100%,100% noise_poissondisk. 10
1,{is},1,5 eval[-2]
"begin(p=0);i?(I[#-1,p++]=[x,y,I(#0)])" to_rgb[1]
mul[0,1] dilate_circ[0] 5 +rbf[-1] {0, [w,h]} c[-1] 0,255
[#2] 32,1,1,5,u([400,400,255,255,255]) rbf 400,400 c
0,255
red_eye:
0<=_threshold<=100,_smoothness>=0,0<=attenuation<=1
Attenuate red-eye effect in selected images.
Default values: ’threshold=75’, ’smoothness=3.5’ and ’attenuation=0.1’.
Example: [#1] image.jpg +red_eye ,
remove_hotpixels:
_mask_size>0, _threshold[%]>0
Remove hot pixels in selected images.
Default values: ’mask_size=3’ and ’threshold=10%’.
Example: [#1] image.jpg noise 10,2 +remove_hotpixels ,
remove_pixels:
number_of_pixels[%]>=0
Remove specified
number of pixels (i.e. set them to 0) from the set of
non-zero pixels in selected
images.
Example: [#1] image.jpg +remove_pixels 50%
rolling_guidance:
std_deviation_s[%]>=0,std_deviation_r[%]>=0,_precision>=0
Apply the
rolling guidance filter on selected image.
Rolling guidance filter is a fast image abstraction filter,
described in:
"Rolling Guidance Filter", Qi Zhang Xiaoyong, Shen
Li, Xu Jiaya Jia, ECCV’2014.
Default values: ’std_deviation_s=4’, ’std_deviation_r=10’ and ’precision=0.5’.
Example: [#1] image.jpg +rolling_guidance , +-
sharpen
(+):
amplitude>=0 |
amplitude>=0,edge>=0,_alpha,_sigma
Sharpen selected
images by inverse diffusion or shock filters methods.
’edge’ must be specified to enable
shock-filter method.
Default values: ’alpha=0’ and ’sigma=0’.
Example:
[#1] image.jpg sharpen 300
[#2] image.jpg blur 5 sharpen 300,1
smooth
(+):
amplitude[%]>=0,_sharpness>=0,0<=_anisotropy<=1,_alpha[%],_sigma[%],_dl>0,_da>0,_precision>0,
_interpolation,_fast_approx={ 0 | 1 } |
nb_iterations>=0,_sharpness>=0,_anisotropy,_alpha,_sigma,_dt>0,0
|
[tensor_field],_amplitude>=0,_dl>0,_da>0,_precision>0,_interpolation,_fast_approx={
0 | 1 } |
[tensor_field],_nb_iters>=0,_dt>0,0
Smooth selected
images anisotropically using diffusion PDE’s, with
specified field of
diffusion tensors.
’interpolation’ can be { 0=nearest |
1=linear | 2=runge-kutta }.
Default
values: ’sharpness=0.7’,
’anisotropy=0.3’,
’alpha=0.6’,
’sigma=1.1’, ’dl=0.8’,
’da=30’,
’precision=2’,
’interpolation=0’ and
’fast_approx=1’.
Example:
[#1] image.jpg repeat 3 smooth 40,0,1,1,2 done
[#2] image.jpg 100%,100%,1,2 rand[-1] -100,100 repeat 2
smooth[-1] 100,0.2,1,4,4 done warp[0] [-1],1,1
Tutorial: https://gmic.eu/tutorial/_smooth.shtml
split_freq:
smoothness>0[%]
Split selected images into low and high frequency parts.
Example: [#1] image.jpg split_freq 2%
solve_poisson:
"laplacian_command",_nb_iterations>=0,_time_step>0,_nb_scales>=0
Solve Poisson
equation so that applying ’laplacian[n]’
is close to the result of
’laplacian_command[n]’.
Solving is performed using a multi-scale gradient descent
algorithm.
If ’nb_scales=0’, the number of scales is
automatically determined.
Default values: ’nb_iterations=60’, ’dt=5’ and ’nb_scales=0’.
Example: [#1] image.jpg command "foo : gradient x" +solve_poisson foo +foo[0] +laplacian[1]
split_details:
_nb_scales>0,_base_scale[%]>=0,_detail_scale[%]>=0
Split selected
images into ’nb_scales’ detail scales.
If
’base_scale’==’detail_scale’==0,
the image decomposition is done with ’a
trous’ wavelets.
Otherwise, it uses laplacian pyramids with linear standard
deviations.
Default values: ’nb_scales=4’, ’base_scale=0’ and ’detail_scale=0’.
Example: [#1] image.jpg split_details ,
structuretensors
(+):
_scheme={ 0=centered | 1=forward/backward }
Compute the structure tensor field of selected images.
Default value: ’scheme=1’.
Example: [#1] image.jpg structuretensors abs pow 0.2
Tutorial: https://gmic.eu/tutorial/_structuretensors.shtml
solidify:
_smoothness[%]>=0,_diffusion_type={ 0=isotropic |
1=delaunay-oriented | 2=edge-oriented },
_diffusion_iter>=0
Solidify selected transparent images.
Default values: ’smoothness=75%’, ’diffusion_type=1’ and ’diffusion_iter=20’.
Example: [#1] image.jpg 100%,100% circle[-1] 50%,50%,25%,1,255 append c +solidify , display_rgba
syntexturize:
_width[%]>0,_height[%]>0
Resynthetize
’width’x’height’ versions of
selected micro-textures by phase randomization.
The texture synthesis algorithm is a straightforward
implementation of the method described in :
http://www.ipol.im/pub/art/2011/ggm_rpn/
Default values: ’width=height=100%’.
Example: [#1] image.jpg crop 2,282,50,328 +syntexturize 320,320
syntexturize_matchpatch:
_width[%]>0,_height[%]>0,_nb_scales>=0,_patch_size>0,_blending_size>=0,_precision>=0
Resynthetize
’width’x’height’ versions of
selected micro-textures using a patch-matching algorithm.
If ’nbscales==0’, the number of scales
used is estimated from the image size.
Default
values: ’width=height=100%’,
’nb_scales=0’,
’patch_size=7’,
’blending_size=5’ and
’precision=1’.
Example: [#1] image.jpg crop 25%,25%,75%,75% syntexturize_matchpatch 512,512
tv_flow:
_nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }
Apply iterations of the total variation flow on selected images.
Default values: ’nb_iter=10’, ’dt=30’ and ’keep_sequence=0’.
Example: [#1] image.jpg +tv_flow 40
unsharp:
radius[%]>=0,_amount>=0,_threshold[%]>=0
Apply unsharp mask on selected images.
Default values: ’amount=2’ and ’threshold=0’.
Example: [#1] image.jpg blur 3 +unsharp 1.5,15 cut 0,255
unsharp_octave:
_nb_scales>0,_radius[%]>=0,_amount>=0,threshold[%]>=0
Apply octave sharpening on selected images.
Default values: ’nb_scales=4’, ’radius=1’, ’amount=2’ and ’threshold=0’.
Example: [#1] image.jpg blur 3 +unsharp_octave 4,5,15 cut 0,255
vanvliet
(+):
std_deviation>=0[%],order={ 0 | 1 | 2 | 3 },axis={ x | y
| z | c },_boundary_conditions
Apply Vanvliet
recursive filter on selected images, along specified axis
and with
specified standard deviation, order and boundary conditions.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann }.
Default value: ’boundary_conditions=1’.
Example:
[#1] image.jpg +vanvliet 3,1,x
[#2] image.jpg +vanvliet 30,0,x vanvliet[-2] 30,0,y add
voronoi:
Compute the discrete Voronoi diagram of non-zero pixels in selected images.
Example: [#1] 400,400 noise 0.2,2 eq 1 +label_fg 0 voronoi[-1] +gradient[-1] xy,1 append[-2,-1] c norm[-1] ==[-1] 0 map[-2] 2,2 mul[-2,-1] normalize[-2] 0,255 dilate_circ[-2] 4 reverse max
watermark_fourier:
text,_size>0
Add a textual watermark in the frequency domain of selected images.
Default value: ’size=33’.
Example: [#1] image.jpg +watermark_fourier "Watermarked!" +display_fft remove[-3,-1] normalize 0,255 append[-4,-2] y append[-2,-1] y
watershed
(+):
[priority_image],_is_high_connectivity={ 0 | 1 }
Compute the watershed transform of selected images.
Default value: ’is_high_connectivity=1’.
Example: [#1] 400,400 noise 0.2,2 eq 1 +distance 1 mul[-1] -1 label[-2] watershed[-2] [-1] mod[-2] 256 map[-2] 0 reverse
12.9.
Features Extraction
-------------------
area:
tolerance>=0,is_high_connectivity={ 0 | 1 }
Compute area of connected components in selected images.
Default values: ’is_high_connectivity=0’.
Example: [#1] image.jpg luminance stencil[-1] 1 +area 0
Tutorial: https://gmic.eu/tutorial/_area.shtml
area_fg:
tolerance>=0,is_high_connectivity={ 0 | 1 }
Compute area of
connected components for non-zero values in selected images.
Similar to ’area’ except that 0-valued
pixels are not considered.
Default values: ’is_high_connectivity=0’.
Example: [#1] image.jpg luminance stencil[-1] 1 +area_fg 0
at_line:
x0[%],y0[%],z0[%],x1[%],y1[%],z1[%]
Retrieve pixels of the selected images belonging to the specified line (x0,y0,z0)-(x1,y1,z1).
Example: [#1] image.jpg +at_line 0,0,0,100%,100%,0 line[0] 0,0,100%,100%,1,0xFF00FF00,255,0,0
at_quadrangle:
x0[%],y0[%],x1[%],y1[%],x2[%],y2[%],x3[%],y3[%],_interpolation,_boundary_conditions
|
x0[%],y0[%],z0[%],x1[%],y1[%],z1[%],x2[%],y2[%],z2[%],x3[%],y3[%],z3[%],_interpolation,
_boundary_conditions
Retrieve pixels
of the selected images belonging to the specified 2D or 3D
quadrangle.
’interpolation’ can be {
0=nearest-neighbor | 1=linear | 2=cubic }.
’boundary_conditions’ can be {
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
Example: [#1] image.jpg params=5%,5%,95%,5%,60%,95%,40%,95% +at_quadrangle $params polygon.. 4,$params, 0.5,255
barycenter:
Compute the barycenter vector of pixel values.
Example: [#1] 256,256 ellipse 50%,50%,20%,20%,0,1,1 deform 20 +barycenter +ellipse[-2] {@0,1},5,5,0,10
delaunay:
Generate
discrete 2D Delaunay triangulation of non-zero pixels in
selected images.
Input images must be scalar.
Each pixel of the output image is a triplet (a,b,c) meaning
the pixel belongs to
the Delaunay triangle ’ABC’ where
’a’,’b’,’c’ are
the labels of the pixels
’A’,’B’,’C’.
Example:
[#1] 400,400 rand 32,255 100%,100% noise. 0.4,2 eq. 1 mul
+delaunay
[#2] image.jpg b 1% 100%,100% noise. 0.8,2 eq. 1 mul
+delaunay channels 0,2
detect_skin:
0<=tolerance<=1,_skin_x,_skin_y,_skin_radius>=0
Detect skin in
selected color images and output an appartenance probability
map.
Detection is performed using CbCr chromaticity data of skin
pixels.
If arguments ’skin_x’,
’skin_y’ and
’skin_radius’ are provided, skin pixels
are learnt
from the sample pixels inside the circle located at
(’skin_x’,’skin_y’) with
radius ’skin_radius’.
Default value: ’tolerance=0.5’ and ’skin_x=skiny=radius=-1’.
displacement
(+):
[source_image],_smoothness,_precision>=0,_nb_scales>=0,_iteration_max>=0,is_backward={
0 | 1 }, _[guide]
Estimate
displacement field between specified source and selected
target images.
If ’smoothness>=0’, regularization
type is set to isotropic, else to anisotropic.
If ’nbscales==0’, the number of scales
used is estimated from the image size.
Default
values: ’smoothness=0.1’,
’precision=5’,
’nb_scales=0’,
’iteration_max=10000’,
’is_backward=1’ and
’[guide]=(unused)’.
Example: [#1] image.jpg +rotate 3,1,0,50%,50% +displacement[-1] [-2] quiver[-1] [-1],15,1,1,1,{1.5*iM}
distance
(+):
isovalue[%],_metric |
isovalue[%],[metric],_method
Compute the
unsigned distance function to specified isovalue, opt.
according to a custom metric.
’metric’ can be { 0=chebyshev |
1=manhattan | 2=euclidean | 3=squared-euclidean }.
’method’ can be { 0=fast-marching |
1=low-connectivity dijkstra | 2=high-connectivity dijkstra |
3=1+return path | 4=2+return path }.
Default value: ’metric=2’ and ’method=0’.
Example:
[#1] image.jpg threshold 20% distance 0 pow 0.3
[#2] 400,400 set 1,50%,50% +distance[0] 1,2 +distance[0] 1,1
distance[0] 1,0 mod 32 threshold 16 append c
Tutorial: https://gmic.eu/tutorial/_distance.shtml
fftpolar:
Compute fourier transform of selected images, as centered magnitude/phase images.
Example: [#1] image.jpg fftpolar ellipse 50%,50%,10,10,0,1,0 ifftpolar
histogram
(+):
_nb_levels>0[%],_value0[%],_value1[%]
Compute the
histogram of selected images.
If value range is set, the histogram is estimated only for
pixels in the specified
value range. Argument ’value1’ must be
specified if ’value0’ is set.
Default values: ’nb_levels=256’, ’value0=0%’ and ’value1=100%’.
Example: [#1] image.jpg +histogram 64 display_graph[-1] 400,300,3
histogram_nd:
nb_levels>0[%],_value0[%],_value1[%]
Compute the
1D,2D or 3D histogram of selected multi-channels images
(having 1,2 or 3 channels).
If value range is set, the histogram is estimated only for
pixels in the specified
value range.
Default values: ’value0=0%’ and ’value1=100%’.
Example: [#1] image.jpg channels 0,1 +histogram_nd 256
histogram_cumul:
_nb_levels>0,_is_normalized={ 0 | 1
},_val0[%],_val1[%]
Compute cumulative histogram of selected images.
Default values: ’nb_levels=256’, ’is_normalized=0’, ’val0=0%’ and ’val1=100%’.
Example: [#1] image.jpg +histogram_cumul 256 histogram[0] 256 display_graph 400,300,3
histogram_pointwise:
nb_levels>0[%],_value0[%],_value1[%]
Compute the
histogram of each vector-valued point of selected images.
If value range is set, the histogram is estimated only for
values in the specified
value range.
Default values: ’value0=0%’ and ’value1=100%’.
hough:
_width>0,_height>0,gradient_norm_voting={ 0 | 1 }
Compute hough transform (theta,rho) of selected images.
Default values: ’width=512’, ’height=width’ and ’gradient_norm_voting=1’.
Example: [#1] image.jpg +blur 1.5 hough[-1] 400,400 blur[-1] 0.5 add[-1] 1 log[-1]
ifftpolar:
Compute inverse fourier transform of selected images, from centered magnitude/phase images.
isophotes:
_nb_levels>0
Render isophotes of selected images on a transparent background.
Default value: ’nb_levels=64’
Example: [#1] image.jpg blur 2 isophotes 6 dilate_circ 5 display_rgba
label
(+):
_tolerance>=0,is_high_connectivity={ 0 | 1
},_is_L2_norm={ 0 | 1 }
Label connected components in selected images.
Default values: ’tolerance=0’, ’is_high_connectivity=0’ and ’is_L2_norm=1’.
Example:
[#1] image.jpg luminance threshold 60% label normalize 0,255
map 0
[#2] 400,400 set 1,50%,50% distance 1 mod 16 threshold 8
label mod 255 map 2
Tutorial: https://gmic.eu/tutorial/_label.shtml
label_fg:
tolerance>=0,is_high_connectivity={ 0 | 1 }
Label connected
components for non-zero values (foreground) in selected
images.
Similar to ’label’ except that 0-valued
pixels are not labeled.
Default value: ’is_high_connectivity=0’.
laar:
Extract the
largest axis-aligned rectangle in non-zero areas of selected
images.
Rectangle coordinates are returned in status, as a sequence
of numbers x0,y0,x1,y1.
Example: [#1] shape_cupid 256 coords=${-laar} normalize 0,255 to_rgb rectangle $coords,0.5,0,128,0
max_patch:
_patch_size>=1
Return locations
of maximal values in local patch-based neighborhood of given
size for selected
images.
Default value: ’patch_size=16’.
Example: [#1] image.jpg norm +max_patch 16
min_patch:
_patch_size>=1
Return locations
of minimal values in local patch-based neighborhood of given
size for selected
images.
Default value: ’patch_size=16’.
Example: [#1] image.jpg norm +min_patch 16
minimal_path:
x0[%]>=0,y0[%]>=0,z0[%]>=0,x1[%]>=0,y1[%]>=0,z1[%]>=0,_is_high_connectivity={
0 | 1 }
Compute minimal path between two points on selected potential maps.
Default value: ’is_high_connectivity=0’.
Example: [#1] image.jpg +gradient_norm fill[-1] 1/(1+i) minimal_path[-1] 0,0,0,100%,100%,0 pointcloud[-1] 0 *[-1] 280 to_rgb[-1] ri[-1] [-2],0 or
mse (+):
Compute MSE (Mean-Squared Error) matrix between selected images.
Example: [#1] image.jpg +noise 30 +noise[0] 35 +noise[0] 38 cut. 0,255 mse
patches:
patch_width>0,patch_height>0,patch_depth>0,x0,y0,z0,_x1,_y1,_z1,...,_xN,_yN,_zN
Extract N+1 patches from selected images, centered at specified locations.
Example: [#1] image.jpg +patches 64,64,1,153,124,0,184,240,0,217,126,0,275,38,0
matchpatch
(+):
[patch_image],patch_width>=1,_patch_height>=1,_patch_depth>=1,_nb_iterations>=0,_nb_randoms>=0,
_patch_penalization,_output_score={ 0 | 1 },_[guide]
Estimate
correspondence map between selected images and specified
patch image, using
a patch-matching algorithm.
Each pixel of the returned correspondence map gives the
location (p,q) of the closest patch in
the specified patch image. If
’output_score=1’, the third channel also
gives the corresponding
matching score for each patch as well.
If ’patch_penalization’ is >=0, SSD is
penalized with patch occurrences.
If ’patch_penalization’ is <0, SSD is
inf-penalized when distance between patches are less than
’-patch_penalization’.
Default
values: ’patch_height=patch_width’,
’patch_depth=1’,
’nb_iterations=5’,
’nb_randoms=5’,
’patch_penalization=0’,
’output_score=0’ and
’guide=(undefined)’.
Example: [#1] image.jpg sample colorful +matchpatch[0] [1],3 +warp[-2] [-1],0
plot2value:
Retrieve values from selected 2D graph plots.
Example: [#1] 400,300,1,1,’if(y>300*abs(cos(x/10+2*u)),1,0)’ +plot2value +display_graph[-1] 400,300
pointcloud:
_type = { -X=-X-opacity | 0=binary | 1=cumulative | 2=label
| 3=retrieve coordinates },_width,
_height>0,_depth>0
Render a set of
point coordinates, as a point cloud in a 1D/2D or 3D binary
image
(or do the reverse, i.e. retrieve coordinates of non-zero
points from a rendered point cloud).
Input point coordinates can be a NxMx1x1, Nx1x1xM or 1xNx1xM
image, where ’N’ is the number of
points,
and M the point coordinates.
If ’M’>3, the 3-to-M components sets
the (M-3)-dimensional color at each point.
Parameters ’width’,’height’
and ’depth’ are related to the size of
the final image :
- If set to 0, the size is automatically set along the
specified axis.
- If set to N>0, the size along the specified axis is N.
- If set to N<0, the size along the specified axis is at
most N.
Points with coordinates that are negative or higher than
specified
(’width’,’height’,’depth’)
are not plotted.
Default values: ’type=0’ and ’max_width=max_height=max_depth=0’.
Example:
[#1] 3000,2 rand 0,400 +pointcloud 0 dilate[-1] 3
[#2] 3000,2 rand 0,400 {w} {w},3 rand[-1] 0,255 append y
+pointcloud 0 dilate[-1] 3
psnr:
_max_value
Compute PSNR (Peak Signal-to-Noise Ratio) matrix between selected images.
Default value: ’max_value=255’.
Example: [#1] image.jpg +noise 30 +noise[0] 35 +noise[0] 38 cut[-1] 0,255 psnr 255 replace_inf 0
segment_watershed:
_threshold>=0
Apply watershed segmentation on selected images.
Default values: ’threshold=2’.
Example: [#1] image.jpg segment_watershed 2
shape2bump:
_resolution>=0,0<=_weight_avg_max_avg<=1,_dilation,_smoothness>=0
Estimate bumpmap from binary shape in selected images.
Default value: ’resolution=256’, ’weight_avg_max=0.75’, ’dilation=0’ and ’smoothness=100’.
skeleton:
_boundary_conditions={ 0=dirichlet | 1=neumann }
Compute skeleton of binary shapes using distance transform and constrained thinning.
Default value: ’boundary_conditions=1’.
Example: [#1] shape_cupid 320 +skeleton 0
slic:
size>0,_regularity>=0,_nb_iterations>0
Segment selected
2D images with superpixels, using the SLIC algorithm (Simple
Linear Iterative
Clustering).
Scalar images of increasingly labeled pixels are returned.
Reference paper: Achanta, R., Shaji, A., Smith, K., Lucchi,
A., Fua, P., & Susstrunk, S. (2010).
SLIC Superpixels (No. EPFL-REPORT-149300).
Default values: ’size=16’, ’regularity=10’ and ’nb_iterations=10’.
Example: [#1] image.jpg +srgb2lab slic[-1] 16 +blend shapeaverage f[-2] "j(1,0)==i && j(0,1)==i" *[-1] [-2]
ssd_patch:
[patch],_use_fourier={ 0 | 1 },_boundary_conditions={
0=dirichlet | 1=neumann }
Compute fields
of SSD between selected images and specified patch.
Argument ’boundary_conditions’ is valid
only when ’use_fourier=0’.
Default value: ’use_fourier=0’ and ’boundary_conditions=0’.
Example: [#1] image.jpg +crop 20%,20%,35%,35% +ssd_patch[0] [1],0,0
thinning:
_boundary_conditions={ 0=dirichlet | 1=neumann }
Compute skeleton
of binary shapes using morphological thinning
(beware, this is a quite slow iterative process)
Default value: ’boundary_conditions=1’.
Example: [#1] shape_cupid 320 +thinning
tones:
N>0
Get N tones masks from selected images.
Example: [#1] image.jpg +tones 3
topographic_map:
_nb_levels>0,_smoothness
Render selected images as topographic maps.
Default values: ’nb_levels=16’ and ’smoothness=2’.
Example: [#1] image.jpg topographic_map 10
tsp:
_precision>=0
Try to solve the
’travelling salesman’ problem, using a
combination of greedy search and 2-opt
algorithms.
Selected images must have dimensions Nx1x1xC to represent N
cities each with C-dimensional
coordinates.
This command re-order the selected data along the x-axis so
that the point sequence becomes a
shortest path.
Default values: ’precision=256’.
Example: [#1] 256,1,1,2 rand 0,512 tsp , 512,512,1,3 repeat w#0 circle[-1] {0,I[$>]},2,1,255,255,255 line[-1] {0,boundary=2;[I[$>],I[$>+1]]},1,255,128,0 done keep[-1]
variance_patch:
_patch_size>=1
Compute variance of each images patch centered at (x,y), in selected images.
Default value: ’patch_size=16’
Example: [#1] image.jpg +variance_patch
12.10. Image
Drawing
-------------
arrow:
x0[%],y0[%],x1[%],y1[%],_thickness[%]>=0,_head_length[%]>=0,_head_thickness[%]>=0,_opacity,_pattern,
_color1,...
Draw specified
arrow on selected images.
’pattern’ is an hexadecimal number
starting with ’0x’ which can be omitted
even if a color is specified. If a pattern is specified, the
arrow is
drawn outlined instead of filled.
Default
values: ’thickness=1%’,
’head_length=10%’,
’head_thickness=3%’,
’opacity=1’,
’pattern=(undefined)’ and
’color1=0’.
Example: [#1] 400,400,1,3 repeat 100 arrow 50%,50%,{u(100)}%,{u(100)}%,3,20,10,0.3,${-rgb} done
axes:
x0,x1,y0,y1,_font_height>=0,_opacity,_pattern,_color1,...
Draw xy-axes on
selected images.
’pattern’ is an hexadecimal number
starting with ’0x’ which can be omitted
even if a color is specified.
To draw only one x-axis at row Y, set both
’y0’ and ’y1’ to Y.
To draw only one y-axis at column X, set both
’x0’ and ’x1’ to
X.
Default values: ’font_height=14’, ’opacity=1’, ’pattern=(undefined)’ and ’color1=0’.
Example: [#1] 400,400,1,3,255 axes -1,1,1,-1
ball:
_size>0,
_R,_G,_B,0<=_specular_light<=8,0<=_specular_size<=8,_shadow>=0
Input a 2D RGBA colored ball sprite.
Default
values: ’size=64’,
’R=255’, ’G=R’,
’B=R’,
’specular_light=0.8’,
’specular_size=1’ and
’shading=1.5’.
Example: [#1] repeat 9 ball {1.5ˆ($>+2)},${-rgb} done append x
chessboard:
size1>0,_size2>0,_offset1,_offset2,_angle,_opacity,_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_distmax>=0,_segment_distmax>=0,
0<=_spline_anglemax<=180,_spline_roundness>=0,_area_min>=0,_allow_self_intersection={
0 | 1 }
Automatically close open shapes in binary images (defining white strokes on black background).
Default
values: ’endpoint_rate=75’,
’endpoint_connectivity=2’,
’spline_distmax=80’,
’segment_distmax=20’,
’spline_anglemax=90’,
’spline_roundness=1’,’area_min=100’,
’allow_self_intersection=1’.
ellipse
(+):
x[%],y[%],R[%],r[%],_angle,_opacity,_pattern,_color1,...
Draw specified
colored ellipse on selected images.
A radius of ’100%’ stands for
’sqrt(widthˆ2+heightˆ2)’.
’pattern’ is an hexadecimal number
starting with ’0x’ which can be omitted
even if a color is specified. If a pattern is specified, the
ellipse is
drawn outlined instead of filled.
Default values: ’opacity=1’, ’pattern=(undefined)’ and ’color1=0’.
Example: [#1] image.jpg repeat 300 ellipse {u(100)}%,{u(100)}%,{u(30)},{u(30)},{u(180)},0.3,${-rgb} done ellipse 50%,50%,100,100,0,0.7,255
flood
(+):
x[%],_y[%],_z[%],_tolerance>=0,_is_high_connectivity={ 0
| 1 },_opacity,_color1,...
Flood-fill selected images using specified value and tolerance.
Default values: ’y=z=0’, ’tolerance=0’, ’is_high_connectivity=0’, ’opacity=1’ and ’color1=0’.
Example: [#1] image.jpg repeat 1000 flood {u(100)}%,{u(100)}%,0,20,0,1,${-rgb} done
gaussian:
_sigma1[%],_sigma2[%],_angle
Draw a centered gaussian on selected images, with specified standard deviations and orientation.
Default values: ’sigma1=3’, ’sigma2=sigma1’ and ’angle=0’.
Example: [#1] 400,400 gaussian 100,30,45
Tutorial: https://gmic.eu/tutorial/_gaussian.shtml
graph
(+):
[function_image],_plot_type,_vertex_type,_ymin,_ymax,_opacity,_pattern,_color1,...
|
’formula’,_resolution>=0,_plot_type,_vertex_type,_xmin,xmax,_ymin,_ymax,_opacity,_pattern,_color1,
...
Draw specified
function graph on selected images.
’plot_type’ can be { 0=none | 1=lines
| 2=splines | 3=bar }.
’vertex_type’ can be { 0=none |
1=points | 2,3=crosses | 4,5=circles | 6,7=squares }.
’pattern’ is an hexadecimal number
starting with ’0x’ which can be omitted
even if a color is specified.
Default
values: ’plot_type=1’,
’vertex_type=1’, ’ymin=ymax=0
(auto)’, ’opacity=1’,
’pattern=(undefined)’
and ’color1=0’.
Example: [#1] image.jpg +rows 50% blur[-1] 3 split[-1] c div[0] 1.5 graph[0] [1],2,0,0,0,1,255,0,0 graph[0] [2],2,0,0,0,1,0,255,0 graph[0] [3],2,0,0,0,1,0,0,255 keep[0]
grid:
size_x[%]>=0,size_y[%]>=0,_offset_x[%],_offset_y[%],_opacity,_pattern,_color1,...
Draw xy-grid on
selected images.
’pattern’ is an hexadecimal number
starting with ’0x’ which can be omitted
even if a color is specified.
Default values: ’offset_x=offset_y=0’, ’opacity=1’, ’pattern=(undefined)’ and ’color1=0’.
Example:
[#1] image.jpg grid 10%,10%,0,0,0.5,255
[#2] 400,400,1,3,255 grid
10%,10%,0,0,0.3,0xCCCCCCCC,128,32,16
j (+):
Shortcut for command ’image’.
image
(+):
[sprite],_x[%|˜],_y[%|˜],_z[%|˜],_c[%|˜],_opacity,_[opacity_mask],_max_opacity_mask
Draw specified
sprite image on selected images.
(equivalent to shortcut command ’j’).
If one of the
x,y,z or c argument ends with a ’˜’, its
value is expected to be
a centering ratio (in [0,1]) rather than a position.
Usual centering ratio are { 0=left-justified |
0.5=centered | 1=right-justified }.
Default values: ’x=y=z=c=0’, ’opacity=1’, ’opacity_mask=(undefined)’ and ’max_opacity_mask=1’.
Example: [#1] image.jpg +crop 40%,40%,60%,60% resize[-1] 200%,200%,1,3,5 frame[-1] 2,2,0 image[0] [-1], 30%,30% keep[0]
line (+):
x0[%],y0[%],x1[%],y1[%],_opacity,_pattern,_color1,...
Draw specified
colored line on selected images.
’pattern’ is an hexadecimal number
starting with ’0x’ which can be omitted
even if a color is specified.
Default values: ’opacity=1’, ’pattern=(undefined)’ and ’color1=0’.
Example: [#1] image.jpg repeat 500 line 50%,50%,{u(w)},{u(h)},0.5,${-rgb} done line 0,0,100%,100%,1, 0xCCCCCCCC,255 line 100%,0,0,100%,1,0xCCCCCCCC,255
linethick:
x0[%],y0[%],x1[%],y1[%],_thickness,_opacity,_color1
Draw specified colored thick line on selected images.
Default values: ’thickness=2’, ’opacity=1’ and ’color1=0’.
Example: [#1] 400,400,1,3 repeat 100 linethick {u([w,h,w,h,5])},0.5,${-rgb} done
mandelbrot
(+):
z0r,z0i,z1r,z1i,_iteration_max>=0,_is_julia={ 0 | 1
},_c0r,_c0i,_opacity
Draw mandelbrot/julia fractal on selected images.
Default values: ’iteration_max=100’, ’is_julia=0’, ’c0r=c0i=0’ and ’opacity=1’.
Example: [#1] 400,400 mandelbrot -2.5,-2,2,2,1024 map 0 +blur 2 elevation3d[-1] -0.2
marble:
_image_weight,_pattern_weight,_angle,_amplitude,_sharpness>=0,_anisotropy>=0,_alpha,_sigma,
_cut_low>=0,_cut_high>=0
Render marble like pattern on selected images.
Default
values: ’image_weight=0.2’,
’pattern_weight=0.1’,
’angle=45’,
’amplitude=0’,
’sharpness=0.4’ and
’anisotropy=0.8’,
’alpha=0.6’,
’sigma=1.1’ and
’cut_low=cut_high=0’.
Example: [#1] image.jpg +marble ,
maze:
_width>0,_height>0,_cell_size>0
Input maze with specified size.
Example: [#1] maze 30,20 negate normalize 0,255
maze_mask:
_cellsize>0
Input maze
according to size and shape of selected mask images.
Mask may contain disconnected shapes.
Example: [#1] 0 text "G’MIC",0,0,53,1,1 dilate 3 autocrop 0 frame 1,1,0 maze_mask 8 dilate 3 negate mul 255
newton_fractal:
z0r,z0i,z1r,z1i,_angle,0<=_descent_method<=2,_iteration_max>=0,_convergence_precision>0,_expr_p(z),
_expr_dp(z),_expr_d2p(z)
Draw newton
fractal on selected images, for complex numbers in range
(z0r,z0i) - (z1r,z1i).
Resulting images have 3 channels whose meaning is [ last_zr,
last_zi, nb_iter_used_for_convergence
].
’descent_method’ can be { 0=secant |
1=newton | 2=householder }.
Default
values: ’angle=0’,
’descent_method=1’,
’iteration_max=200’,
’convergence_precision=0.01’,
’expr_p(z)=zˆˆ3-1’,
’expr_dp(z)=3*zˆˆ2’ and
’expr_d2z(z)=6*z’.
Example: [#1] 400,400 newton_fractal -1.5,-1.5,1.5,1.5,0,2,200,0.01,"zˆˆ6 + zˆˆ3 - 1","6*zˆˆ5 + 3*zˆˆ2", "30*zˆˆ4 + 6*z" f "[ atan2(i1,i0)*90+20,1,cut(i2/30,0.2,0.7) ]" hsl2rgb
j3d (+):
Shortcut for command ’object3d’.
object3d
(+):
[object3d],_x[%],_y[%],_z,_opacity,_rendering_mode,_is_double_sided={
0 | 1 },_is_zbuffer={ 0 | 1 },
_focale,_light_x,_light_y,_light_z,_specular_lightness,_specular_shininess
Draw specified
3D object on selected images.
(equivalent to shortcut command
’j3d’).
’rendering_mode’
can be { 0=dots | 1=wireframe | 2=flat | 3=flat-shaded |
4=gouraud-shaded |
5=phong-shaded }.
Default
values: ’x=y=z=0’,
’opacity=1’ and
’is_zbuffer=1’. All other arguments take
their
default values
from the 3D environment variables.
Example: [#1] image.jpg torus3d 100,10 cone3d 30,-120 add3d[-2,-1] rotate3d. 1,1,0,60 object3d[0] [-1], 50%,50% keep[0]
pack_sprites:
_nb_scales>=0,0<=_min_scale<=100,_allow_rotation={
0=0 deg. | 1=180 deg. | 2=90 deg. | 3=any },
_spacing,_precision>=0,max_iterations>=0
Try to randomly
pack as many sprites as possible onto the
’empty’ areas of an image.
Sprites can be eventually rotated and scaled during the
packing process.
First selected image is the canvas that will be filled with
the sprites.
Its last channel must be a binary mask whose zero values
represent potential locations for drawing
the sprites.
All other selected images represent the sprites considered
for packing.
Their last channel must be a binary mask that represents the
sprite shape (i.e. a 8-connected
component).
The order of sprite packing follows the order of specified
sprites in the image list.
Sprite packing is done on random locations and iteratively
with decreasing scales.
’nb_scales’ sets the number of decreasing
scales considered for all specified sprites to be packed.
’min_scale’ (in %) sets the minimal size
considered for packing (specified as a percentage of the
original sprite size).
’spacing’ can be positive or negative.
’precision’ tells about the desired
number of failed trials before ending the filling
process.
Default
values: ’nb_scales=5’,
’min_scale=25’,
’allow_rotation=3’,
’spacing=1’,
’precision=7’
and ’max_iterations=256’.
Example: [#1] 512,512,1,3,"min(255,y*c/2)" 100%,100% circle 50%,50%,100,1,255 append c image.jpg resize2dy[-1] 24 to_rgba pack_sprites 3,25
piechart:
label_height>=0,label_R,label_G,label_B,"label1",value1,R1,G1,B1,...,"labelN",valueN,RN,GN,BN
Draw pie chart on selected (RGB) images.
Example: [#1] image.jpg piechart 25,0,0,0,"Red",55,255,0,0,"Green",40,0,255,0,"Blue",30,128,128,255, "Other",5,128,128,128
plasma
(+):
_alpha,_beta,_scale>=0
Draw a random
colored plasma fractal on selected images.
This command implements the so-called
’Diamond-Square’ algorithm.
Default values: ’alpha=1’, ’beta=1’ and ’scale=8’.
Example: [#1] 400,400,1,3 plasma
Tutorial: https://gmic.eu/tutorial/_plasma.shtml
point
(+):
x[%],y[%],_z[%],_opacity,_color1,...
Set specified colored pixel on selected images.
Default values: ’z=0’, ’opacity=1’ and ’color1=0’.
Example: [#1] image.jpg repeat 10000 point {u(100)}%,{u(100)}%,0,1,${-rgb} done
polka_dots:
diameter>=0,_density,_offset1,_offset2,_angle,_aliasing,_shading,_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
polygon is
drawn outlined instead of filled.
Default values: ’opacity=1’, ’pattern=(undefined)’ and ’color1=0’.
Example:
[#1] image.jpg polygon
4,20%,20%,80%,30%,80%,70%,20%,80%,0.3,0,255,0 polygon
4,20%,20%,80%,30%, 80%,70%,20%,80%,1,0xCCCCCCCC,255
[#2] image.jpg 2,16,1,1,’u(if(x,{h},{w}))’
polygon[-2] {h},{ˆ},0.6,255,0,255 remove[-1]
quiver:
[function_image],_sampling[%]>0,_factor>=0,_is_arrow={
0 | 1 },_opacity,_color1,...
Draw specified 2D vector/orientation field on selected images.
Default
values: ’sampling=5%’,
’factor=1’,
’is_arrow=1’,
’opacity=1’,
’pattern=(undefined)’
and ’color1=0’.
Example:
[#1] 100,100,1,2,’if(c==0,x-w/2,y-h/2)’
500,500,1,3,255 quiver[-1] [-2],10
[#2] image.jpg +resize2dy 600 luminance[0] gradient[0]
mul[1] -1 reverse[0,1] append[0,1] c blur[0] 8
orientation[0] quiver[1] [0],20,1,1,0.8,255
rectangle:
x0[%],y0[%],x1[%],y1[%],_opacity,_pattern,_color1,...
Draw specified
colored rectangle on selected images.
’pattern’ is an hexadecimal number
starting with ’0x’ which can be omitted
even if a color is specified. If a pattern is specified, the
rectangle is
drawn outlined instead of filled.
Default values: ’opacity=1’, ’pattern=(undefined)’ and ’color1=0’.
Example: [#1] image.jpg repeat 30 rectangle {u(100)}%,{u(100)}%,{u(100)}%,{u(100)}%,0.3,${-rgb} done
rorschach:
’smoothness[%]>=0’,’mirroring={ 0=none
| 1=x | 2=y | 3=xy }
Render rorschach-like inkblots on selected images.
Default values: ’smoothness=5%’ and ’mirroring=1’.
Example: [#1] 400,400 rorschach 3%
sierpinski:
recursion_level>=0
Draw Sierpinski triangle on selected images.
Default value: ’recursion_level=7’.
Example: [#1] image.jpg sierpinski 7
spiralbw:
width>0,_height>0,_is_2dcoords={ 0 | 1 }
Input a 2D rectangular spiral image with specified size.
Default values: ’height=width’ and ’is_2dcoords=0’.
Example:
[#1] spiralbw 16
[#2] image.jpg spiralbw {[w,h]},1 +warp[0] [1],0 +warp[2]
[1],2
spline:
x0[%],y0[%],u0[%],v0[%],x1[%],y1[%],u1[%],v1[%],_opacity,_color1,...
Draw specified colored spline curve on selected images (cubic hermite spline).
Default values: ’opacity=1’ and ’color1=0’.
Example: [#1] image.jpg repeat 30 spline {u(100)}%,{u(100)}%,{u(-600,600)},{u(-600,600)},{u(100)}%, {u(100)}%,{u(-600,600)},{u(-600,600)},0.6,255 done
tetraedron_shade:
x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3,R0,G0,B0,...,R1,G1,B1,...,R2,G2,B2,...,R3,G3,B3,...
Draw tetraedron with interpolated colors on selected (volumetric) images.
t (+):
Shortcut for command ’text’.
text (+):
text,_x[%|˜],_y[%|˜],_font_height[%]>=0,_opacity,_color1,...
Draw specified
colored text string on selected images.
(equivalent to shortcut command ’t’).
If one of the x
or y argument ends with a ’˜’, its value
is expected to be
a centering ratio (in [0,1]) rather than a position.
Usual centering ratio are { 0=left-justified |
0.5=centered | 1=right-justified }.
Sizes ’13’ and ’128’
are special and correspond to binary fonts
(no-antialiasing).
Any other font size is rendered with anti-aliasing.
Specifying an empty target image resizes it to new
dimensions such that the image contains
the entire text string.
Default values: ’x=y=0.01˜’, ’font_height=16’, ’opacity=1’ and ’color1=0’.
Example:
[#1] image.jpg resize2dy 600 y=0 repeat 30 text
{2*$>}" : This is a nice text, isn’t it
?",10, $y,{2*$>},0.9,255 y+={2*$>} done
[#2] 0 text "G’MIC",0,0,23,1,255
to:
Shortcut for command ’text_outline’.
text_outline:
text,_x[%|˜],_y[%|˜],_font_height[%]>0,_outline>=0,_opacity,_color1,...
Draw specified
colored and outlined text string on selected images.
If one of the x or y argument ends with a
’˜’, its value is expected to be
a centering ratio (in [0,1]) rather than a position.
Usual centering ratio are { 0=left-justified |
0.5=centered | 1=right-justified }.
Default
values: ’x=y=0.01˜’,
’font_height=7.5%’,
’outline=2’,
’opacity=1’,
’color1=color2=color3=255’ and
’color4=255’.
Example: [#1] image.jpg text_outline "Hi there!",10,10,63,3
triangle_shade:
x0,y0,x1,y1,x2,y2,R0,G0,B0,...,R1,G1,B1,...,R2,G2,B2,...
Draw triangle with interpolated colors on selected images.
Example: [#1] image.jpg triangle_shade 20,20,400,100,120,200,255,0,0,0,255,0,0,0,255
truchet:
_scale>0,_radius>=0,_pattern_type={ 0=straight |
1=curved }
Fill selected images with random truchet patterns.
Default values: ’scale=32’, ’radius=5’ and ’pattern_type=1’.
Example: [#1] 400,300 truchet ,
turbulence:
_radius>0,_octaves={1,2,3...,12},_alpha>0,_difference={-10,10},_mode={0,1,2,3}
Render fractal noise or turbulence on selected images.
Default values: ’radius=32’, ’octaves=6’, ’alpha=3’, ’difference=0’ and ’mode=0’.
Example: [#1] 400,400,1,3 turbulence 16
Tutorial: https://gmic.eu/tutorial/_turbulence.shtml
yinyang:
Draw a yin-yang symbol on selected images.
Example: [#1] 400,400 yinyang
12.11. Matrix
Computation
------------------
dijkstra
(+):
starting_node>=0,ending_node>=0
Compute minimal distances and paths from specified adjacency matrices by the Dijkstra algorithm.
eigen (+):
Compute the
eigenvalues and eigenvectors of selected symmetric matrices
or matrix fields.
If one selected image has 3 or 6 channels, it is regarded as
a field of 2x2 or 3x3 symmetric
matrices,
whose eigen elements are computed at each point of the
field.
Example:
[#1] (1,0,0;0,2,0;0,0,3) +eigen
[#2] image.jpg structuretensors blur 2 eigen split[0] c
Tutorial: https://gmic.eu/tutorial/_eigen.shtml
invert
(+):
solver={ 0=SVD | 1=LU }
Compute the
inverse of the selected matrices.
SVD solver is slower but less numerically instable than
LU.
Default value: ’solver=1’.
Example: [#1] (0,1,0;0,0,1;1,0,0) +invert
orthogonalize:
_mode = { 0=orthogonalize | 1=orthonormalize }
Orthogonalize or orthonormalize selected matrices, using Modified Gram-Schmidt process.
Default value: ’mode=0’.
mproj
(+):
[dictionary],_method,_max_iter={ 0=auto | >0
},_max_residual>=0
Find best
matching projection of selected matrices onto the span of an
over-complete
dictionary D, using the orthogonal projection or Matching
Pursuit algorithm.
Selected images are 2D-matrices in which each column
represent a signal to project.
’[dictionary]’ is a matrix in which each
column is an element of the dictionary D.
’method’ tells what projection algorithm
must be applied. It can be:
- 0 = orthogonal projection (least-squares solution using
LU-based solver).
- 1 = matching pursuit.
- 2 = matching pursuit, with a single orthogonal projection
step at the end.
- >=3 = orthogonal matching pursuit where an orthogonal
projection step is performed
every ’method-2’ iterations.
’max_iter’ sets the max number of
iterations processed for each signal.
If set to ’0’ (default),
’max_iter’ is equal to the number of
columns in D.
(only meaningful for matching pursuit and its variants).
’max_residual’ gives a stopping criterion
on signal reconstruction 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 solution is returned
(using SVD-based solver).
Example: [#1] (0,1,0;1,0,0;0,0,1) (1;2;3) +solve[-1] [-2]
svd (+):
Compute SVD decomposition of selected matrices.
Example: [#1] 10,10,1,1,’if(x==y,x+u(-0.2,0.2),0)’ +svd
transpose:
Transpose selected matrices.
Example: [#1] image.jpg +transpose
trisolve
(+):
[image]
Solve
tridiagonal system AX = B for selected B-vectors and
specified tridiagonal A-matrix.
Tridiagonal matrix must be stored as a 3 column vector,
where 2nd column contains the
diagonal coefficients, while 1st and 3rd columns contain the
left and right coefficients.
Example: [#1] (0,0,1;1,0,0;0,1,0) (1;2;3) +trisolve[-1] [-2]
12.12. 3D
Meshes
---------
+3d (+):
Shortcut for command ’add3d’.
add3d
(+):
tx,_ty,_tz |
[object3d] |
(no arg)
Shift selected
3D objects with specified displacement vector, or merge them
with specified
3D object, or merge all selected 3D objects together.
(equivalent to shortcut command
’+3d’).
Default values: ’ty=tz=0’.
Example:
[#1] sphere3d 10 repeat 5 +add3d[-1] 10,{u(-10,10)},0
color3d[-1] ${-rgb} done add3d
[#2] repeat 20 torus3d 15,2 color3d[-1] ${-rgb} mul3d[-1]
0.5,1 if $>%2 rotate3d[-1] 0,1,0,90 fi add3d[-1] 70 add3d
rotate3d[-1] 0,0,1,18 done double3d 0
animate3d:
_width>0,_height>0,_angle_dx,_angle_dy,_angle_dz,_zoom_factor>=0,_filename
Animate selected
3D objects in a window.
If argument ’filename’ is provided, each
frame of the animation is saved as a numbered filename.
Default
values: ’width=640’,
’height=480’,
’angle_dx=0’,
’angle_dy=1’,
’angle_dz=0’,
’zoom_factor=1’ and
’filename=(undefined)’.
apply_camera3d:
pos_x,pos_y,pos_z,target_x,target_y,target_z,up_x,up_y,up_z
Apply 3D camera matrix to selected 3D objects.
Default values: ’target_x=0’, ’target_y=0’, ’target_z=0’, ’up_x=0’, ’up_y=-1’ and ’up_z=0’.
apply_matrix3d:
a11,a12,a13,...,a31,a32,a33
Apply specified 3D rotation matrix to selected 3D objects.
Example: [#1] torus3d 10,1 +apply_matrix3d {mul(rot(1,0,1,-15),[1,0,0,0,2,0,0,0,8],3)} double3d 0
array3d:
size_x>=1,_size_y>=1,_size_z>=1,_offset_x[%],_offset_y[%],_offset_y[%]
Duplicate a 3D object along the X,Y and Z axes.
Default values: ’size_y=1’, ’size_z=1’ and ’offset_x=offset_y=offset_z=100%’.
Example: [#1] torus3d 10,1 +array3d 5,5,5,110%,110%,300%
arrow3d:
x0,y0,z0,x1,y1,z1,_radius[%]>=0,_head_length[%]>=0,_head_radius[%]>=0
Input 3D arrow with specified starting and ending 3D points.
Default values: ’radius=5%’, ’head_length=25%’ and ’head_radius=15%’.
Example: [#1] repeat 10 a={$>*2*pi/10} arrow3d 0,0,0,{cos($a)},{sin($a)},-0.5 done +3d
axes3d:
_size_x,_size_y,_size_z,_font_size>0,_label_x,_label_y,_label_z,_is_origin={
0=no | 1=yes }
Input 3D axes with specified sizes along the x,y and z orientations.
Default
values: ’size_x=size_y=size_z=1’,
’font_size=23’,
’label_x=X’,
’label_y=Y’,
’label_z=Z’ and
’is_origin=1’
Example: [#1] axes3d ,
boundingbox3d:
Replace selected 3D objects by their 3D bounding boxes.
Example: [#1] torus3d 100,30 +boundingbox3d +3d[-1] [-2]
box3d:
_size_x,_size_y,_size_z
Input 3D box at (0,0,0), with specified geometry.
Default values: ’size_x=1’ and ’size_z=size_y=size_x’.
Example: [#1] box3d 100,40,30 +primitives3d 1 color3d[-2] ${-rgb}
c3d:
Shortcut for command ’center3d’.
center3d:
Center selected
3D objects at (0,0,0).
(equivalent to shortcut command
’c3d’).
Example: [#1] repeat 100 circle3d {u(100)},{u(100)},{u(100)},2 done add3d color3d[-1] 255,0,0 +center3d color3d[-1] 0,255,0 add3d
circle3d:
_x0,_y0,_z0,_radius>=0
Input 3D circle at specified coordinates.
Default values: ’x0=y0=z0=0’ and ’radius=1’.
Example: [#1] repeat 500 a={$>*pi/250} circle3d {cos(3*$a)},{sin(2*$a)},0,{$a/50} color3d[-1] ${-rgb}, 0.4 done add3d
circles3d:
_radius>=0,_is_wireframe={ 0 | 1 }
Convert specified 3D objects to sets of 3D circles with specified radius.
Default values: ’radius=1’ and ’is_wireframe=1’.
Example: [#1] image.jpg luminance resize2dy 40 threshold 50% * 255 pointcloud3d color3d[-1] 255,255,255 circles3d 0.7
col3d
(+):
Shortcut for command ’color3d’.
color3d
(+):
R,_G,_B,_opacity
Set color and
opacity of selected 3D objects.
(equivalent to shortcut command
’col3d’).
Default value: ’B=G=R’ and ’opacity=(undefined)’.
Example: [#1] torus3d 100,10 double3d 0 repeat 7 +rotate3d[-1] 1,0,0,20 color3d[-1] ${-rgb} done add3d
colorcube3d:
Input 3D color cube.
Example: [#1] colorcube3d mode3d 2 +primitives3d 1
cone3d:
_radius,_height,_nb_subdivisions>0
Input 3D cone at (0,0,0), with specified geometry.
Default value: ’radius=1’,’height=1’ and ’nb_subdivisions=24’.
Example: [#1] cone3d 10,40 +primitives3d 1 color3d[-2] ${-rgb}
cubes3d:
_size>=0
Convert specified 3D objects to sets of 3D cubes with specified size.
Default value: ’size=1’.
Example: [#1] image.jpg luminance resize2dy 40 threshold 50% * 255 pointcloud3d color3d[-1] 255,255,255 cubes3d 1
cup3d:
_resolution>0
Input 3D cup object.
Default value: ’resolution=128’.
Example: [#1] cup3d ,
cylinder3d:
_radius,_height,_nb_subdivisions>0
Input 3D cylinder at (0,0,0), with specified geometry.
Default value: ’radius=1’,’height=1’ and ’nb_subdivisions=24’.
Example: [#1] cylinder3d 10,40 +primitives3d 1 color3d[-2] ${-rgb}
delaunay3d:
Generate 3D
delaunay triangulations from selected images.
One assumes that the selected input images are binary images
containing the set of points to mesh.
The output 3D object is a mesh composed of non-oriented
triangles.
Example: [#1] 500,500 noise 0.05,2 eq 1 * 255 +delaunay3d color3d[1] 255,128,0 dilate_circ[0] 5 to_rgb[0] +object3d[0] [1],0,0,0,1,1 max[-1] [0]
distribution3d:
Get 3D color distribution of selected images.
Example: [#1] image.jpg distribution3d colorcube3d primitives3d[-1] 1 add3d
/3d (+):
Shortcut for command ’div3d’.
div3d
(+):
factor |
factor_x,factor_y,_factor_z
Scale selected
3D objects isotropically or anisotropically, with the
inverse of specified
factors.
(equivalent to shortcut command
’/3d’).
Default value: ’factor_z=0’.
Example: [#1] torus3d 5,2 repeat 5 +add3d[-1] 12,0,0 div3d[-1] 1.2 color3d[-1] ${-rgb} done add3d
db3d (+):
Shortcut for command ’double3d’.
double3d
(+):
_is_double_sided={ 0 | 1 }
Enable/disable
double-sided mode for 3D rendering.
(equivalent to shortcut command
’db3d’).
Default value: ’is_double_sided=1’.
Example: [#1] mode3d 1 repeat 2 torus3d 100,30 rotate3d[-1] 1,1,0,60 double3d $> snapshot3d[-1] 400 done
elevation3d
(+):
z-factor |
[elevation_map] |
’formula’ |
(no arg)
Build 3D
elevation of selected images, with a specified elevation
map.
When invoked with (no arg) or ’z-factor’,
the elevation map is computed as the pointwise L2 norm of
the
pixel values. Otherwise, the elevation map is taken from the
specified image or formula.
Example:
[#1] image.jpg +blur 5 elevation3d. 0.75
[#2] 128,128,1,3,u(255) plasma 10,3 blur 4 sharpen 10000
elevation3d[-1]
’X=(x-64)/6;Y=(y-64)/6;-100*exp(-(Xˆ2+Yˆ2)/30)*abs(cos(X)*sin(Y))’
empty3d:
Input empty 3D object.
Example: [#1] empty3d
extrude3d:
_depth>0,_resolution>0,_smoothness[%]>=0
Generate extruded 3D object from selected binary XY-profiles.
Default values: ’depth=16’, ’resolution=1024’ and ’smoothness=0.5%’.
Example: [#1] image.jpg threshold 50% extrude3d 16
f3d (+):
Shortcut for command ’focale3d’.
focale3d
(+):
focale
Set 3D focale.
(equivalent to shortcut command
’f3d’).
Set
’focale’ to 0 to enable parallel
projection (instead of perspective).
Set negative ’focale’ will disable 3D
sprite zooming.
Default value: ’focale=700’.
Example: [#1] repeat 5 torus3d 100,30 rotate3d[-1] 1,1,0,60 focale3d {$<*90} snapshot3d[-1] 400 done remove[0]
gaussians3d:
_size>0,_opacity
Convert selected 3D objects into set of 3D gaussian-shaped sprites.
Example: [#1] image.jpg r2dy 32 distribution3d gaussians3d 20 colorcube3d primitives3d[-1] 1 +3d
gmic3d:
Input a 3D G’MIC logo.
Example: [#1] gmic3d +primitives3d 1
gyroid3d:
_resolution>0,_zoom
Input 3D gyroid at (0,0,0), with specified resolution.
Default values: ’resolution=32’ and ’zoom=5’.
Example: [#1] gyroid3d 48 +primitives3d 1
histogram3d:
Get 3D color histogram of selected images.
Example: [#1] image.jpg resize2dx 64 histogram3d circles3d 3 opacity3d. 0.75 colorcube3d primitives3d[-1] 1 add3d
image6cube3d:
Generate 3D mapped cubes from 6-sets of selected images.
Example: [#1] image.jpg animate flower,"30,0","30,5",6 image6cube3d
imageblocks3d:
_maximum_elevation,_smoothness[%]>=0
Generate 3D
blocks from selected images.
Transparency of selected images is taken into account.
Default values: ’maximum_elevation=10’ and ’smoothness=0’.
Example: [#1] image.jpg resize2dy 32 imageblocks3d -20 mode3d 3
imagecube3d:
Generate 3D mapped cubes from selected images.
Example: [#1] image.jpg imagecube3d
imageplane3d:
Generate 3D mapped planes from selected images.
Example: [#1] image.jpg imageplane3d
imagepyramid3d:
Generate 3D mapped pyramids from selected images.
Example: [#1] image.jpg imagepyramid3d
imagerubik3d:
_xy_tiles>=1,0<=xy_shift<=100,0<=z_shift<=100
Generate 3D mapped rubik’s cubes from selected images.
Default values: ’xy_tiles=3’, ’xy_shift=5’ and ’z_shift=5’.
Example: [#1] image.jpg imagerubik3d ,
imagesphere3d:
_resolution1>=3,_resolution2>=3
Generate 3D mapped sphere from selected images.
Default values: ’resolution1=32’ and ’resolutions2=16’.
Example: [#1] image.jpg imagesphere3d 32,16
isoline3d
(+):
isovalue[%] |
’formula’,value,_x0,_y0,_x1,_y1,_size_x>0[%],_size_y>0[%]
Extract 3D isolines with specified value from selected images or from specified formula.
Default values: ’x0=y0=-3’, ’x1=y1=3’ and ’size_x=size_y=256’.
Example:
[#1] image.jpg blur 1 isoline3d 50%
[#2] isoline3d
’X=x-w/2;Y=y-h/2;(Xˆ2+Yˆ2)%20’,10,-10,-10,10,10
isosurface3d
(+):
isovalue[%] |
’formula’,value,_x0,_y0,_z0,_x1,_y1,_z1,_size_x>0[%],_size_y>0[%],_size_z>0[%]
Extract 3D isosurfaces with specified value from selected images or from specified formula.
Default values: ’x0=y0=z0=-3’, ’x1=y1=z1=3’ and ’size_x=size_y=size_z=32’.
Example:
[#1] image.jpg resize2dy 128 luminance threshold 50%
expand_z 2,0 blur 1 isosurface3d 50% mul3d 1,1,30
[#2] isosurface3d
’xˆ2+yˆ2+abs(z)ˆabs(4*cos(x*y*z*3))’,3
label3d:
"text",font_height>=0,_opacity,_color1,...
Generate 3D text label.
Default values: ’font_height=13’, ’opacity=1’ and ’color=255,255,255’.
label_points3d:
_label_size>0,_opacity
Add a numbered label to all vertices of selected 3D objects.
Default values: ’label_size=13’ and ’opacity=0.8’.
Example: [#1] torus3d 100,40,6,6 label_points3d 23,1 mode3d 1
lathe3d:
_resolution>0,_smoothness[%]>=0,_max_angle>=0
Generate 3D object from selected binary XY-profiles.
Default values: ’resolution=128’, ’smoothness=0.5%’ and ’max_angle=361’.
Example: [#1] 300,300 rand -1,1 blur 40 sign normalize 0,255 lathe3d ,
l3d (+):
Shortcut for command ’light3d’.
light3d
(+):
position_x,position_y,position_z |
[texture] |
(no arg)
Set the light
coordinates or the light texture for 3D rendering.
(equivalent to shortcut command
’l3d’).
(no arg) resets the 3D light to default.
Example: [#1] torus3d 100,30 double3d 0 specs3d 1.2 repeat 5 light3d {$>*100},0,-300 +snapshot3d[0] 400 done remove[0]
line3d:
x0,y0,z0,x1,y1,z1
Input 3D line at specified coordinates.
Example: [#1] repeat 100 a={$>*pi/50} line3d 0,0,0,{cos(3*$a)},{sin(2*$a)},0 color3d. ${-rgb} done add3d
lissajous3d:
resolution>1,a,A,b,B,c,C
Input 3D lissajous curves (x(t)=sin(a*t+A*2*pi), y(t)=sin(b*t+B*2*pi), z(t)=sin(c*t+C*2*pi)).
Default values: ’resolution=1024’, ’a=2’, ’A=0’, ’b=1’, ’B=0’, ’c=0’ and ’C=0’.
Example: [#1] lissajous3d ,
m3d (+):
Shortcut for command ’mode3d’.
mode3d
(+):
_mode
Set static 3D
rendering mode.
(equivalent to shortcut command
’m3d’).
’mode’
can be { -1=bounding-box | 0=dots | 1=wireframe | 2=flat |
3=flat-shaded | 4=gouraud-shaded
| 5=phong-shaded }.");
Bounding-box mode (’mode==-1’) is active
only for the interactive 3D viewer.
Default value: ’mode=4’.
Example: [#1] (0,1,2,3,4,5) double3d 0 repeat w torus3d 100,30 rotate3d[-1] 1,1,0,60 mode3d {0,@$>} snapshot3d[-1] 300 done remove[0]
md3d (+):
Shortcut for command ’moded3d’.
moded3d
(+):
_mode
Set dynamic 3D
rendering mode for interactive 3D viewer.
(equivalent to shortcut command
’md3d’).
’mode’
can be { -1=bounding-box | 0=dots | 1=wireframe | 2=flat |
3=flat-shaded | 4=gouraud-shaded
| 5=phong-shaded }.
Default value: ’mode=-1’.
*3d (+):
Shortcut for command ’mul3d’.
mul3d
(+):
factor |
factor_x,factor_y,_factor_z
Scale selected
3D objects isotropically or anisotropically, with specified
factors.
(equivalent to shortcut command
’*3d’).
Default value: ’factor_z=0’.
Example: [#1] torus3d 5,2 repeat 5 +add3d[-1] 10,0,0 mul3d[-1] 1.2 color3d[-1] ${-rgb} done add3d
n3d:
Shortcut for command ’normalize3d’.
normalize3d:
Normalize
selected 3D objects to unit size.
(equivalent to shortcut command
’n3d’).
Example: [#1] repeat 100 circle3d {u(3)},{u(3)},{u(3)},0.1 done add3d color3d[-1] 255,0,0 +normalize3d[-1] color3d[-1] 0,255,0 add3d
o3d (+):
Shortcut for command ’opacity3d’.
opacity3d
(+):
_opacity
Set opacity of
selected 3D objects.
(equivalent to shortcut command
’o3d’).
Default value: ’opacity=1’.
Example: [#1] torus3d 100,10 double3d 0 repeat 7 +rotate3d[-1] 1,0,0,20 opacity3d[-1] {u} done add3d
parametric3d:
_x(a,b),_y(a,b),_z(a,b),_amin,_amax,_bmin,_bmax,_res_a>0,_res_b>0,_res_x>0,_res_y>0,_res_z>0,
_smoothness>=0,_isovalue>=0
Input 3D object from specified parametric surface (a,b) ⶠ(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
},_normalize_output={ 0 | 1 },_lambda_xy
Get 3D patch-pca
representation of selected images.
The 3D patch-pca is estimated from M patches on the input
image, and displayed as a cloud of N 3D
points.
Default
values: ’patch_size=7’,
’M=1000’, ’N=3000’,
’normalize_input=1’,
’normalize_output=0’,
and ’lambda_xy=0’.
Example: [#1] image.jpg pca_patch3d 7
plane3d:
_size_x,_size_y,_nb_subdivisions_x>0,_nb_subdisivions_y>0
Input 3D plane at (0,0,0), with specified geometry.
Default values: ’size_x=1’, ’size_y=size_x’ and ’nb_subdivisions_x=nb_subdivisions_y=24’.
Example: [#1] plane3d 50,30 +primitives3d 1 color3d[-2] ${-rgb}
point3d:
x0,y0,z0
Input 3D point at specified coordinates.
Example: [#1] repeat 1000 a={$>*pi/500} point3d {cos(3*$a)},{sin(2*$a)},0 color3d[-1] ${-rgb} done add3d
pointcloud3d:
Convert selected planar or volumetric images to 3D point clouds.
Example: [#1] image.jpg luminance resize2dy 100 threshold 50% mul 255 pointcloud3d color3d[-1] 255,255, 255
pose3d:
p1,...,p12
Apply 3D pose matrix to selected 3D objects.
Example: [#1] torus3d 100,20 pose3d 0.152437,1.20666,-0.546366,0,-0.535962,0.559129,1.08531,0,1.21132, 0.0955431,0.548966,0,0,0,-206,1 snapshot3d 400
p3d:
Shortcut for command ’primitives3d’.
primitives3d:
mode
Convert
primitives of selected 3D objects.
(equivalent to shortcut command
’p3d’).
’mode’ can be { 0=points | 1=outlines | 2=non-textured }.
Example: [#1] sphere3d 30 primitives3d 1 torus3d 50,10 color3d[-1] ${-rgb} add3d
projections3d:
_x[%],_y[%],_z[%],_is_bounding_box={ 0 | 1 }
Generate 3D xy,xz,yz projection planes from specified volumetric images.
pyramid3d:
width,height
Input 3D pyramid at (0,0,0), with specified geometry.
Example: [#1] pyramid3d 100,-100 +primitives3d 1 color3d[-2] ${-rgb}
quadrangle3d:
x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3
Input 3D quadrangle at specified coordinates.
Example: [#1] quadrangle3d -10,-10,10,10,-10,10,10,10,10,-10,10,10 repeat 10 +rotate3d[-1] 0,1,0,30 color3d[-1] ${-rgb},0.6 done add3d mode3d 2
random3d:
nb_points>=0
Input random 3D point cloud in [0,1]ˆ3.
Example: [#1] random3d 100 circles3d 0.1 opacity3d 0.5
rv3d (+):
Shortcut for command ’reverse3d’.
reverse3d (+):
Reverse
primitive orientations of selected 3D objects.
(equivalent to shortcut command
’rv3d’).
Example: [#1] torus3d 100,40 double3d 0 +reverse3d
r3d (+):
Shortcut for command ’rotate3d’.
rotate3d
(+):
u,v,w,angle
Rotate selected
3D objects around specified axis with specified angle (in
deg.).
(equivalent to shortcut command
’r3d’).
Example: [#1] torus3d 100,10 double3d 0 repeat 7 +rotate3d[-1] 1,0,0,20 done add3d
rotation3d:
u,v,w,angle
Input 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,_backgroundA
|
[background_image],zoom>=0
Take 2d
snapshots of selected 3D objects.
Set ’zoom’ to 0 to disable object
auto-scaling.
Default values: ’size=512’, ’zoom=1’ and ’[background_image]=(default)’.
Example:
[#1] torus3d 100,20 rotate3d 1,1,0,60 snapshot3d
400,1.2,128,64,32
[#2] torus3d 100,20 rotate3d 1,1,0,60 sample ?
+snapshot3d[0] [1],1.2
sl3d (+):
Shortcut for command ’specl3d’.
specl3d
(+):
value>=0
Set lightness of
3D specular light.
(equivalent to shortcut command
’sl3d’).
Default value: ’value=0.15’.
Example: [#1] (0,0.3,0.6,0.9,1.2) repeat w torus3d 100,30 rotate3d[-1] 1,1,0,60 color3d[-1] 255,0,0 specl3d {0,@$>} snapshot3d[-1] 400 done remove[0]
ss3d (+):
Shortcut for command ’specs3d’.
specs3d
(+):
value>=0
Set shininess of
3D specular light.
(equivalent to shortcut command
’ss3d’).
Default value: ’value=0.8’.
Example: [#1] (0,0.3,0.6,0.9,1.2) repeat w torus3d 100,30 rotate3d[-1] 1,1,0,60 color3d[-1] 255,0,0 specs3d {0,@$>} snapshot3d[-1] 400 done remove[0]
sphere3d
(+):
radius,_nb_recursions>=0
Input 3D sphere at (0,0,0), with specified geometry.
Default value: ’nb_recursions=3’.
Example: [#1] sphere3d 100 +primitives3d 1 color3d[-2] ${-rgb}
spherical3d:
_nb_azimuth>=3,_nb_zenith>=3,_radius_function(phi,theta)
Input 3D spherical object at (0,0,0), with specified geometry.
Default
values: ’nb_zenith=nb_azimut=64’ and
’radius_function="abs(1+0.5*cos(3*phi)*sin(4*thet
a))"’.
Example: [#1] spherical3d 64 +primitives3d 1
spline3d:
x0[%],y0[%],z0[%],u0[%],v0[%],w0[%],x1[%],y1[%],z1[%],u1[%],v1[%],w1[%],_nb_vertices>=2
Input 3D spline with specified geometry.
Default values: ’nb_vertices=128’.
Example: [#1] repeat 100 spline3d {u},{u},{u},{u},{u},{u},{u},{u},{u},{u},{u},{u},128 color3d[-1] ${-rgb} done box3d 1 primitives3d[-1] 1 add3d
s3d (+):
Shortcut for command ’split3d’.
split3d
(+):
_keep_shared_data={ 0 | 1 }
Split selected
3D objects into 6 feature vectors :
{ header, sizes, vertices, primitives, colors, opacities
}.
(equivalent to shortcut command
’s3d’).
To recreate the 3D object, append these 6 images along the y-axis.
Default value: ’keep_shared_data=1’.
Example: [#1] box3d 100 +split3d
sprite3d:
Convert selected
images as 3D sprites.
Selected images with alpha channels are managed.
Example: [#1] image.jpg sprite3d
sprites3d:
[sprite],_sprite_has_alpha_channel={ 0 | 1 }
Convert selected
3D objects as a sprite cloud.
Set ’sprite_has_alpha_channel’ to 1 to
make the last channel of the selected sprite be a
transparency mask.
Default value: ’mask_has_alpha_channel=0’.
Example: [#1] torus3d 100,20 image.jpg resize2dy[-1] 64 100%,100% gaussian[-1] 30%,30% *[-1] 255 append[-2,-1] c +sprites3d[0] [1],1 display_rgba[-2]
star3d:
_nb_branches>0,0<=_thickness<=1
Input 3D star at position (0,0,0), with specified geometry.
Default values: ’nb_branches=5’ and ’thickness=0.38’.
Example: [#1] star3d , +primitives3d 1 color3d[-2] ${-rgb}
streamline3d
(+):
x[%],y[%],z[%],_L>=0,_dl>0,_interpolation,_is_backward={
0 | 1 },_is_oriented={ 0 | 1 } |
’formula’,x,y,z,_L>=0,_dl>0,_interpolation,_is_backward={
0 | 1 },_is_oriented={ 0 | 1 }
Extract 3D
streamlines from selected vector fields or from specified
formula.
’interpolation’ can be { 0=nearest
integer | 1=1st-order | 2=2nd-order | 3=4th-order }.
Default values: ’dl=0.1’, ’interpolation=2’, ’is_backward=0’ and ’is_oriented=0’.
Example: [#1] 100,100,100,3 rand -10,10 blur 3 repeat 300 +streamline3d[0] {u(100)},{u(100)},{u(100)}, 1000,1,1 color3d[-1] ${-rgb} done remove[0] box3d 100 primitives3d[-1] 1 add3d
-3d (+):
Shortcut for command ’sub3d’.
sub3d
(+):
tx,_ty,_tz
Shift selected
3D objects with the opposite of specified displacement
vector.
(equivalent to shortcut command
’3d’).
Default values: ’ty=tz=0’.
Example: [#1] sphere3d 10 repeat 5 +sub3d[-1] 10,{u(-10,10)},0 color3d[-1] ${-rgb} done add3d
superformula3d:
resolution>1,m>=1,n1,n2,n3
Input 2D superformula curve as a 3D object.
Default values: ’resolution=1024’, ’m=8’, ’n1=1’, ’n2=5’ and ’n3=8’.
Example: [#1] superformula3d ,
tensors3d:
_radius_factor>=0,_shape={ 0=box | >=N=ellipsoid
},_radius_min>=0
Generate 3D
tensor fields from selected images.
when ’shape’>0, it gives the ellipsoid
shape precision.
Default values: ’radius_factor=1’, ’shape=2’ and ’radius_min=0.05’.
Example: [#1] 6,6,6,9,"U = [x,y,z] - [w,h,d]/2; U/=norm(U); mul(U,U,3) + 0.3*eye(3)" tensors3d 0.8
text_pointcloud3d:
_"text1",_"text2",_smoothness
Input 3D text pointcloud from the two specified strings.
Default values: ’text1="text1"’, ’text2="text2"’ and ’smoothness=1’.
Example: [#1] text_pointcloud3d "G’MIC","Rocks!"
text3d:
text,_font_height>0,_depth>0,_smoothness
Input a 3D text object from specified text.
Default values: ’font_height=53’, ’depth=10’ and ’smoothness=1.5’.
Example: [#1] text3d "G’MIC as a 3D logo!"
t3d:
Shortcut for command ’texturize3d’.
texturize3d:
[ind_texture],_[ind_coords]
Texturize
selected 3D objects with specified texture and coordinates.
(equivalent to shortcut command
’t3d’).
When ’[ind_coords]’ is omitted, default XY texture projection is performed.
Default value: ’ind_coords=(undefined)’.
Example: [#1] image.jpg torus3d 100,30 texturize3d[-1] [-2] keep[-1]
torus3d:
_radius1,_radius2,_nb_subdivisions1>2,_nb_subdivisions2>2
Input 3D torus at (0,0,0), with specified geometry.
Default values: ’radius1=1’, ’radius2=0.3’, ’nb_subdivisions1=24’ and ’nb_subdivisions2=12’.
Example: [#1] torus3d 10,3 +primitives3d 1 color3d[-2] ${-rgb}
triangle3d:
x0,y0,z0,x1,y1,z1,x2,y2,z2
Input 3D triangle at specified coordinates.
Example: [#1] repeat 100 a={$>*pi/50} triangle3d 0,0,0,0,0,3,{cos(3*$a)},{sin(2*$a)},0 color3d[-1] ${-rgb} done add3d
volume3d:
Transform selected 3D volumetric images as 3D parallelepipedic objects.
Example: [#1] image.jpg animate blur,0,5,30 append z volume3d
weird3d:
_resolution>0
Input 3D weird object at (0,0,0), with specified resolution.
Default value: ’resolution=32’.
Example: [#1] weird3d 48 +primitives3d 1 color3d[-2] ${-rgb}
12.13.
Control Flow
------------
ap:
Shortcut for command
’apply_parallel’.
apply_parallel:
"command"
Apply specified
command on each of the selected images, by parallelizing 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 parallelizing 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 parallelizing it
on ’nb_threads’
overlapped sub-images.
(equivalent to shortcut command
’apo’).
’nb_threads’ must be a power of 2.
Default values: ’overlap=0’,’nb_threads=0’.
Example: [#1] image.jpg +apply_parallel_overlap "smooth 500,0,1",1
at:
Shortcut for command ’apply_tiles’.
apply_tiles:
"command",_tile_width[%]>0,_tile_height[%]>0,_tile_depth[%]>0,_overlap_width[%]>=0,
_overlap_height[%]>=0,_overlap_depth[%]>=0,_boundary_conditions={
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }
Apply specified
command on each tile (neighborhood) of the selected images,
eventually with
overlapping tiles.
(equivalent to shortcut command
’at’).
Default
values:
’tile_width=tile_height=tile_depth=10%’,
’overlap_width=overlap_height=overlap_depth=0’
and ’boundary_conditions=1’.
Example: [#1] image.jpg +equalize[0] 256 +apply_tiles[0] "equalize 256",16,16,1,50%,50%
apply_timeout:
"command",_timeout={ 0=no timeout | >0=with
specified timeout (in seconds) }
Apply a command
with a timeout.
Set variable ’$_is_timeout’ to
’1’ if timeout occurred,
’0’ otherwise.
Default value: ’timeout=20’.
check
(+):
condition
Evaluate
specified condition and display an error message if
evaluated to false.
If ’expression’ is not a math expression,
it is regarded as a filename and checked if it exists.
check3d
(+):
_is_full_check={ 0 | 1 }
Check validity
of selected 3D vector objects, and display an error message
if one of the selected images is not a valid 3D vector
object.
Full 3D object check is slower but more precise.
Default value: ’is_full_check=1’.
check_display:
Check if a display is available, and throw an error otherwise.
continue (+):
Go to end of current ’repeat...done’, ’do...while’ or ’local...endlocal’ block.
Example: [#1] image.jpg repeat 10 blur 1 if 1==1 continue fi deform 10 done
break (+):
Break current ’repeat...done’, ’do...while’ or ’local...endlocal’ block.
Example: [#1] image.jpg repeat 10 blur 1 if 1==1 break fi deform 10 done
do (+):
Start a ’do...while’ block.
Example: [#1] image.jpg luminance i={ia+2} do set 255,{u(100)}%,{u(100)}% while ia<$i
done (+):
End a ’repeat/for...done’ block, and go to associated ’repeat/for’ position, if iterations remain.
elif (+):
condition
Start a
’elif...[else]...fi’ block if previous
’if’ was not verified
and test if specified condition holds
’condition’ is a mathematical expression,
whose evaluation is interpreted as { 0=false | other=true
}..
else (+):
Execute following commands if previous ’if’ or ’elif’ conditions failed.
fi (+):
End a
’if...[elif]...[else]...fi’ block.
(equivalent to shortcut command
’fi’).
endl (+):
Shortcut for command ’endlocal’.
endlocal (+):
End a
’local...endlocal’ block.
(equivalent to shortcut command
’endl’).
error
(+):
message
Print specified
error message on the standard error (stderr) and exit
interpreter, except
if error is caught by a ’onfail’ command.
Command selection (if any) stands for displayed call stack
subset instead of image indices.
eval (+):
expression
Evaluate
specified math expression.
* If no command selection is specified, the expression is
evaluated once and its result is set to
status.
* If command selection is specified, the evaluation is
looped over selected images. Status is not
modified.
(in this latter case, ’eval’ is similar
to ’fill’ without assigning the image
values).
x (+):
Shortcut for command ’exec’.
exec (+):
_is_verbose={ 0 | 1 },"command"
Execute external
command using a system call.
The status value is then set to the error code returned by
the system call.
If ’is_verbose=1’, the executed command
is allowed to output on stdout/stderr.
(equivalent to shortcut command ’x’).
Default value: ’is_verbose=1’.
for (+):
condition
Start a ’for...done’ block.
Example: [#1] image.jpg resize2dy 32 400,400,1,3 x=0 for $x<400 image[1] [0],$x,$x x+=40 done
if (+):
condition
Start a
’if...[elif]...[else]...fi’ block and
test if specified condition holds.
’condition’ is a mathematical expression,
whose evaluation is interpreted as { 0=false | other=true
}.
Example: [#1] image.jpg if ia<64 add 50% elif ia<128 add 25% elif ia<192 sub 25% else sub 50% fi cut 0, 255
l (+):
Shortcut for command ’local’.
local (+):
Start a
’local...[onfail]...endlocal’ block, with
selected images.
(equivalent to shortcut command ’l’).
Example:
[#1] image.jpg local[] 300,300,1,3 rand[0] 0,255 blur 4
sharpen 1000 endlocal
[#2] image.jpg +local repeat 3 deform 20 done endlocal
Tutorial: https://gmic.eu/tutorial/_local.shtml
mutex
(+):
index,_action={ 0=unlock | 1=lock }
Lock or unlock
specified mutex for multi-threaded programming.
A locked mutex can be unlocked only by the same thread. All
mutexes are unlocked by default.
’index’ designates the mutex index, in
[0,255].
Default value: ’action=1’.
noarg (+):
Used in a custom
command, ’noarg’ tells the command that
its argument list have not been used
finally, and so they must be evaluated next in the
G’MIC pipeline, just as if the custom
command takes no arguments at all.
Use this command to write a custom command which can decide
if it takes arguments or not.
onfail (+):
Execute
following commands when an error is encountered in the body
of the ’local...endlocal’ block.
The status value is set with the corresponding error
message.
Example: [#1] image.jpg +local blur -3 onfail mirror x endlocal
parallel
(+):
_wait_threads,"command1","command2",...
Execute
specified commands in parallel, each in a different thread.
Parallel threads share the list of images.
’wait_threads’ can be { 0=when current
environment ends | 1=immediately }.
Default value: ’wait_threads=1’.
Example: [#1] image.jpg [0] parallel "blur[0] 3","mirror[1] c"
progress
(+):
0<=value<=100 |
-1
Set the progress
index of the current processing pipeline.
This command is useful only when G’MIC is used
by an embedding application.
q (+):
Shortcut for command ’quit’.
quit (+):
Quit
G’MIC interpreter.
(equivalent to shortcut command ’q’).
repeat
(+):
nb_iterations,_variable_name
Start
’nb_iterations’ iterations of a
’repeat...done’ block.
’nb_iterations’ is a mathematical
expression that will be evaluated.
Example:
[#1] image.jpg split y repeat $!,n shift[$n] $<,0,0,0,2
done append y
[#2] image.jpg mode3d 2 repeat 4 imagecube3d rotate3d
1,1,0,40 snapshot3d 400,1.4 done
Tutorial: https://gmic.eu/tutorial/_repeat.shtml
return (+):
Return from current custom command.
rprogress:
0<=value<=100 | -1 |
"command",0<=value_min<=100,0<=value_max<=100
Set the progress
index of the current processing pipeline (relatively to
previously defined progress bounds), or call the specified
command with
specified progress bounds.
run:
"G’MIC pipeline"
Run specified
G’MIC pipeline.
This is only useful when used from a shell, e.g. to avoid
shell substitutions to happen in argument.
skip (+):
item
Do nothing but skip specified item.
u (+):
Shortcut for command ’status’.
status
(+):
status_string
Set the current
status. Used to define a returning value from a function.
(equivalent to shortcut command ’u’).
Example: [#1] image.jpg command "foo : u0=Dark u1=Bright status ${u{ia>=128}}" text_outline ${-foo},2,2, 23,2,1,255
while
(+):
condition
End a
’do...while’ block and go back to
associated ’do’ if specified condition
holds.
’condition’ is a mathematical expression,
whose evaluation is interpreted as { 0=false | other=true
}.
12.14.
Arrays, Tiles and Frames
------------------------
array:
M>0,_N>0,_expand_type={ 0=min | 1=max | 2=all }
Create MxN array from selected images.
Default values: ’N=M’ and ’expand_type=0’.
Example: [#1] image.jpg array 3,2,2
array_fade:
M>0,_N>0,0<=_fade_start<=100,0<=_fade_end<=100,_expand_type={0=min
| 1=max | 2=all}
Create MxN array from selected images.
Default values: ’N=M’, ’fade_start=60’, ’fade_end=90’ and ’expand_type=1’.
Example: [#1] image.jpg array_fade 3,2
array_mirror:
N>=0,_dir={ 0=x | 1=y | 2=xy | 3=tri-xy },_expand_type={
0 | 1 }
Create 2ˆNx2ˆN array from selected images.
Default values: ’dir=2’ and ’expand_type=0’.
Example: [#1] image.jpg array_mirror 2
array_random:
Ms>0,_Ns>0,_Md>0,_Nd>0
Create MdxNd array of tiles from selected MsxNs source arrays.
Default values: ’Ns=Ms’, ’Md=Ms’ and ’Nd=Ns’.
Example: [#1] image.jpg +array_random 8,8,15,10
frame:
Shortcut for command ’frame_xy’.
frame_blur:
_sharpness>0,_size>=0,_smoothness,_shading,_blur
Draw RGBA-colored round frame in selected images.
Default values: ’sharpness=10’, ’size=30’, ’smoothness=0’, ’shading=1’ and ’blur=3%’.
Example: [#1] image.jpg frame_blur 3,30,8,10%
frame_cube:
_depth>=0,_centering_x,_centering_y,_left_side={0=normal
| 1=mirror-x | 2=mirror-y | 3=mirror-xy},
_right_side,_lower_side,_upper_side
Insert 3D frames in selected images.
Default
values: ’depth=1’,
’centering_x=centering_y=0’ and
’left_side=right_side,
lower_side=upper_side=0’.
Example: [#1] image.jpg frame_cube ,
frame_fuzzy:
size_x[%]>=0,_size_y[%]>=0,_fuzzyness>=0,_smoothness[%]>=0,_R,_G,_B,_A
Draw RGBA-colored fuzzy frame in selected images.
Default values: ’size_y=size_x’, ’fuzzyness=5’, ’smoothness=1’ and ’R=G=B=A=255’.
Example: [#1] image.jpg frame_fuzzy 20
frame_painting:
_size[%]>=0,0<=_contrast<=1,_profile_smoothness[%]>=0,_R,_G,_B,_vignette_size[%]>=0,
_vignette_contrast>=0,_defects_contrast>=0,0<=_defects_density<=100,_defects_size>=0,
_defects_smoothness[%]>=0,_serial_number
Add a painting frame to selected images.
Default
values: ’size=10%’,
’contrast=0.4’,
’profile_smoothness=6%’,
’R=225’, ’G=200’,
’B=120’,
’vignette_size=2%’,
’vignette_contrast=400’,
’defects_contrast=50’,
’defects_density=10’,
’defects_size=1’,
’defects_smoothness=0.5%’ and
’serial_number=123456789’.
Example: [#1] image.jpg frame_painting ,
frame_pattern:
M>=3,_constrain_size={ 0 | 1 } |
M>=3,_[frame_image],_constrain_size={ 0 | 1 }
Insert selected pattern frame in selected images.
Default values: ’pattern=0’ and ’constrain_size=0’.
Example: [#1] image.jpg frame_pattern 8
frame_round:
_sharpness>0,_size>=0,_smoothness,_shading,_R,_G,_B,_A
Draw RGBA-colored round frame in selected images.
Default values: ’sharpness=10’, ’size=10’, ’smoothness=0’, ’shading=0’ and ’R=G=B=A=255’.
Example: [#1] image.jpg frame_round 10
frame_seamless:
frame_size>=0,_patch_size>0,_blend_size>=0,_frame_direction={
0=inner (preserve image size) | 1=outer }
Insert frame in selected images, so that tiling the resulting image makes less visible seams.
Default values: ’patch_size=7’, ’blend_size=5’ and ’frame_direction=1’.
Example: [#1] image.jpg +frame_seamless 30 array 2,2
frame_x:
size_x[%],_col1,...,_colN
Insert colored frame along the x-axis in selected images.
Default values: ’col1=col2=col3=255’ and ’col4=255’.
Example: [#1] image.jpg frame_x 20,255,0,255
frame_xy:
size_x[%],_size_y[%],_col1,...,_colN
Insert colored frame along the x-axis in selected images.
Default
values: ’size_y=size_x’,
’col1=col2=col3=255’ and
’col4=255’.
(equivalent to shortcut command
’frame’).
Example: [#1] image.jpg frame_xy 1,1,0 frame_xy 20,10,255,0,255
frame_xyz:
size_x[%],_size_y[%],_size_z[%]_col1,...,_colN
Insert colored frame along the x-axis in selected images.
Default values: ’size_y=size_x=size_z’, ’col1=col2=col3=255’ and ’col4=255’.
frame_y:
size_y[%],_col1,...,_colN
Insert colored frame along the y-axis in selected images.
Default values: ’col1=col2=col3=255’ and ’col4=255’.
Example: [#1] image.jpg frame_y 20,255,0,255
img2ascii:
_charset,_analysis_scale>0,_analysis_smoothness[%]>=0,_synthesis_scale>0,_output_ascii_filename
Render selected
images as binary ascii art.
This command returns the corresponding the list of widths
and heights (expressed as a number of
characters)
for each selected image.
Default
values: ’charset=[ascii charset]’,
’analysis_scale=16’,
’analysis_smoothness=20%’,
’synthesis_scale=16’ and
’_output_ascii_filename=[undefined]’.
Example: [#1] image.jpg img2ascii ,
imagegrid:
M>0,_N>0
Create MxN image grid from selected images.
Default value: ’N=M’.
Example: [#1] image.jpg imagegrid 16
imagegrid_hexagonal:
_resolution>0,0<=_outline<=1
Create hexagonal grids from selected images.
Default values: ’resolution=32’, ’outline=0.1’ and ’is_antialiased=1’.
Example: [#1] image.jpg imagegrid_hexagonal 24
imagegrid_triangular:
pattern_width>=1,_pattern_height>=1,_pattern_type,0<=_outline_opacity<=1,_outline_color1,...
Create
triangular grids from selected images.
’pattern type’ can be { 0=horizontal |
1=vertical | 2=crossed | 3=cube | 4=decreasing |
5=increasing }.
Default
values: ’pattern_width=24’,
’pattern_height=pattern_width’,
’pattern_type=0’,
’outline_opacity=0.1’ and
’outline_color1=0’.
Example: [#1] image.jpg imagegrid_triangular 6,10,3,0.5
linearize_tiles:
M>0,_N>0
Linearize MxN tiles on selected images.
Default value: ’N=M’.
Example: [#1] image.jpg +linearize_tiles 16
map_sprites:
_nb_sprites>=1,_allow_rotation={ 0=none | 1=90 deg. |
2=180 deg. }
Map set of
sprites (defined as the ’nb_sprites’
latest images of the selection) to other selected
images,
according to the luminosity of their pixel values.
Example: [#1] image.jpg resize2dy 48 repeat 16 ball {8+2*$>},${-rgb} mul[-1] {(1+$>)/16} done map_sprites 16
pack:
is_ratio_constraint={ 0 | 1 },_sort_criterion
Pack selected
images into a single image.
The returned status contains the list of new (x,y) offsets
for each input image.
Parameter ’is_ratio_constraint’ tells if
the resulting image must tend to a square image.
Default values: ’is_ratio_constraint=0’ and ’sort_criterion=max(w,h)’.
Example: [#1] image.jpg repeat 10 +resize2dx[-1] 75% balance_gamma[-1] ${-rgb} done pack 0
puzzle:
_width>0,_height>0,_M>=1,_N>=1,_curvature,_centering,_connectors_variability,_resolution>=1
Input puzzle binary mask with specified size and geometry.
Default
values: ’width=height=512’,
’M=N=5’,
’curvature=0.5’,
’centering=0.5’,
’connectors_variability=0.5’ and
’resolution=64’.
Example: [#1] puzzle ,
quadratize_tiles:
M>0,_N>0
Quadratize MxN tiles on selected images.
Default value: ’N=M’.
Example: [#1] image.jpg +quadratize_tiles 16
rotate_tiles:
angle,_M>0,N>0
Apply MxN tiled-rotation effect on selected images.
Default values: ’M=8’ and ’N=M’.
Example: [#1] image.jpg to_rgba rotate_tiles 10,8 drop_shadow 10,10 display_rgba
shift_tiles:
M>0,_N>0,_amplitude
Apply MxN tiled-shift effect on selected images.
Default values: ’N=M’ and ’amplitude=20’.
Example: [#1] image.jpg +shift_tiles 8,8,10
taquin:
M>0,_N>0,_remove_tile={ 0=none | 1=first | 2=last |
3=random },_relief,_border_thickness[%],
_border_outline[%],_outline_color
Create MxN taquin puzzle from selected images.
Default
value: ’N=M’,
’relief=50’,
’border_thickness=5’,
’border_outline=0’ and
’remove_tile=0’.
Example: [#1] image.jpg +taquin 8
tunnel:
_level>=0,_factor>0,_centering_x,_centering_y,_opacity,_angle
Apply tunnel effect on selected images.
Default
values: ’level=9’,
’factor=80%’,
’centering_x=centering_y=0.5’,
’opacity=1’ and
’angle=0’
Example: [#1] image.jpg tunnel 20
12.15.
Artistic
--------
boxfitting:
_min_box_size>=1,_max_box_size>=0,_initial_density>=0,_nb_attempts>=1
Apply box
fitting effect on selected images, as displayed the web
page:
[http://www.complexification.net/gallery/machines/boxFittingImg/]
Default values: ’min_box_size=1’, ’max_box_size=0’, ’initial_density=0.1’ and ’nb_attempts=3’.
Example: [#1] image.jpg boxfitting ,
brushify:
[brush],_brush_nb_sizes>=1,0<=_brush_min_size_factor<=1,_brush_nb_orientations>=1,_brush_light_type,
0<=_brush_light_strength<=1,_brush_opacity,_painting_density[%]>=0,
0<=_painting_contours_coherence<=1,0<=_painting_orientation_coherence<=1,
_painting_coherence_alpha[%]>=0,_painting_coherence_sigma[%]>=0,_painting_primary_angle,
0<=_painting_angle_dispersion<=1
Apply specified
brush to create painterly versions of specified images.
’brush_light_type’ can be { 0=none |
1=flat | 2=darken | 3=lighten | 4=full }.
Default
values: ’brush_nb_sizes=3’,
’brush_min_size_factor=0.66’,
’brush_nb_orientations=12’,
’brush_light_type=0’,
’brush_light_strength=0.25’,
’brush_opacity=0.8’,
’painting_density=20%’,
’painting_contours_coherence=0.9’,
’painting_orientation_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,_thickness>=0,_color>=0,quantization>0
Apply cartoon effect on selected images.
Default
values: ’smoothness=3’,
’sharpening=150’,
’threshold=20’,
’thickness=0.25’,
’color=1.5’ and
’quantization=8’.
Example: [#1] image.jpg cartoon 3,50,10,0.25,3,16
color_ellipses:
_count>0,_radius>=0,_opacity>=0
Add random color ellipses to selected images.
Default values: ’count=400’, ’radius=5’ and ’opacity=0.1’.
Example: [#1] image.jpg +color_ellipses ,,0.15
cubism:
_density>=0,0<=_thickness<=50,_max_angle,_opacity,_smoothness>=0
Apply cubism effect on selected images.
Default
values: ’density=50’,
’thickness=10’,
’max_angle=75’,
’opacity=0.7’ and
’smoothness=0’.
Example: [#1] image.jpg cubism ,
draw_whirl:
_amplitude>=0
Apply whirl drawing effect on selected images.
Default value: ’amplitude=100’.
Example: [#1] image.jpg draw_whirl ,
drawing:
_amplitude>=0
Apply drawing effect on selected images.
Default value: ’amplitude=200’.
Example: [#1] image.jpg +drawing ,
drop_shadow:
_offset_x[%],_offset_y[%],_smoothness[%]>=0,0<=_curvature<=1,_expand_size={
0 | 1 }
Drop shadow behind selected images.
Default
values: ’offset_x=20’,
’offset_y=offset_x’,
’smoothness=5’,
’curvature=0’ and
’expand_size=1’.
Example: [#1] image.jpg drop_shadow 10,20,5,0.5 expand_xy 20,0 display_rgba
ellipsionism:
_R>0[%],_r>0[%],_smoothness>=0[%],_opacity,_outline>0,_density>0
Apply ellipsionism filter to selected images.
Default values: ’R=10’, ’r=3’, ’smoothness=1%’, ’opacity=0.7’, ’outline=8’ and ’density=0.6’.
Example: [#1] image.jpg ellipsionism ,
fire_edges:
_edges>=0,0<=_attenuation<=1,_smoothness>=0,_threshold>=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_threshold<=100,_is_fast={
0 | 1 }
Apply hard B&W sketch effect on selected images.
Default
values: ’amplitude=1000’,
’sampling=3’,
’opacity=0.1’,
’edge_threshold=20’ and
’is_fast=0’.
Example: [#1] image.jpg +hardsketchbw 200,70,0.1,10 median[-1] 2 +local reverse blur[-1] 3 blend[-2,-1] overlay endlocal
hearts:
_density>=0
Apply heart effect on selected images.
Default value: ’density=10’.
Example: [#1] image.jpg hearts ,
houghsketchbw:
_density>=0,_radius>0,0<=_threshold<=100,0<=_opacity<=1,_votesize[%]>0
Apply hough B&W sketch effect on selected images.
Default values: ’density=100’, ’radius=3’, ’threshold=100’, ’opacity=0.1’ and ’votesize=100%’.
Example: [#1] image.jpg +houghsketchbw ,
lightrays:
100<=_density<=0,_center_x[%],_center_y[%],_ray_length>=0,_ray_attenuation>=0
Generate ray lights from the edges of selected images.
Default
values: ’density=50%’,
’center_x=50%’,
’center_y=50%’,
’ray_length=0.9’ and
’ray_attenuation=0.5’.
Example: [#1] image.jpg +lightrays , + cut 0,255
light_relief:
_ambient_light,_specular_lightness,_specular_size,_darkness,_light_smoothness,_xl,_yl,_zl,_zscale,
_opacity_is_heightmap={ 0 | 1 }
Apply relief
light to selected images.
Default values(s) : ’ambient_light=0.3’,
’specular_lightness=0.5’,
’specular_size=0.2’,
’darkness=0’,
’xl=0.2’, ’yl=zl=0.5’,
’zscale=1’,
’opacity=1’ and
’opacity_is_heightmap=0’.
Example: [#1] image.jpg blur 2 light_relief 0.3,4,0.1,0
linify:
0<=_density<=100,_spreading>=0,_resolution[%]>0,_line_opacity>=0,_line_precision>0,_mode={
0=subtractive | 1=additive }
Apply linify
effect on selected images.
The algorithm is inspired from the one described on the
webpage ’http://linify.me/about’.
Default
values: ’density=50’,
’spreading=2’,
’resolution=40%’,
’line_opacity=10’,
’line_precision=24’ and
’mode=0’.
Example: [#1] image.jpg linify 60
mosaic:
0<=_density<=100
Create random mosaic from selected images.
Default values: ’density=30’.
Example: [#1] image.jpg mosaic , +fill "I!=J(1) || I!=J(0,1)?[0,0,0]:I"
old_photo:
Apply old photo effect on selected images.
Example: [#1] image.jpg old_photo
pencilbw:
_size>=0,_amplitude>=0
Apply B&W pencil effect on selected images.
Default values: ’size=0.3’ and ’amplitude=60’.
Example: [#1] image.jpg pencilbw ,
pixelsort:
_ordering={ + | - },_axis={ x | y | z | xy | yx
},_[sorting_criterion],_[mask]
Apply a
’pixel sorting’ algorithm on selected
images, as described in the page :
http://satyarth.me/articles/pixel-sorting/
Default values: ’ordering=+’, ’axis=x’ and ’sorting_criterion=mask=(undefined)’.
Example: [#1] image.jpg +norm +ge[-1] 30% +pixelsort[0] +,y,[1],[2]
polaroid:
_size1>=0,_size2>=0
Create polaroid effect in selected images.
Default values: ’size1=10’ and ’size2=20’.
Example: [#1] image.jpg to_rgba polaroid 5,30 rotate 20 drop_shadow , drgba
polygonize:
_warp_amplitude>=0,_smoothness[%]>=0,_min_area[%]>=0,_resolution_x[%]>0,_resolution_y[%]>0
Apply polygon effect on selected images.
Default
values: ’warp_amplitude=300’,
’smoothness=2%’,
’min_area=0.1%’,
’resolution_x=resolution_y=10%’.
Example: [#1] image.jpg image.jpg polygonize 100,10 +fill "I!=J(1) || I!=J(0,1)?[0,0,0]:I"
poster_edges:
0<=_edge_threshold<=100,0<=_edge_shade<=100,_edge_thickness>=0,_edge_antialiasing>=0,
0<=_posterization_level<=15,_posterization_antialiasing>=0
Apply poster edges effect on selected images.
Default
values: ’edge_threshold=40’,
’edge_shade=5’,
’edge_thickness=0.5’,
’edge_antialiasing=10’,
’posterization_level=12’ and
’posterization_antialiasing=0’.
Example: [#1] image.jpg poster_edges ,
poster_hope:
_smoothness>=0
Apply Hope stencil poster effect on selected images.
Default value: ’smoothness=3’.
Example: [#1] image.jpg poster_hope ,
rodilius:
0<=_amplitude<=100,_0<=thickness<=100,_sharpness>=0,_nb_orientations>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,_threshold>=0,_opacity,_bgfactor>=0,_density>0,
_sharpness>=0,_anisotropy>=0,_smoothness>=0,_coherence>=0,_is_boost={
0 | 1 },_is_curved={ 0 | 1 }
Apply sketch effect to selected images.
Default
values: ’nb_angles=2’,
’start_angle=45’,
’angle_range=180’,
’length=30’,
’threshold=3’,
’opacity=0.03’,
’bgfactor=0’,
’density=0.6’,
’sharpness=0.1’,
’anisotropy=0.6’,
’smoothness=0.25’,
’coherence=1’,
’is_boost=0’ and
’is_curved=1’.
Example: [#1] image.jpg +sketchbw 1 reverse blur[-1] 3 blend[-2,-1] overlay
sponge:
_size>0
Apply sponge effect on selected images.
Default value: ’size=13’.
Example: [#1] image.jpg sponge ,
stained_glass:
_edges[%]>=0, shading>=0, is_thin_separators={ 0 | 1
}
Generate stained glass from selected images.
Default values: ’edges=40%’, ’shading=0.2’ and ’is_precise=0’.
Example: [#1] image.jpg stained_glass 20%,1 cut 0,20
stars:
_density[%]>=0,_depth>=0,_size>0,_nb_branches>=1,0<=_thickness<=1,_smoothness[%]>=0,_R,_G,_B,
_opacity
Add random stars to selected images.
Default
values: ’density=10%’,
’depth=1’, ’size=32’,
’nb_branches=5’,
’thickness=0.38’,
’smoothness=0.5’,
’R=G=B=200’ and
’opacity=1’.
Example: [#1] image.jpg stars ,
stencil:
_radius[%]>=0,_smoothness>=0,_iterations>=0
Apply stencil filter on selected images.
Default values: ’radius=3’, ’smoothness=1’ and ’iterations=8’.
Example: [#1] image.jpg +norm stencil. 2,1,4 +mul rm[0]
stencilbw:
_edges>=0,_smoothness>=0
Apply B&W stencil effect on selected images.
Default values: ’edges=15’ and ’smoothness=10’.
Example: [#1] image.jpg +stencilbw 40,4
stylize:
[style_image],_fidelity_finest,_fidelity_coarsest,_fidelity_smoothness_finest>=0,
_fidelity_smoothnes_coarsest>=0,0<=_fidelity_chroma<=1,_init_type,_init_resolution>=0,
init_max_gradient>=0,_patchsize_analysis>0,_patchsize_synthesis>0,_patchsize_synthesis_final>0,
_nb_matches_finest>=0,_nb_matches_coarsest>=0,_penalize_repetitions>=0,_matching_precision>=0,
_scale_factor>1,_skip_finest_scales>=0,_"image_matching_command"
Transfer colors
and textures from specified style image to selected images,
using a multi-scale
patch-mathing algorithm.
If instant display window[0] is opened, the steps of the
image synthesis are displayed on it.
’init_type’ can be { 0=best-match |
1=identity | 2=randomized }.
Default
values: ’fidelity_finest=0.5’,
’fidelity_coarsest=2’,
’fidelity_smoothness_finest=3’,
’fidelity_smoothness_coarsest=0.5’,
’fidelity_chroma=0.1’,
’init_type=0’,
’init_resolution=16’,
’init_max_gradient=0’,
’patchsize_analysis=5’,
’patchsize_synthesis=5’,
’patchsize_synthesis_final=5’,
’nb_matches_finest=2’,
’nb_matchesc_coarsest=30’,
’penalize_repetitions=10’,
’matching_precision=2’,
’scale_factor=1.85’,
’skip_finest_scales=0’ and
’image_matching_command’="s c,-3
transfer_pca[0] [2] b[0,2] xy,0.7 n[0,2] 0,255 n[1,2] 0,200
a[0,1]
c a[1,2] c"’.
tetris:
_scale>0
Apply tetris effect on selected images.
Default value: ’scale=10’.
Example: [#1] image.jpg +tetris 10
warhol:
_M>0,_N>0,_smoothness>=0,_color>=0
Create MxN Andy Warhol-like artwork from selected images.
Default values: ’M=3’, ’N=M’, ’smoothness=2’ and ’color=20’.
Example: [#1] image.jpg warhol 3,3,3,40
weave:
_density>=0,0<=_thickness<=100,0<=_shadow<=100,_shading>=0,_fibers_amplitude>=0,
_fibers_smoothness>=0,_angle,-1<=_x_curvature<=1,-1<=_y_curvature<=1
Apply weave
effect to the selected images.
’angle’ can be { 0=0 deg. | 1=22.5
deg. | 2=45 deg. | 3=67.5 deg. }.
Default
values: ’density=6’,
’thickness=65’,
’shadow=40’,
’shading=0.5’,
’fibers_amplitude=0’,
_’fibers_smoothness=0’,
’angle=0’ and
’curvature_x=curvature_y=0’
Example: [#1] image.jpg weave ,
whirls:
_texture>=0,_smoothness>=0,_darkness>=0,_lightness>=0
Add random whirl texture to selected images.
Default values: ’texture=3’, ’smoothness=6’, ’darkness=0.5’ and ’lightness=1.8’.
Example: [#1] image.jpg whirls ,
12.16.
Warpings
--------
deform:
_amplitude>=0,_interpolation
Apply random
smooth deformation on selected images.
’interpolation’ can be { 0=none |
1=linear | 2=bicubic }.
Default value: ’amplitude=10’.
Example: [#1] image.jpg +deform[0] 10 +deform[0] 20
euclidean2polar:
_center_x[%],_center_y[%],_stretch_factor>0,_boundary_conditions={
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }
Apply euclidean to polar transform on selected images.
Default values: ’center_x=center_y=50%’, ’stretch_factor=1’ and ’boundary_conditions=1’.
Example: [#1] image.jpg +euclidean2polar ,
equirectangular2nadirzenith:
Transform selected equirectangular images to nadir/zenith rectilinear projections.
fisheye:
_center_x,_center_y,0<=_radius<=100,_amplitude>=0
Apply fish-eye deformation on selected images.
Default values: ’x=y=50’, ’radius=50’ and ’amplitude=1.2’.
Example: [#1] image.jpg +fisheye ,
flower:
_amplitude,_frequency,_offset_r[%],_angle,_center_x[%],_center_y[%],_boundary_conditions={
0=dirichlet | 1=neumann | 2=periodic | 3=mirror}
Apply flower deformation on selected images.
Default
values: ’amplitude=30’,
’frequency=6’,
’offset_r=0’,
’angle=0’,
’center_x=center_y=50%’ and
’boundary_conditions=3’.
Example: [#1] image.jpg +flower ,
kaleidoscope:
_center_x[%],_center_y[%],_radius,_angle,_boundary_conditions={
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }
Create kaleidoscope effect from selected images.
Default values: ’center_x=center_y=50%’, ’radius=100’, ’angle=30’ and ’boundary_conditions=3’.
Example: [#1] image.jpg kaleidoscope ,
map_sphere:
_width>0,_height>0,_radius,_dilation>0,_fading>=0,_fading_power>=0
Map selected images on a sphere.
Default
values: ’width=height=512’,
’radius=100’,
’dilation=0.5’,
’fading=0’ and
’fading_power=0.5’.
Example: [#1] image.jpg map_sphere ,
nadirzenith2equirectangular:
Transform selected nadir/zenith rectilinear projections to equirectangular images.
polar2euclidean:
_center_x[%],_center_y[%],_stretch_factor>0,_boundary_conditions={
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }
Apply euclidean to polar transform on selected images.
Default values: ’center_x=center_y=50%’, ’stretch_factor=1’ and ’boundary_conditions=1’.
Example: [#1] image.jpg +euclidean2polar ,
raindrops:
_amplitude,_density>=0,_wavelength>=0,_merging_steps>=0
Apply raindrops deformation on selected images.
Default values: ’amplitude=80’,’density=0.1’, ’wavelength=1’ and ’merging_steps=0’.
Example: [#1] image.jpg +raindrops ,
ripple:
_amplitude,_bandwidth,_shape={ 0=bloc | 1=triangle | 2=sine
| 3=sine+ | 4=random },_angle,_offset
Apply ripple deformation on selected images.
Default values: ’amplitude=10’, ’bandwidth=10’, ’shape=2’, ’angle=0’ and ’offset=0’.
Example: [#1] image.jpg +ripple ,
rotoidoscope:
_center_x[%],_center_y[%],_tiles>0,_smoothness[%]>=0,_boundary_conditions={
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }
Create rotational kaleidoscope effect from selected images.
Default
values: ’center_x=center_y=50%’,
’tiles=10’,
’smoothness=1’ and
’boundary_conditions=3’.
Example: [#1] image.jpg +rotoidoscope ,
spherize:
_radius[%]>=0,_strength,_smoothness[%]>=0,_center_x[%],_center_y[%],_ratio_x/y>0,_angle,
_interpolation
Apply spherize effect on selected images.
Default
values: ’radius=50%’,
’strength=1’,
’smoothness=0’,
’center_x=center_y=50%’,
’ratio_x/y=1’,
’angle=0’ and
’interpolation=1’.
Example: [#1] image.jpg grid 5%,5%,0,0,0.6,255 spherize ,
symmetrize:
_x[%],_y[%],_angle,_boundary_conditions={ 0=dirichlet |
1=neumann | 2=periodic | 3=mirror }, _is_antisymmetry={ 0 |
1 },_swap_sides={ 0 | 1 }
Symmetrize selected images regarding specified axis.
Default
values: ’x=y=50%’,
’angle=90’,
’boundary_conditions=3’,
’is_antisymmetry=0’ and
’swap_sides=0’.
Example: [#1] image.jpg +symmetrize 50%,50%,45 +symmetrize[-1] 50%,50%,-45
transform_polar:
"expr_radius",_"expr_angle",_center_x[%],_center_y[%],_boundary_conditions={
0=dirichlet | 1=neumann }
Apply user-defined transform on polar representation of selected images.
Default
values: ’expr_radius=R-r’,
’expr_rangle=a’,
’center_x=center_y=50%’ and
’boundary_conditions=1’.
Example: [#1] image.jpg +transform_polar[0] R*(r/R)ˆ2,a +transform_polar[0] r,2*a
twirl:
_amplitude,_center_x[%],_center_y[%],_boundary_conditions={
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }
Apply twirl deformation on selected images.
Default values: ’amplitude=1’, ’center_x=center_y=50%’ and ’boundary_conditions=3’.
Example: [#1] image.jpg twirl 0.6
warp_perspective:
_x-angle,_y-angle,_zoom>0,_x-center,_y-center,_boundary_conditions={
0=dirichlet | 1=neumann | 2=periodic | 3=mirror }
Warp selected images with perspective deformation.
Default
values: ’x-angle=1.5’,
’y-angle=0’, ’zoom=1’,
’x-center=y-center=50’ and
’boundary_conditions=2’.
Example: [#1] image.jpg warp_perspective ,
water:
_amplitude,_smoothness>=0,_angle
Apply water deformation on selected images.
Default values: ’amplitude=30’, ’smoothness=1.5’ and ’angle=45’.
Example: [#1] image.jpg water ,
wave:
_amplitude>=0,_frequency>=0,_center_x,_center_y
Apply wave deformation on selected images.
Default values: ’amplitude=4’, ’frequency=0.4’ and ’center_x=center_y=50’.
Example: [#1] image.jpg wave ,
wind:
_amplitude>=0,_angle,0<=_attenuation<=1,_threshold
Apply wind effect on selected images.
Default values: ’amplitude=20’, ’angle=0’, ’attenuation=0.7’ and ’threshold=20’.
Example: [#1] image.jpg +wind ,
zoom:
_factor,_cx,_cy,_cz,_boundary_conditions={ 0=dirichlet |
1=neumann | 2=periodic | 3=mirror }
Apply zoom factor to selected images.
Default values: ’factor=1’, ’cx=cy=cz=0.5’ and ’boundary_conditions=0’.
Example: [#1] image.jpg +zoom[0] 0.6 +zoom[0] 1.5
12.17.
Degradations
------------
cracks:
0<=_density<=100,_is_relief={ 0 | 1
},_opacity,_color1,...
Draw random cracks on selected images with specified color.
Default values: ’density=25’, ’is_relief=0’, ’opacity=1’ and ’color1=0’.
Example: [#1] image.jpg +cracks ,
light_patch:
_density>0,_darkness>=0,_lightness>=0
Add light patches to selected images.
Default values: ’density=10’, ’darkness=0.9’ and ’lightness=1.7’.
Example: [#1] image.jpg +light_patch 20,0.9,4
noise_hurl:
_amplitude>=0
Add hurl noise to selected images.
Default value: ’amplitude=10’.
Example: [#1] image.jpg +noise_hurl ,
pixelize:
_scale_x>0,_scale_y>0,_scale_z>0
Pixelize selected images with specified scales.
Default values: ’scale_x=20’ and ’scale_y=scale_z=scale_x’.
Example: [#1] image.jpg +pixelize ,
scanlines:
_amplitude,_bandwidth,_shape={ 0=bloc | 1=triangle | 2=sine
| 3=sine+ | 4=random },_angle,_offset
Apply ripple deformation on selected images.
Default values: ’amplitude=60’, ’bandwidth=2’, ’shape=0’, ’angle=0’ and ’offset=0’.
Example: [#1] image.jpg +scanlines ,
shade_stripes:
_frequency>=0,_direction={ 0=horizontal | 1=vertical
},_darkness>=0,_lightness>=0
Add shade stripes to selected images.
Default values: ’frequency=5’, ’direction=1’, ’darkness=0.8’ and ’lightness=2’.
Example: [#1] image.jpg +shade_stripes 30
shadow_patch:
_opacity>=0
Add shadow patches to selected images.
Default value: ’opacity=0.7’.
Example: [#1] image.jpg +shadow_patch 0.4
spread:
_dx>=0,_dy>=0,_dz>=0
Spread pixel values of selected images randomly along x,y and z.
Default values: ’dx=3’, ’dy=dx’ and ’dz=0’.
Example: [#1] image.jpg +spread 3
stripes_y:
_frequency>=0
Add vertical stripes to selected images.
Default value: ’frequency=10’.
Example: [#1] image.jpg +stripes_y ,
texturize_canvas:
_amplitude>=0,_fibrousness>=0,_emboss_level>=0
Add paint canvas texture to selected images.
Default values: ’amplitude=20’, ’fibrousness=3’ and ’emboss_level=0.6’.
Example: [#1] image.jpg +texturize_canvas ,
texturize_paper:
Add paper texture to selected images.
Example: [#1] image.jpg +texturize_paper
vignette:
_strength>=0,0<=_radius_min<=100,0<=_radius_max<=100
Add vignette effect to selected images.
Default values: ’strength=100’, ’radius_min=70’ and ’radius_max=90’.
Example: [#1] image.jpg vignette ,
watermark_visible:
_text,0<_opacity<1,_size>0,_angle,_mode={ 0=remove
| 1=add },_smoothness>=0
Add or remove a visible watermark on selected images (value range must be [0,255]).
Default
values: ’text=(c) G’MIC’,
’opacity=0.3’,
’size=53’, ’angle=25’,
’mode=1’ and
’smoothness=0’.
Example: [#1] image.jpg watermark_visible ,0.7
12.18.
Blending and Fading
-------------------
blend:
[layer],blending_mode,_opacity[%],_selection_is={
0=base-layers | 1=top-layers } |
blending_mode,_opacity[%]
Blend selected
G,GA,RGB or RGBA images by specified layer or blend all
selected images together,
using specified blending mode.
’blending_mode’ can be { add | alpha |
and | average | blue | burn | darken | difference |
divide | dodge | edges | exclusion | freeze | grainextract |
grainmerge | green | hardlight |
hardmix | hue | interpolation | lighten | lightness |
linearburn | linearlight | luminance |
multiply | negation | or | overlay | pinlight | red |
reflect | saturation | seamless |
seamless_mixed |
screen | shapeareamax | shapeareamax0 | shapeareamin |
shapeareamin0 | shapeaverage | shapeaverage0
|
shapemedian | shapemedian0 | shapemin | shapemin0 | shapemax
| shapemax0 | softburn | softdodge |
softlight | stamp | subtract | value | vividlight | xor }.
’opacity’ should be in
’[0,1]’, or ’[0,100]’
if expressed with a ’%’.
Default values: ’blending_mode=alpha’, ’opacity=1’ and ’selection_is=0’.
Example:
[#1] image.jpg +drop_shadow , resize2dy[-1] 200 rotate[-1]
20 +blend alpha display_rgba[-2]
[#2] image.jpg testimage2d {w},{h} blend overlay
[#3] command "ex : $""=arg repeat
$""# +blend[0,1] ${arg{$>+1}} text_outline[-1]
Mode:" "${arg{$>+1}},2,2,23,2,1,255 done"
image.jpg testimage2d {w},{h} ex add,alpha,and,
average,blue,burn,darken
[#4] command "ex : $""=arg repeat
$""# +blend[0,1] ${arg{$>+1}} text_outline[-1]
Mode:" "${arg{$>+1}},2,2,23,2,1,255 done"
image.jpg testimage2d {w},{h} ex difference,divide,
dodge,exclusion,freeze,grainextract,grainmerge
[#5] command "ex : $""=arg repeat
$""# +blend[0,1] ${arg{$>+1}} text_outline[-1]
Mode:" "${arg{$>+1}},2,2,23,2,1,255 done"
image.jpg testimage2d {w},{h} ex green,hardlight,
hardmix,hue,interpolation,lighten,lightness
[#6] command "ex : $""=arg repeat
$""# +blend[0,1] ${arg{$>+1}} text_outline[-1]
Mode:" "${arg{$>+1}},2,2,23,2,1,255 done"
image.jpg testimage2d {w},{h} ex linearburn,
linearlight,luminance,multiply,negation,or,overlay
[#7] command "ex : $""=arg repeat
$""# +blend[0,1] ${arg{$>+1}} text_outline[-1]
Mode:" "${arg{$>+1}},2,2,23,2,1,255 done"
image.jpg testimage2d {w},{h} ex pinlight,red,reflect,
saturation,screen,shapeaverage,softburn
[#8] command "ex : $""=arg repeat
$""# +blend[0,1] ${arg{$>+1}} text_outline[-1]
Mode:" "${arg{$>+1}},2,2,23,2,1,255 done"
image.jpg testimage2d {w},{h} ex softdodge,softlight,
stamp,subtract,value,vividlight,xor
blend_edges:
smoothness[%]>=0
Blend selected images togethers using ’edges’ mode.
Example: [#1] image.jpg testimage2d {w},{h} +blend_edges 0.8
blend_fade:
[fading_shape]
Blend selected images together using specified fading shape.
Example: [#1] image.jpg testimage2d {w},{h} 100%,100%,1,1,’cos(y/10)’ normalize[-1] 0,1 +blend_fade[0, 1] [2]
blend_median:
Blend selected images together using ’median’ mode.
Example: [#1] image.jpg testimage2d {w},{h} +mirror[0] y +blend_median
blend_seamless:
_is_mixed_mode={ 0 | 1
},_inner_fading[%]>=0,_outer_fading[%]>=0
Blend selected images using a seamless blending mode (Poisson-based).
Default values: ’is_mixed=0’, ’inner_fading=0’ and ’outer_fading=100%’.
fade_diamond:
0<=_start<=100,0<=_end<=100
Create diamond fading from selected images.
Default values: ’start=80’ and ’end=90’.
Example: [#1] image.jpg testimage2d {w},{h} +fade_diamond 80,85
fade_linear:
_angle,0<=_start<=100,0<=_end<=100
Create linear fading from selected images.
Default values: ’angle=45’, ’start=30’ and ’end=70’.
Example: [#1] image.jpg testimage2d {w},{h} +fade_linear 45,48,52
fade_radial:
0<=_start<=100,0<=_end<=100
Create radial fading from selected images.
Default values: ’start=30’ and ’end=70’.
Example: [#1] image.jpg testimage2d {w},{h} +fade_radial 30,70
fade_x:
0<=_start<=100,0<=_end<=100
Create horizontal fading from selected images.
Default values: ’start=30’ and ’end=70’.
Example: [#1] image.jpg testimage2d {w},{h} +fade_x 30,70
fade_y:
0<=_start<=100,0<=_end<=100
Create vertical fading from selected images.
Default values: ’start=30’ and ’end=70’.
Example: [#1] image.jpg testimage2d {w},{h} +fade_y 30,70
fade_z:
0<=_start<=100,0<=_end<=100
Create transversal fading from selected images.
Default values: ’start=30’ and ’end=70’.
sub_alpha:
[base_image],_opacity_gain>=1
Compute the
minimal alpha-channel difference (opposite of alpha
blending) between the selected
images
and the specified base image.
The alpha difference A-B is defined as the image having
minimal opacity, such that
alpha_blend(B,A-B) = A.
Default value: ’opacity_gain=1’.
Example: [#1] image.jpg testimage2d {w},{h} +sub_alpha[0] [1] display_rgba
12.19. Image
Sequences and Videos
--------------------------
animate:
filter_name,"param1_start,...,paramN_start","param1_end,...,paramN_end",nb_frames>=0,
_output_frames={ 0 | 1 },_output_filename |
delay>0,_back and forth={ 0 | 1 }
Animate filter
from starting parameters to ending parameters or animate
selected images
in a display window.
Default value: ’delay=30’.
Example: [#1] image.jpg animate flower,"0,3","20,8",9
apply_camera:
_"command",_camera_index>=0,_skip_frames>=0,_output_filename
Apply specified command on live camera stream, and display it on display window [0].
Default
values: ’command=""’,
’camera_index=0’ (default camera),
’skip_frames=0’ and
’output_filename=""’.
apply_files:
"filename_pattern",_"command",_first_frame>=0,_last_frame={
>=0 | -1=last },_frame_step>=1, _output_filename
Apply a
G’MIC command on specified input image files,
in a streamed way.
If a display window is opened, rendered frames are displayed
in it during processing.
The output filename may have extension
’.avi’ (saved as a video), or any other
usual image file
extension (saved as a sequence of images).
Default
values: ’command=(undefined)’,
’first_frame=0’,
’last_frame=-1’,
’frame_step=1’ and
’output_filename=(undefined)’.
apply_video:
video_filename,_"command",_first_frame>=0,_last_frame={
>=0 | -1=last },_frame_step>=1, _output_filename
Apply a
G’MIC command on all frames of the specified
input video file, in a streamed way.
If a display window is opened, rendered frames are displayed
in it during processing.
The output filename may have extension
’.avi’ (saved as a video), or any other
usual image
file extension (saved as a sequence of images).
Default
values: ’first_frame=0’,
’last_frame=-1’,
’frame_step=1’ and
’output_filename=(undefined)’.
average_files:
"filename_pattern",_first_frame>=0,_last_frame={
>=0 | -1=last },_frame_step>=1,_output_filename
Average
specified input image files, in a streamed way.
If a display window is opened, rendered frames are displayed
in it during processing.
The output filename may have extension
’.avi’ (saved as a video), or any other
usual image
file extension (saved as a sequence of images).
Default
values: ’first_frame=0’,
’last_frame=-1’,
’frame_step=1’ and
’output_filename=(undefined)’.
average_video:
video_filename,_first_frame>=0,_last_frame={ >=0 |
-1=last },_frame_step>=1,_output_filename
Average frames
of specified input video file, in a streamed way.
If a display window is opened, rendered frames are displayed
in it during processing.
The output filename may have extension
’.avi’ (saved as a video), or any other
usual image
file extension (saved as a sequence of images).
Default
values: ’first_frame=0’,
’last_frame=-1’,
’frame_step=1’ and
’output_filename=(undefined)’.
fade_files:
"filename_pattern",_nb_inner_frames>0,_first_frame>=0,_last_frame={
>=0 | -1=last },_frame_step>=1, _output_filename
Generate a
temporal fading from specified input image files, in a
streamed way.
If a display window is opened, rendered frames are displayed
in it during processing.
The output filename may have extension
’avi’ (saved as a video), or any other
usual image
file extension (saved as a sequence of images).
Default
values: ’nb_inner_frames=10’,
’first_frame=0’,
’last_frame=-1’,
’frame_step=1’ and
’output_filename=(undefined)’.
fade_video:
video_filename,_nb_inner_frames>0,_first_frame>=0,_last_frame={
>=0 | -1=last },_frame_step>=1, _output_filename
Create a
temporal fading sequence from specified input video file, in
a streamed way.
If a display window is opened, rendered frames are displayed
in it during processing.
Default
values: ’nb_inner_frames=10’,
’first_frame=0’,
’last_frame=-1’,
’frame_step=1’ and
’output_filename=(undefined)’.
files2video:
"filename_pattern",_output_filename,_fps>0,_codec
Convert several files into a single video file.
Default values: ’output_filename=output.avi’, ’fps=25’ and ’codec=mp4v’.
median_files:
"filename_pattern",_first_frame>=0,_last_frame={
>=0 | -1=last },_frame_step>=1,_frame_rows[%]>=1,
_is_fast_approximation={ 0 | 1 }
Compute the
median frame of specified input image files, in a streamed
way.
If a display window is opened, rendered frame is displayed
in it during processing.
Default
values: ’first_frame=0’,
’last_frame=-1’,
’frame_step=1’,
’frame_rows=20%’ and
’is_fast_approximation=0’.
median_video:
video_filename,_first_frame>=0,_last_frame={ >=0 |
-1=last },_frame_step>=1,_frame_rows[%]>=1,
_is_fast_approximation={ 0 | 1 }
Compute the
median of all frames of an input video file, in a streamed
way.
If a display window is opened, rendered frame is displayed
in it during processing.
Default
values: ’first_frame=0’,
’last_frame=-1’,
’frame_step=1’,
’frame_rows=100%’ and
’is_fast_approximation=1’.
morph:
nb_inner_frames>=1,_smoothness>=0,_precision>=0
Create morphing sequence between selected images.
Default values: ’smoothness=0.1’ and ’precision=4’.
Example: [#1] image.jpg +rotate 20,1,1,50%,50% morph 9
morph_files:
"filename_pattern",_nb_inner_frames>0,_smoothness>=0,_precision>=0,_first_frame>=0,_last_frame={
>=0 | -1=last },_frame_step>=1,_output_filename
Generate a
temporal morphing from specified input image files, in a
streamed way.
If a display window is opened, rendered frames are displayed
in it during processing.
The output filename may have extension
’.avi’ (saved as a video), or any other
usual image
file extension (saved as a sequence of images).
Default
values: ’nb_inner_frames=10’,
’smoothness=0.1’,
’precision=4’,
’first_frame=0’,
’last_frame=-1’,
’frame_step=1’ and
’output_filename=(undefined)’.
morph_rbf:
nb_inner_frames>=1,xs0[%],ys0[%],xt0[%],yt0[%],...,xsN[%],ysN[%],xtN[%],ytN[%]
Create morphing
sequence between selected images, using RBF-based
interpolation.
Each argument (xsk,ysk)-(xtk,ytk) corresponds to the
coordinates of a keypoint
respectively on the source and target images. The set of all
keypoints define the overall image
deformation.
morph_video:
video_filename,_nb_inner_frames>0,_smoothness>=0,_precision>=0,_first_frame>=0,_last_frame={
>=0 | -1=last },_frame_step>=1,_output_filename
Generate a
temporal morphing from specified input video file, in a
streamed way.
If a display window is opened, rendered frames are displayed
in it during processing.
The output filename may have extension
’.avi’ (saved as a video), or any other
usual image
file extension (saved as a sequence of images).
Default
values: ’nb_inner_frames=10’,
’smoothness=0.1’,
’precision=4’,
’first_frame=0’,
’last_frame=-1’,
’frame_step=1’ and
’output_filename=(undefined)’.
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,_single_frame_only={
-1=disabled | >=0 }
Generate a transition sequence between selected images.
Default values: ’shading=0’ and ’single_frame_only=-1’.
Example: [#1] image.jpg +mirror c 100%,100% plasma[-1] 1,1,6 transition[0,1] [2],5
transition3d:
_nb_frames>=2,_nb_xtiles>0,_nb_ytiles>0,_axis_x,_axis_y,_axis_z,_is_antialias={
0 | 1 }
Create 3D
transition sequence between selected consecutive images.
’axis_x’, ’axis_y’ and
’axis_z’ can be set as mathematical
expressions, depending on ’x’ and
’y’.
Default
values: ’nb_frames=10’,
’nb_xtiles=nb_ytiles=3’,
’axis_x=1’,
’axis_y=1’, ’axis_z=0’
and ’is_antialias=1’.
Example: [#1] image.jpg +blur 5 transition3d 9 display_rgba
video2files:
input_filename,_output_filename,_first_frame>=0,_last_frame={
>=0 | -1=last },_frame_step>=1
Split specified
input video file into image files, one for each frame.
First and last frames as well as step between frames can be
specified.
Default
values: ’output_filename=frame.png’,
’first_frame=0’,
’last_frame=-1’ and
’frame_step=1’.
12.20. Neural
Networks
---------------
nn_new_input:
module_name,width,_height,_spectrum
Add an input module with specified size to the neural network.
nn_new_output:
module_name,previous_module_name
Add an output module to the neural network.
nn_new_fullyconnected:
module_name,previous_module_name,nb_neurons,activation_function
Add a fully-connected module to the neural network.
nn_propagate_batch:
module_name,[inputs_zstacked]
Batch propagate
specified inputs through the neural network.
Insert image of corresponding network outputs at the end of
the list.
nn_propagate:
module_name
Propagate input through the neural network.
nn_backpropagate_batch:
module_name,[inputs_zstacked],[expected_outputs_zstacked],_insert_network_outputs={
0 | 1 }, _loss_function
Batch propagate
and backpropagate inputs and errors in neural network.
Optionnally insert image of corresponding network outputs at
the end of the list.
Return averaged loss.
nn_backpropagate:
module_name,[expected_output],_loss_function
Propagate input,
then back-propagate output error, through the neural
network.
This command set the network output.
Return average loss.
nn_update:
module_name,epsilon
Update neural network weights, after back-propagation of the error.
nn_output:
module_name,filename
Output specified network as a file.
nn_serialize:
module_name,_is_compressed={ 0 | 1 }
Serialize network into a single image, optionnally in a compressed form.
nn_unserialize:
Unserialize specified selection to retrieve a neural network.
nn_input:
"filename"
Input neural network from file.
12.21.
Convenience Functions
---------------------
alert:
_title,_message,_label_button1,_label_button2,...
Display an alert
box and wait for user’s choice.
If a single image is in the selection, it is used as an icon
for the alert box.
Default values: ’title=[G’MIC Alert]’ and ’message=This is an alert box.’.
arg:
n>=1,_arg1,...,_argN
Return the n-th argument of the specified argument list.
arg0:
n>=0,_arg0,...,_argN
Return the n-th argument of the specified argument list (where ’n’ starts from ’0’).
arg2var:
variable_name,argument_1,...,argument_N
For each i in
[1...N], set
’variable_name$i=argument_i’.
The variable name should be global to make this command
useful (i.e. starts by an underscore).
autocrop_coords:
value1,value2,... | auto
Return
coordinates (x0,y0,z0,x1,y1,z1) of the autocrop that could
be performed on the latest
of the selected images.
Default value: ’auto’
average_colors:
Return the average vector-value of the latest of the selected images.
base642img:
"base64_string"
Decode given
base64-encoded string as a newly inserted image at the end
of the list.
The argument string must have been generated using command
’img2base64’.
base642uchar:
"base64_string"
Decode given
base64-encoded string as a newly inserted 1-column image at
the end of the list.
The argument string must have been generated using command
’uchar2base64’.
basename:
file_path,_variable_name_for_folder
Return the
basename of a file path, and opt. its folder location.
When specified ’variable_name_for_folder’
must starts by an underscore
(global variable accessible from calling function).
bin:
binary_int1,...
Print specified binary integers into their octal, decimal, hexadecimal and string representations.
bin2dec:
binary_int1,...
Convert specified binary integers into their decimal representations.
covariance_colors:
_avg_outvarname
Return the
covariance matrix of the vector-valued colors in the latest
of the selected images
(for arbitrary number of channels).
Parameter ’avg_outvarname’ is used as a
variable name that takes the value of the average
vector-value.
dec:
decimal_int1,...
Print specified decimal integers into their binary, octal, hexadecimal and string representations.
dec2str:
decimal_int1,...
Convert specifial decimal integers into its string representation.
dec2bin:
decimal_int1,...
Convert specified decimal integers into their binary representations.
dec2hex:
decimal_int1,...
Convert specified decimal integers into their hexadecimal representations.
dec2oct:
decimal_int1,...
Convert specified decimal integers into their octal representations.
fact:
value
Return the factorial of the specified value.
fibonacci:
N>=0
Return the Nth number of the Fibonacci sequence.
Example:
[#1] echo ${"fibonacci 10"}
[gmic]-0./ Start G’MIC interpreter.0-0./ 550-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.
file_rm:
filename
Delete a file.
filename:
filename,_number1,_number2,...,_numberN
Return a filename numbered with specified indices.
files
(+):
_mode,path
Return the list
of files and/or subfolders from specified path.
’path’ can be eventually a matching
pattern.
’mode’ can be { 0=files only |
1=folders only | 2=files + folders }.
Add ’3’ to ’mode’ to
return full paths instead of filenames only.
Default value: ’mode=5’.
fitratio_wh:
min_width,min_height,ratio_wh
Return a 2D size
’width,height’ which is bigger than
’min_width,min_height’ and has the
specified
w/h ratio.
fitscreen:
width,height,_depth,_minimal_size[%],_maximal_size[%] |
[image],_minimal_size[%],_maximal_size[%]
Return the ’ideal’ size WxH for a window intended to display an image of specified size on screen.
Default values: ’depth=1’, ’minimal_size=128’ and ’maximal_size=85%’.
fontchart:
Insert G’MIC font chart at the end of the image list.
Example: [#1] fontchart
fps:
Return the
number of time this function is called per second, or -1 if
this info is not yet
available.
Useful to display the framerate when displaying
animations.
gcd:
a,b
Return the GCD (greatest common divisor) between a and b.
hex:
hexadecimal_int1,...
Print specified hexadecimal integers into their binary, octal, decimal and string representations.
hex2dec:
hexadecimal_int1,...
Convert specified hexadecimal integers into their decimal representations.
hex2img:
"hexadecimal_string"
Insert new image
1xN at the end of the list with values specified by the
given hexadecimal-encoded
string.
hex2str:
hexadecimal_string
Convert specified hexadecimal string into a string.
img2base64:
_encoding={ 0=base64 | 1=base64url },_store_names={ 0 | 1
}
Encode selected
images as a base64-encoded string.
The images can be then decoded using command
’base642img’.
Default values: ’encoding=0’.
img2hex:
Return
representation of last image as an hexadecimal-encoded
string.
Input image must have values that are integers in
[0,255].
img2str:
Return the content of the latest of the selected images as a special G’MIC input string.
img2text:
_line_separator
Return text contained in a multi-line image.
Default value: ’line_separator= ’.
img82hex:
Convert selected 8bits-valued vectors into their hexadecimal representations (ascii-encoded).
hex2img8:
Convert selected hexadecimal representations (ascii-encoded) into 8bits-valued vectors.
is_3d:
Return 1 if all of the selected images are 3D objects, 0 otherwise.
is_change:
_value={ 0=false | 1=true }
Set or unset the
’is_change’ flag associated to the image
list.
This flag tells the interpreter whether or not the image
list should be displayed when the pipeline
ends.
Default value: ’value=1’.
is_half:
Return 1 if the type of image pixels is limited to half-float.
is_ext:
filename,_extension
Return 1 if specified filename has a given extensioin.
is_image_arg:
string
Return 1 if specified string looks like ’[ind]’.
is_pattern:
string
Return 1 if specified string looks like a drawing pattern ’0x......’.
is_percent:
string
Return 1 if specified string ends with a ’%’, 0 otherwise.
is_variable_name:
"str"
Returns 1 if specified argument can be considered as a variable name, 0 otherwise.
is_videofilename:
Return 1 if extension of specified filename is typical from video files.
is_macos:
Return 1 if current computer OS is Darwin (MacOS), 0 otherwise.
is_windows:
Return 1 if current computer OS is Windows, 0 otherwise.
math_lib:
Return string that defines a set of several useful macros for the embedded math evaluator.
mad:
Return the MAD
(Maximum Absolute Deviation) of the last selected image.
The MAD is defined as MAD = med_i|x_i-med_j(x_j)|
max_w:
Return the maximal width between selected images.
max_h:
Return the maximal height between selected images.
max_d:
Return the maximal depth between selected images.
max_s:
Return the maximal spectrum between selected images.
max_wh:
Return the maximal wxh size of selected images.
max_whd:
Return the maximal wxhxd size of selected images.
max_whds:
Return the maximal wxhxdxs size of selected images.
median_color:
Return the median color value of the last selected image.
min_w:
Return the minimal width between selected images.
min_h:
Return the minimal height between selected images.
min_d:
Return the minimal depth between selected images.
min_s:
Return the minimal s size of selected images.
min_wh:
Return the minimal wxh size of selected images.
min_whd:
Return the minimal wxhxd size of selected images.
min_whds:
Return the minimal wxhxdxs size of selected images.
nmd (+):
Shortcut for command ’named’.
named
(+):
_mode,"name1","name2",...
Return the set
of indices corresponding to images of the selection with
specified names.
After this command returns, the status contains a list of
indices (unsigned integers),
separated by commas (or an empty string if no images with
those names have been found).
(equivalent to shortcut command
’nmd’).
’mode’
can be { 0=all indices (default) | 1=lowest index |
2=highest index | 3 = all indices (case
insensitive) | 4 = lowest index (case insensitive) | 5 =
highest index (case insensitive)}
normalize_filename:
filename
Return a "normalized" version of the specified filename, without spaces and capital letters.
oct:
octal_int1,...
Print specified octal integers into their binary, decimal, hexadecimal and string representations.
oct2dec:
octal_int1,...
Convert specified octal integers into their decimal representations.
padint:
number,_size>0
Return a integer with ’size’ digits (eventually left-padded with ’0’).
path_cache:
Return a path to store G’MIC data files for one user (whose value is OS-dependent).
path_current:
Return current folder from where G’MIC has been run.
path_gimp:
Return a path to store GIMP configuration files for one user (whose value is OS-dependent).
path_tmp:
Return a path to store temporary files (whose value is OS-dependent).
remove_copymark:
"image_name"
Remove copy mark from names of selected images.
reset:
Reset global parameters of the interpreter environment.
rgb:
Return a random int-valued RGB color.
rgba:
Return a random int-valued RGBA color.
std_noise:
Return the estimated noise standard deviation of the last selected image.
str:
string
Print specified string into its binary, octal, decimal and hexadecimal representations.
str2hex:
string
Convert specified string into a sequence of hexadecimal values.
strcapitalize:
string
Capitalize specified string.
strcontains:
string1,string2
Return 1 if the first string contains the second one.
strlen:
string1
Return the length of specified string argument.
strreplace:
string,search,replace
Search and replace substrings in an input string.
strlowercase:
string
Return a lower-case version of the specified string.
struppercase:
string
Return an upper-case version of the specified string.
strvar:
string
Return a simplified version of the specified string, that can be used as a variable name.
strver:
_version
Return the specified version number of the G’MIC interpreter, as a string.
Default value: ’version=$_version’.
tic:
Initialize
tic-toc timer.
Use it in conjunction with ’toc’.
toc:
Display elapsed
time of the tic-toc timer since the last call to
’tic’.
This command returns the elapsed time in the status value.
Use it in conjunction with ’tic’.
to_clutname:
"string"
Return simplified name that can be used as a CLUT name, from specified input string.
uchar2base64:
_encoding={ 0=base64 | 1=base64url }
Encode the
values of the latest of the selected images as a
base64-encoded string.
The string can be decoded using command
’base642uchar’.
Selected images must have values that are integers in
[0,255].
Default values: ’encoding=0’.
12.22. Other
Interactive Commands
--------------------------
demos:
_run_in_parallel={ 0=no | 1=yes | 2=auto }
Show a menu to select and view all G’MIC interactive demos.
tixy:
"expression"
Animate
specified mathematical expression with a 16x16 grid of
circles, using the rules described
at https://tixy.land
x_2048:
Launch the 2048 game.
x_blobs:
Launch the blobs editor.
x_bouncing:
Launch the bouncing balls demo.
x_color_curves:
_colorspace={ rgb | cmy | cmyk | hsi | hsl | hsv | lab | lch
| ycbcr | last }
Apply color
curves on selected RGB[A] images, using an interactive
window.
Set ’colorspace’ to
’last’ to apply last defined color curves
without opening interactive windows.
Default value: ’colorspace=rgb’.
x_colorize:
_is_lineart={ 0 | 1 },_max_resolution={ 0 | >=128
},_multichannels_output={ 0 | 1 },_[palette1],
_[palette2],_[grabber1]
Colorized
selected B&W images, using an interactive window.
When >0, argument ’max_resolution’
defines the maximal image resolution used in the interactive
window.
Default values: ’is_lineart=1’, ’max_resolution=1024’ and ’multichannels_output=0’.
x_connect4:
Launch the Connect Four game.
xz:
Shortcut for command ’x_crop’.
x_crop:
Crop selected
images interactively.
(equivalent to shortcut command
’xz’).
x_cut:
Cut selected images interactively.
x_fire:
Launch the fire effect demo.
x_fireworks:
Launch the fireworks demo.
x_fisheye:
Launch the fish-eye effect demo.
x_fourier:
Launch the fourier filtering demo.
x_grab_color:
_variable_name
Open a color
grabber widget from the first selected image.
Argument ’variable_name’ specifies the
variable that contains the selected color values at any
time.
Assigning ’-1’ to it forces the
interactive window to close.
Default values: ’variable_name=xgc_variable’.
x_hanoi:
Launch the Tower of Hanoi game.
x_histogram:
Launch the histogram demo.
x_hough:
Launch the hough transform demo.
x_jawbreaker:
0<_width<20,0<_height<20,0<_balls<=8
Launch the Jawbreaker game.
x_landscape:
Launch the virtual landscape demo.
x_life:
Launch the game of life.
x_light:
Launch the light effect demo.
x_mandelbrot:
_julia={ 0 | 1 },_c0r,_c0i
Launch Mandelbrot/Julia explorer.
x_mask_color:
_colorspace={ all | rgb | lrgb | ycbcr | lab | lch | hsv |
hsi | hsl | cmy | cmyk | yiq },
_spatial_tolerance>=0,_color_tolerance>=0
Interactively
select a color, and add an alpha channel containing the
corresponding color mask.
Argument ’colorspace’ refers to the color
metric used to compute color similarities, and can be
basically
one of { rgb | lrgb | ycbcr | lab | lch | hsv | hsi | hsl
| cmy | cmyk | yiq }.
You can also select one one particular channel of this
colorspace, by setting ’colorspace’ as
’colorspace_channel’ (e.g.
’hsv_h’ for the hue).
Default values: ’colorspace=all’, ’spatial_tolerance=5’ and ’color_tolerance=5’.
x_metaballs3d:
Launch the 3D metaballs demo.
x_minesweeper:
8<=_width=<20,8<=_height<=20
Launch the Minesweeper game.
x_minimal_path:
Launch the minimal path demo.
x_morph:
_nb_frames>=2,_preview_fidelity={ 0=coarsest | 1=coarse |
2=normal | 3=fine | 4=finest }
Launch the interactive image morpher.
Default values: ’nb_frames=16’ and ’preview_fidelity=3’.
x_pacman:
Launch pacman game.
x_paint:
Launch the interactive painter.
x_plasma:
Launch the plasma effect demo.
x_quantize_rgb:
_nbcolors>=2
Launch the RGB color quantization demo.
x_reflection3d:
Launch the 3D reflection demo.
x_rubber3d:
Launch the 3D rubber object demo.
x_segment:
_max_resolution={ 0 | >=128 }
Segment
foreground from background in selected opaque RGB images,
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,_background_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
information :
- The first row defines the values of a background curve
displayed on the window (e.g. an
histogram).
- The 2nd, 3rd and 4th rows define the R,G,B color
components displayed beside the X and Y axes.
Argument ’variable_name’ specifies the
variable that contains the selected function keypoints at
any time.
Assigning ’-1’ to it forces the
interactive window to close.
Default
values: ’variable_name=xsf_variable’,
’background_curve_R=220’,
’background_curve_G=background_curve_B=background_curve_T’.
x_select_palette:
_variable_name,_number_of_columns={ 0=auto | >0 }
Open a RGB or
RGBA color selector widget from a palette.
The palette is given as a selected image.
Argument ’variable_name’ specifies the
variable that contains the selected color values (as
R,G,B,[A])
at any time.
Assigning ’-1’ to it forces the
interactive window to close.
Default values: ’variable_name=xsp_variable’ and ’number_of_columns=2’.
x_shadebobs:
Launch the shade bobs demo.
x_spline:
Launch spline curve editor.
x_starfield3d:
Launch the 3D starfield demo.
x_tetris:
Launch tetris game.
x_threshold:
Threshold selected images interactively.
x_tictactoe:
Launch tic-tac-toe game.
x_warp:
_nb_keypoints_xgrid>=2,_nb_keypoints_ygrid>=2,_nb_keypoints_contours>=0,_preview_fidelity={
0=coarsest | 1=coarse | 2=normal | 3=fine | 4=finest
},_[background_image],0<=_background_opacity<=1
Launch the interactive image warper.
Default
values:
’nb_keypoints_xgrid=nb_keypoints_ygrid=2’,
’nb_keypoints_contours=0’ and
’preview_fidelity=1’.
x_waves:
Launch the image waves demo.
x_whirl:
_opacity>=0
Launch the fractal whirls demo.
Default values: ’opacity=0.2’.
13. Examples
of Use
---------------
gmic is a
generic image processing tool which can be used in a wide
variety of situations. The
few examples below illustrate possible uses of this
tool:
## View a list of images:
$ gmic file1.bmp file2.jpeg
## Convert an image file:
$ gmic input.bmp output output.jpg
## Create a volumetric image from a movie sequence:
$ gmic input.mpg append z output output.hdr
## Compute image gradient norm:
$ gmic input.bmp gradient_norm
## Denoise a color image:
$ gmic image.jpg denoise 30,10 output denoised.jpg
## Compose two images using overlay layer blending:
$ gmic image1.jpg image2.jpg blend overlay output blended.jpg
## Evaluate a mathematical expression:
$ gmic echo "cos(pi/4)ˆ2+sin(pi/4)ˆ2={cos(pi/4)ˆ2+sin(pi/4)ˆ2}"
## Plot a 2D function:
$ gmic 1000,1,1,2 fill "X=3*(x-500)/500;Xˆ2*sin(3*Xˆ2)+if(c==0,u(0,-1),cos(X*10))" plot
## Plot a 3D elevated function in random colors:
$ gmic
128,128,1,3,"u(0,255)" plasma 10,3 blur 4 sharpen
10000 elevation3d[-1]
"’X=(x-64)/6;Y=(y-64)/6;100*exp(-(Xˆ2+Yˆ2)/30)*abs(cos(X)*sin(Y))’"
## Plot the isosurface of a 3D volume:
$ gmic mode3d 5 moded3d 5 double3d 0 isosurface3d "’xˆ2+yˆ2+abs(z)ˆabs(4*cos(x*y*z*3))’",3
## Render a G’MIC 3D logo:
$ gmic 0 text
G´MIC,0,0,53,1,1,1,1 expand_xy 10,0 blur 1 normalize
0,100 +plasma 0.4 add blur 1
elevation3d -0.1 moded3d 4
## Generate a 3D ring of torii:
$ gmic repeat 20
torus3d 15,2 color3d[-1]
"{u(60,255)},{u(60,255)},{u(60,255)}" *3d[-1]
0.5,1 if
"{$>%2}" rotate3d[-1] 0,1,0,90 fi add3d[-1] 70
add3d rotate3d 0,0,1,18 done moded3d 3 mode3d 5
double3d 0
## Create a vase from a 3D isosurface:
$ gmic moded3d 4
isosurface3d
"’xˆ2+2*abs(y/2)*sin(2*y)ˆ2+zˆ2-3’,0"
sphere3d 1.5 sub3d[-1] 0,5
plane3d 15,15 rotate3d[-1] 1,0,0,90 center3d[-1] add3d[-1]
0,3.2 color3d[-1] 180,150,255
color3d[-2] 128,255,0 color3d[-3] 255,128,0 add3d
## Display filtered webcam stream:
$ gmic apply_camera
## Launch a set of interactive demos:
$ gmic demos
** G’MIC comes with ABSOLUTELY NO WARRANTY; for details visit: https://gmic.eu **