|
JIU 0.12.0 Homepage | ||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectnet.sourceforge.jiu.ops.Operation
net.sourceforge.jiu.ops.ImageToImageOperation
net.sourceforge.jiu.color.dithering.ErrorDiffusionDithering
This class is used to apply error diffusion dithering to images that are being reduced in their color depth.
Works with GrayIntegerImage
and
RGBIntegerImage
objects.
For RGB images, a quantizer must be specified via setQuantizer(net.sourceforge.jiu.color.quantization.RGBQuantizer)
.
That quantizer must have been initialized (it must have searched for / given a palette that it can map to).
This class offers six predefined types of error diffusion dithering.
In addition, user-defined types can be integrated by providing a
information on how the error is to be distributed; see the
description of setTemplateData(int[][])
.
MemoryRGB24Image image = ...; // some RGB image OctreeColorQuantizer quantizer = new OctreeColorQuantizer(); quantizer.setInputImage(image); quantizer.setPaletteSize(120); quantizer.init(); ErrorDiffusionDithering edd = new ErrorDiffusionDithering(); edd.setType(ErrorDiffusionDithering.TYPE_STUCKI); edd.setQuantizer(quantizer); edd.setInputImage(image); edd.process(); PixelImage quantizedImage = edd.getOutputImage();
Gray8Image
object
is reduced to black and white using Floyd-Steinberg dithering.
Gray8Image image = ...; // some grayscale image ErrorDiffusionDithering edd = new ErrorDiffusionDithering(); edd.setGrayscaleOutputBits(1); edd.setInputImage(image); edd.process(); PixelImage ditheredImage = edd.getOutputImage(); // if you need something more specific than PixelImage: BilevelImage output = null; // ditheredImage should be a BilevelImage... if (ditheredImage instanceof BilevelImage { // ... and it is! output = (BilevelImage)ditheredImage; }
Several sources recommend Robert Ulichney's book Digital Halftoning for this topic (published by The MIT Press, ISBN 0-262-21009-6). Unfortunately, I wasn't able to get a copy (or the CD-ROM version published by Dr. Dobb's Journal).
Field Summary | |
static int |
DEFAULT_TYPE
The default error diffusion type, to be used if none is specified by the user. |
static int |
INDEX_ERROR_DENOMINATOR
The index of the denominator of the relative part of the error of a neighbor pixel. |
static int |
INDEX_ERROR_NUMERATOR
The index of the numerator of the relative part of the error of a neighbor pixel. |
static int |
INDEX_X_POS
The index for the horizontal position of a neighbor pixel. |
static int |
INDEX_Y_POS
The index for the vertical position of a neighbor pixel. |
static int |
TYPE_BURKES
Constant for Burkes error diffusion. |
static int |
TYPE_FLOYD_STEINBERG
Constant for Floyd-Steinberg error diffusion. |
static int |
TYPE_JARVIS_JUDICE_NINKE
Constant for Burkes error diffusion. |
static int |
TYPE_SIERRA
Constant for Burkes error diffusion. |
static int |
TYPE_STEVENSON_ARCE
Constant for Burkes error diffusion. |
static int |
TYPE_STUCKI
Constant for Stucki error diffusion. |
Fields inherited from interface net.sourceforge.jiu.data.RGBIndex |
INDEX_BLUE, INDEX_GREEN, INDEX_RED |
Constructor Summary | |
ErrorDiffusionDithering()
Creates a new object of this class and set the dithering type to DEFAULT_TYPE . |
Method Summary | |
void |
process()
Quantizes the input image, distributing quantization errors to neighboring pixels. |
void |
setGrayscaleOutputBits(int numBits)
Sets the number of bits to be in the output image when a grayscale image is quantized. |
void |
setQuantizer(RGBQuantizer q)
Sets the color quantizer to be used (if the input image is a truecolor image). |
void |
setTemplateData(int[][] data)
Set information on how errors are to be distributed by this error diffusion dithering operation. |
void |
setTemplateType(int type)
Sets a new template type. |
void |
setTruecolorOutput(boolean truecolor)
When dithering an RGB input image, this method specifies whether the output will be an RGBIntegerImage
(true ) or a Paletted8Image (false ). |
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 Detail |
public static final int TYPE_FLOYD_STEINBERG
public static final int TYPE_STUCKI
public static final int TYPE_BURKES
public static final int TYPE_SIERRA
public static final int TYPE_JARVIS_JUDICE_NINKE
public static final int TYPE_STEVENSON_ARCE
public static final int DEFAULT_TYPE
public static final int INDEX_X_POS
setTemplateData(int[][])
.
public static final int INDEX_Y_POS
setTemplateData(int[][])
.
public static final int INDEX_ERROR_NUMERATOR
setTemplateData(int[][])
.
public static final int INDEX_ERROR_DENOMINATOR
setTemplateData(int[][])
.
Constructor Detail |
public ErrorDiffusionDithering()
DEFAULT_TYPE
.
Method Detail |
public void process() throws MissingParameterException, WrongParameterException
Gray8Image
(then setGrayscaleOutputBits(int)
must have been called to set a number of output bits between 1 and 7) objects and
RGB24Image
(then a quantizer must be specified using
setQuantizer(RGBQuantizer)
) objects.
process
in class Operation
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.)public void setGrayscaleOutputBits(int numBits)
Gray8Image
, only values between 1 and 7
are valid.
numBits
- the number of bits in the output imagepublic void setQuantizer(RGBQuantizer q)
q
- an object of a class implementing the RGBQuantizer interfacepublic void setTemplateData(int[][] data)
Error diffusion dithering works by quantizing each pixel and distributing the resulting error to neighboring pixels. Quantizing maps a pixel to another pixel. Each pixel is made up of one or more samples (as an example, three samples rorig, gorig and borig for the original pixel of an RGB image and rquant, gquant and bquant for the quantized pixel).
The process of quantization attempts to find a quantized pixel that is as close to the original as possible. In the ideal case, the difference between original and quantized pixel is zero for each sample. Otherwise, this quantization error is non-zero, positive or negative. Example: original pixel (12, 43, 33), quantized pixel (10, 47, 40); the error is (12 - 10, 43 - 47, 40 - 33) = (2, -4, 7). The error (2, -4, 7) is to be distributed to neighboring pixels.
The data
argument of this constructor describes how to do that.
It is a two-dimensional array of int values.
Each of the one-dimensional int arrays of data
describe
one neighboring pixel and the relative amount of the error that it gets.
That is why data.length
specifies the number of neighboring
pixels involved in distributing the error.
Let's call the pixel that was just quantized the current pixel.
It is at image position (x, y).
Each of the one-dimensional arrays that are part of data
must have a length of 4.
The meaning of these four values is now described.
The values can be accessed by the INDEX_xyz constants of this class.
These four values describe the position of one neighboring pixel and
the relative amount of the error that will be added to or subtracted
from it.
INDEX_X_POS
(0):
the difference between the horizontal position of the current pixel, x,
and the neighboring pixel; can take a positive or negative value,
or zero; exception: the y position of the current pixel is zero;
in that case, this value must be larger than zero, because
neighboring pixels that get part of the error must be to the right of
or below the current pixelINDEX_Y_POS
(1):
the difference between the vertical position of the current pixel, y,
and the neighboring pixel; must be equal to or larger than 0INDEX_ERROR_NUMERATOR
(2):
the numerator of the relative part of the error that wil be added
to this neighboring pixel; must not be equal to 0INDEX_ERROR_DENOMINATOR
(3):
the denominator of the relative part of the error that wil be added
to this neighboring pixel; must not be equal to 0data
array:
int[][] FLOYD_STEINBERG = {{ 1, 0, 7, 16}, {-1, 1, 3, 16}, { 0, 1, 5, 16}, { 1, 1, 1, 16}};Each of the one-dimensional arrays is of length 4. Accidentally, there are also four one-dimensional arrays. The number of arrays is up to the designer. The first array {1, 0, 7, 16} is interpreted as follows--go to the pixel with a horizontal difference of 1 and a vertical difference of 0 (so, the pixel to the right of the current pixel) and add 7 / 16th of the quantization error to it. Then go to the pixel at position (-1, 1) (one to the left, one row below the current row) and add 3 / 16th of the error to it. The other two one-dimensional arrays are processed just like that.
As you can see, the four relative errors 1/16, 3/16, 5/16 and 7/16 sum up to 1 (or 16/16); this is in a precondition to make sure that the error is distributed completely.
data
- contains a description of how the error is to be distributedpublic void setTruecolorOutput(boolean truecolor)
RGBIntegerImage
(true
) or a Paletted8Image
(false
).
truecolor
- true if truecolor output is wantedpublic void setTemplateType(int type)
type
- int value, one of the TYPE_xyz constants of this class
IllegalArgumentException
- if the argument is not of the TYPE_xyz constants
|
JIU 0.12.0 Homepage | ||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |