KR100790616B1 - Method and apparatus for compensation for time varying nozzle misalignment in a drop on demand printhead - Google Patents

Abstract

A method and apparatus are provided for compensating for variable overlap between segments of a page width printhead system to reduce eye perceptible artifacts due to misalignment of adjacent overlapping segments. As one method, a summation means for summing and outputting an overlap signal with the current dither value in the dither matrix is employed, and the output value of the summation means is compared with the input continuous tone data value by a comparator to determine the overlapping area of the segment. It will provide an output compensation dither value that controls the nozzle. Alternatively, a software program is used to provide a compensated dither matrix. The sensing means measures the degree of overlap of the segments and provides a measurement to produce an overlap signal. The sensing means may be able to sense the temperature or relative position of the segment. The degree of overlap can be determined for various temperatures and stored in the ROM.

Inkjet, Dither Matrix, Overlap, Compensation, Printhead, Dots.

Description

METHOD AND APPARATUS FOR COMPENSATION FOR TIME VARYING NOZZLE MISALIGNMENT IN A DROP ON DEMAND PRINTHEAD}

The present invention relates to inkjet printing, and more particularly, to a method and apparatus for compensating time-varying nozzle misalignment of a printhead assembly having overlapping segments.

Various methods, systems and apparatus related to the present invention are filed and pending by the present applicant or the assignee of the present invention simultaneously with the present application, and the application number is as follows.

PCT / AU00 / 00518, PCT / AU00 / 00519, PCT / AU00 / 00520, PCT / AU00 / 00521, PCT / AU00 / 00522, PCT / AU00 / 00523, PCT / AU00 / 00524, PCT / AU00 / 00525, PCT / AU00 / 00526, PCT / AU00 / 00527, PCT / AU00 / 00528, PCT / AU00 / 00529, PCT / AU00 / 00530, PCT / AU00 / 00531, PCT / AU00 / 00532, PCT / AU00 / 00533, PCT / AU00 / 00534, PCT / AU00 / 00535, PCT / AU00 / 00536, PCT / AU00 / 00537, PCT / AU00 / 00538, PCT / AU00 / 00539, PCT / AU00 / 00540, PCT / AU00 / 00541, PCT / AU00 / 00542, PCT / AU00 / 00543, PCT / AU00 / 00544, PCT / AU00 / 00545, PCT / AU00 / 00547, PCT / AU00 / 00546, PCT / AU00 / 00554, PCT / AU00 / 00556, PCT / AU00 / 00557, PCT / AU00 / 00558, PCT / AU00 / 00559, PCT / AU00 / 00560, PCT / AU00 / 00561, PCT / AU00 / 00562, PCT / AU00 / 00563, PCT / AU00 / 00564, PCT / AU00 / 00565, PCT / AU00 / 00566, PCT / AU00 / 00567, PCT / AU00 / 00568, PCT / AU00 / 00569, PCT / AU00 / 00570, PCT / AU00 / 00571, PCT / AU00 / 00572, PCT / AU00 / 00573, PCT / AU00 / 00574, PCT / AU00 / 00575, PCT / AU00 / 00576, PCT / AU00 / 00577, PCT / AU00 / 00578, PCT / AU00 / 00579, PCT / AU00 / 00581, PCT / AU00 / 00580, PCT / AU00 / 00582, PCT / AU00 / 00587, PCT / AU00 / 00588, PCT / AU00 / 00589, PCT / AU00 / 00583, PCT / AU0 0/00593, PCT / AU00 / 00590, PCT / AU00 / 00591, PCT / AU00 / 00592, PCT / AU00 / 00584, PCT / AU00 / 00585, PCT / AU00 / 00586, PCT / AU00 / 00594, PCT / AU00 / 00595, PCT / AU00 / 00596, PCT / AU00 / 00597, PCT / AU00 / 00598, PCT / AU00 / 00516, PCT / AU00 / 00517, PCT / AU00 / 00511, PCT / AU00 / 00501, PCT / AU00 / 00502, PCT / AU00 / 00503, PCT / AU00 / 00504, PCT / AU00 / 00505, PCT / AU00 / 00506, PCT / AU00 / 00507, PCT / AU00 / 00508, PCT / AU00 / 00509, PCT / AU00 / 00510, PCT / AU00 / 00512, PCT / AU00 / 00513, PCT / AU00 / 00514, PCT / AU00 / 00515.

The above applications are referenced as cross-references in connection with the present application.

In another Applicant's application (PCT / AU98 / 00500), a series of inkjet printing apparatuses for printing at high speed across a page width by employing a new ink ejection mechanism is proposed. The device used a thermal bend actuator installed as part of the monolithic structure.

In such an apparatus, it is desirable to form a larger array of inkjet spray nozzles for application to a page width drop-on-demand printhead. Preferably, very high resolution droplet sizes are required. For example, competitive printing systems such as offset printing allow for 1600 dpi resolution. Therefore, for example, for an A4 page, to print at that resolution with a printhead that is 8 inches wide, about 12800 ink jetting nozzles are required for each color. Even assuming four standard colors, about 51000 ink jetting nozzles are required. Including six standard colors, plus fixed and infrared (IR) inks, six colors result in 76800 ink jetting nozzles. Unfortunately, it is impractical to manufacture large monolithic printheads with seamlessly continuous segments of substrate, such as silicon wafer substrates. This is inherently an increase in structure size and a substantial reduction in productivity. The problem of productivity is a well studied problem in the semiconductor industry, and the manufacture of inkjet devices sometimes uses semiconductors or similar semiconductor processing techniques. In particular, the field is widely known as Micro Electro Mechanical Systems (MEMS). A study in the field of MEMS was covered in Stom Picraux and Paul J McWhorter's November 1998 IEEE Spectrum paper "The Broad Sweep of Integrated Micro Systems."

One solution to the problem of maintaining high productivity is to manufacture very long printheads in multiple segments and have all segments either contiguous or overlapping. Unfortunately, the extremely high pitch ink ejection nozzles required in the printhead device mean that the space between adjacent printhead segments must be controlled very accurately even in the presence of thermal cycles under normal operating conditions. For example, to obtain a resolution of 1600 dpi, the nozzle-to-nozzle spacing should be about 16 μm.

The ambient conditions and operating environment of the printhead can result in thermal cycling of the printhead in the overlap area, which causes expansion and contraction of the overlap between adjacent printhead segments, which in turn results in artifacts in the resulting output image. For example, the temperature of the printhead may rise 25 ° C. higher than the ambient during operation. In addition, the assembly of the printhead may be made of a material having a different thermal characteristic than the printhead segment, which causes different thermal expansion between these components. The silicon substrate may be packaged in an elastomer having a respective coefficient of thermal expansion of ^2.6x10-6 and ^20x10-6 μm / ° C.

Artifacts are caused by the limited resolution of the printhead to represent a continuous tone image in binary form and the human eye's ability to detect 0.5% difference in color of adjacent dots in the image.

It is an object of the present invention to provide a mechanism that effectively and conveniently compensates for the relative position of overlapping printhead segments during operation.                 

According to a first aspect of the present invention, there is provided a method for controlling ejection of nozzles from overlapping segments in an ink ejection printhead composed of a plurality of overlapping printhead segments and whose spatial relationship between adjacent segments varies with time. (A) determining the degree of overlap between adjacent printhead segments, (b) generating a half toning pattern for nozzles in the overlap region of the overlapping segments, ( c) adjusting the half toning pattern as a function of the degree of overlap in the overlapping area of the printhead segment to reduce artifacts caused by the overlap of the printhead segment. A method of controlling is provided.

Preferably, the step of determining the degree of overlap is to measure the temperature of the printhead segment. The half toning pattern is preferably generated by a dither matrix or dither volume, and is changeable to add an overlap value to the current continuous tone pixel output value before using the dither matrix or dither volume. Instead of measuring the temperature, it is also possible to use the fiduciary strips on each segment and to measure the distance using interferometry to determine the relative degree of movement between the segments.

According to another aspect of the present invention, there is provided a plurality of spatially spaced and overlapping printhead segments, at least one means for measuring the degree of overlap between adjacent printhead segments, and half toning of continuous tone images. And means for adjusting said half toning means in the overlap area between said adjacent segments to reduce artifacts between adjacent printhead segments.

Means for adjusting the half toning means may include continuous tone inputs, spatial overlap inputs and binary inputs, and the half toning means may use the spatial overlap inputs to change the continuous tone inputs, thereby overlapping the overlap area of the printhead segment. Generate modified continuous tone inputs to be used in the dither matrix or look-up table of the dither volume to generate output binary values for adjustment. Means for adjusting halftones or dither matrices may be realized in hardware or by means of software employing an algorithm.

The invention is specified by the claims. The above and other advantages of the present invention will become more apparent with reference to the following description in conjunction with the accompanying drawings.

1 is a schematic diagram illustrating a pair of adjacent printhead segments in accordance with the present invention;

FIG. 2 is a diagram showing a process for printing dots from adjacent printhead segments shown in FIG. 1;

3 is a view showing a process of mixing dots between adjacent printheads according to the present invention;

4 is a view showing a variable control process of a dither matrix according to an embodiment of the present invention;                 

5 is a view showing a variable control process of a dither matrix according to another embodiment of the present invention;

6 is a diagram schematically showing an algorithm for executing a variable control process of a dither matrix according to another embodiment of the present invention.

In a first embodiment, a method is provided for compensating for relative movement of adjacent printhead segments that vary with temperature using digital processing mechanisms to adjust overlap between adjacent segments.

In the case of a printhead covering an A4 page width, ten segments will be arranged in staggered pairs with nine overlapping portions. Initial alignment of the segments can be made within 10 μm using techniques well known in the art of monolithic fabrication techniques. The width of one segment in the six-color ink apparatus is about 225 µm, assuming that the nozzles of the segments are arranged at intervals of 16 µm from each center in a vertical zigzag pattern.

In this embodiment, a temperature sensor is placed on each printhead to measure the current thermal characteristics of each printhead segment. The current temperature measurement can be used to determine the amount of overlap between adjacent printhead segments.

Alternatively, if one can assume that the segments of the printhead are sufficiently similar in physical properties and response to each other and the surrounding environment of each pair of overlapped segments is substantially the same, it is also possible to use only one temperature sensor.                 

The degree of overlap is used to provide a mechanism for controlling half toning between adjacent printhead segments. The output of the image in the present invention is assumed to be by digital half toning employing a method or technique well known in the art. Many other half toning techniques can be used, and can be found in Ulichney's paper, "Digital Half Toning," published by MIT Publishing.

As shown in FIG. 1, adjacent printhead segments 2, 3 overlap in each region 12, 13. Overlap area extends to about 40 tons (~ 1 mm) with overlap of 64 nozzles spaced at intervals of 16 μm for a resolution of 1600 dpi. In the region 10 of the segment 2, the nozzles of this segment are dedicated to ink jetting. Similarly, in the region 11 of the segment 3, the nozzles of this segment are dedicated to ink jetting. In the overlapping areas 12, 13, 'mixing' between the two printhead segments 2, 3 occurs, for example along the edge 14 the nozzles of the printhead segment 2 are in the area 12. Dedicated to printing, and likewise along the edge 15 the nozzles of the segment 3 are almost dedicated for printing. In the meantime, interpolation (which may or may not be linear) is performed between these two edges. Thus, as shown in FIG. 2, when printing a full color output on one page, one area 17 is printed exclusively by the printhead segment 10, and the other area. 18 is exclusively printed by printhead segment 11 (indicated by black dots), and region 19 consists of a mixture of nozzles of two segments. The print process may be any well known as half toning matrix as disclosed in the aforementioned references. Even if a known half-toning matrix is used, the actual printhead segment will depend on the blending ratio obtained by measuring the degree of overlap between the overlapping segments.

One such method is shown in FIG. 3. 3 shows linear interpolation in the overlapped area. In the region corresponding to the overlapped portion 12 at the edge 14, the nozzle of the printhead segment 2 is used 100%, and there is no output at the edge 7 of the printhead segment 3 in the same region. As the edge 14 of the segment 2 goes from the edge 15 of the segment 3 to the edge 15 of the segment 3, the utilization ratio of the nozzles of the region 12 gradually decreases (linearly) so that zero (0) at the edge 9 is reduced. do. On the other hand, the utilization rate of the nozzle in the area 13 increases uniformly and gradually until it reaches the edge 15. In the first embodiment where the overlap between the nozzles increases, half toning thresholds increase in the overlap area. This reduces the number of dots printed in the mixed area. Conversely, if the overlap is reduced by allowing the printhead segments to be more spaced apart than generally allowed, the dots frequency can be increased by reducing the half toning threshold.

A half toning device is shown in FIG. The half toning apparatus here has a dither matrix 25 which outputs the current dither value 26 to the summation means 27, where the summation means 27 Another input 28 is received with an overlap signal that changes positive or negative depending on the degree of overlap between adjacent segments. The comparator 30 outputs the half tone data 31 by comparing the output value 29 of the adder or adder 27 with the input continuous tone data 32. Alternatively, a device configured to subtract the data value 28 from the continuous tone data 29 before dithering will show similar results. This apparatus is shown in FIG.

As shown in FIG. 5, the output halftone data 52 is added by the adder 46 by the output 42 of the dither matrix 40 and the overlap signal 44, and then by the subtractor 50. Can be generated by obtaining the difference between the output 54 of the adder 46 and the continuous tone data 48. This is equivalent to the device of FIG. 4.

By using the apparatus as described with reference to Figs. 3 and 4, it is possible to some extent control the overlap mixing to reduce the occurrence of streaking artifacts between adjacent print head segments.

Since each overlap signal 28 can be multiplied by a calibration factor or added with a calibration offset factor, the accuracy of the position of adjacent printhead segments can also be very effectively reduced. Thus, adjacent printhead segments can be roughly disposed with one another during manufacture. The test pattern can then be printed at a known temperature to determine the degree of overlap between the nozzles of adjacent segments. Once the degree of overlap in a particular temperature range has been determined, a series of corresponding values can be written to the programmable ROM storage to provide all the offset values that apply individually to the printhead segment overlap so that they are available at any time.                 

Another embodiment of the present invention utilizes a software solution to reduce the occurrence of artifacts between overlapped segments of the printhead. A full software implementation of the dither matrix is included below, including the implementation of an algorithm for coordinating variable overlap between printhead segments. This program is written in C language. The algorithm may be written in other code by those skilled in the art with modifications within the scope of the knowledge. The technical background behind this algorithm is described below.

Dispersed dot stochastic dithering is used to reproduce continuous tone pixel values using two-level dots. Dispersive dot dithering reproduces high spatial frequencies, i.e., image details to a near limit of dot resolution, while simultaneously reproducing lower spatial frequencies at full intensity depth when spatially concentrated by the eye. Probabilistic dither matrices are designed such that there are no undesirable low frequency patterns when filled across the page.

Dot overlap can be designed using dot gain technology. The dot gain depends on the increase from the ideal intensity of the dot pattern to the actual intensity that appears when the pattern is printed. In inkjet printing, dot gain is mainly a problem by ink bleeding. Smear is a function itself by the characteristics of the ink and the print media. Pigmented ink may bleed off the surface but does not diffuse far into the medium. The dye ink can diffuse along the cellulose fiber into the medium. Surface coatings can be used to reduce bleeding.                 

Like dot gain, the effect of dot overlap is sensitive to the distribution of dots, so it is useful to model it as an ideal dot that completely fills the page without overlap. Actual inkjet dots are almost round and overlap with neighboring dots, but ideal dots can be modeled as squares. Thus, the ideal dot and the actual dot become dot gain parameters.

Dot gain is an edge effect, that is, an effect that appears along the border between printed dots and adjacent unprinted areas. The dot gain is proportional to the ratio of the edge link of the dot pattern to the area of the dot pattern. Two techniques for dot gain are distributed dot dithering and clustered dot dithering. In distributed dot dithering, the dots are distributed evenly over the area. For example, a checker board pattern is used in dots of 50% intensity. In cluster dot dithering, dots are represented by a 'colored' area and a 'colorless' border at the center, where the ratio of the 'colored' area to the 'colorless' area is equal to the intensity of the dots to be printed. . Therefore, distributed dot dithering is more sensitive to dot gain than cluster dot dithering.

Two adjacent printhead segments have numerous overlapping nozzles. In general, there will be no perfect match between corresponding nozzles of adjacent segments. At the local level, there may be ± half mismatch of nozzle spacing, which is about 8 μm at 1600 dpi. At higher levels, the number of overlapping nozzles may actually vary.                 

The first approach of smoothly mixing the output from one segment to another and across the overlap bridge consists of mixing the continuous tones input to the two segments from one segment to another across the overlap area. As an output process across the overlap region, the second segment receives a continuous tone value that is directly proportional, and correspondingly the first segment receives a value that is inversely proportional to that described above in FIG. 3. Linear or higher order interpolation may be used. The dither matrix used to dither the output through the two segments is matched at the nozzle level.

The first approach has two drawbacks. First, if the dither threshold at a particular dot position is less than the interpolated continuous tone value of the two segments, the two segments will generate dots for that position. Since the two dots overlap, the intensity determined by the two dither matrices will only be partially reproduced, which will result in a loss of overall intensity. This can be solved by ensuring that two corresponding nozzles do not produce one dot. This is either using the inverse of the dither matrix for the opponent's segment, or dithering the continuous tone values through a single dither matrix, and then probably outputting either one or the other nozzle, depending on the probability given by the current interpolation coefficients. This can be solved by assigning dots.

As a second drawback, neighboring dots printed by other segments overlap again, resulting in a loss of overall intensity.

As shown in FIG. 6, the value of each overlapped segment is represented by V _A and V _B along horizontal lines 60 and 62 as values between 0.0 and 1.0, respectively. The calculated output 66 is represented by the function I _{A + B} for the vertical line 64 as a value in the range 0.0-1.0. Contour plane 68 shows the result for I _{A + B} = 0.5.

FIG. 6 shows the property shape of a three-dimensional function connecting the input continuous tone values V _A and V _B of two segments to the observed output intensities I _{A + B.} In the first approach, V _A = (1-f) V and V _B = fV are obtained from the input continuous tone value V and the interpolation coefficient f. As the interpolation coefficient approaches 0.5, the difference between the input continuous tone value and the observed output intensity increases. The case where V = 10 is shown by the curve 200 in the plane of the vertical line V _A + V _B = 1.0 in FIG. 6. Obviously this curve is on the function surface. 6 shows that if some kind of mixing occurs (i.e. 0.0 <f <1.0), the output intensity is reduced and the sum of the input values of the two segments must exceed the intended output value (ie, to achieve the desired output intensity). , V _A + V _B > V). This is the basis for the algorithm attached below.

