CN1672940A

CN1672940A - 具有用于重叠打印头元件的补偿的喷墨打印机

Info

Publication number: CN1672940A
Application number: CN200510063190.2A
Authority: CN
Inventors: 卡·西尔弗布鲁克; 保罗·拉普斯顿
Original assignee: Silverbrook Research Pty Ltd
Current assignee: Memjet Technology Ltd
Priority date: 2000-05-24
Filing date: 2000-05-24
Publication date: 2005-09-28
Anticipated expiration: 2020-05-24
Also published as: JP4460206B2; EP1301347A1; WO2001089845A1; EP1301347A4; US7517037B2; IL166876A; ATE367926T1; JP2003534171A; IL153025A; AU4732800A; CN1452557A; US20090195586A1; CN1205043C; US7201460B1; DE60035715D1; US7837289B2; IL153025A0; US20070153038A1; AU2000247328B2; DE60035715T2

Abstract

一种包括喷墨打印头的打印机，所述喷墨打印头包括多个在空间上间隔开的重叠的打印头段；该打印机进一步包括至少一个用于测量相邻打印头段之间的重叠度的装置；用于提供连续色调图象的半色调的装置和用于调节相邻打印头段之间的重叠区内的所述半色调装置的装置，以减小所述相邻段之间的假象。

Description

具有用于重叠打印头元件的补偿的喷墨打印机

本申请是申请号为00819578.1(PCT/AU00/00593)，申请日为2000年5月24日的中国专利申请“用于补偿喷墨打印头中喷嘴随时间变化发生错位的方法和装置”的分案申请。

技术领域

本发明涉及喷墨打印领域，特别地公开了用于对具有重叠段的打印头组件的随时间变化的喷嘴失准进行补偿的方法和装置。

共同未决专利申请

与本发明相关的各种方法、系统和装置在申请人或受让人与本发明同时提出的下列同类专利申请中揭示：

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/AU00/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，

这里通过交叉引用结合这些共同未决申请的公开。

背景技术

在专利申请人的共同未决专利申请PCT/AU98/00550中提出了一系列喷墨打印装置，用于通过采用新颖的喷墨机制，以高速跨页宽进行打印。所揭示的装置利用被作为整体结构的部分而建造的热弯曲激励器。

在这种装置中，需要形成较大的喷墨喷嘴阵列以便在所需打印头提供页宽按需滴墨打印头。期望地，要求对小墨滴尺寸的非常高的分辨率。例如，具有普通竞争力的打印系统，如胶印允许到每英寸1600点(1600dpi)的分辨率。因此，作为例子，按上述分辨率打印，对于8英寸宽的A4页打印头，以此分辨率打印大约需要12800个喷墨喷嘴用于每种颜色。如采取标准的四色打印方法，这等于大约五万一千个喷墨喷嘴。对于包括标准四色加上定色剂和IR墨的六色打印方法，这导致76800个喷墨喷嘴。不幸的是，从，如硅晶片基片的基片的连续段来制造大的单片打印头是不实际的。

这主要是因为随着结构尺寸的增大，产量会有相当的减小。产出问题在半导体业中是一个已被详细研究的问题，而喷墨设备的制造通常利用半导体或模拟半导体处理技术。特别地，该领域通常被公知为微电子机械系统(MEMS)。S Tom Picraux和Paul J McWhorter在1998年12月的IEEE Spectrum一篇题为“The Broad Sweep of Integrated MicroSystems”的文章中对MEMS领域进行了研究。

保持高产量的一种解决方案是制造分成若干段的很长的打印头，并把这些段邻接或重叠在一起。不幸的是，打印头设备要求喷墨喷嘴非常高的间距，这就意味着，相邻打印头段之间的间隔必须被非常精确地控制，即使正常工作条件下存在热循环。例如，为了提供1600点每英寸的分辨率，要求喷嘴到喷嘴的间隔为16微米左右。

