Dithering

In this chapter...

• Introduction
• CMYK versus RGB
• Gamma Correction

Introduction

When printing on a page, the printed dots are most often bilevel -- they produce two intensities (either "on" or "off"). Dithering is used to simulate the 256 intensity levels (* three colors) that exist on the Photon draw stream.

The printer drivers currently support the following dithering methods:

Halftone approximation (HT)

Creates a 6 * 6 matrix of pixel patterns that make a different pattern for every intensity.

QNX rendering (QR)

An improved form of halftone approximation.

Floyd-Steinberg error diffusion (FS)

A numerical-method system where the current color value is approximated by the printer dot. Any error in the approximation is then spread to the adjacent pixels.

For further information on the HT and FS techniques, see Foley et al., Computer Graphics: Principles and Practice (Addison-Wesley Publishing Company, 1991, ISBN 0-201-12110-7).

CMYK versus RGB

When drawing on the screen, the colors are often represented in RGB format. Red, Green, and Blue are called additive primaries -- they're added together on the black screen to create the desired color.

When printing on paper, we start with a blank white sheet and add inks to create the color. These inks are Cyan, Magenta, and Yellow, the subtractive primaries:

• Cyan = RGB - Red
• Magenta = RGB - Green
• Yellow = RGB - Blue

Many printers also have a black ink cartridge (abbreviated as K) that improves the quality of black printing and reduces the amount of ink required.

Gamma Correction

The colors created by the dithering process are an approximation of the RGB values on the screen. The amount of ink necessary to approximate a given color depends on the printer, the inks used, the type of the paper, and so on.

The dither.c file has fuctions for setting up the necessary structures for dithering, gamma values, and dithering RGB lines into CMYK output values.

For any print job, Halftone, QNX Rendering, or Floyd-Steinberg methods can be used. The current system isn't designed to interchange between slices.

void InitFSGammas(int mode,
				  double c_acc,
				  double m_acc,
				  double y_acc,
				  double k_acc,
				  int intensity)

void InitHTGammas( int intensity )


void InitDithers()
void ClearDiffusion(struct _doc_ctrl *c)

static int HalftoneVal(int x, int y, int c)

// FS Error diffusion
void FS_RGBToCMYK( struct _doc_ctrl *cc , int y)

// Halftone screen based
void HT_RGBToCMYK( struct _doc_ctrl *cc , int y)

int HT_PrintBits(struct _doc_ctrl *c, int color, int y)
int FS_PrintBits(struct _doc_ctrl *c, int color, int y)