Package net.sourceforge.jiu.color.quantization

# Class OctreeColorQuantizer

java.lang.Object
net.sourceforge.jiu.ops.Operation
net.sourceforge.jiu.ops.ImageToImageOperation
net.sourceforge.jiu.color.quantization.OctreeColorQuantizer

All Implemented Interfaces:
  `RGBQuantizer`, `RGBIndex`

public class OctreeColorQuantizer extends ImageToImageOperation implements RGBIndex, RGBQuantizer
Performs the octree color quantization algorithm for a given RGB truecolor image. The quality is usually somewhat inferior to the results of `MedianCutQuantizer`. Note that you can improve the quality by applying a dithering algorithm. See `ErrorDiffusionDithering`.

### Usage example

This reduces some RGB24Image image to a 16 color paletted image:

     MemoryRGB24Image image = ...; // initialize
     OctreeColorQuantizer ocq = new OctreeColorQuantizer();
     ocq.setInputImage(image);
     ocq.setPaletteSize(16);
     ocq.process();
     PixelImage quantizedImage = ocq.getOutputImage();

### Credits

Since:
  0.6.0
Author:
  Marco Schmidt

## Field Summary

Fields
Modifier and Type
Field
Description
`private int[]`
`blueValues`
`static final int`
`DEFAULT_PALETTE_SIZE`
The default number of colors in the palette.
`private int[]`
`greenValues`
`private Palette`
`palette`
`private int`
`paletteSize`
`private int[]`
`redValues`
`private OctreeNode`
`root`

### Fields inherited from interface net.sourceforge.jiu.data.RGBIndex

`INDEX_BLUE, INDEX_GREEN, INDEX_RED`

## Constructor Summary

Constructors
Constructor
Description
`OctreeColorQuantizer()`

## Method Summary

Modifier and Type
Method
Description
`private int`
`assignPaletteIndexValues(OctreeNode node, int index)`
If node is a leaf node, this method assigns palette index values and determines the representative color, otherwise it simply recursively calls itself for all child nodes.
`Palette`
`createPalette()`
Return a Palette object with the list of colors to be used in the quantization process.
`void`
`init()`
Creates an octree and prepares this quantizer so that colors can be mapped to palette index values.
`private int`
`initOctree()`
`private void`
`initPalette(OctreeNode node, Palette palette)`
`int`
`map(int[] origRgb, int[] quantizedRgb)`
Maps an RGB color `origRgb` to one of the colors in the color map; that color will be written to `quantizedRgb` and its palette index will be returned.
`private void`
`mapImage()`
`void`
`process()`
Initializes an octree, reduces it have as many leaves (or less) as the desired palette size and maps the original image to the newly-created palette.
`private void`
`pruneOctree()`
Reduces the octree until it has as many leaves (or less) than specified by the `paletteSize` argument in the constructor
invalid reference

    #OctreeColorQuantizer(int)

.
`void`
`setPaletteSize(int newPaletteSize)`

### Methods inherited from class net.sourceforge.jiu.ops.ImageToImageOperation

`canInputAndOutputBeEqual, ensureImagesHaveSameResolution, ensureInputImageIsAvailable, ensureOutputImageResolution, getInputImage, getOutputImage, setCanInputAndOutputBeEqual, setInputImage, setOutputImage`

### Methods inherited from class net.sourceforge.jiu.ops.Operation

`addProgressListener, addProgressListeners, getAbort, removeProgressListener, setAbort, setProgress, setProgress`

### Methods inherited from class java.lang.Object

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

## Field Details

### DEFAULT_PALETTE_SIZE

public static final int DEFAULT_PALETTE_SIZE
The default number of colors in the palette. Will be used when no other value is specified via `setPaletteSize(int)`.

See Also:
  - Constant Field Values

### paletteSize

private int paletteSize

### root

private OctreeNode root

### palette

private Palette palette

### redValues

private int[] redValues

### greenValues

private int[] greenValues

### blueValues

private int[] blueValues

## Constructor Details

### OctreeColorQuantizer

public OctreeColorQuantizer()

## Method Details

### assignPaletteIndexValues

private int assignPaletteIndexValues(OctreeNode node, int index)
If node is a leaf node, this method assigns palette index values and determines the representative color, otherwise it simply recursively calls itself for all child nodes. The updated index value is returned. It is increased whenever a leaf is assigned that index value.

Parameters:
  `node` - the node of the octree that will itself (and its children) be processed
  `index` - the current index in the palette index assignment procedure
Returns:
  updated index value; may have been increased while node or its child(ren) - were assigned index values

### createPalette

public Palette createPalette()
Description copied from interface: `RGBQuantizer`
Return a Palette object with the list of colors to be used in the quantization process. That palette may be fixed or created specifically for a given input image.

Specified by:
  `createPalette` in interface `RGBQuantizer`
Returns:
  Palette object for destination image

### init

public void init() throws MissingParameterException, WrongParameterException
Creates an octree and prepares this quantizer so that colors can be mapped to palette index values. If you use `process()` you must not call this method. On the other hand, if you want to do the mapping yourself - maybe if you want to do mapping and dithering interchangeably - call this method first, then do the mapping yourself.

Throws:
  `MissingParameterException` - if parameters like the input image are missing
  `WrongParameterException` - if parameters exist but are of the wrong type

### initOctree

private int initOctree()

### initPalette

private void initPalette(OctreeNode node, Palette palette)

### map

public int map(int[] origRgb, int[] quantizedRgb)
Maps an RGB color `origRgb` to one of the colors in the color map; that color will be written to `quantizedRgb` and its palette index will be returned.

Specified by:
  `map` in interface `RGBQuantizer`
Parameters:
  `origRgb` - the color to be mapped to the best-possible counterpart in the palette; the array is indexed by the constants from `RGBIndex`
  `quantizedRgb` - the resulting color from the palette will be written to this array; it is also indexed by the constants from `RGBIndex`
Returns:
  index of the found color in the palette

### mapImage

private void mapImage()

### process

public void process() throws MissingParameterException, WrongParameterException
Initializes an octree, reduces it have as many leaves (or less) as the desired palette size and maps the original image to the newly-created palette.

Overrides:
  `process` in class `Operation`
Throws:
  `MissingParameterException` - if any mandatory parameter was not given to the operation
  `WrongParameterException` - if at least one of the input parameters was not initialized appropriately (values out of the valid interval, etc.)

### pruneOctree

private void pruneOctree()
Reduces the octree until it has as many leaves (or less) than specified by the `paletteSize` argument in the constructor
invalid reference

    #OctreeColorQuantizer(int)

.

### setPaletteSize

public void setPaletteSize(int newPaletteSize)