打印头的周围环境和工作环境可在重叠区内产生打印头的热循环，使相邻打印头段之间的重叠产生膨胀和收缩，其又导致在结果输出图像中产生假象。例如，在工作时，打印头的温度可比周围环境升高25℃。打印头组件还可是使用对打印头段具有不同热特性的材料制成的，导致组件之间不同的热膨胀。硅基片可采用合成橡胶封装，其热膨胀系数分别是2.6×10^-6和20×10^-6每摄氏度。

假象的产生是由于打印头表现二进制的连续色调图像的有限的分辨率和人眼能检测图像中相邻点的颜色上的0.5％的差异的能力。

发明内容

本发明的一个目的是提供一种机制来有效地、方便地补偿重叠的打印头段在工作期间的相对位移。

根据本发明的第一方面，本发明提供在包含多个重叠的打印头段的喷墨打印头中，其中，相邻段之间的空间关系可随时间变化，用于控制重叠段内的喷嘴喷射的方法，包括步骤：(a)确定相邻打印头段之间的重叠量；(b)为在重叠段的重叠区域中的喷嘴产生一个半色调图案；和(c)根据所述打印头段的重叠区域内的所述量，调节所述半色调图案，以减小由所述打印头段的重叠而产生的假象。

优选的是，确定重叠量的步骤采用对打印头段的温度的测量。所述半色调图案优选的是通过抖动矩阵或抖动容量产生，并且这种变换可以包括在利用抖动矩阵或抖动容量之前向当前连续色调像素输出值增加重叠值。可以利用每个段上的基准带(fiduciary strip)并使用干涉测量技术提供距离测量来代替温度测量，以确定段之间的相对移动的程度。

根据本发明的又一方面，提供一种喷墨打印头系统，包括：多个在空间上相互间隔开的重叠打印头段；至少一种用于测量相邻打印头段之间的重叠度的装置；为连续色调图像提供半色调的装置，以及用于调整相邻打印头段之间的重叠区域内的所述半色调装置的装置，以便减少所述相邻段之间的假象。

所述调整半色调装置的装置可包括连续色调输入、空间重叠输入、以及二进制输入，所述半色调装置利用空间重叠输入来改变连续色调输入，从而产生用于抖动矩阵或抖动容量的查询表中的各种各样的连续色调输入，以便产生输出二进制值，从而调整打印头段的重叠区域。用于调整半色调或抖动矩阵的装置可以在硬件中实现或通过使用算法的软件实现。

附图说明

本发明的特征在所附的权利要求书被详细指出。通过参考下面的描述并结合所附图纸可以更好地了解本发明的上述优点和其它优点，其中：

图1示出根据本发明的一对相邻打印头段的示意图；

图2显示了从图1中所示的相邻打印头段打印点的过程；

图3显示了在根据本发明的打印头段之间混合点的过程；

图4显示了根据本发明的实施例的抖动矩阵变化控制的过程；

图5显示了根据本发明的另一个实施例的抖动矩阵变化控制的过程；以及

图6以图形方式显示了根据本发明的另一个实施例所的一个算法，该算法实现了另一种抖动矩阵变化控制的过程。

具体实施方式

在第一个实例中，通过利用调整相邻段之间的重叠的数字处理机制，提供了一种补偿相邻打印头段的随温度变化的相对位移的方法。

在覆盖A4页宽的打印头中可以有10个段，其有9个以交错对的重复顺序设置的重叠部分。使用某种在单片集成电路制造技术领域中公知的技术，可在10微米以内得到段的初始对准。假设段的喷嘴以纵向的“之”字型形式设置在16微米的圆心上，那么6色墨装置的段宽为225微米左右。

在本实施例中，温度传感器被放置在每个打印头段上，用来提供对每个打印头段的当前温度特性的测量。然后，可以利用当前温度测量确定相邻打印头段之间的重叠量。

或者，如果可假设打印头段的物理特点和性能彼此充分相同，并且每对重叠段的周围环境基本相同，则可以只使用单一温度传感器。

