- Index
- ImageMagick Examples Preface and Index
- Converting Color to Gray-Scale
(Making grayscale images)
- Image Level Adjustments
(adjusting the colors in images)
- Automatic Level Adjustments
(automatic enhancement of images)
- DIY Level Adjustments
(general tinting operators)
- Tinting Images
(general tinting operators)
- Global Color Modifiers
- Replacing Colors in an Image
(replacing individual colors)
- Recoloring Images with Gradients
- Miscellaneous Color Operators
(special recoloring operators)
Color modification of images without changing the overall image itself is
a very common requirement of ImageMagick. Whether it is to lighten or darken
the image, or more drastic color modifications.
We will need a test image... Don't worry above how I actually generated this
image, it is not important for the exercise. I did design it to contain a
range of colors, transparencies and other features, specifically to give IM a
good workout when used.
|
|
If you are really interested in the commands used to generate this image
you can look at the special script, "generate_test
", I use to create it.
Converting Color to Gray-Scale
Gray scale images can be very useful for many uses. Either as furthering the
processing of the original image, or for use in background compositions.
The best method of converting an image to gray-scale is to just ask IM to
convert the image into a gray-scale
Color
Space representation for the image.
convert test.png -colorspace Gray gray_colorspace.png
|
Note how the blue is much darker than the red, due the weighting to match the
intensity as they seem to appear to the human eye. That is '
red
'
is quite a bright color compared to '
blue
' which looks darker.
However there a many other methods, and meanings of 'gray-scale'...
For example, you can drain all the color out of the the image by using
"-modulate ", to set all
color saturation levels to zero.
convert test.png -modulate 100,0 gray_modulate.png
| |
|
Note how the IM '
green
' color I used in my test image is not a
pure green, but the half-bright green defined by the new
SVG -- Scalable Vector Graphics
standard. If you need a pure RGB green you can use the color
'
lime
' instead.
Another way is to use the FX DIY operator to
average the three channels together to get a pure mathematical meaning of
gray-scale.
convert test.png -fx '(r+g+b)/3' gray_fx_average.png
| |
|
You can use the same technique to control the weighting of the individual
color channels. For example this is the normal IM meaning of 'gray-scale' for
an RGB image.
convert test.png -fx '0.3*r+0.6*g+0.1*b' gray_diy.png
| |
|
You can also use 'intensity' if you want the same meaning within the "-fx " operator.
convert test.png -fx intensity gray_intensity.png
| |
|
Another technique is to simply add all three channels together and while the
resulting image will not loose information due to 'quantum rounding' effects,
you may loose information about the brightest colors.
convert test.png -separate -background black \
-compose plus -flatten gray_added.png
| |
|
This grayscale image is particularly well suited for generating masks from
Difference Images.
However as the
FX DIY operator is interpreted,
it can run very very slowly. For more complex operations you can use the
simpler
Evaluate Operator, "
-evaluate
".
For example here is a 2/5/3 ratio gray-scaled image, though I make no attempt
to preserve the transparency channel of the original image.
convert test.png -channel R -evaluate multiply .2 \
-channel G -evaluate multiply .5 \
-channel B -evaluate multiply .3 \
+channel -separate -compose add -flatten gray_253.png
| |
|
|
The above would suffer from 'quantization' effects for a ImageMagick
compiled at a 'Q8' Quality Level. That
is because the results of the "-evaluate " will be saved into a small 8 bit integer, used for
image values. Only later are those values added together with the
resulting loss of accuracy.
An ImageMagick compiled with 'Q16', or better still the HDRI, quality compile options will produce a
much more exact result.
|
A similar technique can be used to generate a pure mathematical gray-scale,
by directly averaging the three RGB channels equally.
convert test.png -separate -average gray_average.png
| |
|
However as you can see, I did not attempt to preserve the alpha channel of the
resulting image.
Another fast alternative is to use the "
-recolor
" color matrix operator,
which will let you specify the weighting of the three color channels.
convert test.png -recolor '.2 .5 .3
.2 .5 .3
.2 .5 .3' gray_recolor.png
| |
|
Basically the first tree numbers is the channel weighting for the resulting
images red channel, next 3 for green, and the final three numbers for blue.
A much more interesting technique is to extract a variety of different
meanings of brightness by extracting the appropriate
Color Channel from various
Color Space representations of the image.
The first image is the normal recommended method.
convert rose: -colorspace Gray channel_gray.gif
convert rose: -colorspace CMYK -channel K -negate -separate channel_black.gif
convert rose: -colorspace HSB -channel B -separate channel_brilliance.gif
convert rose: -colorspace HSL -channel B -separate channel_lightness.gif
convert rose: -colorspace YUV -channel R -separate channel_luma.gif
|
|
|
Gray RGB
|
Neg Black CMYK
|
Brilliance HSB
|
Lightness HSL
|
Luma (Y) YUV
|
Note that none of the gray-scale results are quite the same due to
the different meanings of 'brightness' in the various colorspaces.
Alternatively you can use "-type " to tell IM to treat the image as gray-scale, when either
reading or writing the image.
convert test.png -type GrayScaleMatte gray_type.png
| |
|
|
The "-type " setting is
generally only used when an image is being read or written to a file. As
such its action is delayed to the final write of the image. Its effect is
also highly dependant on the capabilities of the image file format
involved and is used to override ImageMagick's normal determination during
that process. See the Type examples for
more information.
|
|
Before IM v6.3.5-9 the above will have removed any transparency in the
written image (equivalent of a "-type Grayscale ") due to a bug. This was fixed as soon as I
noted the problem and reported it. (There is a lesson here :-)
|
Image Level Adjustments
The most basic form of adjustment you can make to images are known as 'level'
adjustments. This basically means taking the individual RGB color values
(or even the matte/alpha channel values) and adjusting them so as to either
stretch or compress those values.
As only channel values are being adjusted, they are best demonstrated on a
gray-scale image, rather than a color image. However if you adjust all the
color channels of an image by the same amount you can use them with color
images, for the purposes of either enhancing, or adjusting the image.
Do not confuse this with the more automatic form of level adjustments, which
we will look at in the next major section of examples below,
Auto-Level Adjustments. This function will do exactly
the same operation regardless of the actual content of the image. It does not
matter if the image is bright, or dark, or has a blue, or yellow tint. The
operations are blind to the actual image content.
In demonstrating these operations I will be using a modified "
gnuplot
" graph such as shown to
the right, which I generate using a special script "
im_graph_levels
". The graph has
a red line which maps the given original 'x' value (representing the
gray-scale value of the top most gradient) to the 'y' value shown. The
resulting color gradient is also shown underneath the input linear gradient.
The graph shown to right is of the IM "
-noop
" operator which actually does nothing to an image. As such
each of the image's color values are just mapped to exactly the same value
without change. The lower gradient is thus the same as the upper gradient.
Image Negation
The simplest and most basic global level adjustment you can make is to negate
the image, using the "
-negate
" image operator.
Essentially this makes white, black, and black, white,
, adjusting all the colors to match. That is it will make the color
red, its complementary color of cyan, and blue, yellow, etc.
You can see this with the mapping graph shown below, as I use the "
-negate
" operator on both the
'test' image and the standard IM 'rose' built-in image. Note how the lower
gradient in the mapping graph image is now reversed, so that black and white
are swapped, and the same reversal appearing in the negated 'test' image.
convert test.png -negate test_negate.png
convert rose: -negate rose_negate.gif
|
Internally negate is actually rather stupid. It handles the three color
channels independently, and by default ignores the alpha or matte channel.
If this was not the case, you would get a very silly result like this...
convert test.png -channel RGBA -negate negate_rgba.png
|
The image is negated, as you can see by the semi-transparent color gradient.
But as the transparency channel has also been negated you loose all the opaque
colors in the image. This is why the default setting for "
-channel
" is '
RGB
'.
See
Color Channels for more information.
You can limit the negation to just one channel, say the green color channel.
This may not seem very useful, but at times it is vitality important.
convert test.png -channel green -negate negate_green.png
|
The "
-negate
" operator
is actually its own inverse. Doing two negations with the same "
-channel
" setting cancels each
other out.
convert negate_green.png -channel green -negate negate_restore.png
|
Negation is extremely common in image processing, particularly when dealing
with gray-scale images as a step before or after other processing options. As
such I recommend you play with it and keep it in mind whenever you are doing
anything, as working with negated images can solve some otherwise difficult
problems.
Direct Level Adjustments
The "
-level
" operator is
the more general level adjustment operator. You basically give it two values
a 'black_point' and a 'white_point', as well as an optional third value (gamma
adjustment), which I will look at
later.
What it does is map any color values in the image that is equal to or less
than the 'black_point', and make them black (or a 0 value). Similarly, any
color values which are equal to or brighter that the 'white_point' will make
them white (or a Maximum value). The colors in between these two points
are then 'stretched' linearly to fill the complete range of values.
The effect of this is to improve the contrast, enhancing the colors within an
image. For example here is a 25% contrast enhancement of our test image,
using the same values as shown by the graph.
As you commonly adjust both the black and white points by the same amount from
the
0%
and
100%
amounts, you can just specify the
'black_point' only. The white point will be adjusted by the same amount
inward.
convert test.png -level 25%,75% test_level.png
convert rose: -level 25% rose_level.gif
|
Note that
25%
is a huge contrast enhancement for any image, but
it clearly shows what it does.
You don't have to change both the 'black' and 'white' points. Instead it is
quite permissible to just adjust only one end of the color range. For example
we can make a very light, or a very dark rose image.
convert rose: -level 0,75% rose_level_light.gif
convert rose: -level 25%,100% rose_level_dark.gif
|
However I again warn you that the colors outside the given range are 'clipped'
or 'burned', and as such will no longer be available for later image
processing. This is the biggest problem with using a "
-level
" operator.
By using a negative value you can do some rough de-contrasting of an image.
What this means is that rather than providing a color value for the values
to be mapped to 'black' and 'white' and thus stretching out the colors
in between, you instead compress the color values so as to map the imaginary
negative color to black or white. The result is a general graying of the image.
convert rose: -level -25% rose_decontrast.gif
| |
|
This method of decontrasting an image however is very inaccurate and not
recommended, unless you have a IM older than version 6.4.2 where you don't
have access to the new
Reversed Level Operator.
You can use the "
-level
"
operator to negate an image, just by swapping the 'black' and 'white' point
values given, using "
-level 100%,0
".
Or by setting them to the same value, you can effectively call all the color
values in the image to be thresholded. Using "
-level
" to threshold an image is
exactly the same as if you used the "
-threshold
" operator with the
value. The mapping graph shown right, shows the results of a
"
-level 50%,50%
" operation, and its effect on a grayscale
gradient.
And here is the result of applying this thresholding "
-level
" operation on the built-in
rose image. Note that unlike "
-threshold
" the image is not converted to a grayscale image as
part of the thresholding, when used with the default "
-channel
" setting (see
Thresholding Images).
convert rose: -level 50%,50% rose_level_thres.gif
| |
|
The general nature of level to linearly modify an image, makes the "
-level
" operator a very good for
general gray-scale image, and mask adjustments. Add the fact that you can
modify individual channels (using the "
-channel
" setting) as opposed to
the whole image, makes it one of the basic color modification operators
available to IM users.
|
Be warned that the "-level " operator treats the transparency channel as 'matte'
values. As such 100% is fully transparent and 0% is opaque. Please take
this into account when using -level with a blurred shape image. This is
most typically done after blurring an 'shape' image, to expand and stretch
the results. For examples of this see Soft Edges, and Shadow
Outlines.
|
|
Note you can also use the Evaluate and
Function Operators for a more direct mathematical modification of the
color values, to achieve the same results for -level both + and - forms).
|
Reversed Level Adjustments
As of IM version 6.4.2 the
Level Operator was expanded
to provide a 'reversed' form "
+level
" (note the 'plus'). Alternatively you can use the original
"
-level
" form of the
operator but add a '
!
' to the level argument given (for older API
interfaces).
The arguments for this variant is exactly the same, but instead of stretching
the values so as to map the 'black_point' and 'white_point' to 'black' and
'white', it maps 'black' and 'white' to the given points. In other words
"
+level
" is the exact
reverse of "
-level
".
For example here we map 'black' to a 25% gray, and white to 75% gray,
effectively de-contrasting the image in a very exact way.
convert test.png +level 25% test_level_plus.png
convert rose: +level 25% rose_level_plus.gif
|
If you compare the above "
+level 25%
" operation with the use
of a a negative de-contrasting, "
-level -25%
" operator we
showed previously, you will see that are not the same. The 'plus' version
produces a much stronger de-contrasted image (it is greyer), but does so by
mapping to the exact values you give the operator, and not the 'imaginary'
values the 'minus' form used. This exact value usage is important, and one of
the reasons why the 'plus' form of the operator was added.
Of course a '
25%
' is again a very large value, and it is not
recommended for use with typical image work.
Note that the "
-level
"
and "
+level
", are in
actual fact the exact reverse of each other when given the same argument.
That is one maps values to the range extremes, while the other maps from the
range extremes.
However while you can use one to 'undo' the other, the result may not be
exactly the same, due to 'clipping' and 'quantum rounding' effects on the
image values.
For example here we compress the colors of the test image using "
+level
", then decompress them
again using "
-level
", so
as to restore the image close to its original appearance.
convert test.png +level 20% -level 20% test_level_undo.png
|
The two images appear to be very very similar, and as I am using a high
quality 'Q16' version of IM, you will be hard
pressed to notice any difference at all. However the values may not be
exactly the same (especially with a Q8 version of IM), as you have
effectively compressed, the un-compressed the image, which can produce some
'rounding' effects (unless you use a floating point
HDRI version of ImageMagick).
Unfortunately, doing these two operations in the opposite order (stretch, then
compress the color values) produces a very different result...
convert test.png -level 20% +level 20% test_level_undo2.png
|
Notice how the center values of the color range are restored correctly, but
the bright and dark ends have been clipped during the stretching by the
"
-level
" operator. Then
when the "
+level
"
operator was applied the 'clipped' or 'burned' values was moved to the given
grey levels, effectively clipping the brightest and darkest pixels to
specific values. This can be a extremely useful technique.
One other useful aspect of the "
+level
" operator is that you can completely compress all the color
values in an image to the same gray-scale level.
convert test.png +level 30%,30% test_level_const.png
|
By specifying levels according to the values of specific colors for each
individual channel, you can effectively convert a greyscale gradient into a
specific color gradient. However this is rather difficult to calculate and
do. As such a "
-level-colors
" operator has also been provided that will let you
specify the black and white points in terms of specific colors rather than
'level' values. See
Level by Color below.
Level Gamma Adjustments
Both the above "
-level
"
variants also allow you to use a third setting. The 'gamma' adjustment value.
By default this is set to a value of
1.0
', which does not do any
sort of mid-tone adjustment of the resulting image, producing a pure linear
mapping of the values from the old image to the new image.
However by making this value larger, you will curve the resulting line so as
to brighten the image, while shrinking that value will darken the image.
For example here I use just the 'gamma' setting to brighten and darken just
the mid-tones of the image.
convert rose: -level 0%,100%,2.0 rose_level_gamma_light.gif
convert rose: -level 0%,100%,0.5 rose_level_gamma_dark.gif
|
Values generally range from 10 for a blinding bright image, to .2 for very
dark image. As mentioned a value of
1.0
will make no 'gamma'
changes to the image. However the special value of '
2.0
' (see
above) can be used to get the square root of the images normalized color.
Both versions of the "
-level
" operate handles 'gamma' in the same way. This means you can
combine the level adjustment of the 'black' and 'white' ends with a
non-linear 'gamma' adjustment. You can also only adjust a single channel of
an image. For example, here we give an image a subtle tint at the black end
of just the blue channel, while using gamma to preserve the mid-tone color
levels of the image.
convert test.png -channel B +level 25%,100%,.6 test_blue_tint.png
|
This specific example, could be used to tint a weather satellite photo, where
only the sea is pure black, while land is more grey. Other alturnatives to
this blue channel adjustment is given below in
DIY
Mathematical Non-linear Adjustments.
The "
-gamma
" operator is
also provided, and has exactly the same effect as the 'gamma' setting in the
"
-level
" operator.
However it will let you adjust the 'gamma' adjustment level for each
individual channel as well.
For example here we brighten the image differently for each individual RGB
channel.
convert rose: -gamma 0.8,1.3,1.0 gamma_channel.gif
| |
|
As you can see this can be used to do some subtle tinting and color
adjustments to an image, or correct images with contain too much of a specific
color.
|
One of the most important things when resizing, filtering or modifying
images (even more important anything else) is to do it in linear space, so
if your image is gamma corrected, you should transform it to linear space,
scale and then transform back to gamma space.
|
One less obvious use of "
-gamma
" is to zero out specific image channels (see
Zeroing Color Channels). Or color an image
completely 'black', 'white' or some other primary color (see
Primary Colored Canvases).
Level Adjustment by Color
The "
-level-colors
" operator was added to IM v6.2.4-1. Essentially, it
is exactly the same as the
Level Operator we discussed
above, but with the value for each channel specified as a color value.
That is the "
-level-colors
" option will map the given colors to 'black' and
'white' and stretching all the other colors between then linearly. This
effectively removes the range of colors given from the image.
And while this works, it is not particularly useful, as it is prone to fail
for colors which have common values in some channel. For example the colors
'
DodgerBlue
' and '
White
' have the same color values
in the blue channel, as such "
-level-colors DodgerBlue,White
"
will not convert those colors to black and white.
The better technique in that case is to extract a greyscale image of the
channel with the highest differences (such as red) and level or normalize that
channel.
WARNING: watch out for 'transparent' colors.
The plus form of the operator "
+level-colors
" on the other hand is extremely useful as it will
map the 'black' and 'white' color to the given values compressing all the
other colors linearly to fit the two colors you give.
For example lets map '
black
' and '
white
' to
'
green
', and '
gold
'...
convert test.png +level-colors green,gold levelc_grn-gold.png
|
As you can see the grayscale gradient is remapped into the a gradient bound by
the colors given, and although colors outside a gray-scale range are also
modified, they will also follow the basic style of the color range
specified. This makes the "
+level-colors
" operator an extremely useful one, especially when
mapping grayscale images.
If you only supply one colorname but include a comma, the missing color will
default either to '
black
' or '
white
' as appropriate.
convert test.png +level-colors ,DodgerBlue levelc_dodger.png
convert test.png +level-colors ,Gold levelc_gold.png
convert test.png +level-colors ,Lime levelc_lime.png
convert test.png +level-colors ,Red levelc_red.png
convert test.png +level-colors Navy, levelc_navy.png
convert test.png +level-colors DarkGreen, levelc_darkgreen.png
convert test.png +level-colors Firebrick, levelc_firebrick.png
|
This makes it easy to convert grayscale images into a gradient for any color
you like, without aliasing problems you may get using
Direct Color Replacement.
convert cow.gif +level-colors red, cow_red.gif
|
Of course if you want one of the colors to be made transparent instead you are
better off using the
-alpha Shape
operator instead.
If you only specify a single color without any 'comma' separator, that color
will be used for both black and white points. That means all the colors in the
image will be reset to that one color. (according to the current "
-channel
" setting limitations).
convert test.png +level-colors dodgerblue levelc_blue.png
| |
|
If you want to set the images transparency setting as well you will need to
set "
-channel
" to
include the transparency channel, OR set the
Alpha
Channel to fully-opaque, using either "
-alpha opaque
" or
"
-alpha off
.
convert test.png -channel ALL +level-colors dodgerblue levelc_blue2.png
| |
|
Also see
Blanking Existing Images.
Here are a few more examples of using this to adjust or 'tint' a colorful
image, rather than a gray-scale image.
convert rose: +level-colors navy,lemonchiffon levelc_faded.gif
convert rose: +level-colors firebrick,gold levelc_fire.gif
convert rose: +level-colors 'rgb(102,75,25)',lemonchiffon levelc_tan.gif
|
In summary the "
+level-colors
" is a gradient color replacement, a linear tinting
operator, and can also completely reset colors.
Sigmoidal Non-linearity Contrast
From a PDF paper on '
Fundamentals of
Image Processing' (page 44) they present an alternative from the linear
contrast control with gamma correction known as '
sigmoidal non-linearity
contrast control'.
The result is a non-linear, smooth contrast change (a 'Sigmoidal Function' in
mathematical terms) over the whole color range, preserving the white and black
colors, much better for photo color adjustments.
The exact formula from the paper is very complex, and even has a mistake, but
essentially requires with two adjustment values. A threshold level for the
the contrast function to center on (typically '
50%
'), and a
contrast factor ('
10
being very high, and '
0.5
' very
low).
|
For those interested, the corrected formula for the 'sigmoidal
non-linearity contrast control' is...
(1/(1+exp(β(α-u)))
- 1/(1+exp(β)))
/ (1/(1+exp(β(α-u))/(1+exp(β))))
Where α is the threshold level, and β the contrast
factor to be applied.
The formula is actually very simple exponential curve, with the bulk of
the above formula is designed to ensure that 0 remains 0 and 1 remains
one. That is the graph always goes though the points 0,0 and 1,1. And the
highest gradient of change is at the given threshold.
|
Here for example is a "
-fx
"
implementation of the above formula, resulting from a very high contrast value
of '
10
' and a '
50%
' threshold value. These values
have been rolled into the floating point constants, to speed up the function.
convert test.png -fx '(1/(1+exp(10*(.5-u)))-0.0066928509)*1.0092503' \
sigmoidal.png
|
Lucky for us IM v6.2.1 had this complex function built in as a new operator
"-sigmoidal-contrast ", allowing a much simpler application.
convert test.png -sigmoidal-contrast 10,50% test_sigmoidal.png
| |
|
As a bonus IM also provides the inverse, a 'sigmoidal contrast reduction'
function (as plus '+ ' form of the operator), which if applied
with the same arguments restores our original image (almost exactly).
convert test_sigmoidal.png +sigmoidal-contrast 10,50% \
test_sigmoidal_inv.png
| |
|
And here we apply it to the rose image...
convert rose: -sigmoidal-contrast 10,50% rose_sigmoidal.gif
| |
|
I did say '
10
' was a very heavy contrast factor. In fact anything
higher than this value can be considered to me more like a fuzzy threshold
operation, rather than a contrast enhancement.
For a practical example of using this operator see the advanced
"Gel" Effects Example, where it is used
to sharpen the bright area being added to a shaped area color.
Miscellaneous Contrast Operators
Under Construction
-contrast and +contrast
Rather useless minor contrast adjustment operator
-threshold
Threshold the image, any value less than or equal to the given value is
set to 0 and anything greater is set to the maximum value.
Note that like level, this is a channel operator, but if the default
'channel setting' is used only the gray-scale intensity of the image is
thresholded producing a black and white image.
convert rose: -threshold 45% x:
You can force normal channel behaviour, where each channel is thresholded
individually buy using "-channel All"
convert rose: -channel All -threshold 45% x:
-black-threshold
-white-threshold
This is like -threshold except that only one side of the threshold value is
actually modified.
For example, here anything that is darker than 30% is set to black.
convert rose: -black-threshold 30% x:
convert rose: -white-threshold 50% x:
These operators however do not seem to be channel effected, so may only be
suitable for gray-scale images!
Then
-colorize, and -tint
-opaque -transparency floodfill -fuzz
-recolor
Automatic Level Adjustments
Being able to adjust the color range of a gray scale image can be crucial to
general image manipulation. This is generally known as Histogram Adjustment.
The following are just some of the methods that can be used to do this.
FUTURE:
-normalise
Try to stretch the image uniformly across all color channels so as to
enhance the image.
The channel operator can be used to 'disconnect' the uniformity across
all channels, or alternatively you can separate and normalize each
channel individually. However when recombined you may find you get some
color distortion due to each channel being stretched out unequally.
Normalizing a intensity, or equivalent channel in some other colorspace
can also be used to ensure correct normalization of the image without
color distortions, though this is a much more trickier method.
See also equalize, and (future) -equalize-gaussian, also look at Fred
Weinhaus's scripts for various methods of image enhancements.
In reality this operator is equivalent to "-contrast-stretch 2%,99%"
Which means at least 2% of the darkest color values will be set to zero
(black) while the top 1% of the brightest pixels will be set to maximum
(white) all the other pixels in the image are the stretched out to fill
the whole range from black to white.
If you do not which to 'burn' those top and bottom pixels, use
"-contrast-stretch 0" to do a more 'logical normalize' of the image,
without clipping or burning the top and bottom values.
-contrast-stretch
normalize the image so that the given percentage of pixels in a greyscale
image are mapped to black and white respectively.
That is -contrast-stretch 5% will make at least 5% of all pixels in a
greyscale image black, and at least 5% of the pixels white.
NOTE that -normalize is defined as -contrast-stretch 2%,99%
If you really want a 'true' normalize using the exact minimum and maximum
values, use -contrast-stretch 0
ASIDE: This currently does the value remapping using 'binned' color
values, as as a result produces a slightly distorted 'stretch'.
We are endeavouring to have this fixed to stretch the color values using
the internal -level operator.
Example: an image that does not span the histogram. You
can show a histogram plot or list. Then do -contrast-stretch 0% to
show that the min and max of the image are now at black and white,
resp. I think this is a good example as it stretches the histogram
just enough to span the range as opposed to normalize with clip or
burns or whatever you want to call it by 2% on the low end and 1% on
the high end.
People need to know that they can stretch the image to just exactly span
the histogram and do not have to use -normalize and lose data.
-linear-stretch
Finds the 'level' points for stretching by counting the number of pixels
from each end, until it exceeds the counts given.
-equalize histogram equalization of the image
When one wishes to compare two or more images on a specific basis, such
as texture, it is common to first normalize their histograms to a
"standard" histogram. The most common histogram normalization technique
is histogram equalization where one attempts to change the histogram so
that all the histogram colors are spread out equally over all brightness
values. This would correspond to a brightness distribution where all
values are equally probable. Unfortunately, for an arbitrary image, one
can only approximate this result.
Is it a image comparison technique?
Expand or Normalize gray-scale
To expand the gray scale image so it occupies the full range of gray values
(maximize contrast) is straight forward using the "
-normalize
" operator. That
is, the lightest gray becomes white and darkest gray, black.
Here we create a gray-scale gradient, and expand it to the full black and white
range.
convert -size 150x100 gradient:gray70-gray30 gray_range.jpg
convert gray_range.jpg -normalize normalize_gray.jpg
|
|
For practical reasons to do with JPEG color inaccuracies (see JPEG Color Distortion for more details)
and scanned image noise, "-normalize " does not expand the very brightest and darkest
colors, but a little beyond those values. That is it is equivalent to a
"-contrast-stretch " with a value of '2%,99% ' (see
below).
This means if highest and lowest color values are very close together,
"-normalize " will
fail, an no action will be taken.
If you really want to expand the exact brightest and darkest color values
to their extremes use "-contrast-stretch " with a value of '0 ' instead.
|
Up until IM version 6.2.5-5, "
-normalize
" worked purely as a grayscale operator. That is each of
the red, green, blue, and alpha channels were expanded independently of each
other according to the "
-channel
" setting.
As of IM version 6.2.5-5, if only the default "
+channel
" setting
'
RGB
' is given, then "
-normalize
" will tie together
all the color channels, and normalizes them all by the same amount. This
ensures that any grayscale that is in the image, remains grayscale. However if
non-grayscale colors are present, it may not expand the image to produce a
pure white or black level.
For example here we added some extra colors (a blue to navy gradient) to our
normalization test image.
convert -size 100x100 gradient:gray70-gray30 \
-size 50x100 gradient:blue-navy +append color_range.jpg
convert color_range.jpg -normalize normalize.jpg
|
As you can see from the last example, for color images "
-normalize
" maximized all the
channels together so one channel has a zero value, and another channel has a
maximum value. That is, no black pixels were generated, as all the added blue
colors already contains 'zero' values in the 'red' and 'green' channels. As
such the lower bounds of the image did not expand.
If you want the old "-normalize " behaviour, you will need to use a different "-channel " setting than the
default 'RGB ' setting. For images that contain no alpha (or
matte) channel, you can just use the 'all ' channel setting.
convert color_range.jpg -channel all -normalize normalize_all.jpg
| |
|
Alternatively, you can normalize each channel as a separate image using the
"-separate " operator
(as of IM v6.2.9-2), then "-combine " them back into a single image again.
convert color_range.jpg -separate -normalize -combine normalize_sep.jpg
| |
|
The results of the above turns the grayscale areas of the image yellow
As the '
red
' and '
green
' channels lightened.
The '
blue
' channel however is only darkened slightly.
This brings use to an important point
Normalise is really a grayscale operator,
caution is needed when used with color images.
contrast-stretch -- controlled normalize
The "
-contrast-stretch
" (added IM v6.2.6), is a more controlled version
of "
-normalize
". It
first finds the maximum and minimum bounds in the image, as normal, but then
shifts those bounds further inward by the given amount of color inward before
selecting the colors that will be mapped to white and black.
In other words it is still a "
-normalize
" type of operator, but then ignores the most extreme
colors by the amount given (generally as a percentage of gray scale).
For example, this will replace both the top and bottom 15% of colors with their
extremes (white and black), stretching the rest of the color to improve the
overall contrast.
convert gray_range.jpg -contrast-stretch 15% stretch_gray.jpg
|
And here I just grab the brightest 5% of colors, stretching them linearly, and
making all other colors black.
convert gray_range.jpg -contrast-stretch 95x100% stretch_black.jpg
| |
|
This can be quite useful, to find bright points in images. It is a bit like a
normalized version "
-black-threshold
" operator, but with the other colors stretched to
fill the full color range, rather than just turning the thresholded color
black.
Note that "
-contrast-stretch
" is not a true contrast operator, as it
normalizes the image first. If you want to improve the contrast of an image
by a fixed amount that is independent of the actual images current content,
then you should use "
-level
" instead.
DIY Level Adjustments
Mathematical Linear Histogram Adjustments
The various basic forms of "
Level Adjustments shown above
linearly adjust the colors of the image.
These changes can be applied mathematically as well. For example by
multiplying the image with a specific color, we set all pure white areas to
that color. So lets just read in our image, create an image containing the
color we want, then multiply the original image with this color using the IM
free-form "
-fx
" or
DIY Operator.
convert test.png -size 1x1 xc:Yellow \
-fx 'u*v.p{0,0}' fx_linear_white.png
|
By getting "
-fx
" to read the
color from a second '
v
' image makes it easy to change the color,
without needing to convert colors to RGB values for use in the mathematics.
If you were using a fancy graphical image processing package like "
Gimp
" and "
Photoshop
" the above operation would have been applied to an image
by adjusting the images color histogram graph 'curve'.
For example to the right is a "
gnuplot
" generated graph (See the script "
im_histogram
") of the
mathematical formula showing what happens to just one of the three RGB
channels. The original color (green line) is remapped to a darker color (red
line) linearly.
Linearly tinting the black colors is also quite simple. For example
to linear map '
black
' to a gold like color
'
rgb(204,153,51)
', (while leaving '
white
' as
'
white
'), would require a mathematical formula such as...
result = 1-(1-color)*(1-intensity)
This formula negates the colors, multiples the image with the negated color
wanted, and negates the image back again. The result is tinting of the black
side of the gray scale, leaving white unchanged.
convert test.png -size 1x1 xc:'rgb(204,153,51)' \
-fx '1-(1-v.p{0,0})*(1-u)' fx_linear_black.png
|
A "
gnuplot" histogram graph of the
remapping formula is also displayed in the above for your reference.
With a slightly more complicated formula you can linearly replace both the
'
black
' and '
white
' end of the grayscale with
specific colors.
convert test.png -size 1x2 gradient:gold-firebrick \
-fx 'v.p{0,0}*u+v.p{0,1}*(1-u)' fx_linear_color.png
|
The "
-size 1x2 gradient:color1-color2
" in the above is only used
to generate a two color pixel image for the "
-fx
" formula to reference. The first
color replaces white, while the second replaces black, while all others are
interpolated between white and black. As is typical of a gray-scale operator,
each RGB channel is treated as a separate gray scale channel, though the
linear interpolation is different for each channel.
This by the way is exactly equivalent to the
Level
Adjustments by Color operator "
+level-colors
"
However unlike "+level-colors ", the colors to use can of course come from any
image source, and not just the color names provided as an argument. However
even direct use of color names is posible.
convert test.png -fx "yellow*u+green*(1-u)" fx_linear.png
| |
|
Mathematical Non-linear Histogram Adjustments
While linear color adjustments are important, and faster methods ar available,
there are many situations where a linear 'level' adjustment, is not what is
wanted, and this is where the "
-fx
"
DIY Operator, becomes more
useful.
Well an alternative formula for linear adjustment is "
-fx
'v.p{0,1}+(v.p{0,0}-v.p{0,1})*u'
", which has the advantage that the
'
u
' can be replaced by a single random function
'
f(u)
' to produce non-linear color change.
This lets you do more interesting things. For example what if in the last
example you wanted to push all the colors toward the '
black
'
side, resulting in the image being a more '
firebrick
' color.
convert test.png -size 1x2 gradient:gold-firebrick \
-fx 'v.p{0,1}+(v.p{0,0}-v.p{0,1})*u^4' fx_non-linear.png
|
In a more practical example, Adelmo Gomes needed a color adjustment for a
automated
Weather Map Recoloring script he was developing.
In this case he wanted to tint pure black parts of the image to a .25 blue,
but leave the rest of the gray-scale alone, especially the white and mid-tone
grays of the image. Only the blue color needed such adjustment, which he
currently was doing by hand in an image editor.
For example you could use a quadratic formula like '
u^2
' to tint
the black end of the histogram to a '
.25
' blue color. Only the
blue channel needs to be modified, so the value was inserted directly into
the formula.
convert test.png -channel B -fx '.25+(1-.25)*u^2' fx_quadratic.png
|
However while this produced a reasonable result it does darken the mid-tone
grays slightly, producing a sickly off-yellow color.
To avoid this a 'exponential' function can be used instead, to give better
control of the tinting process.
convert test.png -channel B -fx '.3*exp(-u*4.9)+u' fx_expotential.png
|
Again the graph show how blue channel was modified to give black a distinctive
dark blue tint.
The second value ('
4.9
') is the falloff back to a linear
'
+u
' graph. The smaller this value is the slower the fall off,
and the more linear the adjustment becomes. The larger the value, the more
dramatic the 'fall-off'. The value may need to be adjusted for different
color values, so this is not a good general formula for general black color
tinting, but perfect for tinting weather maps.
Generally if you can express the color adjustment you want mathematically, you
can then use "
-fx
" operator
to achieve the results you want.
'Curves' Adjustments
Normally in a graphical photo editor you would be presented with a histogram
'curves' chart such as I have shown to the left. The user can then edit the
'curve' by moving four (or more) control points, and the histogram adjustment
function will follow those points.
The control points generally specify that the first grayscale level is after
adjustment to become the second grayscale level. So a point like 0.0,0.2
basically means that a 0% gray (black) should after adjustment be a 20% gray
level.
Now IM does not allow you to directly specify 'control points' to generate a
'curve' adjustment, what it wants is the mathematical formula of that 'curve'
generated. Lucky for us there are programs that can generate that curve
formula from the control points, including "
gnuplot
",
"
fudgit
", "
mathematica
", and "
matlab
", as well as many more mathematical software packages.
The following is one method you can use to generate the formula from four
control points using "
gnuplot
" which is a standard extra package
you can install on most linux distributions (and is available for Windows
too)...
( echo "0.0 0.2"; echo "1.0 0.9"; \
echo "0.2 0.8"; echo "0.7 0.5"; ) > fx_control.txt
( echo 'f(x) = a*x**3 + b*x**2 + c*x + d'; \
echo 'fit f(x) "fx_control.txt" via a, b, c, d'; \
echo 'print a,"*u^3 + ",b,"*u^2 + ",c,"*u + ",d'; \
) | gnuplot 2>&1 | tail -1 > fx_funct.txt
|
Control Points
|
|
|
| |
Gnuplot Fitted FX Function
|
Note that the number of parameters ('a ' to 'd '
in above) needed for curve fitting, must equal the number of control
points you provide. As such if you want five control points you need to
include another 'e ' term to the function.
If your histogram curve goes though the fixed control points
0,0 and 1,1 , you really only need two parameters
as 'd ' will be equal to '0 ', and
'c ' will be equal to '1-a-b '.
|
As you can see from the extra "
gnuplot
" generated image above,
the function generated fits the control points perfectly. Also as it generated
a "
-fx" style formula it can be used
as is as an IM argument.
For example...
convert test.png -fx "`cat fx_funct.txt`" fx_funct_curve.png
| |
|
To make it easier for users to convert control points into a histogram
adjustment function, I have created a shell script called "
im_fx_curves
" to call
"
gnuplot
", and output a nicer looking polynomial equation of the
given the control points. Gabe Schaffer, also provided a perl version (using a
downloaded "
Math::Polynomial
" library module) called "
im_fx_curves.pl
" to do
the same thing. Either script can be used.
For example here is a different curve with 5 control points...
im_fx_curves 0,0.2 0.3,0.7 0.6,0.5 0.8,0.8 1,0.6 > fx_curve.txt
|
However the FX function is very slow. But as of IM 6.4.8-9 you can now
directly pass the discovered coefficents of the fitted polynomial expression
directly into a
Polynomial
Function Method.
You can generate the comma seperated list of coefficients using "
im_fx_curves.pl
" with a
special '
-c
' option...
im_fx_curves -c 0,0.2 0.3,0.7 0.6,0.5 0.8,0.8 1,0.6 > coefficients.txt
|
For example lets apply those curves to our test image...
convert test.png -function Polynomial `cat coefficients.txt` test_curves.png
| |
|
A more practical example of this method is detailed in the advanced
"Aqua" Effects example.
Tinting Images
Uniformly Color Tinting Images
Typically tinting an image is achieved by blending the image with a color by a
certain amount. This can be done using an
Evaluate Operator or
Blend Images
techniques, but these are not simple to use.
Lucky for us a simpler method of bleading a uniform color into an image is
available by using the "
-colorize
" image operator. This operator bleands the current
"
-fill
" color,
into all the images in the current image sequence. The alpha channel
of the original image is preserved, with only the color channels being
modified.
For example lighten an image (gray scale or otherwise) we use "
-colorize
" to blend some amount
of white into the image, making it brighter without saturating the image
completely.
convert test.png -fill white -colorize 50% colorize_lighten.png
|
Similarly we can use a '
black
' fill color to darken an image.
convert test.png -fill black -colorize 50% colorize_darken.png
|
To gray both ends of the image toward the mid-tones, you would use a specific
gray fill color. The color '
gray50
' is the exact middle color of
the RGB color spectrum.
convert test.png -fill gray50 -colorize 40% colorize_grayer.png
|
The "
-colorize
"
operator also allows you to specify dissolve percentages for each of the three
color channels separately. This is useful for linearly darkening (or
lightening) an image in a special way.
One common use of the "-colorize " operator is to simply replace all the colors
in an existing image (tinting '100% ') to set the color of a shape
mask.
convert test.png -fill blue -colorize 100% colorize_shape.png
| |
|
Or by reseting the alpha channel, make a completely blank canvas..
convert test.png -fill blue -colorize 100% -alpha opaque colorize_blank.png
| |
|
However these functions can be handles faster by using
Level Adjustments by Color operator, with a single color. See also
Blank Canvases.
Midtone Color Tinting
While a "
-colorize
"
operator applies the "
-fill
" color to tint all the colors in an image linearly, the
"
-tint
" operator applies
the "
-fill
" color in such
a way as to only tint the mid-tone colors of an image.
The operator is a grayscale operator, and the color is moderated or enhanced
by the percentage given (0 to 200). To limit its effects it is also adjusted
using a a mathematical formula so that it will not effect black and white.
but have the greatest effect on mid-tone colors of each color channel.
A "
-tint 100
" essentially will tint a perfect gray color so that
it becomes the current fill color. A lower value will tint it to a darker
color while a higher value will tint to a lighter shade of that color.
convert test.png -fill red -tint 40 tint_red.png
|
The green color in the test image is not a true RGB green, but a Scaled Vector
Graphics '
green
', which is only half as bright as a true green
color. As such it is also a mid-tone color, and thus is effected by the
"
-tint
" operator, becoming
darker, unlike red and blue color spots of the test image.
Also you can tint the individual color components, by using a comma separated
list of percentages. For example "
-tint 30,40,20,10
". This
however can be tricky to use and may need some experimentation to get right.
The tinting operator is perfect to adjust the results of the output of
"
-shade
", (See
Shade Overlay Highlight Images), such
as the examples in
3d Bullet Images.
|
The "-tint " operator
works by taking the color and percentages given then then adjusting the
individual colors in the image according to the "-fill " colors intensity, as per
the following formula. (see graph right)
f(x)=(1-(4.0*((x-0.5)*(x-0.5))))
A quadratic function, the result of which is used as vector for the existing
color in the image. As you can see gives a complete replacement of the color
for a pure mid-gray, with no adjustment for either white or black.
|
You can also use "
-tint
"
to brighten or darken the mid-tone colors of an image. This is sort of like a
'gamma adjustment' for images, though not exactly.
For example using a tint value greater than 100 with a '
white
'
color will brighten the mid-tones.
convert test.png -fill white -tint 130 tint_lighter.png
|
While a value less than 100 will darken colors.
convert test.png -fill white -tint 70 tint_darker.png
|
As "
-tint
" uses the color
as a 'vector' in color space, a "
-fill
" color of '
black
' will have no effect on the
result, as it produces a zero color vector.
On the same note tinting with 100% '
white
' generates no change in
the mid-tone colors of the image. Other colors darkens the midtones so that
perfect grays will become the color specified.
Of course their are other ways of color tinting images...
DIY Color Tinting
One of the biggest problems with "
-tint
" is that it is a grayscale (or vector) operator. That is it
handles each of the red,green,blue channels completely separately to each
other. That in turn means that a primary and secondary color like
'
blue
' or '
yellow
' are not effected by "
-tint
", even though all the gray
levels are.
However thanks to the "
-fx
" you can create your own tinting method, by using it to create
a color overlay so that it works in a similar way to the "
-colorize
" operator. (see
Uniformly Color Tinting Images).
For example, here I convert an image's '
intensity
' or grayscale
brightness level into a 'mid-tone tinting overlay' image to tint grayscale
midtone '
gold
'.
convert test.png \( +clone -matte -channel A \
-fx 'tint=intensity-.5; (1-4*tint*tint)*a* 1.0' +channel \
-fill gold -colorize 100% \) -composite tint_diy.png
| |
|
The final '
1.0
' is equivalent to a 100% level of tinting, so you
can reduce that figure to moderate the amount of tinting.
Note that while similar to "
-tint
" the above uses the "
-colorize
" overlay method of
modifing the image colors color vector or color channel approach, so primary
colors are also tinted '
gold
' leaving only the pure
'
white
' and '
black
' colors unchanged.
You can also change the '
intensity
' to other things like
'
lightness
', for other tinting methods.
Overlay Color Tinting
The special
Alpha Composition methods
'
Overlay
' and '
Hardlight
' were actually designed
with color (and pattern) tinting in mind. These compose methods also will
replace mid-tone grays leaving black and white highlights in the image alone.
For example here I quickly generate a colored overlay image, and compose it
to tint the original image.
convert test.png \( +clone +matte -fill gold -colorize 100% \) \
-compose overlay -composite tint_overlay.png
| |
|
As you can see the alpha composition does not preserve any transparency of the
original image, requiring the use of a second alpha composition operation to
fix this problem.
convert test.png \
\( +clone +matte -fill gold -colorize 100% \
+clone +swap -compose overlay -composite \) \
-compose SrcIn -composite tint_overlay_fixed.png
| |
|
Using '
Overlay
' is much more
linear form of tinting than the quadratic function used above, and like
"
-tint
" is applied to each
channel of the image separately such that primary and secondary colors are
also left unchanged. The 'SVG green' color is of course effected as it is a
half bright green.
Also no adjustment control is provided by this alpha composition method, so if
you want to control the level of tinting, you will need to adjust the
overlay image transparency before applying the tint.
Of course unlike the other tinting methods I have shown so far, you are not
limited to tinting a simple color, but can apply a tint using an image, or
tile pattern.
convert test.png \
\( -size 150x100 tile:tile_disks.jpg \
+clone +swap -compose overlay -composite \) \
-compose SrcIn -composite tint_overlay_pattern.png
| |
|
This however is getting outside the scope of basic color handling so I'll
leave image tinting at that.
|
The alpha composition method 'HardLight ' will produce the same results as 'Overlay ' but with the source and
destination images swapped.
This could have been used instead of the "+swap " in the last
few examples.
|
Global Color Modifiers
Modulate Brightness, Satuartion, and Hue
The "
-modulate
" operator is special
in that it modifies an image in the special HSB (hue-saturation-brightness)
colorspace. It converts each color pixel
in into this color space and modifys it and converts it back to its original
color space.
It takes three values (though later values are optional) as a percentage such
that 100 will make no change to an image. For example..
convert rose: -modulate 100,100,100 mod_noop.gif
| |
|
The first value,
brightness is a multiplier of the images overall
brightness.
convert rose: -modulate 0 mod_bright_0.gif
convert rose: -modulate 50 mod_bright_50.gif
convert rose: -modulate 80 mod_bright_80.gif
convert rose: -modulate 100 mod_bright_100.gif
convert rose: -modulate 150 mod_bright_150.gif
convert rose: -modulate 200 mod_bright_200.gif
|
Note that while a brightness argument of '
0
' will produce a pure
black image, you can not produce a pure white image using this operator on its
own.
The second value
saturation is also a multiplier adjusting the overall
amount of color that is present in the image.
convert rose: -modulate 100,0 mod_sat_0.gif
convert rose: -modulate 100,20 mod_sat_20.gif
convert rose: -modulate 100,70 mod_sat_70.gif
convert rose: -modulate 100,100 mod_sat_100.gif
convert rose: -modulate 100,150 mod_sat_150.gif
convert rose: -modulate 100,200 mod_sat_200.gif
|
A saturation of '
0
' will produce a grayscale image, as was
exampled in
Converting Color to Gray-Scale above.
The gray however mixes all three color channels equally, as defined by the HSB
colorspace. Small values produce more 'pastel' colors, while values larger
than '
100
' will produce more cartoon-like colorful images.
The final value,
Hue, rotates the colors of the image, in a cyclic
manner.
convert rose: -modulate 100,100,0 mod_hue_0.gif
convert rose: -modulate 100,100,33.3 mod_hue_33.gif
convert rose: -modulate 100,100,66.6 mod_hue_66.gif
convert rose: -modulate 100,100,100 mod_hue_100.gif
convert rose: -modulate 100,100,133.3 mod_hue_133.gif
convert rose: -modulate 100,100,166.6 mod_hue_166.gif
convert rose: -modulate 100,100,200 mod_hue_200.gif
|
As you can see a value of '
33
' produces a negative, or
counter-clockwise rotation of all the colors by 60 degrees, effectivally
mapping the red to blue, blue to green, and green to red. Using values of
'
0
' or '
200
' produces a compete 180 degree negation
of the colors, without negating the brightness of the image. A value of
'
300
' will produce a 360 degree in color rotation resulting in no
change to the image.
These type of operations and more can be applied using advanced
Color Space techniques, such as demonstrated
in
Combining non-RGB Channel Images,
but for basic 'modulation' of an image the above simplifies things.
Modulate Problems and Alternatives
The biggest problem with "
-modulate
" when handing images containing a lot of 'near white'
colors. As it does its work in HSL colorscape, colors which are off white get
exaggerated. You can see this in the white leaf of the rose image above,
which shows lots of color artifacts.
This is especially a problem when dealing with JPEG image formats, as it tends
to generate off-white colors as part of its compression algorithm. For
example...
convert wedding_party_sm.jpg -modulate 85 modulate_off-white.png
|
The problem is that in HSL all the off white colors were packed into a small
'white point' of the color cones used. When brightness is then reduced the
area off-white color get expanded as the cone color space expands, causing the
off white color to generate a more colorful set of off-white colors. That is
and small variations in color are exaggerated.
The solution to this is to do the equivalent of "
-modulate
" but in the HSB
colorspace instead of HSL colorspace. In this colorspace 'white' is not a
single point, but a large 'disk', and as such off-whites, are not 'close' to
each other. As such when you reduce the brightness, the off-whites contract
equallyx, reducing the variations rather than expanding them. As such the
whites just become grayer, and not more colorful.
convert wedding_party_sm.jpg -colorspace HSB \
-channel B -evaluate multiply 0.85 +channel \
-colorspace RGB modulate_channel.png
| |
|
Another soltuion is to do the modulation of the image immediatally after
resizing, before saving it to JPEG or some other image file format. By not
saving the image to a intermedite file the modulation is performed on a higher
quality image that does not contain these small bit-depth errors (in a Q16
version of IM that is), and will thus produce the right result.
For a larger discussion of this problem see the IM Forum thread
Brightness Problem.
Recolor Matrix Operator
-recolor translate, scale, shear, or rotate image colors
(good for hue changes)
Each of the rows of the matrix represents the value assignment
for each channel in the image.
As such the first three numbers is the color formula for the
'red' channel. the next for 'green' and so on
As such the following will swap the red and blue channel color,
but leave the green channel as is.
convert rose: -recolor ' 0 0 1
0 1 0
1 0 0 ' rose_blue.png
And this example makes a grayscale image using a 2/5/3 ratio
by using the same formula for all color channels.
convert rose: -recolor ' .2 .5 .3
.2 .5 .3
.2 .5 .3 ' rose_gray_253.png
The matrix is applied such that each row represents the formula
for each channel in turn. As such the first row translates to
new_red = .2*red + .5*green + .3*blue
And so on, with all the colors being calculated before finally being
assigned back into the original image.
If a 4x4 matrix is used the transparency channel is also included
While a 5x5 matrix will also include the 'blacK' channel for CMYKA images.
Vivid colors, in a technique called Digital Velvia
From http://www.reflectiveimages.com/digitalvelvia.htm
For example this will produce a 20% vivid color image operation...
convert rose: -recolor ' 1.2 -0.1 -0.1
-0.1 1.2 -0.1
-0.1 -0.1 1.2 ' rose_vivid.png
These matrices brighten that color channel while subtracting
the colors from the other channels, making colors more vivid
in the RGB image. Each row should add to a value of 1.0 to preserve
the images overall brightness.
Note that this is not the same as using -modulate to increase an images
color saturation by 20%.
Replacing Colors in Images
ImageMagick naturally provides a number of options to replacing a specific and
near match colors with another color. This is great when dealing with icons
and 'bitmap' type images that contain very few colors, but tends to fail when
dealing with images containing shades of colors or anti-aliasing edge pixels.
Basically you need to remember that colors are replaced by a single shade. So
if you replace a set or neighbourhood of colors all those colors replaced by
one color and not a range of colors, that matches the original. That is not
to say it is imposible to do a shaded color replacement, just not simple to do
at this time.
Even so as the GIF image does not allow semi-transparency, replacing colors in
this way is a good method for controlling GIF background transparency (See
GIFs on a background pattern for examples)
The other aspect is that while you can map all 'close colors' to a given
colormap, using
Pre-Defined Color Maps, you
can not currently do a global remapping of one set of colors to another
completely different set. A short comming that may change in a future version
of IM.
With that caveat, lets look at the ways IM does provide to replace specific
colors with another color, one color at a time.
Replace a Specific Color
The "
-opaque
" and
"
-transparent
"
operators are designed for replacing one color in an image with another.
For example to replace a '
blue
' color with say '
white
'
you would use a command like this...
convert balloon.gif -fill white -opaque blue balloon_white.gif
| |
|
Basically any color that was 'blue' has been replaced with the current
"
-fill
" color.
However as of IM v6.2.7, this operator limited by the -channel setting. As
such to convert a color (say blue) to transparency you will need to specify a
"
-channel
" to include
the alpha channel in the output changes, You will also need to ensure the
image has a 'matte' or
alpha channel enabled.
convert balloon.gif -alpha set -channel RGBA \
-fill none -opaque blue balloon_none.gif
| |
|
Because replacing a color with transparency is such a common operation the
above has its own special replace with transparency operator "
-transparent
".
convert balloon.gif -alpha set -transparent blue balloon_trans.gif
| |
|
As of IM version 6.3.7-10, the 'plus' versions of these operators invert the
color selection. That is the colors that do NOT match the given color will be
replaced. For example here I replace any color that is NOT black, with white,
leaving just the pure black borders of the image.
convert balloon.gif -fill white +opaque black balloon_borders.gif
| |
|
This may not seem like much, but when you combine it with a
Fuzz Factor see below, this becomes a very powerful tool.
|
Before IM v6.3.7-10, the inverse operation required the use of some
trickiness using image masks. Basically you replace the color you want to
preserve with transparency, then "-colorize " all the other
colors to the desired color to create an overlay mask. This is then
overlaid on the original image to 'mask out' the colors that did not match!
convert balloon.gif \
\( +clone -matte -transparent black \
-fill white -colorize 100% \) \
-composite balloon_mask_non-black.gif
| |
|
As you can see the 'plus' form of the operator simplified the 'not this
color' replacement operation enormously.
|
For more advanced replacement techniques, I suggest you look at
Transparency Masking and Background
Removal.
|
Be warned that as all matching colors (especially 'fuzzy matched colors',
see below) are replaces with a single uniform color, you will not get any
anti-aliasing of the edges of the colored areas. And you will lose any an
all shaodw or other shading effects that may be present. This can have a
seriously detrimental effect to the look off any non-cartoon like images.
This type of color replacement is not designed with practical real world
images in mind, but more for image masking effects. Caution is advised.
|
The "
-opaque
" color
replacement can not replace a color with a tiled pattern. It will only replace
colors with another single specific color. However both the "
-draw
" and "
-floodfill
" color replacement
methods can (see below).
Replace using a Image Color
You can also use
Draw Color Replacement to
recolor images based on colors present in the image itself, rather than a
specific color.
convert present.gif -fill red -draw 'color 0,0 replace' present_blue.gif
| |
|
Note that I never specified the color to be replaced, only the location of the
color to be replaced. It is the color at that location that is used for
'matching' what areas is to be filled, regardless of what that color is.
You can see in the above example the problem with color replacement, the
specific color may appear in other places that you intend, giving us a line of
red pixels within the 'present' image above.
Transparency also presents no problem, though some internal parts of the image
was also made transparent just as they became red in the above...
convert present.gif -matte -fill none \
-draw 'color 0,0 replace' present_none.gif
| |
|
Note however that unlike "
-opaque
" and "
-transparent
" the
Draw Color
Replacement, does not let you invert the 'matching colors' to be replaced.
Draw also has a special
Matte Replacement, where
only the transparency of the fill color is replaced. That is you can make
all matching colors transparent, or semi-transparent, without actually
changing the color of the pixel itself. With the appropriate file format of
course.
convert present.gif -matte -fill '#00000080' \
-draw 'matte 0,0 replace' present_semi.png
| |
|
This becomes much more useful when a
Fuzz Factor is also
specified.
The biggest advantage of using "
-draw
" is that you can also replace the color with a tile pattern.
For example..
convert present.gif -tile pattern:right30 \
-draw 'color 0,0 replace' present_tile.gif
| |
|
For more advanced replacement techniques, I suggest you look at
Transparency Masking and Background
Removal.
Floodfill Draw
The
Draw Color methods also provide you with a
simple method of replacing a color by 'floodfilling'. That is, rather than
replacing ALL the matching colors within the image, you can select just the
colors which are 'connected to' or 'attached' to the specified point in the
image.
Again the specified point given sets the starting (or center) of the colors
which are to be replaced.
convert present.gif -fill red -draw 'color 0,0 floodfill' present_fill.gif
| |
|
Note that the red areas which was not 'attached' to the 0,0 pixel was note
replaced.
For background replacing that can be a problem, but the solution is just as
easy. Expand the image slightly so the floodfill can 'leak' into the image
from all directions, then remove that extra space when finished.
convert present.gif -bordercolor white -border 1x1 \
-fill red -draw 'color 0,0 floodfill' \
-shave 1x1 present_bgnd.gif
| |
|
Of course you can adjust what colors are 'matched' using the
Fuzz Factor control setting below, which is especially important for
JPEG images.
Floodfill Operator
The "
-floodfill
"
operator was added to make floodfilling slightly easier, especially when you
what to exactly specify the 'center' color for the
Fuzz
Factor color matching.
That is you not only specify the start or seed point for the flood fill, but
also the center color, of the colors you are replacing.
convert present.gif -bordercolor white -border 1x1 \
-fill red -floodfill +0+0 white \
-shave 1x1 present_floodfill.gif
| |
|
This will replace any color that is 'white' to 'red' that is directly part of
the area surrounding the seed pixel starting at +0+0.
Note that the 'seeding pixel' must itself be match the 'white' color otherwise
no action will be taken. This 'do nothing if no match' is particularly useful
to ensure that the color of the area specified is the expected color, such as
when doing a scripted color replacement.
Again if you are attempting to replace a background color, adding a border for
the "
-floodfill
" to
'leak from is a good idea, such as we did above. That border should naturally
be the same color that floodfill is replacing.
You can also floodfill with a tile pattern.
convert present.gif -bordercolor white -border 1x1 \
-tile pattern:left30 -floodfill +0+0 white \
-shave 1x1 present_pattern.gif
| |
|
Of course if the colors are not exact, as it is in the above I recommend that
you also specify a "
-fuzz
"
factor, so that nearby colors also 'match' the given color. See next
set of examples.
For more advanced replacement techniques, I suggest you look at
Transparency Masking and Background
Removal.
Fuzz Factor - Matching Similar Colors
The overall results of just selecting a single color to replace, as shown in
the previous examples is usually not very nice. The edges or areas of solid
colors generally have a mix of colors at the edge, due to anti-aliasing (See
Anti-Aliasing for more information. As such
you should avoid direct color replace if possible.
EXAMPLE: floodfill
You can improve the selection of the area being recolored, by setting a
"
-fuzz
" factor setting.
Here for example we tell IM that other colors 'close' to the one selected is
also OK to be replaced.
EXAMPLE: fuzzy floodfill
As you can see we now replaced even the pixels closer to the edge of the
image. This isn't perfect and replacing the backgrounds of images like this
is a difficult task. For more on this specific problem see
Re-adding Transparency to an Image.
The fuzz factor, technically represents a 'similarity' match in
multi-dimensional spherical distance between colors, using whatever color
space the image is using.
Well okay lets try that in plain English. You have a specific color. Another
color will be treated as being same as the first color if the difference
between these two colors is less than the currently fuzz factor setting.
A "
-fuzz
" setting of
'
200
' represents a distance of 200 units in the current color
depth of the IM being used, for a IM Q16 (16 bit quality for color store)
this is quite small, for a IM Q8 this is VERY large, and will cause a lot of
colors to match each other.
Here for example I change all the colors that are within 3000 color units of
'blue ' to white. With my Q16 ImageMagick programs, that
represents about the distance from 'blue to 'navy
blue ' (about 25% as a percentage, see below).
convert colorwheel.png -fuzz 30000 -fill white -opaque blue opaque_blue.jpg
| |
|
To make this easier to understand here I invert the matched colors
turning the unmatched colors to white.
convert colorwheel.png \
-fuzz 30000 -fill white +opaque blue \
opaque_blue_not.png
| |
|
|
If your IM is older than version 6.3.7-10 when the 'plus' form of the
"-opaque " operator was
added, you can use this masking method to invert the result of the color
match...
convert colorwheel.png \
\( +clone -fuzz 30000 -transparent blue \
-fill white -colorize 100% \) \
-composite opaque_blue_inv.png
| |
|
|
|
As a matter of interest, in a IM with a Q8 compilation setting, a
"-fuzz " factor of 256
(28) will make the colors 'black ' and
'blue ' the same. For a IM with a Q16 setting this number is
65536 (216).
To make 'blue ' and 'red ' colors match this
number must be multiplied by the square root of 2, or 362 for IM Q8,
and with 92682 for IM Q16.
Finally to make all colors match (eg colors 'black ' and
'white ') you will need to multiply by the square root of 3.
In other words, a fuzz factor setting of 444 for IM Q8 and 113512 for IM
Q16.
|
As you can see from the above formulas, direct color distances is definitely
not a nice way of setting the fuzz factor to use, as it is also dependant on
exactly what compile time
Quality Setting is
used.
Setting the "
-fuzz
" factor
as a percentage, makes its use a lot simpler. In this case
'
100%
' represents a large enough fuzz factor to cover all colors.
That is it represents the color distance from '
black
' to
'
white
', across the 3 dimensional diagonal of the RGB color cube.
To demonstrate lets change 90% of all the colors closest to
'white ', white. This should result in only the last 10% colors
near 'black ' on the image, as black is on the opposite side of
the RGB color cube.
convert colorwheel.png -fuzz 90% -fill white -opaque white opaque_w90.jpg
| |
|
Note that as the 90% represents a sphere of colors around 'white' in RGB color
space, this is not the same as replacing the colors which are not within a 10%
sphere of black.
convert colorwheel.png -fuzz 10% -fill white +opaque black opaque_k10.jpg
| |
|
As you can see 10% sphere of colors near the black is much more uniform, than
selecting a 90% sphere of the colors around white.
|
A "-fuzz " factor of
100%, equates to the RGB color cube distance from 'black ' to
'white '. From this we can calculate that a percentage of about
57.7% is the distance between 'black ' and 'blue ',
and 81.6% is the distance from 'blue ' to 'red ' or
from either of those colors to 'white '.
In summary, anything larger than about 25%, (just short of the RGB distance
from 'blue ' to 'navy blue ' represents a very
large color change.
|
To demonstrate the color distances more, lets use a progressively larger fuzz
factor percentage around the blue colors...
convert colorwheel.png -fuzz 10% -fill white -opaque blue opaque_b10.jpg
convert colorwheel.png -fuzz 25% -fill white -opaque blue opaque_b25.jpg
convert colorwheel.png -fuzz 57% -fill white -opaque blue opaque_b57.jpg
convert colorwheel.png -fuzz 81% -fill white -opaque blue opaque_b81.jpg
convert colorwheel.png -fuzz 95% -fill white -opaque blue opaque_b95.jpg
|
From this you can clearly see that it isn't '
black
', or
'
white
' that is the most distant color from '
blue
',
but that it is actually '
yellow
' that is most distant within RGB
color space.
Also not that a 81% color difference will juts miss matching a pure
'
red
' color, however while pure red does not match almost all of
the other reds do. That is again due the to 'sphereical' nature of the color
matching. The moral is that you are probably better of either using multiple
small "
-fuzz
" factored
matches or a smaller 'inverted match', that a large value.
Color matching is actually much more 'natural if the image was stored using
some other color scheme than RGB, such as YIQ. The formula is still the same,
just using a different colorspace. Similarly for other color spaces.
How to use YIQ or even CMYK with opaque tests ????
Colors do not seem to map correctly in mathcing to images in a different
colorspace.
Using a "
-fuzz
" factor
becomes more complicated when matching involves transparent and
semi-transparent colors, and recent work (for IM version 6.2.6-2) has adjusted
the comparison algorithm so that fully-transparent colors will always match
as being the same, no matter what other color components are present.
Comparing semi-transparent colors will results in the distance between the RGB
color components being divided by amount of transparency involved, as such
semi-transparent colors are thought of by IM as being closer than their
fully-opaque equivalents.
This improves comparisons between image with transparencies, and also
color reduction for images with some semi-transparency, with less
semi-transparent colors being generated in color reductions.
The "
-fuzz
" operator effects
just about any operator which compares specific colors within an image. This
includes: "
-opaque
",
"
-transparent
",
"
-floodfill
", "
-trim
", "
-deconstruct
", "
-layer
", "
-draw 'color'
", "
-draw 'matte'
", and probably others.
Full Color Map Replacement
FUTURE: Replace all the colors in one color map to another.
Suggestions as to how is welcome, perhaps using the ideas presented in
Dithering with Symbols.
Recoloring Images with Gradients
While you can recolor images using the various histogram color adjustments
shown above, there is another technique for recoloring images based on color
lookups of pre-prepared color gradients.
Color Lookup Tables
A common requirement of a image processing tool is the ability to replace the
whole range of colors, from a pre-prepared table of colors. This allows you to
convert images of one set of colors (generally gray-scale) into completely
different set of colors, just by looking up its replacement color from a
special image known as a Color Lookup Table (or color LUT).
Of course you do need a 'Look Up Table' image from which to read the
replacement colors. For these first few examples, I choose to use a vertical
gradient of colors for the LUT so that the IM "
gradient:
" generator can be used to
simplify the generation of the 'color lookup table'.
Well so much for the theory. Let try it out by recoloring a simple
gray-Scale Plasma image, replacing the
grayscale with a dark-blue to off-white gradient of colors.
convert -size 100x100 plasma:fractal -virtual-pixel edge -blur 0x5 \
-shade 140x45 -normalize \
-size 1x100 xc:black -size 9x100 gradient: \
+append gray_image.jpg
convert -size 10x100 gradient:navy-snow gradient_ice-sea.png
convert gray_image.jpg gradient_ice-sea.png -clut gray_recolored.jpg
|
The "
-clut
" operator
takes two images. The first is the image to replace color values in, the
second is a gradient image that is either a single row, or a single column.
|
The "-clut " operator was
added to IM v6.3.5-8.
|
If your IM is too old to understand the the "
-clut
" operator or you want to do
something out of the ordinary, such as a 2 dimensional color lookup table,
then you can roll your own using the
General DIY
Operator, FX. For example here is a slow, but equivalent command to the
above.
convert gray_image.jpg gradient_ice-sea.png \
-fx 'v.p{0,u*v.h}' gray_recolored_fx.jpg
| |
|
The problem is that even for a simple process such as the above the "
-fx
" operator is very slow, and has
to be designed specifically for either a row or column LUT. But it does work.
The LUT does not have to be very large. For example here we use a very small
LUT, with a very limited number of colors.
convert -size 1x6 gradient:navy-snow gradient_levels.png
convert gray_image.jpg gradient_levels.png -clut gray_levels.jpg
|
I enlarged the gradient image for the web page display above, otherwise it
would be too small to see properly. The LUT is in actual fact only 6 pixels in
size. However if you look at the result you will see that the Color Lookup
Operator smoothes out those 6 colors into a smooth gradient.
What is happening is that IM is doing an
Interpolated Lookup of the LUT image. That is, instead of just picking
the color found, it does a weighted average of all the nearby colors to better
represent the LUT. In this particular case, it used the default '
Bilinear
' setting that just links each
colored pixel together with linear line segments.
Different "
-interpolate
" settings generate different levels of smoothing of
the colors when using a very small color LUT. Here for example I show a
various type of interpolated smoothing of the LUT colors.
convert gray_image.jpg gradient_levels.png \
-interpolate Integer -clut gray_levels_integer.jpg
convert gray_image.jpg gradient_levels.png \
-interpolate NearestNeighbor -clut gray_levels_nearest.jpg
convert gray_image.jpg gradient_levels.png \
-interpolate Average -clut gray_levels_average.jpg
convert gray_image.jpg gradient_levels.png \
-interpolate BiLinear -clut gray_levels_bilinear.jpg
convert gray_image.jpg gradient_levels.png \
-interpolate BiCubic -clut gray_levels_bicubic.jpg
convert gray_image.jpg gradient_levels.png \
-interpolate Spline -clut gray_levels_spline.jpg
|
Integer
|
Nearest Neighbor
|
Average
|
BiLinear
|
BiCubic
|
Spline
|
The '
Integer
' and '
NearestNeighbor
' settings are
special in that they do no smoothing colors at all. That is no new 'mixed
colors' will be added,
only the exact color values present will be used
used to color a grayscale image. However note how the lookup of the colors are
differ between the two. It is a subtle difference but important.
The '
Average
' setting on the
other hand also generated bands of color but only using a mix of the colors,
resulting in one less color than the size of the color lookup table image.
This type of color 'banding' (or
Blocking
Artifacts) is actually rather common for geographic maps, and temperature
graphs, as it gives a better representation of the exact shape of the map.
The sharp boundary edges being known as iso-lines. Adding a slight one pixel
Blur to the final image can improve the look
of those edges, making it look a little smoother, without destroying the color
banding.
The '
BiLinear
' setting will also
generate banding but only in the form of sharp gradient changes, as will
'
BiCubic
' to a lesser extent.
This is easily seen in the above.
To avoid this problem you would normally use much longer LUT to produce a
larger range of intermediate colors. Ideally this should cover the full range
of possible intensity values. For ImageMagick Q16 (compiled with 16 bit
quality) that requires a LUT to have a height of 65536 pixels. However thanks
to
Pixel Interpolation, a LUT gradient
image of 500 pixels or more is usually good enough for re-coloring most images
quite well.
Note that the vertical gradient LUT used in the above examples appears
upside-down to our eyes, as the black or '
0
' index is at the top
of the image. Normally we humans prefer to see gradients with the black level
at the bottom (thanks to our evolutionary past).
If you rather save the gradient image the 'right way up' you can "
-flip
" the image as you reading it
in. For example lets try a more complex LUT, flipping the vertical gradient
before using it on the image.
convert -size 1x33 gradient:wheat-brown gradient:brown-lawngreen \
gradient:dodgerblue-navy -append gradient_planet.png
convert gray_image.jpg \
\( gradient_planet.png -flip \) -clut gray_planet.jpg
|
As you can see for a vertical gradient, flipping it before using makes
a lot of sense.
For more examples of generating gradients see
Gradients of Color.
You may also be interested in a way of tiling greyscale images using a image
for each grey level, which can produce even better 'map' like images. See
Dithering with Patterns.
Function to LUT Conversion
These pre-prepared "Lookup Table Images" (or LUTs) can also be used to greatly
increase the speed of very complex and thus slow "
-fx
" operations, so instead of IM
interpreting the functional string 3 or 4 times per pixel, it can do a much
faster lookup of the replacement color.
The procedure for doing this is quite straight forward, either apply the
function to a unmodified linear gradient, or replace the '
u
' in
the function with the value '
(i/w)
' for a row lut image, or
'
(j/h)
' for a column lut image.
For example, in the advanced
'Aqua'
Effects example, I used a complex "
-fx
" function to adjust the gray-scale output of "
-shade
". Also as this gray-scale
adjustment is also overlaid onto a 'DodgerBlue' shape, there is no reason why
the results of both of these operators could not be combined into a single
gradient lookup table.
That is we generate a LUT from the "
-fx
" formula and the color overlay. Also for these examples
I decided to generate a single row of pixels rather than a column as I did
previously.
convert -size 1x512 gradient: -rotate 90 +matte \
-fx '3.5u^3 - 5.05u^2 + 2.05u + 0.3' \
-size 512x1 xc:DodgerBlue -compose Overlay -composite \
aqua_gradient.png
|
This pre-generated LUT can now be applied to the shaded shape much quicker
at the minimal cost for the storage of a small image.
convert -font Candice -pointsize 72 label:A -trim +repage -negate \
\( +clone -blur 0x8 -shade 110x45 -normalize \
aqua_gradient.png -clut \) \
+matte +swap -compose CopyOpacity -composite \
aqua_font.png
|
WARNING: the above is incomplete (edges have not been darkened)
|
|
As you can see, the result is very effective, and once appropraite LUT
gradient has been generated, you can use the same gradient over and over.
Color Replacement with Transparency
The "
-clut
" operator is
controlled by the "
-channel
" setting, and in reality it only replaces the individual
channel values within the image.
That means that normally each individual channel of the source image is used to
'lookup' the replacement value for just that channel from the color lookup
table. That includes the alpha/matte channel which is usually very
inconvenient, and difficult to apply.
Typically the "
-clut
"
operator is used to either colorize a gray-scale source image, (see previous
examples), OR it is used to do a histogram adjustment of a color image using
a gray-scale CLUT (Color Lookup Table).
As of IM v6.4.9-8, if a "
-channel
" setting specifies that you are wanting to replace/adjust
the alpha channel of an image (an '
A
' is present), and the source
or CLUT image has no alpha/matte channel defined, then IM will assume that you
are doing a color replacement of a gray-scale, and will act accordingally.
For example, here I generate a simple blurred triangle, which I can then color
using a Color Lookup Table that includes transparency. I did not flip the
CLUT image so the black replacement will be at the top and white replacement
at the bottom.
convert -size 100x100 xc: -draw 'polygon 50,10 10,80 90,80' \
-blur 0x10 blurred_shape.jpg
convert -size 1x5 xc:none \
-draw 'fill red point 0,2' \
-draw 'fill yellow rectangle 0,0 0,1' gradient_border.png
convert blurred_shape.jpg -alpha off gradient_border.png \
-channel RGBA -interpolate integer clut_shape.png
|
Remember the above will only work as expected if the gray-scale image has no
alpha channel (turned off using either "
-alpha off
" or "
+matte
"), and you specify that you
also want to lookup alpha channel values (using "
-channel RGBA
").
The other special case is if you are modifying the alpha channel of some
image, but this time the you only give a gray scale lookup table (no alpha
channel) but you again specified alpha channel replacement. IM will assume
you want to use the gray-scale as a histogram adjustment for the alpha
channel.
For example here I generated triangle from colored tile, But I want to roughly
feather its outline.
convert -size 100x100 xc:none -draw 'polygon 50,10 10,80 90,80' \
tile_disks.jpg -compose In -composite shape_triangle.gif
convert shape_triangle.gif -channel A -blur 0x10 +channel shape_blurred.png
convert -size 1x50 gradient: xc:black -append -flip \
-sigmoidal-contrast 6x0% feather_histogram.jpg
convert shape_blurred.png \( feather_histogram.jpg -alpha off \) \
-channel A -clut shape_feathered.png
|
Note that I ensure that the CLUT image does not have a alpha channel by using
a "
-alpha off
" operator
after reading just that image in.
The 'black' halo in the intermedite image is caused by the "
-blur
" operation making the
fully-transparent areas surrounding the triangle visible. As fully-transparent
has an undefined color, IM defaults to black. The CLUT image itself was
designed to ensure that any pixel which was less than 50% transparent will be
turned fully-transparent, effectively making the previously fully transparent
parts of the image, transparent again.
For demonstration purposes I overdo the initial 'blur', then over-correct the
alpha channel adjustment. The result is a sever rounding of the points of the
triangle. You would typically use much smaller values for both the "
-blur
" and the "
-sigmoidal-contrast
"
alpha adjustment.
Also the above blurred-feathering method, will add undefined semi-transparent
pixels on concave internal facing corners of a mask image. This problem
however could be solved by masking the image with a thresholded mask of the
original outline to ensure no pixel that was fully-transparent in the original
image is added as a semi-transparent pixel in the final feathered result.
Fred Weinhaus, has
implemented a blurred feathering technique in his "
feather" script,
to make it easier to use.
Miscellaneous Color Operators
Sepia Tone Coloring
A special photographic recoloring technique, "
-sepia-tone
" is basically
consists to converting the image into a grayscale, and coloring all the
mid-tones to a special brown color.
convert rose: -sepia-tone 65% sepia-tone.jpg
| |
|
The argument in the above is the 'mid-point' that is to become the closest to
the sepia-tone brown color.
The most common use of this simple color operator is probably generating
'old looking' photos.
The actual formula used is not a simple one, and one I have not been able to
figure out myself.
Solarize Coloring
To "
-solarize
" an
image is to basically 'burn' the brightest colors black. The brighter the
color, the darker the solarized color is. This happens in photography when
chemical film is over exposed.
convert rose: -solarize 90% solarize.jpg
| |
|
Basically anything above the grayscale level given is negated. So if you give
a argument of '
0%
' you basically have a poorman's "
-negate
" operator.
For example here is a faked "
-solarize
" using a "
-fx
" mathematical formula.
convert rose: -fx '.9>u ? u : 1-u' solarize_fx.jpg
| |
|
This operator is particularly well suited to extracting the midtone gray
colors from images.
For example here I use very strong
Sigmoidal
Contrast operation to produce a sort of 'fuzzy' threshold at 70% gray. I
then
Solarize that to generate a 'fuzzy' spike at
that gray-scale level. Then using a level adjustment the spike is enlarged to
generate a 'filament' effect.
convert -size 10x300 gradient: -rotate 90 \
-sigmoidal-contrast 30x70% fuzzy_thres.png
convert fuzzy_thres.png -solarize 50% fuzzy_spike.png
convert fuzzy_spike.png -level 0,50% filament.png
|
ASIDE: The above images showing 'profile' graphs of the
gradient, was generated using the "im_profile
" in the IM Examples, Scripts
directory.
Note how anything that is white becomes black, while the midtone gray around
the central spike are preserved. The fuzziness and placement of the spike is
determined by "
-sigmoidal-contrast
" operator.
I call it a 'filament' is in grayscale gradient images the result looks
remarkably like glowing electrical fillaments, or lightning discharges. See
Random Flux for an example of this
effect.
This extraction of midtone grays is also put to good use in techniques for
generating
Edge Outlines from Bitmap
Shapes.
Another novel use of this operation is in determining if an image is basically
a pure black and white sketch or drawing (such as from a book), rather than a
shaded grayscale or color images, See
Determining if an image is: Pure Black and White, or Grayscale
Under Construction
More color options yet to be looked at in detail...
-cycle shift colormap (for animations of fractals???)
Thresholding/Contrasting...
-threshold Looked at in quantization as a 'simplistic dither'
Now look at it as a color operator
-black-threshold
-white-threshold
Threshold operations which only threshold half the image.
-lat low,high local adaptive thresholding???
Color maths (get the average of two or more colors)....
Example Averaging two colors... Say '#000000' and '#DDDDDD'
Generally the colors are added to images, and the result output as a
single pixel 'txt:-' image, which which the color can be extracted.
* use -resize to merge the colors
convert -size 2x1 xc:'#000000' -fill '#DDDDDD' \
-draw 'point 0,0' -resize 1x1 txt:-
* Use -average on them!
convert -size 1x1 xc:'#000000' xc:'#DDDDDD' \
-average txt:-
Or for a lot of colors you can use the 'Box' resize filter
convert rose: -filter Box -resize 1x1\! txt:
# ImageMagick pixel enumeration: 1,1,255,RGB
0,0: (145, 89, 80) #915950
* Use -fx to apply whatever formula you want
convert -size 1x1 xc:'#000000' xc:'#DDDDDD' \
-fx '(u+v)/2' txt:-
With a ImageMagick API the results can be more directly retrieved from the
image.
Chromaticity Color Points???
–white-point x,y
–red-primary x,y
–green-primary x,y
–blue-primary x,y