Class PaletteFactory

java.lang.Object

org.apache.commons.imaging.palette.PaletteFactory

public class PaletteFactory
extends Object

Factory for creating palettes.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static final class	PaletteFactory.DivisionCandidate

Field Summary

Fields

Modifier and Type	Field	Description
static final int	COMPONENTS
private static final Logger	LOGGER

Constructor Summary

Constructors

Constructor	Description
PaletteFactory()

Method Summary

Modifier and Type	Method	Description
int	countTransparentColors(BufferedImage src)
int	countTrasparentColors(int[] rgbs)
private void	divide(List<ColorSpaceSubset> v, int desiredCount, int[] table, int precision)
private PaletteFactory.DivisionCandidate	divideSubset2(int[] table, ColorSpaceSubset subset, int precision)
private List<PaletteFactory.DivisionCandidate>	divideSubset2(int[] table, ColorSpaceSubset subset, int component, int precision)
private PaletteFactory.DivisionCandidate	finishDivision(ColorSpaceSubset subset, int component, int precision, int sum, int slice)
private int	getFrequencyTotal(int[] table, int[] mins, int[] maxs, int precision)
boolean	hasTransparency(BufferedImage src)
boolean	hasTransparency(BufferedImage src, int threshold)
boolean	isGrayscale(BufferedImage src)
Palette	makeExactRgbPaletteFancy(BufferedImage src)	Builds an exact complete opaque palette containing all the colors in src, using an algorithm that is faster than makeExactRgbPaletteSimple(BufferedImage, int) for large images but uses 2 mebibytes of working memory.
SimplePalette	makeExactRgbPaletteSimple(BufferedImage src, int max)	Builds an exact complete opaque palette containing all the colors in src, and fails by returning null if there are more than max colors necessary to do this.
Palette	makeQuantizedRgbaPalette(BufferedImage src, boolean transparent, int max)	Builds an inexact possibly translucent palette of at most max colors in src using the traditional Median Cut algorithm.
Palette	makeQuantizedRgbPalette(BufferedImage src, int max)	Builds an inexact opaque palette of at most max colors in src using a variation of the Median Cut algorithm.
private int	pixelToQuantizationTableIndex(int argb, int precision)

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

LOGGER

private static final Logger LOGGER

COMPONENTS

public static final int COMPONENTS

See Also:

• Constant Field Values

Constructor Details

PaletteFactory

public PaletteFactory()

Method Details

countTransparentColors

public int countTransparentColors(BufferedImage src)

countTrasparentColors

public int countTrasparentColors(int[] rgbs)

divide

private void divide(List<ColorSpaceSubset> v,
 int desiredCount,
 int[] table,
 int precision)

divideSubset2

private PaletteFactory.DivisionCandidate divideSubset2(int[] table,
 ColorSpaceSubset subset,
 int precision)

divideSubset2

private List<PaletteFactory.DivisionCandidate> divideSubset2(int[] table,
 ColorSpaceSubset subset,
 int component,
 int precision)

finishDivision

private PaletteFactory.DivisionCandidate finishDivision(ColorSpaceSubset subset,
 int component,
 int precision,
 int sum,
 int slice)

getFrequencyTotal

private int getFrequencyTotal(int[] table,
 int[] mins,
 int[] maxs,
 int precision)

hasTransparency

public boolean hasTransparency(BufferedImage src)

hasTransparency

public boolean hasTransparency(BufferedImage src,
 int threshold)

isGrayscale

public boolean isGrayscale(BufferedImage src)

makeExactRgbPaletteFancy

public Palette makeExactRgbPaletteFancy(BufferedImage src)

Builds an exact complete opaque palette containing all the colors in src, using an algorithm that is faster than makeExactRgbPaletteSimple(BufferedImage, int) for large images but uses 2 mebibytes of working memory. Treats all the colors as opaque.

Parameters:

src - the image whose palette to build

Returns:

the palette

makeExactRgbPaletteSimple

public SimplePalette makeExactRgbPaletteSimple(BufferedImage src,
 int max)

Builds an exact complete opaque palette containing all the colors in src, and fails by returning null if there are more than max colors necessary to do this.

Parameters:

src - the image whose palette to build

max - the maximum number of colors the palette can contain

Returns:

the complete palette of max or less colors, or null if more than max colors are necessary

makeQuantizedRgbaPalette

public Palette makeQuantizedRgbaPalette(BufferedImage src,
 boolean transparent,
 int max)
                                 throws ImagingException

Builds an inexact possibly translucent palette of at most max colors in src using the traditional Median Cut algorithm. Color bounding boxes are split along the longest axis, with each step splitting the box. All bits in each component are used. The Algorithm is slower and seems exact than makeQuantizedRgbPalette(BufferedImage, int).

Parameters:

src - the image whose palette to build

transparent - whether to consider the alpha values

max - the maximum number of colors the palette can contain

Returns:

the palette of at most max colors

Throws:

ImagingException - if it fails to process the palette

makeQuantizedRgbPalette

public Palette makeQuantizedRgbPalette(BufferedImage src,
 int max)

Builds an inexact opaque palette of at most max colors in src using a variation of the Median Cut algorithm. Accurate to 6 bits per component, and works by splitting the color bounding box most heavily populated by colors along the component which splits the colors in that box most evenly.

Parameters:

src - the image whose palette to build

max - the maximum number of colors the palette can contain

Returns:

the palette of at most max colors

pixelToQuantizationTableIndex

private int pixelToQuantizationTableIndex(int argb,
 int precision)