The function shows a linear response when only one segment contributes to the output (ie f = 0.0 or f = 1.0). This, of course, assumes that the dither matrix includes the effect of dot gain.

What has been described above is limited to specific embodiments of the present invention. It is apparent that changes or modifications can be made to the present invention while including some or all features of the present invention. For example, the present invention may be implemented as hardware or software in a properly programmed digital data processing system, both of which may be readily made by those skilled in the art. Accordingly, the claims of the present application include all changes and modifications made within the scope of the spirit and scope of the present invention.

(Example of a program implementing the present invention)

static

void

ObtainMisregistrationTransferFunction

(

int dotsPerPixel,

int subdotsPerDot,

BI_Image const & dotImage,

char const * pDotImageName,

char const * pRefDotImageName,

int const overlapSize,

int const overlapIndex, // 0 .. overlapSize-1

int const misregFactor,

BI_Image const & ditherMatrix,

BI_LUT & lutv,

BI_LUT & lut0,                 

BI_LUT & lut1

);

class RLE_DotLine

{

public:

RLE_DotLine ()

: m_whiteRun (0), m_blackRun (0) {}

RLE_DotLine (int whiteRun, int blackRun)

: m_whiteRun (whiteRun), m_blackRun (blackRun) {}

int WhiteRun () const {return m_whiteRun; }

int BlackRun () const {return m_blackRun; }

private:

int m_whiteRun;

int m_blackRun;

};

typedef vector <RLE_DotLine, allocator <RLE_DotLine>>RLE_Dot;

static                 

void

Usage ()

{

fprintf (stderr, "usage: SegmentDither \ n");

fprintf (stderr, "inputImage \ n");

fprintf (stderr, "dotPerPixel \ n");

fprintf (stderr, "subdotsPerDot \ n");

fprintf (stderr, "dotImage \ n");

fprintf (stderr, "refDotImage \ n");

fprintf (stderr, "overlapCenter \ n");

fprintf (stderr, "overlapSize \ n");

fprintf (stderr, "misregFactor \ n");

fprintf (stderr, "ditherMatrix \ n");

fprintf (stderr, "outputImage \ n");

fprintf (stderr, "outputResolution \ n");

exit (1);

}

static

void                 

BadArgument (char const * pErrorMsg)

{

fprintf (stderr, "SegmentDither: argument error:% s \ n", pErrorMsg);

exit (1);

}

#define CHECK_ARGUMENT (cond) if (cond) BadArgument (#cond)

static

double

MisregDots (int const misregFactor)

{

return (double) misregFactor / 1000;

}

static

int

MisregSubdots (int const misregFactor, int const subdotsPerDot)

{

return (int) BU_Round (MisregDots (misregFactor) * subdotsPerDot);                 

}

static

void

Putdot

(

int const subdotsPerDot,

RLE_Dot const & rleDot,

int const dotRow,

int const dotCol,

int const misregFactor,

BI_Image & outputImage

)

{

int const misregSubdots = MisregSubdots (misregFactor, subdotsPerDot);

int const subdotRow = dotRow * subdotsPerDot;

int const subdotCol = dotCol * subdotsPerDot;

int const dotOverlap = rleDot.size ()-subdotsPerDot;

int const dotMargin = dotOverlap / 2;

RLE_Dot :: const_iterator ii = rleDot.begin ();

for (int i = 0; i <rleDot.size (); i ++, ii ++)

{

int const row = subdotRow-dotMargin + i;

if (row <0 || row> = outputImage.Height ())

continue;

int const whiteRun = (* ii) .WhiteRun ();

int blackRun = (* ii) .BlackRun ();

int col = subdotCol-dotMargin + whiteRun + misregSubdots;

if (col <0)

{

blackRun + = col;

col = 0;

}

if (col + blackRun> = outputImage.Width ())

blackRun = outputImage.Width ()-col;

if (blackRun <= 0)                 

continue;

BU_ExpandBitRun

(

outputImage.Image (row),

col,

outputImage.Width (),

blackRun,

One

);

}

}

static

void

MergeScale

(

double const scale,

int & v,

double & f0,                 

double & f1

)

{

double const vScaled = (double) v * scale;

if (vScaled <= 255.0)

{

v = (int) BU_Round (vScaled);

}

else

{

v = 255;

double const fScale = vScaled / 255.0;

f0 * = fScale;

f1 * = fScale;

}

}

static

void

Dither                 

(

BI_Image const & inputImage,

BI_LUT const & lutDotGain,

int const dotsPerPixel,

int const subdotsPerDot,

BI_Image const & dotImage,

char const * pDotImageName,

char const * pRefDotImageName,

int const overlapCenter,

int const overlapSize,

int const misregFactor,

BI_Image const & ditherMatrix,

BI_Image & outputImage,

int const outputResolution,

bool const bRetain,

bool const bSkipLHS,

bool const bSkipRHS,

bool const bFixedInterp = false,

double const fixedF0 = 0,

double const fixedF1 = 0                 

)

