Performs the
Median Cut color quantization algorithm
for a given list of colors.
Supported image types
The input image must implement
RGB24Image
.
Usage example
The following code snippet uses the default settings with a palette of 256 entries.
MedianCutQuantizer quantizer = new MedianCutQuantizer();
quantizer.setInputImage(image);
quantizer.setPaletteSize(256);
quantizer.process();
PixelImage quantizedImage = quantizer.getOutputImage();
If you want to combine Median Cut quantization with error diffusion dithering to
improve the visual quality of the output, try the
ErrorDiffusionDithering
class.
However, note that noise is introduced into the image with dithering methods so
that the resulting image may not be suitable for automatic processing.
Credits
The Median Cut algorithm was designed by
Paul Heckbert.
He described it in the article
Color image quantization for frame
buffer display. Comput. Graphics 16(3), 1982, 297 - 304.
CiteSeer
page of the article.
DEFAULT_METHOD_REPR_COLOR
public static final int DEFAULT_METHOD_REPR_COLOR
METHOD_REPR_COLOR_AVERAGE
public static final int METHOD_REPR_COLOR_AVERAGE
Constant value for a method of determining the representative color
for a set of colors by computing the average of all samples for each
of the three components red, green and blue.
#getMethodToDetermineRepresentativeColors
#setMethodToDetermineRepresentativeColors
METHOD_REPR_COLOR_MEDIAN
public static final int METHOD_REPR_COLOR_MEDIAN
Constant value for a method of determining the representative color
for a set of colors by picking the median value of all samples for each
of the three components red, green and blue.
#getMethodToDetermineRepresentativeColors
#setMethodToDetermineRepresentativeColors
METHOD_REPR_COLOR_WEIGHTED_AVERAGE
public static final int METHOD_REPR_COLOR_WEIGHTED_AVERAGE
Constant value for a method of determining the representative color
for a set of colors by computing the weighted average of all samples for each
of the three components red, green and blue.
Weighted means that each color is multiplied by the number of times it occurs
in the input image.
The values of samples multiplied by their frequency are then divided by the total
number of times the colors appear in the image.
#getMethodToDetermineRepresentativeColors
#setMethodToDetermineRepresentativeColors
doNotMap
private boolean doNotMap
maxValue
private int maxValue
outputTruecolor
private boolean outputTruecolor
paletteSize
private int paletteSize
createLeafList
public MedianCutNode[] createLeafList()
Creates a linear list of leaf nodes.
Assumes that
findPalette()
was successfully run before.
createPalette
public Palette createPalette()
Creates a palette with the representative colors of all leaf nodes.
Assumes that
findPalette()
was successfully run before.
- createPalette in interface RGBQuantizer
- palette with all representative colors
findAllRepresentativeColors
public void findAllRepresentativeColors()
findLeafToBeSplit
private MedianCutNode findLeafToBeSplit(MedianCutNode node)
Traverses tree given by argument node and returns leaf with largest distribution
of samples for any of its three components.
findNearestNeighbor
public MedianCutNode findNearestNeighbor(int[] rgb)
For a given RGB value, searches the node in the internal node tree whose
representative color is closest to this color.
rgb
- the color for which a match is searched; the array must have at least
three entries; RGBIndex
constants are used to address the samples
findNearestNeighbor
public int findNearestNeighbor(MedianCutNode[] nodes,
int red,
int green,
int blue)
For each node in the argument array computes the distance between the
representative color of that node and the color given by the three
argument samples.
- index of the node with the smallest distance or -1 if the array has a length of 0
findPalette
public void findPalette()
findRepresentativeColor
private int[] findRepresentativeColor(int index1,
int index2)
Computes a representative color for a set of colors in the color list.
Returns the color as a length three int array of sample values (which can be accessed using the
index constants from
RGBIndex
.
The method of determining the color (the REPR_xxx constants from this class)
has been given to the constructor.
findRepresentativeColors
private void findRepresentativeColors(MedianCutNode node)
Calls findRepresentativeColor with node if node is a leaf.
Otherwise, recursively calls itself with both successor nodes.
getMethodToDetermineRepresentativeColors
public int getMethodToDetermineRepresentativeColors()
Returns the method (to be) used to determine the representative
color for the list of colors of a node.
Default is
DEFAULT_METHOD_REPR_COLOR
.
- the method, one of the METHOD_xyz constants
getPaletteSize
public int getPaletteSize()
Returns the number of colors in the destination image.
If output is paletted, this is also the number of entries
in the palette.
- number of colors in the destination
getTruecolorOutput
public boolean getTruecolorOutput()
Returns if this operation is supposed to generate truecolor or
paletted output.
- if truecolor images are to be generated
map
public int map(int[] origRgb,
int[] quantizedRgb)
This method maps a triplet of intensity values to its quantized counterpart
and returns the palette index of that quantized color.
The index values for the two arrays are taken from RGBIndex.
- map in interface RGBQuantizer
origRgb
- the three samples red, green and blue for which a good match is searched in the palettequantizedRgb
- will hold the three samples found to be closest to origRgb after the call to this method
- int index in the palette of the match quantizedRgb
setAllPaletteIndexValues
public void setAllPaletteIndexValues()
setMapping
public void setMapping(boolean doMap)
Defines whether process will map the input image to an output image.
If not, only the palette is determined.
setMethodToDetermineRepresentativeColors
public void setMethodToDetermineRepresentativeColors(int newMethod)
Sets the method to determine the representative color
for a list of colors.
After the algorithm has determined sets of colors that lie
closely together in color space and will be
mapped to the same color in the destination image,
the algorithm will determine that color
newMethod
- the new method, one of the METHOD_xyz constants in this class
setPaletteIndexValues
private int setPaletteIndexValues(MedianCutNode node,
int index)
Recursively visits node and its descendants, assigning ascending
palette index values to leaves via MedianCutNode.setPaletteIndex(int).
If this method is called with root and 0 as parameters, all leaves
will get a unique palette index.
setPaletteSize
public void setPaletteSize(int newPaletteSize)
Sets the number of colors that this operations is supposed to reduce
the original image to.
newPaletteSize
- the number of colors
setTruecolorOutput
public void setTruecolorOutput(boolean useTruecolor)
Lets the user specify if the output image is to be truecolor
(argument useTruecolor is true
) or paletted
(argument useTruecolor is false
).
If the color type is to be changed afterwards, use PromoteToRgb24
to convert from paletted to truecolor.
Reducing a truecolor image that uses only 256 or less colors to
a paletted image can be done with AutoDetectColorType.