然后，重叠量被用于提供一种控制相邻打印头段之间的半色调的机制。在本发明中，假设图像的输出是借助数字半色调，所述数字半色调采用该领域中熟知的任何方法或者技术。很多不同的半色调技术可被利用，参考美国麻省理工学院出版社出版的由Ulichney撰写的文章“Digital Half Toning”。

如图1所示，相邻打印头段2、3在各自区域12、13中重叠。对于1600dpi分辨率，重叠区域可扩展大约千分之四十(～1毫米)，提供64个间隔16微米的喷嘴的重叠。在段2的区域10中，该段喷嘴专用于喷墨。同样，段3的区域11中该段的喷嘴专用于喷墨。在重叠区域12、13中，两个打印头段2、3之间提供“混合”，因此，沿打印头段2的边缘14，喷嘴专用于在区域12中打印，同样，沿边缘15，段3的喷嘴也几乎专用于打印。在其间，可为线性或者其它的插值被提供在两个极端位置之间。因此，如图2所示，当在页上打印全色输出时，17侧的区域由打印头段10独立打出，而区域18由打印头段11独立打出(如图上的黑色点所示)，而区域19包含所述两个段的喷嘴之间的混合。这种打印方法利用任何公知的半色调矩阵，如上述参考中公开的。虽然已知的半色调矩阵被利用，但是实际利用的打印头段取决于重叠段之间的重叠量所提供的混合比。

图3中显示了一种这样的方法，其中，重叠区域内的线性插值被示出。在边缘14处相应于重叠部分12的区域中，打印头段2的喷嘴的利用率为100％，而在打印头段3的等价区域，边缘7，为0输出。当重叠区域的距离从段2的行14向段3的行15增加时，部分12的喷嘴的利用率逐渐下降(线性)，在边缘9上为0；部分13的喷嘴的利用率逐渐增加到1，直到边缘15被到达时。在第一实施例中，其中喷嘴之间有被增加的重叠，所以在重叠区域中所利用的半色调阀值被增加。这样减少在混合区域中打印的点数。反之，如果打印头段被间隔开略大于正常可接受的间隔，重叠降低，则可以通过降低半色调阀值增加点频率。

全面概括的半色调装置可被提供，如图4所示，其抖动矩阵25向求和装置27输出一个当前抖动值26，而其求和装置27具有另一个输入28，该输入28是一个重叠信号，它根据相邻段间的重叠量在正的或负的意义上变动。求和装置或加法器27的输出值29通过比较器30与输入连续色调数据32比较，以输出半色调数据31。一种可替代的装置允许在施加抖动前从连续色调数据29中减去数据值28，产生类似结果。装置被在图5中示处。

如图5所示，通过在加法器46中把抖动矩阵40的输出42与叠加信号44组合，且然后取得加法器46的输出54和减法器50的连续色调数据48的差，可以产生半色调数据输出52。这是图4的等效装置。

通过利用上述装置，如图3和图4以上所述，可以提供对叠加混合的一定程度的控制，以减少相邻打印头段之间的条纹假象的产生。

由于每个叠加信号28可乘以校准因子并被加至校准偏移因子，相邻打印头段的位置的精确程度也可被显著降低。因此，在制造中，相邻打印头段可以粗略地彼此对准。然后，可以在已知温度下打印出测试图案，以确定相邻段的喷嘴之间的重叠度。一旦针对特定温度范围的重叠度被确定，可以向可编程ROM存储设备写入一系列相应值，以便按需提供全部偏移值，其被各自地使用换算因数换算为打印头段重叠。

本发明的另一个实例中涉及用于减少打印头的重叠段之间的假象的产生的软件解决方案。抖动矩阵的完整的软件实现被附在附录A，包括为调整打印头段之间的可变重叠量的算法的实现。该程序是用C语言编写的。在该领域技术人士的知识内，也可以使用其它已作必要的修正的代码编写该算法。该算法的原理被解释如下。

分散点随机抖动被用于使用双值点来再现连续色调像素值。离散点抖动再现高空间频率，即几乎到点分辨率的极限的图像细节，而同时在被人眼空间集成时再现较低的空间频率到其完全强度深度。随机抖动矩阵被设计来成跨页平铺时免于令人不快的低频率图案。