{

// compute overlap interval

int const overlapStart = overlapCenter-(overlapSize / 2);

int const overlapEnd = overlapStart + overlapSize-1;

// copy and invert dither matrix

BI_Image ditherMatrix2;

ditherMatrix2 = ditherMatrix;

BI Invert (ditherMatrix2);

// initialise and clear output image

int const subdotsPerPixel = dotsPerPixel * subdotsPerDot;

int const bilevelHeight = inputImage.Height () * subdotsPerPixel;

int const bilevelWidth = inputImage.Width () * subdotsPerPixel;

if (! bRetain)

{

// initialise

outputImage.Initialise

(                 

BI_ColorModel (BI_ColorGrayscale, 1),

bilevelHeight,

bilevelWidth,

outputResolution,

outputResolution

);

// clear

BI_CC * pOutputRow = outputImage.Image ();

for (int j = 0; j <outputImage.Height (); j ++)

{

BU_ClearLine (pOutputRow, outputImage.Width ());

pOutputRow + = outputImage.RowSize ();

}

}

// convert dot image to RLE

RLE_Dot rleDot;

for (int i = 0; i <dotImage.Height (); i ++)

{                 

int const whiteRun = BU_GetBitRun

(

dotImage.Image (i),

0,

dotImage.Width (),

0 // white

);

int blackRun;

if (whiteRun == dotImage.Width ())

{

blackRun = 0;

}

else

{

blackRun = BU_GetBitRun

(

dotImage.Image (i),

whiteRun,

dotImage.Width (),

1 // black                 

);

}

rleDot.push_back (RLE_DotLine (whiteRun, blackRun));

}

// dither contone input image to bi-level output image

BI_CC const * pImage = inputImage.Image ();

BI_CC const * pRow = pImage;

BI_CC const * pDither = ditherMatrix.Image ();

BI_CC const * pDitherRow = pDither;

BI_CC const * pDither2 = ditherMatrix2.Image ();

BI_CC const * pDitherRow2 = pDither2;

int ditherRow = 0;

for (int row = 0; row <inputImage.Height (); row ++)

{

for (int dotRow = 0; dotRow <dotsPerPixel; dotRow ++)

{

int const globalDotRow = (row * dotsPerPixel) + dotRow;

BI_CC const * pPixel = pRow;

BI_CC const * pDitherPixel = pDitherRow;                 

BI_CC const * pDitherPixel2 = pDitherRow2;

int ditherCol = 0;

for (int col = 0; col <inputImage.Width (); col ++)

{

int const vRaw = * pPixel ++;

int const vDotGain = lutDotGain [vRaw];

for (int dotCol = 0; dotCol <dotsPerPixel; dotCol ++)

{

int vRawDot = vRaw;

int const t0 = * pDitherPixel;

int const t1 = t0; // * pDitherPixel2;

int const globalDotCol = (col * dotsPerPixel) + dotCol;

// interpolate intensities in overlap region and dither

// one or the other or both

if (! bFixedInterp && globalDotCol <overlapStart)                 

{

int const t = t0;

if ((vDotGain == 255) || (vDotGain> = t && vDotGain! = 0))

{

if (! bSkipLHS)

{

Putdot

(

subdotsPerDot,

rleDot,

globalDotRow,

globalDotCol,

0,

outputImage

);

}

}

}

else                 

if (! bFixedInterp && overlapEnd <globalDotCol)

{

int const t = (overlapSize == 0)? t0: t1;

if ((vDotGain == 255) || (vDotGain> = t && vDotGain! = 0))

{

if (! bSkipRHS)

{

Putdot

(

subdotsPerDot,

rleDot,

globalDotRow,

globalDotCol,

misregFactor,

outputImage

);

}

}                 

}

else

{

#if 1

// account for stretch or shrink

if (! bFixedInterp)

{

double const misregDots = MisregDots (misregFactor);

double const newOverlapSize = overlapSize + misregDots;

double const overlapScale = newOverlapSize / overlapSize;

vRawDot = (int) BU_Round (vRawDot * overlapScale);

if (vRawDot> 255)

vRawDot = 255;

// MergeScale (overlapScale, vRawDot, f0, f1);                 

}

#endif

#if 1

// compute interpolation factors

double f0, f1;

if (bFixedInterp)

{

f0 = fixedF0;

f1 = fixedF1;

}

else

{

// compute overlap index

int const overlapIndex =

globalDotCol-overlapStart;

// obtain misregistration LUTs

BI_LUT lutv;

BI_LUT lut0;                 

BI_LUT lut1;

ObtainMisregistrationTransferFunction

(

dotsPerPixel,

subdotsPerDot,

dotImage,

pDotImageName,

pRefDotImageName,

overlapSize,

overlapIndex,

misregFactor,

ditherMatrix,

lutv,

lut0,

lut1

);

// retrieve interpolation factors

f0 = (double) lut0 [vRawDot] / 255;                 

f1 = (double) lut1 [vRawDot] / 255;

if (globalDotCol> overlapCenter)

BU_Swap (f0, f1);

// adjust intensity for attenuation

vRawDot = lutv [vRawDot];

}

#endif

// diagnostics

//printf("f0=%5.1lf f1 =% 5.1lf (% 5.1lf) vRaw =% d v =% d \ n ",

// f0, f1, f0 + f1, vRaw, vRawDot);

// interpolate dither with jitter

int vd = 0;

int v0d = 0;

int v1d = 0;

if ((vRawDot == 255) || (vRawDot> = t0 && vRawDot! = 0))                 

{

vd = 1;

}

double const rr = (double) rand () / RAND_MAX;

if (vd && rr <f0)

{

v0d = 1;

if (! bSkipLHS)

{

Putdot

(

subdotsPerDot,

rleDot,

globalDotRow,

globalDotCol,

0,

outputImage

);                 

}

}

if (vd && (1.0-rr) <= f1)

{

v1d = 1;

if (! bSkipRHS)

{

Putdot

(

subdotsPerDot,

rleDot,

globalDotRow,

globalDotCol,

misregFactor,

outputImage

);

}

}

#if 0                 

if (globalDotRow == 864)

{

printf ("% 1d% 1d% 1d (% 3d% 3d% 3d% 3d)",

vd, v0d, v1d, vRawDot, v0, v1, v0 + v1);

if (v0d + v1d <vd)

printf ("?");

if (v0d + v1d> vd)

printf ("#");

printf ("\ n");

}

#endif

}

pDitherPixel ++;

pDitherPixel2 ++;

ditherCol ++;

if (ditherCol> = ditherMatrix.Width ())

{                 

pDitherPixel = pDitherRow;

pDitherPixel2 = pDitherRow2;

ditherCol = 0;

}

}

}

pDitherRow + = ditherMatrix.RowSize ();

pDitherRow2 + = ditherMatrix2.RowSize ();

ditherRow ++;

if (ditherRow> = ditherMatrix.Height ())

{

pDitherRow = pDither;

pDitherRow2 = pDither2;

ditherRow = 0;

}

}

pRow + = inputImage.RowSize ();

}

}

static

void

Changefilesuffix

(

char const * pPath,

char const * pSuffix,

char const * pExt,

char path [_MAX_PATH]

)

{

char drive [_MAX_DRIVE];

char dir [_MAX_DIR];

char fname [_MAX_FNAME];

char ext [_MAX_EXT];

_splitpath (pPath, drive, dir, fname, ext);

strcat (fname, pSuffix);

_makepath (path, drive, dir, fname, pExt);

}

