专利名称：：利用多种传感技术的手写输入设备的制作方法
技术领域：
：本发明一般地讲涉及计算机输入设备，特别是涉及手写体识别计算机输入设备。在联机手写体识别领域中存在着大量的活动。直到1990年的现有技术(在1990年8月的IEEE的图形分析与机器智能论文集第12卷第8期)CharlesC.Tappert等人的文章“联机手写体识别的技术发展水平”中论述了。一般地讲，联机手写体分析目前用于两种不同的用途身份检验和手写体字母与数字输入到计算机。这两个用途的操作要求和目标尖锐地对立。用于身份检验的手写体分析检测手写体的特征，这些特征每一个人都是不同的，因此可用于明确地识别一个给定的个人。相反地，用于数字字母输入到计算机的手写体分析试图减小各个特征的影响(这些特征对于身份检验是重要的)，并关注于一般的手写体特征上(这些特征可与给定的符号相关，这些给定的符号与各个书写者无关)。提供字母数字输入到计算机的手写体分析的目前已有的和建议的系统一般地适合于符号象什么的识别而不是它是如何产生的。因此，这种系统采用数字化装置或者图形输入板。另一方面，签字检验系统试图识别书写者的生物统计特征并且采用一致性，如在书写期间的压力和加速度。美国专利4,345,239采用在签字检验系统中的笔加速度。美国专利5,054,088采用身份检验的手写体的加速度和压力数据特征。如上述两专利所指出的，笔加速度用于签字检验，因为它是个人特性，每个人的特征。因此，笔加速度不用于字母数字输入。美国专利4,751,741叙述了仅仅采用笔压力数据的笔型字符识别设备。美国专利4,695,741叙述了装备一个加速度计的光笔，用于在计算机屏幕上检测该笔的出水。如上述专利所指出的，更一般地讲笔加速度不用于确定笔与表面的接触。美国专利4,845,684叙述了用于检测笔与书写表面之间的接触的一个手持的超声波设备。上述专利没有公开加速度数据的使用。美国专利4,122,435叙述了一个使用加速度计的设备，当用于在特别的表面上书写时，它产生可用于手写体分析的信号。通过超声波位置数字化的位置数字化在现有技术中是公知的，例如美国专利3,731,273；4,317,005；4,357,672；4,578,674；4,654,648；4,758,619；4,814,552；4,862,152；4,991,148；5,142,506；5,214,615；5,239,139；和5,280,457。叙述超声波位置数字化的其它出版物包括IEEE计算机论文集，1970年6月第C-19卷第6期第546-548页Brenner和DeBruyne的文章“声响笔一个数字记录笔系统”；1986年12月的TEEE计算机绘图与应用第49-53页DeBruyne的文章“PC的小型的大面积绘图数字化器”；IBM技术公开公报，1969年8月第12卷第3期第390页和IBM技术公开公报，1985年4月第27卷第11期“美国光标位置检测”。实际上从超声测量获得的数字化位置没有足够精确地确定以便允许更少地操作的手写体识别，以致于在现有技术中不知道从超声波位置检测的手写体识别。本发明试图提供一个改进的计算机输入设备。因此根据本发明的优选实施例提供手写体识别设备，包括至少使用两个不同的检测技术检测手写体的手写体输入装置，和符号识别装置，接收手写体输入装置的输出以便提供以手写体代表的输出符号的指示。而且根据本发明的优选实施例，该手写体输入装置包括在手持书写工具中的一个位置数字化器和至少一个加速度计。仍然根据本发明的优选实施例，该手写体输入装置包括在手持书写工具中的超声波位置确定装置和至少一个加速度计。另外根据本发明的优选实施例，该手写体输入装置可在计算机屏幕上书写。根据本发明还提供用于检测笔一表面接触的设备，包括至少一个加速度计，至少测量使用者手操作一支笔的加速度的一个部件，和一个笔-表面接触检测器，接收该加速度计的输入。而且根据本发明的优选实施例，该至少一个加速度计包括多个互相正交地放置的加速度计。仍然根据本发明的优选实施例，该符号识别装置包括组合的位置与加速处理装置，在识别符号中它组合从该数字化器和该至少一个加速度计来的输入。另外根据本发明的优选实施例，该符号识别装置包括第一识别信道，使用该数字化器来的输入提供代表符号的识别的第一输出，第二识别信道，使用该至少一个加速度计来的输入提供代表符号的识别第二输出，和符号选择装置，根据预定的准则在第一和第二输出之间选择。而且根据本发明的优选实施例，该检测器包括一个加速度噪声分析器，有效的提取该加速度数据中的噪声。仍然根据本发明的优选实施例，该至少一个加速度计可改型成笔。根据本发明的另一个优选实施例还提供一种手写体识别方法，包括接收有关书写工具加速度的信息，和至少部分地在该书写工具的加速度与表征多个符号的每个符号的存储加速度序列之间比较的基础上，识别由该书写工具书写的符号。根据本发明的另一个优选实施例还提供手写体识别设备，包括一个特征加速度序列存储器，有效的存储表征多个符号的每一个符号的加速度序列，一个书写工具监视器，有效的接收有关书写工具加速度的信息，和一个符号识别器，至少部分地在书写工具的加速度与存储的加速度序列之间比较的基础上工作的提供该书写工具书写的符号的输出指示。而且根据本发明的优选实施例，该书写工具监视器还工作以接收有关该书写工具位置的信息。根据本发明的另一个优选实施例还提供一种手写体识别方法，包括采用至少两个不同的检测技术检测手写体，和接收该检测技术的输出以便提供以该手写体代表的输出符号的指示。而且根据本发明的优选实施例，检测技术包括位置数字化，和采用在手持书写工具中的至少一个加速度计检测加速度。根据本发明的另一个优选实施例还提供一种检测笔—表面接触的方法，包括采用至少一个加速度计测量使用者的手操作一支笔的加速度的至少一个部件，和接收该加速度计来的输入及提供笔一表面接触的输出指示。而且根据本发明的优选实施例，该方法还包括通过组合数字化的位置输入和检测的加速度信息来识别符号。而且根据本发明的优选实施例，该接收步骤包括采用数字化的位置输入提供代表符号识别的第一输出，采用加速度信息提供代表符号识别的第二输出和在第一和第二输出之间选择。根据本发明的另一个优选实施例还提供手写体识别设备，包括手写体输入装置，该装置至少包括产生第一和第二手写体输出的第一和第二不同的手写体检测器，和一个相关器(associator)，用于组合第一和第二手写体输出以便提供一个增强性能的手写体输出，和符号识别装置，接收增强性能的手写体输出，以便提供由该手写体代表的符号的输出指示。而且根据本发明的优选实施例，第二手写体检测器包括一个键盘。另外根据本发明的优选实施例，其中第二手写体检测器包括超声波位置确定装置。而且根据本发明的优选实施例，第二手写体检测器工作以检测在计算机屏幕上的手写体。仍然根据本发明的优选实施例，该手写体识别装置包括一个书写工具。另外根据本发明的优选实例，至少第一和第二手写体检测器之一包括检测该书写工具位置的装置。而且根据本发明的优选实施例，该相关器工作以在两维范围内组合第一和第二手写体输出。仍然根据本发明的优选实施例，该相关器工作以在时域中组合第一和第二手写体输出。根据本发明的另一个优选实施例还提供一种手写体识别方法，包括至少采用第一和第二不同的手写体检测器产生第一和第二手写体输出，组合第一和第二手写体输出以提供一个增强性能的手写体输出，和采用该增强性能手写体输出以提供以该手写体代表的符号输出指示。而且根据本发明的优选实施例，第一手写体检测器检测加速度。仍然根据本发明的优选实施例，至少第一和第二手写体检测器之一工作以检测书写工具的位置。另外根据本发明的优选实施例，该组合的步骤包括在两维域中组合第一和第二手写体输出。而且根据本发明的优选实施例，该组合的步骤包括在时域中组合第一和第二手写体输出。根据本发明的优选实施例还提供手动成象识别设备，包括手绘体输入装置，它至少采用两个不同的检测技术检测手绘体，和形状识别装置，它接收手绘体输入装置的输出以提供由手绘体代表的形状的输出指示。而且根据本发明的优选实施例，该手绘体输入装置包括放在手持书写工具中的一个位置数字化器和至少一个加速度计。仍然根据本发明的优选实施例，该手绘体至少包括手绘和手写。另外根据本发明的优选实施例，该输入装置包括超声波位置确定装置和放在手持书写工具中的至少一个加速度计。而且根据本发明的优选实施例，该形状识别装置包括组合的位置与加速度处理装置，它以识别的形状组合来自数字化器和至少一个加速度计的输入。仍然根据本发明的优选实施例，该形状识别装置包括第一识别信道，它使用来自数字化器的输入提供代表形状识别的第二输出，和形状选择装置，它根据预定的准则在第一和第二输出之间选择。而且根据本发明的优选实施例，该至少一个加速度计可改进为一支笔。根据本发明的另一个优选实施例还提供一种手绘体识别方法，包括接收有关书写工具加速度的信息，和至少部分地在该书写工具的速度加与表征多个形状的每个形状的存储加速度的序列之间比较的基础上识别由书写工具书写的形状。而且根据本发明的优选实施例，该手绘体识别方法还包括接收有关书写工具位置的信息。仍然根据本发明的优选实施例，该手动成象识别方法还包括存储由第二多个使用者之一产生的表征第一多个形状的每个形状的加速度序列。根据本发明的另一个优选实施例还提供手绘体识别设备，包括一个特征加速度序列存储器，它工作以便存储表征多个形状的每个形状的加速度序列，一个书写工具监视器，它工作以接收有关书写工具加速度的信息，和一个形状识别器，它工作以便至少部分地在该书写工具的加速度与该存储的加速度序列之间比较的基础上提供由该书写工具书写的形状的输出指示。而且根据本发明的优选实施例，该书写工具监视器还工作以便接收有关书写工具位置的信息。根据本发明的另一个优选实施例还提供一种手绘体识别方法，包括至少采用两个不同的检测技术检测手绘体，和接收检测技术的输出以使提供由该手绘体代表的形状的输出指示。而且根据本发明的优选实施例，该检测技术包括位置数字化，和采用放在手持书写工具中的至少一个加速度检测加速度。仍然根据本发明的优选实施例，该手动成象识别方法还包括通过组合数字化的位置输入和检测的加速度信息来识别形状。另外根据本发明的优选实施例，该接收步骤包括采用数字化的位置输入提供代表形状识别的第一输出，采用加速度信息提供代表形状识别的第二输出，和在第一与第二输出之间选择。而且根据本发明的优选实施例，该接收步骤包括提取加速度数据中的噪声。根据本发明的另一个优选实施例还提供手绘体识别设备，包括手绘体输入装置，该装置包括产生第一和第二手绘体输出的至少第一和第二不同的手绘体检测器，和一个相关器，用于组合第一和第二手绘体输出以提供一个增强性能的手绘体输出，和形状识别装置，它接收增强性能的手绘体输入以提供由该手绘体代表的形状的输出指示。而且根据本发明的优选实施例，第一手绘体检测器包括至少一个加速度计。仍然根据本发明的优选实施例，第二手绘体检测器包括一个键盘。另外根据本发明的优选实施例，第二手写体检测器包括一个超声波位置确定装置。而且根据本发明的优选实施例，手绘体识别装置包括一个书写工具。而且根据本发明的优选实施例，至少第一各第二手写体检测器之一包括用于检测该书写工具位置的装置。仍然根据本发明的优选实施例，该相关器工作以便在两维域中相关第一和第二手动成象输出。而且根据本发明的优选实施例，该相关器工作以便在时域中相关第一和第二手绘体输出。根据本发明的另一个优选实施例还提供手绘体识别方法，包括采用至少第一和第二不同的手绘体检测器产生第一和第二手绘体输出，组合第一和第二手绘体输出以产生一个增强性能的手绘体输出，和采用该增强性能的手绘体输出提供由该手绘体代表的形状的输出指示。而且根据本发明的优选实施例，第一手绘体检测器检测加速度。仍然根据本发明的优选实施例，至少第一和第二手写体检测器之一工作以检测书写工具的位置。另外根据本发明的优选实施例，该组合步骤包括在两维域中相关第一和第二手绘体输出。根据本发明的优选实施例，该组合步骤包括在时域中相关第一和第二手绘体输出。仍然根据本发明的优选实施例，该手写体输入装置包括光字符识别装置。另外根据本发明的优选实施例，该至少一个加速度计包括多个加速度计。此外根据本发明的优选实施例，该多个加速度计互相正交地放置。而且根据本发明的优选实施例，该符号识别装置包括组合的位置与加速度处理装置，它组合来自该光字符识别装置和该至少一个加速度计的输入为识别的符号。仍然根据本发明的优选实施例，该符号识别装置包括第一识别信道，采用该光字符识别装置来的输入提供代表符号识别的第一输出，第二识别信道，采用该至少一个加速度计来的输入提供代表符号识别的第二输出，和符号选择装置，它根据预定的准则在第一和第二输出之间选择。另外根据本发明的优选实施例，该至少个加速度计可改型为一支笔。此外根据本发明的优选实施例，该输入装置包括光识别装置。而且根据本发明的优选实施例，该形状识别装置包括组合的光字符识别与加速度处理装置，它组合来自光字符识别装置和该至少一个加速度计为识别形状的输入。仍然根据本发明的优选实施例，该形状识别装置包括第一识别信道，它采用光字符识别装置来的输入提供代表形状识别的第一输出，第二识别信道，它利用该至少一个加速度计来的输入提供代表形状识别的第二输出，和形状选择装置，它根据预定的准则在第一和第二输出之间选择。对照附图以下面的详细叙述中将理解和知道本发明，其中图1A是按照本发明的优选实施例构成和工作的手写体识别装置简化的半绘图半方框图表示；图1B是按照本发明的可替代的优选实施例构成和工作的手写体识别装置简化的半绘图半方框图表示；图2A至2H是图1A和1B装置部分的优选结构的示意图；图3是图1A和1B的手写体识别装置的简化分框图；图4A是表示由图1A和1B的手写体识别装置执行的教导过程的简化流程图；图4B是表示由图1A和1B的手写体识别装置执行的识别过程的简化流程图；图5A至5D是表示由图1A和1B的手写体识别装置执行的教导部分和识别过程的优选方法的数据图形表示；图6A是图1A的数字化笔/加速度计的优选机械结构的简化表示；图6B是图1B的数字化笔/加速度计的优选机械结构的简化表示；图7是按照本发明的加一个可替代的优选实施例结构和工作的手写体识别装置简化的半绘图半方框图；图8是图7的手写体识识别装置的简化方框图；图9A是表示由图7的手写体识别装置执行的教导过程的简化流程图；和图9B是表示由图7的手写体识别装置执行的识别过程的简化流程图。附件是以下附录，目的在于理解和知道所示的和所叙述的一发明的优选实施例附录A是一个计算机表，包括图4A与4B的步骤220和300部分的优选实施和图9B与9B步骤720和800部分的优选实施；附录B是一个计算机表，包括所有图4A与4B的步骤220和300的部分的另一个优选实施和步骤310及320的优选实施。附录C是一个计算机表，包括图2D至2H的装置的优选实施；附录D是一个计算机表，包括图1B装置部分的优选实施；和附录E是一个计算机表，包括图1B的装置部分的优选实施。现在参见图1A，它是按照本发明构成和工作的手写体识别装置的优选实施例的简草绘图表示。采用一个数字化笔/加速度计在图形输入板12上书写。笔10还包括一个内置加速度计25，如可从ICSensors公司实到的型号为ICS3031-2，地址为1701McCarthyBlvd.，Milpitas，CA95035。另一方案，笔10可包括多个加速度计，这些加速度计可以是也可以不是正交地放置的。笔10还包括一个或几个加大器30，与一个或几个加速度计25相连。图2A是适于在本申请中使用的放大器30的优选实施例的示意图。另一方案，笔10可以与包括如上所述的一个或几个加速计25的可改型装置装配在一起，而且如上所述还包括相连的放大器30。该装置可具有固定笔10端部的一个帽。包围该笔的一个环的形式，或者任何其它合适的形式。图形输入板12检测笔10的笔尖相对于图形输入板12的位置并且提供表示该位置的数据的数字化输出。图形输入板12可以是任何合适的图形输入板，诸如从WACOMCom-puterSystemGmbH公司实到的型号SD-510C的Wacom图形输入板处理器，公司的地址为德国Hellersbergstrasse4，W-4040Neuss1。从笔10中的一个或几个加速度计获得的数据在这里称为“加速度计数据”。加速度计数据和从图形输入板12来的地点数据分别通过分开的电缆发送到控制电路40。可替代的方案如，该加速度计数据和地点数据可通过单条电缆发送。根据又一个替代方案，该加速度计数据和地点数据可通过任何类型的合适的通信链路如超声波、红外线或者利用任何其它合适的手段发送。控制电路40放大从笔10来的加速度信号并且将它们变换为数字形式，最好使用模数变换器。图2B是适于在本申请中使用的模数变换器优选实施例的示意图。然后控制电路40发送组合的同步的加速度数据与位置数据到一个加速度计与位置数据处理器50。数据处理器50可以是任何合适的计算机，例如具有80386处理器芯片的IBMPC兼容计算机。与数据处理器50相连的是一个符号显示器60和一个输入设备70。在数据处理器50内进行识别，而所识别的符号在符号显示器60上显示。如果需要的话，用户可使用输入设备70输入识别差错的校正。可替代的方案，用户可使用笔10和数字化图形输入板12在符号显示器上显示的可选择方案中进行选择或者使用其它合适的方法输入校正。现在叙述图1A的装置功能。使用者使用笔10在图形输入板12上写符号。在写入控制电路40期间笔10发送描述笔10的加速度的加速度数据。图形输入板12在笔10点的时刻发送描述位置的笔点位置数据到控制电路40。控制电路40放大和数字化加速度数据。如果加速度数据和位置数据没有及时同步，通过使笔状态信号与加速度数据相符，控制电路40同步加速和位置数据。下面参见图4B更全面地描述笔状态信号。由控制电路40发送组合的同步数据至数据处理器50。另一方面，控制电路40还可包括一个处理器和适用于存储组合同步数据的存储器。在这种情况下，笔10和图形输入板12及控制电路40可用于产生和存储组合的同步数据。然后，在稍后的时间，为了手写体识别的出现，由控制电路40发送该数据到数据处理器50。在手写体识别可能出现之前，数据处理器50必须建立一个数据库，该数据库包括有关可被识别的每个符号的数据，规定每个人使用的设备，该数据库在这里被规定为每个人每个符号的数据库。在教导期间，数据处理器50控制每个人每个符号数据库的手写体特性的建立。该每个人每个符号数据库包括每个人的数据，他的手写体该系统是知道的，该数据描述每个符号的一个或多个原型的数据。每个原型包括描述由该个人写入符号的参数，下面参见步骤240更详细地描述这些参数。在教导期间，用户从数据处理器50已知的预先安排的笔迹书写一些符号，而且在写入期间相关的符号出现在符号显示器60上。最好是，预先安排的笔迹包含每个符号的几个重复。根据本发明人的经验，最好是，这些符号出现在整个预先安排的笔迹的字的不同部分，例如开始，中间和结束。下面参见图4A更全面地描述在教导过程期间数据处理器50的功能性。在识别期间，该数据处理器50控制识别过程，该过程包括选择相应于由用户写的符号的正确的符号码。最好是，该识别过程还包括选择由用户写入的正确的字。下面参见图4B更全面地描述在识别过程期间数据处理器50的功能性。现在另外参考图1B，图1B是根据本发明的另一个可供选择的最佳实施例构成和运行的手写体识别设备的简化的半图解半方框图的图示说明。图1B的设备除了下面描述的之外，基本上类似于图1A的设备。在图1B的设备中，笔10在书写平面75上写入，书写平面可能是一张纸，一个计算机的显示屏幕或是其它合适的书写平面。在书写平面75包括一个计算机显示屏幕的情况下，可任意地利用笔10来写，而不用墨水，以便笔10的功能限制为用于相关计算机的数据输入设备。应当明白，在这种情况下，笔10特别适于起着数据输入和指点器的功能以及起着下面描述的手写体分析的功能。图1B的笔10类似于图1A的笔10，面且另外包括一个超声波发射机80，例如型号MA40S3S，它可从德国的Murata电气公司实到。超声波发射机80可安装在笔上适当位置，例如靠近笔尖。另一可选择的方案超声波发射机80可是可改型安装在笔上。而且，另一方面，超声波发射机可包括多个发射机。多个超声波接收机，例如，型号MA40S3R，可从德国的Murata电气公司买到，这些接收机被放置在靠近书写平面75的预定位置。在书写平面75包括一个典型的纸张或典型的计算机显示屏幕时，三个超声波接收机85足以有代表性的确定笔10的位置。在书写平面75比典型的纸张或典型的计算机显示屏幕大的情况下，最好使用两个以上的接收机。在利用两个接怪不得机85的情况下，由两个接收机的中心确定的线最好是基本上平行于书写平面75大部分所处的平面。在利用两个以上接收机85的情况下，由这些接收机确定的线最好基本上处在平行于书写平面75大部分所在平面的平面内。接收机85最好相对于书写平面75放置，以这样的方法来达到笔位置测量的精度最大。如上所述在MA40S3R接收机的情况下，每个接收机85和书写平面75的最近部分之间的最好佳的最小距离是20厘米，而每个接收机85和书写平面75的最远部分之间的最佳最大距离是1米。该接收机85典型地具有一个最佳接收方向；接收机85最好应当是定向在所用笔10所在区域的总方向。同样，发射机80典型地具有最佳传输方向；应当最佳地利用笔10，以便发射机80的传输最佳方向将朝着接收机85。控制电路90周期地触发超声波发射机80，从超声波接收机85累加数据，并根据累加数据计算笔10的位置。控制电路90包括一个数字信号处理器，这里称为“DSP”，例如型号ADSP2101，可从美国AnalogDevices公司买到。控制电路90还包括与多个超声波接收机85操作操作地相连的多个数字计数器。一个合适的计数器是型号74HCT4040，可从德国RCAGMGH公司买到。控制电路90还包括合适的用于数据存储和节目存储的存储单元。控制电路90还放大和数字化加速度数据。控制电路90放大来自笔10的加速度信号并变换它们为数字形式，最好使用模/数变换器。图2B是适于在这种应用的模/数变换器的最佳实施例的原理图。现在描述图1B设备的功能，用户利用笔10在书写平面75上写入符号。笔10发送在写入期间描述笔10加速度的加速度数据至控制电路90。控制电路90发送信号至笔10，触发超声波发射机80发射脉冲序列。典型地，控制电路90发送一个脉冲串，每个脉冲串与下一个脉冲串由规定的时间周期分离开。最好在每一个脉冲串中发送4个间隔靠近的脉冲，而且这些脉冲用25微秒分离开。现在再参见图2C，该图是发送信号至笔10的控制电路90的部分优选结构的原理图。控制电路90重新开始，包括在每个脉冲串的开始的计数。每个超声波接收机85接收由超声波发射机80发射的超声波声波，作为脉冲串的一部分，而且发送一个信号至控制电路90。从超声波接收机85的一个接收机接收一个信号时，控制电路90停止相关计数。现在再参见图2D至2H，这些图是控制电路90部分最佳结构的原理图，控制电路90包括计数器，DSP，和相关的电子电路。附录C是一个计算机表，包括图2D至2H的设备最佳实现的PALASM计算机语言清单。附录D包括以上面所述ADSP2101DSP语言的上面描述的累加超声波数据方法最佳实现的计算机表。控制电路90根据控制电路内计数器的值与控制电路90执行的其它操作并行地计算笔10笔尖的座标。控制电路90通过除去在一个脉冲串和下一个脉冲串之间计数值的大突变来滤波计数器的信号，典型地，突变超过计数器上的25至30个单元被认为是大的突变。当由控制电路90检测到包括单个数据点的大突变时，重新计算这些点的值，作为前面的和下一个值的平均值。当一个大突变包括两个数据点时，使用线性内插，控制电路90重新计算该值。当一个大突变包括多于两个数据点时，该控制电路90重新计算在减去在前一个数据点上测量的突变高度的突变之后这些点的值。控制电路90除去计数器的量化噪声。当检测到在包括单数据点计数器上一个单元的突变时，控制电路90使用零次内插，给定数据点一个等于前面和随后的数据点的值来重新计算数据点的值。然后，控制电路90使用如下的三角测量计算笔10的位置。该计数值代表由超声波发射机80发送脉冲和由与该计数器相关的一个超声波接收机85接收的脉冲之间的时间。因为声音在空气中的速度是各向同性的，因此该计数值也代表超声波发射机80和由与该计数器相关的一个超声波接收机85之间的距离。然后利用勾股定理计算笔10的位置。然后控制电路90使用低通滤波器滤波信号，例如由T.Wparks和C.SBurrus所著，由JohnWiley&Sons公司于1987年出版的“数字滤波器设计”第七章，第7.3.3节所描述的，使用具有0.03的截止频率的第四级(order)低通数字滤波器。附录E是一个计算机表，是以C编程语言写成的，包括上面描述的从超声波数据来计算位置的最佳实现方法。因此，由控制电路90计算的位置数据可包括随后由图1B设备使用的位置数据。另一个可选择的方案，如下所描述的，位置数据可根据超声波接收机85接收的数据和加速度数据的组合来计算。控制电路90放大和数字化加速度数据。如果加速度数据和位置数据设有及时同步，通过使笔状态信号与加速度数据相符，控制电路90同步加速度和位置数据。下面参见图4B更全面地描述笔状态信号。由控制电路90发送组合同步数据至数据处理器50。另一方面，控制电路90还可包括一个处理器和适用于存储组合同步数据的存储器。在这种情况下，笔10和控制电路90可用于产生和存储组合的同步数据。然后在稍后的时间，为了手写体识别的出现，由控制电路90发送该数据到数据处理器50。在上述情况下，来自超声波接收机85的数据与加速度数据组合得到位置数据，由数据处理器50计算改进的位置数据。另一方面，通过关于控制电路90的上面所述的DSP可计算新的位置数据。数据处理器50滤波来自控制电路90的位置数据，除去噪声以外的分量。例如，加速度数据可由一个Butterworth数据滤波器滤波，该滤波器在由JohnWiley&Sons公司于1987年出版的T.W.Parks和C.S.Burrus所著的“数字滤波器设计”的第7章第7.3.3.节中描述，使用具有0.7至0.9的截止频率的第4级低通数字滤波器。当由用户移动的笔10在书写平面75上不规则的，包括微观的不规则运动时，产生噪声成分。在大多数书写面75的情况下，例如一张纸，在规则间隔的平面75上出现微观的平面不规则，噪声分量的峰值数被用于代表横过平面不规则和因此横过距离不规则的数量。数据处理器50辨别和计算噪声峰值。每单位距离的峰值数可预先对特定书写平面75的特定类型进行确定或由学习过程确定，或可由其它方法确定。由控制电路90从超声波数据确定的位置被用于规定运动方向，而上面描述的噪声分量的峰值数用于规定横向距离。数据处理器50根据运动方向和横向距离计算更新的和更精确的位置数据。最好是，用于计算噪声的加速度数据的样值速率大于来自控制电路90的超声波数据的数据传输速率。在手写体识别可能出现之前，数据处理器50必须建立一个数据库，该数据库包括有关可被识别符号的数据，规定每个人使用设备的数据。该数据库在这里称为每人每个符号数据库。在教导期间，数据处理器50控制手写体特征的每人每个符号数据库的建立。每人每个符号数据库包括手写体是该系统已知的每人的数据，它描述每个符号的一个或多个原型。每个原型包括描述由该个人写入符号的参数，下面参见步骤240更详细地描述这些参数。在教导期间，用户从数据处理器50已知的预先安排的笔迹，而且在写入期间相关的符号出现在符号显示器60上，最好是，预先安排的笔迹包含每个符号的几个重复。根据本发明人的经验，这些符号最好出现在整个预先安排的笔迹的字的不同部分，例如开始，中间和结束。下面参见图4A更全面地描述在教导过程期间数据处理器50的功能。在识别期间，该数据处理器50控制识别过程，该过程包括选择相应于由用户书写的符号的正确的符号码。该识别过程最好还包括选择由用户书写的正确的字。下面参见图4B更全面地描述在识别过程期间数据处理器50的功能。现在再参考图3，该图3是图1A和1B的手写体识别设备简化的方框图。图3的手写体识别设备从笔10和从图形输入板12或控制电路90接收输入。从图形输入板12或控制电路90输入代表笔10位置的数据在这里称为位置数据。当手写体识别设备的用户移动笔10时，笔10发送描述在教导控制130和/或手写体识别控制150的时间笔10的加速度的数据。笔10还与图形输入板12一起提供描述位置轨迹的数据，轨迹是由用户在图形输入板12的表面上使笔10运动时笔10的笔尖的运动轨迹。另一方面，在图1B设备的情况下，如上所述，由控制电路90提供位置数据。来自笔10的数据和位置数据可被发送到教导控制130。在一个人首次使用手写体识别的系统之前，对于使用手写体识别系统的每个人来说，出现到教导控制130的传输。当检测识别差错时也出现到教导控制130的传输，当检测识别差错时，教导控制130的使用被称为自适应技术。教导控制130操作接收的数据，该数据代表当写一个符号时用户手的运动，它与人工提供的符号码的辨别一起都是相关的数据。然后，教导控制130更新数据库140，即每人每个符号数据库。数据库140包括每个符号的加速度和符号形状的原型，包括每个人特定的每个符号的数据。另一方面，来自笔10的数据和位置数据可被发送到手写体识别控制150。手写体识别控制150操作从笔10接收的数据和位置数据，以便识别由笔10在图形输入板12或书写平面75上运动所代表的符号。手写体识别控制150的输出包括一个符号编码表及其各自的概率。手写体识别后置处理电路160根据符号编码表和概率以及根据包括以前的混乱和字典数据库的后置处理信息选择正确的符号码。手写体识别后置处理电路160的输出是一个符号码或字。现在再参见图4A和4B，这些图是根据本发明的优选实施例说明图1A和1B手写体识别设操作的简化流程图。图4a说明教导过程，而图4B说明识别过程。图4A方法的最佳操作方法包括如下的步骤步骤210，并行读位置数据和加速度计数据。最好是，加速度计数据的取样比位置数据更经常，例如，对于每个位置数据的数据点从加速度计可收集8个数据点。组合数据最好包括笔10的笔尖在图形输入板格栅内的位置和笔10是否与图形输入板平面接触的输入板接触状态的X，Y座标。在上面规定的WaComTablet处理器的情况下，工作状态可能是指示为“笔提起”，“笔向下”或“笔接近出了输入板”该组合数据还最好包括相应于单个图形输入板数据点的加速计数据点的平均值。笔10的状态可从图形输入板12发送的信号导出，或通过与笔10的笔尖相连的工作开关，正如步骤212的描述的，或通过其它方法导出笔10的状态。步骤212辨别笔表面接触终止。来自步骤210的数据可不包括笔10表面接触状态。在这种情况下，笔10的表面接触状态可从加速度数据中导出。该加速度数据被滤波以去除了噪声之外的分量。例如，加速度数据由ButterWorth数字滤波器滤波，该滤波器在由JohnWiley&Sons于1987年出版的T.W.Parks和C.SBurrus所著的“数字滤波器设计”第7章第7.3.3节描述，使用具有0.7至0.9的低频截止频率的第4级纸数字滤波器。然后滤波的加速度数据对时间积分。然后分析积分的滤波的加速度数据的斜率，确定斜率超过门限值的那一点。斜率超过门限值的那一点取为具有“笔向下”状态的第一点。斜率降到门限值以下的那一点取作为具有“笔提起”状态的第一点。该门限值与前面描述的门限值可能是相同的或者可能是不相同的。在根据加速度计数据确定笔状态的情况下，设有“笔接近出去”的状态。上面描述的门限值对于特定的笔型和书写平面可预先确定，这些门限值可由学习过程对于特定的个人进行确定，或可由其它方法来确定。步骤215，辨别各个符号和字。从前面部骤来的数据被分为代表各个符号的数据。包括“笔向上…”或“笔接近出去”的状态被定义为“笔不向下”。最好是，具有“笔不向下”状态的相邻数据点数用于指示符号或字的结束，这些数据点数代表“笔不向下”状态的特定期间。典型地，从200毫秒至400毫秒的范围内“笔不向下”状态期间用于指示符号的结束。在800毫秒至1200毫秒范围的“笔不向下”状态期间典型地用于指示字的结束。加一方面，符号或字的结束可由不是符号的一部分的数据点指示，这些数据点代表笔的运动，或由其它方式指示。从步骤215输出的数据包括符号结束和字结束数据。步骤220，规范化组合的数据。组合的位置数据和加速度计数据随时或用其它方式被规范化。附录A是一个C编程语言的计算机表，包括实现步骤220优选程序。该程序包括第II节“预先——预处理”中的如下程序正常的，与由日常使用的各种规定一起。步骤230；滤波组合的数据。从前面步骤接收的规范化的组合数据被滤波，以便除去噪声。通过相邻点的迭代平滑完成滤波，直到由于平滑操作信号的总变化小于希望的数据精度，或用其它合适的方式实现滤波。步骤240参数化组合的数据。根据选择用于代表每个符号的准则参数化该数据。现在再参见图5A至5D，这些图用图说明一些参数。如果笔包括单个加速度计，优选地参数据包括如下在规范化之前的点数；笔状态的规范化信号；加速度的规范化信号；α角的正弦，α角规定为与当前数据点(Xi，Yi，Acczi)相关的矢量和图5A所示XY平面之间的角度；α角的余弦；β角的正弦，β角规定为在连接在前面点(Xi-2，Yi-2，AccZi-2)之前的点和当前的点(Xi，Yi，Acczi)的矢量和连接在图5B中所示空间(X，Y，ACCZ)中随后点(Xi+2，Yi+2，ACCZi+2)之后的点与当前点的矢量之间的角度；β角的余弦；另一个替代方案，该笔例如可包括三个加速度计，它们不需要互相正交。如果加速度计不是互相正交，该加速度数据可变换为互相正交的座标系统中的等效数据如下假定用矢量U＝(U1，U2，U3)T表示非正交信号，而用U＝(U1′U2′，U3′)T表示正交信号，这里T表示移置(transpose)。那么U1′＝A0A-1U，这里A是三个加速度计的静态，灵敏度矢量A＝(A1，A3，A3)。在规定方位不运动期间，从加速度计的输出计算静态灵敏度矢量。A0是直角座标系统灵敏度的对角线矩阵，包括范数(norm)A1，A3和A3。当笔例如包括三个加速度计时，参数最好包括上述参数和加下参数α′的正弦，α角规定为与当前数据点(ACCXi，ACCYiACCZi)相关的矢量和在图5C中所示AccXAccY平面之间的角度；α′角的余弦；β′角的正弦，β′角规定为在连接在前面数据点(AccXi-2，AccYi-2，AccZi-2)如当前点(AccXi，AccYi，AccZi)的矢量和在图5D所示空间(AccX，AccY，AccZ)内在随后的点(AccXi+2，AccYi+2，AccZi+2)之后的点与当前的点连接的矢量之间的角度；β′角的余弦。步骤250一般化参数。学习符号的参数代表符号的特定情况。由系统存储的符号原型代表由那个人画出符号的一般特性。因此，学习符号的参数由一些合适方式一般化，例如通过从该符号前面情况计算每个参数值平均值与从该符号当前情况计算每个参数值。步骤260更新每人每个符号原型数据库。前面步骤的新计算的参数被存储在每人每符号原型数据库中。图4B的优选方法包括作为图4A描述的一部分所描述的步骤。为了简短起见，等同于图4A步骤的那些步骤的描述已省略了。图4B步骤的剩余步骤包括如下步骤300对于每人每个符号原型数据库中的每个原型建立样值和原型之间比较的索引，对原型参数进行组合。根据本发明的优选实施例，所有参数被组合在一起产生比较索引。附录A是一个用C编程语言的计算机表，包括优选的实现步骤300的程序。该程序包括如下这些程序在第V节“符号识别”中找到make-Corr；Correl-hem；obj-funct；与程序使用的各种规定在一起。根据本发明的另一个优选实施例，来自图形输入板数据的参数被组合并且一起比较，而来自加速度计数据的参数分别组合和比较，这样在样值和原型之间产生两个比较度量。附录B是以C编程语言的计算机表，包括最佳实现步骤300的程序。该程序包括如下，这些程序在第IV节“识别程序”def-k-class；def-k-letter；def-k-word；def-k-row；mut-metric；metric-dir-y；metric-dir-x；与由程序使用的各种规定在一起。步骤310建立一个表或由类似性分类的概率符号的表。根据索引或在步骤300产生双较的索引，根据本发明的一个优选实施例，产生通过类似性分类的概率符号的单个表。根据本发明的另一个优选实施例，产生两个类似性分类概率符号的分离的表。当产生两个分离的表时，一个表大概包括基于图形输入板数据的符号，而另一个表大概包括基于加速度计的符号。附录B是以C编程语言的计算机表，包括最佳实现步骤310的程序。该程序包括如下该程序在第IV节“识别程序”中找到主要分部分“分出类”；sort-a；sort-b；sort-c；sort；check-map；read-map；r-matt；add-metric；sort-add；与由程序使用的各种规定在一起。步骤320根据表或多个表，前面混乱和字典数据库选择正确的符号和正确的字。如果预先产生一个表，具有最大类似性的符号是选择正确符号的候选符号。如果产生一个以上的表，这些表被组合而且在组合表上具有高类似性的符号是选择正确符号的候选符号。这些表可由表最好决程序组合，表决程序首先形成两个表的逻辑乘。附录B是以C编程语言的计算机表，包括最佳实现步骤320的程序。这些程序包括在标题为“从图形输入板和加速度识别”一节中找到的那些程序，与由该程序使用的各种规定在一起。如果两个表的逻辑乘是空的，那么在两个表中没有符号出现，输出是从位置数据产生的表。如果逻辑乘不是空的，那么至少一个符号出现在两个表中，该输出表包括在两个输入表的逻辑乘组中包括的、根据在两个表中包含平均概率分类的所有符号。上述的混乱数据库提供信息，它允许根据前面不正确辨别正确选择正确的符号。上述混乱数据库包括每个符号其它符号的表，其它符号与第一符号混乱，例如，符号“f”经常与符号“b”混乱。当这样的输入发现对于表中的符号包含前面的混乱时，该符号或一些符号与表中的符号混乱加到该表中。根据前面的例子，如果在该表中发现符号“f”，那么符号“b”被加到该表中。每个字结束的指示已经作为从步骤215的输出传送，如上所述，根据该指示，对该表中的每个符号的包括很可能辨别的很可能的词被辨别。对于字典检查很可能的字。该字典包括两个字典，一般的字典用于系统的所有用户即个人字典用于该系统的每个用户。如果对于很可能的字输入存在于该字典内，该字被选择为正确有辨别。如果在该字典中没有找到很可能的字，形成表中所有可能字的组合，对字典的每一个字进行检查。在字典中找到的所有这样的字中，具有最高类似性的字被选择作为正确的辨认。如果在字典中没有找到任一个字，很可能的字被选择作为正确的辨别。步骤330检查看一看是否已输入了一个校正。在识别过程中，最好地是系统用户提供识别每个符号的可视指示。在检测到字结束以后，系统的用户最好提供一种识别字的可视指示。用户可人工地指示那个给定的字是不正确地识别而且可输入校正。步骤340更新以前的混乱数据库。根据在步骤330输入的人工校正或基于字典的自动校正，以前的混乱数据库被更新。如果被校正的字在字典中没有找到，则个人字典也被更新。现在再参见图6A，该图是图1A的数字化的笔/加速度计10的最佳机械结构的简化说明图。笔10可包括一个电磁笔，例如型号为WACOMSP-200，可从德国的WACOM计算机系统公司买到，或设计与适当型号的图形输入板一起使用的其它任何合适的笔。笔10还包括一个电磁线圈410，它连同图形输板12一起工作，提供笔10点位置的指示。笔10还包括一个墨水再装管420，它提供在纸上或在其它表面上书写的能力。笔10还包括三个插入的相互正交的加速度计25，例如可用IC传感器，型号为ICS3031-2。另一方面，也有可能多个加速度计不需要正交安置。根据另一个可选择的方案，可能是只有一个加速度计。参见图1A如上所述，笔10还包含相连的放大器30。笔10还包括通信电缆450，用于发送数据到控制电路40。另一个替代方案，该数据可通过任何类型的适当通信链路，例如超声波，红外线，或任何其它合适的方式进行发送。现在再参见图6B，该图是图1B的数字化笔/加速度计10的优选机械结构的简化说明图。图10可包括一个机壳，例如ABS塑料机壳或其它合适的机壳。笔10进一步包括墨水再装管420和弹簧，它提供在纸上或在别的表面上书写的能力。笔10还包括三个插入的相互正交的加速度计25，例如可用IC传感器，型号为ICS3031-2。另一方面，也有可能多个加速度计不需要正交放置，根据另一个可替代方案，可能只有一个加速度计。笔10还包括上面参照图1A描述的附属大器30。笔10还包括如上文所规定的超声发射机80。笔10还包括用于向控制电路90发送数据的通信电缆450。另外一方面，数据可以通过任何种类的适当的通信链路发送，诸如超声、红外、或任何其他的适合的手段。现在参照图7，该图是一个构成的手写识别设备另外可代替优选实施例的简化图示说明和按照本发明的操做。笔10被用于在笔记本上、在纸张上、或在其他任何适合的表面所描述的，但是一个或多个加速度计25包括多个加速度计。图7的设备包括一个扫描器500，诸如一个LogitechScanMan256型扫描器。用户用笔在书写表面512上写。除了这里参照图7扫描的以外，参照图1在上面描述的也用于图7。笔10通过控制电路40向数据处理器50发送加速度数据。在书写结束以后，表面512被扫描器500扫描。根据来自笔10和扫描器500的组合的数据面后进行认识和识别。现在再参照图8，图8是图7的手写识别设备的简化框图。图8的手写识别设备接收来自笔10和扫描器500的输入。当手写识别设备的用户移动笔10时，笔10发送在加速教导控制630和/或加速手写教导控制650时间范围内描述笔10的加速度的数据。用在这里的术语OCR叫做光字符识别。当扫描书写表面512时，扫描器500向OCR教导控制635和/或OCR控制655发送描述在表面512上的图象的数据。来自笔10和扫描器500的数据分别可以发送到加速度教导控制器630或OCR教导控制器635。对于每个使用手写识别系统的人，该人第一次使用该手写识别系统之前，发生向加速度教导控制器630或OCR教导控制器635进行发送。向加速度教导控制器630或OCR教导控制635还出现在检测到识别差错；利用加速度教导控制630或OCR教导控制635，当检测出差错时这里叫做自适应教导。加速度教导控制器630或OCR教导控制器635对收到的数据进行操作，其中数据与该数据相连系的手动提供的符号码的识别一起代表用户当书写一个符号时手的移动。加速度教导控制器630而后修改数据库640，每人每符号加速度数据库；OCR教导控制器635修改数据库645、每人每符号OCR数据库。数据库640和数据库645包括对于每个符号的加速度和符号形状的原型，该原型包括对于每个人对每个符号的数据规范。另外一方面，来自笔10和扫描器500的数据可以分别被发送到加速度手写识别控制器650或OCR控制器635。加速度手写识别控制器650和OCR控制器655对分别来自笔10和扫描器500的接收数据进行操作，识别由笔10在扫描500上的移动所代表的符号。加速度手写识别控制器650的输出包括一个符号码表和它们的相应概率。加速度手写识别后置处理电路660根据符号码表和概率和根据后置处理的信息，该信息最好包括以前混乱和字典的数据库。加速度手写识别后置处理电路660的输出是一个由类似性分类的符号码和/或字的表。识别字存储电路670为每个被识别的字存储由加速度手写识别后置电路660输出的类似字的分类的表。该分类的表被保持以便以后进行处理。OCR控制器655为在从扫描器500扫描每个符号的输出包括由类似性分类的可能的符号码的表。OCR控制器655例如可以由任何适当的商品化的OCR系统实现。字串匹配器680接收由加速度手写识别后置处理电路660的输出字表和由OCR控制器655输出的概率的符号码表作为输入。字串匹配器680找到它的两个输入表之间的相符。字串匹配器680的输出包括字的和/或符号串的表，和在书写表面512上的每个字的和/或串的部分。现在再参照图9A和9B，这些图是说明按照本发明的优选类施例图7的手写识别设备操作的简化流程图。图9A表示教导程序，图9B表示识别程序。图9A的的优选方法包括作为图4A的一部分已效描述过了。出于简洁的原因，与图4A中相同的步骤的描述已被省略。在图9A中剩下的步骤包括以下步骤步骤710读加速度计的数据。加速度数据包括代表由加速度计25取样测量加速度的数据点。最好是，取样速率大约是每秒1600个数据点，平均全部8个点产生每秒约200个数据点输出。步骤712识别笔表面接触终结，来自步骤710的数据不包括笔10的表面接触状态。笔10的表面接触状态正如在上它参考图形输入板接触数据在解释步骤212那样，可以从加速度数据得到。步骤715识别个别的符号和字。来自前面步骤的数据被分为代表个别符号的数据。包括“笔提起”的状态的状态在这里叫做“笔未落底”。最好是，多个连续的具有“笔未落底”的数据点，这些数据点代表“笔未落底”状态的一个特定的持续期，被用于指示一个符号或一个字的终结。一般来说，“笔未落底”的状态持续期在200毫秒到400毫秒范围内被用来指示一个符号的终结。“笔未落底”的状态持续期在从800毫秒到1200毫秒范围一般被用于指示一个字的终结。另外一种方式，一个符号或一个字的终结可以利用不是符号的一部分的代表笔移动的数据点来指示，或者其他方式。从步骤715的数据输出包括符号终结和字终结的数据。步骤720规格化加速度计数据。加速度计数据被按时间或通过其他方式规格化。在上文参照步骤220的附件A是一个包括各程序的以C编程语言的计算机列表，这些程序是步骤720的优选实施方案。这些程序包括在部分II中的下列程序“预先一预处理”；规定；以反利用程序规定的各种定义。步骤730滤波加速度计数据。从前面步骤接收的已规格化的加速度数据被滤波，以侵去掉噪声。滤波可以通过各相邻点的重复平滑直至由于平滑操作信号总的变化小于要求的数据精度，或通过其他适合的方式。步骤740参数化加速度计数据。数据按照从当前的每个符号中选择的准则被参数化。如果各加速度计不是互相正交的，加速度数据正如上文参照步骤240所描述的那样，可以被变换为在相互正交座标系中等效的数据。参数最好包括以下在规格化以前的点数；笔状态的规格化信号；正加速度的规格化信号；参照步骤240上文限定的角α’的正弦；角α’的余弦；参照步骤240上文所限定的角β’的正弦；角β’的余弦。步骤760修改每人每符号加速度原型数据库。从前面步骤新近计算的各参数被存储到每人每符号加速度原型数据库。步骤770是否预定的正文已经到达？是否该终结已经到达是由该预定正文文件的终结已经到达确定的。如果没有，程序从步骤710继续。如果该终结已经到达，程序从步骤780继续。步骤780扫描书写过的正文。利用扫描器500扫描表面512上书写过的正文。步骤790OCR教导过程。对于在正文中的每个符号，识别对应于书写在表面512上的特征。步骤795修改每人每字符OCR原型数据库。在每人每符号OCR原型数据库中修改在步骤790中被识别的特征。图9B的优选方法包括作为图4A和图9A描述的一部分已经被描述过。为了简化起见，与图4A和9A相同步骤的那些步骤的描述已被省略。在图9B中剩余的步骤包括以下步骤800对于在每人每符号加速度原型数据库中的每个原型，建立样值与原型之间比较的索引，在原型中组合所有各参数。按照本发明的一个优选实施例，所有参数被组合在一起产生该比较索引。附件A是包括各程序的C编程语言的计算机表，这些程序是步骤800的优选实施方案。程序包括在第V部分可找到的下列内容进行—修正(makd-corr)；相关—范围(correl-nem)；目标—函数(obj-funct)；以及由各程序所用的各种定义。步骤810产生由类似性存储的概率符号的表。根据在步骤800中产生的比较指数或各指数，产生由类似性分类的概率符号的一个单一的表。步骤820根据该表、以前混乱的数据库和字典，选择正确的符号和正确的字。具有最大类似性的符号成为候选者，以候选者中选出正确的符号。正如上文参照步骤320所描述的，以前混乱的数据库提供了信息，允许以前不正确的识别修正选择正确的符号。如上所述，每个字的终结的指示已经作为步骤715的输出被通过。根据该指示，最类似的字，包括在表中对每个符号的最类似的识别被识别出。如果在字典中未找到最类似的字，在表中形成所有可能的字的组合和对照字典选择每一个字。在所有的在字典上被找到的那些字中，具有最高类似性的字而后被选为正确的识别。如果在字典中这些字没有，最类似的字被选为正确的识别。步骤822存储识别信息。由前面步骤输出最可能分类的表被存储，用于以后的处理。步骤824检查正文的终结。利用输入装置70用户指示正文的终结。步骤826扫描写过的正文。扫描器500被使用去扫描书写表面512。被扫描的图象输出到步骤828。步骤828执行OCR。OCR控制器655被用于执行对来自前面步骤的扫描图象的光字符识别。步骤828的输出包括来自步骤826的扫描图象的每一个符号，由类似性分类的概率符号码的表和每个符号在扫描图象中的位置。OCR控制器655例如可以由任何适宜的商品OCR系统实现。步骤830寻找匹配字。对于每个来自加速度的字，找出在OCR中的所有精确匹配的字和包括位置；或不匹配的标记列出它们。对于在加速度表中被匹配被找到的每个字，检查随后的字，看是否该随后的字处于按由OCR表所指示的各个随后的位置上；这种过程持续进行直至没有更为相符的字被找到。在加速度表中对于每个字可能有若干相符。更为相符的字的序列利用相符的以前的表的最后一个字之后下一个字的开始被找到。对于在加速度表中每个剩下的不相符字来说，在OCR表中最接近的匹配字里根据某些测量差异被识别的。例如，差异测量可以是在表中两上字之间的多个相符的字母，利用最少两上字母相同进行的。然后检查部分相同字的相邻范围，如果该范围之前和之后是相同的，则我们判定该部分相同字是相同的。现在检查在OCR表中的不相同的字。对于任何不相同的字，如果该范围之前和之后的字是相同的，该字认为是相同的。可以选择地，任何其他上下文感知方法，诸如语法检查或其他适合的识别遗漏部分的方法可以被用于识别仍然不相符的字。任何剩余的不相符的字通过用户人工地进行识别。步骤840修改以前混乱的数据库。根据在步骤330输入的人工校正或根据字典的自动校正，修改的前混乱的数据库。基于人工校正，如果在字典中未找到经校正的字，个人字典也要修改。应当理解为在附录中所描述的具体实施例程试图提供未发明的一个极为详细的公开而不是要进行限制。应理解为，为了清楚，是以各分别的实施例的上下文描述的本发明还可以提供一个单一实施例的组合。相反，为了简洁，以一个单一实施例的上下文描述的本发明的各个特征也可以被单独地提供或在任何适合的分组合中。本专业的技术人员将理解，本发明不限制在已具体地表示和描述在上文的内容。相反，本发明的范围仅由下列的权利要求来限定。说明书附录包括附录A-E，其中附录A23页附录B113页附录C7页附录D6页附录E7页附录A根据复合信号的识别定义和数据结构<prelisting-type="program-listing"><![CDATA[Board.Hfile/*Functioninit_datatr(portbase)setscommunicationwithdatatranslationboardviaportportbase.Itreturns 0-communicationwasestablished； -1-erroronboard(boardisnotexist).*/∥intinit_datatr(int)；intnewcomp(void)；intread_ch(intchannel，intgain)；∥intread_point(structpoint*，int)；/*intread_block(structpoint*，intmax_numb_point， inttimeout_for_begin，inttimeout_for_end， intkey_mouse_stop)；*/∥intread_symbol(structpoint*，int，int)；intmshit(void)；voidclose_datatr(void)；#definePORT_BASE0×210#defineKEY_STOP0×1#defineMOUSE_STOP0×2#defineKEY_MOUSE_STOP0×3#definePEN_WAIT0×1#definePEN_NOWAIT0×0Data.Hfilestructpoint_pen{unsignedax；unsigneday；unsignedaz；unsignedpn；}；structpoint_tablet{intx；inty；intp；}；#defineSYNCROBIT0×80Datar.Hfile#definePORT_BASE0×210#defineCSR0×0#defineGAIN0×1#defineDAC0_LOW0×2#defineDAC0_HIGH0×3#defineDAC1_LOW0×4#defineDAC1_HIGH0×5#defineCHANNEL_AX0×4#defineCHANNEL_AY0×5#defineCHANNEL_AZ0×6#defineCHANNEL_PN0×7#defineSTATUS0×e#defineCHANNEL_EMPTY0×0#defineIDREGISTER0×f#defineGAIN_10×00#defineGAIN_20×40#defineGAIN_40×80#defineGAIN_80×C0#defineIER0×21#defineIIR0×20#defineIRQ00×08#defineIRQ10×09#defineIRQ20×0a#defineIRQ30×0b#defineIRQ40×0c#defineIRQ50×0d#defineIRQ60×0e#defineIRQ70×0f/*structpoint{unsignedax；unsigneday；unsignedaz；unsignedpn；}；*/#defineMINUS_PEN1700/*#definePEN_UP0×2#definePEN_DOWN0×4#definePEN_THRSLD200#defineEMPTY0*/#defineBUFSIZE0×80#defineTIME_COUNT3000#include＜dos.h＞Ser.Hfile/*----------------------------------------------------------------------* 文件名SERIAL.H SER.C使用的一些定义*----------------------------------------------------------------------*/#defineCOM11#defineCOM22#defineCOM1BASE0×3F8/*BaseportaddressforCOM1*/#defineCOM2BASE0×2F8/*BaseportaddressforCOM2*//* 8250UART有10个；通过7端口地址可存取的寄存器，这里是关于COMIBASE和 COM2BASE的地址。注意波特率寄存器。只有当DLAB是开启时，DLL和DLH 激活。DLAB是LCR的比特7。 TXR到串行端口的输出数据 RXR来自串行端口的输入数据 LCR初始化串行端口 LER控制中断产生 IIR识别中断 MCR送控制信号到调制解调器 LSR监视串行端口的状态 MSR接收调制解调器的状态 DLL波特率除数的低字节 DHH波特率除数的高字节*/#defineTXR0/*Transmitregister(WRITE)*/#defineRXR0/*Receiveregister(READ)*/#defineIER1/*InterruptEnable*/#defineIIR2/*InterruptID*/#defineLCR3/*Linecontrol*/#defineMCR4/*Modemcontrol*/#defineLSR5/*LineStatus*/#defineMSR6/*ModemStatus*/#defineDLL0/*DivisorLatchLow*/#defineDLH1/*DivisorlatchHigh*//*------------------------------------------------------------------*LCR中的比特值 bit意义 ---------- 0-100＝5bits，01＝6bits，10＝7bits.11＝8bits. 2Stopbits. 30＝parityoff，1＝parityon. 40＝parityodd，1＝parityeven. 5Stickyparity. 6Setbreak. 7Toggieportaddresses.*-------------------------------------------------------------------*/#defineNO_PARITY0×00#defineEVEN_PARITY0×13#defineODD_PARITY0×03/*-------------------------------------------------------------------* LSR中的比特值 bit意义 ---------- 0Dataready. 1Overrunerror-Dataregisteroverwritten. 2Parityerror-badtransmission. 3Framingerror-Nostopbitwasfound. 4Breakdetect-Endtotransmissionrequested. 5Transmitterholdingregisterisempty. 6Transmittershiftregisterisempty. 7Timeout-offline.*-------------------------------------------------------------------*/#defineRCVRDY0×01#defineOVRERR0×02#definePRTYERR0×04#defineFRMERR0×08#defineBRKERR0×10#defineXMTRDY0×20#defineXMTRSR0×40#defineTIMEOUT 0×80/*-------------------------------------------------------------------* MCR中的比特值 bit意义 ---------- 0DataTerminalReady.Computerreadytogo. 1RequestToSend.Computerwantstosenddata. 2auxillaryoutput#1. 3auxillaryoutput#2.(Note；Thisbitmustbe settoallowthecommunicationscardtosend interruptstothesystem) 4UARTouputloopedbackasinput. 5-7notused.*------------------------------------------------------------------*/#defineDTR0×01#defineRTS0×02#defineMC_INT0×08/*------------------------------------------------------------------* MSR中的比特值 bit意义 ---------- 0deltaClearToSend. 1deltaDataSetReady. 2deltaRinglndicator. 3deltaDataCarrierDetect. 4ClearToSend. 5DataSetReady. 6RingIndicator. 7DataCarrierDetect.*------------------------------------------------------------------*/ #defineCTS0×10 #defineDSR0×20/*-------------------------------------------------------------------*IER中的比特值 bit意义 ---------- 0Interruptwhendatareceived. 1Interruptwhentransmitterholdingreg.empty. 2Interruptwhendatareceptionerror. 3Interruptwhenchangeinmodemstatusregister. 4-7Notused.*-------------------------------------------------------------------*/#defineRX_INT0×01/*-------------------------------------------------------------------*IIR中的比特值 bit意义 ---------- 0Interruptpending 1-2InterruptIDcode 00＝Changeinmodemstatusregister， 01＝Transmitterholdingregisterempty. 10＝Datareceived， 11＝receptionerror，orbreakencountered. 3-7Notused.*-------------------------------------------------------------------*/#defineRX_ID0×04#defineRX_MASK0×07/* 这是8259可编程中断控制器(PIC)的端口地址*/#defineIMR0×21/*InterruptMaskRegisterport*/#defineICR0×20/*InterruptControlPort*//* 当硬件中断结束时，中断末端要送到8259的控制端口*/#defineEOI0×20/*EndOfInterrupt*//* 当PIC不显示出(FALSE)时，IMR告诉PIC服务于中断*/#defineIRQ30×F7/*COM2*/#defineIRQ40×EF/*COM1*/ 当PIC不显示出(FALSE)时，IMR告诉PIC服务于中断 */ #defineIRQ30×F7/*COM2*/ #defineIRQ40×EF/*COM1*/intflag； intSetSerial()； intSetOthers(intParity，intSits，intStopBit)； intSetSpeed(intSpeed)； intSetPort(intPort)； voidinit_serial(void)； voidcomm_off(void)； voidsetallport(intPort，intSpeed，intParity，intBits，intStopBit)； intputchport(char)； voidputstrport(char*)； intgetchport(void)； voidoffport()；Serconst.Hfile/*-------------------------------------------------------------------* 文件名SERCONST.H SER.C所使用的一些定义*-------------------------------------------------------------------*//* 8250UART有10个通过7端口地址可存取的寄存器，这里是关于COMIBASE和 COM2BASE的地址。注意波特率寄存器。只有当DLAB是开启时，DLL和DLH 激活。DLAB是LCR的比特7。 TXR到串行端口的输出数据 RXR来自串行端口的输入数据 LCR初始化串行端口 LER控制中断产生 IIR识别中断 MCR送控制信号到调制解调器 LSR监视串行端口的状态 MSR接收调制解调器的状态 DLL波特率除数的低字节 DHH波特率除数的高字节*/#defineTXR0/*Transmitregister(WRITE)*/#defineRXR0/*Receiveregister(READ)*/#defineIER1/*InterruptEnable*/#defineIIR2/*InterruptID*/#defineLCR3/*Linecontrol*/#defineMCR4/*Modemcontrol*/#defineLSR5/*LineStatus*/#defineMSR6/*ModemStatus*/#defineDLL0/*DivisorLatchLow*/#defineDLH1/*DivisorlatchHigh*/#defineDLAB0×80/**//*--------------------------------------------------------------------------*BitvaluesheldintheLineControlRegister(LCR) bitmeaning ----------0-100＝5bits，01＝6bits，10＝7bits，11-8bits. 2Stopbits. 30＝parityoff，1＝parityon. 40＝parityodd，1＝parityeven. 5Stickyparity. 6Setbreak. 7Toggleportaddresses.*-------------------------------------------------------------------*/#defineNO_PARITY0×00#defineEVEN_PARITY0×18#defineODD_PARITY0×08/*-------------------------------------------------------------------* BitvaluesheldintheLineStatusRegister(LSR) bitmeaning ---------- 0Dataready. 1Overrunerror-Dataregisteroverwritten. 2Parityerror-badtransmission. 3Framingerror-Nostopbitwasfound. 4Breakdetect-Endtotransmissionrequested. 5Transmitterholdingregisterisempty. 6Transmittershiftregisterisempty. 7Timeout-offline.*------------------------------------------------------------------*/#defineRCVRDY0×01#defineOVRERR0×02#definePRTYERR0×04#defineFRMERR0×08#defineBRKERR0×10#defineXMTRDY0×20#defineXMTRSR0×40#defineTIMEOUT0×80/*------------------------------------------------------------------*BitvaluesheldintheModemOutputControlRegister(MCR). bitmeaning ---------- 0DataTerminalReady.Computerreadytogo. 1RequestToSend.Computerwantstosenddata. 2auxillaryoutput#1. 3auxillaryoutput#2.(NoteThisbitmustbe settoallowthecomunicationscardtosend interruptstothesystem) 4UARTouputtoopedbackasinput. 5-7notused.*-----------------------------------------------------------------*/#defineDTR0×01#defineRTS0×02#defineMC_INT0×08/*----------------------------------------------------------------*BitvaluesheldintheModemInputStatusRegister(MSR) bitmeaning0deltaClearToSend. 1deltaDataSetReady. 2deltaRingIndicator. 3deltaDataCarrierDetect. 4ClearToSend. 5DataSetReady. 6RingIndicator. 7DataCarrierDetect.*------------------------------------------------------------------*/#defineCTS0×10#defineDSR0×20/*------------------------------------------------------------------* BitvaluesheldintheInterruptEnableRegister(IER) bitmeaning ---------- 0Interruptwhendatareceived. 1Interruptwhentransmitterholdingreg.empty. 2Interruptwhendatareceptionerror. 3Interruptwhenchangeinmodemstatusregister. 4-7Notused./*------------------------------------------------------------------*#defineRX_INT0×01/*------------------------------------------------------------------* BitvaluesheldintheInterruptIdentificationRegister(IIR). bitmeaning ---------- 0Interruptpending 1-2InterruptIDcode 00＝Changeinmodemstatusregister， 01＝Transmitterholdingregisterempty， 10＝Datareceived， 11＝receptionerror，orbreakencountered. 3-7Notused.*------------------------------------------------------------------*/#defineRX_ID0×04#defineRX_MASK0×07/* 这是8259可编程中断控制器(PIC)的端口地址*/#defineIMR0×21/*InterruptMaskRegisterport*/#defineICR0×20/*InterruptControlPort*//* 当硬件中断结束时，中断末端要送到8259的控制端口*/#defineEOI0×20/*EndOfInterrupt*//*当PIC不显示出(FALSE)时，IMR告诉PIC服务于中断*//*unsignedcharIRQ[8]＝{-0×01，-0×02，-0×04，-0×80， -0×10，-0×*/#defineIRQ30×F7/*COM2*/#defineIRQ40×EF/*COM1*/intSerSetPortBase(int，unsigned*)；intSerSetSpeed(unsigned，long)；intSerSetBitsParityStopBit(unsigned，int，int，int)；intSerPutChar(unsigned，unsignedchar)；intSerPutString(unsigned，unsignedchar*)；intSerInitBuffer(unsigned)；intSerGetChar(unsigned)；intSerTestDSR(unsigned)；intSerTestCTS(unsigned)；/*intflag；intSetSerial()；intSetOthers(intParity，intBits，intStopBit)；intSetSpeed(intSpeed)；intSetPort(intPort)；voidinit_serial(void)；voidcomm_off(void)；voidsetallport(intPort，intSpeed，intParity，intBits，intStopBit)；intputchport(char)；voidputstrport(char*)；intgetchport(void)；voidoffport()；*/Tablet.Hfile#definePEN_DOWN1#definePEN_UP0#definePEN_OUTPROX99#defineTBL_WACOM_II3#defineTBL_DATA_ASCII1#defineTBL_DATA_BINARY0#defineTBL_MODE_STREAM3#defineTBL_MODE_SWITCH_STREAM2#defineTBL_MODE_SUPRESSED0#defineTBL_MODE_POINT0#defineTBL_TYPE_ABSOLUTE0#defineTBL_TYPE_RELATIVE1#defineTBL_MILLIMETERS0#defineTBL_INCHES1#defineTBL_ALWAYS_TRANSMIT_YES1#defineTBL_ALWAYS_TRANSMIT_NO0#defineTBL_BAUD_192007#defineTBL_BAUD_96006#defineTBL_BAUD_48005#defineTBL_BAUD_24004#defineTBL_BAUD_12003#defineTBL_BAUD_6002#defineTBL_BAUD_3001#defineTBL_BAUD_1500#defineTBL_PARITY_NONE0#defineTBL_PARITY_ODD1#defineTBL_PARITY_EVEN2#defineTBL_STOPBITS_10#defineTBL_STOPBITS_21#defineTBL_DSR_MONITOR_OFF0#defineTBL_DSR_MONITOR_ON1#defineTBL_DATALENGTH_70#defineTBL_DATALENGTH_81#defineTBL_TRANSFER_RATE_MAX7#defineTBL_TRANSFER_RATE_1006#defineTBL_TRANSFER_RATE_675#defineTBL_TRANSFER_RATE_504#defineTBL_TRANSFER_RATE_203#defineTBL_TRANSFER_RATE_102#defineTBL_TRANSFER_RATE_51#defineTBL_TRANSFER_RATE_10#defineTBL_ORIGINLOG_UPPER_LEFT1#defineTBL_ORIGINLOG_LOWER_LEFT0#defineTBL_DATA_TERMINATOR_CR_LF2#defineTBL_DATA_TERMINATOR_LF1#defineTBL_DATA_TERMINATOR_CR0intread_point_tablet_pen(unsigned，int， structpoint_tablet*，structpoint_pen*[8])；intfind_set_parameters_tablet(intcomport，unsigned*portbase)；intinit_tablet(intport，unsigned*portbase，intcommand_set， intdata_format，intoperation_mode，intorigin_type， intunit_mesure，intalways_transmit，intspeed， intparity，intstopbit，intdsr_monitor， intdatalength，inttransfer_rate，intorig_log， intdata_terminator，intmax_x，intmax_y)；voidclose_tablet(unsiqnedportbase)；]]></pre>I.从装置中读出<prelisting-type="program-listing"><![CDATA[/*这个程序同步地从图形书写板和加速度计中读数据intread_point_tablet_pen(unsignedportbase，intread_pen， structpoint_tablet*tablet， structpoint_penpen[8]){intind_package＝0，reply，debug[10]，i；unsignedcharpackage[7]＝{0，0，0，0，0，0，0)；if(read_pen) read_point_pen(&pen)；i＝0；/*Waitingforsynchro-bit*/do{if((reply＝SerGetChar(portbase))＜0) returnreply；debug[i++]＝reply；if((package＝(char)reply)&SYNCROBIT) break；}while(ind_package++＜10)；/*Error-Nosynchro-bitin10bytes*/if(ind_package＞＝10) returnSER_SYNCROBIT；/*从书写板中读下面的6个字节，及从加速度计中读6点for(ind_package＝1；ind_package＜7；ind_package++){if(read_pen){ read_point_pen(&pen[ind_package])；}if((reply＝SerGetChar(portbase))＜0) returnreply；package[ind_package]＝(char)reply；}/*读加速度计中最后的点*/if(read_pen) read_point_pen(&pen[ind_package])；/*计算书写板的信号值*/tablet-＞x＝(package&0×03)＜＜14；tablet-＞x+＝(package[1]&0×7f)＜＜7；tablet-＞x+＝(package[2]&0×7f)；if(package&0×04) tablet-＞x＝-tablet-＞x；tablet-＞y＝(package[3]&0×03)＜＜14；tablet-＞y+＝(package[4]&0×7f)＜＜7；tablet-＞y+＝(packaqe[5]&0×7f)；tablet-＞p＝0；if(！(package&0×40)) tablet-＞p＝99；if(package[3]&0×04) tablet-＞y＝-tablet-＞y；if(package[6]&0×20) tablet-＞p＝(package[6]&0×1f)；return0；}]]></pre>II.预处理<prelisting-type="program-listing"><![CDATA[/*TwoproceduresNormalizationintimeandfilteringtheinputsignalsbysmoothing */voidnormal(intnum_old，floatarr_old[]，intnum_new，floatarr_new[]){doublekoeff；intind_old，ind_new；koeff＝(double)(num_old-1)/(float)(num_new-1)；arr_new＝arr_old；for(ind_new＝1；ind_new＜num_new-1；ind_new++){ind_old＝(int)(floor(koeff*ind_new))；arr_new[ind_new]＝(ind_old+1-koeff*ind_new)*arr_old[ind_old]+ (koeff*ind_new-ind_old)*arr_old[ind_old+1]；arr_new[ind_new]＝arr-new[ind_new]；}arr_new[ind_new]＝arr_old[num_old-1]；}floatsmooth1(intnum，floatz[]){intind；floattemp；floatnorma；for(ind＝1，norma＝0；ind＜num-1；ind++){temp＝(z[ind-1]+z[ind]+z[ind+1])/3；norma+＝abbs(z[ind]-temp)；z[ind]＝temp；}returnnorma；}]]></pre>III.参数提取<prelisting-type="program-listing"><![CDATA[/*根据输入入信号计算一个符号的参数。*/intmake_par(chararg_ch){structpoint{unsignedintx12；unsignedinty12；unsignedintz12；unsignedintpen4；}point，points[500]；intread_next_symbol(FILE*，structpoint[])；charfile_name[40]；intlen，number_points＝0；FILE*in_file，*out_file[10]，*out_letter，*out_bin；floatparam[6][NUMBER_POINT]，sum_par[6][NUMBER_POINT]；intindex＝0，max_point；intind，start；intcur_x，cur_y，cur_z，cur_p；floatarr_x[MAX_POINT]，arr_y[MAX_POINT]，arr_z[MAX_POINT]，arr_p[MAX_POINT]；/*初始化结果阵列到零*/for(ind＝0；ind＜6；ind++) for(index＝0；index＜NUMBER_POINT；index++){ param[ind][index]＝0.0； sum_par[ind][index]＝0.0； }/*识别数据的文件*/sprintf(file_name，*％03d.smb*，(int)arg_ch)；if((in_file＝fopen(file_name，＂rb＂))＝＝NULL){ strcpy(ext_err，file_name)； return-4；}start＝0；/*读文件的数据*/while((max_point＝read_next_symbol(in_file，points))＞0){for(index＝0；index＜max_point；index++){ arr_x[index]＝(float)points[index].x； arr_y[index]＝(float)points[index].y； arr_z[index]＝(float)points[index].z； arr_p[index]＝(float)points[index].pen；}arr_p＝arr_p[max_point-1]＝1；start++；number_points+＝max_point；/*调用Make_par_let程序计算参数1-6make_par_let(arr_x，arr_y，arr_z，arr_p，param，max_point-1./*计算每个参数的平均值*/for(ind＝0；ind＜6；ind++)for(index＝0；index＜NUMBER_POINT；index++)( sum_par[ind][index]+＝param[ind][index]；}}for(ind＝0；ind＜6；ind++)for(index＝0；index＜NUMBER_POINT；index++) sum_par[ind][index]/＝start；sum_par＝(float)number_points/start；fclose(in_file)；/*writeavginBinaryfile*/sprintf(file_name，＂％03d.par＂，(int)arg_ch)；out_letter＝fopen(file_name，＂wb+＂)；for(index＝0；index＜6；index++) fwrite(sum_par[index]，sizeof(float)，NUMBER_POINT，out_letter)；fclose(out_letter)；returnstart；}voidmake_par_let(floatarr_x[]，floatarr_y[]，floatarr_z[]， floatarr_p[]，fioatparam[6][NUMBER_POINT]，intmax_point){floatend_smooth；floatnew_arr_x[500]，new_arr_y[500]，new_arr_z[500]，new_arr_p[500]；intind，index；/*调用用户预处理*/normal(max_point，arr_x，NUMBER_POINT，new_arr_x)；normal(max_point，arr_y，NUMBER_POINT，new_arr_y)；normal(max_point，arr_z，NUMBER_POINT，new_arr_z)；normal(max_point，arr_p，NUMBER_POINT，new_arr_p)；max_point＝NUMBER_POINT；for(ind＝0；ind＜max_point；ind+++){ arr_x[ind]＝new_arr_x[ind]； arr_y[ind]＝new_arr_y[ind]； arr_z[ind]＝new_arr_z[ind]； arr_p[ind]＝new_arr_p[ind]；}while((end_smooth＝smooth1(max_point，arr_x))＞NUMBER_POINT/10)；while((end_smooth＝smooth1(max_point，arr_y))＞NUMBER_POINT/10)；while((end_smooth＝smooth1(max_point，arr_z))＞NUMBER_POINT/10)；/*lnitializationofparameters*/param＝(float)arr_pparam[1]＝(arr_z-arr_z);param[2]＝0.0；param[3]＝0.0；param[4]＝0.0;param[5]＝0.0；param[1]＝(float)arr_p[1]/*Calculationofparameters*/param[1][1]＝(arr_z[1]-arr_z)；elev(arr_x[2]-arr_x，arr_y[2]-arr_y，arr_z[2]-arr_z， &param[2][1]，&param[3][1])；param[4][1]＝0.0；param[5][1]＝0.0；for(index＝2；index＜max_point-2；index++)[ param[index]＝(float)arr_p[index]； param[1][index]＝(arr_z[index]-arr_z)；elev(arr_x[index+1]-arr_x[index-1]，arr_y[index+1]-arr_y[index-1]，arr_z[index+1]-arr_z[index-1] &param[2][index]，&param[3][index])；angles(arr_x[index+2]-arr_x[index]， arr_y[index+2]-arr_y[index]， arr_z[index+2]-arr_z[index]， arr_x[index]-arr_x[index-2]， arr_y[index]-arr_y[index-2]， arr_z[index]-arr_z[index-2]， &param[4][index]，&param[5][index])；index＝index；}param[index]＝(float)arr_p[index]；param[1][index]＝(arr_z[index]-arr_z)；elev(arr_x[index+1]-arr_x[index-1]，arr_y[index+1]-arr_y[index-1]，arr_z[index+1]-arr_z[index-1]， &param[2][index]，&param[3][index])；param[4][index]＝0.0；param[5][index]＝0.0；index++；/*Calculationofparametersforlastpoint*/param[index]＝(float)arr_p[index]；param[1][index]＝(arr_z[index]-arr_z)；param[2][index]＝0.0；param[3][index]＝0.0；param[4][index]＝0.0；param[5][index]＝0.0；/*该程序用于计算上升角的正弦和余弦*/voidelev(floatx，floaty，floatz，float*cos_ug，float*sin_ug){floatnorma；norma＝(float)sqrt(x*x+y*y+z*z)；if(norma＜.00001){*cos_ug＝0.0；*sin_ug＝0.0；return；}*cos_ug＝((float)sqrt(x*x-/*y))/norma*sm_ug＝z/norma；return；}]]></pre>/*该程序计算β角的正弦和余弦*/voidangles(floatx1，floaty1，floatz1，floatx2，floaty2，floatz2，float*cos_ug，float*sin_ug){floatnorma1，norma2，x3，y3，z3；norma1＝(float)sqrt(x1*x1+y1*y1+z1*z1)；norma2＝(float)sqrt(x2*x2+y2*y2+z2*z2)；if(norma1＜.0001‖norma2＜.0001){*cos_ug＝0.0；*sm_ug＝0.0；return；}*cos_ug＝(x1*x2+y1*y2+z1*z2)/norma1/norma2；x3＝(y1*z2-z1*y2)；y3＝(x2*z1-x1*z2)；z3＝(x1*y2-x2*y1)；*sin_ug＝((float)sqrt(x3*x3+y3*y3+z3*z3))/norma1/norma2；return；}IV.训练程序<prelisting-type="program-listing"><![CDATA[/*初级教导程序**/intfirst_teach(void){FILE*fp；FILE*fpout；inti；charbuf[4]，NdxStr[4]，symbols[256]；intndx＝0，max_symb＝0intnum_sym；comment(＂convertingdatafiles，pleasewait＂，0，1)；if((fp＝fopen(＂symbols.dat”，＂r＂))＝＝NULL){strcpy(ext_err，＂symbols.dat＂)；hide_comment(＂convertingdatafiles，pleasewait＂，0)；return(-4)；}while(fscanf(fp，＂％s＂，buf)＞0)symbols[max_symb++]＝buf；fclose(fp)；fpout＝fopen(＂text.adp＂，＂w＂)；for(ndx＝0；ndx＜max_symb；ndx++){sprintf(NdxStr，＂％03d＂，ndx)；if((num_sym＝make_par(symbols[ndx]))＜＝0){hide_comment(＂convertingdatafiles，pleasewait＂，0)；return(num_sym)；}elsefor(i＝0；i＜num_sym；i++) fprintf(fpout，＂％c＂，symbols[ndx])；}fclose(fpout)；hide_comment(＂convertingdatafiles，pleasewait＂，0)；return(0)；}/*适用的原型的程序*/floathuge*all_par[100]；intfirst_adap(void){floatold_rec，new_rec；intcount＝0，temp；char*text；charstr[80]；if((temp＝read_text(＂try.txt＂，&text))＜0)return(temp)read_param()；new_rec＝recogn(＂try.prl，text，0，0)；sprintf(str，＂％3f-beforeadaptation＂，new_rec)；comment(str，-1，1)；do{if(new_rec＜0){hide_comment(str，-1)；while(all_par[temp]！＝NULL){ farfree(all_par[temp++])；}return((int)new_rec)；}if(new_rec＞.995)break；old_rec＝new_rec；new_rec＝recogn(＂try.prl＂，text，1，0)；if(new_rec＜0){hide_comment(str，-1)；while(all_par[temp]！＝NULL){ farfree(all_par[temp++])；}return((int)new_rec)；}hide_comment(str，-1)；sprintf(str，“％3f-inadaptation＂，new_rec)；comment(str，-1，1)；new_rec＝recogn(＂try.prl＂，text，0，0)；hide_comment(str，-1)；sprintf(str，＂％3f-afteradaprion”，new_rec)；comment(str，-1，1)；if(new_rec＜0){ hide_comment(str，-1)； while(all_par[temp]！＝NULL){ farfree(all_par[temp++])； } return((int)new_rec)；}}while(fabs(old_rec-new_rec)＞.005&count++＜9)；hide_comment(str，-1)；farfree(text)；while(all_par[temp]！＝NULL){farfree(all_par[temp++])；}return0；}]]></pre>V.符号的识别<prelisting-type="program-listing"><![CDATA[structpoint(unsignedintx12；unsignedinty12；unsignedintz12；unsignedintpen4；}；structreply{intndx；floatweight；}；floatrecogn(char*file_pen，char*text，intadapt，intwords){floatold_rec，new_rec，probs[10][20]；intcount＝0；charsymbols[256]，buf[4]；unsignedlongttt；intmax_symb；FILE*in_file，*file_symb，*temp_word；intsymb；unsignedlongstart_word，end_word；floatparam[6][NUMBER_POINT]；intindex＝0，max_point；structreply*repl；inttemp；intNgood＝0；intind，NumSymbols，ndx；structpointsymb_pnts[MAX_POINT]；floatarr_x[MAX_POINT]，arr_y[MAX_POINT]，arr_z[MAX_POINT]，arr_p[MAX_POINT]；intmap[256]；intorder＝0；charletters[10][20]，dict_wrds[10][20]；intend_of_word＝0；intwrdlen；floatsum[10]，maxsum，ndx_maxsum；charorg_wrd[20]，f_word[20]；inttxt_width；inti；if((file_symb＝fopen(＂symbols.dat＂，＂r＂))＝＝NULL){strcpy(ext_err.＂symbolsdat＂)；return(-4)；}for(ind＝0；ind＜256；ind++)mad[ind]＝-1；max_symb＝0；while(fscanf(file_symb，＂％s＂，buf)＞0){map[buf]＝max_symb；symbols[max_symb++]＝buf；}fclose(file_symb)；symbols[max_symb]＝0；for(ind＝0ind＜6ind++)for(index＝0index＜NUMBER_POINT；index++){ param[ind][index]＝0.0；}if((in_file＝fopen(file_pen，＂rb＂))＝＝NULL){strcpy(ext_err，file_pen)；return-4；}index＝0NumSymbols＝0；symb＝-1； if(adapt) repl＝make_corr(param，symbols，symb)； else{ repl＝make_corr(param，symbols，-1)； } if(repl.ndx＜0) return(repl.weight)； if(repl.ndx＝＝symb) Ngood++； else Ngood＝Ngood； }fclose(in_file)；if(NumSymbols＝＝0)return0； elsereturn(Ngood/(float)NumSymbols)；}/*计算所有原型及所识别符号的所有特征的相似性*/externfloathuge*all_par[100]；structreply{intndx；floatweight；}；staticintcomm_count＝0，abs_count＝0；intobj_funct(float[100][7]，int，int，float[100]，float[7]，int[10])；floatcorrel_hem(float[NUMBER_POINT]，float[NUMBER_POINT]，float)；floatcorrel(float[NUMBER_POINT]，float[NUMBER_POINT])；structreply*make_corr(fioatcur_par[6][NUMBER_POINT]，char*symbols，intsymb){FILE*cur_file；intind_repl，ind_corrct，ind，max_symb，ind_symb，index；structreplyarr_repl[30]；intarr_ind[10]；floatres[100].nres[7].old_max_pnt＝cur_par，com_wight；floatold_max_pnt2，corr[100][7].tmp_par[6][NUMBER_POINT]；charbuf[8]；intiterat；structreplyrt；inti，j；max_symb＝strlen(symbols)；for(ind_symb＝0；ind_symb＜max_symb；ind_symb++){for(i＝0；i＜6；i++) for(j＝0；j＜NUMBER_POINT；j++) tmp_par[i][j]＝all_par[ind_symb][i*100+j]；if(tmp_par＞0){ cur_par＝old_max_pnt； corr[ind_symb][N_PAR-1]＝1.0*(1- min(fabs(tmp_par-cur_par)/cur_par，1))； old_max_pnt＝cur_par； tmp_par＝1.； cur_par＝1.； corr[ind_symb]＝correl_hem(cur_par，tmp_par，.9)； for(ind＝1；ind＜N_PAR-1；ind++){ corr[ind_symb][ind]＝correl(cur_par[ind]，tmp_par[ind])； }}elsefor(ind＝1；ind＜N_PAR-1；ind++){ corr[ind_symb][ind]＝0.0；}}if(symb＜0){ index＝obj_funct(corr，max_symb，N_PAR，res，nres，arr_ind)； iterat＝20；}else{ sprintf(buf，＂％03d.par＂，(int)symbols[symb])； for(i＝0；i＜6；i++) for(j＝0；j＜NUMBER_POINT；j++) tmp_par[i][j]＝all_par[symb][i*100+j]； iterat＝0； while((index＝obj_funct(corr，max_symb，N_PAR，res，nres，arr_ind))＞0 &&(arr_ind！＝symb)) { if(iterat＞19)break； for(ind＝0，ind_corrct＝0；ind＜N_PAR-1；ind++) if(corr[symb][ind]＜0.95*nres[ind]) { ind_corrct++； for(index＝0；index＜NUMBER_POINT；index++) tmp_par[ind][index]＝tmp_par[ind][index]*9 +cur_par[ind][index]*1； } if(corr[symb][ind]＜0.95*nres[ind]) { ind_corrct++； tmp_par＝tmp_par*9+old_max_pnt*.1； } if(lind_corrct){ iterat＝20； break； }iterat++； cur_par＝old_max_pnt； corr[symb][N_PAR-1]＝1-fabs(tmp_par-cur_par)/cur_par； old_max_pnt＝cur_par； old_max_pnt2＝tmp_par； tmp_par＝1.； cur_par＝1.； corr[symb]＝correl_hem(cur_Par，tmp_par，.9)； for(ind＝1；ind＜N_PAR-1；ind++){ corr[symb][ind]＝correl(cur_par[ind]，tmp_par[ind])； } cur_par＝old_max_pnt； tmp_par＝old_max_pnt2；}/*while*/}/*else*/if((iterat＜20)&&(index＞0)&&(iterat＞0)){ cur_file＝.fopen(buf，＂w+b＂)； for(index＝0；index＜N_PAR-1；index++) fvrite(tmp_par[index]，sizeof(float)，NUMBER_POINT，cur_file)； fclose(cur_file)； for(i＝0；i＜6；i++) for(j＝0；j＜NUMBER_POINT；j++) all_par[symb][i*100+j]＝tmp_par[i][j]；}index＝min(index，g)；arr_ind[index]＝-1；res[arr_ind[index]]＝-1；for(i＝0；i＜＝index；i++){ arr_repl[i].ndx＝arr_ind[i]； arr_repl[i].weight＝-res[arr_ind[i]]；}returnarr_repl；}/*计算两个矢量之间的相关性*/floatcorrel(floatfirst[NUMBER_POINT]，floatsecond[NUMBER_POINT]){floatsumxy＝0.0，sumx＝0.0，sumy＝0.0，sumx2＝0.0，sumy2＝0.0；inti_d，i_s；for(i_s＝0；i_s＜NUMBER_POINT；i_s++){ sumxy+＝first[i_s]*second[i_s]； sumx+＝first[i_s]； sumy+＝second[i_s]； sumx2+＝first[i_s]*first[i_s]； sumy2+＝second[i_s]*second[i_s]；}if((sumx2-sumx*sumx/NUMBER_POINT)＜0‖ (sumy2-sumy*sumy/NUMBER_POINT)＜0) return0； if((sumxy＝(sumxy-sumx*sumy/NUMBER_POINT)/sqrt(sumx2-sumx*sumx/NUMBER_POINT)/ sqrt(sumy2-sumy*sumy/NUMBER_PCINT))＜.5) return0；returnsumxy；}/*笔向上/向下参数的相似性函数*/floatcorrel_hem(floatpar1[NUMBER_POINT]，floatpar2[NUMBER_POINT]，floatborder){intindex；floatresult＝0.0；for(index＝1；index＜NUMBER_POINT；index++)result+＝fabs(par1[index]-par2[index])；result/＝NUMBER_POINT；result＝1-result；if(result＜border)return0；returnresult；}/*选择可能被识别的符合表*/intobj_funct(floatarr[100][7]，intn_symb，intn_par， floatres[100]，floatnres[7]，intarrrindex[30]){intind_s，ind_p，ind_arr＝0；floatmax_res＝0.0，cur_res，abs_res＝0.0；intresult＝-1；for(ind_s＝0；ind_s＜n_symb；ind_s++){for(ind_p＝0，cur_res＝0.0；ind_p＜n_par；ind_p++) cur_res+＝arr[ind_s][ind_p]；res[ind_s]＝cur_res；if(cur_res＞max_res){result＝ind_s；max_res＝cur_res；}}abs_res＝max_res*.85；do{arrindex[ind_arr++]＝result；res[result]＝-res[result]；for(ind_s＝0，max_res＝0.0；ind_s＜n_symb；ind_s++)if(res[ind_s]＞max_res){result＝ind_s；max_res＝res[ind_s]；}}while(max_res＞abs_res&&ind_arr＜30)；for(ind_p＝0，ind_p＜n_par，ind_p++)for(ind_s＝0，nres[ind_p]＝-5；ind_s＜n_symb；ind_s++)nres[ind_p]＝max(arr[ind_s][ind_p]，nres[ind_p])returnind_arr；}]]></pre>附录B根据第二种方法的识别图形书写板识别I.开始<prelisting-type="program-listing"><![CDATA[ oidmain(void) voidinit_map(void)；inti，j；for(i＝0；i＜NUM_SYMBOLS；i++)for(j＝0；j＜2；j++)map_char[i][j]＝0；init_map()；extemintmap_char[NUM_SYMBOLS][2]；oidsave_map(void)FILE*fp；inti；fp＝fopen(＂map_ch＂，＂wb＂)；for(i＝0；i＜NUM_SYMBOLS；i++)fprintf(fp，＂％d％d\n＂，map_char[i]，map_char[i][1])；fclose(fp)；oidinit_map(void)inti，j；for(i＝97，j＝0；i＜123；j++，i++){map_char[j]＝i；∥a-zmap_char[j][1]＝0；}for(i＝65，j＝26；i＜91；j++，i++){map_char[j]＝i；∥A-Zmap_har[j][1]＝0；}for(i＝48，j＝52；i＜58；j++，i++){map_char[j]＝i；map_char[j][1]＝0；∥0123456789}for(i＝43，j＝62；i＜47；j++，i++){map_char[j]＝ipr＝0；break；}}}}for(count＝0；count＜num_lig；count++){temp＝ARR_LIG1[count].x_end；ARR_LIG1[count].x_end＝ARR_LIG1[count].x_beg；ARR_LIG1[count].x_beg＝temp；temp＝ARR_LIG1[count].y_end；ARR_LIG1[count].y_end＝ARR_LIG1[count].y_beg；ARR_LIG1[count].y_beg＝temp；temp＝ARR_LIG1[count].pns_end；ARR_LIG1[count].pns_end＝ARR_LIG1[count].pns_beg；ARR_LIG1[count].pns_beg＝temp；}return(num_lig)；}/***************************************************************functionord_1_lig1()definesoneorderrightupstrokesfromthebeginingofrightupstrokesinthearr_extremoms[]，recordsoneorderrightupstroke’sparameterstoARR_ORD_1_LIG1[]accordingtohisnumberandlabelsMASKpenn.***************************************************************/intord_1_lig1(ntnum_of_extmns，intnum_lig1){intpr，num_lig，num_pns，count，num_str；unsignedtemp；pr＝0；num_pns＝0；num_lig＝0；if(num_lig1＝＝0)return(0)；for(count＝0；count＜num_lig1；count++){pr＝0；if(ARR_LIG1[count].pns_beg＜(unsigned)2)continue；if(penn[ARR_LIG1[count].pns_beg].form_code＝＝0)continue；if(arr_extremoms[ARR_LIG1[count].pns_beg-1].dir＞2)continue；if(penn[ARR_LIG1[count].pns_beg-1].form_code！＝0)continue；if(arr_extremoms[ARR_LIG1[count].pns_beg-1].pen_sts＝＝(unsigned)0)continue；for(num_str＝ARR_LIG1[count].pns_beg-1；num_str＞＝1；num_str-){if((arr_extremoms[num_stt].dir＜＝2)&&(arr_extremoms[num_str].dir＞＝0)&&(penn[num_str].form_code＝＝0)){if(pr＝＝0){ARR_ORD_1_LIG1[num_lig].num＝num_lig；ARR_ORD_1_LIG1[num_lig].pns_beg＝num_str；ARR_ORD_1_LIG1[num_lig].x_beg＝arr_extremoms[num_str+1].x_corARR_ORD_1_LIG1[num_lig].y_beg＝arr_extremoms[num_str+1].y_corARR_ORD_1_LIG1[num_lig].pns_end＝num_str；]]></pre>II.训练过程<prelisting-type="program-listing"><![CDATA[/*用于教导的主程序*/structTABLE_EXTREMOMSarr_extremoms[MAX_NUM_OF_EXTREMOMS]；structPOINTarr_cor[MAX_NUM_OF_POINTS]；structLINARR_DIR[MAX_AMOUNT_DIREC]；structLIGARR_LIGAT[MAX_AMOUNT_DIREC]；structLIGARR_ORD_1_LIGAT[MAX_AMOUNT_DIREC]；structLIGARR_LIG1[MAX_AMOUNT_DIREC]；structLIGARR_ORD_1_LIG1[MAX_AMOUNT_DIREC]；structLIGARR_LIG2[MAX_AMOUNT_DIREC]；structLIGARR_ORD_1_LIG2[MAX_AMOUNT_DIREC]；structLIGARR_LIG3[MAX_AMOUNT_DIREC]；structLIGARR_ORD_1_LIG3[MAX_AMOUNT_DIREC]；structMASKpenn[MAX_NUM_OF_EXTREMOMS]；charour_sent[MAX_LENGTH_SENTENSE]；structXx[MAX_AMOUNT_DIREC]；structYy[MAX_AMOUNT_DIREC]；intmap_char[NUM_SYMBOLS][2]；intamp_y；intnum_of_extrms；floaty_vec_beg；floaty_vec_end；floatx_vec_beg；floatx_vec_end；voidmain(intarg，char*par[]){FILE*fp；charinfile[30]；intnum；structffblkffblk；intdone；read_map()；fp＝fopen(＂fextr.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂feat.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂feat1.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂fsent0.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂fsent1.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂fsent2.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂fsent3.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂fsent4.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂fsent5.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂fsent6.out＂，＂wb＂)；fclose(fp)；done＝findfirst(＂*tab＂，&ffblk.0)；num＝1；while(ldone){sprintf(infile，＂％-12.12s＂，ffblk.ff_name)；fp＝fopen(infile，＂r＂)；if(lfp){printf(＂Can’topeninputfile-％s-\n＂，infile)；return；}if(infile！＝′B′)letter＝tolower(infile)；else{if(isdigit((int)infile[1])！＝0)lefter＝tolower(infile)；elseletter＝infile[1]}num＝transform(fp，&letter)；if((num＞＝0)&&(num＜7))save_files(num，&letter)；if(num＝＝-3)num＝1；fclose(fp)；done＝findnext(&ffblk)；}save_map()；}inttransform(FILE*fp，char*letter){externstructPOINTarr_cor[MAX_NUM_OF_POINTS]；/*arrayofcoordinates*/externstructTABLE_EXTREMOMSarr_extremoms[MAX_NUM_OF_EXTREMOMS]；/*arrayofspecialpoints(i.e.extremums，changingofpenposition*/externstructTABLE_EXTREMOMSarr_exc_extrms[MAX_NUM_OF_EXTREMOMS]；/*arrayofexcludedextremums，itisexcludedfromthearrayofextremumsbyexcludingclosepoints*/externstructLINARR_DIR[MAX_AMOUNT_DIREC]；externstructLINARR_DIR[MAX_AMOUNT_DIREC]；externstructLIGARR_LIGAT[MAX_AMOUNT_DIREC]；externstructLIGARR_ORD_1_LIGAT[MAX_AMOUNT_DIREC]；externstructLIGARR_LIG1[MAX_AMOUNT_DIREC]；externstructLIGARR_ORD_1_LIG1[MAX_AMOUNT_DIREC]；externstructLIGARR_LIG2[MAX_AMOUNT_DIREC]；externstructLIGARR_ORD_1_LIG2[MAX_AMOUNT_DIREC]；externstructLIGARR_LIG3[MAX_AMOUNT_DIREC]；externstructLIGARR_ORD_1_LIG3[MAX_AMOUNT_DIREC]；externstructMASKpenn[MAX_NUM_OF_EXTREMOMS]；externcharour_sent[MAX_LENGTH_SENTENSE]；externstructXx[MAX_AMOUNT_DIREC]；externstructYy[MAX_AMOUNT_DIREC]；externintamp_y；externintnum_of_extrms；intcount；intnum；intnum_direc；floatlength_of_letter；intnum_ligat_d_r_o；intnum_ord_1_nlgat；intnum_ligat_u_r_i；intnum_ord_1_lig1；intnum_ligat_d_l_o；intnum_ord_1_lig3；intnum_ligat_u_l_i；intnum_ord_1_lig2；intindex_max_dir；intamp_x；num＝read_symb(fp，letter)；if((num＝＝-2)‖(num＝＝1))return(-1)；if(num＝＝0)return(-1)；if(num＝＝-3)return(-3)；if(num＞MAX_NUM_OF_POINTS-1){printf(＂Inputfiletoohuge\n＂)；getch()；return(-1)；}num_of_extrms＝calc_extremoms(num)；if(num_of_extrms＞MAX_NUM_OF_EXTREMOMS-1){printf(“Arrayofextremumstoohuge\n＂)；getch()；return(-1)；}length_of_letter＝letter_length(num，arr_cor)；filtr(num_of_extrms)；amp_y＝ampl_y(num，arr_cor)；amp_x＝ampl_x(num，arr_cor)；start(num_of_extms)；if((num_direc＝direct(num_of_extrms))＝＝0){printf(“It’snodirections\n＂)；getch()；return(0)；}index_max_dir＝length_angl(num_direc，ARR_DIR)；/***************************filterforlongdown****************************/if(filtr_1(length_of_letter，num_direc，num_of_extrms)＝＝1){start(num_of_extrms)；if((num_direc＝direct(num_of_extrms))＝＝0){printf(“It’snodirectionsafterconversionandfiltr_1\n＂)；getch()；return(0)；}index_max_dir＝length_angl(num_direc，ARR_DIR)；}if(filtr_2(length_of_letter，num_direc)＝＝1){start(num_of_extrms)；if((num_direc＝direct(num_of_extrms))＝＝0){printf(＂It’snodirectionsafterconversionfiltr_1and_2\n＂)；getch()；return(0)；}index_max_dir＝length_angl(num_direc，ARR_DIR)；}if(filtr_3(length_of_letter，num_direc，num_of_extrms)＝＝1){start(num_of_extrms)；if((num_direc＝direct(num_of_extrms))＝＝0){printf(“It’snodirectionsafterconversionfiltr_1，_2and_3\n”)；getch()return(0)}index_max_dir＝length_angl(num_direc，ARR_DIR)；}num_ligat_d_r_o＝ligat(num_of_extrms，num_direc)；num_ligat_d_r_o＝lig1(num_of_extrms，num_direc)；num_ligat_d_r_o＝lig2(num_of_extrms，num_direc)；num_ligat_d_r_o＝lig3(num_of_extrms，num_direc)；num_ord_1_ligat＝ord_1_ligat(num_of_extrms，num_ligat_d_r_o)；num_ord_1_lig1＝ord_1_lig1(num_of_extrms，num_ligat_u_r_i)；num_ord_1_lig2＝ord_1_lig2(num_of_extrms，num_ligat_u_l_i)；num_ord_1_lig3＝ord_1_lig3(num_of_extrms，num_ligat_d_l_o)；curve(num_of_extrs)；if(sentense(num_of_extrms)＝＝0)printf(“It’snosentense\n”)；conv_dir_train(num_direc，amp_y，ARR_DIR，x，y)；return(num_direc)；}/*Thismoduleisforcalculatingandmanipulatingextremums，itincludesthreeprocedures(1)calc_extremumsTofindtheextremumsofthesymbol，andthechangeinpen”points.(2)find_max_extrmTofindthemax/minX-coordinateandthemax/minY-coordinateofthexymbol.(3)analyse_extremumsAproceduretoanalysetheextremumsfoundsofar，mainlythisproceduremarkscloseextre-mumsassuspeciousextremums.*//**************************************************************************Theinputofthisprocedureisthearrayofcoordinateswhichholdsthecoordinatesofthesymbol，andthenumberofthesepoints，itfillsthespecialofpoints(i.e.，extremumsorchangeinpen)inthearrayarr_extremums，itreturnsthenumberofspecialpointsitfound.***************************************************************************/structTABLE_EXTREMOMSextrm[MAX_NUM_OF_EXTREMOMS]externstructPOINTarr_cor[MAX_NUM_OF_POINTS]；/*arrayofcoordinates*/externstructTABLE_EXTREMOMSarr_extremoms[MAX_NUM_OF_EXTREMOMS]；/*arrayofspecialpoints(i.e.extremums，changingofpen)position*/externstructTABLE_EXTREMOMSarr_exc_extrms[MAX_NUM_OF_EXTREMOMS]；/*arrayofexcludedextremums，inisexcludedfromthearrayofextremumsbyexcludingclosepoints*/structTABLE_EXTREMOMSarr_exc_extrm[MAX_NUM_OF_EXTREMOMS]；intcalc_extremoms(intnum_of_points){intdef_quart(intx，inty)；unsignedintindE；unsignedintnox；unsignedpen_was_up；intcrnt_quart，prev_quart；intcrnt_rot，prev_rot；intSx，Sy，PSx，PSy，a，b；intfirst_point＝1；intPndx＝0；unsignedintLastNdx；inti；indE＝0；ndx＝0；pen_was_up＝1；Sx＝0；Sy＝0；PSx＝0；PSy＝0；a＝0；b＝0；while(ndx＜num_of_points){while((arr_cor[ndx].pen_status)＝＝1){if(pen_was_up＝＝1){/*beginningextremom*/if(first_point＝＝1){inttSx，tSy；Sx＝(arr_cor[ndx+1].x_cor-arr_cor[ndx].x_cor)；Sy＝(arr_cor[ndx+1].y_cor-arr_cor[ndx].y_cor)；tSx＝(arr_cor[ndx+2].x_cor-arr_cor[ndx+1].x_cor)；tSy＝(arr_cor[ndx+2].y_cor-arr_cor[ndx+1].y_cor)；a＝Sx*tSy-Sy*tSx；b＝Sx*tSx+Sy*tSy；PSx＝Sx；PSy＝Sy；}else{/*forthepreviousENDINGextremom*/Sx＝(arr_cor[ndx].x_cor-arr_cor[Pndx].x_cor)；Sy＝(arr_cor[ndx].y_cor-arr_cor[Pndx].y_cor)；PSx＝(arr_cor[Pndx].x_cor-arr_cor[Pndx-1].x_cor)；PSy＝(arr_cor[Pndx].y_cor-arr_cor[Pndx-1].y_cor)；a＝PSx*Sy-PSy*Sx；b＝PSx*Sx+PSy*Sy；arr_extremoms[indE].p_ndx＝Pndx；arr_extremoms[indE].x_cor＝arr_cor[Pndx].x_corarr_extremoms[indE].y_cor＝arr_cor[Pndx].y_cor；arr_extremoms[indE].pen_sts＝0；arr_extremoms[indE].dir＝def_quart(PSx，PSy)；arr_extremoms[indE].out_rot＝def_quart(b，a)；{intPPSx，PPSy；PPSx＝(arr-cor[Pndx-1].x_cor-arr_cor[Pndx-2].x_cor)；PPSy＝(arr_cor[Pndx-1].y_cor-arr_cor[Pndx-2].y_cor)，a＝PPSx*PSy-PPSy*PSx；b＝PPSx*PSx+PPSy*PSy；arr_extremoms[indE].in_rot＝def_quart(b，a)；}indE++；PSx＝Sx；PSy＝Sy；{inttSx，tSy；Sx＝(arr_cor[ncx+1].x_cor-arr_cor[ndx].x_cor)；Sy＝(arr_cor[ndx+1].y_cor-arr_cor[ndx].y_cor)；tSx＝(arr_cor[ndx].x_cor-arr_cor[Pndx].x_cor)；tSy＝(arr_cor[ndx].y_cor-arr_cor[Pndx].y_cor)；a＝tSx*Sy-tSy*Sx；b＝tSx*Sx+tSy*Sy；}}cmt_quart＝def_quart(Sx，Sy)；crnt_rot＝def_quart(b，a)；arr_extremoms[indE].p_ndx＝ndx；arr_extremoms[indE].x_cor＝arr_cor[ndx].x_cor；arr_extremoms[indE].y_cor＝arr_cor[ndx].y_cor；arr_extremoms[indE].pen_sts＝1；if(first_point＝＝1){arr_extremoms[indE].dir＝15；arr_extremoms[indE].in_rot＝15；arr_extremoms[indE].out_rot＝15；ndx++；first_point＝0；}else{arr_extremoms[indE].dir＝def_quart(PSx，PSy)；arr_extremoms[indE].in_rot＝0；arr_extremoms[indE].out_rot＝def_quart(b，a)；}indE++；pen_was_up＝0；}eise{crnt_quart＝def_quart(Sx，Sy)；crnt_rot＝def_quart(b，a)；if((b＜0)&&((a/b)＜-10))crnt_rot＝2；if((b＜0)&&((a/b)＞10))crnt_rot＝6；if(((crnt_quart＝prev_quart)))/*‖((crnt_rot＞＝4)&&(prev_rot＜4))‖((crnt_rot＜4)&&(prev_rot＞＝4)))&&(prev_rot！＝15))*/{/*regularextremom*/if((abs(Sx)＞0)‖(abs(Sy)＞0)‖(b＜0)){if((ndx-1-arr_extremoms[indE-1].p_ndx)＞0){arr_extremoms[indE].p_ndx＝ndx-1；arr_extremoms[indE].x_cor＝arr_cor[ndx-1].x_cor；arr_extremoms[indE].y_cor＝arr_cor[ndx-1].y_cor；arr_extremoms[indE].pen_sts＝1；arr_extremoms[indE].dir＝prev_quart；arr_extremoms[indE].in_rot＝prev_rot；arr_extremoms[indE].out_rot＝crnt_rot；indE++；}}}}ndx++；Sx＝(arr_cor[ndx].x_cor_arr_cor[ndx-1].x_cor)；Sy＝(arr_cor[ndx].y_cor-arr_cor[ndx-1].y_cor)；a＝PSx*Sy-PSy*Sx；b＝PSx*Sx+PSy*Sy；PSx＝Sx；PSy＝Sy；prev_quart＝crnt_quart；prev_rot＝crnt_rot；}*endofwhile(arr_cor[ndx].penstatus＝＝1)*/if((pen_was_up＝＝0)&&(arr_cor[ndx-1].pen_status＝＝1))/*endingextremom*/Pndx＝ndx-1；pen_was_up＝1；LastNdx＝ndx-1；}ndx**}/*ndx\＝NumOfPoints*//*Addthelastspecialpointtothearray*/arr_extremoms[indE].p_ndx＝LastNdx；arr_extremoms[indE].x_cor＝arr_cor[LastNdx].x_cor；arr_extremoms[indE].y_cor＝arr_cor[LastNdx].y_cor；arr_extremoms[indE].pen_sts＝0；Sx＝(arr_cor[LastNdx-1].x_cor-arr_cor[LastNdx-2].x_cor)；Sy＝(arr_cor[LastNdx-1].x_cor-arr_cor[LaxtNdx-2].x_cor)；PSx＝(arr_cor[LastNdx-2].x_cor-arr_cor[LastNdx-3].x_cor)；PSy＝(arr_cor[LastNdx-2].y_cor-arr_cor[LastNdx-3].y_cor)；arr_extremoms[indE].dir＝def_quan(Sx，Sy)；a＝PSx*Sx-PSy*Sx；b＝PSx*Sx+PSy*Sy；arr_extremoms[indE].in_rot＝def_quart(b，a)；arr_extremoms[indE].out_rot＝15；return；indE)；}/***************************************************************************Thisprocedureistofindthemax/minX-coordinateandthemax/minY-coordinateofthesymbol.***************************************************************************/voidfind_max_extrm(intnum_of_extrms，int*Xmin，int*Xmax，int*Ymin，int*Ymax){unsignedinti＝0;*Xmin＝1200；*Xmax＝0；*Ymin＝1200；*Ymax＝0；while(i＜＝num_of_extrms){if(arr_extremoms[i].x_cor＜*Xmin)*Xmin＝arr_extremoms[i].x_cor；if(arr_extremoms[i].x_cor＞*Xmax)*Xmax＝arr_extremoms[i].x_cor；if(arr_extremoms[i].y_cor＜*Ymin)*Ymin＝arr_extremoms[i].y_cor；if(arr_extremoms[i].y_cor＞*Ymax)*Ymax＝arr_extremoms[i].y_cor；i++；}}/**********************************************************************correctdir，in_rot，out_rotforsuspiciouspoints，calledfromanalyse_extremums***********************************************************************/voidcorrect_extrm(inti，intPi，intj){intdef_quart(intx，inty)；intSx，Sy，PSx，PSy；intndx1，ndx2；inta，b；ndx1＝extrm[Pi].p_ndx；ndx2＝extrm[i].p_ndx；if(Pi＞0){if(extrm[Pi-1].pen_sts＝＝0){PSx＝arr_cor[ndx1].x_cor-arr_cor[extrm[Pi-1].p_ndx].x_cor；PSy＝arr_cor[ndx1].y_cor-arr_cor[extrm[Pi-1].p_ndx].y_cor；}else{PSx＝arr_cor[ndx1].x_cor-arr_cor[ndx1-1].x_cor；PSy＝arr_cor[ndx1].y_cor-arr_cor[ndx1-1].y_cor；}}else{PSx＝0；PSy＝0；}Sx＝arr_cor[ndx2].x_cor-arr_cor[ndx1].x_cor；Sy＝arr_cor[ndx2].y_cor-arr_cor[ndx1].y_cor；a＝PSx*Sy-PSy*Sx；b＝PSx*Sx+PSy*Sy；if(arr_exc_extrm[j-1].out_rot！＝15)arr_exc_extrm[j-1].out_rot＝def_quart(b，a)；PSx＝Sx；PSy＝Sy；arr_exc_extrm[j].dir＝def_quart(PSx，PSy)；arr_exc_extrm[j].in_rot＝0；if(arr_exc_extrm[j].out_rot！＝15){if(extrm[i].pen_sts＝＝0){Sx＝arr_cor[extrm[i+1].p_ndx].x_cor-arr_cor[ndx2].x_cor；Sy＝arr_cor[extrm[i+1].p_ndx].y_cor-arr_cor[ndx2].y_cor；}else{Sx＝arr_cor[ndx2+1].x_cor-arr_cor[ndx2].x_cor；Sy＝arr_cor[ndx2+1].y_cor-arr_cor[ndx2].y_cor；}a＝PSx*Sy-PSy*Sx；b＝PSx*Sx+PSy*Sy；arr_exc_extrm[j].out_rot＝def_quart(b，a)；}}/******************************************************************Aproceduretoanalysetheextremumsfoundsofar，mainlythisproceduremarkscloseextremumsassuspeciousextremums.********************************************************************intanalyse_extremoms(intnum_of_extrms){inti，j＝0；intcount＝0；intPi＝0；booleanFirstP＝TRUE；for(i＝1；i＜nurr_of_extrms；i++){if(((abs(extrm[i].x_cor-extrm[i+1].x_cor))＜2‖(abs(extrm[i].y_cor-extrm[i+1].y_cor))＜2)&&(extrm[i].in_rot！＝extrm[i+1].in_rot)&&(extrm[i].dir＝＝extrm[i+1].dir)&&(extrm[i]pen_sts＝＝1)&&(extrm[i-1].pen_sts！＝0))extrm[i].susp＝1；else{extrm[i].susp＝0；count++；}}extrm.susp＝0；extrm[i].susp＝0；count++；for(i＝0；i＜＝num_of_extrms；i++){if(extrm[i].susp＝＝0){arr_exc_extrm[j].p_ndx＝extrm[i].p_ndx；arr_exc_extrm[j].x_cor＝extrm[i].x_cor；arr_exc_extrm[j].y_cor＝extrm[i].y_cor；arr_exc_extrm[j].pen_sts＝extrm[i].pen_sts；arr_exc_extrm[j]dir＝extrm[i].dir；arr_exc_extrm[j].in_rot＝extrm[i].in_rot；arr_exc_extrm[j].out_rot＝extrm[i].out_rot；if(FirstP＝＝FALSE){correct_extrm(i，Pi，j)；FirstP＝TRUE；}jf(extrm[i].pen_sts＝＝0)FirstP＝TRUE；j++；}else{if(FirstP)Pi＝i-1；FirstP＝FALSE；}}for(i＝1；i＜＝count；i++)if(extrm[i-1].p_ndx＝＝(extrm[i].p_ndx-1))arr_exc_extrm[i].in_rot＝0；return(count)；}/*************************************************************functionlength_angl()calculateslengthfortheeachlongdownandreturnsthenumberofthelongdownwiththemaxlengt.**************************************************************/intlength_angl(intnum_lin，structLINZ[]){intcount，dy，max_dy，max_length，_max_length，i_max_dy；floattng；max_dy＝0；max_length＝0；for(count＝0；count＜num_lin；count++){dx＝Z[count].x_end-Z[count].x_beg；dy＝Z[count].y_end-Z[count].y_beg；Z[count].length＝(unsigned)sqrt((float)dx*(float)dx+if(max_dy＜abs(dy))(float)dy*(float)dy)；{max_dy＝abs(dy)；i_max_dy＝count；}if(max_length＜Z[count].length){max_length＝Z[count].length；i_max_length＝count；}if((dx＝＝0)&&(dy＜0))tng＝M_P1/2；/*90*/elseif((dx＝＝0)&&(dy＜0))tng＝-M_Pl/2；/*-90*/elseif((dx＝＝0)&&(dy＝＝0))tng＝999999；elsetng＝atan((float)dy/(float)dx)；if(tng＜0)tng＝tng+M_PI；/*angle+180*/Z[count].angle＝tng；}return(i_max_dy)}/***************************************************************functionampl_y()calculatesmaximumandminimumofycoordinateandreturnsy-amplitude.***************************************************************/intampl_y(intnum_of_points，structPOINTarr_cor[]){intmin，max，count.temp；min＝arr_cor.y_cor；max＝arr_cor.y_cor；for(count＝1；count＜＝num_of_points；count++){if(arr_cor[count].pen_status＝＝0)continue；if(max＜arr_cor[count].y_cor)max＝arr_cor[count].y_cor；if(min＞arr_cor[count].y_cor)min＝arr_cor[count].y_cor；}if(max＝＝min)max＝max+1；y_vec_beg＝(float)(arr_cor.y_cor_min)/(float)(max-min)；y_vec_end＝(float)(arr_cor[num_of_points-1].y_cor-min)/(float)(max-min)；return(abs(max-min))；}intampl_x(intnum_of_points，strudPOINTarr_cor[]){intmin，max，count，temp；min＝arr_cor.x_cor；max＝arr_cor.x_cor；for(count＝1；count＜＝num_of_points；count++){if(arr_cor[count].pen_status＝＝0)continue；if(max＜arr_cor[count].x_cor)max＝arr_cor[count].x_cor；if(min＞arr_cor[count].x_cor)min＝arr_cor[count].x_cor；}if(max＝＝min)max＝max+1；x_vec_beg＝(float)(arr_cor.x_cor_min)/(float)(max-min)；x_vec_end＝(float)(arr_cor[num_of_points-1].x_cor-min)/(float)(max-min)；return(abs(max-min))；}/*************************************************************functionconv_dir_train()calculatesrelativeordinatesofletterskeleton****************************************************************/voidconv_dir_train(intnum_dir.intamp_y，structLINZ[]，structXx[]，structYy[]){intcount；intx_min＝9999；inty_min＝9999；intx_max＝0；inty_max＝0；for(count＝0，count＜num_dir；count++){if(Z[count].x_beg＜x_min)x_min＝Z[count].x_beg；if(Z[count].x_beg＞x_max)x_max＝Z[count].x_beg；if(Z[count].x_end＜x_min)x_min＝Z[count]x_end；if(Z[count].x_end＞x_max)x_max＝Z[count].x_end；if(Z[count].y_beg＜y_min)y_min＝Z[count].y_beg；if(Z[count].y_beg＜y_max)y_max＝Z[count].y_beg；if(Z[count].y_end＜y_min)y_min＝Z[count].y_end；if(Z[count].y_end＜y_max)y_max＝Z[count].y_end；}for(count＝0；count＜num_dir；count++){x[count].x_b＝(float)(Z[count].x_beg-x_min)/(float)(y_max-y_min)；y[count].y_b＝(float)(Z[count].y_beg-y_min)/(float)amp_y；x[count].x_e＝(float)(Z[count].x_end-x_min)/(float)(y_max-y_min)；y[count].y_e＝(float)(Z[count].y_end-y_min)/(float)amp_y；}return；}floatletter_length(intnum_of_points，structPOINTarr_cor[]){inti；doubleres＝0.0；for(i＝0；i＜num_of_points；i++){if(arr_cor[i].pen_status！＝0)res＝res+hypot((double)((signed)arr_cor[i+1].x_cor-(signed)arr_cor[i].x_cor)，(double)((signed)arr_cor[i+1].y_cor-(signed)arr_cor[i].y_cor))；}return((float)res)；}/**fnctionfiltr()calculatesone’smorestroke’sdirectionsandcorrectsitinthearrayarrextremoms.**/voidfiltr(intnum_of_extrm){intcount，dir；intdef_quart(intx，inty)；for(count＝0；count＜＝num_of_extrm；count++){dir＝def_quart(arr_extremoms[count+1].x_cor_arr_extremoms[count].x_cor，arr_extremoms[count+1].y_cor-arr_extremoms[count].y_cor)；if(dir！＝arr_extremoms[count+1].dir)arr_extremoms[count+1].dir＝dir；}}/**functionfiler_1returns0，iftherewasn’tfiltrationcorrectsthearrayarr_extremoms[]andreturns1，iftherewasfiltrationfiltr_1takesawayalongdown，ifsheisfirstorlast，iftherearenopenstrokesbefore(forthefirst)orafter(forthelastlongdown)andifrelativelengthofdeletedlongdownisless0.2.**/intfittr_1(floatlength_of_letter，intnum_dir，intnum_of_extrm)/********************************return0therewas’tfiltration1wasfiltration*********************************/{inttemp＝0；intcount；if(((float)ARR_DIR.length/length_of_letter＜TRESH_F1)&&(ARR_DIR.pns_beg＝＝1)){for(count＝0count＜＝ARR_DIR.pns_end；count++)arr_extremoms[count].pen_sts＝0；temp＝1；}if(((float)ARR_DIR[num_dir-1].length/length_of_letter＜TRESH_F1)&&(ARR_DIR[num_dir-1].pns_end＝＝nur_of_extrm)){for(count＝ARR_DIR[num_dir-1].pns_beg-1；count＜＝ARR_DIR[num_dir-1].pns_end；count++)arr_extremoms[count].pen_sts＝0；temp＝1；}return(temp)；}/**functionfilr_2returns0iftherewasn’tfiltration.correctsarrayarr_extremoms[]，returns1，iftherewasfiltration.filtr_2takesawayaonepenstrokebetweemtwolongdown，ifdistancexbetweenlongdown＜＝5anddistanceybetweenlongdown＜＝2.**/intfiltr_2(floatlength_of_letter.intnum_dir){inttemp＝0，i；for(i＝0；i＜num_dir-2；i++){if(ARR_DIR[i+1].pns_beg-ARR_DIR[i].pns_end＞2)continue；if(abs(arr_extremoms[ARR_DIR[i+1].pns_bag].dir-arr_extremoms[ARR_DIR[i].pns_end].dir)＞1)continue；if(hypot((double)((signed)arr_extremoms[ARR_DIR[i+1].pns_beg].x_cor-(signed)arr_extremoms[ARR_DIR[i].pns_end].x_cor)，(double)((signed)arr_extremoms[ARR_DIR[i+1].pns_beg].y_cor-(signed)arr_extremoms[ARR_DIR[i].pns_end].y_cor))/(double)length_of_letter＜(double)TRESH_F2)arr_extremoms[ARR_DIR[i].pns_end+1].dir＝arrextremoms[ARR_DIR[i].pns_end].dir；temp＝1；}return(temp)；}/**functionfiltr_3returns0，iftherewasn’tfiltration.correctsarrayarr_extremoms[]，returns，iftherewasfiltration.takesawaylongdownbeforestrokewithpenup＝＝0，iflongdown’slength＜＝0.2frommaxlength.**/intfiltr_3(floatlength_of_letter，intnum_dir，intnum_of_extrm){inttemp＝0，i，mcount；i＝num_of_extrm；while(arr_extremoms[i].pen_sts＝＝0)i-；while(arr_extremoms[i].pen_sts＝＝1)i-；if(i＜＝0)return(temp)；else{for(count＝0；count＜num_dir；count++){if((i＞＝ARR_DIR[count].pns_beg)&&(i＜＝ARR_DIR[count].pns_end)&&((float)ARR_DIR[count].length/length_of_letter＜TRESH_F3)){for(m＝ARR_DIR[count].pns_beg-1；m＜＝ARR_DIR[count].pns_end；m++){arr_extremoms[m].pen_sts＝0；temp＝1；return(temp)；}}}}return(temp)}voidstart(intnum_of_extrms){intcount；for(count＝0；count＜MAX_AMOUNT_DIREC；count++){ARR_DIR[count].num＝0；ARR_DIR[count].pns_beg＝0；ARR_DIR[count].pns_end＝0；ARR_DIR[count].x_beg＝0；ARR_DIR[count].y_beg＝0；ARR_DIR[count].x_end＝0；ARR_DIR[count].y_end＝0；ARR_DIR[count].length＝0；ARR_DIR[count].angle＝0；ARR_LIGAT[count].num＝0；ARR_LIGAT[count].pns_beg＝0；ARR_LIGAT[count].pns_end＝0；ARR_LIGAT[count].x_beg＝0；ARR_LIGAT[count].y_beg＝0；ARR_LIGAT[count].x_end＝0；ARR_LIGAT[count].y_end＝0；ARR_LIGAT[count].length＝0；ARR_LIG1[count].num＝0；ARR_LIG1[count].pns_beg＝0；ARR_LIG1[count].pns_end＝0；ARR_LIG1[count].x_beg＝0；ARR_LIG1[count].y_beg＝0；ARR_LIG1[count].x_end＝0；ARR_LIG1[count].y_end＝0；ARR_LIG1[count].ength＝0；ARR_LIG2[count].num＝0；ARR_LIG2[count].pnx_beg＝0；ARR_LIG2[count].pns_end＝0；ARR_LIG2[count].x_beg＝0；ARR_LIG2[count].y_beg＝0；ARR_LIG2[count].x_end＝0；ARR_LIG2[count].y_end＝0；ARR_LIG2[count].ength＝0；ARR_LIG3[count].num＝0；ARR_LIG3[count].pns_beg＝0；ARR_LIG3[count].pns_end＝0；ARR_LIG3[count].x_beg＝0；ARR_LIG3[count].y_beg＝0；ARR_LIG3[count].x_emd＝0；ARR_LIG3[count].y_end＝0；ARR_LIG3[count].length＝0；}for(count＝0count＜＝num_of_extrms；count++){penn[count].strk_num＝count；penn[count].p_ndx＝arr_extremoms[count].p_ndx；penn[count].form_code＝0；penn[count].pen_sts＝arr_extremoms[count].pen_sts；}}/***************************************************************functionligat()definesleftupstrokesfromtheendoflongdowninthearr_extremoms[]，recordsdefinedleftupstroke’sparameterstoARR_LIGAT[]accordingtohisnumberandlabelsMASKpenn.***************************************************************/intligat(intnum_of_extrms，intnum_dir){intpr，num_lig，num_pns，count，num_str；pr＝0；num_pns＝0；num_lig＝0；if(num_dir＝＝0)return(0)；for(count＝0；count＜num_dir；count++){pr＝0；if(ARR_DIR[count].pns_end＝＝(unsigned)0)continue；if(penn[ARR_DIR[count].pns_end].form_code＝＝(unsigned)0)continue；if(arr_extremoms[ARR_DIR[count].pns_end+1].dir＞2)continue；if(arr_extremoms[ARR_DIR[count].pns_end].pen_sts＝＝(unsigned)0)continuefor(num_str＝ARR_DIR[count].pns_end+1；num_str＜＝num_of_extrms；num_str++){if((arr_extremoms[num_str].dir＜＝2)&&(penn[num_str].form_code＝＝0)){if(pr＝＝0){ARR_LIGAT[num_lig].num＝num_lig；ARR_LIGAT[num_lig].pns_beg＝num_str；ARR_LIGAT[num_lig].x_beg＝arr_extremoms[num_str-1].x_cor；ARR_LIGAT[num_lig].y_beg＝arr_extremoms[num_str-1].y_cor；ARR_LIGAT[num_lig].pns_end＝num_str；ARR_LIGAT[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_LIGAT[num-lig].y_end＝arr_extremoms[num_str].y_cor；pr＝1；num_pns++penn[num_str].form_code＝3if((num_str＝＝num_of_extrms)‖(arr_extremoms[num_str].pen_sts＝＝(unsigned)0)){num_lig++；pr＝0；break；}}else{/*ARR_LIGAT[num_lig].dir＝ARR_LIGAT[count].dir*arr_extremoms[num_str].dir；*/num_pns++；penn[num_str]form_code＝3；if((arr_extremoms[num_str].pen_sts＝＝(unsigned)0)‖(num_str＝＝num_of_extrms)){/*ARR_LIGAT[num_lig].pen_sts＝arr_extremoms[num_str].pen_sts；*/ARR_LIGAT[num_lig].pns_end＝num_str；ARR_LIGAT[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_LIGAT[num_lig].y_end＝arr_extremoms[num_str].y_cor；num_lig++；pr＝0；/***************************************************************functionligat()definesleftupstrokesfromtheendoflongdowninthearr_extremoms[]，recordsdefinedleftupstroke’sparameterstoARR_LIGAT[]accordingtohisnumberandlabelsMASKpenn.****************************************************************/intligat(intnum_of_extrms，intnum_dir){intpr，num_lig，num_pns，count，num_str；pr＝0；num_pns＝0；num_lig＝0；if(num_dir＝＝0)return(0)；for(count＝0；count＜num_dir；count++){pr＝0；if(ARR_DIR[count].pns_end＝＝(unsigned)0)continue；if(penn[ARR_DIR[count].pns_end].form_code＝＝(unsigned)0)cotinue；if(arr_extremoms[ARR_DIR[count].pns_end+1].dir＞2)continue；if(arr_extremoms[ARR_DIR[count].pns_end].pen_sts＝＝(unsigned)0)continue；for(num_str＝ARR_DIR[count].pns_end+1；num_str＜＝num_of_extrms；num_str++){if((arr_extremoms[num_str].dir＜＝2)&&(penn[num_str].form_code＝＝0)){if(pr＝＝0){ARR_LIGAT[num_lig].num＝num_lin；ARR_LIGAT[num_lig].pns_beg＝num_str；ARR_LIGAT[num_lig].x_beg＝arr_extremoms[num_str-1].x_cor；ARR_LIGAT[num_lig].y_beg＝arr_extremoms[num_str-1].y_cor；ARR_LIGAT[num_lig].pns_end＝num_str；ARR_LIGAT[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_LIGAT[num_lig].y_end＝arr_extremoms[num_str].y_cor；pr＝1；num_pns++；penn[num_str].form_code＝3；if((num_str＝＝num_of_extrms)‖(arr_extremoms[num_str].pen_sts＝＝(unsigned)0)){num_lig++；pr＝0；break；}}else{/*ARR_LIGAT[num_lig].dir＝ARR_LIGAT[count].drr+arr_extremoms[num_str].dir；*/num_pns++；penn[num_str].form_code＝3；if((arr_extremoms[num_str].pen_sts＝＝(unsigned)0)‖(num_str＝＝num_of_extrms)){/*ARR_LIGAT[num_lig].pen_sts＝arr_extremoms[num_str].pen_sts；*/ARR_LIGAT[num_lig].pns_end＝num_str；ARR_LIGAT[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_LIGAT[num_lig].y_end＝arr_extremoms[num_str].y_cor；num_lig++；pr＝0；break；}}}else{if(pr＝＝1){ARR_LIGAT[num_lig].pns_end＝num_str-1；ARR_LIGAT[num_lig].x_end＝arr_extremoms[num_str-1].x_cor；ARR_LIGAT[num_lig].y_end＝arr_extremoms[num_str-1].y_cor；num_lig++；pr＝0；braak；}}}}return(num_lig)；}/***************************************************************functionord_1_ligat()definesoneorderleftupstrokesfromtheendofleftupstrokesinthearr_extremoms[]，recordsoneorderleftupstroke’sparameterstoARR_ORD1_LIGAT[]accordingtohisnumberandlabelsMASKpenn.***************************************************************/intord_1_ligat(intnum_of_extrms，intnum_ligat){intpr，num_lig，num_pns，count，num_str；pr＝0；num_pns＝0；num_lig＝0；if(num_ligat＝＝0)return(0)；for(count＝0；count＜num_ligat；count++){pr＝0；if(ARR_LIGAT[count].pns_end＝＝(unsigned)0)continue；if(penn[ARR_LIGAT[count].pns_end].form_code＝＝(unsigned)0)continue；if((arr_extremoms[ARR_LIGAT[count].pns_and+1].dir＞4)‖(arr_extremoms[ARR_LIGAT[count].pns_end+1].dir＜2))continue；if(arr_extremoms[ARR_LIGAT[count].pns_end].pen_sts＝＝(unsigned)0)continue；for(num_str＝ARR_LIGAT[count].pns_end+1；num_str＜＝num_of_extrms；num_str++){if((arr_extremoms[num_str].dir＜＝4)&&(arr_extremoms[num_str].dir＞＝2)&&(penn[num_str].form_code＝＝0)){if(pr＝＝0){ARR_ORD_1_LIGAT[num_lig].num＝num_lig；ARR_ORD_1_LIGAT[num_lig].pns_beg＝num_str；ARR_ORD_1_LIGAT[num_lig].x_beg＝arr_extremoms[num_str-1].x_cor；ARR_ORD_1_LIGAT[num_lig].y_beg＝arr_extremoms[num_str-1].y_cor；ARR_ORD_1_LIGAT[num_lig].pns_end＝num_str；ARR_ORD_1_LIGAT[num_lig].x_end＝arr_extremoms[num_str].x_corARR_ORD_1_LIGAT[num_lig].y_end＝arr_extremoms[num_str].y_corpr＝1；num_pns++；penn[num_str].frm_code＝11；if((num_str＝＝num_of_extrms)‖(arr_extremoms[num_str].pen_sts＝＝(unsigned)0)){num_lig++；pr＝0；break；}}else{/*ARR_ORD_1_LIGAT[num_lig].dir＝ARR_ORD_1_LIGAT[count].dir+arr_extremoms[num_str].dir，*/num_pns++；penn[num_str].form_code＝11；if((arr_extremoms[num_str].pen_sts＝＝(unsigned)0)‖(num_str＝＝num_of_extms)){∥ARR_ORD_1_LIGAT[num_lig].pen_sts＝arr_extremoms[num_str].pen_sts；ARR_ORD_1_LIGAT[num_lig].pns_end＝num_str；ARR_ORD_1_LIGAT[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_ORD_1_LIGAT[num_lig].y_end＝arr_extremoms[num_str].y_cor；(unsigned)ARR_ORD_1_LIGAT[num_lig].dir/num_pns；num_lig++；pr＝0；break；}}}else{if(pr＝＝1){ARR_ORD_1_LIGAT[num_lig].pns_end＝num_str-1；ARR_ORD_1_LIGAT[num_lig].x_end＝arr_extremoms[num_str-1].x_cor；ARR_ORD_1_LIGAT[num_lig].y_end＝arr_extremoms[num_str-1].y_cor；num_lig++；pr＝0；break；}}}}return(num_lig)；}/***************************************************************functionlig1()definesnghtupstrokesfromthebeginingoflongdowninthearr_extremoms[]，recordsdefinedrightupstroke’sparameterstoARR_LIG1[]accordingtohisnumberandlabelsMASKpenn.***************************************************************/intlig1(intnum_of_extrms，intnum_dir){intpr，num_lig，num_pns，count，num_str；unsignedtemp；pr＝0；num_pns＝0；num_lig＝0；if(num_dir＝＝0)return(0)；ARR_ORD_1_LIG1[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_ORD_1_LIG1[num_lig].y_end＝arr_extremoms[num_str].y_cor；pr＝1；num_pns++；penn[num_str].form_code＝12；if((num_str＝＝1)‖(arr_extremoms[num_str-1].pen_sts＝＝(unsigned)0)){num_lig++；pr＝0；break；}}else{/*ARR_ORD_1_LIG1[num_lig].dir＝ARR_ORD_1_LIG1[count].dir+arr_extremoms[num_str].dir；*/numT_pns++；penn[num_str].form_code＝12；if((arr_extremoms[num_str-1].pen_sts＝＝(unsigned)0)‖(num_str＝＝1)){∥ARR_ORD_1_LIG1[num_lig].pen_sts＝arr_extremoms[num_str].pen_sts；ARR_ORD_1_LIG1[num_lig].pns_end＝num_str；ARR_ORD_1_LIG1[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_ORD_1_LIG1[num_lig].y_end＝arr_extremoms[num_str].y_cor；num_lig++；pr＝0；break；}}}else{if(pr＝＝1){ARR_ORD_1_LIG1[num_lig].pns_end＝num_str+1；ARR_ORD_1_LIG1[num_lig].x_end＝arr_extremoms[num_str+1].x_cor；ARR_ORD_1_LIG1[num_lig].y_end＝arr_extremoms[num_str+1].y_cor；num_lig++；pr＝0；break；}}}}for(count＝0；count＜num_lig；count++){temp＝ARR_ORD_1_LIG1[count].x_end；ARR_ORD_1_LIG1[count].x_end＝ARR_ORD_1_LIG1[count].x_beg；ARR_ORD_1_LIG1[count].x_beg＝temp；temp＝ARR_ORD_1_LIG1[count].y_end；ARR_ORD_1_LIG1[count].y_end＝ARR_ORD_1_LIG1[count].y_beg；ARR_ORD_1_LIG1[count].y_beg＝temp；temp＝ARR_ORD_1_LIG1[count].pns_end；ARR_ORD_1_LIG1[count].pns_end＝ARR_ORD_1_LIG1[count].pns_beg；ARR_ORD_1_LIG1[count].pns_beg＝temp；}return(num_lig)；}/***************************************************************functionlig2()definesleftupstrokesfromthebeginingoflongdowninthearr_extremoms[]，recordsdefinedleftupstroke’sparameterstoARR_LIG2[]accordingtohisnumberandlabelsMASKpenn.****************************************************************intlig2(intnum_of_extrms，intnum_dir){intpr，nun_lig，num_pns，count，num_str；unsignedtemp；pr＝0；num_pns＝0；num_lig＝0；if(num_dir＝＝0)return(0)；for(count＝0；count＜num_dir；count++){pr＝0；if(ARR_DIR[count].pns_beg＜(unsigned)2)continue；if(penn[ARR_DIR[count].pns_beg].form_code＝＝0)continue；if(arr_extremoms[ARR_DIR[count].pns_beg-1].dir＞(unsigned)2)continue；if(penn[ARR_DIR[count].pns_beg-1].form_code！＝0)continue；if(arr_extremoms[ARR_DIR[count].pns_beg-1].pen_sts＝＝(unsigned)0)continue；for(num_str＝ARR_OIR[count].pns_beg-1；num_str＞＝1；num_str-){if((arr_extremoms[num_str].dir＜＝(unsigned)2)&&(penn[num_str].form_code＝＝0)){if(pr＝＝0){ARR_LIG2[num_lig].num＝num_lig；ARR_LIG2[num_lig].pns_beg＝num_str；ARR_LIG2[num_lig].x_beg＝arr_extremoms[num_str+1].x_cor；ARR_LIG2[num_lig].y_beg＝arr_extremoms[num_str+1].y_cor；ARR_LIG2[num_lig].pns_end＝num_str；ARR_LIG2[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_LIG2[num_lig].y_end＝arr_extremoms[num_str].y_cor；pr＝1；num_pns++；penn[num_str].form_code＝7；if((num_str＝＝1)‖(arr_extremoms[num_str-1].pen_sts＝＝(unsigned)0)){num_lig++；pr＝0break}}else{/*ARR_LIG2[num_lig].dir＝ARR_LIG2[count].dir+arr_extremoms[num_str].dir；*/num_pns++；penn[num_str].form_code＝7；if((arr_extremoms[num_str-1].pen_sts＝＝(unsigned)0)‖(num_str＝＝0)){∥ARR_LIG2[num_lig].pen_sts＝arr_extremoms[num_str].pen_sts；ARR_LIG2[num_lig].pns_end＝num_str；ARR_LIG2[num_lig].x_end＝arr_extremoms[num_str].x_corARR_LIG2[num_lig].y_end＝arr_extremoms[num_str].y_cor；num_lig++；pr＝0；break；}}}else{if(pr＝＝1){ARR_LIG2[num_lig].pns_end＝num_str+1；ARR_LIG2[num_lig].x_end＝arr_extremoms[num_str+1].x_cor；ARR_LIG2[num_lig].y_end＝arr_extremoms[num_str+1].y_cor；num_lig++；pr＝0；break；}}}}for(count＝0；count＜num_lig；count++){temp＝ARR_LIG2[count].x_end；ARR_LIG2[count].x_end＝ARR_LIG2[count].x_beg；ARR_LIG2[count].x_beg＝temp；temp＝ARR_LIG2[count].y_end；ARR_LIG2[count].y_end＝ARR_LIG2[count].y_beg；ARR_LIG2[count].y_beg＝temp；temp＝ARR_LIG2[count].pns_end；ARR_LIG2[count].pns_end＝ARR_LIG2[count].pns_beg；ARR_LIG2[count].pns_beg＝temp；}return(num_lig)；}/***************************************************************functionord_1_lig2()definesoneorderleftupstrokesfromthebeginmgofleftupstrokesinthearr_extremorms[]，recordsoneorderleftupstroke’sparameterstoARR_ORD_2_LIG1[]accordingtohisnumberandlabeisMASKpenn.***************************************************************/intord_1_lig2(intnum_of_extrms.intnum_lig2){intpr，num_lig.num_pns，count.num_str；unsignedtemp；pr＝0；num_pns＝0；num_lig＝0；if(num_lig2＝＝0)return(0)；for(count＝0；count＜num_lig2；count++){pr＝0；if(ARR_LIG2[count]pns_beg＜(unsigned)2)continue；if(penn[ARR_LIG2[count].pns_beg].form_code＝＝0)continue；if((arr_extremoms[ARR_LIG2[count].pns_beg-1].dir＜(unsigned)2)‖(arr_extremoms[ARR_LIG2[count].pns_beg-1].dir＞(unsignied)4))continue；if(penn[ARR_LIG2[count].pns_beg-1].form_code！＝0)continueif(arr_extremoms[ARR_LIGZ[count].pns_beg-1].pen_sts＝＝(unsigned)0)continue；for(num_str＝ARR_LIG2[count].pns_beg-1；num_str＞＝1；num_str-){if((arr_extremoms[num_str].dir＜＝(unsigned)4)&&(arr_extremoms[num_str].dir＞＝(unsigned)2)&&(penn[num_str].form_code＝＝0)){if(pr＝＝0){ARR_ORD_1_LIG2[num_lig].num＝num_lig；ARR_ORD_1_LIG2[num_lig].pns_beg＝num_str；ARR_ORD_1_LIG2[num_lig].x_beg＝arr_extremoms[num_str+1].x_cor；ARR_ORD_1_LIG2[num_lig].y_beg＝arr_extremoms[num_str+1].y_cor；ARR_ORD_1_LIG2[num_lig].pns_end＝num_str；ARR_ORD_1_LIG2[num_lig].x_end＝arr_extremoms[num_stf].x_cor；ARR_ORD_1_LIG2[num_lig].y_end＝arr_extremoms[num_str].y_cor；pr＝1；num_pns++；penn[num_str].form_code＝13；if((num_str＝＝1)‖(arr_extremoms[num_str-1].pen_sts＝＝(unsigned)0)){num_lig++；pr＝0；break；}}else{/*ARR_ORD_1_LIG2[num_lig].dir＝ARR_ORD_1_LIG2[count].dir+arr_extremoms[num_str].dir；*/num_pns++；penn[num_str].form_code＝13；if((arr_extremoms[num_str-1].pen_sts＝＝(unsigned)0)‖(num_str＝＝0)){∥ARR_ORD_1_LIG2[num_lig].pen_sts＝arr_extremoms[num_str].pen_sts；ARR_ORD_1_LIG2[num_lig].pns_end＝num_str；ARR_ORD_1_LIG2[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_ORD_1_LIG2[num_lig].y_and＝arr_extremoms[num_str].y_cor；(urnsigned)ARR_ORD_1_LIG2[num_lig].dir/num_pns；num_lig++；pr＝0；break；}}}else{if(pr＝＝1){ARR_ORD_1_LIG2[num_lig].pns_end＝num_str+1；ARR_ORD_1_LIG2[num_lig].x_end＝arr_extremoms[num_str+1].x_cor；ARR_ORD_1_LIG2[num_lig].y_end＝arr_extremoms[num_str+1].y_cor；num_lig++；pr＝0break；}}}}for(count＝0；count＜num_lig；count++){temp＝ARR_ORD_1_LIG2[count].x_end；ARR_ORD_1_LIG2[count].x_end＝ARR_ORD_1_LIG2[count].x_beg；ARR_ORD_1_LIG2[count].x_beg＝temp；temp＝ARR_ORD_1_LIG2[count].y_end；ARR_ORD_1_LIG2[count].y_and＝ARR_ORD_1_LIG2[count].y_beg；ARR_ORD_1_LIG2[count].y_beg＝temp；tamp＝ARR_ORD_1_LIG2[count].pns_and；ARR_ORD_1_LIG2[count].pns_end＝ARR_ORD_1_LIG2[count].pns_beg；ARR_ORD_1_LIG2[count].pns_beg＝temp；}return(num_lig)；}/***************************************************************functionlig3()definesrightupstrokesfromtheendoflongdowninthearr_extremoms[]，recordsdefinedleftupstroke’sparameterstoARR_LIG3[]accordingtohisnumberandlabelsMASKpenn.****************************************************************/intlig3(intnum_of_extrms，intnum_dir){intpr，num_lig，num_pns，count，num_str；pr＝0；num_pns＝0；num_lig＝0；if(num_dir＝＝0)return(0)；for(count＝0；count＜num_dir；count++){pr＝0；if(ARR_DIR[count].pns_end＝＝(unsigned)0)continue；if(penn[ARR_DIR[count].pns_end].form_code＝＝(unsigned)0)continue；if((arr_extremoms[ARR_DIR[count].pns_and+1].dir＞4)‖(arrextremoms[ARR_DIR[count].pns_end+1].dir＜2))continue；if(penn[ARR_DIR[count].pns_end+1].form_code！＝0)continue；if(arr_extremoms[ARR_DIR[count].pns_end].pen_sts＝＝(unsigned)0)continue；for(num_str＝ARR_DIR[counf].pns_end+1num_str＜＝num_of_extrms；num_str++){if((arr_extremoms[num_str].dir＜＝4)&&(arr_extremoms[num_str].dir＞＝2)&&(penn[num_str].form_code＝＝0)){if(pr＝＝0){ARR_LIG3[num_lig].num＝num_lig；ARR_LIG3[num_lig]pns_beg＝num_str；ARR_LIG3{num_lig].x_beg＝arr_extremoms[num_str-1].x_cor；ARR_LIG3[num_lig].y_beg＝arr_extremoms[num_str-1].y_cor；ARR_LIG3[num_lig].pns_end＝num_str；ARR_LIG3[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_LIG3[num_lig].y_end＝arr_extremoms[num_str].y_cor；pr＝1；num_pns++；penn[num_str].form_code＝9；if((num_str＝＝num_of_extrms)‖(arr_extremoms[num_str].pen_sts＝＝(unsigned)0；}/********/fp＝fopen(＂fextr.out＂，＂ab+＂)；fprintf(fp，＂％d％c％d％d＂，map_char[letter_num][1]，(*lette)，num_direc，num_of_extrms)；for(i＝0；i＜＝num_of_extrms；i++)fwrite(&arr_extremoms[i]，stzeof(structTABLE_EXTREMOMS)，1，fp)；fprintf(fp，＂\n＂)；fclose(fp)；/********/fp＝fopen(＂feat.out＂，＂ab+＂)；fprintf(fp，＂％c％d％.4f％.4f％.4f％.4f\n＂，(*letter)，map_char[letter_num][1]，y_vec_beg，y_vec_end，x_vec_beg，x_vec_end)；fclose(fp)；/********/fp＝fopen(“feat1.out”，＂ab+＂)；fprintf(fp，＂％c％d％d\n＂，(*letter)，map_char[letter_num][1]，amp_y)；fclose(fp)；/********/if(num_direc＝＝0)fp＝fopen(“fsent0.out＂，＂ab+＂)；if(num_direc＝＝1)fp＝fopen(“fsent1.out＂，＂ab+＂)；if(num_direc＝＝2)fp＝fopen(“fsent2.out＂，＂ab+＂)；if(num_direc＝＝3)fp＝fopen(＂fsent3.out＂，＂ab+＂)；if(num_direc＝＝4)fp＝fopen(“fsent4.out＂，＂ab+＂)；if(num_direc＝＝5)fp＝fopen(＂fsent5.out＂，＂ab+＂)；if(num_direc＝＝6)fp＝fopen(＂fsent6.out＂，＂ab+＂)；fprintf(fp，＂％d％c＂，map_char[letter_num][1]，(*letter))；if(num_direc！＝0){fprintf(fp，＂％s＂，oursent)；for(i＝0；i＜numdirec；i++)fprintf(fp＂％.4f％.4f＂，x[i].x_b，x[i].x_e)；for(i＝0；i＜numdirec；i++)fprintf(fp＂％4f％.4f＂，y[i].y_b，y[i].y_e)；fprintf(fp，＂％d＂.amp_y)；}fprintf(fp，＂\n＂)fclose(fp)}intadd_map(onar*letter){inti；for(i＝0；i＜NUM_SYMBOLS；i++)if(*letter＝＝(onar)map_char[i]){map_char[i][1]++；return(i)；}if(i＝＝NUMSYMBOLS){printf(“Thereisnosuchcharacterinthemap％c\n＂，*letter)；return(-1)；}return(-1)；}voidread_map(void){FILE*fp；inti；fp＝fopen(＂map_ch＂，＂rb＂)；for(i＝0；i＜NUM_SYMBOLS；i++)fscanf(fp，＂％d％d\n＂，&map_char[i]，&map_char[i][1])；fclose(fp)；}voidsave_map(void){FILE*fp；inti；fp＝fopen(＂map_ch＂，＂wb＂)；for(i＝0；i＜NUM_SYMBOLS；i++)fprintf(fp，＂％d％d\n＂，map_char[i]，map_char[i][1])；fclose(fp)；}intget_num(char*letter){inti；for(i＝0；i＜NUM_SYMBOLS；i++)if(*letter＝＝(char)map_char[i])return(i)；return(-1)；}]]></pre>III.一般化<prelisting-type="program-listing"><![CDATA[voidmain(void){FILE*fp，*fp1；inti；charfilename[30]，filename1[30]；read_map()；for(i＝1；i＜＝MAX_AMOUNT_DIREC；i++){if(i＝＝1){strcpy(filename，＂fsent1.out＂)；strcpy(filename1，＂fgen1.out＂)；pfintf(＂——％d——\n＂，i)；gotoA；}if(i＝＝2){strcpy(filename，＂fsent2.out＂)；strcpy(filename1，＂fgen2.out＂)；printf(＂——％d——\n＂，i)；gotoA；}if(i＝＝3){strcpy(filename，＂fsent3.out＂)；strcpy(filename1，＂fgen3.out＂)；printf(＂——％d——\n＂，i)；gotoA；}if(i＝＝4){strcpy(filename，＂fsent4.out＂)；strcpy(filename1，＂fgen4.out＂)；printf(＂——％d——\n＂，i)；gotoA；}if(i＝＝5){strcpy(filename，＂fsent5.out＂)；strcpy(filename1，＂fgen5.out＂)；printf(＂——％d——\n＂，i)；gotoA；}if(i＝＝6){strcpy(filename，＂fsent6.out＂)；strcpy(filename1，＂fgen6.out＂)；printf(“——％d——\n＂，i)；gotoA}Afp1＝fopen(filename1，＂wb＂)；fclose(fp1)；gener(i，filename，filename1)；}fp1＝fopen(＂genfeat.out＂，＂wb＂)；fclose(fp1)；gener_feat()；fp1＝fopen(＂genfet1.out”，＂wb＂)；fclose(fp1)；gener_feat1()}voidread_map(void){FILE*fp；inti；fp＝fopen(＂map_ch”“rb＂)；for(i＝0；i＜NUM_SYMBOLS；i++)fscanf(fp，＂％d％d\n＂，&map_char[i]，&map_char[i][1])；fclose(fp)；}voidgener(inti，charfilename[]，charfilename1[]){voidgether(charletter，intnum_dir，charfilename[]，charfilename1[])；intj；for(j＝0；j＜100；j++){if(map_char[j][1]＞0)gether(map_char[j]，i，filename，filename1)；}}voidgener_feat(void){voidgether_feat(charletter)；intj；for(i＝0；j＜100；j++){if(map_char[j][1]＞0)gether_feat(map_char[j])；}}voidgener_feat1(void){voidgether_feat1(charletter)；intj；for(j＝0；j＜100；i++){if(map_char[j][1]＞0)gether_feat1(map_char[j])；}}voidgether(charletter，intnum_dir，charfilename[]，charfilename1[]){charch；intletter_num；inti，amount；intamp_y；FILE*fp；intconv(void)；voidconv_dir_defin(intamount，intnum_dir)；voidwrite_to_gen(intamount，intnum_dir，charletter)；voidsave_gen(intnum_dir，charletter，charfilename1[])；voidsave_xy(intnum_dir，charfilename1[])；amount＝0gen.repr.num＝0；for(i＝0；i＜＝MAX_AMOUNT_DIREC；i++)genrepr.tabl[i].number＝0；fp＝fopen(filename，＂rb＂)；while(fscanf(fp，＂％d＂，&letter_num)！＝EOF){fscanf(fp.＂％c＂，&ch)；fscanf(fp＂％s＂.our_sent)；for(i＝0；i＜num_dir；i++)fscanf(fp，＂％f％f＂，&bx[amount][i].x_b，&bx[amount)[i].x_e)；for(i＝0；i＜num_dir；i++)fscanf(fp，＂％f％f＂，&by[amount][i].y_b，&by[amount][i].y_e)；fscanf(fp，＂％d\n＂，&amp_y)；if(ch＝＝letter){conv()；write_to_gen(amount，num_dir-1，letter)；amount++；if(amount＝＝MAX_REPRESNT){fclose(fp)；break；}}}fclose(fp)；if(amount＞0){conv_dir_defin(amount，num_dir)；save_gen(num_dir，letter，filename1)；save_xy(num_dir，filename1)；}}voidsave_gen(intnum_dir，charletter，charfilename1[]){FILE*fp1；inti，j；fp1＝fopen(filename1，＂ab+＂)；fprintf(fp1，＂％c＂，letter)；fprintf(fp1，＂％d％c％d＂，gen.amount，gen.repr.letter，gen.repr.num)；for(i＝0；i＜＝num_dir；i++){fprintf(fp1，*％d＂，gen.repr.tabl[i].number)；if(gen.repr.tabl[i].number＞0){for(j＝0；j＜gen.repr.tabl[i].number；j++)fprintf(fp1，＂％s＂，gen.repr.tabl[i].row[j].str)；fprintf(fp1，＂\n＂)；}}fclose(fp1)；}voidsave_xy(intnum_dir，charfilename1[]){FILE*fp1；inti；fp1＝fopen(filename1，＂ab+＂)；for(i＝0；i＜num_dir；i++)fprintf(fp1，＂％.4f％4f＂.x_mid‖[i].x_b，x_mid‖[i].x_e)；for(i＝0；i＜num_dir；i++)fprintf(fp1，＂％.4f％4f＂，x_dev[i].x_b，x_dev[i].x_e)；for(i＝0；i＜num_dir；i++)fprintf(fp1，＂％.4f％.4f＂，y_mid‖[i].y_b，y_mid‖[i].y_e)；for(i＝0i＜num_dir；i++)fprintf(fp1，＂％4f％4f\n＂，y_dev[i]y_b，y_dev[i].y_e)；fclose(fp1)；}voidsave_feat1(charletter){FILE*fp1；inti；fp1＝fopen(＂genfeat.out＂，＂ab+＂)；fprintf(fp1，＂％c＂，letter)；fprintf(fp1，“％.4f％.4f％.4f％.4f\n＂，x_mid‖.x_b，x_mid‖.x_e，y_mid‖.y_b，y_mid‖.y_e)；for(i＝0；i＜3；i++){fpnntf(fp1，＂％4f％.4f％.4f％.4f\n＂，x_dev[i].x_b，x_dev[i].x_e，y_dev[i].y_b，y_dev[i].y_e)；}fclose(fp1)；}voidsave_feat2(charletter){FILE*fp1；inti；fp1＝fopen(“genfet1.out”，＂ab+＂)；fprintf(fp1，＂％c＂，letter)；fprintf(fp1，＂％.4f％d％d\n＂，y_midll.y_b，amp_y，amp_y[1])；for(i＝0；i＜3；i++)fprintf(fp1，＂％.4f”y_dev[i].y_b)；fprintf(fp1，＂\n＂)；fclose(fp1)；}voidgether_feat(charletter){voidcalc_vec(intamount)；FILE＂fp，fp1；intamount，letter_num；charch；amount＝0；fp＝fopen(＂feat.out＂，＂rb＂)；while(fscanf(fp，＂％c＂，&ch)！＝EOF){fscanf(fp，＂％d％f％f％f％f\n＂，&letternum，&by[amount].y_b，&by[amount].y_e，&bx[amount].x_b，&bx[amount].x_e)；if(ch＝＝letter){amount++；if(amount＝＝MAX_REPRESNT)break；}}fclose(fp)；if(amount＞0){calc_vec(amount)；save_feat1(letter)，}}voidgether_feat1(charletter){voidcalc_amp(intamount)；FILE*fp；intamount.letter_num；charch；amount＝0；by[i][count].y_e；summ_4＝summ_4+temp*temp；}x_dev[count].x_b＝sqrt(summ_1/(float)amount)；y_dev[count].y_b＝sqrt(summ_2/(float)amount)；x_dev[count].x_e＝sqrt(summ_3/(float)amount)；y_dev[count].y_e＝sqrt(summ_4/(float)amount)；}}return；}voidcalc_vec(intamount){intcount，i；floatsumm_1＝0.0；floatsumm_2＝0.0；floatsumm_3＝0.0；floatsumm_4＝0.0；floatsumm_1m＝0.0；floatsumm_2m＝0.0；floatsumm_3m＝0.0；floatsumm_4m＝0.0；floattemp；intam1，am2.am3，am4，am5，am6，am7，am8；if(amount＞0)for(i＝0；i＜amount；i++){summ_1＝summ_1+bx[i]0].x_b；summ_2＝summ_2+by[i].y_b；summ_3＝summ_3+bx[i].x_e；summ_4＝summ_4+by[i].y_e；}x_midll.x_b＝summ_1/(float)amount；y_midll.y_b＝summ_2/(float)amount；x_midll.x_e＝summ_3/(float)amount；y_midll.y_e＝summ_4/(float)amount；summ_1＝0.0；summ_2＝0.0；summ_3＝0.0；summ_4＝0.0；summ_1m＝0.0；summ_2m＝0.0；summ_3m＝0.0；summ_4m＝0.0；am1＝0；am2＝0；am3＝0；am4＝0；am5＝0；am6＝0；am7＝0am8＝0；for(i＝0；i＜amount，i++){temp＝x_midll.x_b-bx[i].x_b；if(temp＞0.0){summ_1＝summ_1+temp*temp；am1+-}else{summ_1m＝summ_1m+temp*temp；am2++；}temp＝y_midll.y_b-by[i].y_b；if(temp＞0.0){summ_2＝summ_2+temp*temp；am3++；}else{summ_2m＝summ_2m+temp*temp；am4++；}temp＝x_midll.x_e-bx[i].x_e；if(temp＞0.0){summ_3＝sum_3+temp*temp；am5++；}else{summ_3m＝summ_3m+temp*temp；am6++；}temp＝y_midll.y_e-by[i].y_e；if(temp＞0.0){summ_4＝summ_4+temp*temp；am7++；}else{summ_4m＝summ_4m+temp*temp；am8++；}}if(am1＝＝0)x_dev.x_b＝0.0；∥dev-elsex_dev.x_b＝sqrt(sum_1/(float)am1)；if(am2＝＝0)x_dev[1].x_b＝0.0；∥dev+elsex_dev[1].x_b＝sqrt(summ_1m/(float)am2)；if((am1+am2)＝＝0)x_dev[2].x_b＝0.0；∥develsex_dev[2].x_b＝sqrt((summ_1+summ_1m)/(float)(am1+am2))；if(am3＝＝0)y_dev.y_b＝0.0；∥dev-elsey_dev.y_b＝sqrt(summ_2/(float)am3)；if(am4＝＝0)y_dev[1].y_b＝0.0；∥dev+elsey_dev[1].y_b＝sqrt(summ_2m/(float)am4)；if((am3+am4)＝＝0)y_dev[2].y_b＝0.0；∥develsey_dev[2].y_b＝sqrt((summ_2+summ_2m)/(float)(am3+am4))；if(am5＝＝0)x_dev.x_e＝0.0；∥dev-elsex_dev.x_e＝sqrt(summ_3/(float)am5)；if(am6＝＝0)x_dev[1].x_e＝0.0；∥dev+elsex_dev[1].x_e＝sqrt(summ_3m/(float)am6)；if((am5+am6)＝＝0)x_dev[2].x_e＝0.0；∥develsex_dev[2].x_e＝sqrt((summ_3+summ_3m)/(float)(am5+am6))；if(am7＝＝0)y_dev.y_e＝0.0；∥dev-elsey_dev.y_e＝sqrt(summ_4/(float)am7)；if(am8＝＝0)y_dev[1].y_e＝0.0；∥dev+elsey_dev[1].y_e＝sqrt(summ_4m/(float)am8)；if((am7+am8)＝＝0)y_dev[2].y_e＝0.0；∥develsey_dev[2]y_e＝sqrt((summ_4+summ_4m)/(float)(am7+am8))}{num_lig++；pr＝0；break；}}else{/*ARR_LIG3[num_lig].dir＝ARR_LIG3[count].dir+arr_extremoms[num_sti.dir；*/num_pns++；penn[num_str].form_code＝9；if((arr_extremoms[num_str].pen_sts＝＝(unsigned)0)‖(num_str＝＝num_of_extmms)){∥ARR_LIG3[num_lig].pen_sts＝arr_extremoms[num_str].pen_sts；ARR_LIG3[num_lig].pns_end＝num_str；ARR_LIG3[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_LIG3[num_lig].y_end＝arr_extremoms[num_str].y_cor；num_lig++；pr＝0；break；}}}else{if(pr＝＝1){ARR_LIG3[num_lig].pns_end＝num_str-1；ARR_LIG3[num_lig].x_end＝arr_extremoms[num_str-1].x_cor；ARR_LIG3[num_lig].y_end＝arr_extremoms[num_str-1].y_cor；num_lig++；pr＝0；break；}}}}return(num_lig)；}/****************************************************************functionord_1_lig3()definesoneorderrightupstrokesfromtheendofrightupstrokesinthearr_extremoms[]，recordsoneorderleftupstroke’sparameterstoARR_ORD_2_LIG1[]accordingtohisnumberandlabelsMASKpenn.****************************************************************/intord_1_lig3(intnum_of_extrms.intnum_lig3){intpr，num_lignum_pns，count，num_str；pr＝0；num_pns＝0；num_lig＝0；if(num_lig3＝＝0)return(0)；for(count＝0；count＜num_lig3；count++){pr＝0；if(ARR_LIG3[count].pns_end＝＝(unsigned)0)continue；if(penn[ARR_LIG3[count].pns_end].form_code＝＝(unsigned)0)continueif(arr_extremoms[ARR_LIG3[count].pns_end+1].dir＞2)continue；if(penn[ARR_LIG3[count].pns_end+1].form_code！＝0)continue；if(arr_extremoms[ARR_LIG3[count].pns_end].pen_sts＝＝(unsigned)0)continue；for(num_str＝ARR_LIG3[count].pns_end+1；num_str＜＝num_of_extrms；num_str++){if((arr_extremoms[num_str].dir＜＝2)&&(arr_extremoms[num_str].dir＞＝0)&&(penn[num_str].form_code＝＝0)){if(pr＝＝0){ARR_ORD_1_LIG3[num_lig].num＝num_lig；ARR_ORD_1_LIG3[num_lig].pns_beg＝num_str；ARR_ORD_1_LIG3[num_lig].x_beg＝arr_extremoms[num_str-1].x_cor；ARR_ORD_1_LIG3[num_lig].y_beg＝arr_extremoms[num_str-1].y_cor；ARR_ORD_1_LIG3[num_lig].pns_end＝num_str；ARR_ORD_1_LIG3[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_ORD_1_LIG3[num_lig].y_end＝arr_extremoms[num_str].y_cor；pr＝1；num_pns++；penn[num_str].form_code＝14；if((num_str＝＝num_of_extrms)‖(arr_extremoms[num_str].pen_sts＝＝(unsigned)0)){num_lig++；pr＝0；break；}}else{/*ARR_ORD_1_LIG3[num_lig].dir＝ARR_ORD_1_LIG3[count].dir+arr_extremoms[num_str].dir；*/num_pns++；penn[num_str].form_code＝14；if((arr_extremoms[num_str].pen_sts＝＝(unsigned)0)‖(num_str＝＝num_of_extrms)){∥ARR_ORD_1_LIG3[num_lig].pen_sts＝arr_extremoms[num_str].pen_sts；ARR_ORD_1_LIG3[num_lig].pns_end＝num_str；ARR_ORD_1_LIG3[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_ORD_1_LIG3[num_lig].y_end＝arr_extremoms[num_str].y_cor；num_lig++；pr＝0；break}}}else{if(pr＝＝1){ARR_ORD_1_LIG3[num_lig].pns_end＝num_str-1；ARR_ORD_1_LIG3[num_lig].x_end＝arr_extremoms[num_str-1].x_cor；ARR_ORD_1_LIG3[num_lig].y_end＝arr_extremoms[num_str-1].y_cor；num_lig++；pr＝0；break；}}}return(num_lig)；}/*functioncurve()recordstoMASKpenn[]formcodetoeachofpenstrokes(exceptlongdown)accordingtoitscurvature.*/voidcunve(intnum_of_extrms){extermstructTABLE_EXTREMOMSarr_extremoms[MAX_NUM_OF_EXTREMOMS]；intcount；for(count＝0；count＜＝num_of_extrms；count++)switch(penn[count].form_code){case(unsigned)3；{if(arr_extremoms[count].in_rot＝＝7)penn[count].form_code＝4；else{if((arr_extremoms[count].in_rot＝＝1)‖(arr_extremoms[count].in_rot＝＝0))penn[count].form_code＝3；elsepenn[count].form_code＝15；}continue；}case(unsigned)5；{if(arr_extremoms[count].in_rot＝＝1)penn[count].form_code＝6；else{if((arr_extremoms[count].in_rot＝＝7)‖(arr_extremoms[count].in_rot＝＝0))penn[count].form_code＝5；elsepenn[count].form_code＝16；}continue；}case(unsigned)7；{if(arr_extremoms[count].in_rot＝＝7)penn[count].form_code＝7；else{if((arr_extremoms[count].in_rot＝＝1)‖(arr_extremoms[count].in_rot＝＝0))penn[count].form_code＝8；elsepenn[count].form_code＝17；}continue}case(unsigned)9{if(arr_extremoms[count].in_rot＝＝1)penn[count].form_code＝9else{if((arr_extremoms[count].in_rot＝＝7)‖(arr_extremoms[count].in_rot＝＝0))penn[cout].form_code＝10elsepenn[count].form_cooe＝18)}}defauttcontinue；}elurn.if((penn[count].form_code＝＝(unsigned)17)&&((strcmp(temp，＂Y”)！＝0))){strcpy(temp，＂Y＂)；strcat(our_sent，＂Y＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)18)&&((strcmp(temp，＂Z＂)！＝0))){strcpy(temp，＂Z＂)；strcat(our_sent，＂Z＂)；gotoA；}if((penn[count].form_code＝＝3)&&((strcmp(temp，＂C＂)！＝0))){strcpy(temp，＂C＂)；strcat(our_sent，＂C＂)；gotoA；}if((penn[count].form_code＝＝4)&&((strcmp(temp，＂D＂)！＝0))){strcpy(temp，＂D＂)；strcat(our_sent，＂D＂)；gotoA；}if((penn[count].form_code＝＝5)&&((strcmp(temp，＂E＂)！＝0))){strcpy(temp，＂E＂)；strcat(our_sent，＂E＂)；gotoA；}if((penn[count].form_code＝＝6)&&((strcmp(temp，＂F＂)！＝0))){strcpy(temp，＂F＂)；strcat(our_sent，＂F＂)；gotoA；}if((penn[count].form_code＝＝7)&&((strcmp(temp，＂G＂)！＝0))){strcpy(temp，＂G＂)；strcat(our_sent，＂G＂)；gotoA；}if((penn[count].form_code＝＝8)&&((strcmp(temp，＂H＂)！＝0))){strcpy(temp，＂H＂)；strcat(our_sent，＂H＂)；gotoA；}if((penn[count].form_code＝＝9)&&((strcmp(temp，＂｜＂)！＝0))){strcpy(temp，＂｜＂)；strcat(our_sent，＂｜＂)；gotoA；}if((penn[count].form_code＝＝10)&&((strcmp(temp，＂J＂)！＝0))){strcpy(temp，＂J＂)；strcat(our_sent，＂J＂)；gotoA；}Aif((penn[count].pen_sts＝＝0)&&(strcmp(temp，＂_＂)！＝0)){strcat(our_sent，＂_＂)；strcpy(temp，＂_＂)；continue}if((penn[count].form_code＝＝0)&&(penn[count].pen_sts＝＝1)&&((strcmp(temp，＂B＂)！＝0))){strcpy(temp＂B＂)/***********************************************************************-initialMASKpennhavetobebuildfrompenstrokestableformcodehavetobedone＝0recordtoMASKpennisusedinfunctionsdirect，ligat，lig1，lig2，lig3，ord_1_ligat，ord_1_lig1，ord_1_lig2，ord_1_lig3.FromtheseprogramsinformationforeveryfindformhavetobewrittentoMASKfortheseletter.output1-letterrepresentationinthe＂LETTERSYMBOLICREPRESENTATION＂output2-letterrepresentationinthe＂LETTERSYMBOLICREPRESENTATIONINGENERALIZEDFORM＂.***********************************************************************/intsentense(intnum_of_extrms){externstructMASKpenn[MAX_NUM_OF_EXTREMOMS]；externcharour_sent[MAX_LENGTH_SENTENSE]；chartemp[10]intcount；strcpy(our_sent，***)；strcpy(temp，“_＂)；for(count＝1；count＜＝num_of_extrms；count++){if((penn[count].form_code＝＝(unsigned)1)&&((strcmp(temp，＂A＂)！＝0))){strcpy(temp，＂A＂)；strcat(our_sent，＂A＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)11)&&((strcmp(temp，＂i＂)！＝0))){strcpy(temp，＂i＂)；strcat(our_sent，＂j＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)12)&&((strcmp(temp，＂g＂)！＝0))){strcpy(temp，＂g＂)；strcat(our_sent，＂g＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)13)&&((strcmp(temp，＂f”)！＝0))){strcpy(temp，＂f＂)；strcat(our_sent，＂f＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)14)&&((strcmp(temp.＂d＂)！＝0))){strcpy(temp，＂d＂)；strcat(our_sent，＂d＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)15)&&((strcmp(temp，＂Q＂)！＝0))){strcpy(temp，＂Q＂)；strcat(our_sent，＂Q＂)；gotoA；}if((penn[count].forn_code＝＝(unsigned)16)&&((strcmp(temp，＂X＂)！＝0))){strcpy(temp＂X＂)；strcat(our_sent，＂X＂)；gotoA；}strcat(our_sent，＂B＂)；continue；}}return(1)；}/***********************************************************************afuntionthatrecievestwonumbers，andreturnsthequarterofthesetwonumbersintherangeof0..7.***********************************************************************/intdef_quart(intx，inty){if((x＞0)&&(y＝＝0))return(0)；if((x＞0)&&(y＞0))return(1)；if((x＝＝0)&&(y＞0))return(2)；if((x＜0)&&(y＞0))return(3)；if((x＜0)&&(y＝＝0))return(4)；if((x＜0)&&(y＜0))return(5)；if((x＝＝0)&&(y＜0))return(6)；if((x＞0)&&(y＜0))return(7)；return(15)；}/***********************************************************************afunctiontoreturnstheroundnumberofthedivisionoftwointegernumbers.***********************************************************************/intdiv_round(inta，intb){inti＝0；inttemp1，temp2；temp1＝a；temp2＝b；a＝abs(a)；if(b＝＝0)return(MAXINT)；while(a＞b){if(b＞0)a-＝b；elsea+＝b；}if((a+a)＞bi++；if(((temp1＞0)&&(temp2＞0))‖((ternp1＜0)&&(temp2＜0)))return(i)elsereturn(-i)}voidsave_files(intnum_direc，char*letter){FILE*fp；inti；intletter_num；charfilename[20]；intget_num(char*letter)；if((letter_num＝get_num(letter))＜0){printf(＂Errorinthenumberoftheletter％c\n＂，*letter)；getch(){num_lig++；pr＝0；break；}}else{/*ARR_LIG3[num_lig].dir＝ARR_LIG3[count].dir+arr_extremoms[num_str].dir；*/num_pns++；penn[num_str].form_code＝9；if((arr_extremoms[num_str].pen_sts＝＝(unsigned)0)‖(num_str＝＝num_of_extrrns)){∥ARR_LIG3[num_lig].pen_sts＝arr_extremoms[num_str].pen_sts；ARR_LIG3[num_lig].pns_end＝num_str；ARR_LIG3[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_LIG3[num_lig].y_end＝arr_extremoms[num_str].y_cor；num_lig++；pr＝0；break；}}}else{if(pr＝＝1){ARR_LIG3[num_lig].pns_end＝num_str-1；ARR_LIG3[num_lig].x_end＝arr_extremoms[num_str-1].x_cor；ARR_LIG3[num_lig].y_end＝afr_extremoms[num_str-1].y_cor；num_lig++；pr＝0；break；}}}}return(num_lig)；}/***********************************************************************functionord_1_lig3()definesoneorderrightupstrokesfromtheendofrightupstrokesinthearr_extremoms[]，recordsoneorderleftupstroke’sparameterstoARR_ORD_2_LIG1[]accordingtohisnumberandlabelsMASKpenn.***********************************************************************/intord_1_lig3(int.num_of_extrms.intnum_lig3){intpr，num_lig.num_pns，count，num_str；pr＝0；num_pns＝0；num_lig＝0；if(num_lig3＝＝0)return(0)；for(count＝0；count＜num_lig3；count++){pr＝0if(ARR_LIG3[count].pns_end＝＝(unsigned)D)continue；if(penn[ARR_LIG3[count].pns_end].form_code＝＝(unsigned)0)continue；if(arr_extremoms[ARR_LIG3[count].pns_end+1].dir＞2)continue；if(penn[ARR_LIG3[count].pns_end+1].form_code！＝0)continue.if(arr_extremoms[ARR_LIG3[count].pns_end].pen_sts＝＝(unsigned)0)continue；for(num_str＝ARR_LIG3[count].pns_end+1；num_str＜＝nur_of_extrms；num_str++){if((arr_extremoms[num_str].dir＜＝2)&&(arr_extremoms[num_str].dir＞＝0)&&(penn[num_str].form_code＝＝0)){if(pr＝＝0){ARR_ORD_1_LIG3[num_lig].num＝num_lig；ARR_ORD_1_LIG3[num_lig].pns_beg＝num_str；ARR_ORD_1_LIG3[num_lig].x_beg＝arr_extremoms[num_str-1].x_cor；ARR_ORD_1_LIG3[num_lig].y_beg＝arr_extremoms[num_str-1].y_cor；ARR_ORD1_LIG3[num_lig].pns_end＝num_str；ARR_ORD_1_LIG3[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_ORD_1_LIG3[num_lig].y_end＝arr_extremoms[num_str].y_cor；pr＝1；num_pns++；penn[num_str].form_code＝14；if((num_str＝＝num_of_extrms)‖(arr_extremoms[num_str].pen_sts＝＝(unsigned)0)){num_lig++；pr＝0；break；}}else{/*ARR_ORD_1_LIG3[num_lig].dir＝ARR_ORD_1_LIG3[count].dir+arr_extremoms[num_str].dir；*/num_pns++；penn[num_str].formcode＝14；if((arr_extremoms[num_str].pen_sts＝＝(unsigned)0)‖(num_str＝＝num_of_extrms)){∥ARR_ORD_1_LIG3[num_lig].pen_sts＝ar_extremoms[num_str].pen_sts；ARR_ORD_1_LIG3[num_lig].pns_end＝num_str；ARR_ORD_1_LIG3[num_lig].x_end＝arr_extremoms[num_str].x_cor；ARR_ORD_1_LIG3[num_lig].y_end＝arr_extremoms[num_str].y_cor；num_lig++；pr＝0；break；}}}else{if(pr＝＝1){ARR_ORD_1_LIG3[num_lig].pns_end＝num_str-1；ARR_ORD_1_LIG3[num_lig].x_end＝arr_extremoms[num_str-1].x_cor；ARR_0RD_1_LIG3[num_lig].y_end＝arr_extremoms[num_str-1].y_cor；num_lig++；pr＝0；break；}}}}return(numm_lig)}/*functioncurve()recordstoMASKpenn[]formcodetoeachofpenstrokes(exceptlongdown)accordingtoltscunvature.*/voidcurve(intnum_of_extrms){extemstructTABLE_EXTREMOMSarr_extremoms[MAX_NUM_OF_EXTREMOMS]；intcount；for(count＝0；count＜＝num_of_extrms；count++)switch(penn[count].form_code){case(unsigned)3{if(arr_extremoms[count].in_rot＝＝7)penn[count].form_code＝4；else{if((arr_extremoms[count].in_rot＝＝1)‖(arr_extremoms[count].in_rot＝＝0))penn[count].form_code＝3；elsepenn[count].form_code＝15；}continue；}case(unsigned)5{if(arr_extremoms[count].in_rot＝＝1)penn[count].form_code＝6；else{if((arr_extremoms[count].in_rot＝＝7)‖(arr_extremoms[count].in_rot＝＝0))penn[count].form_code＝5；elsepenn[count].form_code＝16；}continue；}case(unsigned)7；{if(arr_extremoms[count].in_rot＝＝7)penn[count].form_code＝7；else{if((arr_extremoms[count].in_rot＝＝1)‖(arr_extremoms[count].in_rot＝＝0))penn[count].form_code＝8；elsepenn[count].form_code＝17}continue；}case(unsigned)9{if(arr_extremoms[count].in_rot＝＝1)penn[count].form_code＝9；else{if((arr_extremoms[count].in_rot＝＝7)‖(arr_extremoms[count].in_rot＝＝0))penn[count].form_code＝10elsepenn[count].form_code＝18}}defaultcontinue}eturn；if((penn[count].form_code＝＝(unsigned)17)&&((strcmp(temp.“Y＂)！＝0))){strcpy(temp，＂Y＂)；strcat(our_sent，＂Y＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)18)&&((strcmp(temp，＂Z＂)！＝0))){strcpy(temp，＂Z＂)；strcat(our_sent，＂Z＂)；gotoA；}if((penn[count].form_code＝＝3)&&((strcmp(temp，＂C＂)！＝0))){strcpy(temp，＂C＂；strcat(our_sent，＂C＂)；gotoA；}if((penn[count].form_code＝＝4)&&((strcmp(temp，＂D＂)！＝0))){strcpy(temp，＂D＂)；strcat(our_sent，＂D＂)；gotoA；}if((penn[count].fonn_code＝＝5)&&((strcmp(temp，＂E＂)！＝0))){strcpy(temp，＂E＂)；strcat(our_sent，＂E＂)；gotoA；}if(penn[count].form_code＝＝6)&&((strcmp(temp，＂F＂＂)！＝0))){strcpy(temp，“F＂)；strcat(our_sent，＂F＂)；gotoA；}if(penn[count].fomn_code＝＝7)&&((strcmp(temp，＂G＂)！＝0))){strcpy(temp，＂G＂)；strcat(our_sent，＂G＂)；gotoA；}if((penn[count].form_code＝＝8)&&((strcmp(temp，＂H＂)！＝0))){strcpy(temp，＂H＂)；strecat(our_sent，＂H＂)；gotoA；}if((penn[count].form_code＝＝9)&&((strcmp(temp，＂I＂)！＝0))){strcpy(temp，＂I＂)；strcat(our_sent，＂I＂)；gotoA}if((penn[count]form_code＝＝10)&&((strcmp(temp，＂J＂)！＝0))){strcpy(temp，＂J＂)；strcat(our_sent，＂J＂)；gotoA}Aif((penn[count].pen_sts＝＝0)&&(strcmp(temp，＂_＂)！＝0)){strcat(our_sent，＂_＂)；strcpy(temp，＂_＂)；continue}if((penn[count].form_code＝＝0)&&(penn[count].pen_sts＝＝1)&&((strcmp(temp，＂B＂)！＝0))){strcpy(temp，＂B＂)./***********************************************************************-initialMASKpennhavetobebuildfrompenstrokestableform_codehavetobedone＝0recordtoMASKpennisusedinfunctionsdirect，ligat，lig1，lig2，lig3，ord_1_ligat，ord_1_lig1，ord_1_lig2，ord_1_lig3.FromtheseprogramsinformationforeveryfindformhavetobewrittentoMASKfortheseletter.output1_1etterrepresentationinthe＂LETTERSYMBOLICREPRESENTATION＂.output2_letterrepresentationinthe＂LETTERSYMBOLICREPRESENTATIONINGENERALIZEDFORM＂.***********************************************************************/intsentense(intnum_of_extrms){extemstructMASKpenn[MAX_NUM_OF_EXTREMOMS]；extemcnarour_sent[MAX_LENGTH_SENTENSE]；chartemp[10]intcount；strcpy(our_sent，***)；strcpy(temp，＂_＂)；for(count＝1；count＜＝num_of_extrms；count++){if((penn[count].form_code＝＝(unsigned)1)&&((strcmp(temp，＂A＂)！＝0))){strcpy(temp，＂A＂)；strcat(our_sent，＂A＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)11)&&((strcmp(temp，＂i＂)！＝0))){strcpy(temp，＂i＂)；strcat(our_sent，＂i＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)12)&&((strcmp(temp，＂g＂)！＝0))){strcpy(tamp，“g＂)；strcat(our_sent，＂g＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)13)&&((strcmp(temp，＂f＂)！＝0))){strcpy(temp，＂f”)；strcat(our_sent，＂f＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)14)&&((strcmp(temp，＂d＂)！＝0))){strcpy(temp，＂d＂)；strcat(our_sent＂d＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)15)&&((strcmp(temp，＂Q＂)＝0))){strcpy(temp，＂Q＂)；strcat(our_sent，＂Q＂)；gotoA；}if((penn[count].form_code＝＝(unsigned)16)&&((strcmp(temp，＂X＂)＝0))){strcpy(temp，＂X＂)；strcat(our_sent，＂X＂)；gotoA}strcat(our_sent，＂B＂)；continue}}return(1)；}/***********************************************************************afuntionthatrecievestwonumbers，andreturnsthequarterofthesetwonumbersintherangeof0..7.***********************************************************************/intdef_quart(intx，inty){if(x＞0)&&(y＝＝0))return(0)；if(x＞0)&&(y＞0))return(1)；if(x＝＝0)&&(y＞0))return(2)；if(x＜0)&&(y＞0))return(3)；if((x＜0)&&(y＝＝0))return(4)；if(x＜0)&&(y＜0))return(5)；if(x＝＝0)&&(y＜0))return(6)；if(x＞0)&&(y＜0))return(7)；return(15)}/***********************************************************************afunctiontoreturnstheroundnumberofthedivisionoftwointegernumbers.***********************************************************************/intdiv_round(inta，intb){inti＝0；inttemp1，temp2；temp1＝a；temp2＝b；a＝abs(a)；if(b＝＝0)return(MAXINT)；while(a＞b){if(b＞0)a-＝b；elsea+＝b；i++；}if((a+a)＞b)i++；if(((temp1＞0)&&(temp2＞0))‖((temp1＜0)&&(temp2＜0)))return(i)；elsereturn(-i)；}voidsave_files(intnum_direc，char*letter){FILE*fp；inti；intletter_num；charfilename[20]；intget_num(char*letter)；if((letter_num＝get_num(letter))＜0){prinff(＂Errorinthenumberoftheletter％c\n＂，*letter)；getch()；}/*******/fp＝fopen(＂fextr.out＂，＂ab+＂)；fprintf(tp，＂％d％c％d％d＂，map_char[letter_num][1]，(*letter)，num_direc，num_of_extrms)；for(i＝0；i＜＝num_of_extrms；i++)fwrite(&arr_extremoms[i]，sizeof(structTABLE_EXTREMOMS)，1，fp)；fprintf(fp，＂\n＂)；fclose(fp)；/*******/fp＝fopen(“feat.out＂，＂ab+＂)；fprintf(fp，＂％c％d％.4f％.4f％.4f％.4\n＂，(*letter)，map_chaf[letter_num][1]，y_vec_beg，y_vec_end，x_vec_beg，x_vec_end)；fclose(fp)；/*******/fp＝fopen(＂feat1.out＂，＂ab++＂)；fprintf(fp，＂％c％d％d\n＂，(*letter)，map_char[letter_num][1]，amp_y)；tclose(fp)；/*******/if(num_direc＝＝0)fp＝fopen(“fsent0.out＂，＂ab+＂)；if(num_direc＝＝1)fp＝fopen(“fsent1.out＂，＂ab++＂)；if(num_direc＝＝2)fp＝fopen(“fsent2.out＂，＂ab+＂)；if(num_direc＝＝3)fp＝fopen(“fsent3.out”，＂ab+＂)；if(num_direc＝＝4)fp＝fopen(“fsent4.out＂，＂ab+＂)；if(num_direc＝＝5)fp＝fopen(“fsent5.out＂，＂ab+＂)；if(num_direc＝＝6)fp＝fopen(“fsent6.out＂，＂ab+＂)；fprintf(fp，％d％c＂，map_char[letter_num][1]，(*letter))；if(num_direc！＝0){fpnntf(fp，＂％s＂，our_sent)；for(i＝0；i＜num_direc；i++)fprintf(fp.＂％.4f％.4f＂，x[i].x_b，x[i].x_e)；for(i＝0；i＜num_direc；i++)fprintf(fp.＂％.4f％4f＂，y[i].y_b，y[i].y_e)；fprintf(fp，＂％d＂，amp_y)；}fpnntf(fp，＂\n＂)fclose(fp)；}intadd_map(char*letter){inti；for(i＝0；i＜NUM_SYMBOLS；i++)if(*letter＝＝(cnar)map_char[i]){map_char[i][1]++；return(i)；}if(i＝＝NUM_SYMBOLS){printf(＂Thereisnosuchcharacterinthemap％c\n＂，*letter)；return(1)；}return(-1)；}voidread_map(void){FILE*fp；inti；fp＝fopen(*map_ch＂，＂rb＂)；for(i＝0；i＜NUM_SYMBOLS；i++)fscanf(fp，＂％d％d\n＂，&map_char[i]，&map_char[i][1])；fclose(fp)；}voidsave_map(void){FILE*fp；inti；fp＝fopen(＂map_ch＂，＂wb＂)；for(i＝0；i＜NUM_SYMBOLS；i++)fprintf(fp，％d％d\n＂，map_cha[i]，map_char[i][1])；fclose(fp)；}intget_num(char*letter){inti；for(i＝0；i＜NUM_SYMBOLS；i++)if(*letter＝＝(char)map_char[i])return(i)；return(-1)；}]]></pre>III.一般化<prelisting-type="program-listing"><![CDATA[voidmain(void){FILE*fp，*fp1；inti；charfilename[30]，filename1[30]；read_map()；for(i＝1；i＜＝MAXAMOUNT_DIREC；i++){if(i＝＝1){strcpy(filename，＂fsent1.out＂)；strcpy(filename1，＂fgen1.out＂)；printf(＂——％d——\n＂，i)；gotoA；}if(i＝＝2){strcpy(filename，＂fsent2.out＂)；strcpy(filename1，＂fgen2.out＂)；printf(＂——％d——\n＂，i)；gotoA；}if(i＝＝3){strcpy(filename，＂fsent3.out＂)；strcpy(filename1，＂fgen3.out＂)；printf(“——％d——\n＂，i)；gotoA；}if(i＝＝4){strcpy(filename，＂fsent4.out＂)；strcpy(filename1，＂fgen4.out＂)；printf(＂——％d——\n＂，i)；gotoA；}if(i＝＝5){strcpy(filename，＂fsent5.out＂)；strcpy(filename1，＂fgen5.out＂)；printf(＂——％d——\n＂，i)；gotoA；}if(i＝＝6){strcpy(filename，＂fsent6.out＂)；strcpy(filename1，＂fgen6.out＂)；printf(＂——％d——\n＂，i)；gotoA；}Afp1＝fopen(filename1，＂wb＂)；fclose(fp1)；gener(i.filename，filename1)；}fp1＝fopen(＂genfeat.out＂，＂wb＂)；fclose(fp1)；gener_feat()；fp1＝fopen(＂genfet1.out＂，＂wb＂)；fclose(tp1)；gener_feat1()}voidread_map(void){FILE*fp；inti；fp＝fopen(＂map_ch＂，＂rb”)；for(i＝0；i＜NUM_SYMBOLS；i++)fscanf(fp，＂％d％c\n＂，&map_char[i]，&map_char[i][1])；fclose(fp)；}voidgener(inti，charfilename[]，charfilename1[]){voidgether(charletter，intnum_dir，charfilename[]，charfilename1[])；intj；for(j＝0；j＜100；j++){if(map_char[j][1]＞0)gether(map_char[j]，i，filename，filename1)；}}voidgener_feat(void){voidgether_feat(charletter)；intj；for(j＝0；j＜100；j++){if(map_char[j][1]＞0)gether_teat(map_char[j])；}}voidgener_feat1(void){voidgether_feat1(charletter)；intj；for(j＝0；j＜100；j++){if(map_char[j][1]＞0)gether_feat1(map_char[j])；}}voidgether(charletter，intnum_dir，charfilename[]，charfilename1[]){charch；intletter_num；inti，amount；intamp_y；FILE*fp；intconv(void)；voidconv_dir_defin(intamount，intnum_dir)；voidwrite_to_gen(intamount，intnum_dir，charletter)；voidsave_gen(intnum_dir，charletter，charfilename1[])；voidsave_xy(intnum_dir，charfilename1[])；amount＝0；gen.repr.num＝0；for(i＝0；i＜＝MAX_AMOUNT_DIREC；i++)gen.repr.tabl[i].number＝0；fp＝fopen(filename，＂rb＂)；while(fscanf(fp，＂％d＂，&letter_num)！＝EOF){fscanf(fp，＂％c＂，&ch)；fscanf(fp，＂％s＂，our_sent)；for(i＝0；i＜num_dir；i++)fscanf(fp，＂％f％f＂，&bx[amount][i]；x_b，&bx[amount][i].x_e)，for(i＝0；i＜num_dir；i++)fscanf(fp，＂％f％f＂，&by[amount][i].y_b，&by[amount][i].y_e)；fscanf(fp，＂％d\n＂，&amp_y)；if(ch＝＝letter){conv()；write_to_gen(amount，num_dir-1，letter)；amount++；if(amount＝＝MAX_REPRESNT){fclose(fp)；break；}}}fclose(fp)；if(amount＞0){conv_dir_defin(amount，num_dir)；save_gen(num_dir，letter，filename1)；save_xy(num_dir，filename1)；}}voidsave_gen(intnum_dir，charletter，charfilename1[]){FILE*fp1；inti，j；fp1＝fopen(fiiename1，＂ab++＂)；fprintf(fp1，％c＂，letter)；fprintf(fp1，％d％c％d＂，gen.amount，gen.repr.letter，gen.repr.num)；for(i＝0；i＜＝num_dir；i++){fprintf(fp1，％d＂，gen.repr.tabl[i].number)；if(gen.repr.tabl[i].number＞0){for(j＝0；j＜gen.repr.tabl[i].number；j++)fprintf(fp1，＂％s＂，gen.repr.tabl[i].row[j].str)；fprintf(fp1，＂\n＂；}}fclose(fp1)；} voidsave_xy(intnum_dir，charfilename1[]) {FILE*fp1； inti； fp1＝fopen(filename1，＂ab+＂)； for(i＝0；i＜num_dir；i++) fprintf(fp1，＂％4f％.4f＂，x_midll[i].x_b，x_midll[i].x_e)； for(i＝0；i＜num_dir；i++) fprintf(fp1，＂％4f％.4f＂，x_dev[i].x_b，x_dev[i].x_e)； for(i＝0；i＜num_dir；i++) fprintf(fp1，＂％.4f％.4f＂，y_midll[i].y_b，y_midll[i].y_e)； for(i＝0；i＜num_dir；i++) fprintf(fp1，＂％4f％4f\n＂，y_dev[i].y_b，y_dev[i].y_e)； fclose(fp1)；}voidsavefeat1(charletter){FILE*fp1； inti； fp1＝fopen(“genfeat.out＂，＂ab+＂)； fprintf(fp1，＂％c＂，letter)； fprintf(fp1，＂％.4f％.4f％.4f％.4f\n＂，x_midll.x_b，x_midll.x_e， y_midll.y_b，y_midll.y_e)； for(i＝0；i＜3；i++) {fpritf(fp1，＂％.4f％.4f％.4f％.4f\n＂，x_dev[i].x_b，x_dev[i].x_e， y_dev[i].y_b，y_dev[i].y_e)； } fclose(fp1)；}voidsave_feat2(charlettef){FILE*fp1； inti； fp1＝fopen(＂genfet1.out＂，＂ab+＂)； fprintf(fp1，＂％c＂，letter)； fprintf(fp1，＂％.4f％d％d\n＂，y_midll.y_b，amp_y.amp_y[1])； for(i＝0；i＜3；i++) fprintf(fp1，％.4f＂，y_dev[i].y_b)； fprintf(fp1，“\n”)； fclose(fp1)；}voidgether_feat(charletter){ voidcalc_vec(intamount)； FILE*fp，fp1； intamount，letter_num； charch； amount＝0； fp＝fopen(＂feat.out＂，＂rb＂)； while(fscanf(fp，*％c＂，&ch)！＝EOF) {fscanf(fp，＂％d％f％f％f％f\n＂，&letter_num. &by[amount].y_b，&by[amount].y_e， &bx[amount][D].x_b，&bx[amount].x_e)； if(ch＝＝letter) {amount++； if(amount＝＝MAX_REPRESNT)break； } } fclose(fp)；if(amount＞0){calc_vec(amount)； save_feat1(letter)；}}voidgether_feat1(charletter){voidcalc_amp(intamount)；FILE*fp；intamount，letter_num； charch；amount＝0；by[i][count].y_e； summ_4＝summ_4+temp*temp； } x_dev[count].x_b＝sqrt(summ_1/(float)amount)； y_dev[count].y_b＝sqrt(summ_2/(float)amount)； x_dev[count].x_e＝sqrt(summ_3/(float)amount)； y_dev[count].y_e＝sqrt(summ_4/(float)amount)； } } return；}voidcalc_vec(intamount){intcount，i； floatsumm_1＝0.0； floatsumm_2＝0.0； floatsumm_3＝0.0； floatsumm_4＝0.0； floatsumm_1m＝0.0； floatsumm_2m＝0.0； floatsumm_3m＝0.0； floatsumm_4m＝0.0； floattemp； intam1，am2，am3，am4，am5，am6，am7，am8； if(amount＞0) for(i＝0；i＞amount；i++) {summ_1＝summ_1+bx[i].x_b； summ_2＝summ_2+by[i].y_b； summ_3＝summ_3+bx[i].x_e； summ_4＝summ_4+by[i].y_e； } x_midll.x_b＝summ_1/(float)amount； y_midll.y_b＝summ_2/(float)amount； x_midll.x_e＝summ_3/(float)amount； y_midll.y_e＝summ_4/(float)amount； summ_1＝0.0； summ_2＝0.0； summ_3＝0.0； summ_4＝0.0； summ_1m＝0.0； summ_2m＝0.0； summ_3m＝0.0； summ_4m＝0.0； am1＝0； am2＝0； am3＝0； am4＝0； am5＝0； am6＝0； am7＝0； am8＝0； for(i＝0；i＜amount；i++) {temp＝x_midll.x_b-bx[i].x_b； if(temp＞0.0) {summ_1＝summ_1+temp*temp； am1++；} else {summ_1m＝summ_1m+temp*temp； am2++； } temp＝y_midll.y_b-by[i].y_b； if(temp＞0.0) {summ_2＝summ_2+temp*temp； am3++； } else {summ_2m＝summ_2m+temp*temp； am4++； } temp＝x_midll.x_e-bx[i].x_e； if(temP＞0.0) {summ_3＝summ_3+temp*temp； am5++； } else {summ_3m＝summ_3m+temp*temp； am6++； } temp＝y_midll.y_e-by[i].y_e； if(temp＞0.0) {summ_4＝summ_4+temp*temp； am7++； } else {summ_4m＝summ_4m+temp*temp； am8++； } } if(am1＝＝0)x_dev.x_b＝0.0；∥dev- elsex_dev.x_b＝sqrt(summ_1/(float)am1)； if(am2＝＝0)x_dev[1].x_b＝0.0；∥dev+ elsex_dev[1].x_b＝sqrt(summ_1m/(float)am2)； if((am1+am2)＝＝0)x_dev[2].x_b＝0.0；∥(dev elsex_dev[2].x_b＝sqrt((summ_1+summ_1m)/(float)(am1+am2))； if(am3＝＝0)y_dev.y_b＝0.0；∥dev- elsey_dev.y_b＝sqrt(summ_2/(float)am3)； if(am4＝＝0)y_dev[1].y_b＝0.0；∥dev+ elsey_dev[1].y_b＝sqrt(summ_2m/(float)am4)； if((am3+am4)＝＝0)y_dev[2].y_b＝0.0；∥dev elseydev[2].y_b＝sqrt((summ_2+summ_2m)/(float)(am3+am4))； if(am5＝＝0)x_dev.x_e＝0.0；∥dev- elsex_dev.x_e＝sqrt(summ_3/(float)am5)； if(am6＝＝0)x_dev[1].x_e＝0.0；∥dev+ elsex_dev[1].x_e＝sqrt(summ_3m/(float)am6)； if((am5+am6)＝＝0)xdev[2].x_e＝0.0；∥dev elsex_dev[2].x_e＝sqrt((summ_3+summ_3m)/(float)(am5+am6))； if(am7＝＝0)y_dev.y_e＝0.0；∥dev- elsey_dev.y_e＝sqrt(summ_4/(float)am7)； if(am8＝＝0)y_dev[1].y_e＝0.0；∥dev+ elsey_dev[1].y_e＝sqrt(summ_4m/(float)am8)； if((am7+am8)＝＝0)y_dev[2].y_e＝0.0；∥dev elsey_dev[2].y_e＝sqrt((summ_4+summ_4m)/(float)(am7+am8))；}fp＝fopen(＂feat1.out＂，＂rb＂)；while(fscanf(fp，＂％c＂，&ch)！＝EOF){fscanf(fp，＂％d％d\n＂，&lette_num，&amp_y[amount])；if(ch＝＝letter){amount++；if(amount＝＝MAX_REPRESNT)break；}}fclose(fp)；if(amount＞0){calc_amp(amount)；save_feat2(letter)；}}/***********************************************************************functionconv_dir_defin()calculatesdispersionsofxandyrelativecoordinatesinletterskeleton.***********************************************************************/voidconv_dir_defin(intamount，intnum_dir){intcount，i；floatsumm_1＝0.0；floatsumm_2＝0.0；floatsumm_3＝0.0；floatsumm_4＝0.0；floattemp；if(amount＞＝0){for(count＝0；count＜num_dir；count++){summ_1＝0.0；summ_2＝0.0；summ_3＝0.0；summ_4＝0.0；for(i＝0；i＜amount；i++){summ_1＝summ_1+bx[i][count].x_b；summ_2＝summ_2+by[i][count].y_b；summ_3＝summ_3+bx[i][count].x_e；summ_4＝summ_4+by[i][count].y_e；}x_midll[count].x_b＝summ_1/(float)amount；y_midll[count].y_b＝summ_2/(float)amount；x_midll[count].x_e＝summ_3/(float)amount；y_midll[count].y_e＝summ_4/(float)amount；summ_1＝0.0；summ_2＝summ_1；summ_3＝summ_2；summ_4＝summ_3；for(i＝0；i＜amount；i++){temp＝x_midll[count].x_b；bx[i][count].x_b；summ_1＝summ_1+temp*temp；temp＝y_midll[count].y_b-by[i][count].y_b；summ_2＝summ_2+temp*temp；temp＝x_midil[count].x_e-bx[i][count].x_e；summ_3＝summ_3+temp*temp；temp＝y_midll[count].y_e；voidcalc_amp(intamount){inti；floatsumm_1＝0.0；floatsumm_1m＝0.0；floatamp_midll，temp；intam1，am2；intmax，min；max＝amp_y；min＝amp_y；if(amount＞0)for(i＝0；i＜amount；i++){summ_1＝summ_1+amp_y[i]；if(amp_y[i]＞max)max＝amp_y[i]；if(amp_y[i]＜min)min＝amp_y[i]；}amp_midll＝summ_1/(float)amount；am1＝0；am2＝0；summ_1＝0.0；summ_1m＝0.0；for(i＝0；i＜amount；i++){temp＝amp_midll-amp_y[i]；if(temp＞0.0){summ_1＝summ_1+temp*temp；am1++；}else{summ_1m＝summ_1m+temp*temp；am2++；}}if(am1＝＝0)y_dev.y_b＝0.0；∥dev-elsey_dev.y_b＝sqrt(summ_1/(float)am1)；if(am2＝＝0)y_dev[1].y_b＝0.0；∥dev+elsey_dev[1].y_b＝sqrt(summ_1m/(float)am2)；if((am1+am2)＝＝0)y_dev[2].y_b＝0.0；∥develsey_dev[2].y_b＝sqrt((summ_1+summ_1m)/(float)(am1+am2))；y_midll.y_b＝amp_midll；amp_y＝max；amp_y[1]＝min；}intconv(void){char*p；intcount；count＝0；p＝strtok(our_sent，＂A＂)；if(p){while(p){strcpy(buf[count]，p)；if(strlen(buf[count])＞9)return(0)；count++；p＝strtok(NULL，＂A＂)，}}else{printf(..Thereisnodirectionsinsentence＂)；getch()；return(0)；}return(1)；}∥********************************************∥words’generalization∥********************************************intcmpr(chara，charb，constcharc，constchard，constcharq){if((a＝＝c)&&(b＝＝d)‖(a＝＝d)&&(b＝＝c)‖(a＝＝c)&&(b＝＝q)‖(a＝＝q)&&(b＝＝c)‖(a＝＝d)&&(b＝＝q)‖(a＝＝q)&&(b＝＝d)){return(1)；}elsereturn(0)；}intcomp1(chara[]，charb[]，inti)/********************************************comparesiontwoletterswiththesamenumberinthewordsaandbcount-numberoflettersinwords********************************************/{if(a[i]＝＝b[i]){stmcat(lgt；&b[i]，1)；return(1)；}if(cmpr(a[i]，b[i]，′C′，′D′，′Q)＝＝1){strcat(lgt，＂Q＂)；return(1)；}if(cmpr(a[i]，b[i]，′E′，′F′，′X′)＝＝1){strcat(lgt，＂X＂)；return(1)；}if(cmpr(a[i]，b[i]，′G′，′H′，′Y)＝＝1){strcat(lgt，＂Y＂)；return(1)；}if(cmpr(a[i]，b[i]，′I′，′J′，′Z′)＝＝1){strcat(lgt，＂Z＂)；return(1)；}return(0)；}intcompar(intnum_dir，intcount)/********************************************comparisonthewordwithword’srowk-amountoflettersinthewordsj-amountofwordsintherowreturn；777-wordisn’tintherow0-10-numberofwordsifthereiscomparisonoftheword’spart222-wordalreadyisintherow********************************************/{intk，j，n，m，l，temp；strcpy(lgt，**)；for(j＝0；j＜gen.repr.tabl[count].number；j++)if(strcmp(buf[count]，gen.repr.tabl[count].row[j].str)＝＝0)return(222)；n＝strlen(buf[count])；for(j＝0；j＜gen.repr.tabl[count].number；j++){strcpy(lgt，**)；m＝strlen(gen.repr.tabl[count].row[j].str)；if(n＝＝m){for(k＝0；k＜＝n；k++){temp＝comp1(buf[count]，gen.repr.tabl[count].row[j].str，k)；if(temp＝＝0)break；elseif((temp＝＝1)&&(k＝＝n)){for(l＝0；l＜gen.repr.tabl[count].number；l++)if(strcmp(lgt，gen.repr.tabl[count].row[1].str)＝＝0)return(222)；return(j)；}}}else{if(j＝＝gen.repr.tabl[count].number-1)return(777)；}}return(777)；}/********************************************i-numberofrow(0-infrontoffirstdirection1-afterfirstdir2-afferseconddir...)********************************************/voidwrite_to_gen(intamount，infnum_dir，charletter){inti，count，j，temp；intm，n；genrepr.letter＝letter；gen.repr.num++；for(count＝0；count＜num_dir+2；count++){if(gen.repr.tabl[count].number＝＝0){if(buf[count]！＝NULL){strcpy(gen.repr.tabl[count].row.str，buf[count])；gen.repr.tabl[count].number++；}}else{temp＝compar(num_dir，count)；if(temp＝＝777){j＝gen.repr.tabl[count].number；strcpy(gen.repr.tabl[count].row[j].str，buf[count])；gen.repr.tabl[count].number++；}else{if(temp！＝222){∥j＝gen[num_dir].repr[i].tabl[counf].number；strcpy(gen.repr.tabl[count].row[temp].str，lgt)；∥gen[num_dir].repr[i].tabl[count].number++；}}}}return；}voidmain(void){intlength(intnum_dir)；voidcutting(inti，intk，FILE*fpx)；voidadd_1(intnum_dir)；charfilename1[30]；chartemp[10]；inti，k；intnum_cut_long；fp＝fopen(＂g_cut1.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂g_cut2.out＂，＂wb＂)；fclose(fp)；fp＝fopen(“g_cut3.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂g_cut4.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂g_cut5.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂g_cut6.out＂，＂wb＂)；fclose(fp)；for(i＝1；i＜＝6；i++){strcpy(filename1，＂fgen..)；sprintf(temp，＂％d＂，i)；stmcat(filename1，temp，1)；strcat(filename1，＂.out＂)；if((fp＝fopen(filename1，＂r+b＂))＝＝NULL)continue；strcpy(filename1，＂g_cut＂)；strncat(filename1，temp，1)；strcat(filename1，＂.out＂)；if((fp1＝fopen(filename1，＂a+b＂))＝＝NULL)continue；add_1(i)；fclose(fp)；fclose(fp1)；}for(i＝2；i＜＝6；i++){strcpy(filename1，＂fgen＂)；sprintf(temp，＂％d＂，i)；strncat(filename1，temp，1)；strcat(filename1，＂.out＂)；if((fp＝fopen(filename1，＂r+b＂))＝＝NULL)continue；while((num_cut_long＝length(i))＞0){for(k＝i-1；k＞＝1；k-){switch(k){case1fp1＝fopen(“g_cut1.out＂，＂a+b＂)；cutting(i，k，fp1)；fclose(fp1)；break；case2fp2＝fopen(“g_cut2.out＂，＂a+b＂)；cutting(i，k，fp2)；fclose(fp2)；break；case3fp3＝fopen(＂g_cut3.out＂，＂a+b＂)；cutting(i，k，fp3)；fclose(fp3)；break；case4fp4＝fopen(“g_cut4.out＂，＂a+b＂)；cutting(i，k，fp4)；fclose(fp4)；break；case5fp5＝fopen(＂g_cut5.out＂，＂a+b＂)；cutting(i，k，fp5)；fclose(fp5)；break；case6fp6＝fopen(＂g_cut6.out＂，＂a+b＂)；cutting(i，k，fp6)；fclose(fp6)；break；defaultprintf(＂Errorincutting\n＂)；getch()；}}}fclose(fp)；}}voidcutting(inti，intk，FILE＂fpx){voidcut_sent(intnum_dir)；voidcut_skel(intnum_dir，intk)；voidsav_new(intnum_dir，intk，FILE*fp1)；cut_skel(i，k)；cut_sent(i)；sav_new(i，k，fpx)；}intlength(intnum_dir){inti，j；floatarr_hip[6]；charletter；intpr；floattemp_fl，w；inttemp；while(fscanf(fp，＂％c＂，&letter)！＝EOF)/*letterfromgenset*/{fscanf(fp，＂％d％c％d＂，&gen.amount，&gen.repr.letter，&gen.repr.num)；for(i＝0；i＜＝num_dir；i++){fscanf(fp，＂％d＂，&gen.repr.tabl[i].number)；for(j＝0；j＜gen.repr.tabl[i].number；j++)fscanf(fp，＂％s＂，gen.repr.tabl[i].row[j].str)；fscanf(fp，＂\n＂)；}for(i＝0；i＜num_dir；i++)fscanf(fp，＂％f％f＂，&x_midll[i].x_b，&x_midll[i].x_e)；for(i＝0；i＜num_dir；i++)fscanf(fp，＂％f％f＂，&x_dev[i].x_b，&x_dev[i].x_e)；for(i＝0；i＜num_dir；i++)fscanf(fp，＂％f％f＂，&y_nidll[i].y_b，&y_midll[i].y_e)；for(i＝0；i＜num_dir；i++)fscanf(fp，＂％f％f\n＂，&y_dev[i].y_b，&y_dev[i].y_e)；for(i＝0；i＜num_dir；i++)arr_hip[i]＝fabs(y_midll[i].y_e-y_midll[i].y_b)；for(i＝0；i＜num_dir；i++)arr_num_long[i]＝i；pr＝1；while(pr＝＝1){pr＝0；for(i＝num_dir-1；i＞＝1；i-){if(arr_hip[i]＜arr_hip[i-1]){temp_fi＝arr_hip[i-1]；arr_hip[i-1]＝arr_hip[i]；arr_hip[i]＝temp_fi；temp＝arr_num_long[i-1]；arr_num_long[i-1]＝arr_num_long[i]；arr_num_long[i]＝temp；pr＝1；}}}w＝1.0；for(i＝0；i＜num_dir；i++){coef[i]＝w*(1.0-arr_hip[i])；w＝coef[i]；}return(1)；}return(-1)；}voidpaste(intk，intout_number，structSTRINGout[10]，intin_number，structSTRINGin[10]){inti，j，m，len_out；chara[20]；m＝0；gen_cut.repr.tabl[k].number＝out_number*in_number；if(gen_cut.repr.tabl[k].number＞＝100)gen_cut.repr.tabl[k].number＝99；for(i＝0；i＜out_number；i++)for(j＝0；j＜in_number；j++){strcpy(a，****)；len_out＝strlen(out[i].str)；if(out[i].str[len_out-1]＝＝in[j].str){if(len_out＞1){strncpy(a，out[i].str，len_out-1)；a[len_out-1]＝′\0′；}elsestrcpy(a，****)；}elsestrcpy(a，out[i].str)；strcat(a，in[j].str)；if(strlen(a)＜10){strcpy(gen_cut.repr.tabl[k].row[m].str，a)；m++；if(m＞＝100)break；}else{printf(＂ERR.paste，lengthofpastedword＞10**)；getch()；}}}/********************************************num_dir-anishialamountoflong.k-amountoflong，whichhavetobestay.(num_dir-k)-numberofloop.********************************************/voidcut_sent(intnum_dir){voidcut_word_in(chargen_cut[15]，chara[15])；voidcut_word_out(chargen_cut[15]，chara[15])；intj，k，i；chara[15]；intout_number，in_number，len，pr，pr1；structSTRlNGout[10]；structSTRINGin[10]；gen_cut.amount＝gen.amount；gen_cut.repr.letter＝gen.repr.letter；gen_cut.repr.num＝gen.repr.num；j＝0；k＝0；pr＝0；pr1＝0；while(j＜num_dir){if(mark_long[i]！＝0){j++；pr1＝1；continue；}elsebreak；}if(pr1＝＝1){in_number＝gen.repr.tabl[j].number；for(i＝0；i＜in_number；i++){strcpy(a，gen.repr.tabl[j].row[i].str)；cut_word_in(gen.repr.tabl[j].row[i]str，a)；strcpy(in[i].str，a)；}gen_cut.repr.tabl[k].number＝in_number；for(i＝0；i＜in_number；i++)strcpy(gen_cut.repr.tabl[k].row[i].str，in[i].str)；pr1＝0；}else{gen_cut.repr.tabl[k].number＝gen.repr.tabl[j].number；for(i＝0；i＜gen_cut.repr.tabl[k].number；i++)strcpy(gen_cut.repr.tabl[k].row[i].str，gen.repr.tabl[j].row[i].str)；}for(i＝0；i＜gen_cut.repr.tabl.number；i++){if(gen_cut.repr.tabl.row[i].str＝＝＂_＂)gen_cut.repr.tabl.row[i].str＝＂*＂；else{if(gen_cut.repr.tabl.row[i].str＝＝＂*＂)else{strcpy(a，＂*＂)；strcat(a，gen_cut.repr.tabl.row[i].str)；strcpy(gen_cut.repr.tabl.row[i].str，a)；}}}j++；k++；while(i＜num_dir){while((mark_long[j]＝＝0)&&(i＜nurm_dir)){gen_cut.fepr.tabl[k].number＝gen.repr.tabl[i].number；for(i＝0；i＜gen_cut.repr.tabl[k].number；i++)strcpy(gen_cut.repr.tabl[k].row[i].str，gen.repr.tabl[j].row[i].str)；j++；k++；}pr＝1；out_number＝gen.reprtabl[j].number；for(i＝0；i＜out_number；i++){strcpy(a，gen.repr.tabl[j]row[i].stt)；cut_word_out(gen.repr.tabl[j].row[i].str，a)；strcpy(out[i].str，a)；}while((mark_long[j]＝＝1)&&(j＜num_dir))j++；if(j＝＝num_dir)break；pr＝0；in_number＝gen.repr.tabl[j].number；for(i＝0；i＜in_number；i++){strcpy(a，gen.repr.tabl[j].row[i].str)；cut_word_in(gen.repr.tabl[j].row[i].str，a)；strcpy(in[i].str，a)；}paste(k，out_number，out，in_number，in)；j++；k++；}if(pr＝＝1){gen_cut.repr.tabl[k].number＝out_number；for(i＝0；i＜out_number；i++)strcpy(gen_cut.repr.tabl[k].row[i].str，out[i].str)；}else{gen_cut.repr.tabl[k].number＝gen.repr.tabl[j].number；for(i＝0；i＜gen_cut.repr.tabl[k].number；i++)strcpy(gen_cut.repr.tabl[k].row[i].str，gen.repr.tabl[j].row[i].str)；}k++；for(i＝0；i＜gen_cut.repr.tabl[k-1].number；i++){len＝strlen(gen_cut.repr.tabl[k-1].row[i].str)；if(gen_cut.repr.tabl[k-1].row[i].str[len-1]＝＝＂_＂)；else{strcpy(a，gen_cut.repr.tabl[k-1].row[i].str)；strcat(a，＂_＂)；strcpy(gen_cut.repr.tabl[k-1].row[i].str，a)；strcpy(a，gen_cut.repr.tabl[k-1].row[i].str)；}}}voidcut_skel(intnum_dir，intk){intj；intl；floatmin_x，min_y；for(j＝0；j＜6；j++)mark_long[j]＝0；for(j＝0；j＜num_dir-k；j++)mark_long[arr_num_long[j]]＝1；l＝0；for(j＝0；j＜num_dir；j++){if(mark_long[j]＝＝0){cut_x_midll[l].x_b＝x_midll[j].x_b；cut_x_midll[l].x_e＝x_midll[j].x_e；cut_y_midll[l].y_b＝y_midll[j].y_b；cut_y_midll[l].y_e＝y_midll[j].y_e；cut_x_dev[l].x_b＝x_dev[j].x_b；cut_x_dev[l].x_e＝x_dev[j].x_e；cut_y_dev[l].y_b＝y_dev[j].y_b；cut_y_dev[l]y_e＝y_dev[j].y_e；1++；}}min_x＝9999.0；min_y＝9999.0；for(j＝0；j＜＝l；j++){if(min_x＞cut_x_midl[j].x_b)min_x＝cut_x_midll[j].x_b；if(min_x＜cut_x_midll[j].x_e)min_x＝cut_x_midll[j].x_e；if(min_y＜cut_y_midll[j].y_b)min_y＝cut_y_midll[j].y_b；if(min_y＜cut_y_midll[j].y_e)min_y＝cut_y_midll[j].y_e；}for(j＝0；j＜l；j++){cut_x_midll[j].x_b＝cut_x_midll[j].x_b-min_x；cut_x_midll[j].x_e＝cut_x_midll[j].x_e-min_x；cut_y_midll[j].y_b＝cut_y_midll[j].y_b-min_y；cut_y_midll[j].y_e＝cut_y_midll[j].y_e-min_y；}}voidsav_new(intnum_dir，intk，FILE*fp1){inti，j；fprintf(fp1，＂％c＂，gen_cut.repr.letter)；fprintf(fp1，＂％f＂，coef[num_dir-k-1])；fprintr(fp1，＂％d％c％d＂，gen_cut.amount，gen_cut.repr.letfer，gen_cut.repr.num)；for(i＝0；i＜＝k；i++){fprintf(fp1，＂％d＂，gen_cut.repr.tabl[i].number)；if(gen_cut.repr.tabl[i].number＞0){for(j＝0；j＜gen_cut.repr.tabl[i].number；j++)fprintf(fp1，＂％s＂，gen_cut.repr.tabl[i].row[j].str)；fprintf(fp1，＂\n＂)；}}for(i＝0；i＜k；i++)fprintf(fp1，＂％.4f％.4f＂，cut_x_midll[i].x_b，x_midll[i].x_e)；for(i＝0；i＜k；i++)fprintf(fp1，＂％.4f％.4f＂，cut_x_dev[i].xb，x_dev[i].x_e)；for(i＝0；i＜k；i++)fprintf(fp1，＂％.4f％.4f＂，cut_y_midll[i].y_b，y_midll[i].y_e)；for(i＝0；i＜k；i++)fprintf(fp1，＂％.4f％.4f\n＂，cut_y_dev[i].y_b，y_dev[i].y_e)；}intcmpr_out(charc){if((c＝＝′E′)l‖(c＝＝′F′)‖(c＝＝′X′)‖(c＝＝′g′)‖(c＝＝′G′)‖(c＝＝′H′)‖(c＝＝′f)‖(c＝＝′Y′))return(1)；elsereturn(0)；}intcmpr_in(charc){if((c＝＝′C′)‖(c＝＝′D′)‖(c＝＝′Q′)‖(c＝＝′i′)‖(c＝＝′J′)‖(c＝＝′l′)‖(c＝＝′d′)‖(c＝＝′Z′))return(1)；elsereturn(0)；}voidcut_word_out(chargen_cut[15]，chara[15]){inti；intlen；len＝strlen(gen_cut)；i＝len-1；while(cmpr_out(gen_cut[i])＝＝1){i-；if(i＜0)break；}if(i＜0)strcpy(a，＂_＂)；else{stmcpy(a；gen_cut，i+1)；a[i+1]＝′\0′；}}voidcut_word_in(chargen_cut[15]，chara[15]){inti；intlen；len＝strlen(gen_cut)；i＝0；while(cmpr_in(gen_cut[i])＝＝1){i++；if(i＞len-1)break；}if(i＞len-1)strcpy(a，＂_＂)；else{strcpy(a，****)；strncpy(a，gen_cut+i，len-i)；a[len-i]＝′\0′；}}voidadd_1(intnum_dir){charletter；inti，j；while(fscanf(fp，＂％c＂，&letter)！＝EOF)/*letterfromgenset*/{fprintf(fp1，＂％c＂，letter)；fprintf(fp1，＂％f＂.1.0)；fscanf(fp，＂％d％c％d＂，&gen.amount，&gen.repr.letter，&gen.repr.num)；fprintf(fp1，＂％d％c％d＂，gen.amount，gen.repr.letter，gen.repr.num)；for(i＝0；i＜＝num_dir；i++){fscanf(fp，＂％d＂，&gen.repr.tabl[i].number)；fprintf(fp1，＂％d＂，gen.repr.tabl[i].number)；for(j＝0；j＜gen.repr.tabl[i].number；j++){fscanf(fp，＂％s＂，gen.repr.tabl[i].row[j].str)；fprintf(fp1，＂％s＂，gen.repr.tabl[i].row[j].str)；}fscanf(fp，＂\n＂)；fprintf(fp1，＂\n＂)；}for(i＝0；i＜num_dir；i++){fscanf(fp，＂％f％f＂，&x_midll[i].x_b，&x_midll[i].x_e)；fprintf(fp1，＂％f％f＂，x_midll[i].x_b，x_midll[i].x_e)；}for(i＝0；i＜num_dir；i++){fscanf(fp，＂％f％f＂，&x_dev[i].x_b，&x_dev[i].x_e)；fprintf(fp1，＂％f％f＂，x_dev[i].x_b，x_dev[i].x_e)；}for(i＝0；i＜num_dir；i++){fscanf(fp，＂％f％f＂，&y_midll[i].y_b，&y_midll[i].y_e)；fprintf(fp1，＂％f％f＂，y_midll[i].y_b，y_midll[i].y_e)；}for(i＝0；i＜num_dir；i++){fscanf(fp，＂％f％f\n＂，&y_dev[i].y_b，&y_dev[i].y_e)；fprintf(fp1，＂％f％f\n＂，y_dev[i].y_b，y_dev[i].y_e)；}}}]]></pre>IV.识别过程<prelisting-type="program-listing"><![CDATA[intmain(void){FILE*fp；charinfile[30]；intnum；structffblkffblk；intdone；intSeqNo；read_map()；fp＝fopen(＂fextr.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂feat.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂feat1.out＂，＂wb＂)；fclose(fp)；fp＝fopen(＂rsent.out＂，＂wb＂)；fclose(fp)；done＝findfirst(＂*.tab＂，&ffblk，0)；num＝1；while(！done){sprintf(infile，＂％-12.12s＂，ffblk.ff_name)；fp＝fopen(infile，＂rb＂)；if(！fp){printf(＂Can’topeninputfile-％s-\n＂，infile)；return；}if(infie！＝′B′){letter＝tolower(infile)；SeqNo＝(int)(infile[2]-48)；}else{if(isdigit((int)infile[1])！＝0){letter＝tolower(infile)；SeqNo＝(int)(infile[2]-48)；}else{letter＝infile[1]；SeqNo＝(int)(infile[3]-48)；}}num＝transform(fp，&letter)；if((num＞＝0)&&(num＜7))save_files(SeqNo，num，&letter)；if(num＝＝-3)num＝1；fclose(fp)；done＝findnext(&ffblk)；}return0；}/*MAINFORRECOGNITION*/voidrecogn(FILE*fp，FILE*fp2)；intmain(void){FILE*fp，*fp2；inti；charfilename[30]，filename1[30]；map_char[i][1]＝0；map_char[i]＝′a′；fp2＝fopen(“sort.out＂，＂wb＂)；fp＝fopen(＂rsent.out＂，＂rb＂)；recogn(fp，fp2)；fcose(fp)；fclose(fp2)；return0；}/****************************************************************************structuresinitialization(initialsetofthesymbolstoberecognized)****************************************************************************/voidread_map(void){FILE*fp；inti；fp＝fopen(＂map_ch＂，＂rb＂)；for(i＝0；i＜NUM_SYMBOLS；i++)fscanf(fp，＂％d％d\n＂，&map_char[i]，&map_char[i][1])；fclose(fp)；}/****************************************************************************functiondefinesifthecharletterwasinmappingcardintrainingset****************************************************************************/intcheck_map(charletter){inti；for(i＝0；i＜NUM_SYMBOLS；i++)if((letter＝＝(char)map_char[i])&&(map_char[i][1]＞0))return(i)；if(i＝＝NUM_SYMBOLS){pnntf(＂Thereisnosuchcharacterinthemap\n＂)；return(-1)；}return(-1)；}/****************************************************************************functionreadsFILE*fp(symbolstoberecognized)andusinggeneralizedinformationafterthetraining(FILE*fp1)definessimilarityfunctionsforeverysymboltoberecognizedfromthedifferentpointsofviewandwritesthisinformationtoFILE*fp2****************************************************************************/intconv(void)；floatdef_k_sent(intnum_dir)；floatmetric_dir_y(intnum_dir，intamp_y，structXx[]，structYy[])；floatmetric_dir_x(intnum_dir，intamp_y，structXx[]，structYy[])；voidlength(intnum_dir)；floatcut_skel(intnum_dir，intk)；voidcut_sent(intnum_dir)；intcalc_per_up(chara[MAX_LENGTH_SENTENSE])；voidrecogn(FILE*fp，FILE*fp2){FILE*fp1；charfilename1[30]；floatw_sent.w_y，w_x；intamp_y，w_pen_up；charch，letter；intlette_num；inti，j，k；intnum_dir；charnum_long[10]；floatgen_coef，rsent_coef；intgen_max_pan_up，gen_min_pen_up；intrsent_pen_up；charour_sent1[MAX_LENGTH_SENTENSE]；while(fscanf(fp，＂％d＂，&lette_num)！＝EOF){fscanf(fp，*％c＂，&ch)；fscanf(fp，＂％d＂，&num_dir)；if(num_dir＝＝0)continue；fscanf(fp，＂％s＂，our_sent)；/*letterfromrecognitionset*/for(i＝0；i＜num_dir；i++)fscanf(fp，＂％f％f＂，&x[i]x_b，&x[i].x_e)；for(i＝0；i＜num_dir；i++)fscanf(fp，“％f％f＂，&y[i].y_b，&y[i].y_e)；fscanf(fp，＂％d\n＂，&amp_y)；for(i＝0；i＜num_dir；i++)xz[i]＝x[i]；for(i＝0；i＜num_dir；i++)yz[i]＝y[i]；strcpy(our_sent1，our_sent)；if(conv()＝＝0){printf(“Thisligatureistoolong\n＂)；continue；}for(i＝0；i＜＝num_dir；i++)strcpy(bufz[i]，buf[i])；rsent_pen_up＝calc_pen_up(our_sent1)；{k＝num_dir；rsent_coef＝1.0；length(num_dir)；for(num_dir＝k；num_dir＞＝1；num_dir-){strcpy(filename1，＂g_cut＂)；sprintf(num_long，＂％d＂，num_dir)；stmcat(filename1，num_long，1)；strcat(filename1，＂.out＂)；fp1＝fopen(filename1，＂rb＂)；while(fscanf(fp1，＂％c＂，&letter)！＝EOF)/*letterfromganset*/{fscanf(fp1，＂％f＂，&gen_coef)；fscanf(fp1，＂％d％c％d＂，&gen.amount，&gen.repr.letter，&gen.reprnum)；for(i＝0；i＜＝num_dir；i++){fscanf(fp1，＂％d＂，&gen.repr.tabl[i].number)；for(j＝0；j＜gen.repr.tabl[i].number；j++)fscanf(fp1，＂％s＂，gan.repr.tabl[i].row[j].str)；！scanf(fp1，＂\n＂)；}fscanf(fp1，*％d％d\n＂，&gen_max_pen_up，&gen_min_pen_up)；fbr(i＝0；i＜num_dir；i++)fscanf(fp1，“％f％f”&x_midll[i].x_b，&x_midll[i].x_e)；for(i＝0；i＜num_dir；i++)fscanf(fp1，＂％f％f＂，&x_dev[i].x_b，&x_dev[i].x_e)；for(i＝0；i＜num_dir.i++)fscanf(fp1，＂％f％f＂，&y_midll[i].y_b，&y_midll[i].y_e)；for(i＝0；i＜num_dir.i++)fscanf(fp1，＂％f％f\n＂，&y_dev[i].y_b，&y_dev[i].y_e)；w_sent＝gen_coef*rsent_coef*def_k_sent(num_dir-1)；w_y＝gen_coef*rsent_coef*metric_dir_y(num_dir，amp_y，x，y)；w_x＝gen_coef*rsent_coef*metric_dir_x(num_dir，amp_y，x，y)；if((rsent_pen_up＞＝gen_min_pen_up)&&(rsent_pen_up＜＝gen_max_pen_up))w_pen_up＝1；elsew_pen_up＝0；if(rsent.coef＞TRESH_CUT)fprintf(fp2，＂％c％d％d％c％f％f％f％d\n＂，ch，letter_num，num_dir，letter，w_sent，w_y，w_x，w_pen_up)；}fclose(fp1)；if(num_dir＝＝1)；else{rsent_coef＝cut_skel(k，num_dir-1)；cut_sent(k)；}}fprintf(fp2，＂*＂)；}}}voidlength(intnum_dir){inti，j；floatarr_hip[6]；charletter；intpr；floattemp_fl；inttemp；for(i＝0；i＜num_dir；i++)arr_hip[i]＝fabs(y[i].y_e-y[i].y_b)；for(i＝0；i＜num_dir；i++)arr_num_long[i]＝i；pr＝1；while(pr＝＝1){pr＝0；for(i＝num_dir-1；i＞＝1；i-){if(arr_hip[i]＜arr_hip[i-1]){temp_fl＝arr_hip[i-1]；arr_hip[i-1]＝arr_hip[i]；arr_hip[i]＝temp_fl；temp＝arr_num_long[i-1]；arr_num_long[i-1]＝arr_num_long[i]；arr_num_long[i]＝temp；pr＝1；}}}coef＝1.0；for(i＝1；i＜＝num_dir；i++)coef[i]＝coef[i-1]*(1.0-arr_hip[i-1])；}voidpaste(intk，charout[10]，charin[10]){inti，j，m，len_out；chara[20]；strcpy(a，＂＂)；len_out＝strlen(out)；if(out[len_out-1]＝＝in){if(len_out＞1){stmcpy(a，out，len_out-1)；a[len_out-1]＝′\0′；}elsestrcpy(a，**)；}elsestrcpy(a，out)；strcat(a，in)；if(strlen(a)＜10)strcpy(buf[k]，a)；else{printf(＂RSENT.OUT-ERR.paste，lengthofpastedword＞10＂)；getch()；}}voidcut_sent(intnum_dir){voidcut_word_in(chargen_cut[15]，chara[15)；voidcut_word_out(chargen_cut[15]，chara[15])；intj，k，i；chara[15]；intout_number，in_number，len，pr，pr1；charout[10]；charin[10]；for(i＝0；i＜＝num_dir；i++)strcpy(buf[i]，**)；j＝0；k＝0；pr＝0；pr1＝0；while(j＜num_dir){if(mark_long[j]！＝0){j++；pr1＝1；continue；}elsebreak；}if(pr1＝＝1){strcpy(a，bufz[j]])；cut_word_in(bufz[j]，a)；strcpy(buf[k]，a)；pr1＝0；}elsestrcpy(buf[k]，bufz[j])；if(buf＝＝＂_＂)buf＝＂*＂；else{if(buf＝＝＂*＂)；else{strcpy(a，＂*＂)；strcat(a，buf)；}}j++；k++；while(j＜num_dir){while((mark_long[j]＝＝0)&&(j＜num_dir)){strcpy(buf[k]，bufz[j])；j++；k++；}pr＝1；strcpy(a，bufz[j])；cut_word_out(bufz[j]，a)；strcpy(out，a)；while((mark_long[j]＝＝1)&&(j＜num_dir))j++；if(j＝＝num_dir)break；pr＝0；strcpy(a，bufz[j])；cut_word_in(bufz[j]，a)；strcpy(in，a)；paste(k，out，in)；j++；k++；}if(pr＝＝1)strcpy(buf[k]，out)；elsestrcpy(buf[k]，bufz[j])；k++；len＝strlen(buf[k-1])；if(buf[k-1][len-1]＝＝“_”)；else{strcpy(a，buf[k-1])；strcat(a，“_＂)；strcpy(buf[k-1]，a)；strcpy(a，buf[k-1])；}}floatcut_skel(intnum_dir，intk){intj；intl；floatmin_x.min_y；for(j＝0；j＜6；j++)mark_long[j]＝0；for(j＝0；j＜num_dir_k；j++)mark_long[arr_num_long[j]]＝1；l＝0；for(j＝0；j＜k；j++){if(mark_long[j]＝＝0){x[l].x_b＝xz[j].x_b；x[l].x_e＝xz[j].x_e；y[l].y_b＝yz[j].y_b；y[l].y_e＝yz[j].y_e；l++；}}min_x＝9999.0；min_y＝9999.0；for(j＝0；j＜＝l；j++){if(min_x＞x[j].x_b)min_x＝x[j].x_b；if(min_x＞x[j].x_e)min_x＝x[j].x_e；if(min_y＞y[j].y_b)min_y＝y[j].y_b；if(min_y＞y[j].y_e)min_y＝y[j].y_e；}for(j＝0；j＜1；j++){x[j].x_b＝x[j].x_b-min_x；x[j].x_e＝x[j].x_e-min_x；y[j].y_b＝y[j].y_b-min_y；y[j].y_e＝y[j].y_e-min_y；}return(coef[num_dir-k])；}intcmp_out(char.c){if((c＝＝′E')‖(c＝＝′F′)‖(c＝＝′x’)‖(c＝＝′g′)‖(c＝＝′G’)‖(c＝＝′H′)‖(c＝＝′f)‖(c＝＝′Y))return(1)；elsereturn(0)；}intcmp_in(charc){if((c＝＝′C)‖＝(c＝＝′D′)‖(c＝＝′Q′)‖(c＝＝′i′)Z‖(c＝＝′J′)‖(c＝＝′l′)‖(c＝＝′d′)‖(c＝＝′Z′))return(1)；elsereturn(0)；}voidcut_word_out(chargen_cut[15]，chara[15]){inti；intlen；len＝strlen(gen_cut)；i＝len-1；while(cmp-out(gen_cut[i])＝＝1){i-；if(i＜0)break；}if(i＜0)strcpy(a，＂-＂)；else{strncpy(a，gen_cut，i+1)；a[i+1]＝′\0′；}}voidcut_word_in(chargen_cut[15]，chara[15]){inti；intlen；len＝strlen(gen_cut)；i＝0；while(cmp_in(gen_cut[i])＝＝1){i++；if(i＞len-1)break；}if(i＞len-1)strcpy(a，＂_＂)；else{strcpy(a，****)；strncpy(a，gen_cut+i，len-i)；a[len_i]＝′\0′；}}intcalc_penup(chara[MAX_LENGTH_SENTENSE]){intcount；char*p；count＝-0；if((strlen(a)＝＝1)&&(a＝＝“_”))return(0)；p＝strchr(a，＂_＂)；if(p＝＝NULL)return(0)；while(p！＝NULL){p＝strchr(p+1，＂_＂)；count++；}count-；return(count)；}/**functionconv()makessentenceseparationintowordsusingsymbol＂A＂asdelimiterandwntestheresultstobu[l].**/intconv(void){char*p；intcount；count＝0；p＝strtok(our_sent，＂A＂)；if(p){while(p){strcpy(buf[count]，p)；if(strlen(buf[count])＞9)return(0)；count++；p＝strtok(NULL，＂A＂)；}}else{printf(＂Thereisnolonginthesentence\n＂)；getch0；return(0)；}return(1)；}floatdef_k_class(chara，charb，constcharc，constchard，constcharq，constchard_small)/*******************a-letterfromthegeneralizedsentenceb-letterfromthesymbols’sentencetoberecognizedc，d，q，d_small-symbols’fromthesameclasssegments’vocabularyfunctiondefinesifthelettersaandthebbelongstooneclassinthesegments’vocabularyornotanddefinesdef_k[i][i]forthemintheweighttabledef_k[5][5]***************************/{floatdef_k[5][5]＝{1.00，0.50，1.00，0.25，0.00，0.50，1.00，1.00，0.25，0.00，1.00，1.00，1.00，0.25，0.00，0.25，0.25，0.25，1.00，0.00，0.00，0.00，0.00，0.00，0.00}；∥posibilitytomodifythesimilarity！！！！charalfabet[4]；inti，j；alfabet＝c；alfabet[1]＝d；alfabet[2]＝q；alfabet[3]＝d_small；i＝0；while(a！＝alfabet[i]){i++；if(i＝＝4)break；}j＝0；while(b！＝alfabet[j]){j++；if(j＝＝4)break；}return(def_k[i][j])；}/**functiondet_k_ietter()calculatessimiliritybetweenlettersinthewordsaccordingtoweightstable.**/floatdef_k_letter(chara[]，charb[]，inti，intj)*******************a-wordfromthegeneralizedsentenceb-wordfromsymbolssentencetoberecognizedi-numberofletterinthewordaj-numberofletterinthewordb*******************/{floattemp；if(a[j]＝＝b[j])return(1.00)；if((temp＝def_k_class(a[i]，b[j]，′C′，′D′，′Q′，′d′))！＝0)return(temp)；if((temp＝def_k_class(a[i]，b[j]，′E′，′F′，′X′，′f’))！＝0)return(temp)；if((temp＝def_k_class(a[i]，b[j]，′G′，′H′，′Y′，′g’))！＝0)return(temp)；if((temp＝def_k_class(a[i]，b[j]，′I′，′J′，′Z′，′i′))！＝0)return(temp)；if((a[i]＝＝b[j])&&(a[i]＝＝′B′))return(1.00)；return(0.0)；}intcmpr_in(charc){if((c＝＝′E′)‖(c＝＝′F′)‖(c＝＝′X’)‖(c＝＝′g′)‖(c＝＝′G′)‖(c＝＝′H′)‖(c＝＝′f′)‖(c＝＝′Y′))return(1)；elsereturn(0)；}intcmpr_out(charc){if((c＝＝′C′)‖(c＝＝′D′)‖(c＝＝′Q′)‖(c＝＝′i′)‖(c＝＝′J′)‖(c＝＝′I′)‖(c＝＝′d′)‖(c＝＝′Z′))return(1)；elsereturn(0)；}/**functiondef_k_word()calculatesandreturnssymilirityfunction(SF)fortheeverywordintherow.SFisdefinedfrom0to1.IfwordintherecognizedsymbolisequaltothewordintherowthenSFisequalto1；ifwordsarenotequal，thenpartsofwordsarecompared.Therearethreepartsinthewords.Part1-downinputsegments，part2-downoutputsegments，part3segmentsbetweenpart1andpart2.**/floatdef_k_word(chara[]，charb[]，introw)/*****************************words’similaritycomparisonfunctiona-wordfromthegeneralizedsentenceb-wordfromthesymbolssentencetoberecognized*************************/{floatw＝0.0；inti，j，n，m，temp.i_end_1，i_end_2，j_end-1，j_end_2；intpr_a_1＝0，pr_a_2＝0，pr_b_1＝0，pr_b_2＝0；floatw1＝0.0，w2＝0.0，w3＝0.0，w4＝0.0；if(strcmp(a，b)＝＝0)return(1.0)；n＝strlen(a)；m＝strlen(b)；if((n＝＝0)&&(m！＝0))return(00)；if((n！＝0)&&(m＝＝0))return(0.0)；if((n＝＝0)&&(m＝＝0))return(1.0)；if(n＞＝m)temp＝n；elsetemp＝m；if(row＝＝0){for(i＝n-1，j＝m-1；(i＞0)‖(j＞0)；i-，j-)w＝w+def_k_lerter(a，b，i，i)；if(temp＞1)w＝w/(float)(temp-1)；elsew＝1.0；return(w)；}evelse{if(row＝＝2){for(i＝0；(i＜n-1)‖(i＜m-1)；i++)w＝w+def_k_letter(a，b，i，i)；if(temp＞1)w＝w/(float)(temp-1)；elsew＝1.0；return(w)；}else{i＝0；while(cmpr_out(a[i])＝＝1){i++；pr_a_1＝1；if(i＞n)break；}i_end_1＝i-1；i＝n-1；while(cmpr_in(a[i])＝＝1){i-；pr_a_2＝1；if(i＜0)break；}i_end_2＝i+1；i＝0；while(cmpr_out(b[i])＝＝1){i+；pr_b_1＝1；if(i＞m)break；}j_endd_1＝i-1；i＝m-1；while(cmpr_in(b[i])＝＝1){i-；pr_b_2＝1；if(i＜0)break；}j_end_2＝i+1；if((i_end_1＞＝i_end_2)‖(j_end_1＞＝j_end_2)){puts(＂it＂snotrightdividinginsidethewords\n＂)printf(＂a[]＝％sb[]＝％s\n＂，a，b)；printf(＂i_end_1＝％di_end_2＝％dj_end_1＝％dj_end_2＝％d\n＂，i_end-1，i_end_2，j_end-1，j_end_2)；printf(＂pr_a-1＝％dpr_a_2＝％dpr_b_1＝％dpr_b_2＝％d\n＂，pr_a_1，pr_a_2，pr_b_1，pr_b_2)；getch()；getch()；}if((pr_a_1＝＝1)&&(pr_b_1＝＝1))for(i＝0，j＝0；(i＜＝i_end_1)‖(j＜＝j_end_1)；i++，j++)w1＝w1+def_k_letter(a，b，i，j)；if((pr_a_2＝＝1)&&(pr_b_2＝＝1))for(i＝n-1，j＝m-1；(i＞＝i_end_2)‖(j＞＝j_end_2)；i-，j-)w2＝w2+def_k_letter(a，b，i，j)；if((j_end_21＝i_end_1+1)&&(j_end_21-j_end_1-1)){for(i＝i_end_1+1，j＝j_end-1+1；(i＜i_end_2)‖(j＜j_end_2)；i++，j++)w3＝w3+def_k_letter(a，b，i，j)；for(i＝i_end_2-1，j＝j_end_2-1；(i＞i_end_1)‖(j＞j_end_1)；i-，j-)w4＝w4+def_k_letter(a，b，i，j)；if(w3＜w4)w3＝w4；}if(temp＞0)w＝(w1+w2+w3)/(float)(temp)；else{printf(***def_k_word**-amountoflettersintherowequal0\n＂)；getch()；}}}return(W)；}/**functiondef_k_row()calculatesandreturnssymilirityfunctionforeveryrowinsymbolsgeneralizedrepresentationasmaximumvalueinrow.SFisdefinedfrom0to1.**/floatdef_k_row(intnum_dir，intcount，introw){floattemp；floatw＝0.0；intj；if(gen.repr.tabl[count].number＜1)if(buf[count]＝＝NULL)return(1.0)；elsereturn(0.0)；for(j＝0；j＜gen.repr.tabl[count].number；j++)if((temp＝def_k_word(gen.repr.tabl[count].row[j].str，buf[count]，row))＞0.9999999){w＝temp；break；}elseif(temp＞w)w＝temp；return(w)；}floatdef_k_sent(intnum_dir){floatw＝0.0；intcount；w＝w+def_k_row(num_dir，0，0)；if(num_dir＞0){for(count＝1；count＜num_dir+1；count++){w＝w+def_k_row(num_dir，count，1)；}}w＝w+def_k_row(num_dir，num_dir+1，2)；return(w/(float)(num_dir+2))；}/******************************************************************************similarityfunctiondefiningsimilaritybetweendefinedparamandsampleofparameterswithknownmedial，leftandrightdeviation，andrangeofdefinition(const_l，const_r)******************************************************************************/floatmut_metric(floatparam，floatmedial，floatconst_1，floatconst_r，floatdev_l，floatdev_r){floatleft，right，m，div；left＝mediai-dev_l；if(left＜const_l)left＝const_1；right＝medial+dev_r；if(right＞const_r)right＝const_r；if((param＞＝left)&&(param＜＝right))return(1.0)；else{div＝const_r-const_1-right+letf+0.0001；if(div＝＝0.0){if(medial＝＝0){printf(＂ERRORinmut_metric\n＂)；getch()；}div＝medial；}if(param＜left)m＝1.0-(left-param)/div；if(param＞right)m＝1.0-(param-right)/div；}if(m＜0.0)m＝0.0；return(m)；}/******************************************************************************functionsmetric_dir_y()andmetric_dir_x()calculatesimilaritymetricsonthebaseofdistancebetweenrecognizedletterskeletonandsymbol’sgeneralizedskeletoncalculatedduringateaching.******************************************************************************/floatmetric_dir_y(intnum_dir，intamp_y，structXx[]，structYy[]){intcount；floatm_1，m_2，metric；metric＝1.0；for(count＝0；count＜nun_dir；count++){m_1＝mut_metric(y[count].y_b，y_midll[count].y_b，0.0，1.0，y_dev[count].y_b，y_dev[count].y_b)；m_2＝mut_metric(y[count].y_e，y_midll[count].y_e，0.0，1.0，y_dev[count].y_e，y_dev[count].y_e)；metric＝metric*m_1*m_2；}return(metnc)；}floatmetric_dir_x(intnum_dir.intamp_y，structXx[]，structYy[]){intcount；floatm_1，m_2.metric；metric＝1.0for(count＝0；count＜numdir；count++){m_1＝mut_metric(x[count].x_b，x_midll[count].x_b，0.0，1.0，x_dev[count].x_b，x_dev[count].x_b)；m_2＝mut_metric(x[count].x_e，x_midll[count].x_e，0.0，1.0，x_dev[count].x_e，x_dev[count].x_e)；metric＝metric*m_1*m_2；}return(metric)；}/******************************************************************************Thefilesort.outissortingstepbystepusingappropriatesimilarityfunctions(definedwithparametersa，b，candtresholdsw_level，y_level，x_level)andtheirorder，theresultiswrittenthefileerr.******************************************************************************/intmain(void){charsort(intj，chara，charb，charc，floatw_level，floaty_level，floatx_level，charch，intnum_dir)；intcheck_map(charletter)；voidread_map(void)；voidr_matr(void)；inti，j；floatw_level，y_level，x_level；chara，b，c；charch，temp_ch，letter；intletter_num，num_dir；floatttt；inttt；a＝′w′；b＝′y′；c＝′′；w_level＝0.6；y_level＝0.6；x_level＝0.6；fout5＝fopen(＂err＂，＂w+＂)；fprintf(fout5，＂％c％c％cMw＝％.4fMy＝％.4fMx＝％.4f\n＂，a，b，c，wlevel，y_level，x_level)；fp＝fopen(＂sort.out＂，＂rb＂)；while(fscanf(fp，＂％c＂，&ch)！＝EOF){i＝0；fscanf(fp，＂％d％d＂，&letter_num，&num_dir)；fpnntf(fout5，＂％d％cnum_long＝％d＂，letter_num，ch，num_dir)；fscanf(fp，＂％c＂，&arr_srt[i].letter)；fscanf(fp，＂％f＂，&ttt)；arr_sry[i].w＝ttt；fscanf(fp，＂％f＂，&ttt)；arr_srt[i].y＝ttt；fscanf(fp，＂％f＂，&ttt)；arr_srt[i].x＝ttt；fscanf(fp＂％d\n＂，&tt)；arr_srt[i].pen_up＝tt；temp_ch＝ch；fscanf(fp，＂％c＂，&ch)；while(ch！＝＂*＂){i++；fscanf(fp，＂％d％d＂，&letter_num，&num_dir)；fscanf(fp，＂％c％f％f％f％d\n＂，&arr_srt[i].letter，&arr_srt[i].w，&arr_srt[i].y，&arr_srt[i].x，&arr_srt[i].pen_up)；fscanf(fp，＂％c＂，&ch)；}letter＝sort(i，a，b，c，w_level，y_level，x_level，temp_ch，num_dir)；}fclose(fp)；fclose(fout5)；return0；}intsort_a(intj，chara，floatw_level，floaty_level，floatx_level){intsort_w(intj，floatlevel)；intsort_y(intj，floatlevel)；intsort_x(intj，floatlevel)；if(a＝＝′w′)return(sort_w(j，w_level))；if(a＝＝′y′)return(sort_y(j，y_level))；if(a＝＝′x′)return(sort_x(j，x_level))；return(j)；}intsort_b(intj，charb，floatw_level，floaty_level，floatx_level){intsort_w(intj，floatlevel)；intsort_y(intj，floatlevel)；intsort_x(intj，floatlevel)；if(b＝＝′w′)return(sort_w(j,w_level))；if(b＝＝′y′)return(sort_y(j，y_level))；if(b＝＝′x′)return(sort_x(j，x_level))；return(j)；}intsort_c(intj，charc，floatw_level，floaty_level，floatx_level){intsort_w(intj，floatlevel)；intsort_y(intj，floatlevel)；intsort_x(intj，floatlevel)；if(c＝＝′w′)return(sort_w(j，w_level))；if(c＝＝′y′)return(sort_y(j，y_level))；if(c＝＝′x′)return(sort_x(j，x_level))；return(j)；}charsort(intj.chara，charb，charc，floatw_leval，floaty_level，floatx_level，charch，intnum_dir){inti，k，l；i＝sort_a(j，a，w_level，y_level.x_level)；if(i＝＝0){∥if(ch！＝arr_srt.letter)fprintf(fout5.＂％d\n％cMw＝％.4fMy＝％.4fMx＝％4fMup＝％d\n＂，1，arr_srt.letter，arr_srt.w，arr_srt.y，arr_srt.x，arr_srt.pen_up)；return(arr_srt.letter)；}k＝sort_b(i，b，w_level，y_level，x_level)；if(k＝＝0){∥if(ch！＝arr_srt.letter)fprintf(fout5，＂％d\n％cMw＝％.4fMy＝％.4fMx＝％.4fMup＝％d\n＂1，arr_srt.letter，arr_srt.w，arr_srt.y，arr_srt.x，arr_srt.pen_up)；return(arr_srt.letter)；}l＝sort_c(k，c，w_level，y_level，x_level)；if(l＜0){printf(＂l＜0\n＂)；getch()；}if(l＝＝0){∥if(ch！＝arr_srt.letter)fprintf(fout5，＂％d\n％cMw＝％.4fMy＝％.4fMx＝％.4fMup＝％d\n＂，1，arr_srt.letter，arr_srt.w，arr_srt.y，arr_srt.x，arr_srt.pen_up)；return(arr_srt.letter)；}else{∥fprintf(fout4，＂％dlong％c{”，num_dir，ch)；fprintf(fout5，＂％d\n＂，1+1)；for(i＝0；i＜＝l；i++){∥fprintf(fout4，＂％c＂，arr_srt[i].letter)；fprintf(fout5，＂％cMw＝％.4fMy＝％.4fMx＝％.4fMup＝％d\n＂，arr_srt[i].letter，arr_srt[i].w，arr_srt[i].y，arr_srt[i].x，arr_srt[i].pen_up)；}}return(arr_srt.letter)；}intsort_w(intj，floatlevel){inti；charch；floattemp-1，temp-2，temp_w，temp_y，temp_x，temp_penup；intpr＝1；if(j＝＝0)return(0)；while(pr＝＝1){pr＝0；for(i＝j；l＞0；l-){temp_1＝arr_srt[i].w；temp_2＝arr_srt[i-1].w；if(temp_1＞temp_2){ch＝arr_srt[i-1].letter；temp_w＝arr_srt[i-1].w；temp_y＝arr_srt[i-1].y；temp_x＝arr_srt[i-1].x；temp_pen_up＝arr_srt[i-1].pen_up；arr_srt[i-1].letter＝arr_srt[i].letter；arr_srt[i-1].w＝arr_srt[i].w；arr_srt[i-1].y＝arr_srt[i].y；arr_srt[i-1].x＝arr_srt[i].x；arr_srt[i-1].pen_up＝arr_srt[i].pen_up；arr_srt[i-1].m＝temp_1；arr_srt[i].letter＝ch；arr_srt[i].w＝temp_w；arr_srt[i].y＝temp_y；arr_srt[i].x＝tempx；arr_srt[i].pen_up＝temp_pen_up；arr_srt[i].m＝temp_2；pr＝1；}else{arr_srt[i-1].m＝temp_2；arr_srt[i].m＝temp_1；}}}level＝arr_srt.w-level；if(level＜＝0.0)level＝0.0；i＝0；while((i＜＝j)&&(arr_srt[i].w＞＝level))i++；if(i＝＝0)return(0)；elsereturn(i-1)；}intsort_y(intj，floatlevel){inti；charch；floattenmp_1，temp_2，temp_w，temp_y，temp_x，temp_pen_up；intpr＝1；if(j＝＝0)return(0)；while(pr＝＝1){pr＝0；for(i＝j；i＞0；i-){temp_1＝arr_srt[i].y；temp_2＝arr_srt[i-1].y；if(tem_1＞temp_2){ch＝arr_srt[i-1].letter；temp_w＝arr_srt[i-1].w；temp_y＝arr_srt[i-1].y；temp_x＝arr_srt[i-1].x；temp_pen_up＝arr_srt[i-1].pen_up；arr_srt[i-1].letter＝arr_srt[i].letter；arr_srt[i-1].w＝arr_srt[i].w；arr_srt[i-1].y＝arr_srt[i].y；arr_srt[i-1].x＝arr_srt[i].x；arr_srt[i-1].pen_up＝arr_sry[i].pen_up；arr_srt[i-1].m＝temp-1；arr_srt[i].letter＝ch；arr_srt[i].w＝temp_w；arr_srt[i].y＝temp_y；arr_srt[i].x＝temp_x；arr_srt[i].pen_up＝temp_pen_up；arr_srt[i].m＝temp_2；pr＝1；}else[arr_srt[i-1].m＝temp_2；arr_srt[i].m＝temp_1；}}}level＝arr_srt.y-level；if(level＜＝0.0)level＝0.0；i＝0；while((i＜＝1)&&(arr_srt[i].y＞＝level))i++；if(i＝＝0)return(0)；elsereturn(i-1)；}intsort_x(intj，floatlevel){inti；charch；floattemp_1，temp_2，temp_w，temp_y，temp_x，temp_pen_up；intpr＝1；if(j＝＝0)return(0)；while(pr＝＝1){pr＝0；for(i＝j；i＞0；i-){temp_1＝arr_srt[i].x；temp_2＝arr_srt[i-1].x；if(temp_1＞temp_2){ch＝arr_srt[i-1].etter；temp_w＝arr_srt[i-1].w；temp_y＝arr_srt[i-1].y；temp_x＝arr_srt[i-1].x；temp_pen_up＝arr_srt[i-1].pen_up；arr_srt[i-1].letter＝arr_srt[i].letter；arr_srt[i-1].w＝arr_srt[i].w；arr_srt[i-1].y＝arr_srt[i].y；arr_srt[i-1].x＝arr_srt[i].x；arr_srt[i-1].pen_up＝arr_srt[i].pen_up；arr_srt[i-1].m＝temp_1；arr_srt[i].letter＝ch；arr_srt[i].w＝temp_w；arr_srt[i].y＝temp_y；arr_srt[i].x＝temp_x；arr_srt[i].per_up＝temp_pen_up；arr_srt[i].m＝temp-2；pr＝1；}else{arr_srt[i-1].m＝temp_2；arr_srt[i].m＝temp_1；}}}level＝arr_srt.x-evel；if(level＜＝0.0)level＝0.0；i＝0；while((i＜＝j)&&(arr_sry[i].x＞＝level))i++；if(i＝＝0)return(0)；elsereturn(i-1)；}intcheck_map(charletter){inti；for(i＝0；i＜NUM_SYMBOLS；i++)if(letter＝＝(char)map_char[i])return(i)；if(i＝＝NUM_SYMBOLS){printf(＂Thereisnosuchcharacterinthemap％c\n＂，letter)；return(-1)；}return(-1)；}voidread_map(void){FILE*fp；inti；fp＝fopen(＂map_ch＂，＂rb＂)；for(i＝0；i＜NUM_SYMBOLS；i++)fscanf(fp，＂％d％d\n＂，&map_char[i]，&map_char[i][1])；fclose(fp)；}voidr_matr(void){FILE*fout1；inti，j；fout1＝fopen(＂matrix.out＂，＂w＂)；for(i＝0；i＜69；i++)fprintf(fout1，＂％c＂，map_char[i])；fprintf(fout1，＂\n＂)；for(i＝0；i＜69；i++){for(j＝0；j＜69；j++)fprintf(fout1，＂％2d＂，matr[i][j])；fprintf(fout1，＂\n＂)；}fclose(fout1)；}/******************************************************************************Thefile＂err＂issortingusingappropriatesimilantyfunctiondefinedwithtresholdlevelandit’sorder.******************************************************************************/intmain(void){intcheck_map(charletter)；voidread_map(void)；voidadd_metric(charch，intletter_num，intloop)；intsort_add(intj，floatlevel)；voidread_map(void)；voidr_matr(void)；charmtr_cl(inti，charch)；intspell_ch(char[10][20]，char[100][20])；intletter_num，num_dir，loop；charch；inti，k，j，num_inside，pr；floatlevel；charreply[100][20]；intrepl；read_map()；max_min()；level＝0.4；fp＝fopen(＂err＂，＂r＂)；fp1＝fopen(＂add_err＂，＂w+＂)；num_inside＝0；pr＝0；fseek(fp，37，0)；while(fscanf(fp，＂％d＂，&letter_num)！＝EOF){fscanf(fp，＂％c＂，&ch)；fseek(fp，10，1)；fscanf(fp，＂％d％d\n＂，&num_dir，&loop)；for(i＝0；i＜loop；i++){fscanf(fp，＂％c＂，&arr_srt[i].letter)；fseek(fp，6，1)；fscanf(fp，＂％f＂，&arr_srt[i].w)；fseek(fp，6，1)；fscanf(fp，＂％f＂，&arr_srt[i].y)；fseek(fp,6,1)；fscanf(fp，＂％f＂，&arr_srt[i]x)；fseek(fp，6，1)；fscanf(fp，＂％d\n＂，&arr_srt[i].pen_up)；pr＝1；}add_metric(ch，letter_num，loop)；k＝sort_add(loop，level)；if(k＞＝10)k＝8；fprintf(fp1，＂％c％dlong＝％d％d\n＂，ch，letter_num，num_dir，/*loop＂/k+1)；if(k＝＝0){∥if(ch！＝arr_srt.letter)fprinft(fp1，＂％c＂w＝％，4fy＝％，4fx＝％.4fx_vec＝％.4fy_vec＝％.4famp＝％4fup＝％dm＝％.4f\n＂，arr_srt.letter，arr_srt.w，arr_srt.y，arr_srt.x，arr_srt.x_vec，arr_srt.y_vec，arr_srt.amp，arr_srt.pen_up，arr_srt.m)；}else{∥fprintf(fout4，＂％dlong％c{＂，num_dir.ch)；for(i＝0；i＜＝k；i++){∥fprintf(fout4，＂％c＂.arr_srt[i].letter)；fprintf(fp1，＂％cw＝％.4fy＝％.4fx＝％.4fx_vec＝％.4fy_vec＝％.4famp＝％.4fup＝％dm＝％.4f\n＂.arr_srt[i].letter，arr_srt[i].w，arr_sft[i].y，arr_srt[i].x，arr_srt[i].x_vec，arr_srt[i].y_vec，arr_srt[i].amp，arr_srt[i].pen_up，arr_srt[i].m)；}}if((i＝check_map(ch))＜0){printf(＂ERROR1＂)；continue；}if((j＝check_map(arr_srt.letter))＜0){printf(＂ERROR2＂)；continue；}matr[i][j]++；num_inside++；}fclose(fp)；if(pr＝＝0){fsh＝fopen(＂sh_sp.out＂，＂w＂)；fprintf(fsh，＂-0＂)；fclose(fsh)；return0；}fclose(fp1)；r_matt()；return0；}intcheck_map(chaletter){inti；for(i＝0；i＜NUMSYMBOLS；i++)if(letter＝＝(char)map_char[i])return(i)；if(i＝＝NUM_SYMBOLS){printf(＂Thereisnosuchcharacterinthemap％c\n＂，letter)；return(-1)；}return(-1)；}voidread_map(void){FILE*fp；inti；fp＝fopen(＂map_ch＂，＂rb＂)；for(i＝0；i＜NUM_SYMBOLS；i++)fscanf(fp，＂％d％d\n＂，&map_char[i]，&map_char[i][1])；fclose(fp)；}voidr_matr(void){FILE*fout1inti，j；fout1＝fopen(＂matrix.out＂，＂w＂)；for(i＝0；i＜69i++)fprintf(fout1.＂％c＂，map_char[i])；fprintf(fout1.＂\n＂)；for(i＝0；i＜69i++){for(j＝0；j＜69j++)fprintf(fout1，*％2d＂，mat[i][j])；fprintf(fout1.＂\n＂)；}fclose(fout1)；}/*********************************************************************functionadd_metric()fortheeveryletter(accordingtoit’snumberandname)searchesit’sparametersinthefilesfeat.outandfeat1.outandcalculatesconespondingmetrics.**********************************************************************/voidadd_metric(charch，intletter_num，intloop){voidadd_metr_feat(intloop)；voidadd_metr_feat1(intloop)；FILE*fp；chartemp_letter；inttemp_letter_num；fp＝fopen(＂feat.out＂，＂rb＂)；while(fscanf(fp，＂％c＂，&temp_letter)！＝EOF){fscanf(fp，＂％d％f％f％f％r\n＂，&temp_letter_num，&y_vec_beg，&y_vec_end，&x_vec_beg，&x_vec_end)；if((temp_letter＝＝ch)&&(temp_letter_num＝＝letter_num)){fclose(fp)；add_metr_feat(loop)；break；}}fp＝fopen(＂feat1.out＂，＂rb*)；while(fscanf(fp，＂％c＂，&temp_letter)！＝EOF){fscanf(fp，＂％d％dl\n＂，&temp_letter_num，&amp_y)；if((temp_letter＝＝ch)&&(temp_letter_num＝＝letter_num)){fclose(fp)；add_metr_feat1(loop)；break}}}/*********************************************************************functionsadd_metr_feat()calculatessimilarityfunctionononthebaseofdistancebetweenrecognizedsymbol’svector(connectingstartpointwiththeendpointofthesymbol)andgeneralizedsymbol’svectordefinedduringtheteaching.*********************************************************************/voidadd_metr_feat(intloop){inti，j；FlLE*fp；floatm_1，m-2.m-3.m_4；chartemp_letter；for(i＝0；i＜loop；i++){fp＝fopen(＂genfeat.out＂，＂rb＂)；while(fscanf(fp，＂％c＂，&temp_letter)!＝EOF){fscanf(fp，＂％f％f％f％f\n＂，&x_midll.x_b，&x_midll.x_e，&y_midll.y_b，&y_midll.y_e)；for(j＝0；j＜3j++){fscanf(fp.＂％f％f％f％f\n＂，&x_dev[j].x_b，&x_dev[j].x_e，&y_dev[j].y_b，&y_dev[j].y_e)；}if(arr_srt[i].letter＝＝temp_letter){fclose(fp)；m_1＝mut_metric(x_vec_beg，x_midll.x_b，0.0，1.0，x_dev[2].x_b，x_dev[2].x_b)；m_2＝mut_metric(x_vec_end，x_midll.x_e，0.0，1.0，x_dev[2].x_e，x_dev[2].x_e)；arr_srt[i].x_vec＝m_1*m_2；m_3＝mut_metric(y_vec_beg，y_midll.y_b，0.0，1.0，y_dev[2].y_b，y_dev[2].y_b)；m_4＝mut_metric(y_vec_end，y_midll.y_e，0.0，1.0，y_dev[2].y_e，y_dev[2].y_e)；arr_srt[i].y_vec＝m_3*m_4；break；}}}}/*********************************************************************functionsadd_metr_feat1Ocalculatessimilarityfunctiononthebaseofdistancebetweenrecognizedsymbol’samplitudeandsymbol’sgeneralizedampliudecalculatedduringtheteaching.*********************************************************************/voidadd_metr_feat1(intloop){inti，j；FILE*fp；floatm_1；chartemp_letter；inty_max，y_min；for(i＝0；i＜loop；i++){fp＝fopen(＂genfet1.out＂，＂rb＂)；while(fscanf(fp，＂％c＂，&temp_letter)！＝EOF){fscanf(fp，＂％f％d％d\n＂，&y_midll.y_b，&y_max，&y_min)；for(j＝0；j＜3；j++)fscanf(fp，＂％f＂，&y_dev[j].y_b)；fscanf(fp，＂\n＂)；if(arr_srt[i].letter＝＝temp_letter){fclose(fp)；∥y_min＝2*y_min；∥lt’sbettertofindminandmaxforallthesymbols∥y_max＝2*y_max；m-1＝mut_metric((float)amp_y，y_midll.y_b，(float)mut_min，(float)mut_max，y_dev[2].y_b，y_dev[2].y_b)；arr_srt[i].amp＝m_1break}}}}voidmax_min(void){FILE*fp；chartemp_letter；inty_max；inty_min；intj；mut_max＝0；mut_mm＝9999；fp＝fopen(＂genfet1．out＂，＂rb＂)；while(fscanf(fp，＂％c＂，&temp_letter)！＝EOF){fscanf(fp，＂％f％d％d\n＂，&y_midll．y_b，&y_max，&y_min)；for(j＝0；j＜3；j++)fscanf(fp，＂％f＂，&y_dev[j]．y_b)；fscanf(fp，＂\n＂)；if(mut_max＜y_max)mut_max＝y_max；if(mut_min＞y_min)mut_min＝y_min；}fclose(fp)；}/*********************************************************************similarityfunctiondefinessimilaritybetweenparameterandsampleofparameterswithknownmedial．leftandrightdeviation，andrangeofdefinition(const_l，const_r)*********************************************************************/floatmut_metric(floatparam，floatmedial，floatconst*l，float_l，const_r，floatdev_l，floatdev_r{floatleft，right，m，div；left＝medial-dev_l；if(left＜const_l)left＝const_l；right＝medial+dev_r；if(right＞const_r)right＝const_r；if((param＞＝left)&&(param＜＝right))return(1.0)；else{div＝const_r-const_l-right+left+0.0001；if(div＝＝0.0)div＝medial；if(param＜left)m＝1.0-(left-param)/div；if(param＞right)m＝1.0-(param-dght)/div；}if(m＜0.0)m＝00；return(m)；}/*********************************************************************averagesimilarityfunctiondefinition，finalsortingusingtreshold*********************************************************************/externstructSRT1arr_srt[600]；intsort_add(intj.fioatlevel){inti；charch；floattemp_1，temp_2，temp_w，temp_y，temp_x，temp_x_vec，temp_y_vec，temp_amp；inttemp_up；intpr＝1；for(i＝0，i＜j；i++)arr_srt[i].m＝(arr_srt[i].w+arr_srt[i].y+arr_srt[i].x_vec+arr_srt[i].y_vec+arr_srt[i].amp+(float)arr_srt[i].pen_up)/6.0；if(j-1＝＝0)return(0)；while(pr＝＝1){pr＝0；for(i＝j-1；i＞0；i-){temp_1＝arr_srt[i].m；temp_2＝arr_srt[i-1].m；if(temp_1＞temp_2){ch＝arr_srt[i-1].letter；temp_w＝arr_srt[i-1].w；temp_y＝arr_srt[i-1].y；temp_x＝arr_srt[i-1].x；temp_up＝arr_srt[i-1].pen_up；temp_x_vec＝arr_srt[i-1].x_vec；temp_y_vec＝arr_srt[i-1].y_vec；temp_amp＝arr_srt[i-1].amp；arr_srt[i-1].letter＝arr_srt[i].letter；arr_srt[i-1].w＝arr_srt[i].w；arr_srt[i-1].y＝arr_srt[i].y；arr_srt[i-1].x＝arr_srt[i].x；arr_srt[i-1].pen_up＝arr_srt[i].pen_up；arr_srt[i-1].x_vec＝arr_srt[i].x_vec；arr_srt[i-1].y_vec＝arr_srt[i].y_vec；arr_srt[i-1].amp＝arr_srt[i].amp；arr_srt[i-1].m＝temp_1；arr_srt[i].letter＝ch；arr_srt[i].w＝temp_w；arr_srt[i].y＝temp_y；arr_srt[i].x＝temp_x；arr_srt[i].pen_up＝temp_up；arr_srt[i].x_vec＝temp_x_vec；arr_srt[i].y_vec＝temp_y_vec；arr_srt[i].amp＝temp_amp；arr_srt[i].m＝temp_2；pr＝1；}else{arr_srt[i-1].m＝temp_2；arr_srt[i].m＝temp_1；}}}level＝arr_srt.m-level；if(level＜＝0.0)level＝0.0；i＝0；while((i＜j)&&(arr_srt[i].m＞＝level))i++；if(i＝＝0)return(0)；elsereturn(i-1)；}charmtr_cl(inti，charch){intj；for(j＝0；j＜＝i；j++)if(ch＝＝arr_srt[j].letter)return(arr_srt[j].letter)；return(arr_srt.letter)；}]]></pre>加速度识别i.训练过程<prelisting-type="program-listing"><![CDATA[/************************************Todefinetheworkscondition.************************************/voidmain(void){FILE*fp；charfilename[30]；intindex；charnum[4]；charch；intk；printf(＂DoyouwanttodoPRESS(y/n)＂)；ch＝getche()；fp＝fopen(＂fpr，＂w＂)；if(toupper((int)ch)＝＝＂Y′)fprintf(fp，＂％d＂，1)；elsefprintf(fp，＂％d＂，0)；fclose(fp)；printf(＂\nDoyouwanttodoSMOOTH(y/n)＂)；ch＝getche()；fp＝fopen(＂fsm＂，＂w＂)；if(toupper((int)ch)＝＝′Y)fprintf(fp，＂％d＂，1)；elsefprintf(fp，＂％d＂，0)；fclose(fp)；printf(＂\nEnteramoutoflevel＂)；scanf(＂％d＂，&k)；fp＝fopen(＂flv＂，＂w＂)；fprintf(fp，＂％d＂，k)；fclose(fp)；}/*教导用主程序*/voidmain(void){FILE*fp；FILE*fp1；charinfile[30]；charfilename1[30]；intnumber；intindex；intnum；intnum_mut；charnum_ch[4]；intsp_amount；intzon_x[10]；intzon_y[10]；floatarr_x[NUMBER_OF_STROKES]；floatarr_y[NUMBER_OF_STROKES]；floatarr_z[NUMBER_OF_STROKES]；floatarr_p[NUMBER_OF_STROKES]；intx，y，z，p，pen_old，i；intarr_beg_end[2]；fp1＝fopen(＂abc＂，＂r＂)；while(fscanf(fp1，＂％d＂，&number)！＝EOF){fscanf(fp1，＂％s\n＂，infile)；if((fp＝fopen(infile，＂r＂))＝＝NULL)continue；printf(＂-％s-\n＂，infile)；sp_amount＝0；num＝0；num_mut＝0；pen_old＝1；while(fscanf(fp，＂％d＂，&x)！＝EOF){fscanf(fp，％d％d％d\n＂，&y，&z，&p)；if(pen_old＝＝p){arr_x[num]＝(float)x；arr_y[num]＝(float)y；arr_z[num]＝(float)z；nun++；∥amountinthespaceif(num＞NUMBER_OF_STROKES){printf(＂Amountofpenstrokesinthespaceisbiggerthen％d\n＂，NUMBER_OF_STROKES)；getch()；exit(0)；}num_mut++；∥amountinthefile}else{prep(num，num_mut，sp_amount，arr_x，arr_y，arr_z)；sp_amount++；∥amountofspacepen_old＝p；arr_x＝(float)x；arr_y＝(float)y；arr_z＝(float)z；num＝1；num_mut++；}fscanf(fp，＂％d％d％d％d＂，&x，&y，&z，&p)；fscanf(fp，＂％d％d％d％d＂，&x，&y，&z，&p)；fscanf(fp，＂％d％d％d％d＂，&x，&y，&z，&p)；}fclose(fp)；prep(num，num_mut，sp_amount，arr_x，arr_y，arr_z)；strcpy(filename1，＂t＂)；sprintf(num_ch，＂％d＂，sp_amount)；strcat(filename1.num_ch)；strcat(filename1，＂out＂)；fp＝fopen(filename1，＂a+＂)；fprintf(fp，＂％d％d％d\n＂，number，sp_amount，num_mut)；for(i＝0；i＜＝sp_amount；i++){nul_zone(i，arr_beg_end)；save(i，num_mut，arr_beg_end，fp)；}fclose(fp)；}fclose(fp1)；}/************************************Getwork’sconditions.************************************/voidprep(intnum，intnum_mut，intsp_amount，floatarr_x[]，floatarr_y[]，floatarr_z[]){FILE*fp；intpr，sm，amount_lev；if((fp＝fopen(＂fpr＂，＂r＂))＝＝NULL){printf(＂Impossibletoopenthefile′fpr＂\n＂)；getch()；exit(0)；}fscanf(fp，＂％d＂，&pr)；fclose(fp)；if(pr){press(num，arr_x)；press(num，arr_y)；press(num，arr_z)；num＝PRESS_NUMBER_POINT；}if((fp＝fopen(＂fsm＂，＂r＂))＝＝NULL){printf(＂Impossibletoopenthefile′fsm＂\n＂)；getch()；exit(0)；}fscanf(fp，＂％d＂，&sm)；fclose(fp)；if(sm){smooth(num，arr_x)；smooth(num，arr_y)；smooth(num，arr_z)；}level(num，num_mut，sp_amount，arr_x，arr_y，arr_z)；}/************************************Saveonespaceinformationtooutputfile.************************************/voidsave(intspace，intnum_mut.intarr_beg_end[]，FILE*fp){inti，j；fprintf(fp，＂％d\n＂，space)；fprintf(fp，＂％d％f％f\n＂，g[space].num，g[space].beg/(float)num_mut，g[space]end/(float)num_mut)；for(j＝0；j＜g[space].num；j++)fprintf(fp，＂％d％d％d\n＂，g[space].f[j].x，g[space].f[j].y，g[space].f[j].z)；fprintf(fp＂％f％f\n＂，(float)arr_beg_end/(float)g[space].num，(float)arr_beg_end[1]/(float)g[space].num)；}/************************************Calculatecoordinatesaccordinglytoamountoflevels.************************************/voidlevel(intnum，intnum_mut.intspace，floatarr_x[]，floatarr_y[]，floatarr_z[]){inti，j；FILE*fp；floatmin_x＝9999.0；floatmax_x＝0.0；floatmin_y＝9999.0；floatmax_y＝0.0；floatmin_z＝9999.0；floatmax_z＝0.0；intsum；intpr；inttemp；floatkx，ky，kz；intlev；/************************************k-amountoflevel************************************/if((fp＝fopen(＂flv＂，＂r＂))＝＝NULL){printf(＂lmpossibletoopenthefile′flv′\n＂)；getch()；exit(0)；}fscanf(fp，＂％d＂，&lev)；fclose(fp)；for(i＝0；i＜num；i++){if(arr_x[i]＜min_x)min_x＝arr_x[i]；if(arr_x[i]＞max_x)max_x＝arr_x[i]；if(arr_y[i]＜min_y)min_y＝arr_y[i]；if(arr_y[i]＞max_y)max_y＝arr_y[i]；if(arr_z[i]＜min_z)min_z＝arr_z[i]；if(arr_z[i]＞max_z)max_z＝arr_z[i]；}kox＝(max_x-min_x)/(float)lev；ky＝(max_y-min_y)/(float)lev；kz＝(max_z-min_z)/(float)lev；if((kx＜＝1.00)‖(ky＜＝1.00)‖(kz＜＝1.00)){printf(＂-Decreasethenumberoflevels！！！-\n＂)；getch()；}for(i＝0；i＜num；i++){g[space].f[i].x＝(int)(((float)(arr_x[i]-min_x)-0001)/kx)；g[space].f[i].y＝(int)(((float)(arr_y[i]-min_y)-0.001)/ky)；g[space].f[i].z＝(int)(((float)(arr_z[i]-min_z)-0.001)/kz)；}g[space]num＝num；g[space].beg＝(float)(num_mut-num+1)；g[space].end＝(float)(num_mut)；}/************************************Calculatethecoordinatesofnullzone************************************/voidnul_zone(intspace，intarr_beg_end[]){intbeg，end.dif；intbeg_max.end_maxintpr＝0；intj；dif＝0；beg＝0；end＝0；for(j＝0；j＜g[space].num；j++){if(g[space].f[j].z＝＝0){if(pr＝＝0){beg＝j；end＝j；pr＝1；if(j＝＝(g[space].num-1)){if(dif＜1){beg_max＝beg；end_max＝end；}}}else{if(j＝＝(g[space].num-1)){end＝j；if(dif＜(end-beg+1)){beg_max＝beg；end_max＝end；}}}}else{if(pr＝＝1){end＝j；pr＝0；if(dif＜(end-beg)){dif＝end-beg；beg_max＝beg；end_max＝end-1；}}}}arr_beg_end＝beg_max+1；arr_beg_end[1]＝ena_max+1；}/************************************Dosmoothing************************************/floatsmooth1(intnum，floatz[]){intind；floattemp；floatnorma；for(ind＝1，norma＝0；ind＜num-1；ind++){temp＝(z[ind-1]+z[ind]+z[ind+1])/3；norma+＝abbs(z[ind]-temp)；z[ind]＝temp；}returnnorma}voidsmooth(intmax_point，floatarr[]){floatendsmooth；wnile((end_smooth＝smooth1(max_point，arr))＞PRESS_NUMBER_POINT/10)；}/************************************Changefilecoordinatesaccordinglynewlength.************************************/voidnormal(intnum_old，floatarr_old[]，intnum_new，floatarr_new[]){doublekoeff；intind_old，ind_new；koeff＝(double)(num_old-1)/(float)(num_new-1)；arr_new＝arr_old；for(ind_new＝1；ind_new＜num_new-1；ind_new++){ind_old＝(int)(floor(koeff*ind_new))；arr_new[ind_new]＝(ind_old+1-koeff*ind_new)*arr_old[ind_old]+(koeff*ind_new-ind_old)*arr_old[ind_old+1]；}arr_new[ind_new]＝arr_old[num_old-1]；}voidpress(intnum，floatarr[]){floatnew_arr[100]；inti；normnal(num，arr，PRESS_NUMBER_POINT，new_arr)；for(i＝0；i＜PRESS_NUMBER_P0lNT；i++)arr[i]＝new_arr[i]；}]]></pre>II一般化过程<prelisting-type="program-listing"><![CDATA[/*一般化过程主程序*/voidmain(void){voidgener(inti，charfilename[]，charfilename1[])；FILE*fp，*fp1；inti；charnum[4]；charfilename[30]，filename1[30]；for(i＝0；i＜NUMBER_SPACE；i++){strcpy(filename，＂t＂)；sprintf(num，＂％d＂，i)；strcat(filename，num)；strcat(filename，＂.out＂)，if((fp＝fopen(filename，＂r＂))＝＝NULL)continue；fclose(fp)；strcpy(filename1，＂g＂)；strcat(filename1，hum)；strcat(filename1，＂.out＂)；fp1＝fopen(filename1.＂w＂)；fclose(fp1)；gener(i，filename；filename1)；}}voiddef_par(floatarr[MAX_REPRESNT+1[NUMBER_SPACE+1).intamountintspace，charfilename1[])；voidopen_file(charfilename1[]，intamount，intletter){FILE*fp；fp＝fopen(fiename1，＂a+＂)；fprintf(fp，＂％d％d\n＂，letter，amount)；fclose(fp)；}/************************************Generalizeinformationforalltheletter.************************************/voidgener(inti，charfilename[]，charfilename1[]){intgetherrintletter，intnum_space，charfilename[]，charfilename1[])；intj；intamount；for(j＝0；j＜SYMBOLS_NUMBER；j+f){amount＝gether(j，i，filename，filename1)；}}/************************************Generalizeinformationforoneletter.************************************/intgether(intletter，intnum_space，charfilename[]，charfilename1[]){intamount；FILE*fp；FILE*fp1；intin，space，num_mut，sp_num，x，y，z，i，j，length，l；floatspace_length[MAX_REPRESNT+1][NUMBER_SPACE+1]；floatbeg[MAX_REPRESNT+1][NUMBER_SPACE+1]；floatend[MAX_REPRESNT+1][NUMBER_SPACE+1]；floatnul_beg[MAX_REPRESNT+1][NUMBER_SPACE+1]；floatnul_end[MAX_REPRESNT+1][NUMBER_SPACE+1]；inttemp；floatmut_len[MAX_REPRESNT+1][NUMBER_SPACE+1]；amount＝0；fp＝fopen(filename，＂r＂)；fp1＝fopen(＂temp＂，＂w＂)；fclose(fp1)；fp1＝fopen(＂temP＂，＂a+＂)；while(fscanf(fp，＂％d＂，&in)！＝EOF){fscanf(fp，＂％d％d\n＂，&space，&num_mut)；mut_len[amount]＝(float)num_mut；for(i＝0；i＜＝space；i++){fscanf(fp，＂％d＂，&sp_num)；fscanf(fp，＂％d％f％f\n＂，&temp，&beg[amount][i]，&end[amount][i])；space_length[amount][i]＝(float)temp；if(letter＝＝in){∥fp1＝fopen(＂temp＂，＂a+＂)；fprintf(fp1，＂％d\n＂，temp)；if(amount＝＝MAX_REPRESNT){fclose(fp)；fclose(fp1)；printf(＂Representationistoohuge\n＂)getch()return(777)；}for(j＝0；j＜temp；j++){fscanf(fp，＂％d％d％d\n＂，&x，&y，&z)；fprintf(fp1，＂％d％d％d\n＂，x，y，z)；}}else{for(j＝0；j＜temp；j++)fscanf(fp，＂％d％d％d\n＂，&x，&y，&z)；}fscanf(fp，＂％f％f\n＂，&nul_beg[amount][i]，&nul_end[amount][i])；}if(letter＝＝in)amount++；}fclose(fp)；fclose(fp1)；if(amount＞0){open_file(filename1，amount，letter)；def_par(mut_len，amount，0，filename1)；def_par(space_length，amount，space，filename1)；def_par(beg，amount，space，filename1)；def_par(end，amount，space，filename1)；def_par(nul_beg，amount，space，filename1)；def_par(nul_end，amount，space，filename1)；fp＝fopen(＂temp＂，＂r＂)；fp1＝fopen(filename1，＂a+＂)；fbr(i＝0；i＜＝space；i++){for(j＝0；j＜amount；j++){fscanf(fp，＂％d\n＂，&length)；fprintf(fp1，＂％d\n＂，length)；for(l＝0；l＜length；l++){fscanf(fp，＂％d％d％d\n＂，&x，&y，&z)；fprintf(fp1，＂％d％d％d\n＂，x，y，z)；}}}fclose(fp)；fclose(fp1)；}return(amount)；}/***************************************************************************Calculatesmedialxandycoordinatesandtheirdispersions***************************************************************************/voiddef_par(floatarr[MAX_REPRESNT+1][NUMBER_SPACE+1]，intamount，intspace，charfilename1[]){intcount，i；floatdev[NUMBER_SPACE+1]；floatmidll[NUMBER_SPACE+1]；floatsumm；floattemp；floatmax[NUMBER_SPACE+1]；floatmin[NUMBER_SPACE+1]FILE*fp；for(i＝0；i＜＝space；n++){max[i]＝0.0；min[i]＝9999.9；}if(amount＞0}{for(count＝0；count＜＝space；count++){summ＝0.0；for(i＝0；i＜amount；i++){summ＝summ+arr[i][count]；if(max[count]＜arr[i][count])max[count]＝arr[i][count]；if(min[count]＞arr[i][count])min[count]＝arr[i][count]；}midll[count]＝summ/(float)amount；summ＝0.0；for(i＝0；i＜amount；i++){temp＝midll[count]-arr[i][count]；summ＝summ+temp*temp；}dev[count]＝sqrt(summ/(float)amount)；}}fp＝fopen(filename1，＂a+＂)；for(count＝0；count＜＝space；count++)fprintf(fp，＂％f％f％f％f\n＂，midll[count]，dev[count]，max[count]，min[count])；fprintf(fp，＂\n＂)；fclose(fp)；return；}/**************************************************************************functioncalc_veccalculatesmedialxandycoordinatesandtheirdispersionsofthevectorjoiningthefirstpointofthesymbols’trajectoryandthelast***************************************************************************voidcalc_vec(intamount){intcount，i；floatsumm_1＝0.0；floatsumm_2＝0.0；floatsumm_3＝0.0；floatsumm_4＝0.0；floatsumm_1m＝0.0；floatsumm_2m＝0.0；floatsumm_3m＝0.0；floatsumm_4m＝0.0；floattemp；intam1，am2，am3，am4，am5，am6，am7，am8；if(amount＞0)for(i＝0；i＜amount；i++){summ_1＝summ_1+bx[i].x_b；summ_2＝summ_2+by[i].y_b；summ_3＝summ_3+bx[i].x_e；summ_4＝summ_4+by[i].y_e；}x_midll.x_b＝summ_1/(float)amount；y_midll.y_b＝summ_2/(float)amount；x_midll.x_e＝summ_3/(float)amount；y_midll.y_e＝summ_4/(float)amount；summ_1＝0.0；summ_2＝0.0；summ_3＝0.0；summ_4＝0.0；summ_1m＝0.0；summ_2m＝0.0summ_3m＝0.0；summ_4m＝0.0；am1＝0；am2＝0；am3＝0；am4＝0；am5＝0；am6＝0；am7＝0；am8＝0；for(i＝0；i＜amount；i++){temp＝x_midll.x_b-bx[i].x_b；if(temp＞0.0){summ_1＝summ_1+temp*temp；am1++；}else{summ_1m＝summ_1m+temp*temp；am2++；}temp＝y_midll.y_b-by[i].y_b；if(temp＞0.0){summ_2＝summ_2+temp*temp；am3++；}else{summ_2m＝summ_2m+temp*temp；am4++；}temp＝x_midll.x_e-bx[i].x_e；if(temp＞0.0){summ_3＝summ_3+temp*temp；am5++；}else{summ_3m＝summ_3m+temp*temp；am6++；}temp＝y_midll.y_e-by[i].y_e；if(temp＞0.0){summ_4＝summ_4+temp*temp；am7++；}else{summ_4m＝summ_4m+temp*temp；am8++；}}if(am1＝＝o)x_dev.x_b＝0.0；∥dev-elsex_dev.x_b＝sqrt(summ_1/(float)am1)；if(am2＝＝0)x_dev[1].x_b＝0.0；∥dev+elsex_dev[1].x_b＝sqrt(summ_1m/(float)am2)；if((am1+am2)＝＝0)x_dev[2].x_b＝0.0；∥develsex_dev[2].x_b＝sqrt((summ_1+summ_1m)/(float)(am1+am2))；if(am3＝＝0)y_dev.y_b＝0.0；∥dev-elsey_dev.y_b＝sqrt(summ_2/(float)am3)；if(am4＝＝0)y_dev[1].y_b＝0.0；∥dev+elsey_dev[1].y_b＝sqrt(summ_2m/(float)am4)；if((am3+afm4)＝＝o)y_dev[z].y_b＝0.0；∥qevelsey_dev[2].y_b＝sqrt((summ_2+summ_2m)/(float)(am3+am4))；if(am5＝＝0)x_dev.x_e＝0.0；∥dev-elsex_dev.x_e＝sqrt(summ_3/(float)am5)；if(am6＝＝0)x_dev[1].x_e＝0.0；∥dev+elsex_dev[1].x_e＝sqrt(summ_3m/(float)am6)；if((am5+am6)＝＝0)x_dev[2].x_e＝0.0；∥develsex_dev[2].x_e＝sqrt((summ_3+summ_3m)/(float)(am5+am6))；if(am7＝＝0)y_dev.y_e＝0.0；∥dev-elsey_dev.y_e＝sqrt(summ_4/(float)am7)；if(am8＝＝0)y__dev[1].y_e＝0.0；∥dev+elsey_dev[1].y_e＝sqrt(summ_4m/(float)am8)；if((am7+am8)＝＝0)y_dev[2].y_e＝0.0；∥develsey_dev[2].y_e＝sqrt((summ_4+summ_4rm)/(float)(am7+am8))；}]]></pre>III.识别过程<prelisting-type="program-listing"><![CDATA[/*用于识别的主程序*/structGg[NUMBER_SPACE]；floatbeg_end[NUMBER_SPACE][2]；voidmain(void){FILE*fp；FILE*fp1；charininfile[30]；charfilename1[30]；intnumber；intindex；intnum；intnum_mut；charnum_ch[4]；intsp_amount；intzon_x[10]；intzon_y[10]；intletter；floatarr_x[NUMBER_OF_STROKES]；floatarr_y[NUMBER_OF_STROKES]；floatarr_z[NUMBER_OF_STROKES]；floatarr_p[NUMBER_OF_STROKES]；intx，y，z，p，pen_old，i；intarr_beg_end[2]；fp1＝fopen(＂cba＂，＂r＂)；while(fscanf(fp1，＂％d＂，&letter)！＝EOF){fscanf(fp1，＂％s\n＂，infile)；if((fp＝fopen(infile，＂r＂))＝＝NULL)continue；printf(＂-％s-\n＂，infile)；sp_amount＝0；num＝0num_mut＝0pen_old＝1；while(fscanf(fp，＂％d＂，&x)！＝EOF){fscanf(fp，＂％d％d％d\n＂，&y，&z，&p)；if(pen_old＝＝p){arr_x[num]＝(float)x；arr_y[num]＝(float)y；arr_z[num]＝(float)z；num++；//amountinthespaceif(num＞NUMBER_OF_STROKES){printf(＂Amountofpenstrokesinthespaceisbiggerthen％d\n＂，NUMBER_OF_STROKES)；getch()；exit(0)；}num_mut++；∥amountinthefile}else{prep(num，num_t，sp_amount，arr_x，arr_y，arr_z)；sp_amount++；∥amountofspaceprep(num，num_mut，sp_amount，arr_x，arr_y，arr_z)；pen_old＝p；arr_x＝(float)x；arr_y＝(float)y；arr_z＝(float)z；num＝1；num_mut++；}fscanf(fp，＂％d％d％d％d＂，&x，&y，&z，&p)；fscanf(fp，＂％d％d％d％d＂，&x，&y，&z，&p)；fscanf(fp，＂％d％d％d％d＂，&x，&y，&z，&p)；}fclose(fp)；prep(num，num_mut，sp_amount，arr_x，arr_y，arr_z)；strcpy(filename1，＂rec＂)；strcat(filename1，＂.out＂)；fp＝fopen(filename1，＂a+＂)；fprintf(fp，＂％d\n＂，letter)；fprintf(fp，＂％s\n＂，infile)；fprintf(fp，＂％d％c\n＂，sp_amount，num_mut)；for(i＝0；i＜＝sp_amount；i++){nul_zone(i，arr_beg_end)；save(i，num_mut，arr_beg_end，fp)；}fclose(fp)；}fclose(fp1)；}intmain(void){FILE*fp，*fp2；inti，lev，j；charfilename[30]，filename1[30]；floatlev_sortintlev_rb.lev_re；fp＝fopen(＂flv＂，＂r＂)fscanf(fp，＂％d＂.&lev)；fclose(fp)；printf(＂Enterlevelforsorting＂)；scanf(＂％f＂.&lev_sort)；printf(＂Enterlevelforbeginnullzone＂)；scanf(＂％d＂，&lev_rb)printf(＂Enterlevelforendnullzone；＂)；scanf(＂％d＂，&lev_re)；/****************************************************/∥forconfusiontablefor(i＝0；i＜SYMBOLS_NUMBER；i++)for(j＝0；j＜SYMBOLS_NUMBER；j++)conf[i][i]＝0；/****************************************************/fp2＝fopen(＂sort.out＂，a+＂)；fp＝fopen(＂rec.out＂，＂r＂)；recogn(fp，fp2，lev，lev_sort，lev_rb，lev_re)；fclose(fp)；fclose(fp2)；/****************************************************/∥forconfusiontablefp＝fopen(＂matr＂，＂w＂)；for(i＝0；i＜26；i++)fprintf(fp，＂％c＂，(char)(i+97))；for(i＝0；i＜26；i++)fprintf(fp，＂％c＂，(char)(i+65))；for(i＝0；i＜10；i++)fprintf(fp，＂％c＂，(char)(i+48))；fprintf(fp，＂\n＂)；for(i＝0；i＜62；i++){for(j＝0；j＜62；j++)fprintf(fp，＂％d＂，conf[i][j])；fprintf(fp，＂\n＂)；}fclose(fp)；/****************************************************/return0；}/****************************************************Createsortingarrayaccordingtosortinglevel.****************************************************/intcutt_sort(intnum，floatlev_sort，structSsort[]){inti，j；floatlev；floatmax＝0.0；for(i＝0；i＜num；i++)if(sort[i].w＞max)max＝sort[i].w；lev＝max-lev_sort；if(lev＜＝0.0)lev＝00；j＝0；for(i＝0；i＜num；i++)if(sort[i].w＞＝lev){if(j！＝i)sort[j]＝sort[i]；j++；}return(j)；}intsort_funct(constvoid*a，constvoid*b){if(((structS*)a)-＞m＞((structS*)b)-＞m)refurn(-1)；if(((structS*)a)-＞m＜((structS*)b)-＞m)return(1)return(0)；}/**********************************Createfilesignrecognition．***********************************/voidrecogn(FILE*fp，FILE*fp2，intIev，floatIev_sort，intIev_rb，intIev_re){structSsort[SYMBOLS_NUMBER]；FILE*fp1；charfiename1[30]；floatbeg[NUMBER_SPACE]；floatend[NUMBER_SPACE]；intspace，num_mut，space_cur；doublekoef；intnumber，i，j，letter，amount，length，1；charnum[5]；floatmidil，dev，metr；floatx[NUMBER_OF_STROKES]；floaty[NUMBER_OF_STROKES]；floatz[NUMBER_OF_STROKES]；floatx_rec[NUMBER_OF_STROKES]；floatY＿rec[NUMBER_OF_STROKES]；floatz_rec[NUMBER_OF_STROKES]；floatnew_arr[NUMBER_OF_STROKES]；inttemp1，temp2，temp3；floatmax，min；floatsumm；floatsumml;floatm[MAX_REPRESNT][NIMBER_SPACE]；floatml[MAX_REPRESNT][NUMBER_SPACE]；floatb_0[NUMBER_SPACE]；floate_0[NUMBER_SPACE]；floatmunlt；intsymb_num；charname_file[20]；floatlev_sort1；intnum_for_sort；charletter_print；intSeqNo；while(fscanf(fp:“％d\n”&number)！＝EOF){fscanf(fp，“％s\n”，name_file)；printf(“％s\n”name_file)；fscanf(fp，“％d％d\n”&space，&num_mut)；/*letterfromrecognitionser*/for(i＝0i＜＝space；i＋＋){fscanf(fp，“％d\n”&space_cur)； fscanf(fp，“％d％f％f\n”，&g[space_cur].num，&g[space_cur].beg.&g[space_cur].end)； for(j＝0j＜g[space_cur]num；j＋＋)fscanf(fp，“％d％d％d\n”，&g[space_cur].f[j].x，&g[space_cur].f[j].y，&g[space_cur],f[j].z)； fscanf(fp，“％f％f\n”，&beg[space_cur]，&endd[space_cur])；}strcpy(filename1，“g”)；sprintf(num，“％d”，space)；strcat(filename1，num)；strcat(filename1，“out”)；fp1＝fopen(filename1，＂r＂)；symb_num＝0；while(fscanf(fp1，＂％d＂，&sort[symb_num].letter)！＝EOF)/*letterfromgenset*/{fscanf(fp1，＂％d＂，&amount)；fscanf(fp1，＂％f％f％f％f\n＂，&midll，&dev，&max，&min)；sort[symb_num].mut_len＝mut_metric((float)num_mut，midll，0.0，1500.0，dev，dev)；fscanf(fp1，＂\n＂)；for(i＝0；i＜＝space；i++){fscanf(fp1，＂％f％f％f％f\n＂，&midll，&dev，&max，&min)；}mult＝1.0；fscanf(fp1，＂\n＂)；for(i＝0；i＜＝space；i++){fscanf(fp1，＂％f％f％f％f\n＂，&midll，&dev，&max，&min)；if(i％2＝＝0)mult*＝mut_metric(g[i].beg，midll，0.0，1.0，dev，dev)；}fscanf(fp1，＂\n＂)；for(i＝0；i＜＝space；i++){fscanf(fp1，＂％f％f％f％f\n＂，&midll，&dev，&max，&min)；if(i％2＝＝0)mult*＝mut_metric(g[i].end，midll，0.0，1.0，dev，dev)；}sort[symb_num].beg_end＝mult；fscanf(fp1，＂\n＂)；for(i＝0；i＜＝space；i++){fscanf(fp1，＂％f％f％f％f\n＂，&midll，&dev，&max，&min)；}fscanf(fp1，＂\n＂)；for(i＝0；i＜＝space；i++){fscanf(fp1，＂％f％f％f％f\n＂，&midll，&dev，&max，&min)；}fscanf(fp1，＂\n＂)；for(i＝0；i＜amount；i++){for(j＝0；j＜＝space；j++){fscanf(fp1，＂％d\n＂，&length)；for(l＝0；l＜length；l++){fscanf(fp1，＂％d％d％d\n＂，&temp1，&temp2，&temp3)；x[l]＝temp1；y[l]＝temp2；z[l]＝temp3；}for(l＝0；l＜g[j].num；l++){x_rec[l]＝g[j]f[l].x；y_rec[l]＝g[j].f[l].y；z_rec[l]＝g[j].f[l].z；}if(length＜g[j].num){normal(length，x，g[j].num，new_arr)；summ＝metric(xrec，new_arr，g[j].num，lev)；summl＝metncl(xrec，new_arr，g[j].num，lev，lev_rb，lev_re)；normal(length，y，g[j].num，new_arr)；summ+＝metric(y_rec，newarr，g[j].num，lev)；summl+＝metricl(y_rec，new_arr，g[j].num，lev，lev_rb，lev_re)；normal(length，z，g[j].num，new_arr)， summ+＝metric(z_rec，newarr，g[j].num，lev)； summl+＝metricl(z_rec，new_arr，g[j].num，lev，lev_rb，lev_re)； m[i][j]＝1-summ/3； ml[i][j]＝1-summl/3； } else { normal(g[j].num，x_rec，length，new_arr)； summ＝metric(x，new_arr，length，lev)； summl＝metricl(x，new_arr，length，lev，lev_rb，lev_re)； normal(g[j].num，y_rec，length，new_arr)； summ+＝metric(y，new_arr，length，lev)； summl+＝metricl(y，new_arr，length，lev，lev_rb，lev_re)； normal(g[j].num，z_rec，length，new_arr)； summ+＝metric(z，new_arr，length，lev)； summl+＝metricl(z，new_arr，length，lev，lev_rb，lev_re)； m[i][j]＝1-summ/3； m[i][j]＝1-summl/3； } } } metr＝0.0； for(i＝0；i＜＝space；i++) {max＝0.0； for(j＝0；j＜amount；j++) if(max＜m[j][i])max＝m[j][i]； metr+＝max； } sort[symb_num].w＝metr/(space+1)； metr＝0.0； for(i＝0；i＜＝space；i++) {max＝0.0； for(i＝0；j＜amount；j++) if(max＜ml[j][i])max＝m[j][i]； metr+＝max； }sort[symb_num].m_0＝metr/(space+1)；sort[symb_num].m＝(somb[symb_num].w+sort[symb_num].mut_len+ sort[symb_num].beg_end)/3.0； symb_num++；}fclose(fp1)；num_for_sort＝cutt_sort(symb_num，lev_sort，sort)；if(num_for_sort＞1) qsort(sort，num_for_sort，sizeof(structS)，sort_funct)；i＝0；if(name_file！＝′b’){letter_print＝name_file； SeqNo＝(int)(name_file[2]-48)；}else {if(isdigit((int)name_file[1])！＝0) {letter_print＝name_file； SeqNo＝(int)(name_file[2]-48)； }else {letter_print＝toupper(name_file[1])； SeqNo＝(int)(name_file[3]-48)； } } fprintf(fp2，＂-％c0％d-Level＝％f％d\n＂，letter_print，SeqNo，lev_sort，num_for_sort)； /****************************************/∥forconfusiontable conf[number-1][sort.letter-1]++； /****************************************/ while(i＜num_for_sort) {fprintf(fp2，％3d*，sort[i].letter)； fprintf(fp2，＂W＝％.5fmut_len＝％.5fbeg_end＝％.5fm_O＝％.5fmidll＝％.5f\n＂， sort[i].w，sort[i].mut_len，sort[i].beg_end，sort[i].m_O，sort[i].m)； i++； } } } /*************************************************************************** similartyfunctiondefinessimilaritybetweenparameterandsampleof parameterswithknownmedial，leftandrightdeviation，andrangeofdefinition (const_l，const_r) ****************************************************************************/ floatmut_metnc(floatparam，floatmedial，floatconst_l，floatconst_r， floatdev_l，floatdev_r) {floatleft，right，m，div； left＝medial-dev_l； if(left＜const_l)left＝const_l； right＝medial+dev_r； if(right＞const_r)nght＝const_r； if((param＞＝left)&&(param＜＝right)) return(1.0)； else {div＝const_r-const_l-right+left+0.0001； if(div＝＝0.0)div＝medial； if(param＜left) m＝1.0-(left-param)/div； if(param＞right) m＝1.0-(param-right)/div； } if(m＜0.0)m＝0.0； return(m)； } /**************************************** Calculatefilecoordinatesaccordinglynewlength. ****************************************/ voidnormal(intnum_old，floatarr_old[]，intnum_new，floatarr_new[]) { doublekoeff； intind_old，ind_new； koeff＝(double)(num_old-1)/(float)(num_new-1)； arr_new＝arr_old； for(ind_new＝1；ind_new＜num_new-1；ind_new++){ ind_old＝(int)(floor(koeff*ind_new))； arr_new[indnew]＝(ind_old+1-koeff*ind_new)*arr_old[ind_old]+ (koeff*ind_new-ind_old)*arr_old[ind_old+1]； }arr_new[ind_new]＝arr_old[num_old-1]；}/****************************************Calculatelevel’smetric.*****************************************/floatmetric(floatz1[]，floatz2[]，intlength，intlev){inti；floatsumm＝0；for(i＝0；i＜length；i++)summ＝summ+fabs(z1[i]-z2[i])；return(summ/(float)(length*(lev-1)))；}/****************************************Calculatezonemetric.****************************************/floatmetricl(floata[]，floatb[]，intlength，intlev，intbeg，intend){intcalc＝0；inti；floats＝0，0；calc＝0；for(i＝0；i＜length；i++){if(((a[i]＜＝(float)end)&&(a[i]＞＝(float)beg))‖((b[i]＜＝(float)end)&&(b[i]＞＝(float)beg))){s+＝fabs(a[i]-b[i])；calc++；}}if(calc＝＝0)s＝1；s＝1.0-s/(float)(calc*(lev-1))；return(s)；}]]></pre>图形书写板识别和加速度识别的复合结果<prelisting-type="program-listing"><![CDATA[structTAB_ACS{charname；floattab_w；floatacs_w；floaty；floatx_vec；floaty_vec；floatamp；intup；floatm_tab；floatmut_len；floatbeg_end；floatm_acs；floatmidll；}；intmatr[100][100]；voidwrite_matr(void){FILE*fout1；inti，j；fout1＝fopen(＂matrix.t_a＂，＂w＂)；for(i＝0；i＜26；i++)fprintf(fout1，＂％c＂，97+i)；for(i＝0；i＜26；i++)fprintf(fout1，＂％c＂，65+i)；fprintf(fout1，*\n＂)；for(i＝0；i＜52；i++){for(j＝0；j＜52；j++)fprintf(fout1，＂％d＂，matr[i][j])；fprintf(fout1，＂\n＂)；}fclose(fout1)；}charconv_char(intin_name){if(in_name＜27)return((char)(in_name+96))；∥a-z1-26if(in_name＜53)return((char)(in_name+38))；∥A-Z27-52if(in_name＜63)return((char)(in_name-5))；∥0-953-62return(0)；}intconv_int(chara){if(a＜58)return((int)a+4)；if(a＜91)return((int)a-39)；if(a＜123)return((int)a-97)；return(0)；}voidmatr_add(chara，charb){matr[conv_int(a)][conv_int(b)]++；}intsortfunct(constvoid*a.constvoid*b){if(((structTAB_ACS*)a)-＞midll＞((structTAB_ACS*)b)-＞midll)return(-1)；if(((structTAB_ACS*)a)-＞midll＜((structTAB_ACS*)b)-＞midll)return(1)；return(0)；}voidmain(void){structACS{charname；floatw；floatmut_len；floatbeg_end；floatm_O；floatmidll；}；structTAB{charname；floatw；floaty；floatx；floatx_vec；floaty_vec；floatamp；intup；floatm；}；structTABtab[100]；structACSacs[100]；sfructTAB_ACStab_acs[100]；FILE*fp，*fp1，*fout；inti，k，l；charname_file_tab；charname_file_acs；intnum_file_tab，num_file_acs；intnum_tab.num_acs；intin_name；floattemp；chartempc；intpr；intfindfile；fp＝fopen(＂add_err＂，＂r＂)；fp1＝fopen(＂sort.out，＂r＂)；fout＝fopen(＂combine＂＂w＂)；while(fscanf(fp，＂％c％d＂，&name_file_tab，&num_file_tab)！＝EOF)∥add_err{find_file＝0；printf(＂-％c0％d-\n＂，name_file_tab，num_file_tab)；fseek(fp.8.1)；fscanf(fp，＂％d\n＂，&num_tab)；for(i＝0；i＜num_tab；i++){fscanf(fp，＂％c＂，&tab[i].name)；fscanf(fp，＂w＝％6f＂，&temp)；tab[i].w＝temp；fscanf(fp，＂y＝％6f＂，&temp)；tab[i].y＝temp；fscanf(fp，＂x＝％6f＂，&temp)；tab[i].x＝temp；fscanf(fp，＂x_vec＝％6f＂，&temp)；tab[i].x_vec＝temp；fscanf(fp，＂y_vec＝％6f＂，&temp)；tab[i].y_vec＝temp；fscanf(fp，＂amp＝％6f＂，&temp)；tab[i].amp＝temp；fscanf(fp，＂up＝％6f＂，&temp)；tab[i].up＝temp；fscanf(fp，＂m＝％6f＂，&temp)；tab[i].m＝temp；}while(fscanf(fp1，＂-％c＂，&name_file_acs)！＝EOF)∥sort_out{fscanf(fp1，＂0％d＂，&num_file_acs)；fseek(fp1，21，1)；fscanf(fp1，＂％d\n＂，&num_acs)；for(i＝0；i＜num_acs；i++){fscanf(fp1，＂％d＂，&ini_name)；acs[i].name＝conv_char(in_name)；fscanf(fp1，＂W＝％7f＂，&temp)；acs[i].w＝temp；fscanf(fp1，＂mut_len＝％7f＂，&temp)；acs[i].mut_len＝temp；fscanf(fp1，＂beg_end＝％7f＂，&temp)；acs[i].beg_end＝temp；fscanf(fp1，＂m_0＝％7f＂，&temp)；acs[i].m_0＝temp；fscanf(fp1，＂midll＝％7％7f\n＂，&temp)；acs[i].midll＝temp；}if((name_file_acs＝＝name_file_tab)&&(num_file_acs＝＝num_file_tab)){find_file＝1；break；}}if(find_file＝＝0){matr_add(name_file_tab，tab.name)；fseek(fp1，0L，SEEK_SEtT)；continue；}if(acs.name＝＝tab.name){matr_add(name_file_tab，tab.name)；fseek(fp1，OL，SEEK_SET)；continue；}else{k＝0；for(i＝0；i＜num_tab；i++){∥tab_acs[k].name＝tab[i].name；for(j＝0；j＜num_acs；j++){if(tab[i].name＝＝acs[j].name){tab_acs[k].name＝tab[i].name；tab_acs[k].tab_w＝tab[i].w；tab_acs[k].acs_w＝acs[j].w；tab_acs[k].y＝tab[i].y；tab_acs[k].x＝tab[i].x；tab_acs[k].x_vec＝tab[i].x_vec；tab_acs[k].y_vec＝tab[i].y_vec；tab_acs[k].amp＝tab[i].amp；tab_acs[k].up＝tab[i].up；tab_acs[k].m_tab＝(acs[j].w+tab[i].y+tab[i].x_vec+tab[i].amp)/4.0；tab_acs[k].mut_len＝acs[j].mut_len；tab_acs[k].beg_end＝acs[j].beg_end；tab_acs[k].m_acs＝acs[j].midll；tab_acs[k].midll＝(tab_acs[k].m_tab+tab_acs[k].acs_w)/2.0；k++；break；}}}fseek(fp1，0L，SEEK_SET)；}fprintf(fout，＂-％c0％d-％d\n＂，name_file_tab，num_file_tab，k)；if(k＝＝0)matr_add(name_file_tab，tab.name)；else{qsort(tab_acs，k，sizeof(structTAB_ACS)，sort_funct)；matr_add(name_file_tab，tab_acs.name)；for(l＝0；kk；l++)fprintf(fout，“％c-tab_m＝％.4facs_midll＝％.4ftab_acs＝％.4f\n＂，tab_acs[l].name，tab_acs[l].m_tab，tab_acs[l].acs_w，tab_acs[l].midll)；}}fclose(fp1)；fclose(fp)；fclose(fout)；write_matr()；return；}]]></pre>附录C；PALASM设计说明；----------------------------------说明部分------------题目PALASM设计说明方式版本1.0授权者HANNA和VECTOR公司BARON日期02/27/94芯片_PALPAC22V10.<prelisting-type="program-listing"><![CDATA[-------------------------PINDeclarations---------------PIN1CLKCOMBINATORIAL；CLOCK＝12.88MHZPIN2/RDCOMBINATORIAL；INPUTPIN3A0COMBINATORIAL；INPUTPIN4A1COMBINATORIAL；INPUTPIN5A2COMBINATORIAL；INPUTPIN6A3COMBINATORIAL；INPUTPIN7A4COMBINATORIAL；INPUTPIN8A5COMBINATORIAL；INPUTPIN9/RSCOMBINATORIAL；INPUTPIN10/REC0COMBINATORIAL；INPUTPIN11/REC1COMBINATORIAL；INPUTPIN12GNDPIN13IOCSCOMBINATORIAL；INPUT；OUTPUTPIN14/CSC0COMBINATORIAL；INPUTPIN15/CSC1COMBINATORIAL；INPUTpin16/R2REGISTEREDPIN17/R1REGISTEREDPIN18/R0REGISTEREDPIN19MR1COMBINATORIAL；OUTPUTPIN20MR0COMBINATORIAL；OUTPUTPIN21OUTR1COMBINATORIAL；OUTPUTPIN22OUTR0COMBINATORIAL；OUTPUTPIN23/GDCOMBINATORIAL；OUTPUTPIN24VCC；--------------------------------------------------------------------------------------------------------------------------------------STRINGADD1’IOCS*RD*/A5*/A4*/A3*A2*A1*A0’STRINGADD2’IOCS*RD*/A5*/A4*A3*/A2*/A1*/A0’；--------------------------------------------------------------------------------------------------------------------------------------STATEMOOREMACHINESTARTUP＝POWERUP-＞idleIDLE＝RS1-＞CON1+RS2-＞CON2+-＞IDLECON1＝/RD-＞CON3+RD-＞CON1CON2＝/RD-＞CON4+RD-＞CON2CON3＝VCC-＞IDLECON4＝VCC-＞IDLE；------------------------------------------------------------------------------------------------------IDLE＝/R0*/R1*/R2CON1＝R0*/R1*/R2CON2＝/R0*R1*/R2CON3＝R0*R1*/R2CON4＝/R0*/R1*R2；--------------------------------------------------------------------------------------------------------IDLE.OUTF＝/MR0*/MR1CON1.OUTF＝/MR0*/MR1CON2.OUTF＝/MR0*/MR1CON3.OUTF＝MR0CON4.OUTF＝MR1；--------------------------------------------------------------------------------------------------------CONDITIONSRS1＝ADD1RS2＝ADD2；---------------------------------------------------------------------------------------------------------EQUATIONSOUTR0＝RS*REC0OUTR1＝RS*REC1GD＝IOCS*RD*((/A5*/A4*/A3*A2*(A0+A1))+CSC0+CSC1)；--------------------------------------------------------------------------------------------------------------------------------simulationTRACEONCLKRDMR0MR1IOCSA0A1A2A3A4A5PRELOADIDLESETFRDIOCS/A0/A1/A2/A3/A4/A5CLOCKFCLKCLOCKFCLKCLOCKFCLKSETFA3CLOCKFCLKLOCKFCLKCLOCKFCLKSETF/RDCLOCKFCLKCLOCKFCLKSETF/IOCSRD/A3A2A1/A0/CSC0/CSC1SETFIOCSSETFA0/A1SETF/A0SETFCSC0SETFCSC1/CSC0TRACE_OFF；PACASM设计说明------------------------说明部分-------------题目PALASM设计说明方式版本1.0授权者HANNA和VECTOR公司BARON日期02/27/94芯片__PALPAC22V10；--------------------------------PINDecIarations---------------PIN1/RDPIN2FRESPIN3A0PIN4A1PIN5A2PIN6A3PIN7A4PIN8A5PIN9Q0；INPUTPIN10Q1；INPUTPIN11ANR；INPUT；OUTPUTPIN13IOCSPIN14/LSPIN15/CSDACPIN16/CONVST0PIN17/CONVST1PIN18/CSADC0PIN19/CSADC1PIN20/CSCOUNT0PIN21/CSCOUNT1PIN22CPCOUNT0PIN23CPCOUNT1；----------------------------------等式部分---------EQUATIONSLS＝IOCS*/A5*/A4*/A3*/A2CSDAC＝IOCS*WR*/A5*/A4*/A3*(/A2+A2*/A1*/A0)CONVST0＝IOCS*WR*/A5*/A4*/A3*A2*/A1*A0CONVST1＝IOCS*WR*/A5*/A4*/A3*A2*A1*/A0CSADC0＝IOCS*/A5*/A4*/A3*A2*/A1*A0CSADC1＝IOCS*/A5*/A4*/A3*A2*A1*/A0CSCOUNT0＝IOCS*RD*/A5*/A4*/A3*A2*A1*A0CSCOUNT1＝IOCS*RD*/A5*/A4*A3*/A2*/A1*/A0/CPCOUNT0＝FRES*Q0/CPCOUNT1＝FRES*Q1-----------------------------------------------SIMULATIONTRACEON/RDFRESA0A1A2A3A4A5Q0Q1/WRIOCSSETFIOCSRDWRA0A1A2A3A4A5Q0Q1FRESSETF/WR/A5/A4/A3/A2SETF/IOCSSETFIOCSSETF/RDWRSETFA2/A1/A0SETFA0SETFA1/A0SETFRD/WRA0SETFA3/A0/A1/A2SETFFRESQ0SETF/FRES/Q0；PALASM设计说明；---------------------------DeclarationSegment-----------题目PALASM设计说明方式版本1.0授权者HANNA和VECTOR公司BARON日期02/27/94芯片__PALPAC22V10-----------------------------PINDacIarations-------------PIN1A6；INPUTPIN2A7PIN3A8PIN4A9PIN5A10PIN6A11PIN7A12PIN8A13PIN9/DMS；INPUTPIN10/PMS；INPUTPIN11/RD；INPUTPIN14/DMS0；OUTPUTPIN15/DMS1；OUTPUTPIN16/PMS0；OUTPUTPIN17/PMS1；OUTPUTPIN18/DMRD；OUTPUTPIN19/IOCS2PIN20IOCS1；------------------------------BooleanEquationSeqment-------STRINGIO’A13*A12*/A11*A10*A9*A8*A7*A6’EQUATIONSIOCS1＝IO*DMSIOCS2＝IO*DMSDMS0＝/A13*DMSDMS1＝A13*DMSPMS0＝/A13*PMSPMS1＝A13*PMSDMRD＝(/A13+/A12+A11+/A10+/A9+/A8+/A7+/A6)*DMS*RD；--------------------------------------SimulationSeqment-------------SIMULATIONtraceonIOCS1IOCS2DMS0DMS1PMS0PMS1DMRDSETFA13A12A11A10A9A8A7A6DMS/RD/PMSSETFA13A12A11A10A9A8A7A6/DMS/RDPMSSETFA13A12/A11A10A9A8A7/A6DMSRDSETFA13A12/A11A10AgA8A7A6DMSRDSETF/A13/DMSPMSSETF/A13DMS/PMSSETFA13SETF/DMSPMS；------------------------------------------------------------------]]></pre>附录D<prelisting-type="program-listing"><![CDATA[.MODULE/SEG＝prog_memibmstr02；.ENTRYStartUp；.INCLUDE＜d\adidsp\include\def2101.h＞；.CONSTTSCALE＝0；.CONSTTCOUNT＝0×8fff；.CONSTTPERIOD＝0×8fff；.VAR/CIRC/DM/RAM/SEG＝data_memPackage[4]；.VAR/CIRC/DM/RAM/SEG＝data_memShifter_Const[8]；.VAR/CIRC/DM/RAM/SEG＝data_memMasks[8]；.GLOBALPackage；.GLOBALShifter_Const；.GLOBALMasks；.INITShifter_Const＜sh_const.dat＞；.INITMasks＜masks.dat＞；StartUp{SetSystemCorntrolRegisterSPORTO-enable，SPORTl-enable} AX0＝0×1c1f； DM(Sys_Ctrl_reg)＝AX0；{-----------------------------------------------------------------------}{LoadTperiodRegisterfor10milliseconds} AX0＝TPERIOD； DM(Tperiod_Reg)＝AX0；{-----------------------------------------------------------------------}{LoadTcountRegisterfor10milliseconds} AX0＝TCOUNT； DM(Tcount_Reg)＝AX0；{-----------------------------------------------------------------------}{LoadTscaleRegister} AX0＝TSCALE； DM(Tscale_Reg)＝AX0；{-----------------------------------------------------------------------}{SetSPORT0ControlRegisterISCLCK-enable，SLEN＝(1+8+1)-1} AX0＝B#0100101000001001；DM(Sport0_Ctrl_Reg)＝AX0；{-----------------------------------------------------------------------}{SetSPORT0ClockDividerto19200baud}AX0＝0×13f；DM(Sport0Sclkdlv)＝AX0；{-----------------------------------------------------------------------}{SetSPORT1ControlRegisterISCLCK-enable，SLEN＝(8-1)}AX0＝0×4a07；DM(Sportl_Ctrl_Reg)＝AX0；{-----------------------------------------------------------------------}{SetSPORT1ClockDividerto80000cyclesAX0＝0×004c；DM(SportlSclkdiv)＝AX0；{-----------------------------------------------------------------------}{SetparametersofCircBufferpackage} I0＝＾Package； M0＝1； L0＝％Package； I1＝I0；{-----------------------------------------------------------------------}{SetInterruptControlReg，SetIMASKReg，SetMSTATReg} ICNTL＝0×17； IMASK＝0×39；{-----------------------------------------------------------------------}{SetParametersofCircBufferShifter_const} I2＝＾ShifterConst； I3＝＾Masks； M2＝1； M3＝1； L2＝％Shifter_Const； L3＝％Masks；{-----------------------------------------------------------------------} RTS；ENDMOD；.MODULE/SEG=prog_memibmwac0l；.INCLUDE＜d\adi_dsn\include\det2101.h>；.CONSTMASK_RS232=B#0000000001；.CONSTDATA_BITS_1=B#11111110；.CONSTDATA_BITS_2=B#00000000111111100；.CONSTMASK_SYNCHROBIT=B#100000000；.CONSTEXCITATION_WORD=0×0055；.EXTERNALStartUp；.EXTERNALRevers；.PORTx_counter_port；.PORTy_counter_port；.EXTERNALPackage； JUMPStartMouse；NOP；NOP；NOP；{Interuptvectortable} RTI；NOP；NOP；NOP；{Nointerruptsused} JUMPTransmitNext；NOP；NOP；NOP； RTI；NOP；NOP；NOP； RTI；NOP；NOP；NOP； RTI；NOP；NOP；NOP； JUMPSampling；NOP；NOP；NOP；StartMouse{SettingallControlRegistersandotherparameters}{SetsygtemparametersTimer，SPORT’s} CALLStartUp；{--------------------------------------------------------------}{SetparametersofCircBuffer I0=＾Package； M0=1； L0=％Package； I1＝I0{--------------------------------------------------------------}{SetInterruptControlReg，SetIMASKReg，SetMSTATReg ICNTL=0×17； IMASK=0×39； MSTAT=0×30；{--------------------------------------------------------------}{SendfirstsignaltoUST} TX1＝EXCITATION_WORD；{--------------------------------------------------------------}MLoop{Mainloopofprogram} IDLE；{waitforTimerInterrupt} JUMpMLoop；Sampling{TimerInterruptServicercutine(every3ms)} MR0＝DM(x_counter_port)；{ReadXccunter} MR1＝DM(y_counter_port)；{ReadYcounter} Tx1＝EXCITATION_WORD；{TransmitsignaltoUST}{èёёёёёёёùёёёёёёёёёùёёёёёёёёёùёёёёё<paragraphid="d315"></paragraph>ёёёёё<paragraphid="d316"></paragraph>ёёёёё<paragraphid="d317"></paragraph>ёёёёё<paragraphid="d318"></paragraph>ёёёёё<paragraphid="d319"></paragraph>ёёёёё<paragraphid="d320"></paragraph>ёёёёёùёёёёёё¤pack¤9¤8¤7°6°5°4°3°2°1C0¤¤for_ёёёёёёёёё_ёёёёёёёёё_ёёёёёüёёёёёüёёёёёüёёёёёüёёёёёüёёёёёüёёёёё_ёёёёё<paragraphid="d321"></paragraph>ё<paragraphid="d322"></paragraph>¤PC¤StartBit¤Sync.Bit¤DataBits¤Stoo¤¤ёёёёёёё_ёёёёёёёёё_ёёёёёёёёё_ёёёёё<paragraphid="d323"></paragraph>ёёёёё<paragraphid="d324"></paragraph>ёёёёё<paragraphid="d325"></paragraph>ёёёёё<paragraphid="d326"></paragraph>ёёёёё<paragraphid="d327"></paragraph>ёёёёё<paragraphid="d328"></paragraph>ёёёёё_<paragraphid="d329"></paragraph>¤Byte1¤0¤1¤PEN°F11°F10°F09°F08°F07°F06¤1¤úááááááá_ááááááááá_ááááááááá_áááááéáááááéáááááéáááááéáááááéááááááéááááá_áááááN¤Byte2¤0¤0¤0°F05°F04°F03°F02°F01°F00¤1¤úááááááá_ááááááááá_ááááááááá_áááááéáááááéáááááéáááááéáááááéááááááéááááá_áááááN¤Byte3¤0¤0¤0°S11°S10°S09°S08°S07°S06¤1¤úááááááá_ááááááááá_ááááááááá_áááááéáááááéáááááéáááááéáááááéááááááéááááá_áááááN¤Byte4¤0¤0¤0°S05°S04°S03°S02°S01°S00¤1¤àёёёёёёёàёёёёёёёёёòёёёёёёёёёòёёёёёüёёёёёüёёёёёüёёёёёüёёёёёüёёёёёёüёёёёёòёёёёё￥}{BuidingtheFirstbyteofPackageforPC} AR＝MASK_RS232； AY0＝MASK_SYNCHROBIT； AF＝ARORAY0； SR＝LSHIFTMR0BY11(LO)； AY1＝DATA_BITS_1； AR＝SR1ANDAY1； CALLRevers； SR＝LSHIFTARBY1(LO)； AR＝SR0ORAF； DM(I0，M0)＝AR；{---------------------------------------------------------------------------------}{BuidingtheSecondbyteofpackageforPC} AR＝MASKRS232； AY0＝0； AF＝ARORAYO； SR＝LSHIFTMROBY18(LO)； AY1＝DATA_BITS_2； AR＝SRlANDAYl； CALLRevers； SR＝LSHIFTARBY1(LO)； AR＝SROORAF； DM(I0，M0)＝AR；{--------------------------------------------------------------------------------}{BuidingtheThirdbyteofPackageforPC} SR＝LSHIFTMRlBY12(LO)； AY1＝DATA_BITS_1； AR＝SRlANDAYl； CALLRevers； SR＝LSHIFTARBY1(LO)； AR＝SROORAF； DM(I0，M0)＝AR；{--------------------------------------------------------------------------------}{BuidingtheFourthbyteofPackageforPC} SR＝LSHIFTMR1BY18(LO)； AY1＝DATA_BITS_1； AR＝SR1ANDAY1； CALLRevers； SR＝LSHIFTARBY1(LO)； AR＝SR0ORAF； DM(I0，M0)＝AR；{--------------------------------------------------------------------------------}{SendFirstBytetoPC} AX0＝DM(I0，M0)； TX0＝AX0；{---------------------------------------------------------------} RTI；Transmit_Next AXl＝I0； AY1＝I1； AR＝AXl-AYl； IFEQJUMPOut_Interrupt；Send_Next AX0＝DM(I0，M0)； TX0＝AX0；Out_Interrupt RTI；.ENDMOD；.SYSTEMibmwacom01；.ADSP2101；.MMAP0；.SEG/ROM/BOOT＝0/CODEbootpm；.SEG/PM/RAM/ABS＝0/CODEprog_mem；.SEG/DM/RAM/ABS＝0×3800/DATAdata_mem；.PORT/DM/ABS＝0×3400x_counter_port；.PORT/DM/ABS＝0×3401y_counter_port；.ENDSYS；]]></pre>目录E<prelisting-type="program-listing"><![CDATA[externintCOUNTS1[15000]；externintCOUNTS2[15000]；externcharpen_up[15000]；#defineBUFFER_SIZE60000#defineMIN_COUNT850#defineMAX_COUNT1800#defineMINX-120#defineMINY700#defineMAXX800#defineMAXY1600#include＜stdio.h＞#include＂extern.h＂intInitialize(void){FILE*fp；intndx＝0，tmp；if((fp＝fopen(＂temp.tst＂，＂r＋t＂))＝＝NULL) return-1；while(fscanf(fp，＂％d％d％d＂，&COUNTS1[ndx]，&COUNTS2[ndx]，&tmp)＞0&&ndx＜15000){ pen_up[ndx++]＝(char)tmp；}fclose(fp)；if(ndx＝＝15000) printf(＂arrayexceeds15000！！！，notallfioleisread\n＂)；returnndx；}#include＂const.h＂#include＜graphics.h＞#include＜conio.h＞#include＜stdio.h＞#include＜math.h＞#include＜Stdlib.h＞intInitialize(void)；voidbutter_filtO(fioatin[]，fioatout[])；#defineGR_ONintCOUNTS1[15000]，COUNTS2[15000]；charfarpen_up[15000]；#pragmaargsusedintmain(){intrepl；inti，ndx；unsignedcharc1，c2，fix＝0，fly＝0；unsignedintcount1，count2；intgdriver＝DETECT，gmode，errorcode；intScrMaxX，ScrMaxY；intCountRange，XRange，YRange；floatx_cor，y_cor；floatNewCountAX[3]，NewCountAY[3]；floatCountAX[5]，CountAY[5]；floatax＝0.，ay＝0.；floatInFilt[2]，OutFilt[2]；intNumPoints，CountNdx＝0；floattemp；#ifdefGR_ONinitgraph(&gdriver，&gmode，＂C\\BORLANDC\\BGI＂)；errorcode＝graphresult()；if(errorcode！＝grOk){ printf(＂Graphicserror％s\n＂，grapherrormsg(errorcode))； printf(＂Pressanykeytohalt＂)； getch()； return-2；}#endifScrMaxX＝getmaxx()；ScrMaxY＝getmaxy()；CountRange＝MAX_COUNT－MIN_COUNT；XRange＝MAXX－MINX；YRange＝MAXY－MINY；if((NumPoints＝lnitialize())＜0){ printf(＂unabletoinitalize\n＂)； return-1；}count1＝COUNTS1[CountNdx]；count2＝COUNTS2[CountNdx++]；NewCountAX＝NewCountAX[1]＝NewCountAX[2]＝count1；NewCountAY＝NewCountAY[1]＝NewCountAY[2]＝count2；CountAX＝CountAX[1]＝CountAX[2]＝count1；CountAY＝CountAY[1]＝CountAY[2]＝count2；InFilt＝NewCountAX[1]；InFilt[1]＝NewCountAY[1]；InFilt＝375. ((fioat)NewCountAX[1]*NewCountAX[1]－ (fioat)NewCountAY[1]*NewCountAY[1])/1500.；temp＝(fioat)NewCountAY[1]*NewCountAY[1]－InFilt*lnFilt；if(temp＞0) InFilt[1]＝(fioat)sqrt(temp)；x_cor＝(((InFilt－MINX)/(fioat)XRange)*ScrMaxX)；y_cor＝(((InFilt[1]－MINY)/(float)YRange)*ScrMaxY)；#ifdefGR_ONmoveto(x_cor，y_cor)；*#endifndx＝0；NewCountAX＝NewCountAX[1]＝NewCountAX[2]＝COUNTS1[CountNdx]；NewCountAY＝NewCountAY[1]＝NewCountAY[2]＝COUNTS2[CountNdx]；CountAX＝CountAX[1]＝CountAX[2]＝CountAX[3]＝CountAX[4]＝COUNTS1[CountNdx]；CountAY＝CountAY[1]＝CountAY[2]＝CountAY[3]＝CountAY[4]＝COUNTS2[CountNdx++]；while(CountNdx＜NumPoints){ count1＝COUNTS1[CountNdx]； count2＝COUNTS2[CountNdx++]； NewCountAX＝NewCountAX[1]；NewCountAY＝NewCountAY[1]； NewCountAX[1]＝NewCountAX[2]；NewCountAY[1]＝NewCountAY[2]；/*NewCountAX[2]＝count1；NewCountAY[2]＝count2；*/CountAX＝CountAX[1]；CountAY＝CountAY[1]； CountAX[1]＝CountAX[2]；CountAY[1]＝CountAY[2]；CountAX[2]＝CountAX[3]；CountAY[2]＝CountAY[3]; CountAX[3]＝CountAX[4]；CuuntAY[3]＝CountAY[4]； CountAX[4]＝count1；CountAY[4]＝count2； if(fix) { NewCountAX[2]＝(CountAX[3]－CountAX)*2./3.＋NewCountAX； fix＝0； } else if(abs(CountAX[2]－NewCountAX[1]－ax)＜10) NewCountAX[2]＝CountAX[2]－ax； elseif(abs(CountAX[1]－CountAX[3])＜12) NewCountAX[2]＝(CountAX[1]＋CountAX[3])/2.－ax； elseif(abs(CountAX[1]－CountAX[4])＜12) { NewCountAX[2]＝(CountAX[4]－CountAX[1])/3.＋CountAX[1]－ax； fix＝1； } else {floattmp； tmp＝(NewCountAX[1]－NewCountAX＋CountAX[3]－CountAX[2])/2； ax＝(CountAX[2]－NewCountAX[1]－tmp)； NewCountAX[2]＝CountAX[2]－ax； } if(fly) { NewCountAY[2]＝(CountAY[3]－CountAY)*2./3.＋NewCountAY； fly＝0； } else if(abs(CountAY[2]－NewCountAY[1]－ay)＜10) NewCountAY[2]＝CountAY[2]－ay； elseif(abs(CountAY[1]－CountAY[3])＜12) NewCountAY[2]＝(CountAY[1]＋CountAY[3])/2.－ay； elseif(abs(CountAY[1]－CountAY[4])＜12) { NewCountAY[2]＝(CountAY[4]－CountAY[1])/3.＋CountAY[1]－ay； fly＝1； } else {floattmp； tmp＝(NewCountAY[1]－NewCountAY＋CountAY[3]－CountAY[2])/2； ay＝(CountAY[2]－NewCountAY[1]－tmp)； NewCountAY[2]＝CountAY[2]－ay； }/* if(abs(CountAY[1]－NewCountAY－ay)＜10) {NewCountAY[1]＝CountAY[1]－ay；apy＝ay；}elseif(abs(CountAY－CountAY[2])＜12) {NewCountAY[1]＝(int)(CountAY＋CountAY[2])/2.－ay；apy＝ay；} elseif(ay＝＝apy) { apy＝ay； ay＝(int)(CountAY[1]－NewCountAY)； NewCountAY[1]＝CountAY[1]－ay； }*/ InFilt＝375.－ ((float)NewCountAX[2]*NewCountAX[2]－ (fioat)NewCountAY[2]*NewCountAY[2])/1500.； temp＝(float)NewCountAY[2]*NewCountAY[2]－InFilt*InFilt； if(temp＞0) InFilt[1]＝(fioat)sqrt(temp)； butter_filt0(InFilt，OutFilt)；#ifdefGR_ON x_cor＝(((OutFilt－MINX)/(float)XRange)*ScrMaxX)*(480./640.)； y_cor＝(((OutFilt[1]－MINY)/(float)YRange)*ScrMaxY)； if(CountNdx＞21) { if(pen_up[CountNdx－20]&&！pen_up[CountNdx－21]) moveto((x_cor－200)*2，(y_cor－100)*2)； else if(pen_up[CountNdx－20]) lineto((x_cor－200)*2，(y_cor－100)*2)； }#endif#ifndefGR_ON printf(＂％04d％04d％04d％04d\n＂，NewCountAX[1]，NewCountAY[1]，(int)OutFilt，(int)OutFilt[1])； /*printf(＂％u％u\n＂，Buffln，BuffOut)；*/ ndx++；#endif if(kbhit()) { if(getch()＝＝0) getch()； break； } /*if(OverFlowFlag) { printf(＂BufferOverFlow\n＂)； continue； }*/}/*CloselnterrComm(portbase)；*/#ifdefGR_ON while(！kbhit())/*donothing*/； getch()；/*closegraph()；*/#endif returnO；}/*****************************************************.再构造及笔移动图及符合*****************************************************/#include＜conio.h＞#include＜stdio.h＞#include＜math.h＞#include＜stdlib.h＞/*FiltrationbylowPASSfilterButterworth4order.andcutofffreq..04fromhalfsamplingrateInputarayin.Outputarrayout.*/voidbutter_filt0(fioatin[]，floatout[]){ staticfloata[5]＝{1.，-3.6717291，5.0679984，-3.1159669，.71991033}； staticfloatb[5]＝{1.3293729e-05，5.3174916e-05，7.9762373e-05，5.3174916e-05，1.3293729e-05}； staticfloaty[2][5]，x[2][5]； inti，j； floatsum＝0.； staticintfi＝0； for(j＝0；j＜2；j++) { if(！fi) for(i＝0；i＜5；i++) { y[j][i]＝in[j]； x[j][i]＝in[j]； } for(i＝4；i＞0；i--) x[j][i]＝x[j][i-1]； x[j]＝in[j]；if(fl) { sum＝0； for(i＝4；i＞0；i--) y[j][i]＝y[j][i-1]； for(i＝0；i＜5；i++) sum+＝b[i]*x[j][i]； for(i＝1；i＜5；i++) sum-＝a[i]*y[j][i]； y[j]＝sum； out[j]＝sum；； } else out[j]＝in[j]；}if(！fi)fl＝1；}]]></pre>权利要求1.手写体识别设备，包括手写体输入装置使用至少两种不同的检测技术检测手写体和包括至少一个位于手持书写工具上的加速计；和符号识别装置接收该手写体输入装置的输出，提供该手写体所代表的符号的指示输出。2.按照权利要求1的手写体识别设备，其中所述手写体输入装置包括一个位置数字化器。3.按照权利要求1的手写体识别设备，其中所述手写体输入装置包括在空气中操作的超声波位置确定装置。4.按照权利要求3的手写体识别设备，其中所述手写体输入装置是在计算机屏幕上书写操作的。5.用于检测笔—表面接触的设备，包括至少一个加速计测量至少一个用户的手操纵的一个笔的加速度分量，笔一表面接触检测器接收来自加速计的输入，该输入被滤波，去除噪声分量。6.按照权利要求2的手写体识别设备，其中所述至少一个加速计包括多个互相正交放置的加速计。7.按照权利要求2的手写体识别设备，其中所述符号识别装置包括，组合位置和加速度处理装置，该装置组合来自所述数字化器和所述在识别符号中的至少一个加速计的输入。8.按照权利要求2的手写体识别设备，其中所述符号识别装置包括，第一识别信道，用于从所述数字化器输入，提供代表符号的识别的第一输出；第二识别信道，用于从所述至少一个加速计输入，提供代表符号的识别的第二输出；和符号选择装置，用于根据预定的准则在第一和第二输出之间进行选择。9.按照权利要求5的检测笔—表面接触设备，其中所述检测器包括加速度噪声分析器，进行操做提取出加速度数据的噪声输出和使用该噪声来检测笔—表面接触。10.按照权利要求5的用于检测第—表面接触的设备，其中所述至少一个加速计是可改型地安装在笔上。11.一种手写体识别方法，包括从三个互相正交地安装在书写工具上的加速度计上接收涉及一个书写工具的加速度和至少部分地根据书写工具的加速度与存储的具有多个符号的每一个的特征的加速度序列之间比较；识别由书写工具写的符号。12.手写识别设备，包括一个特征的加速度序列存储器有效地存储具有多个符号的每个的特征的加速度序列；一个书写器具监视器有效地从安装在所述书写工具上三个互相正交的加速度计接收涉及书写工件的加速度信息；和一个符号识别器有效地至少根据书写工具的加速度与存储的加速度序列的比较，提供由书写工具书写的符号的输出指示。13.按照权利要求12的手写体识别设备，其中所述书写工具监视器还有效地接收涉及所述书写工具的位置的信息。14.一种手写体识别方法，包括使用至少一个位于手持的书写工具上的加速计和至少一个附加的不同的检测技术检测手写体；和接收手写体的输出指示，以便提供代表手写体的符号输出指示。15.按照权利要求14的手写体识别方法，其中所述至少一个附加的检测技术包括位置数字化。16.一种检测笔—表面接触的方法，包括使用至少一个加速度计测量至少一个用户手操纵笔的加速度分量；和从加速度计接收一个输入，该输入被滤波去除非噪声分量和提供一个笔—表面接触输出指示。17.按照权利要求15的手写体识别方法，还包括通过组合数字化位置输入和检测加速度信息，识别符号。18.按照权利要求14的手写体识别方法，其中所述接收包括使用数字化的位置输入，提供代表符号识别的第一输出；使用加速度信息，提供代表符号识别的第二输出；和在第一和第二输出中进行选择。19.手写体识别设备，包括手写体输入装置包括至少第一和第二不同的手写体检测器，产生第一和第二手写体输出，至少所述第一和所述第二不同的手写体检测器之一包括至少一个位于手持的书写工具上的加速计；和一个用于组合第一和第二手写体输出的附件，提供增强的手写体输出的性能；和符号识别装置接收所述增加的手写体输出性能，提供代表手写体的符号输出指示。20.按照权利要求1的手写体识别设备，其中所述手写体输入装置包括光字符识别装置。21.按照权利要求19的手写体识别设备，其中所述第二手写体检测器包括一个键盘。22.按照权利要求19的手写体识别设备，其中所述第二手写体检测器包括工作在空气中的超声波位置确定装置。23.按照权利要求22的手写体识别设备，其中所述第二手写体检测器有效地检测在计算机屏幕上的手写体。24.按照权利要求20的手写体识别设备，其中所述至少一个加速度计包括多个加速度计。25.按照权利要求19的手写体识别设备，其中所述第一和第二手写体检测器中的至少一个包括有效地检测书写工具的位置的装置。26.按照权利要求19的手写体识别设备，其中所述附件有效地在两维范围相关第一和第二手写体输出。27.按照权利要求19的手写体识别设备，其中所述附件有效地在时间范畴相关第一和第二手写体输出。28.一种手写体识别方法，包括使用至少一个位于手持的书写器具上的加速度计和至少一个附加的检测器，产生第一和第二手写体输出；组合第一和第二手写体输出，提供一个增强性能的手写体输出；和使用所述增强性能和手写体输出，提供一个代表该手写体的符号输出指示。29.按照权利要求24的手写体识别设备，其中所述多个加速度计是互相正交放置的。30.按照权利要求28的方法，其中所述至少一个附加的不同检测器是有效地检测书写工具的位置。31.按照权利要求28的方法，其中组合的步骤包括在两维范围的相关第一和第二手写体输出。32.按照权利要求28的方法，其中组合的步骤包括在时间范畴相关第一和第二手写体输出。33.手绘体识别设备，包括手绘体输入装置使用至少两个不同的检测技术，检测手绘体和包括至少位于手持的书写工具上的一个加速度计；和形状识别装置接收手绘体输入装置的输出，提供代表手绘体的形状指示输出。34.按照权利要求33的手绘体识别设备，其中所述手绘输入装置包括一个位置数字化器。35.按照权利要求33的手绘体识别设备，其中所述手绘体包括至少描绘和手写体之一。36.按照权利要求33的手绘体识别设备，其中所述输入装置包括工作在空气中的超声波位置确定装置。37.按照权利要求33的手绘体识别设备，其中所述形状识别装置包括组合位置和加速度处理装置，该装置在识别形状中组合来自所述数字化器和所述至少一个加速度计的输入。38.按照权利要求33的手绘体识别设备，其中所述形状识别装置包括第一识别信道，用于来自所述数字化器的输入，提供代表形状识别的第一输出，第二识别信道，用于来自至少一个加速计的输入，提供代表形状识别的第二输出，和形状选择装置，用于根据预定的推测在第一和第二输出之间进行选择。39.按照权利要求38的手绘体识别设备，其中所述至少一个加速度计是可多种形式安装在书写工具上的。40.一种手绘体识别方法包括接收从三个互相正交地安装在所述书写工具上的加速度计的涉及书写工具的加速度信息；和至少部分地根据书写工具的加速和存储的具有多个形状的每个的加速度序列之间的比较识别由书写工具所写的形状。41.按照权利要求40的手绘体识别方法，还包括接收涉及书写工具的位置的信息。42.按照权利要求40的手绘体识别设备，还包括存储按照由第二多个用的每一个产生的其有第一多个形状的每个特征的加速度序列。43.手绘体识设备，包括特征的加速度序列存储器有效地存储具有多个形状特征在每一个的加速度序列；书写工具监视器有效地接收来自三个互相正交地安装在所述书写工具上的加速计的涉及书写工具的加速度信息；和一个形状识别器，至少部分地根据书写工具的加速度和存储的加速度序列的比较，提供由书写工具的书写形状的输出指示。44.按照权利要求43的手绘体识别设备，其中所述书写工具监视器也有效地接收涉及所述书写工具的位置信息。45.一种手绘体识别方法，包括使用至少一个位于手持的书写工具上的加速度计和至少一个附加的不同的检测技术，检测手绘体；和接收一个手绘体的输出，以便提供代表该手绘体形状的输出指示。46.按照权利要求45的手绘体识别方法，其中所述至少一个附加的检测技术包括位置数字化。47.按照权利要求45的手绘体识别方法，还包括通过组合数字化位置输入和检测的加速度信息识别形状。48.按照权利要求45的手绘体识别方法，其中所述接收包括使用数字化位置输入，提供代表形状识别的第一输出；使用加速度信息，提供代表形状识别的第二输出；和在第一和第二输出之间进行选择。49.按照权利要求45的方法，其中所述接收包括提取加速度数据的噪声输出和使用该噪声检测笔—表面的接触。50.手绘体识别设备，包括手绘体输入装置包括至少第一和第二不同的手绘体检测器产生第一和第二手绘体输出，至少所述第一和第二手绘体检测器之一包括至少一个位于书写工具上的加速度计；和一个用于组合第一和第二手绘体输出的附件，提供一个增强性能的手绘体输出；和形状识别装置接收所述增强性能的手绘体输出，提供代表手绘体的形状的输出指示。51.按照权利要求20的手写体识别设备，其中所述符号识别装置包括组合位置和加速度处理装置，该装置在识别符号中组合来自所述光字符识别装置和所述至少一个加速度计的输入。52.按照权利要求50的手写体识别设备，其中所述第二手绘检测器包括一个键盘。53.按照权利要求50的手写体识别设备，其中所述第二手写检测器包括一个工作在空气中的超声波位置确定装置。54.按照权利要求20的手写体识别设备，其中所述符号识别装置包括第一识别信道，用于来自所述光字符识别装置的输入，提供代表符号识别的第一输出，第二识别信道，用于来自所述至少一个加速度计的输入，提供代表符号识别的第二输出，和符号选择装置，用于根据预定的准则在第一和第二输出之间进行选择。55.按照权利要求50的手绘体识别设备，其中所述第一和第二手写体检测器中的至少一个包括有效地检测书写工具的位置的装置。56.按照权利要求50的手绘体识别设备，其中所述附件在两维范围中有效地相关第一和第二手绘体输出。57.按照权利要求50的手绘体识别设备，其中所述附件在时间范畴有效地相关第一和第二手绘体输出。58.一种手绘体识别方法，包括使用至少一个位于手持的绘画工具上的加速度计和至少一个附加的检测器，产生第一和第二手绘体输出；组合该第一和第二手绘体输出，提供增加性能的手绘体输出；和使用怕述增强性能的手绘体输出；提供代表该手绘体的形状的输出指示。59.按照权利要求20的手写体识别设备，其中所述至少一个加速度计是可多种形式安装在笔上的。60.按照权利要求58的方法，其中所述第一和第二手写体检测器中的至少一个是有效地检测书写工具的位置。61.按照权利要求58的方法，其中组合包括在两维范围中相关所述第一和第二手绘体输出。62.按照权利要求58的方法，其中组合包括在时间范围相关所述第一和第二手绘体输出。63.按照权利要求33的手绘体识别设备，其中所述输入装置包括光识别装置。64.按照权利要求63的手绘体识别设备，其中所述形状识别装置包括组合光字符识别和加速处理装置，该装置在识别形状中组合来自所述光字符识别装置和所述至少一个加速度计的输入。65.按照权利要求64的手绘体识别设备，其所述形状识别装置包括第一识别信道，用于来自所述光字符识别装置的输入，提供代表形状识别的第一输出，第二识别信道，用于来自所述至少一个加速度计的输入，提供代表形状识别的第二输出，和形状选择装置，用于根据预定的准则在第一和第二输出之间进行选择。全文摘要手写体识别设备包括使用至少两种不同检测技术检测手写体的手写体输入装置和接收该手写体输入装置的输出提供代表该手写体的符号输出指示的符号识别装置。文档编号G06F3/033GK1128380SQ9510140公开日1996年8月7日申请日期1995年2月5日优先权日1994年2月4日发明者埃赫德·巴罗,亚历山大·普丽赤文,泽福·巴-依特查卡,维克多·科塞斯凯申请人:巴罗技术有限公司