可以使用点增益技术对点叠加建模。点增益是指从点图案的理想强度到打印图案时产生的实际强度的增加。在喷墨打印中，点增益主要是由墨洇渗(bleed)引起的。洇渗本身是墨和打印媒质的特性的作用。颜料墨会在表面洇渗，但是向媒质内部不会扩散甚远。基于染料的墨可以沿媒质内部的纤维素纤维扩展。表面涂层可用于减少洇渗。

由于点重叠效应以与点增益效应相同的方式对点分布敏感，所以把理想点的模型建立为完美地铺在页面而不存在重叠是有用的。虽然实际的喷墨点是近似圆的，并且与其相邻点重叠，但可用正方为理想点建模型。因此，理想和实际点的形状成为点增益参数。

点增益是边缘效应，也就是说，其本身出现在沿已打印点和相邻未打印点区域之间的边缘上。点增益与点图案的边缘连接和点图案的区域之间的比成比例。处理点增益的两种技术是分散点抖动和聚集点抖动。在离散点抖动中，点在某个区域中均匀分布，例如，对于50％强度的点，可使用棋盘格图案。在聚集点抖动技术中，点由单个中心的“着色”区域和“未着色”的边表示，其中，“着色”区域与“未着色”区域的比等于要打印的点的强度。因此，分散点抖动比聚集点抖动对点增益更敏感。

两个相邻的打印头段具有若干个重叠的喷嘴。一般来说，相邻段中的相应喷嘴之间没有完美的对齐。在局部级别上，可能存在半个喷嘴间隔左右的位置不正，即在1600dpi下为8微米左右。在较高的级别上，重叠喷嘴的数量实际上可变动。

平滑混合跨重叠桥和从一个段到下一个的输出的第一方法包括混合从一个到另一个跨重叠区域的到两个段的连续色调输入。当输出跨重叠区域进行时，第二个段接收增加的比例的输入连续色调值，而第一个段接收相应减少的比例如以上图3所述。可以使用线性插值或更高阶的插值。则，用于抖动通过上述两个段输出的抖动矩阵然后在喷嘴级别上被对齐。

第一方法有两个缺点。第一，如果特定点位置的抖动阈值低于两个段的插值连续色调值，那么两个段都会为该位置产生一个点。由于该两点会重叠，所以两个抖动矩阵所保证的强度只能部分再现，导致总体强度的损失。这可通过确保相应的喷嘴决不两者都产生点来纠正。这也可以通过使用用于交替段的抖动矩阵的逆，或者通过单个抖动矩阵抖动连续色调值，然后根据当前插值因子给出的概率，把输出点随机地分配给一个或另一个喷嘴来完成。

第二个缺点是，由不同段打印的相邻点会再次重叠，导致总体强度的损失。

如图6所示，每个重叠段的值沿水平轴60，62被表示为V_A和V_B，其各自在值0.0到1.0之间。计算后的输出66关于垂直轴64被表示为函数I_A+B，针对范围从0.0到1.0的值。一个等高面显示了I_A+B＝0.5的结果值。

图6示出把两个段的输入连续色调值V_A和V_B与所观察到的输出强度I_A+B链接起来的三维函数的定性的形状。对于第一方法，输入连续色调值V和插值因子f共同产生V_A＝(1-f)V和V_B＝fV。插值因子越接近0.5，输入连续色调值和所观察到的输出强度之间的差越大。对于V＝1.0，其在图6中由垂直V_A+V_B＝1.0平面的曲线200示出。通过定义，该曲线位于函数表面上。图6显示，当任何形式的混合出现时，即0.0＜f＜1.0，输出强度被削弱。为了实现所需的输出强度，两个段的输入值的和必须超出所需的输出值，即V_A+V_B＞V。这形成附录A中的算法的原理。

当只有一个段有助于输出时，该函数显示线性响应，即f＝0.0或f＝1.0。当然，这假定抖动矩阵包含点增益效应。