static                 

void

LogTransferFunction (char const * pType, double const intensity [], int const v)

{

printf ("% s:% 03d:% 5.1lf (% 5.1lf) \ n",

pType, v, intensity [v], v-intensity [v]);

}

static

void

ComputeMisregistrationTransferFunction

(

int dotsPerPixel,

int subdotsPerDot,

BI_Image const & dotImage,

char const * pDotImageName,

double const f0,

double const f1,

int const misregFactor,

BI_Image const & ditherMatrix,

BI_LUT & lutv,                 

BI_LUT & lut0,

BI_LUT & lut1

)

{

// create test image

BI_Image testImage;

testImage.Initialise

(

BI_ColorModel (BI_ColorGrayscale),

ditherMatrix.Height (),

ditherMatrix.Width ()

);

// build identity transfer function

BI_LUT identityLut;

for (int v = 0; v <256; v ++)

identityLut [v] = v;

// create output image

BI_Image outputImage;

// compute intensity for each gray level

double intensity [512];

int vLast;

for (v = 0; v <512; v ++)

{

// compute extended interpolation factors

double f0x, f1x;

int vx;

if (v <= 255)

{

vx = v;

f0x = f0;

f1x = f1;

}

else

{

vx = 255;

double const fScale = (double) v / 255.0;

f0x = f0 * fScale;                 

f1x = f1 * fScale;

}

// set test image to next intensity

testImage = BI_Color ((BI_CC) vx);

// dither test image to bi-level output

Dither

(

testImage,

identityLut,

dotsPerPixel,

subdotsPerDot,

dotImage,

pDotImageName,

pDotImageName,

0, 0, // no explicit overlap

misregFactor,

ditherMatrix,

outputImage,                 

72, // output resolution

false, // don't retain output image

false, // don't skip LHS

false, // don't skip RHS

true, // fixed interpolation

f0x,

f1x

);

// determine intensity of dithered bi-level output

long nDots = 0;

BI_CC const * pRow = outputImage.Image ();

for (int row = 0; row <outputImage.Height (); row ++)

{

nDots + = BU_CountBits (pRow, 0, outputImage.Width ());

pRow + = outputImage.RowSize ();

}

intensity [v] = 255 * (double) nDots / outputImage.PixelCount ();

// LogTransferFunction ("misreg", intensity, v);

vLast = v;

if (intensity [v]> = 255)

break;

}

LogTransferFunction ("misreg", intensity, 1);

LogTransferFunction ("misreg", intensity, vLast);

// create LUTs

for (int x = 0; x <256; x ++)

{

double d = -1;

for (v = 0; v <= vLast; v ++)

{

double const d2 = BU_Abs (intensity [v]-x);

if (d <0 || d2 <d)

{

d = d2;

if (v <= 255)

{

lutv [x] = v;                 

int const k0 = (int) BU_Round (f0 * 255);

lut0 [x] = (BI_CC) BU_Min (k0, 255);

int const k1 = (int) BU_Round (f1 * 255);

lut1 [x] = (BI_CC) BU_Min (k1, 255);

}

else

{

lutv [x] = 255;

int const k0 = (int) BU_Round (f0 * v);

lut0 [x] = (BI_CC) BU_Min (k0, 255);

int const k1 = (int) BU_Round (f1 * v);

lut1 [x] = (BI_CC) BU_Min (k1, 255);

if (k0> 255 || k1> 255)

{

fprintf (stderr, "k0 =% d k1 =% d (x =% d v =% d f0 =% 5.1lf f1 =% 5.1lf \ n",

k0, k1, x, v, f0, f1);

}

}

}                 

}

}

}

static

void

SimplifyFraction (int & n, int & d)

{

for (int i = n; i> 1 && n> 1; --i)

{

if ((d% i) == 0)

{

if ((n% i) == 0)

{

n / = i;

d / = i;

}

}

}

}

static

void

ObtainMisregistrationTransferFunction

(

int dotsPerPixel,

int subdotsPerDot,

BI_Image const & dotImage,

char const * pDotImageName,

char const * pRefDotImageName,

int const overlapSize,

int const rawOverlapIndex, // 0 .. overlapSize-1

int const misregFactor,

BI_Image const & ditherMatrix,

BI_LUT & lutv,

BI_LUT & lut0,

BI_LUT & lut1

)

{

// normalize overlap index                 

int overlapIndex = rawOverlapIndex;

if (overlapIndex> = ((overlapSize + 1) / 2))

overlapIndex = (overlapSize-1)-overlapIndex;

char lutvName [_MAX_PATH];

char lut0Name [_MAX_PATH];

char lut1Name [_MAX_PATH];

char suffix [_MAX_FNAME];

int interpNum = overlapIndex + 1;

int interpDenom = overlapSize + 1;

SimplifyFraction (interpNum, interpDenom);

sprintf (suffix, "_% 03d_% 02d_% 02d",

BU_Abs (misregFactor), interpNum, interpDenom);

ChangeFileSuffix (pRefDotImageName, suffix, ".amp", lutvName);

sprintf (suffix, "_% 03d_% 02d_% 02d_0",

BU_Abs (misregFactor), interpNum, interpDenom);

ChangeFileSuffix (pRefDotImageName, suffix, ".amp", lut0Name);

sprintf (suffix, "_% 03d_% 02d_% 02d_1",

BU_Abs (misregFactor), interpNum, interpDenom);

ChangeFileSuffix (pRefDotImageName, suffix, ".amp", lut1Name);

try

{

BU_File lutvFile (lutvName, _O_BINARY | _O_RDONLY);

lutv.Load (lutvFile);

BU_File lut0File (lut0Name, _O_BINARY | _O_RDONLY);

lut0.Load (lut0File);

BU_File lut1File (lut1Name, _O_BINARY | _O_RDONLY);

lut1.Load (lut1File);

}

catch (...)

{

// if using a reference dot image, LUTs must already exist

if (strcmp (pDotImageName, pRefDotImageName)! = 0)

{

fprintf (stderr, "can't load% s or% s or% s \ n",                 

lutvName, lut0Name, lut1Name);

exit (1);

}

// determine interpolation factors

double f1 = (double) interpNum / interpDenom;

double f0 = 1.0-f1;

ComputeMisregistrationTransferFunction

(

dotsPerPixel,

subdotsPerDot,

dotImage,

pDotImageName,

f0,

f1,

BU_Abs (misregFactor),

ditherMatrix,

lutv,

lut0,                 

lut1

);

BU_File lutvFile (lutvName, _O_BINARY | _O_WRONLY | _O_CREAT);

lutv.Save (lutvFile);

BU_File lut0File (lut0Name, _O_BINARY | _O_WRONLY | _O_CREAT);

lut0.Save (lut0File);

BU_File lut1File (lut1Name, _O_BINARY | _O_WRONLY | _O_CREAT);

lut1.Save (lut1File);

}

}

static

void

ComputeDotGainTransferFunction

(

int dotsPerPixel,

int subdotsPerDot,

BI_Image const & dotImage,

char const * pDotImageName,

BI_Image const & ditherMatrix,                 

BI_LUT & lutDotGain

)

{

// create test image

BI_Image testImage;

testImage.Initialise

(

BI_ColorModel (BI_ColorGrayscale),

ditherMatrix.Height (),

ditherMatrix.Width ()

);

// build identity transfer function

BI_LUT identityTransferFunction;

for (int v = 0; v <256; v ++)

identityTransferFunction [v] = v;

// create output image

BI_Image outputImage;

// compute intensity for each gray level

double intensity [256];

for (v = 0; v <256; v ++)

{

// set test image to next intensity

testImage = BI_Color ((BI_CC) v);

// dither test image to bi-level output

Dither

(

testImage,

identityTransferFunction,

dotsPerPixel,

subdotsPerDot,

dotImage,

pDotImageName,

pDotImageName,

0, 0, // no overlap

0, // no misregistration

ditherMatrix,                 

outputImage,

72, // output resolution

false, // don't retain output image

false, // don't skip LHS

false // don't skip RHS

);

// determine intensity of dithered bi-level output

long nDots = 0;

BI_CC const * pRow = outputImage.Image ();

for (int row = 0; row <outputImage.Height (); row ++)

{

nDots + = BU_CountBits (pRow, 0, outputImage.Width ());

pRow + = outputImage.RowSize ();

}

intensity [v] = 255 * (double) nDots / outputImage.PixelCount ();

// LogTransferFunction ("dot gain", intensity, v);

}

LogTransferFunction ("dot gain", intensity, 1);                 

LogTransferFunction ("dot gain", intensity, 255);

// create LUT

for (int x = 0; x <256; x ++)

{

double d = -1;

for (v = 0; v <256; v ++)

{

double const d2 = BU_Abs (intensity [v]-x);

if (d <0 || d2 <d)

{

d = d2;

lutDotGain [x] = v;

}

}

}

}

static

void                 

ObtainDotGainTransferFunction

(

int dotsPerPixel,

int subdotsPerDot,

BI_Image const & dotImage,

char const * pDotImageName,

char const * pRefDotImageName,

BI_Image const & ditherMatrix,

BI_LUT & lutDotGain

)

{

char lutName [_MAX_PATH];

ChangeFileSuffix (pRefDotImageName, "", ".amp", lutName);

try

{

BU_File lutFile (lutName, _O_BINARY | _O_RDONLY);

lutDotGain.Load (lutFile);

}

catch (...)

{                 

// if using a reference dot image, LUT must already exist

if (strcmp (pDotImageName, pRefDotImageName)! = 0)

{

fprintf (stderr, "can't load% s \ n", lutName);

exit (1);

}

ComputeDotGainTransferFunction

(

dotsPerPixel,

subdotsPerDot,

dotImage,

pDotImageName,

ditherMatrix,

lutDotGain

);

BU_File lutFile (lutName, _O_BINARY | _O_WRONLY | _O_CREAT);

lutDotGain.Save (lutFile);

}

}

static

void

SegmentDither (int argc, char * argv [])