上述描述只限于阐述本发明的特定实例。但是，显然可对本发明进行改变和修改，达到本发明一些或者全部优点。例如，将理解，本发明可在合适的编程数字数据处理系统中被嵌入硬件或者软件，这两者可由相关领域的普通技术人员容易地完成。因此，所附的权利要求的目的在于将所有这样的变化和修改包括在本发明的实际精神和范围内。

　　static
　　void

　　ObtainMisregistrationTransferFunction

　　(

　　       int dotsPerPixel，

　　       int subdotsPerDot，

　　       BI_Image const& dotImage，

　　       char const* pDotImageName，

　　       char const* pRefDotImageName，

　　       int const overlapSize，
        <!-- SIPO <DP n="9"> -->
        <dp n="d9"/>
　　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，″         dotsPerPixel\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)；
}
        <!-- SIPO <DP n="10"> -->
        <dp n="d10"/>
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；
        <!-- SIPO <DP n="11"> -->
        <dp n="d11"/>
　　   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，

　　            1

　　            )；

　　   }
}
static
void
MergeScale
(

　　   double const scale，

　　   int& v，

　　   double& f0，

　　   double& f1
)
{
        <!-- SIPO <DP n="12"> -->
        <dp n="d12"/>
　　   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 overl.apSize，

　   int const misregFactor，

　　   BI_Image const& ditherMatrix，

　　   BI_Image& outputImage，

　   int const outputResolution，

　　   bool const bRetain，

　　   bool const bSklpLHS，

　　   bool const bSk.pRHS，

　　   bool const bFixedInterp＝false，

　　   double const flxedF0＝0，    

　　   double const flxedF1＝0
)
{

　　   ∥compute overlap interval

　　   int const overl.apStart＝overlapCenter-(overlapSize/2)；

　　   int const overLapEnd＝overlapStart+overlapSize-1；
        <!-- SIPO <DP n="13"> -->
        <dp n="d13"/>
//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())
        <!-- SIPO <DP n="14"> -->
        <dp n="d14"/>
　　         {

　　               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

　　   I_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＜otsPerPixel；
dotCol++)

　　                   {

　　                        int vRawDot＝vRaw；

　　                        int const t0＝*pDitherPixel；

　　                        int const t1＝t0；//*pDitherPixel2；
        <!-- SIPO <DP n="15"> -->
        <dp n="d15"/>
　　                              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

　　                                                 (

　　                                                       subdotePerDot，

　　                                                       rleDot，
        <!-- SIPO <DP n="16"> -->
        <dp n="d16"/>
　　                                                            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＝
        <!-- SIPO <DP n="17"> -->
        <dp n="d17"/>
　　                                                     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″，
        <!-- SIPO <DP n="18"> -->
        <dp n="d18"/>
　　                                           //    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，
        <!-- SIPO <DP n="19"> -->
        <dp n="d19"/>
　　                                                                                                         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()；
        <!-- SIPO <DP n="20"> -->
        <dp n="d20"/>
　　   }
}
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，
        <!-- SIPO <DP n="21"> -->
        <dp n="d21"/>
　　    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；

　　             fix＝f1；

　　        }

　　        else

　　        {

　　             vx＝255；

　　             double const fScale＝(double)v/255.0；

　　             f0x＝f0*fScale；

　　             f1x＝f1*fScale；

　　        }
        <!-- SIPO <DP n="22"> -->
        <dp n="d22"/>
　　   //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 PHS

　　          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)；
        <!-- SIPO <DP n="23"> -->
        <dp n="d23"/>
　　    //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)
        <!-- SIPO <DP n="24"> -->
        <dp n="d24"/>
　　   {

　　          if((d％i)＝＝0)

　　          {

　　                 if((n％i ＝＝0)
　　                 {
　　                       n/＝i；

　　                       d/＝i；

　　                 }

　　          }

　　   }
}
static
void
ObtainMisregistrationTransferFunction<br/>
{

　　   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 lutlName[_MAX_PATH]；

　　   char suffix[_MAX_FNAME]；

　　   int interpNum＝overlapIndex+1；

　　   int interpDenom＝overlapSize+1；

　　   SimplifyFraction(interpNum，interpDenom)；
        <!-- SIPO <DP n="25"> -->
        <dp n="d25"/>
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，
        <!-- SIPO <DP n="26"> -->
        <dp n="d26"/>
　　                 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)；

　　          lutO.Save(lut0File)；

　　          BU_File lut1File(lutlName，_O_BINARY|_O_WRONLY|_O_CREAT)；

　　          lutl.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
        <!-- SIPO <DP n="27"> -->
        <dp n="d27"/>
       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)；

　　   }
        <!-- SIPO <DP n="28"> -->
        <dp n="d28"/>
       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*pRefDot ImageName，

　　   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)
        <!-- SIPO <DP n="29"> -->
        <dp n="d29"/>
　　         {

　　                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()1＝
BI_ColorModel(BI_ColorGrayscale))；
        <!-- SIPO <DP n="30"> -->
        <dp n="d30"/>
　　   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)1＝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
        <!-- SIPO <DP n="31"> -->
        <dp n="d31"/>
(

　　   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，
        <!-- SIPO <DP n="32"> -->
        <dp n="d32"/>
　　   overlapCenter，

　　   overlapSize，

　　   misregFactor，

　　   ditherMatrix，

　　   outputImageLHS，

　　   outputResolution，

　　   false，                            //don′t retain output image

　　   false，                            //don′t skip IHS

　　   true                               //skip RHS
)；
BI_SaveImage(outputImageLHS，″OutLHS.GIF″)；
//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.GIF″)；
//dither input to bi-level output (no interp)
BI_Image outputImageNoInterp；
Dither
(

　　   inputImage，

　　   lutDotGain，

　　   dotsPerPixel，

　　   subdotsPerDot，
        <!-- SIPO <DP n="33"> -->
        <dp n="d33"/>
　　           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.GIF″)；
}
void
main(int argc，char * argv[])
{

　　   try

　　   {

　　           SegmentDither(argc，argv)；

　　   }

　　   catch (BU_Error error)

　　   {

　　           error. Print()；

　　   }

　　   exit(0)；
}。

Claims

1.一种包括喷墨打印头的打印机，所述喷墨打印头包括多个在空间上间隔开的重叠的打印头段；所述打印机进一步包括至少一个用于测量相邻打印头段之间的重叠度的装置；用于提供连续色调图象的半色调的装置，以及用于调节相邻打印头段之间的重叠区内的所述半色调装置的装置，以减小所述相邻段之间的假象。

2.根据权利要求1中所述的打印机，其中所述至少一个用于测量相邻打印头段之间重叠度的装置包括用于测量所述相邻打印头段的温度的装置。

3.根据权利要求1中所述的打印机，其中所述至少一个测量相邻打印头段之间重叠量的装置包括用于测量所述相邻打印头段的相当位移的装置。

4.根据权利要求2中所述的打印机，其中所述用于提供连续色调图象的半色调的装置包括抖动矩阵，且所述用于调节所述半色调装置的装置包括具有两个输入的求和装置，所述一个输入为所述抖动矩阵的输出，所述另一个输入为来源于所述至少一个用于测量相邻打印头段之间的重叠度的装置的重叠信号。

5.根据权利要求4所述的打印机，还包括一个用于比较所述求和装置的输出和连续色调数据输入的比较器装置，所述比较器装置的输出为用于相邻打印头段的相应喷嘴的半色调数据。

6.根据权利要求2中所述的打印机，其中，所述用于调节相邻打印头段之间的重叠区内的所述半色调装置的所述装置包括用于对抖动矩阵求逆用于交替段的装置。

7.根据权利要求4中所述的打印机，还包括用于将所述求和装置的输出从连续色调数据输入信号中减去以产生用于驱动相邻打印头段的喷嘴的半色调数据值的装置。