{

// parse arguments

if (argc! = 12)

Usage ();

char const * pInputImageName = argv [1];

int const dotsPerPixel = atoi (argv [2]);

int const subdotsPerDot = atoi (argv [3]);

char const * pDotImageName = argv [4];

char const * pRefDotImageName = argv [5];

int const overlapCenter = atoi (argv [6]);

int const overlapSize = atoi (argv [7]);

int const misregFactor = atoi (argv [8]);

int const misregSubdots = MisregSubdots (misregFactor, subdotsPerDot);

char const * pDitherMatrixName = argv [9];

char const * pOutputImageName = argv [10];

int const outputResolution = atoi (argv [11]);

// open input image

BI_Image inputImage;

BI_LoadImage (inputImage, pInputImageName);

CHECK_ARGUMENT (inputImage.ColorModel ()! = BI_ColorModel (BI_ColorGrayscale));

BI_Invert (inputImage); // max is black

BI_TIFFSetMinIsBlack (false); // max is black

// check arguments

CHECK_ARGUMENT (dotsPerPixel <1);

CHECK_ARGUMENT (dotsPerPixel> 16);

CHECK_ARGUMENT (subdotsPerDot <1);

CHECK_ARGUMENT (subdotsPerDot> 32);

CHECK_ARGUMENT (overlapCenter <1);

CHECK_ARGUMENT (overlapCenter> = inputImage.Width () * dotsPerPixel);

CHECK_ARGUMENT (overlapSize <0);

CHECK_ARGUMENT (misregSubdots <-subdotsPerDot / 2);

CHECK_ARGUMENT (misregSubdots> subdotsPerDot / 2);

CHECK_ARGUMENT (outputResolution <= 0);

// diagnostics

printf ("misregSubdots =% d \ n", misregSubdots);

// open dot image

BI_Image dotImage;

BI_LoadImage (dotImage, pDotImageName);

CHECK_ARGUMENT (dotImage.ColorModel ()! = BI_ColorModel (BI_ColorGrayscale, 1));

CHECK_ARGUMENT (dotImage.Height () <subdotsPerDot);

CHECK_ARGUMENT (dotImage.Width () <subdotsPerDot);

CHECK_ARGUMENT (dotImage.Height ()! = DotImage.Width ());

int const dotOverlap = dotImage.Width ()-subdotsPerDot;

CHECK_ARGUMENT ((dotOverlap% 2)! = 0);

// open dither matrix

BI_Image ditherMatrix;

BI_LoadImage (ditherMatrix, pDitherMatrixName);

CHECK_ARGUMENT (ditherMatrix.ColorModel ()! = BI_ColorModel (BI_ColorGrayscale, 8));

CHECK_ARGUMENT (ditherMatrix.Height () <16);                 

CHECK_ARGUMENT (ditherMatrix.Width () <16);

// create output image

BI_Image outputImage;

// obtain dot gain transfer function for particular dot shape

BI_LUT lutDotGain;

ObtainDotGainTransferFunction

(

dotsPerPixel,

subdotsPerDot,

dotImage,

pDotImageName,

pRefDotImageName,

ditherMatrix,

lutDotGain

);

// dither input to bi-level output

Dither                 

(

inputImage,

lutDotGain,

dotsPerPixel,

subdotsPerDot,

dotImage,

pDotImageName,

pRefDotImageName,

overlapCenter,

overlapSize,

misregFactor,

ditherMatrix,

outputImage,

outputResolution,

false, // don't retain output image

false, // don't skip LHS

false // don't skip RHS

);

BI_SaveImage (outputImage, pOutputImageName);

// dither input to bi-level output (LHS only)

BI_Image outputImageLHS;

Dither

(

inputImage,

lutDotGain,

dotsPerPixel,

subdotsPerDot,

dotImage,

pDotImageName,

pRefDotImageName,

overlapCenter,

overlapSize,

misregFactor,

ditherMatrix,

outputImageLHS,

outputResolution,

false, // don't retain output image

false, // don't skip LHS

true // skip RHS                 

);

BI_SaveImage (outputImageLHS, "OutLHS.tif");

// dither input to bi-level output (RHS only)

BI_Image outputImageRHS;

Dither

(

inputImage,

lutDotGain,

dotsPerPixel,

subdotsPerDot,

dotImage,

pDotImageName,

pRefDotImageName,

overlapCenter,

overlapSize,

misregFactor,

ditherMatrix,

outputImageRHS,

outputResolution,                 

false, // don't retain output image

true, // skip LHS

false // don't skip RHS

);

BI_SaveImage (outputImageRHS, "OutRHS.tif");

// dither input to bi-level output (no interp)

BI_Image outputImageNoInterp;

Dither

(

inputImage,

lutDotGain,

dotsPerPixel,

subdotsPerDot,

dotImage,

pDotImageName,

pRefDotImageName,

overlapCenter,

overlapSize,

misregFactor,                 

ditherMatrix,

outputImageNoInterp,

outputResolution,

false, // don't retain output image

false, // skip LHS

false, // don't skip RHS

true, // fixed interp

0, // f0

0 // f1

);

BI_SaveImage (outputImageNoInterp, "OutNoInterp.tif");

}

void

main (int argc, char * argv [])

{

try

{

SegmentDither (argc, argv);

}                 

catch (BU_Error error)

{

error.Print ();

}

exit (0);

}

Claims (19)

In an ink ejection printhead composed of a plurality of overlapping printhead segments and whose spatial relationship between adjacent segments varies in time, the method of controlling ejection of nozzles in the overlapping segment, comprising: (a) determining the degree of overlap between adjacent printhead segments; (b) generating a half toning pattern for the nozzles in the overlap region of the overlapping segment; (c) adjusting the half toning pattern as a function of the measurement result in the overlapping area of the printhead segment to reduce artifacts that occur in the printed image due to the overlap of the printhead segment, Method of controlling the injection of the nozzle comprising a. delete delete The method of claim 1, Generating a halftone pattern for a nozzle in the overlap region of the overlapping segment comprising employing a dither matrix with an interpolation function. The method of claim 4, wherein Adjusting the halftone pattern is such that V _A + V _B is greater than V, where V _A and V _B are each independent dither matrix values of two adjacent segments, and V is a continuous tone value represented. A method of controlling the injection of the nozzle, characterized in that. The method of claim 5, Adjusting the halftone pattern comprises adjusting the spraying of nozzles of adjacent segments such that corresponding nozzles of each segment do not spray together. The method of claim 5, Adjusting the halftone pattern comprises using the inverse of the dither matrix for the opposing segment. The method of claim 5, Adjusting the halftone pattern comprises randomly distributing output dots to one or the other nozzles according to a probability given by a current interpolation coefficient of the interpolation function. How to control the injection. delete A plurality of overlapping printhead segments; At least one means for measuring the degree of overlap between adjacent printhead segments; Means for providing half toning of a continuous tone image; Means for adjusting the half toning means in an overlap area between adjacent segments to reduce artifacts in a printed image due to overlap between adjacent print head segments; Ink jet printhead system comprising a. delete delete The method of claim 10, The means for providing half toning of the continuous tone image comprises a dither matrix, and the means for adjusting the half toning means comprises two inputs (one is the output of the dither matrix and the other is between the adjacent printhead segments). Ink summarizing means having an overlap signal derived from at least one means for measuring the degree of overlap. The method of claim 13, And means for comparing the output of said summing means and a continuous tone data input to output halftone data for corresponding nozzles of adjacent printhead segments. The method of claim 10 And means for adjusting the half toning means in the overlap area between adjacent print head segments comprises means for inverting the dither matrix for the opposing segment. The method of claim 13, And means for subtracting the output of the summing means from the continuous tone data input signal to generate halftone data values for driving nozzles of adjacent printhead segments. A plurality of printhead segments spatially overlapping; At least one means for measuring the degree of overlap between adjacent printhead segments; Means for providing half toning of a continuous tone image; Means for adjusting the half toning means in an overlap area between adjacent segments to reduce artifacts in a printed image due to overlap between adjacent print head segments; Including, Means for providing half toning of the continuous tone image and means for adjusting the half toning means in an overlap region between adjacent segments to reduce artifacts between adjacent printhead segments comprises a programmable digital computer; A computer provides the ability of distributed dot probability dithering to reproduce continuous tone pixel values such that the corresponding nozzles of adjacent segments do not simultaneously produce a single dot together and the desired output value is less than the sum of the two input dither matrix values of the adjacent segments. An ink jet printhead system having an algorithm programmed therein. delete The method of claim 17, At least one means for measuring the degree of overlap between adjacent printhead segments comprises means for measuring the relative position of the adjacent printhead segments.

Images