CN1128380A - 利用多种传感技术的手写输入设备 - Google Patents
利用多种传感技术的手写输入设备 Download PDFInfo
- Publication number
- CN1128380A CN1128380A CN95101407A CN95101407A CN1128380A CN 1128380 A CN1128380 A CN 1128380A CN 95101407 A CN95101407 A CN 95101407A CN 95101407 A CN95101407 A CN 95101407A CN 1128380 A CN1128380 A CN 1128380A
- Authority
- CN
- China
- Prior art keywords
- num
- arr
- count
- int
- freehandhand
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06V—IMAGE OR VIDEO RECOGNITION OR UNDERSTANDING
- G06V30/00—Character recognition; Recognising digital ink; Document-oriented image-based pattern recognition
- G06V30/10—Character recognition
- G06V30/32—Digital ink
- G06V30/36—Matching; Classification
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06V—IMAGE OR VIDEO RECOGNITION OR UNDERSTANDING
- G06V30/00—Character recognition; Recognising digital ink; Document-oriented image-based pattern recognition
- G06V30/10—Character recognition
- G06V30/14—Image acquisition
- G06V30/142—Image acquisition using hand-held instruments; Constructional details of the instruments
- G06V30/1423—Image acquisition using hand-held instruments; Constructional details of the instruments the instrument generating sequences of position coordinates corresponding to handwriting
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06V—IMAGE OR VIDEO RECOGNITION OR UNDERSTANDING
- G06V30/00—Character recognition; Recognising digital ink; Document-oriented image-based pattern recognition
- G06V30/10—Character recognition
- G06V30/32—Digital ink
- G06V30/36—Matching; Classification
- G06V30/373—Matching; Classification using a special pattern or subpattern alphabet
Abstract
手写体识别设备包括使用至少两种不同检测技术检测手写体的手写体输入装置和接收该手写体输入装置的输出提供代表该手写体的符号输出指示的符号识别装置。
Description
本发明一般地讲涉及计算机输入设备，特别是涉及手写体识别计算机输入设备。
在联机手写体识别领域中存在着大量的活动。直到1990年的现有技术(在1990年8月的IEEE的图形分析与机器智能论文集第12卷第8期)Charles C.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，地址为1701McCarthy Blvd.，Milpitas，CA95035。另一方案，笔10可包括多个加速度计，这些加速度计可以是也可以不是正交地放置的。
笔10还包括一个或几个加大器30，与一个或几个加速度计25相连。图2A是适于在本申请中使用的放大器30的优选实施例的示意图。
另一方案，笔10可以与包括如上所述的一个或几个加速计25的可改型装置装配在一起，而且如上所述还包括相连的放大器30。该装置可具有固定笔10端部的一个帽。包围该笔的一个环的形式，或者任何其它合适的形式。
图形输入板12检测笔10的笔尖相对于图形输入板12的位置并且提供表示该位置的数据的数字化输出。图形输入板12可以是任何合适的图形输入板，诸如从WACOM Com-puter System GmbH公司实到的型号SD-510C的Wacom图形输入板处理器，公司的地址为德国Hellersbergstrasse 4，W-4040 Neuss 1。
从笔10中的一个或几个加速度计获得的数据在这里称为“加速度计数据”。加速度计数据和从图形输入板12来的地点数据分别通过分开的电缆发送到控制电路40。可替代的方案如，该加速度计数据和地点数据可通过单条电缆发送。根据又一个替代方案，该加速度计数据和地点数据可通过任何类型的合适的通信链路如超声波、红外线或者利用任何其它合适的手段发送。
控制电路40放大从笔10来的加速度信号并且将它们变换为数字形式，最好使用模数变换器。图2B是适于在本申请中使用的模数变换器优选实施例的示意图。
然后控制电路40发送组合的同步的加速度数据与位置数据到一个加速度计与位置数据处理器50。数据处理器50可以是任何合适的计算机，例如具有80386处理器芯片的IBM PC兼容计算机。
与数据处理器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，可从美国Analog Devices公司买到。
控制电路90还包括与多个超声波接收机85操作操作地相连的多个数字计数器。一个合适的计数器是型号74HCT4040，可从德国RCA GMGH公司买到。控制电路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.W parks和C.S Burrus所著，由John Wiley&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数据滤波器滤波，该滤波器在由John Wiley & 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座标。在上面规定的WaCom Tablet处理器的情况下，工作状态可能是指示为“笔提起”，“笔向下”或“笔接近出了输入板”该组合数据还最好包括相应于单个图形输入板数据点的加速计数据点的平均值。笔10的状态可从图形输入板12发送的信号导出，或通过与笔10的笔尖相连的工作开关，正如步骤212的描述的，或通过其它方法导出笔10的状态。
步骤212：辨别笔表面接触终止。来自步骤210的数据可不包括笔10表面接触状态。在这种情况下，笔10的表面接触状态可从加速度数据中导出。该加速度数据被滤波以去除了噪声之外的分量。例如，加速度数据由Butter Worth数字滤波器滤波，该滤波器在由John Wiley&Sons于1987年出版的T.W.Parks和C.S Burrus所著的“数字滤波器设计”第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可包括一个电磁笔，例如型号为WACOM SP-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，诸如一个LogitechScan Man 256型扫描器。用户用笔在书写表面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上书写过的正文。
步骤790：OCR教导过程。对于在正文中的每个符号，识别对应于书写在表面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，其中：
附录A 23页
附录B 113页
附录C 7页
附录D 6页
附录E 7页
附录A
根据复合信号的识别定义和数据结构
Board.H file
/*Function init_datatr(portbase)sets communication with data
translation board via port portbase.It returns：
0-communication was established；
-1-error on board(board is not exist).*/
∥int init_datatr(int)；
int newcomp(void)；
int read_ch(int channel，int gain)；
∥int read_point(struct point*，int)；
/*int read_block(struct point*，int max_numb_point，
int timeout_for_begin，int timeout_for_end，
int key_mouse_stop)；*/
∥int read_symbol(struct point*，int，int)；
int mshit(void)；
void close_datatr(void)；
#define PORT_BASE 0×210
#define KEY_STOP 0×1
#define MOUSE_STOP 0×2
#define KEY_MOUSE_STOP 0×3
#define PEN_WAIT 0×1
#define PEN_NOWAIT 0×0
Data.H file
struct point_pen
{
unsigned ax；
unsigned ay；
unsigned az；
unsigned pn；
}；
struct point_tablet
{
int x；
int y；
int p；
}；
#define SYNCROBIT 0×80
<dp n="d42"/>
Datar.H file
#define PORT_BASE 0×210
#define CSR 0×0
#define GAIN 0×1
#define DAC0_LOW 0×2
#define DAC0_HIGH 0×3
#define DAC1_LOW 0×4
#define DAC1_HIGH 0×5
#define CHANNEL_AX 0×4
#define CHANNEL_AY 0×5
#define CHANNEL_AZ 0×6
#define CHANNEL_PN 0×7
#define STATUS 0×e
#define CHANNEL_EMPTY 0×0
#define IDREGISTER 0×f
#define GAIN_1 0×00
#define GAIN_2 0×40
#define GAIN_4 0×80
#define GAIN_8 0×C0
#define IER 0×21
#define IIR 0×20
#define IRQ0 0×08
#define IRQ1 0×09
#define IRQ2 0×0a
#define IRQ3 0×0b
#define IRQ4 0×0c
#define IRQ5 0×0d
#define IRQ6 0×0e
#define IRQ7 0×0f
/*struct point {
unsigned ax；
unsigned ay；
unsigned az；
unsigned pn；
}；*/
#define MINUS_PEN 1700
/*#define PEN_UP 0×2
#define PEN_DOWN 0×4
#define PEN_THRSLD 200
#define EMPTY 0 */
#define BUFSIZE 0×80
#define TIME_COUNT 3000
#include＜dos.h＞
<dp n="d43"/>
Ser.H file
/*----------------------------------------------------------------------*
文件名 SERIAL.H
SER.C使用的一些定义
*----------------------------------------------------------------------*/
#define COM1 1
#define COM2 2
#define COM1BASE 0×3F8/*Base port address for COM1*/
#define COM2BASE 0×2F8/*Base port address for COM2*/
/*
8250UART有10个；通过7端口地址可存取的寄存器，这里是关于COMIBASE和
COM2BASE的地址。注意波特率寄存器。只有当DLAB是开启时，DLL和DLH
激活。DLAB是LCR的比特7。
TXR到串行端口的输出数据
RXR来自串行端口的输入数据
LCR初始化串行端口
LER控制中断产生
IIR识别中断
MCR送控制信号到调制解调器
LSR监视串行端口的状态
MSR接收调制解调器的状态
DLL波特率除数的低字节
DHH波特率除数的高字节
*/
#define TXR 0 /* Transmit register(WRITE)*/
#define RXR 0 /* Receive register(READ)*/
#define IER 1 /* Interrupt Enable */
#define IIR 2 /* Interrupt ID */
#define LCR 3 /* Line control */
#define MCR 4 /* Modem control */
#define LSR 5 /* Line Status */
#define MSR 6 /* Modem Status */
#define DLL 0 /* Divisor Latch Low */
#define DLH 1 /* Divisor latch High */
/*------------------------------------------------------------------*
LCR中的比特值
bit 意义
--- -------
0-1 00＝5 bits，01＝6 bits，10＝7 bits.11＝8 bits.
2 Stop bits.
3 0＝parity off，1＝parity on.
4 0＝parity odd，1＝parity even.
5 Sticky parity.
6 Set break.
7 Toggie port addresses.
*-------------------------------------------------------------------*/
#define NO_PARITY 0×00
#define EVEN_PARITY 0×13
#define ODD_PARITY 0×03
<dp n="d44"/>
/*-------------------------------------------------------------------*
LSR中的比特值
bit 意义
--- -------
0 Data ready.
1 Overrun error-Data register overwritten.
2 Parity error-bad transmission.
3 Framing error-No stop bit was found.
4 Break detect-End to transmission requested.
5 Transmitter holding register is empty.
6 Transmitter shift register is empty.
7 Time out-off line.
*-------------------------------------------------------------------*/
#define RCVRDY 0×01
#define OVRERR 0×02
#define PRTYERR 0×04
#define FRMERR 0×08
#define BRKERR 0×10
#define XMTRDY 0×20
#define XMTRSR 0×40
#define TIMEOUT 0×80
/*-------------------------------------------------------------------*
MCR中的比特值
bit 意义
--- -------
0 Data Terminal Ready.Computer ready to go.
1 Request To Send.Computer wants to send data.
2 auxillary output #1.
3 auxillary output #2.(Note；This bit must be
set to allow the communications card to send
interrupts to the system)
4 UART ouput looped back as input.
5-7 not used.
*------------------------------------------------------------------*/
#define DTR 0×01
#define RTS 0×02
#define MC_INT 0×08
/*------------------------------------------------------------------*
MSR中的比特值
bit 意义
--- -------
0 delta Clear To Send.
1 delta Data Set Ready.
2 delta Ring lndicator.
3 delta Data Carrier Detect.
4 Clear To Send.
5 Data Set Ready.
6 Ring Indicator.
7 Data Carrier Detect.
*------------------------------------------------------------------*/
#define CTS 0×10
#define DSR 0×20
<dp n="d45"/>
/*-------------------------------------------------------------------*
IER中的比特值
bit 意义
--- -------
0 Interrupt when data received.
1 Interrupt when transmitter holding reg.empty.
2 Interrupt when data reception error.
3 Interrupt when change in modem status register.
4-7 Not used.
*-------------------------------------------------------------------*/
#define RX_INT 0×01
/*-------------------------------------------------------------------*
IIR中的比特值
bit 意义
--- -------
0 Interrupt pending
1-2 Interrupt ID code
00＝Change in modem status register，
01＝Transmitter holding register empty.
10＝Data received，
11＝reception error，or break encountered.
3-7 Not used.
*-------------------------------------------------------------------*/
#define RX_ID 0×04
#define RX_MASK 0×07
/*
这是8259可编程中断控制器(PIC)的端口地址
*/
#define IMR 0×21/*Interrupt Mask Register port*/
#define ICR 0×20/*Interrupt Control Port */
/*
当硬件中断结束时，中断末端要送到8259的控制端口
*/
#define EOI 0×20/*End Of Interrupt*/
/*
当PIC不显示出(FALSE)时，IMR告诉PIC服务于中断
*/
#define IRQ3 0×F7/*COM2*/
#define IRQ4 0×EF/*COM1*/
当PIC不显示出(FALSE)时，IMR告诉PIC服务于中断
*/
#define IRQ3 0×F7/*COM2*/
#define IRQ4 0×EF/*COM1*/
<dp n="d46"/>
int flag；
int SetSerial()；
int SetOthers(int Parity，int Sits，int StopBit)；
int SetSpeed(int Speed)；
int SetPort(int Port)；
void init_serial(void)；
void comm_off(void)；
void setallport(int Port，int Speed，int Parity，int Bits，int StopBit)；
int putchport(char)；
void putstrport(char*)；
int getchport(void)；
void offport()；
Serconst.H file
/*-------------------------------------------------------------------*
文件名 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波特率除数的高字节
*/
#define TXR 0 /* Transmit register(WRITE)*/
#define RXR 0 /* Receive register(READ)*/
#define IER 1 /* Interrupt Enable */
#define IIR 2 /* Interrupt ID */
#define LCR 3 /* Line control */
#define MCR 4 /* Modem control */
#define LSR 5 /* Line Status */
#define MSR 6 /* Modem Status */
#define DLL 0 /* Divisor Latch Low */
#define DLH 1 /* Divisor latch High */
#define DLAB 0×80 /**/
/*--------------------------------------------------------------------------*
Bit values held in the Line Control Register(LCR)
bit meaning
--- -------
<dp n="d47"/>
0-1 00＝5 bits，01＝6 bits，10＝7 bits，11-8 bits.
2 Stop bits.
3 0＝parity off，1＝parity on.
4 0＝parity odd，1＝parity even.
5 Sticky parity.
6 Set break.
7 Toggle port addresses.
*-------------------------------------------------------------------*/
#define NO_PARITY 0×00
#define EVEN_PARITY 0×18
#define ODD_PARITY 0×08
/*-------------------------------------------------------------------*
Bit values held in the Line Status Register(LSR)
bit meaning
--- -------
0 Data ready.
1 Overrun error-Data register overwritten.
2 Parity error-bad transmission.
3 Framing error-No stop bit was found.
4 Break detect-End to transmission requested.
5 Transmitter holding register is empty.
6 Transmitter shift register is empty.
7 Time out-off line.
*------------------------------------------------------------------*/
#define RCVRDY 0×01
#define OVRERR 0×02
#define PRTYERR 0×04
#define FRMERR 0×08
#define BRKERR 0×10
#define XMTRDY 0×20
#define XMTRSR 0×40
#define TIMEOUT 0×80
/*------------------------------------------------------------------*
Bit values held in the Modem Output Control Register(MCR).
bit meaning
--- -------
0 Data Terminal Ready.Computer ready to go.
1 Request To Send.Computer wants to send data.
2 auxillary output #1.
3 auxillary output #2.(Note：This bit must be
set to allow the comunications card to send
interrupts to the system)
4 UART ouput tooped back as input.
5-7 not used.
*-----------------------------------------------------------------*/
#define DTR 0×01
#define RTS 0×02
#define MC_INT 0×08
/*----------------------------------------------------------------*
Bit values held in the Modem Input Status Register(MSR)
bit meaning
<dp n="d48"/>
0 delta Clear To Send.
1 delta Data Set Ready.
2 delta Ring Indicator.
3 delta Data Carrier Detect.
4 Clear To Send.
5 Data Set Ready.
6 Ring Indicator.
7 Data Carrier Detect.
*------------------------------------------------------------------*/
#define CTS 0×10
#define DSR 0×20
/*------------------------------------------------------------------*
Bit values held in the Interrupt Enable Register(IER)
bit meaning
--- -------
0 Interrupt when data received.
1 Interrupt when transmitter holding reg.empty.
2 Interrupt when data reception error.
3 Interrupt when change in modem status register.
4-7 Not used.
/*------------------------------------------------------------------*
#define RX_INT 0×01
/*------------------------------------------------------------------*
Bit values held in the Interrupt Identification Register(IIR).
bit meaning
--- -------
0 Interrupt pending
1-2 Interrupt ID code
00＝Change in modem status register，
01＝Transmitter holding register empty，
10＝Data received，
11＝reception error，or break encountered.
3-7 Not used.
*------------------------------------------------------------------*/
#define RX_ID 0×04
#define RX_MASK 0×07
/*
这是8259可编程中断控制器(PIC)的端口地址
*/
#define IMR 0×21 /* Interrupt Mask Register port*/
#define ICR 0×20 /* Interrupt Control Port */
/*
当硬件中断结束时，中断末端要送到8259的控制端口
*/
#define EOI 0×20 /* End Of Interrupt*/
/*
<dp n="d49"/>
当PIC不显示出(FALSE)时，IMR告诉PIC服务于中断
*/
/*unsigned char IRQ[8]＝{-0×01，-0×02，-0×04，-0×80，
-0×10，-0×*/
#define IRQ3 0×F7 /* COM2*/
#define IRQ4 0×EF /* COM1*/
int SerSetPortBase(int，unsigned*)；
int SerSetSpeed(unsigned，long)；
int SerSetBitsParityStopBit(unsigned，int，int，int)；
int SerPutChar(unsigned，unsigned char)；
int SerPutString(unsigned，unsigned char*)；
int SerInitBuffer(unsigned)；
int SerGetChar(unsigned)；
int SerTestDSR(unsigned)；
int SerTestCTS(unsigned)；
/* int flag；
int SetSerial()；
int SetOthers(int Parity，int Bits，int StopBit)；
int SetSpeed(int Speed)；
int SetPort(int Port)；
void init_serial(void)；
void comm_off(void)；
void setallport(int Port，int Speed，int Parity，int Bits，int StopBit)；
int putchport(char)；
void putstrport(char*)；
int getchport(void)；
void offport()；
*/
Tablet.H file
#define PEN_DOWN 1
#define PEN_UP 0
#define PEN_OUTPROX 99
#define TBL_WACOM_II 3
#define TBL_DATA_ASCII 1
#define TBL_DATA_BINARY 0
#define TBL_MODE_STREAM 3
#define TBL_MODE_SWITCH_STREAM 2
#define TBL_MODE_SUPRESSED 0
#define TBL_MODE_POINT 0
#define TBL_TYPE_ABSOLUTE 0
#define TBL_TYPE_RELATIVE 1
#define TBL_MILLIMETERS 0
#define TBL_INCHES 1
#define TBL_ALWAYS_TRANSMIT_YES 1
#define TBL_ALWAYS_TRANSMIT_NO 0
#define TBL_BAUD_19200 7
#define TBL_BAUD_9600 6
#define TBL_BAUD_4800 5
#define TBL_BAUD_2400 4
#define TBL_BAUD_1200 3
#define TBL_BAUD_600 2
#define TBL_BAUD_300 1
<dp n="d50"/>
#define TBL_BAUD_150 0
#define TBL_PARITY_NONE 0
#define TBL_PARITY_ODD 1
#define TBL_PARITY_EVEN 2
#define TBL_STOPBITS_1 0
#define TBL_STOPBITS_2 1
#define TBL_DSR_MONITOR_OFF 0
#define TBL_DSR_MONITOR_ON 1
#define TBL_DATALENGTH_7 0
#define TBL_DATALENGTH_8 1
#define TBL_TRANSFER_RATE_MAX 7
#define TBL_TRANSFER_RATE_100 6
#define TBL_TRANSFER_RATE_67 5
#define TBL_TRANSFER_RATE_50 4
#define TBL_TRANSFER_RATE_20 3
#define TBL_TRANSFER_RATE_10 2
#define TBL_TRANSFER_RATE_5 1
#define TBL_TRANSFER_RATE_1 0
#define TBL_ORIGINLOG_UPPER_LEFT 1
#define TBL_ORIGINLOG_LOWER_LEFT 0
#define TBL_DATA_TERMINATOR_CR_LF 2
#define TBL_DATA_TERMINATOR_LF 1
#define TBL_DATA_TERMINATOR_CR 0
int read_point_tablet_pen(unsigned，int，
struct point_tablet*，struct point_pen*[8])；
int find_set_parameters_tablet(int comport，unsigned*portbase)；
int init_tablet(int port，unsigned*portbase，int command_set，
int data_format，int operation_mode，int origin_type，
int unit_mesure，int always_transmit，int speed，
int parity，int stopbit，int dsr_monitor，
int datalength，int transfer_rate，int orig_log，
int data_terminator，int max_x，int max_y)；
void close_tablet(unsiqned portbase)；
I.从装置中读出
/* 这个程序同步地从图形书写板和加速度计中读数据
int read_point_tablet_pen(unsigned portbase，int read_pen，
struct point_tablet*tablet，
struct point_pen pen[8])
{
int ind_package＝0，reply，debug[10]，i；
unsigned char package[7]＝{0，0，0，0，0，0，0)；
if(read_pen)
read_point_pen(&pen[0])；
i＝0；
/* Waiting for synchro-bit*/
do
{
if((reply＝SerGetChar(portbase))＜0)
return reply；
debug[i++]＝reply；
if((package[0]＝(char)reply)&SYNCROBIT)
break；
}while(ind_package++＜10)；
/*Error-No synchro-bit in 10 bytes*/
if(ind_package＞＝10)
return SER_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)
return reply；
package[ind_package]＝(char)reply；
}
/*读加速度计中最后的点 */
if(read_pen)
read_point_pen(&pen[ind_package])；
/*计算书写板的信号值 */
tablet-＞x＝(package[0]&0×03)＜＜14；
tablet-＞x+＝(package[1]&0×7f)＜＜7；
tablet-＞x+＝(package[2]&0×7f)；
if(package[0]&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)；
<dp n="d52"/>
tablet-＞p＝0；
if(！(package[0]&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)；
return 0；
}
II.预处理
/* Two procedures：Normalization in time and filtering the input signals by smoothing
*/
void normal(int num_old，float arr_old[]，int num_new，float arr_new[])
{
double koeff；
int ind_old，ind_new；
koeff＝(double)(num_old-1)/(float)(num_new-1)；
arr_new[0]＝arr_old[0]；
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]；
}
float smooth1(int num，float z[])
{
int ind；
float temp；
float norma；
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；
}
return norma；
}
III.参数提取
/* 根据输入入信号计算一个符号的参数。 */
int make_par(char arg_ch)
{
struct point{
unsigned int x：12；
unsigned int y：12；
unsigned int z：12；
unsigned int pen：4；
}point，points[500]；
int read_next_symbol(FILE*，struct point[])；
char file_name[40]；
int len，number_points＝0；
FILE*in_file，*out_file[10]，*out_letter，*out_bin；
float param[6][NUMBER_POINT]，sum_par[6][NUMBER_POINT]；
int index＝0，max_point；
int ind，start；
int cur_x，cur_y，cur_z，cur_p；
float arr_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[0]＝arr_p[max_point-1]＝1；
start++；
number_points+＝max_point；
/*调用Make_par_let程序计算参数1-6
make_par_let(arr_x，arr_y，arr_z，arr_p，param，max_point-1.
<dp n="d54"/>
/*计算每个参数的平均值 */
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[0][0]＝(float)number_points/start；
fclose(in_file)；
/* write avg in Binary file*/
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)；
return start；
}
void make_par_let(float arr_x[]，float arr_y[]，float arr_z[]，
float arr_p[]，fioat param[6][NUMBER_POINT]，int max_point)
{
float end_smooth；
float new_arr_x[500]，new_arr_y[500]，new_arr_z[500]，new_arr_p[500]；
int ind，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)；
/*lnitialization of parameters*/
param[0][0]＝(float)arr_p[0]：
param[1][0]＝(arr_z[0]-arr_z[0]);
param[2][0]＝0.0；
param[3][0]＝0.0；
param[4][0]＝0.0;
param[5][0]＝0.0；
<dp n="d55"/>
param[0][1]＝(float)arr_p[1]：
/* Calculation of parameters*/
param[1][1]＝(arr_z[1]-arr_z[0])；
elev(arr_x[2]-arr_x[0]，arr_y[2]-arr_y[0]，arr_z[2]-arr_z[0]，
&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[0][index]＝(float)arr_p[index]；
param[1][index]＝(arr_z[index]-arr_z[0])；
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[0][index]＝(float)arr_p[index]；
param[1][index]＝(arr_z[index]-arr_z[0])；
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++；
/* Calculation of parameters for last point*/
param[0][index]＝(float)arr_p[index]；
param[1][index]＝(arr_z[index]-arr_z[0])；
param[2][index]＝0.0；
param[3][index]＝0.0；
param[4][index]＝0.0；
param[5][index]＝0.0；
/*该程序用于计算上升角的正弦和余弦 */
void elev(float x，float y，float z，float*cos_ug，float*sin_ug)
{
float norma；
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；
}
/*该程序计算β角的正弦和余弦 */ void angles(float x1，float y1，float z1，float x2，float y2，float z2， float*cos_ug，float*sin_ug) { float norma1，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.训练程序
/*初级教导程序 **/
int first_teach(void)
{
FILE*fp；
FILE*fpout；
int i；
char buf[4]，NdxStr[4]，symbols[256]；
int ndx＝0，max_symb＝0：
int num_sym；
comment(＂converting data files，please wait＂，0，1)；
if((fp＝fopen(＂symbols.dat”，＂r＂))＝＝NULL)
{
strcpy(ext_err，＂symbols.dat＂)；
hide_comment(＂converting data files，please wait＂，0)；
return(-4)；
}
while(fscanf(fp，＂％s＂，buf)＞0)
symbols[max_symb++]＝buf[0]；
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(＂converting data files，please wait＂，0)；
return(num_sym)；
}
else for(i＝0；i＜num_sym；i++)
fprintf(fpout，＂％c＂，symbols[ndx])；
}
fclose(fpout)；
hide_comment(＂converting datafiles，please wait＂，0)；
return(0)；
}
/*适用的原型的程序 */
float huge*all_par[100]；
int first_adap(void)
{
float old_rec，new_rec；
int count＝0，temp；
char*text；
char str[80]；
if((temp＝read_text(＂try.txt＂，&text))＜0)
return(temp)
read_param()；
new_rec＝recogn(＂try.prl，text，0，0)；
sprintf(str，＂％3f-before adaptation＂，new_rec)；
comment(str，-1，1)；
do{
<dp n="d58"/>
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-in adaptation＂，new_rec)；
comment(str，-1，1)；
new_rec＝recogn(＂try.prl＂， text，0，0)；
hide_comment(str，-1)；
sprintf(str，＂％3f-after adaprion”，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++])；
}
return 0；
}
V.符号的识别
struct point(
unsigned int x：12；
unsigned int y：12；
unsigned int z：12；
unsigned int pen：4；
}；
struct reply
{
int ndx；
float weight；
}；
float recogn(char*file_pen，char*text，int adapt，int words)
{
float old_rec，new_rec，probs[10][20]；
int count＝0；
char symbols[256]，buf[4]；
unsigned long ttt；
int max_symb；
FILE*in_file，*file_symb，*temp_word；
int symb；
unsigned long start_word，end_word；
float param[6][NUMBER_POINT]；
int index＝0，max_point；
struct reply*repl；
int temp；
int Ngood＝0；
int ind，NumSymbols，ndx；
struct point symb_pnts[MAX_POINT]；
float arr_x[MAX_POINT]，arr_y[MAX_POINT]，arr_z[MAX_POINT]，arr_p[MAX_POINT]；
int map[256]；
int order＝0；
char letters[10][20]，dict_wrds[10][20]；
int end_of_word＝0；
int wrdlen；
float sum[10]，maxsum，ndx_maxsum；
char org_wrd[20]，f_word[20]；
int txt_width；
int i；
if((file_symb＝fopen(＂symbols.dat＂，＂r＂))＝＝NULL){
strcpy(ext_err.＂symbols dat＂)；
return(-4)；
}
for(ind＝0；ind＜256；ind++)mad[ind]＝-1；
max_symb＝0；
while(fscanf(file_symb，＂％s＂，buf)＞0)
{
map[buf[0]]＝max_symb；
symbols[max_symb++]＝buf[0]；
}
fclose(file_symb)；
symbols[max_symb]＝0；
for(ind＝0：ind＜6：ind++)
<dp n="d60"/>
for(index＝0：index＜NUMBER_POINT；index++){
param[ind][index]＝0.0；
}
if((in_file＝fopen(file_pen，＂rb＂))＝＝NULL)
{
strcpy(ext_err，file_pen)；
return-4；
}
index＝0：
NumSymbols＝0；
symb＝-1；
if(adapt)
repl＝make_corr(param，symbols，symb)；
else{
repl＝make_corr(param，symbols，-1)；
}
if(repl[0].ndx＜0)
return(repl[0].weight)；
if(repl[0].ndx＝＝symb)
Ngood++；
else
Ngood＝Ngood；
}
fclose(in_file)；
if(NumSymbols＝＝0)return 0；
else return(Ngood/(float)NumSymbols)；
}
/*计算所有原型及所识别符号的所有特征的相似性*/
extern float huge*all_par[100]；
struct reply
{
int ndx；
float weight；
}；
static int comm_count＝0，abs_count＝0；
int obj_funct(float[100][7]，int，int，float[100]，float[7]，int[10])；
float correl_hem(float[NUMBER_POINT]，float[NUMBER_POINT]，float)；
float correl(float[NUMBER_POINT]，float[NUMBER_POINT])；
struct reply*make_corr(fioat cur_par[6][NUMBER_POINT]，char*symbols，int symb)
{
FILE*cur_file；
int ind_repl，ind_corrct，ind，max_symb，ind_symb，index；
struct reply arr_repl[30]；
int arr_ind[10]；
float res[100].nres[7].old_max_pnt＝cur_par[0][0]，com_wight；
float old_max_pnt2，corr[100][7].tmp_par[6][NUMBER_POINT]；
char buf[8]；
int iterat；
struct reply rt；
int i，j；
<dp n="d61"/>
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][0]＞0){
cur_par[0][0]＝old_max_pnt；
corr[ind_symb][N_PAR-1]＝1.0*(1-
min(fabs(tmp_par[0][0]-cur_par[0][0])/cur_par[0][0]，1))；
old_max_pnt＝cur_par[0][0]；
tmp_par[0][0]＝1.；
cur_par[0][0]＝1.；
corr[ind_symb][0]＝correl_hem(cur_par[0]，tmp_par[0]，.9)；
for(ind＝1；ind＜N_PAR-1；ind++){
corr[ind_symb][ind]＝correl(cur_par[ind]，tmp_par[ind])；
}
}
else
for(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[0]！＝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[0][0]＝tmp_par[0][0]*9+old_max_pnt*.1；
}
if(lind_corrct){
iterat＝20；
break；
}
<dp n="d62"/>
iterat++；
cur_par[0][0]＝old_max_pnt；
corr[symb][N_PAR-1]＝1-fabs(tmp_par[0][0]-cur_par[0][0])/cur_par[0][0]；
old_max_pnt＝cur_par[0][0]；
old_max_pnt2＝tmp_par[0][0]；
tmp_par[0][0]＝1.；
cur_par[0][0]＝1.；
corr[symb][0]＝correl_hem(cur_Par[0]，tmp_par[0]，.9)；
for(ind＝1；ind＜N_PAR-1；ind++){
corr[symb][ind]＝correl(cur_par[ind]，tmp_par[ind])；
}
cur_par[0][0]＝old_max_pnt；
tmp_par[0][0][0]＝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]]；
}
return arr_repl；
}
/*计算两个矢量之间的相关性 */
float correl(float first[NUMBER_POINT]，float second[NUMBER_POINT])
{
float sumxy＝0.0，sumx＝0.0，sumy＝0.0，sumx2＝0.0，sumy2＝0.0；
int i_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)
return 0；
if((sumxy＝(sumxy-sumx*sumy/NUMBER_POINT)/
<dp n="d63"/>
sqrt(sumx2-sumx*sumx/NUMBER_POINT)/
sqrt(sumy2-sumy*sumy/NUMBER_PCINT))＜.5)
return 0；
return sumxy；
}
/*笔向上/向下参数的相似性函数 */
float correl_hem(float par1[NUMBER_POINT]，float par2[NUMBER_POINT]，float border)
{
int index；
float result＝0.0；
for(index＝1；index＜NUMBER_POINT；index++)
result+＝fabs(par1[index]-par2[index])；
result/＝NUMBER_POINT；
result＝1-result；
if(result＜border)
return 0；
return result；
}
/*选择可能被识别的符合表 */
int obj_funct(float arr[100][7]，int n_symb，int n_par，
float res[100]，float nres[7]，int arrrindex[30])
{
int ind_s，ind_p，ind_arr＝0；
float max_res＝0.0，cur_res，abs_res＝0.0；
int result＝-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])
return ind_arr；
}
附录B
根据第二种方法的识别
图形书写板识别
I.开始
oid main(void)
void init_map(void)；
int i，j；
for(i＝0；i＜NUM_SYMBOLS；i++)
for(j＝0；j＜2；j++)
map_char[i][j]＝0；
init_map()；
extem int map_char[NUM_SYMBOLS][2]；
oid save_map(void)
FILE*fp；
int i；
fp＝fopen(＂map_ch＂，＂wb＂)；
for(i＝0；i＜NUM_SYMBOLS；i++)
fprintf(fp，＂％d％d\n＂，map_char[i][0]，map_char[i][1])；
fclose(fp)；
oid init_map(void)
int i，j；
for (i＝97，j＝0；i＜123；j++，i++)
{map_char[j][0]＝i； ∥a-z
map_char[j][1]＝0；
}
for(i＝65，j＝26；i＜91；j++，i++)
{map_char[j][0]＝i； ∥A-Z
map_har[j][1]＝0；
}
for(i＝48，j＝52；i＜58；j++，i++)
{map_char[j][0]＝i；
map_char[j][1]＝0； ∥0123456789
}
for(i＝43，j＝62；i＜47；j++，i++)
{map_char[j][0]＝i
<dp n="d65"/>
pr＝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)；
}
/***************************************************************
function ord_1_lig1() defines one order right up strokes from the
begining of right up strokes in the arr_extremoms[]，records one
order right up stroke’s parameters to ARR_ORD_1_LIG1[]according
to his number and labels MASK penn.
***************************************************************/
int ord_1_lig1(nt num_of_extmns，int num_lig1)
{ int pr，num_lig，num_pns，count，num_str；
unsigned temp；
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_cor
ARR_ORD_1_LIG1[num_lig].y_beg＝arr_extremoms[num_str+1].y_cor
ARR_ORD_1_LIG1[num_lig].pns_end＝num_str；
II.训练过程
/* 用于教导的主程序 */
struct TABLE_EXTREMOMS arr_extremoms[MAX_NUM_OF_EXTREMOMS]；
struct POINT arr_cor[MAX_NUM_OF_POINTS]；
struct LIN ARR_DIR[MAX_AMOUNT_DIREC]；
struct LIG ARR_LIGAT[MAX_AMOUNT_DIREC]；
struct LIG ARR_ORD_1_LIGAT[MAX_AMOUNT_DIREC]；
struct LIG ARR_LIG1[MAX_AMOUNT_DIREC]；
struct LIG ARR_ORD_1_LIG1[MAX_AMOUNT_DIREC]；
struct LIG ARR_LIG2[MAX_AMOUNT_DIREC]；
struct LIG ARR_ORD_1_LIG2[MAX_AMOUNT_DIREC]；
struct LIG ARR_LIG3[MAX_AMOUNT_DIREC]；
struct LIG ARR_ORD_1_LIG3[MAX_AMOUNT_DIREC]；
struct MASK penn[MAX_NUM_OF_EXTREMOMS]；
char our_sent[MAX_LENGTH_SENTENSE]；
struct X x[MAX_AMOUNT_DIREC]；
struct Y y[MAX_AMOUNT_DIREC]；
int map_char[NUM_SYMBOLS][2]；
int amp_y；
int num_of_extrms；
float y_vec_beg；
float y_vec_end；
float x_vec_beg；
float x_vec_end；
void main(int arg，char*par[])
{
FILE*fp；
char infile[30]；
int num；
struct ffblk ffblk；
int done；
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)；
<dp n="d67"/>
num＝1；
while(ldone)
{
sprintf(infile，＂％-12.12s＂，ffblk.ff_name)；
fp＝fopen(infile，＂r＂)；
if(lfp)
{printf(＂Can’t open input file-％s-\n＂，infile)；
return；
}
if(infile[0]！＝′B′)letter＝tolower(infile[0])；
else
{if(isdigit((int)infile[1])！＝0)lefter＝tolower(infile[0])；
else letter＝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()；
}
int transform(FILE*fp，char*letter)
{
extern struct POINT arr_cor[MAX_NUM_OF_POINTS]；/*array of coordinates*/
extern struct TABLE_EXTREMOMS arr_extremoms[MAX_NUM_OF_EXTREMOMS]；
/*array of special points(i.e.extremums，changing of pen
position*/
extern struct TABLE_EXTREMOMS arr_exc_extrms[MAX_NUM_OF_EXTREMOMS]；
/*array of excluded extremums，it is excluded from the array
of extremums by excluding close points*/
extern struct LIN ARR_DIR[MAX_AMOUNT_DIREC]；
extern struct LIN ARR_DIR[MAX_AMOUNT_DIREC]；
extern struct LIG ARR_LIGAT[MAX_AMOUNT_DIREC]；
extern struct LIG ARR_ORD_1_LIGAT[MAX_AMOUNT_DIREC]；
extern struct LIG ARR_LIG1[MAX_AMOUNT_DIREC]；
extern struct LIG ARR_ORD_1_LIG1[MAX_AMOUNT_DIREC]；
extern struct LIG ARR_LIG2[MAX_AMOUNT_DIREC]；
extern struct LIG ARR_ORD_1_LIG2[MAX_AMOUNT_DIREC]；
extern struct LIG ARR_LIG3[MAX_AMOUNT_DIREC]；
extern struct LIG ARR_ORD_1_LIG3[MAX_AMOUNT_DIREC]；
extern struct MASK penn[MAX_NUM_OF_EXTREMOMS]；
extern char our_sent[MAX_LENGTH_SENTENSE]；
extern struct X x[MAX_AMOUNT_DIREC]；
extern struct Y y[MAX_AMOUNT_DIREC]；
extern int amp_y；
extern int num_of_extrms；
int count；
int num；
int num_direc；
float length_of_letter；
int num_ligat_d_r_o；
int num_ord_1_nlgat；
int num_ligat_u_r_i；
<dp n="d68"/>
int num_ord_1_lig1；
int num_ligat_d_l_o；
int num_ord_1_lig3；
int num_ligat_u_l_i；
int num_ord_1_lig2；
int index_max_dir；
int amp_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(＂Input file too huge\n＂)；
getch()；
return(-1)；
}
num_of_extrms＝calc_extremoms(num)；
if(num_of_extrms＞MAX_NUM_OF_EXTREMOMS-1)
{ printf(“Array of extremums too huge\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’s no directions\n＂)；
getch()；
return(0)；
}
index_max_dir＝length_angl(num_direc，ARR_DIR)；
/***************************
filter for long down
****************************/
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’s no directions after conversion and filtr_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’s no directions after conversion filtr_1 and_2\n＂)；
getch()；
return(0)；
}
index_max_dir＝length_angl(num_direc，ARR_DIR)；
}
<dp n="d69"/>
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’s no directions after conversion filtr_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’s no sentense\n”)；
conv_dir_train(num_direc，amp_y，ARR_DIR，x，y)；
return(num_direc)；
}
/*This module is for calculating and manipulating extremums，it includes
three procedures：
(1)calc_extremums ：To find the extremums of the symbol，and the
change in pen”points.
(2)find_max_extrm ：To find the max/min X-coordinate and the
max/min Y-coordinate of the xymbol.
(3)analyse_extremums：A procedureto analyse the extremums found so
far，mainly this procedure marks close extre
-mums as suspecious extremums.
*/
/**************************************************************************
The input of this procedure is the array of coordinates which holds the
coordinates of the symbol，and the number of these points，it fills
the special of points(i.e.，extremums or change in pen)in the array
arr_extremums，it returns the number of special points it found.
***************************************************************************/
struct TABLE_EXTREMOMS extrm[MAX_NUM_OF_EXTREMOMS]：
extern struct POINT arr_cor[MAX_NUM_OF_POINTS]；/*array of coordinates*/
extern struct TABLE_EXTREMOMS arr_extremoms[MAX_NUM_OF_EXTREMOMS]；
/*array of special points (i.e.extremums，changing of pen)
position*/
extern struct TABLE_EXTREMOMS arr_exc_extrms[MAX_NUM_OF_EXTREMOMS]；
/*array of excluded extremums，in is excluded from the array
of extremums by excluding close points*/
struct TABLE_EXTREMOMS arr_exc_extrm[MAX_NUM_OF_EXTREMOMS]；
int calc_extremoms(int num_of_points)
{
int def_quart(int x，int y)；
<dp n="d70"/>
unsigned int indE；
unsigned int nox；
unsigned pen_was_up；
int crnt_quart，prev_quart；
int crnt_rot，prev_rot；
int Sx，Sy，PSx，PSy，a，b；
int first_point＝1；
int Pndx＝0；
unsigned int LastNdx；
int i；
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)
{/*beginning extremom*/
if(first_point＝＝1)
{
int tSx，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{
/*for the previous ENDING extremom*/
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_cor
arr_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)；
{
int PPSx，PPSy；
PPSx＝(arr-cor[Pndx-1].x_cor-arr_cor[Pndx-2].x_cor)；
<dp n="d71"/>
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；
{
int tSx，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))*/
{/*regular extremom*/
if((abs(Sx)＞0)‖(abs(Sy)＞0)‖(b＜0))
{
if((ndx-1-arr_extremoms[indE-1].p_ndx)＞0)
{
<dp n="d72"/>
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；
}* end of while(arr_cor[ndx].penstatus＝＝1)*/
if((pen_was_up＝＝0)&&(arr_cor[ndx-1].pen_status＝＝1))
/*ending extremom*/
Pndx＝ndx-1；
pen_was_up＝1；
LastNdx＝ndx-1；
}
ndx**
}/*ndx\＝NumOfPoints*/
/*Add the last special point to the array*/
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)；
}
<dp n="d73"/>
/***************************************************************************
This procedure is to find the max/min X-coordinate and the max/min
Y-coordinate of the symbol.
***************************************************************************/
void find_max_extrm(int num_of_extrms，
int *Xmin，int *Xmax，int *Ymin，int *Ymax)
{
unsigned int i＝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++；
}
}
/**********************************************************************
correct dir，in_rot，out_rot for suspicious points， called from
analyse_extremums
***********************************************************************/
void correct_extrm (int i，int Pi，int j)
{
int def_quart (int x，int y)；
int Sx，Sy，PSx，PSy；
int ndx1 ，ndx2；
int a，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；
<dp n="d74"/>
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)；
}
}
/******************************************************************
A procedureto analyse the extremums found sofar，mainly this procedure
marks close extremums as suspecious extremums.
********************************************************************
int analyse_extremoms(int num_of_extrms)
{
int i，j＝0；
int count＝0；
int Pi＝0；
boolean FirstP＝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[0].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)
<dp n="d75"/>
{
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)；
}
/*************************************************************
function length_angl() calculates length for the each long down and
returns the number of the long down with the max lengt.
**************************************************************/
int length_angl(int num_lin，struct LIN Z[])
{int count，dy，max_dy，max_length，_max_length，i_max_dy；
float tng；
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*/
else
if((dx＝＝0)&&(dy＜0))tng＝-M_Pl/2；/*-90*/
else
if((dx＝＝0)&&(dy＝＝0))tng＝999999；
else
tng＝atan((float)dy/(float)dx)；
if(tng＜0)tng＝tng+M_PI；/*angle+180*/
Z[count].angle＝tng；
}
return(i_max_dy)
}
<dp n="d76"/>
/***************************************************************
function ampl_y() calculates maximum and minimum of y coordinate
and returns y-amplitude.
***************************************************************/
int ampl_y(int num_of_points，struct POINT arr_cor[])
{int min，max，count.temp；
min＝arr_cor[0].y_cor；
max＝arr_cor[0].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[0].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))；
}
int ampl_x(int num_of_points，strud POINT arr_cor[])
{int min，max，count，temp；
min＝arr_cor[0].x_cor；
max＝arr_cor[0].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[0].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))；
}
/*************************************************************
function conv_dir_train()calculates relative ordinates of letter
skeleton
****************************************************************/
void conv_dir_train(int num_dir.int amp_y，struct LIN Z[]，struct X x[]，
struct Y y[])
{
int count；
int x_min＝9999；
int y_min＝9999；
int x_max＝0；
int y_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；
<dp n="d77"/>
}
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；
}
float letter_length(int num_of_points，struct POINT arr_cor[])
{int i；
double res＝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)；
}
/**
fnction filtr() calculates one’s more stroke’s directions and corrects it
in the array arr extremoms.
**/
void filtr(int num_of_extrm)
{int count，dir；
int def_quart(int x，int y)；
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；
}
}
/**
function filer_1 returns 0，if there wasn’t filtration
corrects the array arr_extremoms[] and returns 1，if there was filtration
filtr_1 takes away a long down，if she is first or last，if there are no
penstrokes before (for the first)or after(for the last long down)and
if relative length of deleted long down is less 0.2.
**/
int fittr_1(float length_of_letter，int num_dir，int num_of_extrm)
/********************************
return 0 there was’t filtration
1 was filtration
*********************************/
{ int temp＝0；
int count；
if(((float)ARR_DIR[0].length/length_of_letter＜TRESH_F1)&&
(ARR_DIR[0].pns_beg＝＝1))
{for(count＝0：count＜＝ARR_DIR[0].pns_end；count++)
arr_extremoms[count].pen_sts＝0；
temp＝1；
}
<dp n="d78"/>
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)；
}
/**
function filr_2 returns 0 if there wasn’t filtration.
corrects array arr_extremoms[]，returns 1，ifthere was filtration.
filtr_2 takes away a one penstroke betweemtwo long down，if
distance x between long down＜＝5 and distance y between long down＜＝2.
**/
int filtr_2(floatlength_of_letter.int num_dir)
{int temp＝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)；
}
/**
function filtr_3 returns 0，ifthere wasn’t filtration.
corrects array arr_extremoms[]，returns，if there was filtration.
takes away long down before stroke with pen up＝＝0，if long down’s
length＜＝0.2 from max length.
**/
int filtr_3(float length_of_letter，int num_dir，int num_of_extrm)
{inttemp＝0，i，m count；
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)；
}
}
}
}
<dp n="d79"/>
return(temp)
}
void start(int num_of_extrms)
{int count；
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＝0：count＜＝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；
}
}
<dp n="d80"/>
/***************************************************************
function ligat() defines left up strokes from the end of long down
in the arr_extremoms[]，records defined left up stroke’s parameters to
ARR_LIGAT[] according to his number and labels MASK penn.
***************************************************************/
int ligat(int num_of_extrms，int num_dir)
{ int pr，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)
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_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＝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].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；
<dp n="d81"/>
/***************************************************************
function ligat() defines left up strokes from the end of long down
in the arr_extremoms[]，records defined left up stroke’s parameters to
ARR_LIGAT[] according to his number and labels MASK penn.
****************************************************************/
int ligat(int num_of_extrms，int num_dir)
{int pr，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；
<dp n="d82"/>
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)；
}
/***************************************************************
function ord_1_ligat() defines one order left up strokes from the
end of left up strokes inthe arr_extremoms[]，records one order
left up stroke’s parameters to ARR_ORD1_LIGAT[]according to his
number and labels MASK penn.
***************************************************************/
int ord_1_ligat(int num_of_extrms，int num_ligat)
{ int pr，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_cor
ARR_ORD_1_LIGAT[num_lig].y_end＝arr_extremoms[num_str].y_cor
pr＝1；
<dp n="d83"/>
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)；
}
/***************************************************************
function lig1() defines nght up strokes from the begining of long
down in the arr_extremoms[]，records defined right up stroke’s
parameters to ARR_LIG1[] according to his number and labels MASK
penn.
***************************************************************/
int lig1(int num_of_extrms，int num_dir)
{ int pr，num_lig，num_pns，count，num_str；
unsigned temp；
pr＝0；
num_pns＝0；
num_lig＝0；
if(num_dir＝＝0)
return(0)；
<dp n="d84"/>
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)；
}
<dp n="d85"/>
/***************************************************************
function lig2() defines left up strokes from the begining of
long down in the arr_extremoms[]，records defined left up stroke’s
parametersto ARR_LIG2[] according to his number and labels
MASK penn.
****************************************************************
int lig2(int num_of_extrms，int num_dir)
{ int pr，nun_lig，num_pns，count，num_str；
unsigned temp；
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＝0
break
}
}
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_cor
ARR_LIG2[num_lig].y_end＝arr_extremoms[num_str].y_cor；
<dp n="d86"/>
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)；
}
/***************************************************************
function ord_1_lig2() defines one order left up strokes from the
beginmg of left up strokes in the arr_extremorms[]，records one
order left up stroke’s parameters to ARR_ORD_2_LIG1[]according
to his number and labeis MASK penn.
***************************************************************/
int ord_1_lig2(int num_of_extrms.int num_lig2)
{ int pr，num_lig.num_pns，count.num_str；
unsigned temp；
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)continue
<dp n="d87"/>
if(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＝0
break；
}
}
}
}
for(count＝0；count＜num_lig；count++)
{temp＝ARR_ORD_1_LIG2[count].x_end；
<dp n="d88"/>
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)；
}
/***************************************************************
function lig3() defines right up strokes from the end of long
down in the arr_extremoms[]，records defined left up stroke’s
parameters to ARR_LIG3[] according to his number and labels
MASK penn.
****************************************************************/
int lig3(int num_of_extrms，int num_dir)
{ int pr，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+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_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；
<dp n="d89"/>
}
/********/
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(struct TABLE_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＂，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)；
}
fprintf(fp，＂\n＂)：
fclose(fp)：
}
int add_map(onar *letter)
{
int i；
for(i＝0；i＜NUM_SYMBOLS；i++)
if(*letter＝＝(onar)map_char[i][0])
{map_char[i][1]++；
return(i)；
}
if(i＝＝NUM SYMBOLS)
{printf(“There is no such character in the map％c\n＂，*letter)；
return(-1)；
<dp n="d90"/>
}
return(-1)；
}
void read_map(void)
{
FILE*fp；
int i；
fp＝fopen(＂map_ch＂，＂rb＂)；
for(i＝0；i＜NUM_SYMBOLS；i++)
fscanf(fp，＂％d％d\n＂，&map_char[i][0]，&map_char[i][1])；
fclose(fp)；
}
void save_map(void)
{
FILE*fp；
int i；
fp＝fopen(＂map_ch＂，＂wb＂)；
for(i＝0；i＜NUM_SYMBOLS；i++)
fprintf(fp，＂％d％d\n＂，map_char[i][0]，map_char[i][1])；
fclose(fp)；
}
int get_num(char*letter)
{
int i；
for(i＝0；i＜NUM_SYMBOLS；i++)
if(*letter＝＝(char)map_char[i][0])return(i)；
return(-1)；
}
III.一般化
void main(void)
{
FILE*fp，*fp1；
int i；
char filename[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)；
goto A；
}
if(i＝＝2)
{strcpy(filename，＂fsent2.out＂)；
strcpy(filename1，＂fgen2.out＂)；
printf(＂——％d——\n＂，i)；
goto A；
}
if(i＝＝3)
{strcpy(filename，＂fsent3.out＂)；
strcpy(filename1，＂fgen3.out＂)；
printf(＂——％d——\n＂，i)；
goto A；
}
if(i＝＝4)
{strcpy(filename，＂fsent4.out＂)；
strcpy(filename1，＂fgen4.out＂)；
printf(＂——％d——\n＂，i)；
goto A；
}
if(i＝＝5)
{strcpy(filename，＂fsent5.out＂)；
strcpy(filename1，＂fgen5.out＂)；
printf(＂——％d——\n＂，i)；
goto A；
}
if(i＝＝6)
{strcpy(filename，＂fsent6.out＂)；
strcpy(filename1，＂fgen6.out＂)；
printf(“——％d——\n＂，i)；
goto A：
}
A： fp1＝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()
}
<dp n="d92"/>
void read_map(void)
{
FILE*fp；
int i；
fp＝fopen(＂map_ch”“rb＂)；
for(i＝0；i＜NUM_SYMBOLS；i++)
fscanf(fp，＂％d％d\n＂，&map_char[i][0]，&map_char[i][1])；
fclose(fp)；
}
void gener(inti，char filename[]，char filename1[])
{
void gether(char letter，int num_dir，charfilename[]，char filename1[])；
int j；
for(j＝0；j＜100；j++)
{if(map_char[j][1]＞0)
gether(map_char[j][0]，i，filename，filename1)；
}
}
void gener_feat(void)
{
void gether_feat(char letter)；
int j；
for(i＝0；j＜100；j++)
{if(map_char[j][1]＞0)
gether_feat(map_char[j][0])；
}
}
void gener_feat1(void)
{
void gether_feat1(char letter)；
int j；
for (j＝0；j＜100；i++)
{if(map_char[j][1]＞0)
gether_feat1(map_char[j][0])；
}
}
void gether(char letter，int num_dir，char filename[]，char filename1[])
{char ch；
int letter_num；
int i，amount；
int amp_y；
FILE*fp；
int conv(void)；
void conv_dir_defin(int amount，int num_dir)；
void write_to_gen(int amount，int num_dir，char letter)；
void save_gen(int num_dir，char letter，char filename1[])；
void save_xy(int num_dir，char filename1[])；
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++)
<dp n="d93"/>
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)；
}
}
void save_gen(int num_dir，char letter，char filename1[])
{
FILE*fp1；
int i，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)；
}
void save_xy(int num_dir，char filename1[])
{ FILE*fp1；
int i；
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＝0：i＜num_dir；i++)
fprintf(fp1，＂％4f％4f\n＂，y_dev[i]y_b，y_dev[i].y_e)；
fclose(fp1)；
}
<dp n="d94"/>
void save_feat1(char letter)
{ FILE*fp1；
inti；
fp1＝fopen(＂genfeat.out＂，＂ab+＂)；
fprintf(fp1，＂％c＂，letter)；
fprintf(fp1，“％.4f％.4f％.4f％.4f\n＂，x_mid‖[0].x_b，x_mid‖[0].x_e，
y_mid‖[0].y_b，y_mid‖[0].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)；
}
void save_feat2(char letter)
{ FILE*fp1；
int i；
fp1＝fopen(“genfet1.out”，＂ab+＂)；
fprintf(fp1，＂％c＂，letter)；
fprintf(fp1，＂％.4f％d％d\n＂，y_midll[0].y_b，amp_y[0]，amp_y[1])；
for(i＝0；i＜3；i++)
fprintf(fp1，＂％.4f”y_dev[i].y_b)；
fprintf(fp1，＂\n＂)；
fclose(fp1)；
}
void gether_feat(char letter)
{
void calc_vec(int amount)；
FILE＂fp，fp1；
int amount，letter_num；
char ch；
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][0].y_b，&by[amount][0].y_e，
&bx[amount][0].x_b，&bx[amount][0].x_e)；
if(ch＝＝letter)
{amount++；
if(amount＝＝MAX_REPRESNT)break；
}
}
fclose(fp)；
if(amount＞0)
{calc_vec(amount)；
save_feat1(letter)，
}
}
void gether_feat1(char letter)
{
void calc_amp(int amount)；
FILE*fp；
int amount.letter_num；
char ch；
amount＝0；
<dp n="d95"/>
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；
}
void calc_vec(int amount)
{int count，i；
float summ_1＝0.0；
float summ_2＝0.0；
float summ_3＝0.0；
float summ_4＝0.0；
float summ_1m＝0.0；
float summ_2m＝0.0；
float summ_3m＝0.0；
float summ_4m＝0.0；
float temp；
int am1，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][0].y_b；
summ_3＝summ_3+bx[i][0].x_e；
summ_4＝summ_4+by[i][0].y_e；
}
x_midll[0].x_b＝summ_1/(float)amount；
y_midll[0].y_b＝summ_2/(float)amount；
x_midll[0].x_e＝summ_3/(float)amount；
y_midll[0].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[0].x_b-bx[i][0].x_b；
if(temp＞0.0)
{summ_1＝summ_1+temp*temp；
am1+-
<dp n="d96"/>
}
else
{summ_1m＝summ_1m+temp*temp；
am2++；
}
temp＝y_midll[0].y_b-by[i][0].y_b；
if(temp＞0.0)
{summ_2＝summ_2+temp*temp；
am3++；
}
else
{summ_2m＝summ_2m+temp*temp；
am4++；
}
temp＝x_midll[0].x_e-bx[i][0].x_e；
if(temp＞0.0)
{summ_3＝sum_3+temp*temp；
am5++；
}
else
{summ_3m＝summ_3m+temp*temp；
am6++；
}
temp＝y_midll[0].y_e-by[i][0].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[0].x_b＝0.0； ∥dev-
else x_dev[0].x_b＝sqrt(sum_1/(float)am1)；
if(am2＝＝0)x_dev[1].x_b＝0.0； ∥dev+
else x_dev[1].x_b＝sqrt(summ_1m/(float)am2)；
if((am1+am2)＝＝0)x_dev[2].x_b＝0.0； ∥dev
else x_dev[2].x_b＝sqrt((summ_1+summ_1m)/(float)(am1+am2))；
if(am3＝＝0)y_dev[0].y_b＝0.0； ∥dev-
else y_dev[0].y_b＝sqrt(summ_2/(float)am3)；
if(am4＝＝0)y_dev[1].y_b＝0.0； ∥dev+
else y_dev[1].y_b＝sqrt(summ_2m/(float)am4)；
if((am3+am4)＝＝0)y_dev[2].y_b＝0.0； ∥dev
else y_dev[2].y_b＝sqrt((summ_2+summ_2m)/(float)(am3+am4))；
if(am5＝＝0)x_dev[0].x_e＝0.0； ∥dev-
else x_dev[0].x_e＝sqrt(summ_3/(float)am5)；
if(am6＝＝0)x_dev[1].x_e＝0.0； ∥dev+
else x_dev[1].x_e＝sqrt(summ_3m/(float)am6)；
if((am5+am6)＝＝0)x_dev[2].x_e＝0.0； ∥dev
else x_dev[2].x_e＝sqrt((summ_3+summ_3m)/(float)(am5+am6))；
if(am7＝＝0)y_dev[0].y_e＝0.0； ∥dev-
else y_dev[0].y_e＝sqrt(summ_4/(float)am7)；
if(am8＝＝0)y_dev[1].y_e＝0.0； ∥dev+
else y_dev[1].y_e＝sqrt(summ_4m/(float)am8)；
if((am7+am8)＝＝0)y_dev[2].y_e＝0.0； ∥dev
else y_dev[2]y_e＝sqrt((summ_4+summ_4m)/(float)(am7+am8))
}
<dp n="d97"/>
{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)；
}
/****************************************************************
function ord_1_lig3() defines one order right up strokes from
the end of right up strokes in the arr_extremoms[]，records one
order left up stroke’s parameters to ARR_ORD_2_LIG1[]according
to his number and labels MASK penn.
****************************************************************/
int ord_1_lig3(int num_of_extrms.int num_lig3)
{int pr，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＝0；
if(ARR_LIG3[count].pns_end＝＝(unsigned)0)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；
<dp n="d98"/>
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)；
}
<dp n="d99"/>
/*function curve() records to MASK penn[] form codeto each of penstrokes
(except long down)according to its curvature. */
void cunve(int num_of_extrms)
{ exterm struct TABLE_EXTREMOMS arr_extremoms[MAX_NUM_OF_EXTREMOMS]；
int count；
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；
else
penn[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；
else
penn[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；
else
penn[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[cout].form_code＝10：
else
penn[count].form_cooe＝18)
}
}
defautt continue；
}
elurn.
<dp n="d100"/>
if((penn[count].form_code＝＝(unsigned)17)&&((strcmp(temp，＂Y”)！＝0)))
{strcpy(temp，＂Y＂)；
strcat(our_sent，＂Y＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)18)&&((strcmp(temp，＂Z＂)！＝0)))
{strcpy(temp，＂Z＂)；
strcat(our_sent，＂Z＂)；
goto A；
}
if((penn[count].form_code＝＝3)&&((strcmp(temp，＂C＂)！＝0)))
{strcpy(temp，＂C＂)；
strcat(our_sent，＂C＂)；
goto A；
}
if((penn[count].form_code＝＝4)&&((strcmp(temp，＂D＂)！＝0)))
{strcpy(temp，＂D＂)；
strcat(our_sent，＂D＂)；
goto A；
}
if((penn[count].form_code＝＝5)&&((strcmp(temp，＂E＂)！＝0)))
{strcpy(temp，＂E＂)；
strcat(our_sent，＂E＂)；
goto A；
}
if((penn[count].form_code＝＝6)&&((strcmp(temp，＂F＂)！＝0)))
{strcpy(temp，＂F＂)；
strcat(our_sent，＂F＂)；
goto A；
}
if((penn[count].form_code＝＝7)&&((strcmp(temp，＂G＂)！＝0)))
{strcpy(temp，＂G＂)；
strcat(our_sent，＂G＂)；
goto A；
}
if((penn[count].form_code＝＝8)&&((strcmp(temp，＂H＂)！＝0)))
{strcpy(temp，＂H＂)；
strcat(our_sent，＂H＂)；
goto A；
}
if((penn[count].form_code＝＝9)&&((strcmp(temp，＂｜＂)！＝0)))
{strcpy(temp，＂｜＂)；
strcat(our_sent，＂｜＂)；
goto A；
}
if((penn[count].form_code＝＝10)&&((strcmp(temp，＂J＂)！＝0)))
{strcpy(temp，＂J＂)；
strcat(our_sent，＂J＂)；
goto A；
}
A： if((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＂)
<dp n="d101"/>
/***********************************************************************
-initial MASK penn have to be build from penstrokes table form code have
to be done＝0
record to MASK penn is used in functions：direct，ligat，lig1，lig2，lig3，
ord_1_ligat，ord_1_lig1，ord_1_lig2，ord_1_lig3.From these programs
information for every find form have to be written to MASK for
these letter.
output1-letter representation in the＂LETTER SYMBOLIC REPRESENTATION＂
output2-letter representation in the＂LETTER SYMBOLIC REPRESENTATION
IN GENERALIZED FORM＂.
***********************************************************************/
int sentense(int num_of_extrms)
{ extern struct MASK penn[MAX_NUM_OF_EXTREMOMS]；
extern char our_sent[MAX_LENGTH_SENTENSE]；
char temp[10]：
int count；
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＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)11)&&((strcmp(temp，＂i＂)！＝0)))
{strcpy(temp，＂i＂)；
strcat(our_sent，＂j＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)12)&&((strcmp(temp，＂g＂)！＝0)))
{strcpy(temp，＂g＂)；
strcat(our_sent，＂g＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)13)&&((strcmp(temp，＂f”)！＝0)))
{strcpy(temp，＂f＂)；
strcat(our_sent，＂f＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)14)&&((strcmp(temp.＂d＂)！＝0)))
{strcpy(temp，＂d＂)；
strcat(our_sent，＂d＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)15)&&((strcmp(temp，＂Q＂)！＝0)))
{strcpy(temp，＂Q＂)；
strcat(our_sent，＂Q＂)；
goto A；
}
if((penn[count].forn_code＝＝(unsigned)16)&&((strcmp(temp，＂X＂)！＝0)))
{strcpy(temp＂X＂)；
strcat(our_sent，＂X＂)；
goto A；
}
<dp n="d102"/>
strcat(our_sent，＂B＂)；
continue；
}
}
return(1)；
}
/***********************************************************************
a funtion that recieves two numbers，and returns the quarter of these
two numbers in the range of 0..7.
***********************************************************************/
int def_quart(int x，int y)
{
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)；
}
/***********************************************************************
a function to returns the round number ofthe division of two integer
numbers.
***********************************************************************/
int div_round(int a，int b)
{
int i＝0；
int temp1，temp2；
temp1＝a；
temp2＝b；
a＝abs(a)；
if(b＝＝0)return(MAXINT)；
while(a＞b)
{
if(b＞0)a-＝b；
else a+＝b；
}
if((a+a)＞bi++；
if(((temp1＞0)&&(temp2＞0))‖((ternp1＜0)&&(temp2＜0)))return(i)
else return (-i)
}
void save_files(int num_direc，char*letter)
{ FILE*fp；
inti；
int letter_num；
char filename[20]；
int get_num(cha r*letter)；
if((letter_num＝get_num(letter))＜0)
{ printf(＂Error in the number of the letter ％c\n＂，*letter)；
getch()
<dp n="d103"/>
{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)；
}
/***********************************************************************
function ord_1_lig3() defines one order right up strokes from
the end of right up strokes in the arr_extremoms[]，records one
order left up stroke’s parameters to ARR_ORD_2_LIG1[]according
to his number and labels MASK penn.
***********************************************************************/
int ord_1_lig3(int.num_of_extrms.int num_lig3)
{ int pr，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＝0
if(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.
<dp n="d104"/>
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_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＝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)
}
<dp n="d105"/>
/*function curve() records to MASK penn[] form codeto each of penstrokes
(except long down)according to lts cunvature.*/
void curve(int num_of_extrms)
{extem struct TABLE_EXTREMOMS arr_extremoms[MAX_NUM_OF_EXTREMOMS]；
int count；
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；
else
penn[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；
else
penn[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；
else
penn[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＝10
else
penn[count].form_code＝18
}
}
default：continue
}
eturn；
<dp n="d106"/>
if((penn[count].form_code＝＝(unsigned)17)&&((strcmp(temp.“Y＂)！＝0)))
{strcpy(temp，＂Y＂)；
strcat(our_sent，＂Y＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)18)&&((strcmp(temp，＂Z＂)！＝0)))
{strcpy(temp，＂Z＂)；
strcat(our_sent，＂Z＂)；
goto A；
}
if((penn[count].form_code＝＝3)&&((strcmp(temp，＂C＂)！＝0)))
{strcpy(temp，＂C＂；
strcat(our_sent，＂C＂)；
goto A；
}
if((penn[count].form_code＝＝4)&&((strcmp(temp，＂D＂)！＝0)))
{strcpy(temp，＂D＂)；
strcat(our_sent，＂D＂)；
goto A；
}
if((penn[count].fonn_code＝＝5)&&((strcmp(temp，＂E＂)！＝0)))
{strcpy(temp，＂E＂)；
strcat(our_sent，＂E＂)；
goto A；
}
if(penn[count].form_code＝＝6)&&((strcmp(temp，＂F＂＂)！＝0)))
{strcpy(temp，“F＂)；
strcat(our_sent，＂F＂)；
goto A；
}
if(penn[count].fomn_code＝＝7)&&((strcmp(temp，＂G＂)！＝0)))
{strcpy(temp，＂G＂)；
strcat(our_sent，＂G＂)；
goto A；
}
if((penn[count].form_code＝＝8)&&((strcmp(temp，＂H＂)！＝0)))
{strcpy(temp，＂H＂)；
strecat(our_sent，＂H＂)；
goto A；
}
if((penn[count].form_code＝＝9)&&((strcmp(temp，＂I＂)！＝0)))
{strcpy(temp，＂I＂)；
strcat(our_sent，＂I＂)；
goto A：
}
if((penn[count]form_code＝＝10)&&((strcmp(temp，＂J＂)！＝0)))
{strcpy(temp，＂J＂)；
strcat(our_sent，＂J＂)；
goto A：
}
A： if((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＂).
<dp n="d107"/>
/***********************************************************************
-initial MASK penn have to be build from penstrokes table form_code have
to be done＝0
record to MASK penn is used in functions：direct，ligat，lig1，lig2，lig3，
ord_1_ligat，ord_1_lig1，ord_1_lig2，ord_1_lig3.From these programs
information for every find form have to be written to MASK for
these letter.
output1_1etter representation in the＂LETTER SYMBOLIC REPRESENTATION＂.
output2_letter representation in the＂LETTER SYMBOLIC REPRESENTATION
IN GENERALIZED FORM＂.
***********************************************************************/
int sentense(int num_of_extrms)
{extem struct MASK penn[MAX_NUM_OF_EXTREMOMS]；
extem cnar our_sent[MAX_LENGTH_SENTENSE]；
char temp[10]：
int count；
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＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)11)&&((strcmp(temp，＂i＂)！＝0)))
{strcpy(temp，＂i＂)；
strcat(our_sent，＂i＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)12)&&((strcmp(temp，＂g＂)！＝0)))
{strcpy(tamp，“g＂)；
strcat(our_sent，＂g＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)13)&&((strcmp(temp，＂f＂)！＝0)))
{strcpy(temp，＂f”)；
strcat(our_sent，＂f＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)14)&&((strcmp(temp，＂d＂)！＝0)))
{strcpy(temp，＂d＂)；
strcat(our_sent＂d＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)15)&&((strcmp(temp，＂Q＂)＝0)))
{strcpy(temp，＂Q＂)；
strcat(our_sent，＂Q＂)；
goto A；
}
if((penn[count].form_code＝＝(unsigned)16)&&((strcmp(temp，＂X＂)＝0)))
{strcpy(temp，＂X＂)；
strcat(our_sent，＂X＂)；
goto A：
}
<dp n="d108"/>
strcat(our_sent，＂B＂)；
continue：
}
}
return(1)；
}
/***********************************************************************
a funtion that recieves two numbers，and returns the quarter of these
two numbers in the range of 0..7.
***********************************************************************/
int def_quart (int x，int y)
{
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)：
}
/***********************************************************************
a function to returns the round number of the division of two integer
numbers.
***********************************************************************/
int div_round(int a，int b)
{
int i＝0；
int temp1，temp2；
temp1＝a；
temp2＝b；
a＝abs(a)；
if(b＝＝0)return(MAXINT)；
while(a＞b)
{
if(b＞0)a-＝b；
else a+＝b；
i++；
}
if((a+a)＞b)i++；
if(((temp1＞0)&&(temp2＞0))‖((temp1＜0)&&(temp2＜0)))return(i)；
else return(-i)；
}
void save_files(int num_direc，char*letter)
{FILE*fp；
int i；
int letter_num；
char filename[20]；
int get_num(char*letter)；
if((letter_num＝get_num(letter))＜0)
{prinff(＂Error in the number of the letter％c\n＂，*letter)；
getch()；
<dp n="d109"/>
}
/*******/
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(struct TABLE_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)；
}
int add_map(char*letter)
{
int i；
for(i＝0；i＜NUM_SYMBOLS；i++)
if(*letter＝＝(cnar)map_char[i][0])
{map_char[i][1]++；
return(i)；
}
if(i＝＝NUM_SYMBOLS)
{printf(＂There is no such character in the map％c\n＂，*letter)；
return(1)；
<dp n="d110"/>
}
return(-1)；
}
void read_map(void)
{
FILE*fp；
int i；
fp＝fopen(*map_ch＂，＂rb＂)；
for(i＝0；i＜NUM_SYMBOLS；i++)
fscanf(fp，＂％d％d\n＂，&map_char[i][0]，&map_char[i][1])；
fclose(fp)；
}
void save_map(void)
{
FILE*fp；
int i；
fp＝fopen(＂map_ch＂，＂wb＂)；
for (i＝0；i＜NUM_SYMBOLS；i++)
fprintf(fp，％d％d\n＂，map_cha[i][0]，map_char[i][1])；
fclose(fp)；
}
int get_num(char*letter)
{
int i；
for(i＝0；i＜NUM_SYMBOLS；i++)
if(*letter＝＝(char)map_char[i][0])return(i)；
return(-1)；
}
III.一般化
void main(void)
{
FILE *fp，*fp1；
int i；
char filename[30]，filename1[30]；
read_map()；
for(i＝1；i＜＝MAX AMOUNT_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)；
goto A；
}
if(i＝＝3)
{strcpy(filename，＂fsent3.out＂)；
strcpy(filename1，＂fgen3.out＂)；
printf(“——％d——\n＂，i)；
goto A；
}
if(i＝＝4)
{strcpy(filename，＂fsent4.out＂)；
strcpy(filename1，＂fgen4.out＂)；
printf(＂——％d——\n＂，i)；
goto A；
}
if (i＝＝5)
{strcpy(filename，＂fsent5.out＂)；
strcpy(filename1，＂fgen5.out＂)；
printf(＂——％d——\n＂，i)；
goto A；
}
if(i＝＝6)
{strcpy(filename，＂fsent6.out＂)；
strcpy(filename1，＂fgen6.out＂)；
printf(＂——％d——\n＂，i)；
goto A；
}
A： fp1＝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()
}
<dp n="d112"/>
void read_map(void)
{
FILE*fp；
int i；
fp＝fopen(＂map_ch＂，＂rb”)；
for (i＝0；i＜NUM_SYMBOLS；i++)
fscanf(fp，＂％d％c\n＂，&map_char[i][0]，&map_char[i][1])；
fclose(fp)；
}
void gener(int i，char filename[]，char filename1[])
{
void gether(char letter，int num_dir，char filename[]，char filename1[])；
int j；
for(j＝0；j＜100；j++)
{if(map_char[j][1]＞0)
gether(map_char[j][0]，i，filename，filename1)；
}
}
void gener_feat(void)
{
void gether_feat(char letter)；
int j；
for (j＝0；j＜100；j++)
{if(map_char[j][1]＞0)
gether_teat(map_char[j][0])；
}
}
void gener_feat1(void)
{
void gether_feat1(char letter)；
int j；
for (j＝0；j＜100；j++)
{if(map_char[j][1]＞0)
gether_feat1(map_char[j][0])；
}
}
void gether(char letter，int num_dir，char filename[]，char filename1[])
{char ch；
int letter_num；
int i，amount；
int amp_y；
FILE*fp；
int conv(void)；
void conv_dir_defin(int amount，int num_dir)；
void write_to_gen(int amount，int num_dir，char letter)；
void save_gen(int num_dir，char letter，char filename1[])；
void save_xy(int num_dir，char filename1[])；
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++)
<dp n="d113"/>
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)；
}
}
void save_gen(int num_dir，char letter，char filename1[])
{
FILE*fp1；
int i，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)；
}
void save_xy(int num_dir，char filename1[])
{ FILE*fp1；
int i；
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)；
}
<dp n="d114"/>
void save feat1(char letter)
{ FILE*fp1；
int i；
fp1＝fopen(“genfeat.out＂，＂ab+＂)；
fprintf(fp1，＂％c＂，letter)；
fprintf(fp1，＂％.4f％.4f％.4f％.4f\n＂，x_midll[0].x_b，x_midll[0].x_e，
y_midll[0].y_b，y_midll[0].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)；
}
void save_feat2(char lettef)
{ FILE*fp1；
int i；
fp1＝fopen(＂genfet1.out＂，＂ab+＂)；
fprintf(fp1，＂％c＂，letter)；
fprintf(fp1，＂％.4f％d％d\n＂，y_midll[0].y_b，amp_y[0].amp_y[1])；
for(i＝0；i＜3；i++)
fprintf(fp1，％.4f＂，y_dev[i].y_b)；
fprintf(fp1，“\n”)；
fclose(fp1)；
}
void gether_feat(char letter)
{
void calc_vec(int amount)；
FILE*fp，fp1；
int amount，letter_num；
char ch；
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][0].y_b，&by[amount][0].y_e，
&bx[amount][D].x_b，&bx[amount][0].x_e)；
if(ch＝＝letter)
{amount++；
if(amount＝＝MAX_REPRESNT)break；
}
}
fclose(fp)；
if(amount＞0)
{calc_vec(amount)；
save_feat1(letter)；
}
}
void gether_feat1(char letter)
{
void calc_amp(int amount)；
FILE*fp；
int amount，letter_num；
char ch；
amount＝0；
<dp n="d115"/>
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；
}
void calc_vec(int amount)
{int count，i；
float summ_1＝0.0；
float summ_2＝0.0；
float summ_3＝0.0；
float summ_4＝0.0；
float summ_1m＝0.0；
float summ_2m＝0.0；
float summ_3m＝0.0；
float summ_4m＝0.0；
float temp；
int am1，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][0].y_b；
summ_3＝summ_3+bx[i][0].x_e；
summ_4＝summ_4+by[i][0].y_e；
}
x_midll[0].x_b＝summ_1/(float)amount；
y_midll[0].y_b＝summ_2/(float)amount；
x_midll[0].x_e＝summ_3/(float)amount；
y_midll[0].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[0].x_b-bx[i][0].x_b；
if(temp＞0.0)
{summ_1＝summ_1+temp*temp；
am1++；
<dp n="d116"/>
}
else
{summ_1m＝summ_1m+temp*temp；
am2++；
}
temp＝y_midll[0].y_b-by[i][0].y_b；
if(temp＞0.0)
{summ_2＝summ_2+temp*temp；
am3++；
}
else
{summ_2m＝summ_2m+temp*temp；
am4++；
}
temp＝x_midll[0].x_e-bx[i][0].x_e；
if(temP＞0.0)
{summ_3＝summ_3+temp*temp；
am5++；
}
else
{summ_3m＝summ_3m+temp*temp；
am6++；
}
temp＝y_midll[0].y_e-by[i][0].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[0].x_b＝0.0； ∥dev-
else x_dev[0].x_b＝sqrt(summ_1/(float)am1)；
if(am2＝＝0)x_dev[1].x_b＝0.0； ∥dev+
else x_dev[1].x_b＝sqrt(summ_1m/(float)am2)；
if((am1+am2)＝＝0)x_dev[2].x_b＝0.0； ∥(dev
else x_dev[2].x_b＝sqrt((summ_1+summ_1m)/(float)(am1+am2))；
if(am3＝＝0)y_dev[0].y_b＝0.0； ∥dev-
else y_dev[0].y_b＝sqrt(summ_2/(float)am3)；
if(am4＝＝0)y_dev[1].y_b＝0.0； ∥dev+
else y_dev[1].y_b＝sqrt(summ_2m/(float)am4)；
if((am3+am4)＝＝0)y_dev[2].y_b＝0.0； ∥dev
else y dev[2].y_b＝sqrt((summ_2+summ_2m)/(float)(am3+am4))；
if(am5＝＝0)x_dev[0].x_e＝0.0； ∥dev-
else x_dev[0].x_e＝sqrt(summ_3/(float)am5)；
if(am6＝＝0)x_dev[1].x_e＝0.0； ∥dev+
else x_dev[1].x_e＝sqrt(summ_3m/(float)am6)；
if((am5+am6)＝＝0)x dev[2].x_e＝0.0； ∥dev
else x_dev[2].x_e＝sqrt((summ_3+summ_3m)/(float)(am5+am6))；
if(am7＝＝0)y_dev[0].y_e＝0.0； ∥dev-
else y_dev[0].y_e＝sqrt(summ_4/(float)am7)；
if(am8＝＝0)y_dev[1].y_e＝0.0； ∥dev+
else y_dev[1].y_e＝sqrt(summ_4m/(float)am8)；
if((am7+am8)＝＝0)y_dev[2].y_e＝0.0； ∥dev
else y_dev[2].y_e＝sqrt((summ_4+summ_4m)/(float)(am7+am8))；
}
<dp n="d117"/>
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)；
}
}
/***********************************************************************
function conv_dir_defin() calculates dispersions of x and y relative
coordinates in letter skeleton.
***********************************************************************/
void conv_dir_defin(int amount，int num_dir)
{int count，i；
float summ_1＝0.0；
float summ_2＝0.0；
float summ_3＝0.0；
float summ_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；
<dp n="d118"/>
void calc_amp(int amount)
{
int i；
float summ_1＝0.0；
float summ_1m＝0.0；
float amp_midll，temp；
int am1，am2；
int max，min；
max＝amp_y[0]；
min＝amp_y[0]；
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[0].y_b＝0.0； ∥dev-
else y_dev[0].y_b＝sqrt(summ_1/(float)am1)；
if(am2＝＝0)y_dev[1].y_b＝0.0； ∥dev+
else y_dev[1].y_b＝sqrt(summ_1m/(float)am2)；
if((am1+am2)＝＝0)y_dev[2].y_b＝0.0； ∥dev
else y_dev[2].y_b＝sqrt((summ_1+summ_1m)/(float)(am1+am2))；
y_midll[0].y_b＝amp_midll；
amp_y[0]＝max；
amp_y[1]＝min；
}
int conv(void)
{ char*p；
int count；
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＂)，
<dp n="d119"/>
}
}
else
{ printf(..Thereis no directions in sentence＂)；
getch()；
return(0)；
}
return(1)；
}
∥********************************************
∥ words’generalization
∥********************************************
int cmpr(char a，char b，const char c，const char d，const char q)
{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)；
}
else
return(0)；
}
int comp1(char a[]，char b[]，int i)
/********************************************
comparesion two letters with the same number in the words a and b
count-number of letters in words
********************************************/
{ 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)；
}
<dp n="d120"/>
int compar(int num_dir，int count)
/********************************************
comparison the word with word’s row
k-amount of letters in the words
j-amount of words in the row
return；
777-word isn’t in the row
0-10-number of words if there is comparison of the word’s part
222-word already is in the row
********************************************/
{ int k，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；
else
if((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-number of row(0-infront of first direction
1-after first dir
2-affer second dir...)
********************************************/
void write_to_gen(int amount，inf num_dir，char letter)
{ int i，count，j，temp；
int m，n；
gen repr.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[0].str，buf[count])；
<dp n="d121"/>
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；
}
void main(void)
{
int length(int num_dir)；
void cutting(int i，int k，FILE*fpx)；
void add_1 (int num_dir)；
char filename1[30]；
char temp[10]；
int i，k；
int num_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，＂fge n..)；
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；
<dp n="d122"/>
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)
{case 1：fp1＝fopen(“g_cut1.out＂，＂a+b＂)；
cutting(i，k，fp1)；
fclose(fp1)；
break；
case 2：fp2＝fopen(“g_cut2.out＂，＂a+b＂)；
cutting(i，k，fp2)；
fclose (fp2)；
break；
case 3：fp3＝fopen(＂g_cut3.out＂，＂a+b＂)；
cutting(i，k，fp3)；
fclose(fp3)；
break；
case 4：fp4＝fopen(“g_cut4.out＂，＂a+b＂)；
cutting(i，k，fp4)；
fclose(fp4)；
break；
case 5：fp5＝fopen(＂g_cut5.out＂，＂a+b＂)；
cutting(i，k，fp5)；
fclose(fp5)；
break；
case 6：fp6＝fopen(＂g_cut6.out＂，＂a+b＂)；
cutting(i，k，fp6)；
fclose(fp6)；
break；
default：printf(＂Error in cutting\n＂)；getch()；
}
}
}
fclose(fp)；
}
}
void cutting(inti，int k，FILE＂fpx)
{void cut_sent(int num_dir)；
void cut_skel(int num_dir，int k)；
void sav_new(int num_dir，int k，FILE*fp1)；
cut_skel(i，k)；
cut_sent(i)；
sav_new(i，k，fpx)；
}
int length(int num_dir)
{
int i，j；
<dp n="d123"/>
float arr_hip[6]；
char letter；
int pr；
float temp_fl，w；
int temp；
while(fscanf(fp，＂％c＂，&letter)！＝EOF)/*letter from gen set*/
{
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)；
}
<dp n="d124"/>
void paste(int k，int out_number，struct STRING out[10]，int in_number，
struct STRING in[10])
{int i，j，m，len_out；
char a[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[0])
{if(len_out＞1)
{strncpy(a，out[i].str，len_out-1)；
a[len_out-1]＝′\0′；
}
else
strcpy(a，****)；
}
else
strcpy(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，length of pasted word＞10**)；
getch()；
}
}
}
/********************************************
num_dir-anishial amount of long.
k-amount of long，which have to be stay.
(num_dir-k)-number of loop.
********************************************/
void cut_sent(int num_dir)
{
void cut_word_in(char gen_cut[15]，char a[15])；
void cut_word_out(char gen_cut[15]，char a[15])；
int j，k，i；
char a[15]；
int out_number，in_number，len，pr，pr1；
struct STRl NG out[10]；
struct STRING in[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；
<dp n="d125"/>
while(j＜num_dir)
{if(mark_long[i]！＝0)
{j++；
pr1＝1；
continue；
}
else break；
}
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[0].number；i++)
{if(gen_cut.repr.tabl[0].row[i].str[0]＝＝＂_＂)
gen_cut.repr.tabl[0].row[i].str[0]＝＂*＂；
else
{if(gen_cut.repr.tabl[0].row[i].str[0]＝＝＂*＂)
else
{strcpy(a，＂*＂)；
strcat(a，gen_cut.repr.tabl[0].row[i].str)；
strcpy(gen_cut.repr.tabl[0].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；
<dp n="d126"/>
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)；
}
}
}
void cut_skel(int num_dir，int k)
{
intj；
int l；
float min_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；
<dp n="d127"/>
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；
}
}
void sav_new(int num_dir，int k，FILE*fp1)
{
int i，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)；
}
int cmpr_out(char c)
{if((c＝＝′E′)l‖(c＝＝′F′)‖(c＝＝′X′)‖(c＝＝′g′)‖(c＝＝′G′)‖(c＝＝′H′)‖(c＝＝′f)‖
(c＝＝′Y′))
return(1)；
else return(0)；
}
int cmpr_in(char c)
{if((c＝＝′C′)‖(c＝＝′D′)‖(c＝＝′Q′)‖(c＝＝′i′)‖(c＝＝′J′)‖(c＝＝′l′)‖(c＝＝′d′)‖
(c＝＝′Z′))
<dp n="d128"/>
return(1)；
else return(0)；
}
void cut_word_out(char gen_cut[15]，char a[15])
{
int i；
int len；
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′；
}
}
void cut_word_in(char gen_cut[15]，char a[15])
{
int i；
int len；
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′；
}
}
void add_1(int num_dir)
{char letter；
int i，j；
while(fscanf(fp，＂％c＂，&letter)！＝EOF)/*letter from gen set*/
{
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＂)；
<dp n="d129"/>
}
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)；
}
}
}
IV.识别过程
int main(void)
{
FILE*fp；
char infile[30]；
int num；
struct ffblk ffblk；
int done；
int SeqNo；
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’t open input file-％s-\n＂，infile)；
return；
}
if(infie[0]！＝′B′)
{letter＝tolower(infile[0])；
SeqNo＝(int)(infile[2]-48)；
}
else
{if(isdigit((int)infile[1])！＝0)
{letter＝tolower(infile[0])；
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)；
}
return 0；
}
<dp n="d131"/>
/* MAIN FOR RECOGNITION */
void recogn(FILE*fp，FILE*fp2)；
int main(void)
{
FILE*fp，*fp2；
int i；
char filename[30]，filename1[30]；
map_char[i][1]＝0；
map_char[i][0]＝′a′；
fp2＝fopen(“sort.out＂，＂wb＂)；
fp＝fopen(＂rsent.out＂，＂rb＂)；
recogn(fp，fp2)；
fcose(fp)；
fclose(fp2)；
return 0；
}
/****************************************************************************
structures initialization(initial set of the symbols to be recognized)
****************************************************************************/
void read_map(void)
{ FILE*fp；
int i；
fp＝fopen(＂map_ch＂，＂rb＂)；
for(i＝0；i＜NUM_SYMBOLS；i++)
fscanf(fp，＂％d％d\n＂，&map_char[i][0]，&map_char[i][1])；
fclose(fp)；
}/****************************************************************************
function defines if the char letter was in mapping card in training set
****************************************************************************/
int check_map(char letter)
{
int i；
for(i＝0；i＜NUM_SYMBOLS；i++)
if((letter＝＝(char)map_char[i][0])&&(map_char[i][1]＞0))return(i)；
if(i＝＝NUM_SYMBOLS)
{pnntf(＂There is no such character in the map\n＂)；
return(-1)；
}
return(-1)；
}
/****************************************************************************
function reads FILE*fp(symbols to be recognized)and using generalized
information after the training(FILE*fp1)defines similarity functions
for every symbol to be recognized fromthe different points of view and
writes this information to FILE *fp2
****************************************************************************/
int conv(void)；
float def_k_sent(int num_dir)；
float metric_dir_y(int num_dir，int amp_y，struct X x[]，struct Y y[])；
float metric_dir_x(int num_dir，int amp_y，struct X x[]，struct Y y[])；
void length(int num_dir)；
float cut_skel(int num_dir，int k)；
void cut_sent(int num_dir)；
<dp n="d132"/>
int calc_per_up(char a[MAX_LENGTH_SENTENSE])；
void recogn(FILE*fp，FILE*fp2)
{FILE*fp1；
char filename1[30]；
float w_sent.w_y，w_x；
int amp_y，w_pen_up；
char ch，letter；
int lette_num；
int i，j，k；
int num_dir；
char num_long[10]；
float gen_coef，rsent_coef；
int gen_max_pan_up，gen_min_pen_up；
int rsent_pen_up；
char our_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)；/*letter from recognition set*/
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(“This ligature is too long\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)/*letter from gan set*/
{
fscanf(fp1，＂％f＂，&gen_coef)；
fscanf(fp1，＂％d％c％d＂，&gen.amount，&gen.repr.letter，&gen.repr num)；
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＂)；
<dp n="d133"/>
}
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；
else w_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，＂*＂)；
}
}
}
void length(int num_dir)
{
int i，j；
float arr_hip[6]；
char letter；
int pr；
float temp_fl；
int temp；
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；
}
<dp n="d134"/>
}
}
coef[0]＝1.0；
for(i＝1；i＜＝num_dir；i++)
coef[i]＝coef[i-1]*(1.0-arr_hip[i-1])；
}
void paste(int k，char out[10]，charin[10])
{inti，j，m，len_out；
char a[20]；
strcpy(a，＂＂)；
len_out＝strlen(out)；
if(out[len_out-1]＝＝in[0])
{if(len_out＞1)
{stmcpy(a，out，len_out-1)；
a[len_out-1]＝′\0′；
}
else
strcpy(a，**)；
}
else
strcpy(a，out)；
strcat(a，in)；
if(strlen(a)＜10)
strcpy(buf[k]，a)；
else
{printf(＂RSENT.OUT-ERR.paste，length of pasted word＞10＂)；
getch()；
}
}
void cut_sent(int num_dir)
{
void cut_word_in(char gen_cut[15]，char a[15)；
void cut_word_out(char gen_cut[15]，char a[15])；
intj，k，i；
char a[15]；
int out_number，in_number，len，pr，pr1；
char out[10]；
char in[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；
}
else break；
}
if(pr1＝＝1)
{strcpy(a，bufz[j]])；
cut_word_in(bufz[j]，a)；
strcpy(buf[k]，a)；
<dp n="d135"/>
pr1＝0；
}
else
strcpy(buf[k]，bufz[j])；
if(buf[0][0]＝＝＂_＂)
buf[0][0]＝＂*＂；
else
{if(buf[0][0]＝＝＂*＂)
；
else
{strcpy(a，＂*＂)；
strcat(a，buf[0])；
}
}
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)；
else
strcpy(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])；
}
}
float cut_skel(int num_dir，int k)
{ int j；
int l；
float min_x.min_y；
<dp n="d136"/>
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])；
}
int cmp_out(char.c)
{if((c＝＝′E')‖(c＝＝′F′)‖(c＝＝′x’)‖(c＝＝′g′)‖(c＝＝′G’)‖(c＝＝′H′)‖(c＝＝′f)‖
(c＝＝′Y))
return(1)；
else return(0)；
}
int cmp_in(char c)
{if((c＝＝′C)‖＝(c＝＝′D′)‖(c＝＝′Q′)‖(c＝＝′i′)Z‖(c＝＝′J′)‖(c＝＝′l′)‖(c＝＝′d′)‖
(c＝＝′Z′))
return(1)；
else return(0)；
}
void cut_word_out(char gen_cut[15]，char a[15])
{
int i；
int len；
len＝strlen(gen_cut)；
i＝len-1；
while(cmp-out(gen_cut[i])＝＝1)
{i-；
if(i＜0)break；
}
<dp n="d137"/>
if(i＜0)strcpy(a，＂-＂)；
else
{strncpy(a，gen_cut，i+1)；
a[i+1]＝′\0′；
}
}
void cut_word_in(char gen_cut[15]，char a[15])
{
int i；
int len；
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′；
}
}
int calc_penup(char a[MAX_LENGTH_SENTENSE])
{int count；
char*p；
count＝-0；
if((strlen(a)＝＝1)&&(a[0]＝＝“_”))
return(0)；
p＝strchr(a，＂_＂)；
if(p＝＝NULL)return(0)；
while(p！＝NULL)
{p＝strchr(p+1，＂_＂)；
count++；
}
count-；
return(count)；
}
/**
function conv() makes sentence separation into words using symbol＂A＂
as delimiter and wntes the results to bu[l].
**/
int conv(void)
{char *p；
int count；
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
<dp n="d138"/>
{printf(＂There is no long inthe sentence\n＂)；
getch0；
return(0)；
}
return(1)；
}
float def_k_class(char a，char b，const char c，const char d，const char q，
const char d_small)
/*******************
a-letter from the generalized sentence
b-letter from the symbols’sentence to be recognized
c，d，q，d_small-symbols’from the same class segments’vocabulary
function defines if the letters a and the b belongs to one class
inthe segments’vocabulary or not and defines def_k[i][i] for them
in the weight table def_k[5][5]
***************************/
{float
def_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}；∥posibility to modify the similarity！！！！
char alfabet[4]；
int i，j；
alfabet[0]＝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])；
}
/**
function det_k_ietter() calculates similirity between letters in the
words according to weights table.
**/
float def_k_letter(char a[]，char b[]，int i，int j)
*******************
a-word from the generalized sentence
b-word from symbols sentence to be recognized
i-number of letter in the word a
j-number of letter in the word b
*******************/
<dp n="d139"/>
{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)；
}
int cmpr_in(char c)
{if((c＝＝′E′)‖(c＝＝′F′)‖(c＝＝′X’)‖(c＝＝′g′)‖(c＝＝′G′)‖(c＝＝′H′)‖(c＝＝′f′)‖
(c＝＝′Y′))
return(1)；
else return(0)；
}
int cmpr_out(char c)
{if((c＝＝′C′)‖(c＝＝′D′)‖(c＝＝′Q′)‖(c＝＝′i′)‖(c＝＝′J′)‖(c＝＝′I′)‖(c＝＝′d′)‖
(c＝＝′Z′))
return(1)；
else return(0)；
}
/**
function def_k_word() calculates and returns symilirity function(SF)for the
every word in the row.SF is defined from 0 to 1.If word in the recognized
symbol is equal to the word in the row then SF is equal to 1；
if words are not equal，then parts of words are compared.There are three parts
in the words.Part1-down input segments，part2-down output segments，part3
segments between part1 and part2.
**/
float def_k_word(char a[]，char b[]，int row)
/*****************************
words’similarity comparison function
a-word from the generalized sentence
b-word fromthe symbols sentence to be recog nized
*************************/
{float w＝0.0；
int i，j，n，m，temp.i_end_1，i_end_2，j_end-1，j_end_2；
int pr_a_1＝0，pr_a_2＝0，pr_b_1＝0，pr_b_2＝0；
float w1＝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(0 0)；
if((n！＝0)&&(m＝＝0))return(0.0)；
if((n＝＝0)&&(m＝＝0))return(1.0)；
if(n＞＝m)temp＝n；
else temp＝m；
if(row＝＝0)
<dp n="d140"/>
{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)；
else w＝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)；
else w＝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＂s not right dividing inside the words\n＂)
printf(＂a[]＝％s b[]＝％s\n＂，a，b)；
printf(＂i_end_1＝％d i_end_2＝％d j_end_1＝％d j_end_2＝％d\n＂，
i_end-1，i_end_2，j_end-1，j_end_2)；
printf(＂pr_a-1＝％d pr_a_2＝％d pr_b_1＝％d pr_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-)
<dp n="d141"/>
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**-amount ofletters in the row equal 0\n＂)；
getch()；
}
}
}
return(W)；
}
/**
function def_k_row() calculates and returns symilirity function for every
row in symbols generalized representation as maximum value in row.
SF is defined from 0 to 1.
**/
float def_k_row(int num_dir，int count，int row)
{float temp；
float w＝0.0；
int j；
if(gen.repr.tabl[count].number＜1)
if(buf[count]＝＝NULL) return(1.0)；
else return(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；
}
else
if(temp＞w)
w＝temp；
return(w)；
}
float def_k_sent(int num_dir)
{floatw＝0.0；
int count；
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))；
}
<dp n="d142"/>
/******************************************************************************
similarity function defining similarity between defined param and
sample of parameters with known medial，left and right deviation，
and range of definition(const_l，const_r)
******************************************************************************/
float mut_metric(float param，float medial，float const_1，float const_r，
float dev_l，float dev_r)
{float left，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(＂ERROR in mut_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)；
}
/******************************************************************************
fun ctions metric_dir_y() and metric_dir_x() calculate similarity
metrics on the base of distance between recognized letter skeleton
and symbol’s generalized skeleton calculated during a teaching.
******************************************************************************/
float metric_dir_y(int num_dir，int amp_y，struct X x[]，struct Y y[])
{ int count；
float m_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)；
}
float metric_dir_x(int num_dir.int amp_y，struct X x[]，struct Y y[])
{ int count；
float m_1，m_2.metric；
metric＝1.0
<dp n="d143"/>
for(count＝0；count＜num dir；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)；
}
/******************************************************************************
The file sort.out is sorting step by step using appropriate similarity
functions(defined with parameters a，b，c and tresholds w_level，y_level，
x_level) and their order，the result is written the file err.
******************************************************************************/
int main(void)
{
char sort(int j，char a，char b，char c，float w_level，float y_level，
float x_level，char ch，int num_dir)；
int check_map(char letter)；
void read_map(void)；
void r_matr(void)；
int i，j；
float w_level，y_level，x_level；
char a，b，c；
char ch，temp_ch，letter；
int letter_num，num_dir；
float ttt；
int tt；
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％c Mw＝％.4f My＝％.4f Mx＝％.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％c num_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；
<dp n="d144"/>
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)；
return 0；
}
int sort_a(int j，char a，float w_level，float y_level，float x_level)
{
int sort_w(int j，float level)；
int sort_y(int j，float level)；
int sort_x(int j，float level)；
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)；
}
int sort_b(intj，char b，float w_level，float y_level，float x_level)
{
int sort_w(int j，float level)；
int sort_y(int j，float level)；
int sort_x(int j，float level)；
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)；
}
int sort_c(int j，char c，float w_level，float y_level，float x_level)
{
int sort_w(int j，float level)；
int sort_y(int j，float level)；
int sort_x(int j，float level)；
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)；
}
char sort(int j.char a，charb，char c，float w_leval，float y_level，
float x_level，char ch，int num_dir)
{
int i，k，l；
i＝sort_a(j，a，w_level，y_level.x_level)；
if(i＝＝0)
{∥if(ch！＝arr_srt[0].letter)
fprintf(fout5.＂％d\n％c Mw＝％.4f My＝％.4f Mx＝％4f Mup＝％d\n＂，
1，
arr_srt[0].letter，
arr_srt[0].w，
arr_srt[0].y，
arr_srt[0].x，
arr_srt[0].pen_up)；
<dp n="d145"/>
return(arr_srt[0].letter)；
}
k＝sort_b(i，b，w_level，y_level，x_level)；
if(k＝＝0)
{∥if(ch！＝arr_srt[0].letter)
fprintf(fout5，＂％d\n％c Mw＝％.4f My＝％.4f Mx＝％.4f Mup＝％d\n＂
1，
arr_srt[0].letter，
arr_srt[0].w，
arr_srt[0].y，
arr_srt[0].x，
arr_srt[0].pen_up)；
return(arr_srt[0].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[0].letter)
fprintf(fout5，＂％d\n％c Mw＝％.4f My＝％.4f Mx＝％.4f Mup＝％d\n＂，
1，
arr_srt[0].letter，
arr_srt[0].w，
arr_srt[0].y，
arr_srt[0].x，
arr_srt[0].pen_up)；
return(arr_srt[0].letter)；
}
else
{∥fprintf(fout4，＂％d long％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，＂％c Mw＝％.4f My＝％.4f Mx＝％.4f Mup＝％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[0].letter)；
}
int sort_w(intj，float level)
{int i；
char ch；
float temp-1，temp-2，temp_w，temp_y，temp_x，temp_pen up；
int pr＝1；
if(j＝＝0)return(0)；
while(pr＝＝1)
<dp n="d146"/>
{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[0].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)；
else return(i-1)；
}
int sort_y(int j，float level)
{inti；
char ch；
float tenmp_1，temp_2，temp_w，temp_y，temp_x，temp_pen_up；
int pr＝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；
<dp n="d147"/>
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[0].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)；
else return(i-1)；
}
int sort_x(intj，float level)
{int i；
char ch；
floa ttemp_1，temp_2，temp_w，temp_y，temp_x，temp_pen_up；
int pr＝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；
<dp n="d148"/>
}
else
{arr_srt[i-1].m＝temp_2；
arr_srt[i].m＝temp_1；
}
}
}
level＝arr_srt[0].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)；
else return(i-1)；
}
int check_map(char letter)
{
int i；
for(i＝0；i＜NUM_SYMBOLS；i++)
if(letter＝＝(char)map_char[i][0])return(i)；
if(i＝＝NUM_SYMBOLS)
{printf(＂There is no such character in the map％c\n＂，letter)；
return(-1)；
}
return(-1)；
}
void read_map(void)
{
FILE*fp；
int i；
fp＝fopen(＂map_ch＂，＂rb＂)；
for(i＝0；i＜NUM_SYMBOLS；i++)
fscanf(fp，＂％d％d\n＂，&map_char[i][0]，&map_char[i][1])；
fclose(fp)；
}
void r_matr(void)
{ FILE*fout1；
int i，j；
fout1＝fopen (＂matrix.out＂，＂w＂)；
for(i＝0；i＜69；i++)
fprintf(fout1，＂％c＂，map_char[i][0])；
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)；
}
<dp n="d149"/>
/******************************************************************************
The file＂err＂ is sorting using appropriate similanty
function defined with treshold level and it’s order.
******************************************************************************/
int main(void)
{
int check_map(charletter)；
void read_map(void)；
void add_metric(char ch，int letter_num，int loop)；
int sort_add(int j，float level)；
void read_map(void)；
void r_matr(void)；
char mtr_cl(int i，char ch)；
int spell_ch(char[10][20]，char[100][20])；
int letter_num，num_dir，loop；
char ch；
int i，k，j，num_inside，pr；
float level；
char reply[100][20]；
int repl；
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％d long＝％d％d\n＂，ch，letter_num，num_dir，/*loop＂/k+1)；
if(k＝＝0)
{∥if(ch！＝arr_srt[0].letter)
fprinft(fp1，＂％c＂w＝％，4fy＝％，4fx＝％.4fx_vec＝％.4f y_vec＝％.4f amp＝％4f up＝％d m＝％.4f\n＂，
arr_srt[0].letter，arr_srt[0].w，arr_srt[0].y，arr_srt[0].x，
arr_srt[0].x_vec，arr_srt[0].y_vec，arr_srt[0].amp，
arr_srt[0].pen_up，arr_srt[0].m)；
}
else
{∥fprintf(fout4，＂％d long％c{＂，num_dir.ch)；
for(i＝0；i＜＝k；i++)
<dp n="d150"/>
{∥fprintf(fout4，＂％c＂.arr_srt[i].letter)；
fprintf(fp1，＂％cw＝％.4fy＝％.4fx＝％.4fx_vec＝％.4fy_vec＝％.4famp＝％.4fup＝％d m＝％.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[0].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)；
return 0；
}
fclose(fp1)；
r_matt()；
return 0；
}
int check_map(cha letter)
{
int i；
for(i＝0；i＜NUM SYMBOLS；i++)
if(letter＝＝(char)map_char[i][0])return(i)；
if(i＝＝NUM_SYMBOLS)
{printf(＂There is no such character in the map％c\n＂，letter)；
return(-1)；
}
return(-1)；
}
void read_map(void)
{
FILE*fp；
int i；
fp＝fopen(＂map_ch＂，＂rb＂)；
for(i＝0；i＜NUM_SYMBOLS；i++)
fscanf(fp，＂％d％d\n＂，&map_char[i][0]，&map_char[i][1])；
fclose(fp)；
}
void r_matr(void)
{ FILE*fout1：
int i，j；
fout1＝fopen(＂matrix.out＂，＂w＂)；
for(i＝0；i＜69：i++)
fprintf(fout1.＂％c＂，map_char[i][0])；
fprintf(fout1.＂\n＂)；
for(i＝0；i＜69：i++)
{for(j＝0；j＜69：j++)
<dp n="d151"/>
fprintf(fout1，*％2d＂，mat[i][j])；
fprintf(fout1.＂\n＂)；
}
fclose(fout1)；
}
/*********************************************************************
function add_metric() for the every letter(according to it’s number
and name)searches it’s parameters in the files feat.out and feat1.out
and calculates conesponding metrics.
**********************************************************************/
void add_metric(char ch，int letter_num，int loop)
{
void add_metr_feat(int loop)；
void add_metr_feat1(int loop)；
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：
}
}
}
/*********************************************************************
functions add_metr_feat() calculates similarity function on onthe base of
distance between recognized symbol’s vector(connecting start point with
the end point ofthe symbol)and generalized symbol’s vector defined
during the teaching.
*********************************************************************/
void add_metr_feat(int loop)
{
int i，j；
FlLE*fp；
float m_1，m-2.m-3.m_4；
char temp_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＜3：j++)
{fscanf(fp.＂％f％f％f％f\n＂，&x_dev[j].x_b，&x_dev[j].x_e，
<dp n="d152"/>
&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；
}
}
}
}
/*********************************************************************
functions add_metr_feat1 O calculates similarity function on the base of
distance between recognized symbol’s amplitude and symbol’s generalized
ampliude calculated during theteaching.
*********************************************************************/
void add_metr_feat1(int loop)
{
int i，j；
FILE*fp；
float m_1；
char temp_letter；
int y_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’s better to find min and max for all the symbols
∥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_1：
break：
}
}
}
}
void max_min(void)
{ FILE*fp；
char temp_letter；
int y_max；
int y_min；
int j；
<dp n="d153"/>
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)；
}
/*********************************************************************
similarity function defines similarity between parameter and sample of
parameters with known medial．left and right deviation，and range of definition
(const_l，const_r)
*********************************************************************/
float mut_metric(float param，float medial，float const*l，float_l，const_r，
float dev_l，float dev_r
{ float left，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＝0 0；
return(m)；
}
/*********************************************************************
average similarity function definition，final sorting using treshold
*********************************************************************/
extern struct SRT1 arr_srt[600]；
int sort_add(intj.fioat level)
{ int i；
char ch；
float temp_1，temp_2，temp_w，temp_y，temp_x，temp_x_vec，temp_y_vec，temp_amp；
int temp_up；
int pr＝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；
<dp n="d154"/>
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_ve c；
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[0].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)；
else return(i-1)；
}
char mtr_cl(int i，char ch)
{ int j；
for(j＝0；j＜＝i；j++)
if(ch＝＝arr_srt[j].letter)return(arr_srt[j].letter)；
return(arr_srt[0].letter)；
}
加速度识别
i.训练过程
/************************************
To define the works condition.
************************************/
void main(void)
{
FILE*fp；
char filename[30]；
int index；
char num[4]；
char ch；
int k；
printf(＂Do you want to do PRESS(y/n)：＂)；
ch＝getche()；
fp＝fopen(＂fpr，＂w＂)；
if(toupper((int)ch)＝＝＂Y′)fprintf(fp，＂％d＂，1)；
else fprintf(fp，＂％d＂，0)；
fclose(fp)；
printf(＂\n Do you want to do SMOOTH(y/n)：＂)；
ch＝getche()；
fp＝fopen(＂fsm＂，＂w＂)；
if(toupper((int)ch)＝＝′Y)fprintf(fp，＂％d＂，1)；
else fprintf(fp，＂％d＂，0)；
fclose(fp)；
printf(＂\n Enter amout of level：＂)；
scanf(＂％d＂，&k)；
fp＝fopen(＂flv＂，＂w＂)；
fprintf(fp，＂％d＂，k)；
fclose(fp)；
}
/* 教导用主程序 */
void main(void)
{
FILE*fp；
FILE*fp1；
char infile[30]；
char filename1[30]；
int number；
int index；
int num；
int num_mut；
char num_ch[4]；
int sp_amount；
int zon_x[10]；
int zon_y[10]；
float arr_x[NUMBER_OF_STROKES]；
float arr_y[NUMBER_OF_STROKES]；
float arr_z[NUMBER_OF_STROKES]；
float arr_p[NUMBER_OF_STROKES]；
int x，y，z，p，pen_old，i；
<dp n="d156"/>
int arr_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++； ∥amount in the space
if(num＞NUMBER_OF_STROKES)
{ printf(＂Amount of penstrokes in the space is biggerthen％d\n＂，NUMBER_OF_STROKES)；
getch()；
exit(0)；
}
num_mut++；∥amount in the file
}
else
{ prep(num，num_mut，sp_amount，arr_x，arr_y，arr_z)；
sp_amount++；∥amount of space
pen_old＝p；
arr_x[0]＝(float)x；
arr_y[0]＝(float)y；
arr_z[0]＝(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)；
}
<dp n="d157"/>
/************************************
Get work’s conditions.
************************************/
void prep(int num，int num_mut，int sp_amount，float arr_x[]，
float arr_y[]，float arr_z[])
{
FILE*fp；
int pr，sm，amount_lev；
if((fp＝fopen(＂fpr＂，＂r＂))＝＝NULL)
{ printf(＂Impossible to open the file′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(＂Impossible to open the file′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)；
}
/************************************
Save one space information to output file.
************************************/
void save(int space，int num_mut.int arr_beg_end[]，FILE*fp)
{int i，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[0]/(float)g[space].num，
(float)arr_beg_end[1]/(float)g[space].num)；
}
<dp n="d158"/>
/************************************
Calculate coordinates accordingly to amount of levels.
************************************/
void level(int num，int num_mut.int space，float arr_x[]，
float arr_y[]，float arr_z[])
{ int i，j；
FILE*fp；
float min_x＝9999.0；
float max_x＝0.0；
float min_y＝9999.0；
float max_y＝0.0；
float min_z＝9999.0；
float max_z＝0.0；
int sum；
int pr；
int temp；
float kx，ky，kz；
int lev；
/************************************
k-amount of level
************************************/
if((fp＝fopen(＂flv＂，＂r＂))＝＝NULL)
{printf(＂lmpossible to open the file′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(＂-Decrease the number of levels！！！-\n＂)；
getch()；
}
for(i＝0；i＜num；i++)
{g[space].f[i].x＝(int)(((float)(arr_x[i]-min_x)-0 001)/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)；
}
/************************************
Calculate the coordinates of null zone
************************************/
void nul_zone(int space，int arr_beg_end[])
{ int beg，end.dif；
int beg_max.end_max：
<dp n="d159"/>
int pr＝0；
int j；
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[0]＝beg_max+1；
arr_beg_end[1]＝ena_max+1；
}
/************************************
Do smoothing
************************************/
float smooth1(int num，float z[])
{
int ind；
float temp；
float norma；
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；
}
return norma：
}
<dp n="d160"/>
void smooth(int max_point，float arr[])
{float end smooth；
wnile((end_smooth＝smooth1(max_point，arr))＞PRESS_NUMBER_POINT/10)；
}
/************************************
Change file coordinates accordingly new length.
************************************/
void normal(int num_old，float arr_old[]，int num_new，float arr_new[])
{
double koeff；
intind_old，ind_new；
koeff＝(double)(num_old-1)/(float)(num_new-1)；
arr_new[0]＝arr_old[0]；
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]；
}
void press(int num，float arr[])
{ float new_arr[100]；
int i；
normnal(num，arr，PRESS_NUMBER_POINT，new_arr)；
for(i＝0；i＜PRESS_NUMBER_P0lNT；i++)
arr[i]＝new_arr[i]；
}
II一般化过程
/* 一般化过程主程序 */
void main(void)
{
void gener(int i，char filename[]，char filename1[])；
FILE*fp，*fp1；
int i；
char num[4]；
char filename[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)；
}
}
<dp n="d161"/>
void def_par(float arr[MAX_REPRESNT+1[NUMBER_SPACE+1).int amount
int space，char filename1[])；
void open_file(char filename1[]，int amount，int letter)
{ FILE*fp；
fp＝fopen(fiename1，＂a+＂)；
fprintf(fp，＂％d％d\n＂，letter，amount)；
fclose(fp)；
}
/************************************
Generalize information for all the letter.
************************************/
void gener(inti，char filename[]，char filename1[])
{
int getherrint letter，int num_space，char filename[]，char filename1[])；
intj；
int amount；
for(j＝0；j＜SYMBOLS_NUMBER；j+f)
{amount＝gether(j，i，filename，filename1)；
}
}
/************************************
Generalize information for one letter.
************************************/
int gether(intletter，int num_space，char filename[]，char filename1[])
{ int amount；
FILE*fp；
FILE*fp1；
int in，space，num_mut，sp_num，x，y，z，i，j，length，l；
float space_length[MAX_REPRESNT+1][NUMBER_SPACE+1]；
float beg[MAX_REPRESNT+1][NUMBER_SPACE+1]；
float end[MAX_REPRESNT+1][NUMBER_SPACE+1]；
float nul_beg[MAX_REPRESNT+1][NUMBER_SPACE+1]；
float nul_end[MAX_REPRESNT+1][NUMBER_SPACE+1]；
int temp；
float mut_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][0]＝(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+＂)；
fp rintf(fp1，＂％d\n＂，temp)；
if(amount＝＝MAX_REPRESNT)
{fclose(fp)；
fclose(fp1)；
printf(＂Representation is too huge\n＂)
getch()
return(777)；
}
<dp n="d162"/>
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)；
}
/***************************************************************************
Calculates medial x and y coordinates and their dispersions
***************************************************************************/
void def_par(float arr[MAX_REPRESNT+1][NUMBER_SPACE+1]，int amount，
int space，char filename1[])
{int count，i；
float dev[NUMBER_SPACE+1]；
float midll[NUMBER_SPACE+1]；
float summ；
float temp；
float max[NUMBER_SPACE+1]；
float min[NUMBER_SPACE+1]
FILE*fp；
for(i＝0；i＜＝space；n++)
{max[i]＝0.0；
min[i]＝9999.9；
<dp n="d163"/>
}
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；
}
/**************************************************************************
function calc_vec calculates medial x and y coordinates and their dispersions
of the vectorjoining the first point ofthe symbols’trajectory and the last
***************************************************************************
void calc_vec(int amount)
{int count，i；
float summ_1＝0.0；
float summ_2＝0.0；
float summ_3＝0.0；
float summ_4＝0.0；
float summ_1m＝0.0；
float summ_2m＝0.0；
float summ_3m＝0.0；
float summ_4m＝0.0；
float temp；
int am1，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][0].y_b；
summ_3＝summ_3+bx[i][0].x_e；
summ_4＝summ_4+by[i][0].y_e；
}
x_midll[0].x_b＝summ_1/(float)amount；
y_midll[0].y_b＝summ_2/(float)amount；
x_midll[0].x_e＝summ_3/(float)amount；
y_midll[0].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
<dp n="d164"/>
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[0].x_b-bx[i][0].x_b；
if(temp＞0.0)
{summ_1＝summ_1+temp*temp；
am1++；
}
else
{summ_1m＝summ_1m+temp*temp；
am2++；
}
temp＝y_midll[0].y_b-by[i][0].y_b；
if(temp＞0.0)
{summ_2＝summ_2+temp*temp；
am3++；
}
else
{summ_2m＝summ_2m+temp*temp；
am4++；
}
temp＝x_midll[0].x_e-bx[i][0].x_e；
if(temp＞0.0)
{summ_3＝summ_3+temp*temp；
am5++；
}
else
{summ_3m＝summ_3m+temp*temp；
am6++；
}
temp＝y_midll[0].y_e-by[i][0].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[0].x_b＝0.0； ∥dev-
else x_dev[0].x_b＝sqrt(summ_1/(float)am1)；
if(am2＝＝0)x_dev[1].x_b＝0.0； ∥dev+
else x_dev[1].x_b＝sqrt(summ_1m/(float)am2)；
if((am1+am2)＝＝0)x_dev[2].x_b＝0.0； ∥dev
else x_dev[2].x_b＝sqrt((summ_1+summ_1m)/(float)(am1+am2))；
if(am3＝＝0)y_dev[0].y_b＝0.0； ∥dev-
else y_dev[0].y_b＝sqrt(summ_2/(float)am3)；
if(am4＝＝0)y_dev[1].y_b＝0.0； ∥dev+
else y_dev[1].y_b＝sqrt(summ_2m/(float)am4)；
<dp n="d165"/>
if((am3+afm4)＝＝o)y_dev[z].y_b＝0.0； ∥qev
else y_dev[2].y_b＝sqrt((summ_2+summ_2m)/(float)(am3+am4))；
if(am5＝＝0)x_dev[0].x_e＝0.0； ∥dev-
else x_dev[0].x_e＝sqrt(summ_3/(float)am5)；
if(am6＝＝0)x_dev[1].x_e＝0.0； ∥dev+
else x_dev[1].x_e＝sqrt(summ_3m/(float)am6)；
if((am5+am6)＝＝0)x_dev[2].x_e＝0.0； ∥dev
else x_dev[2].x_e＝sqrt((summ_3+summ_3m)/(float)(am5+am6))；
if(am7＝＝0)y_dev[0].y_e＝0.0； ∥dev-
else y_dev[0].y_e＝sqrt(summ_4/(float)am7)；
if(am8＝＝0)y__dev[1].y_e＝0.0； ∥dev+
else y_dev[1].y_e＝sqrt(summ_4m/(float)am8)；
if((am7+am8)＝＝0)y_dev[2].y_e＝0.0； ∥dev
else y_dev[2].y_e＝sqrt((summ_4+summ_4rm)/(float)(am7+am8))；
}
III.识别过程
/* 用于识别的主程序 */
struct G g[NUMBER_SPACE]；
float beg_end[NUMBER_SPACE][2]；
void main(void)
{
FILE*fp；
FILE*fp1；
charin infile[30]；
char filename1[30]；
int number；
int index；
int num；
int num_mut；
char num_ch[4]；
int sp_amount；
int zon_x[10]；
int zon_y[10]；
int letter；
float arr_x[NUMBER_OF_STROKES]；
float arr_y[NUMBER_OF_STROKES]；
float arr_z[NUMBER_OF_STROKES]；
float arr_p[NUMBER_OF_STROKES]；
int x，y，z，p，pen_old，i；
int arr_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＝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)
{
<dp n="d166"/>
arr_x[num]＝(float)x；
arr_y[num]＝(float)y；
arr_z[num]＝(float)z；
num++； //amount in the space
if(num＞NUMBER_OF_STROKES)
{printf(＂Amount of penstrokes in the space is biggerthen％d\n＂，NUMBER_OF_STROKES)；
getch()；
exit(0)；
}
num_mut++；∥amount in the file
}
else
{prep(num，num_t，sp_amount，arr_x，arr_y，arr_z)；
sp_amount++；∥amount of space
prep(num，num_mut，sp_amount，arr_x，arr_y，arr_z)；
pen_old＝p；
arr_x[0]＝(float)x；
arr_y[0]＝(float)y；
arr_z[0]＝(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)；
}
int main(void)
{
FILE*fp，*fp2；
int i，lev，j；
char filename[30]，filename1[30]；
float lev_sort
int lev_rb.lev_re；
fp＝fopen(＂flv＂，＂r＂)
fscanf(fp，＂％d＂.&lev)；
fclose(fp)；
printf(＂Enter level for sorting：＂)；
scanf(＂％f＂.&lev_sort)；
printf(＂Enter level for begin null zone：＂)；
scanf(＂％d＂，&lev_rb)
printf(＂Enter level for end null zone；＂)；
<dp n="d167"/>
scanf(＂％d＂，&lev_re)；
/****************************************************/
∥ for confusion table
for(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)；
/****************************************************/
∥ for confusion table
fp＝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)；
/****************************************************/
return 0；
}
/****************************************************
Create sorting array according to sorting level.
****************************************************/
int cutt_sort(int num，float lev_sort，struct S sort[])
{int i，j；
float lev；
float max＝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＝0 0；
j＝0；
for(i＝0；i＜num；i++)
if(sort[i].w＞＝lev)
{if(j！＝i)sort[j]＝sort[i]；
j++；
}
return(j)；
}
int sort_funct(const void*a，const void*b)
{if(((struct S*)a)-＞m＞((struct S*)b)-＞m)refurn(-1)；
if(((struct S*)a)-＞m＜((struct S*)b)-＞m)return(1)
return(0)；
}
<dp n="d168"/>
/**********************************
Create file sign recognition．
***********************************/
void recogn(FILE*fp，FILE*fp2，int Iev，float Iev_sort，int Iev_rb，int Iev_re)
{
struct S sort[SYMBOLS_NUMBER]；
FILE*fp1；
char fiename1[30]；
float beg[NUMBER_SPACE]；
float end[NUMBER_SPACE]；
int space，num_mut，space_cur；
double koef；
int number，i，j，letter，amount，length，1；
char num[5]；
float midil，dev，metr；
float x[NUMBER_OF_STROKES]；
float y[NUMBER_OF_STROKES]；
float z[NUMBER_OF_STROKES]；
float x_rec[NUMBER_OF_STROKES]；
float Y＿rec[NUMBER_OF_STROKES]；
float z_rec[NUMBER_OF_STROKES]；
float new_arr[NUMBER_OF_STROKES]；
int temp1，temp2，temp3；
float max，min；
float summ；
float summl;
float m[MAX_REPRESNT][NIMBER_SPACE]；
float ml[MAX_REPRESNT][NUMBER_SPACE]；
float b_0[NUMBER_SPACE]；
float e_0[NUMBER_SPACE]；
float munlt；
int symb_num；
char name_file[20]；
float lev_sort1；
int num_for_sort；
char letter_print；
int SeqNo；
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)；/*letter from recognition ser*/for(i＝0：i＜＝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＝0：j＜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”)；
<dp n="d169"/>
fp1＝fopen(filename1，＂r＂)；
symb_num＝0；
while(fscanf(fp1，＂％d＂，&sort[symb_num].letter)！＝EOF)/*letter from gen set*/
{
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(x rec，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，new arr，g[j].num，lev)；
summl+＝metricl(y_rec，new_arr，g[j].num，lev，lev_rb，lev_re)；
<dp n="d170"/>
normal(length，z，g[j].num，new_arr)，
summ+＝metric(z_rec，new arr，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(struct S)，sort_funct)；
i＝0；
if(name_file[0]！＝′b’)
{letter_print＝name_file[0]；
SeqNo＝(int)(name_file[2]-48)；
}
else
{if(isdigit((int)name_file[1])！＝0)
{letter_print＝name_file[0]；
SeqNo＝(int)(name_file[2]-48)；
}
<dp n="d171"/>
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)；
/****************************************/
∥ for confusion table
conf[number-1][sort[0].letter-1]++；
/****************************************/
while(i＜num_for_sort)
{fprintf(fp2，％3d*，sort[i].letter)；
fprintf(fp2，＂W＝％.5f mut_len＝％.5f beg_end＝％.5f m_O＝％.5f midll＝％.5f\n＂，
sort[i].w，sort[i].mut_len，sort[i].beg_end，sort[i].m_O，sort[i].m)；
i++；
}
}
}
/***************************************************************************
similarty function defines similarity between parameter and sample of
parameters with known medial，left and right deviation，and range of definition
(const_l，const_r)
****************************************************************************/
float mut_metnc(float param，float medial，float const_l，float const_r，
float dev_l，float dev_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)；
}
/****************************************
Calculate file coordinates accordingly new length.
****************************************/
void normal(int num_old，float arr_old[]，int num_new，float arr_new[])
{
double koeff；
int ind_old，ind_new；
koeff＝(double)(num_old-1)/(float)(num_new-1)；
arr_new[0]＝arr_old[0]；
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]；
}
<dp n="d172"/>
arr_new[ind_new]＝arr_old[num_old-1]；
}
/****************************************
Calculate level’s metric.
*****************************************/
float metric(float z1[]，float z2[]，int length，int lev)
{ inti；
float summ＝0；
for(i＝0；i＜length；i++)
summ＝summ+fabs(z1[i]-z2[i])；
return(summ/(float)(length*(lev-1)))；
}
/****************************************
Calculate zone metric.
****************************************/
float metricl(float a[]，float b[]，intlength，int lev，int beg，int end)
{
int calc＝0；
int i；
float s＝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)；
}
图形书写板识别和加速度识别的复合结果
struct TAB_ACS
{char name；
float tab_w；
float acs_w；
float y；
float x_vec；
float y_vec；
float amp；
int up；
float m_tab；
float mut_len；
float beg_end；
float m_acs；
float midll；
}；
int matr[100][100]；
void write_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)；
}
char conv_char(int in_name)
{if(in_name＜27)return((char)(in_name+96))；∥a-z 1-26
if(in_name＜53)return((char)(in_name+38))；∥A-Z 27-52
if(in_name＜63)return((char)(in_name-5))；∥0-9 53-62
return(0)；
}
int conv_int(char a)
{if(a＜58)return((int)a+4)；
if(a＜91)return((int)a-39)；
if(a＜123)return((int)a-97)；
return(0)；
}
void matr_add(char a，char b)
{matr[conv_int(a)][conv_int(b)]++；
}
int sort funct(const void*a.const void*b)
<dp n="d174"/>
{if(((struct TAB_ACS*)a)-＞midll＞((struct TAB_ACS*)b)-＞midll)return(-1)；
if(((struct TAB_ACS*)a)-＞midll＜((struct TAB_ACS*)b)-＞midll)return(1)；
return(0)；
}
void main(void)
{struct ACS
{ char name；
float w；
float mut_len；
float beg_end；
float m_O；
float midll；
}；
struct TAB
{char name；
float w；
float y；
float x；
float x_vec；
float y_vec；
float amp；
int up；
float m；
}；
struct TAB tab[100]；
struct ACS acs[100]；
sfruct TAB_ACS tab_acs[100]；
FILE*fp，*fp1，*fout；
int i，k，l；
char name_file_tab；
char name_file_acs；
int num_file_tab，num_file_acs；
int num_tab.num_acs；
int in_name；
float temp；
char tempc；
int pr；
int find file；
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)；
<dp n="d175"/>
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[0].name)；
fseek(fp1，0L，SEEK_SEtT)；
continue；
}
if(acs[0].name＝＝tab[0].name)
{matr_add(name_file_tab，tab[0].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；
<dp n="d176"/>
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[0].name)；
else
{qsort(tab_acs，k，sizeof(struct TAB_ACS)，sort_funct)；
matr_add(name_file_tab，tab_acs[0].name)；
for(l＝0；kk；l++)
fprintf(fout，“％c-tab_m＝％.4f acs_midll＝％.4f tab_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；
}
附录C；PALASM设计说明；----------------------------------说明部分 ------------题目PALASM设计说明方式版本1.0授权者HANNA和VECTOR公司 BAR ON日期02/27/94芯片_PAL PAC22V10.
-------------------------PIN Declarations---------------
PIN 1 CLK COMBINATORIAL ；CLOCK＝12.88MHZ
PIN 2 /RD COMBINATORIAL ；INPUT
PIN 3 A0 COMBINATORIAL ；INPUT
PIN 4 A1 COMBINATORIAL ；INPUT
PIN 5 A2 COMBINATORIAL ；INPUT
PIN 6 A3 COMBINATORIAL ；INPUT
PIN 7 A4 COMBINATORIAL ；INPUT
PIN 8 A5 COMBINATORIAL ；INPUT
PIN 9 /RS COMBINATORIAL ；INPUT
PIN 10 /REC0 COMBINATORIAL ；INPUT
PIN 11 /REC1 COMBINATORIAL ；INPUT
PIN 12 GND
PIN 13 IOCS COMBINATORIAL ；INPUT
；OUTPUT
PIN 14 /CSC0 COMBINATORIAL ；INPUT
PIN 15 /CSC1 COMBINATORIAL ；INPUT
pin 16 /R2 REGISTERED
PIN 17 /R1 REGISTERED
PIN 18 /R0 REGISTERED
PIN 19 MR1 COMBINATORIAL ；OUTPUT
PIN 20 MR0 COMBINATORIAL ；OUTPUT
PIN 21 OUTR1 COMBINATORIAL ；OUTPUT
PIN 22 OUTR0 COMBINATORIAL ；OUTPUT
PIN 23 /GD COMBINATORIAL ；OUTPUT
PIN 24 VCC
；--------------------------------------------------------------------------------------------------------------------------------------
STRING ADD1’IOCS*RD*/A5*/A4*/A3*A2*A1*A0’
STRING ADD2’IOCS*RD*/A5*/A4*A3*/A2*/A1*/A0’
；--------------------------------------------------------------------------------------------------------------------------------------
STATE
MOORE MACHINE
START UP：＝POWER UP-＞idle
IDLE：＝ RS1 -＞CON1
+RS2 -＞ CON2
+-＞IDLE
<dp n="d178"/>
CON1：＝/RD -＞CON3
+RD -＞CON1
CON2：＝/RD -＞CON4
+RD -＞CON2
CON3：＝VCC -＞IDLE
CON4：＝VCC -＞IDLE
；------------------------------------------------------------------------------------------------------
IDLE＝/R0*/R1*/R2
CON1＝R0*/R1*/R2
CON2＝/R0*R1*/R2
CON3＝R0*R1*/R2
CON4＝/R0*/R1*R2
；--------------------------------------------------------------------------------------------------------
IDLE.OUTF＝/MR0*/MR1
CON1.OUTF＝/MR0*/MR1
CON2.OUTF＝/MR0*/MR1
CON3.OUTF＝MR0
CON4.OUTF＝MR1
；--------------------------------------------------------------------------------------------------------
CONDITIONS
RS1＝ADD1
RS2＝ADD2
；---------------------------------------------------------------------------------------------------------
EQUATIONS
OUTR0＝RS*REC0
OUTR1＝RS*REC1
GD＝IOCS*RD*((/A5*/A4*/A3*A2*(A0：+：A1))+CSC0+CSC1)
；--------------------------------------------------------------------------------------------------------------------------------
simulation
TRACE ON CLK RD MR0 MR1 IOCS A0 A1 A2 A3 A4 A5
PRELOAD IDLE
SETF RD IOCS/A0/A1 /A2/A3 /A4/A5
CLOCKF CLK
CLOCKF CLK
CLOCKF CLK
SETF A3
CLOCKF CLK
LOCKF CLK
CLOCKF CLK
SETF/RD
CLOCKF CLK
CLOCKF CLK
SETF/IOCS RD/A3 A2 A1/A0/CSC0/CSC1
SETF IOCS
SETF A0/A1
<dp n="d179"/>
SETF/A0
SETF CSC0
SETF CSC1/CSC0
TRACE_OFF
<dp n="d180"/>
；PACASM设计说明
------------------------ 说明部分 -------------
题目 PALASM设计说明
方式
版本 1.0
授权者 HANNA和VECTOR
公司 BAR ON
日期 02/27/94
芯片 __PAL PAC22V10
；--------------------------------PI N DecIarations---------------
PIN 1 /RD
PIN 2 FRES
PIN 3 A0
PIN 4 A1
PIN 5 A2
PIN 6 A3
PIN 7 A4
PIN 8 A5
PIN 9 Q0 ；INPUT
PIN 10 Q1 ；INPUT
PIN 11 ANR ；INPUT
；OUTPUT
PIN 13 IOCS
PIN 14 /LS
PIN 15 /CSDAC
PIN 16 /CONVST0
PIN 17 /CONVST1
PIN 18 /CSADC0
PIN 19 /CSADC1
PIN 20 /CSCOUNT0
PIN 21 /CSCOUNT1
PIN 22 CPCOUNT0
PIN 23 CPCOUNT1
；---------------------------------- 等式部分 ---------
EQUATIONS
LS＝IOCS*/A5*/A4*/A3*/A2
CSDAC＝IOCS*WR*/A5*/A4*/A3*(/A2+A2*/A1*/A0)
CONVST0＝IOCS*WR*/A5*/A4*/A3*A2*/A1*A0
CONVST1＝IOCS*WR*/A5*/A4*/A3*A2*A1*/A0
CSADC0＝IOCS*/A5*/A4*/A3*A2*/A1*A0
CSADC1＝IOCS*/A5*/A4*/A3*A2*A1*/A0
CSCOUNT0＝IOCS*RD*/A5*/A4*/A3*A2*A1*A0
CSCOUNT1＝IOCS*RD*/A5*/A4*A3*/A2*/A1*/A0
/CPCOUNT0＝FRES*Q0
/CPCOUNT1＝FRES*Q1
<dp n="d181"/>
-----------------------------------------------
SIMULATION
TRACE ON/RD FRES A0 A1 A2 A3 A4 A5 Q0 Q1/WR IOCS
SETF IOCS RD WR A0 A1 A2 A3 A4 A5 Q0 Q1 FRES
SETF /WR/A5/A4/A3/A2
SETF /IOCS
SETF IOCS
SETF /RD WR
SETF A2/A1/A0
SETF A0
SETF A1 /A0
SETF RD /WR A0
SETF A3 /A0/A1 /A2
SETF FRES Q0
SETF /FRES/Q0
<dp n="d182"/>
；PALASM设计说明
；---------------------------Declaration Segment-----------
题目PALASM设计说明
方式
版本1.0
授权者HANNA和VECTOR
公司 BAR ON
日期 02/27/94
芯片__PAL PAC22V10
-----------------------------PIN DacIarations-------------
PIN 1 A6 ；INPUT
PIN 2 A7
PIN 3 A8
PIN 4 A9
PIN 5 A10
PIN 6 A11
PIN 7 A12
PIN 8 A13
PIN 9 /DMS ；INPUT
PIN 10 /PMS ；INPUT
PIN 11 /RD ；INPUT
PIN 14 /DMS0 ；OUTPUT
PIN 15 /DMS1 ；OUTPUT
PIN 16 /PMS0 ；OUTPUT
PIN 17 /PMS1 ；OUTPUT
PIN 18 /DMRD ；OUTPUT
PIN 19 /IOCS2
PIN 20 IOCS1
；------------------------------Boolean Equation Seqment-------
STRING IO’A13*A12*/A11*A10*A9*A8*A7*A6’
EQUATIONS
IOCS1＝IO*DMS
IOCS2＝IO*DMS
DMS0＝/A13*DMS
DMS1＝A13*DMS
PMS0＝/A13*PMS
PMS1＝A13*PMS
DMRD＝(/A13+/A12+A11+/A10+/A9+/A8+/A7+/A6)*DMS*RD
；--------------------------------------Simulation Seqment-------------
SIMULATION
trace on IOCS1 IOCS2 DMS0 DMS1 PMS0 PMS1 DMRD
SETF A13 A12 A11 A1 0 A9 A8 A7 A6 DMS/RD/PMS
SETF A13 A12 A11 A10 A9 A8 A7 A6/DMS/RD PMS
<dp n="d183"/>
SETF A13 A12 /A11 A10 A9 A8 A7 /A6 DMS RD
SETF A13 A12 /A11 A10 Ag A8 A7 A6 DMS RD
SETF /A13/DMS PMS
SETF /A13 DMS/PMS
SETF A13
SETF /DMS PMS
；------------------------------------------------------------------
附录D
.MODULE/SEG＝prog_mem ibmstr02；
.ENTRY StartUp；
.INCLUDE ＜d：\adi dsp\include\def2101.h＞；
.CONST TSCALE＝0；
.CONST TCOUNT＝0×8fff；
.CONST TPERIOD＝0×8fff；
.VAR/CIRC/DM/RAM/SEG＝data_mem Package[4]；
.VAR/CIRC/DM/RAM/SEG＝data_mem Shifter_Const[8]；
.VAR/CIRC/DM/RAM/SEG＝data_mem Masks[8]；
.GLOBAL Package；
.GLOBAL Shifter_Const；
.GLOBAL Masks；
.INIT Shifter_Const：＜sh_const.dat＞；
.INIT Masks：＜masks.dat＞；
StartUp：
{ Set System Corntrol Register：SPORTO-enable，SPORTl-enable }
AX0＝0×1c1f；
DM(Sys_Ctrl_reg)＝AX0；
{-----------------------------------------------------------------------}
{ Load Tperiod Register for 10 milliseconds }
AX0＝TPERIOD；
DM(Tperiod_Reg)＝AX0；
{-----------------------------------------------------------------------}
{ Load Tcount Register for 10 milliseconds }
AX0＝TCOUNT；
DM(Tcount_Reg)＝AX0；
{-----------------------------------------------------------------------}
{ Load Tscale Register }
AX0＝TSCALE；
DM(Tscale_Reg)＝AX0；
{-----------------------------------------------------------------------}
{ Set SPORT0 Control Register：ISCLCK-enable，SLEN＝(1+8+1)-1 }
AX0＝B#0100101000001001；
DM(Sport0_Ctrl_Reg)＝AX0；
{-----------------------------------------------------------------------}
{ Set SPORT0 Clock Divider to 19200 baud }
AX0＝0×13f；
DM(Sport0 Sclkdlv)＝AX0 ；
{-----------------------------------------------------------------------}
{ Set SPORT1 Control Register：ISCLCK-enable，SLEN＝(8-1) }
AX0＝0×4a07 ；
DM(Sportl_Ctrl_Reg)＝AX0 ；
{-----------------------------------------------------------------------}
{ Set SPORT1 Clock Divider to 80000 cycles
AX0＝0×004c；
DM(Sportl Sclkdiv)＝AX0；
<dp n="d185"/>
{-----------------------------------------------------------------------}
{ Set parameters of Circ Buffer package }
I0＝＾Package；
M0＝1；
L0＝％Package；
I1＝I0；
{-----------------------------------------------------------------------}
{ Set Interrupt Control Reg，Set IMASK Reg，Set MSTAT Reg}
ICNTL＝0×17；
IMASK＝0×39；
{-----------------------------------------------------------------------}
{ Set Parameters of Circ Buffer Shifter_const }
I2＝＾Shifter Const；
I3＝＾Masks；
M2＝1；
M3＝1 ；
L2＝％Shifter_Const；
L3＝％Masks；
{-----------------------------------------------------------------------}
RTS；
ENDMOD；
<dp n="d186"/>
.MODULE/SEG=prog_mem ibmwac0l；
.INCLUDE ＜d：\adi_dsn\include\det2101.h>；
.CONST MASK_RS232=B#0000000001；
.CONST DATA_BITS_1=B#11111110；
.CONST DATA_BITS_2=B#00000000111111100；
.CONST MASK_SYNCHROBIT=B#100000000；
.CONST EXCITATION_WORD=0×0055；
.EXTERNAL StartUp；
.EXTERNAL Revers；
.PORT x_counter_port；
.PORT y_counter_port；
.EXTERNAL Package；
JUMP StartMouse；NOP；NOP； NOP； {Interupt vector table}
RTI；NOP ； NOP；NOP； {No interrupts used}
JUMP Transmit Next；NOP；NOP；NOP；
RTI； NOP； NOP ； NOP；
RTI； NOP； NOP；NOP；
RTI；NOP；NOP；NOP；
JUMP Sampling； NOP；NOP； NOP；
StartMouse：{Setting all Control Registers and other parameters}
{ Set sygtem parameters：Timer，SPORT’s }
CALL StartUp；
{--------------------------------------------------------------}
{ Set parameters of Circ Buffer
I0=＾Package；
M0=1；
L0=％Package；
I1＝I0
{--------------------------------------------------------------}
{ Set Interrupt Control Reg，Set IMASK Reg，Set MSTAT Reg
ICNTL=0×17；
IMASK=0×39；
MSTAT=0×30；
{--------------------------------------------------------------}
{ Send first signal to UST }
TX1＝EXCITATION_WORD；
{--------------------------------------------------------------}
MLoop： {Main loop of program}
IDLE； {wait for Timer Interrupt}
JUMp MLoop；
Sampling：{Timer Interrupt Service rcutine(every 3ms)}
MR0＝DM(x_counter_port)； {Read X ccunter}
MR1＝DM(y_counter_port)； {Read Y counter}
Tx1＝EXCITATION_WORD； {Transmit signal to UST}
{
èёёёёёёёùёёёёёёёёёùёёёёёёёёёùёёёёё<paragraph id="d315">
<image width="5" height="9" src="A9510140701981.gif"/>
</paragraph>ёёёёё<paragraph id="d316">
<image width="5" height="9" src="A9510140701982.gif"/>
</paragraph>ёёёёё<paragraph id="d317">
<image width="5" height="9" src="A9510140701983.gif"/>
</paragraph>ёёёёё<paragraph id="d318">
<image width="5" height="9" src="A9510140701984.gif"/>
</paragraph>ёёёёё<paragraph id="d319">
<image width="5" height="9" src="A9510140701985.gif"/>
</paragraph>ёёёёё<paragraph id="d320">
<image width="5" height="9" src="A9510140701986.gif"/>
</paragraph>ёёёёёùёёёёёё
¤ pack ¤ 9 ¤ 8 ¤ 7 ° 6 ° 5 ° 4 ° 3 ° 2 ° 1 C 0 ¤
<dp n="d187"/>
¤ for _ёёёёёёёёё_ёёёёёёёёё_ёёёёёüёёёёёüёёёёёüёёёёёüёёёёёüёёёёёüёёёёё_ёёёёё<paragraph id="d321">
<image width="10" height="10" src="A9510140701991.gif"/>
</paragraph>ё<paragraph id="d322">
<image width="5" height="19" src="A9510140701992.gif"/>
</paragraph>
¤ PC ¤Start Bit¤Sync. Bit¤ Data Bits ¤Stoo ¤
¤ёёёёёёё_ёёёёёёёёё_ёёёёёёёёё_ёёёёё<paragraph id="d323">
<image width="6" height="13" src="A9510140701993.gif"/>
</paragraph>ёёёёё<paragraph id="d324">
<image width="6" height="10" src="A9510140701994.gif"/>
</paragraph>ёёёёё<paragraph id="d325">
<image width="6" height="11" src="A9510140701995.gif"/>
</paragraph>ёёёёё<paragraph id="d326">
<image width="7" height="10" src="A9510140701996.gif"/>
</paragraph>ёёёёё<paragraph id="d327">
<image width="6" height="10" src="A9510140701997.gif"/>
</paragraph>ёёёёё<paragraph id="d328">
<image width="8" height="11" src="A9510140701998.gif"/>
</paragraph>ёёёёё_<paragraph id="d329">
<image width="5" height="9" src="A9510140701999.gif"/>
</paragraph>
¤Byte 1 ¤ 0 ¤ 1 ¤ PEN ° F11 °F10 ° F09 °F08 °F07 °F06 ¤ 1 ¤
úááááááá_ááááááááá_ááááááááá_áááááéáááááéáááááéáááááéáááááéááááááéááááá_áááááN
¤Byte 2 ¤ 0 ¤ 0 ¤ 0 ° F05 °F04 ° F03 °F02 °F01 °F00 ¤ 1 ¤
úááááááá_ááááááááá_ááááááááá_áááááéáááááéáááááéáááááéáááááéááááááéááááá_áááááN
¤Byte 3 ¤ 0 ¤ 0 ¤ 0 ° S11 °S10 ° S09 °S08 °S07 °S06 ¤ 1 ¤
úááááááá_ááááááááá_ááááááááá_áááááéáááááéáááááéáááááéáááááéááááááéááááá_áááááN
¤Byte 4 ¤ 0 ¤ 0 ¤ 0 ° S05 °S04 ° S03 °S02 °S01 °S00 ¤ 1 ¤
àёёёёёёёàёёёёёёёёёòёёёёёёёёёòёёёёёüёёёёёüёёёёёüёёёёёüёёёёёüёёёёёёüёёёёёòёёёёё￥
}
{ Buiding the First byte of Package for PC }
AR＝MASK_RS232；
AY0＝MASK_SYNCHROBIT；
AF＝AR OR AY0；
SR＝LSHIFT MR0 BY 11(LO)；
AY1＝DATA_BITS_1；
AR＝SR1 AND AY1；
CALL Revers；
SR＝LSHIFT AR BY 1(LO)；
AR＝SR0 OR AF；
DM(I0，M0)＝AR；
{---------------------------------------------------------------------------------}
{ Buiding the Second byte of package for PC }
AR＝MASK RS232；
AY0＝0；
AF＝AR OR AYO；
SR＝LSHIFT MRO BY 18(LO)；
AY1＝DATA_BITS_2；
AR＝SRl AND AYl；
CALL Revers；
SR＝LSHIFT AR BY 1(LO)；
AR＝SRO OR AF；
DM(I0，M0)＝AR；
{--------------------------------------------------------------------------------}
{ Buiding the Third byte of Package for PC }
SR＝LSHIFT MRl BY 12(LO)；
AY1＝DATA_BITS_1；
AR＝SRl AND AYl；
CALL Revers；
SR＝LSHIFT AR BY 1(LO)；
AR＝SRO OR AF；
DM(I0，M0)＝AR；
{--------------------------------------------------------------------------------}
{ Buiding the Fourth byte of Package for PC }
SR＝LSHIFT MR1 BY 18(LO)；
AY1＝DATA_BITS_1；
AR＝SR1 AND AY1；
CALL Revers；
SR＝LSHIFT AR BY 1(LO)；
AR＝SR0 OR AF；
DM(I0，M0)＝AR；
{--------------------------------------------------------------------------------}
<dp n="d188"/>
{ Send First Byte to PC }
AX0＝DM(I0，M0)；
TX0＝AX0；
{---------------------------------------------------------------}
RTI；
Transmit_Next：
AXl＝I0；
AY1＝I1；
AR＝AXl-AYl；
IF EQ JUMP Out_Interrupt；
Send_Next：
AX0＝DM(I0，M0)；
TX0＝AX0；
Out_Interrupt：
RTI；
.ENDMOD；
<dp n="d189"/>
.SYSTEM ibmwacom01；
.ADSP2101；
.MMAP0；
.SEG/ROM/BOOT＝0/CODE boot pm[2048]；
.SEG/PM/RAM/ABS＝0/CODE prog_mem[2048]；
.SEG/DM/RAM/ABS＝0×3800/DATA data_ mem[1024]；
.PORT/DM/ABS＝0×3400 x_counter_port；
.PORT/DM/ABS＝0×3401 y_counter_port；
.ENDSYS；
目录E
extern int COUNTS1[15000]；
extern int COUNTS2[15000]；
extern char pen_up[15000]；
#define BUFFER_SIZE 60000
#define MIN_COUNT850
#define MAX_COUNT1800
#define MINX-120
#define MINY700
#define MAXX800
#define MAXY1600
#include＜stdio.h＞
#include＂extern.h＂
int Initialize(void)
{
FILE*fp；
int ndx＝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(＂array exceeds 15000！！！， not all fioleis read\n＂)；
return ndx；
}
<dp n="d191"/>
#include＂const.h＂
#include＜graphics.h＞
#include＜conio.h＞
#include＜stdio.h＞
#include＜math.h＞
#include＜Stdlib.h＞
int Initialize(void)；
void butter_filtO(fioat in[]，fioat out[])；
#define GR_ON
int COUNTS1[15000]，COUNTS2[15000]；
char far pen_up[15000]；
#pragma argsused
int main( )
{
int repl；
int i，ndx；
unsigned char c1，c2，fix＝0，fly＝0；
unsigned int count1，count2；
int gdriver＝DETECT，gmode，errorcode；
int ScrMaxX，ScrMaxY；
int CountRange，XRange，YRange；
float x_cor，y_cor；
float NewCountAX[3]，NewCountAY[3]；
float CountAX[5]，CountAY[5]；
float ax＝0.，ay＝0.；
float InFilt[2]，OutFilt[2]；
int NumPoints，CountNdx＝0；
float temp；
#ifdef GR_ON
initgraph(&gdriver，&gmode，＂C：\\BORLANDC\\BGI＂)；
errorcode＝graphresult()；
if(errorcode！＝grOk)
{
printf(＂Graphics error：％s\n＂，grapherrormsg(errorcode))；
printf(＂Press any key to halt：＂)；
getch()；
return-2；
}
#endif
ScrMaxX＝getmaxx()；
ScrMaxY＝getmaxy()；
CountRange＝MAX_COUNT－MIN_COUNT；
<dp n="d192"/>
XRange＝MAXX－MINX；
YRange＝MAXY－MINY；
if((NumPoints＝lnitialize())＜0)
{
printf(＂unable to initalize\n＂)；
return-1；
}
count1＝COUNTS1[CountNdx]；
count2＝COUNTS2[CountNdx++]；
NewCountAX[0]＝NewCountAX[1]＝NewCountAX[2]＝count1；
NewCountAY[0]＝NewCountAY[1]＝NewCountAY[2]＝count2；
CountAX[0]＝CountAX[1]＝CountAX[2]＝count1；
CountAY[0]＝CountAY[1]＝CountAY[2]＝count2；
InFilt[0]＝NewCountAX[1]；InFilt[1]＝NewCountAY[1]；
InFilt[0]＝375.
((fioat)NewCountAX[1]*NewCountAX[1]－
(fioat)NewCountAY[1]*NewCountAY[1])/1500.；
temp＝(fioat)NewCountAY[1]*NewCountAY[1]－InFilt[0]*lnFilt[0]；
if(temp＞0)
InFilt[1]＝(fioat)sqrt(temp)；
x_cor＝(((InFilt[0]－MINX)/(fioat)XRange)* ScrMaxX)；
y_cor＝(((InFilt[1]－MINY)/(float)YRange)* ScrMaxY)；
#ifdef GR_ON
moveto(x_cor，y_cor)；*
#endif
ndx＝0；
NewCountAX[0]＝NewCountAX[1]＝NewCountAX[2]＝COUNTS1[CountNdx]；
NewCountAY[0]＝NewCountAY[1]＝NewCountAY[2]＝COUNTS2[CountNdx]；
CountAX[0]＝CountAX[1]＝CountAX[2]＝CountAX[3]＝CountAX[4]＝COUNTS1[CountNdx]；
CountAY[0]＝CountAY[1]＝CountAY[2]＝CountAY[3]＝CountAY[4]＝COUNTS2[CountN
dx++]；
while(CountNdx＜NumPoints)
{
count1＝COUNTS1[CountNdx]；
count2＝COUNTS2[CountNdx++]；
NewCountAX[0]＝NewCountAX[1]；NewCountAY[0]＝NewCountAY[1]；
NewCountAX[1]＝NewCountAX[2]；NewCountAY[1]＝NewCountAY[2]；
/* NewCountAX[2]＝count1；NewCountAY[2]＝count2；
*/ CountAX[0]＝CountAX[1]；CountAY[0]＝CountAY[1]；
CountAX[1]＝CountAX[2]；CountAY[1]＝CountAY[2]；
<dp n="d193"/>
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[0])*2./3.＋NewCountAX[0]；
fix＝0；
}
else
if(abs(CountAX[2]－NewCountAX[1]－ax)＜10)
NewCountAX[2]＝CountAX[2]－ax；
else if(abs(CountAX[1]－CountAX[3])＜12)
NewCountAX[2]＝(CountAX[1]＋CountAX[3])/2.－ax；
else if(abs(CountAX[1]－CountAX[4])＜12)
{
NewCountAX[2]＝(CountAX[4]－CountAX[1])/3.＋CountAX[1]－ax；
fix＝1；
}
else
{float tmp；
tmp＝(NewCountAX[1]－NewCountAX[0]＋CountAX[3]－CountAX[2])/2；
ax＝(CountAX[2]－NewCountAX[1]－tmp)；
NewCountAX[2]＝CountAX[2]－ax；
}
if(fly)
{
NewCountAY[2]＝(CountAY[3]－CountAY[0])*2./3.＋NewCountAY[0]；
fly＝0；
}
else
if(abs(CountAY[2]－NewCountAY[1]－ay)＜10)
NewCountAY[2]＝CountAY[2]－ay；
else if(abs(CountAY[1]－CountAY[3])＜12)
NewCountAY[2]＝(CountAY[1]＋CountAY[3])/2.－ay；
else if(abs(CountAY[1]－CountAY[4])＜12)
{
NewCountAY[2]＝(CountAY[4]－CountAY[1])/3.＋CountAY[1]－ay；
fly＝1；
}
else
{float tmp；
tmp＝(NewCountAY[1]－NewCountAY[0]＋CountAY[3]－CountAY[2])/2；
ay＝(CountAY[2]－NewCountAY[1]－tmp)；
NewCountAY[2]＝CountAY[2]－ay；
}
/*
if(abs(CountAY[1]－NewCountAY[0]－ay)＜10)
{NewCountAY[1]＝CountAY[1]－ay；apy＝ay；}
<dp n="d194"/>
else if(abs(CountAY[0]－CountAY[2])＜12)
{NewCountAY[1]＝(int)(CountAY[0]＋CountAY[2])/2.－ay；apy＝ay；}
else if(ay＝＝apy)
{
apy＝ay；
ay＝(int)(CountAY[1]－NewCountAY[0])；
NewCountAY[1]＝CountAY[1]－ay；
}
*/
InFilt[0]＝375. －
((float)NewCountAX[2]*NewCountAX[2]－
(fioat)NewCountAY[2]*NewCountAY[2])/1500.；
temp＝(float)NewCountAY[2]*NewCountAY[2]－InFilt[0]*InFilt[0]；
if(temp＞0)
InFilt[1]＝(fioat)sqrt(temp)；
butter_filt0(InFilt，OutFilt)；
#ifdef GR_ON
x_cor＝(((OutFilt[0]－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
#ifndef GR_ON
printf(＂％04d ％04d ％04d
％04d\n＂， NewCountAX[1]，NewCountAY[1]，(int)OutFilt[0]，(int)OutFilt[1])；
/*printf(＂％u ％u\n＂，Buffln，BuffOut)；*/
ndx++；
#endif
if(kbhit())
{
if(getch()＝＝0)
getch()；
break；
}
/*if(OverFlowFlag)
{
printf(＂Buffer OverFlow\n＂)；
continue；
}*/
}
<dp n="d195"/>
/*CloselnterrComm(portbase)；*/
#ifdef GR_ON
while(！kbhit())/* do nothing*/；
getch()；
/* closegraph()；*/
#endif
return O；
}
/****************************************************
*.再构造及笔移动图及符合 *
****************************************************/
#include＜conio.h＞
#include＜stdio.h＞
#include＜math.h＞
#include＜stdlib.h＞
/*
Filtration by low PASS filter Butterworth 4 order.and
cutoff freq..04 from half sampling rate
Input：aray in.
Output：array out.
*/
void butter_filt0(fioat in[]，float out[])
{
static float a[5]＝{1.，-3.6717291，5.0679984，-3.1159669，.71991033}；
static float
b[5]＝{1.3293729e-05，5.3174916e-05，7.9762373e-05，5.3174916e-05，1.3293729e-05}；
static float y[2][5]，x[2][5]；
int i，j；
float sum＝0.；
static int fi＝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][0]＝in[j]；
<dp n="d196"/>
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][0]＝sum；
out[j]＝sum；；
}
else
out[j]＝in[j]；
}
if(！fi)fl＝1；
}
Claims (65)
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的手绘体识别设备，其所述形状识别装置包括第一识别信道，用于来自所述光字符识别装置的输入，提供代表形状识别的第一输出，第二识别信道，用于来自所述至少一个加速度计的输入，提供代表形状识别的第二输出，和形状选择装置，用于根据预定的准则在第一和第二输出之间进行选择。
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| IL108566 | 1994-02-04 | ||
| IL10856694A IL108566A0 (en) | 1994-02-04 | 1994-02-04 | Handwriting input apparatus using more than one sensing technique |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN1128380A true CN1128380A (zh) | 1996-08-07 |
Family
ID=11065785
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN95101407A Pending CN1128380A (zh) | 1994-02-04 | 1995-02-05 | 利用多种传感技术的手写输入设备 |
Country Status (12)
| Country | Link |
|---|---|
| US (1) | US5517579A (zh) |
| EP (1) | EP0666543B1 (zh) |
| JP (1) | JPH0836462A (zh) |
| KR (1) | KR950033780A (zh) |
| CN (1) | CN1128380A (zh) |
| AT (1) | ATE219588T1 (zh) |
| AU (1) | AU1154895A (zh) |
| CA (1) | CA2141836A1 (zh) |
| DE (1) | DE69527101T2 (zh) |
| IL (1) | IL108566A0 (zh) |
| TW (1) | TW403877B (zh) |
| ZA (1) | ZA95811B (zh) |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1105347C (zh) * | 1998-07-08 | 2003-04-09 | 大腾电子企业股份有限公司 | 电脑输入指标装置 |
| CN105900047A (zh) * | 2014-01-08 | 2016-08-24 | 微软技术许可有限责任公司 | 具有静电和无线电链路的显示器系统 |
| CN111397510A (zh) * | 2020-03-24 | 2020-07-10 | 青岛罗博智慧教育技术有限公司 | 一种数字轨迹记录装置及坐标校准方法 |
Families Citing this family (100)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| DE69522423T2 (de) | 1994-12-16 | 2002-04-11 | Hyundai Electronics America | Digitalisierstift und Verfahren |
| DE69523024T2 (de) * | 1994-12-16 | 2002-03-14 | Hyundai Electronics America | Digitalisierstift und Betriebsverfahren |
| US6081261A (en) * | 1995-11-01 | 2000-06-27 | Ricoh Corporation | Manual entry interactive paper and electronic document handling and processing system |
| US5902968A (en) | 1996-02-20 | 1999-05-11 | Ricoh Company, Ltd. | Pen-shaped handwriting input apparatus using accelerometers and gyroscopes and an associated operational device for determining pen movement |
| US5875257A (en) * | 1997-03-07 | 1999-02-23 | Massachusetts Institute Of Technology | Apparatus for controlling continuous behavior through hand and arm gestures |
| US6104380A (en) * | 1997-04-14 | 2000-08-15 | Ricoh Company, Ltd. | Direct pointing apparatus for digital displays |
| US5977958A (en) * | 1997-06-30 | 1999-11-02 | Inmotion Technologies Ltd. | Method and system for digitizing handwriting |
| US6188392B1 (en) | 1997-06-30 | 2001-02-13 | Intel Corporation | Electronic pen device |
| US6201903B1 (en) | 1997-09-30 | 2001-03-13 | Ricoh Company, Ltd. | Method and apparatus for pen-based faxing |
| US5939702A (en) * | 1997-10-10 | 1999-08-17 | Motorola, Inc. | Writing implement having an integrated optical reader |
| US6181329B1 (en) | 1997-12-23 | 2001-01-30 | Ricoh Company, Ltd. | Method and apparatus for tracking a hand-held writing instrument with multiple sensors that are calibrated by placing the writing instrument in predetermined positions with respect to the writing surface |
| US6124847A (en) * | 1998-05-14 | 2000-09-26 | Virtual Ink, Corp. | Collapsible detector assembly |
| US6211863B1 (en) | 1998-05-14 | 2001-04-03 | Virtual Ink. Corp. | Method and software for enabling use of transcription system as a mouse |
| US6111565A (en) * | 1998-05-14 | 2000-08-29 | Virtual Ink Corp. | Stylus for use with transcription system |
| US6191778B1 (en) | 1998-05-14 | 2001-02-20 | Virtual Ink Corp. | Transcription system kit for forming composite images |
| US6147681A (en) * | 1998-05-14 | 2000-11-14 | Virtual Ink, Corp. | Detector for use in a transcription system |
| US6232962B1 (en) | 1998-05-14 | 2001-05-15 | Virtual Ink Corporation | Detector assembly for use in a transcription system |
| US6177927B1 (en) | 1998-05-14 | 2001-01-23 | Virtual Ink Corp. | Transcription system kit |
| US6100877A (en) * | 1998-05-14 | 2000-08-08 | Virtual Ink, Corp. | Method for calibrating a transcription system |
| US7268774B2 (en) * | 1998-08-18 | 2007-09-11 | Candledragon, Inc. | Tracking motion of a writing instrument |
| IL141400A0 (en) | 1998-08-18 | 2002-03-10 | Digital Ink Inc | Handwriting device with detection sensors for absolute and relative positioning |
| US20100008551A9 (en) * | 1998-08-18 | 2010-01-14 | Ilya Schiller | Using handwritten information |
| US6587577B1 (en) | 1999-04-21 | 2003-07-01 | International Business Machines Corporation | On-line signature verification |
| JP3847058B2 (ja) | 1999-10-04 | 2006-11-15 | 任天堂株式会社 | ゲームシステム及びそれに用いられるゲーム情報記憶媒体 |
| JP2001236451A (ja) * | 2000-02-21 | 2001-08-31 | Oki Data Corp | 電子帳票作成システム |
| JP4618840B2 (ja) | 2000-02-21 | 2011-01-26 | 株式会社沖データ | 座標入力装置 |
| US20020054026A1 (en) * | 2000-04-17 | 2002-05-09 | Bradley Stevenson | Synchronized transmission of recorded writing data with audio |
| US20020067350A1 (en) * | 2000-12-06 | 2002-06-06 | Mourad Ben Ayed | Wireless handwriting input device using graffitis and bluetooth |
| US6717073B2 (en) * | 2000-12-29 | 2004-04-06 | Intel Corporation | Wireless display systems, styli, and associated methods |
| US7203383B2 (en) * | 2001-02-22 | 2007-04-10 | Thinkpen Llc | Handwritten character recording and recognition device |
| DE10110980A1 (de) * | 2001-03-07 | 2002-09-26 | Siemens Ag | Texteingabe in ein Handgerät |
| US6831632B2 (en) * | 2001-04-09 | 2004-12-14 | I. C. + Technologies Ltd. | Apparatus and methods for hand motion tracking and handwriting recognition |
| US20030071798A1 (en) * | 2001-04-23 | 2003-04-17 | Ehud Baron | System and method for transmitting, receiving, and generating digital ink from triangulation data of a transponder-stylus |
| US7279646B2 (en) * | 2001-05-25 | 2007-10-09 | Intel Corporation | Digital signature collection and authentication |
| US7916124B1 (en) | 2001-06-20 | 2011-03-29 | Leapfrog Enterprises, Inc. | Interactive apparatus using print media |
| US20030012374A1 (en) * | 2001-07-16 | 2003-01-16 | Wu Jian Kang | Electronic signing of documents |
| CN1190721C (zh) * | 2001-08-08 | 2005-02-23 | 国际商业机器公司 | 协同手写输入的系统和方法 |
| US7257255B2 (en) * | 2001-11-21 | 2007-08-14 | Candledragon, Inc. | Capturing hand motion |
| AU2003219506B2 (en) | 2002-04-15 | 2009-02-05 | Qualcomm Incorporated | Method and system for obtaining positioning data |
| US6977187B2 (en) * | 2002-06-19 | 2005-12-20 | Foster-Miller, Inc. | Chip package sealing method |
| US20040091847A1 (en) * | 2002-11-06 | 2004-05-13 | Ctb/Mcgraw-Hill | Paper-based adaptive testing |
| US20040121298A1 (en) * | 2002-11-06 | 2004-06-24 | Ctb/Mcgraw-Hill | System and method of capturing and processing hand-written responses in the administration of assessments |
| US7203384B2 (en) * | 2003-02-24 | 2007-04-10 | Electronic Scripting Products, Inc. | Implement for optically inferring information from a planar jotting surface |
| US20040229195A1 (en) * | 2003-03-18 | 2004-11-18 | Leapfrog Enterprises, Inc. | Scanning apparatus |
| JP2004355098A (ja) * | 2003-05-27 | 2004-12-16 | Fujitsu Component Ltd | 超音波座標入力装置及び超音波座標入力方法 |
| US7433499B2 (en) * | 2003-08-22 | 2008-10-07 | Dynasig Corporation | Method and apparatus for capturing and authenticating biometric information from a writing instrument |
| EP1683076A1 (en) * | 2003-10-27 | 2006-07-26 | Koninklijke Philips Electronics N.V. | Processing gesture signals |
| US7088440B2 (en) * | 2003-12-22 | 2006-08-08 | Electronic Scripting Products, Inc. | Method and apparatus for determining absolute position of a tip of an elongate object on a plane surface with invariant features |
| US20050156915A1 (en) * | 2004-01-16 | 2005-07-21 | Fisher Edward N. | Handwritten character recording and recognition device |
| US7961909B2 (en) | 2006-03-08 | 2011-06-14 | Electronic Scripting Products, Inc. | Computer interface employing a manipulated object with absolute pose detection component and a display |
| US7826641B2 (en) * | 2004-01-30 | 2010-11-02 | Electronic Scripting Products, Inc. | Apparatus and method for determining an absolute pose of a manipulated object in a real three-dimensional environment with invariant features |
| US8542219B2 (en) * | 2004-01-30 | 2013-09-24 | Electronic Scripting Products, Inc. | Processing pose data derived from the pose of an elongate object |
| US9229540B2 (en) | 2004-01-30 | 2016-01-05 | Electronic Scripting Products, Inc. | Deriving input from six degrees of freedom interfaces |
| US7453447B2 (en) * | 2004-03-17 | 2008-11-18 | Leapfrog Enterprises, Inc. | Interactive apparatus with recording and playback capability usable with encoded writing medium |
| US20060127872A1 (en) * | 2004-03-17 | 2006-06-15 | James Marggraff | Method and device for associating a user writing with a user-writable element |
| US7831933B2 (en) * | 2004-03-17 | 2010-11-09 | Leapfrog Enterprises, Inc. | Method and system for implementing a user interface for a device employing written graphical elements |
| US20060077184A1 (en) * | 2004-03-17 | 2006-04-13 | James Marggraff | Methods and devices for retrieving and using information stored as a pattern on a surface |
| US7853193B2 (en) | 2004-03-17 | 2010-12-14 | Leapfrog Enterprises, Inc. | Method and device for audibly instructing a user to interact with a function |
| US20060033725A1 (en) * | 2004-06-03 | 2006-02-16 | Leapfrog Enterprises, Inc. | User created interactive interface |
| US20060125805A1 (en) * | 2004-03-17 | 2006-06-15 | James Marggraff | Method and system for conducting a transaction using recognized text |
| JP5243025B2 (ja) | 2004-05-17 | 2013-07-24 | エポス ディベロップメント リミテッド | 音響測位システムのための頑健な音響同期シグナリング |
| US20060001654A1 (en) * | 2004-06-30 | 2006-01-05 | National Semiconductor Corporation | Apparatus and method for performing data entry with light based touch screen displays |
| EP1807146A4 (en) * | 2004-09-29 | 2013-07-03 | Tel Hashomer Medical Res Infrastructure & Services Ltd | COMPOSITION FOR IMPROVING THE EFFICACY OF DRUG DELIVERY |
| US8106888B2 (en) * | 2004-10-01 | 2012-01-31 | 3M Innovative Properties Company | Vibration sensing touch input device |
| US7367944B2 (en) | 2004-12-13 | 2008-05-06 | Tel Hashomer Medical Research Infrastructure And Services Ltd. | Method and system for monitoring ablation of tissues |
| US20060139339A1 (en) * | 2004-12-29 | 2006-06-29 | Pechman Robert J | Touch location determination using vibration wave packet dispersion |
| EP2323017B1 (en) * | 2005-03-23 | 2016-06-29 | QUALCOMM Incorporated | Method and system for digital pen assembly |
| US7683890B2 (en) * | 2005-04-28 | 2010-03-23 | 3M Innovative Properties Company | Touch location determination using bending mode sensors and multiple detection techniques |
| KR100534590B1 (ko) * | 2005-05-26 | 2005-12-08 | 서종범 | 초음파를 이용한 입력장치 및 위치인식방법 |
| US7922099B1 (en) | 2005-07-29 | 2011-04-12 | Leapfrog Enterprises, Inc. | System and method for associating content with an image bearing surface |
| JP4728740B2 (ja) * | 2005-08-23 | 2011-07-20 | Ｎｅｃディスプレイソリューションズ株式会社 | 電子ペン、電子黒板システム、およびプロジェクタシステム |
| US7936339B2 (en) * | 2005-11-01 | 2011-05-03 | Leapfrog Enterprises, Inc. | Method and system for invoking computer functionality by interaction with dynamically generated interface regions of a writing surface |
| US20070109271A1 (en) * | 2005-11-14 | 2007-05-17 | Phison Electronics Corp. | [a portable storage device with handwritten input device] |
| KR100715200B1 (ko) * | 2005-11-17 | 2007-05-07 | 삼성전자주식회사 | 자기력 감지 센서를 이용한 데이터 입력 장치 및 이를이용한 3차원 좌표 산출 방법 |
| US7600194B2 (en) * | 2005-12-02 | 2009-10-06 | Microsoft Corporation | Start menu operation for computer user interface |
| KR100666217B1 (ko) * | 2005-12-07 | 2007-01-10 | 서종범 | 컴퓨터용 입력 시스템 |
| US7755026B2 (en) * | 2006-05-04 | 2010-07-13 | CandleDragon Inc. | Generating signals representative of sensed light that is associated with writing being done by a user |
| US8261967B1 (en) | 2006-07-19 | 2012-09-11 | Leapfrog Enterprises, Inc. | Techniques for interactively coupling electronic content with printed media |
| US11783925B2 (en) | 2006-12-29 | 2023-10-10 | Kip Prod P1 Lp | Multi-services application gateway and system employing the same |
| WO2008082441A1 (en) | 2006-12-29 | 2008-07-10 | Prodea Systems, Inc. | Display inserts, overlays, and graphical user interfaces for multimedia systems |
| US9602880B2 (en) | 2006-12-29 | 2017-03-21 | Kip Prod P1 Lp | Display inserts, overlays, and graphical user interfaces for multimedia systems |
| US9569587B2 (en) | 2006-12-29 | 2017-02-14 | Kip Prod Pi Lp | Multi-services application gateway and system employing the same |
| US20170344703A1 (en) | 2006-12-29 | 2017-11-30 | Kip Prod P1 Lp | Multi-services application gateway and system employing the same |
| US11316688B2 (en) | 2006-12-29 | 2022-04-26 | Kip Prod P1 Lp | Multi-services application gateway and system employing the same |
| US20080166175A1 (en) * | 2007-01-05 | 2008-07-10 | Candledragon, Inc. | Holding and Using an Electronic Pen and Paper |
| US8459119B2 (en) * | 2007-01-28 | 2013-06-11 | Nec Corporation | Method of determining propagation time of ultrasonic from movable body and system thereof |
| CN103399675B (zh) * | 2007-03-14 | 2016-12-28 | 高通股份有限公司 | Mems传声器 |
| US20080281918A1 (en) * | 2007-05-11 | 2008-11-13 | Michael Kirkwood | System and method for sharing information in networks |
| US9181555B2 (en) * | 2007-07-23 | 2015-11-10 | Ramot At Tel-Aviv University Ltd. | Photocatalytic hydrogen production and polypeptides capable of same |
| JP5272401B2 (ja) * | 2007-12-26 | 2013-08-28 | ぺんてる株式会社 | 手書き筆跡入力システム |
| US8165398B2 (en) * | 2008-05-30 | 2012-04-24 | Sony Ericsson Mobile Communications Ab | Method and device for handwriting detection |
| CN101604212B (zh) * | 2008-06-11 | 2013-01-09 | 财团法人工业技术研究院 | 书写动作与轨迹辨识方法及其书写装置与辨识系统 |
| US20100104189A1 (en) * | 2008-10-23 | 2010-04-29 | Aravamudhan Bharath | Handwriting Identification Method, Program And Electronic Device |
| WO2010098346A1 (ja) * | 2009-02-25 | 2010-09-02 | 日本電気株式会社 | 超音波伝播時間測定システム |
| FR2969779A1 (fr) | 2010-12-23 | 2012-06-29 | Movea | Systeme de saisie d'elements graphiques |
| RO128874B1 (ro) * | 2012-12-19 | 2017-08-30 | Softwin S.R.L. | Sistem, pix electronic şi metodă pentru achiziţia semnăturii olografe dinamice, utilizând dispozitive mobile cu ecran capacitiv |
| CN105447433B (zh) | 2014-09-01 | 2020-01-31 | 阿里巴巴集团控股有限公司 | 一种注册身份的方法及装置 |
| US11577159B2 (en) | 2016-05-26 | 2023-02-14 | Electronic Scripting Products Inc. | Realistic virtual/augmented/mixed reality viewing and interactions |
| US11157099B2 (en) * | 2019-08-05 | 2021-10-26 | Adx Research, Inc. | Electronic writing device and a method for operating the same |
| US20210312824A1 (en) * | 2020-04-01 | 2021-10-07 | Magicom Inc. | Smart pen apparatus |
Family Cites Families (52)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US3731273A (en) * | 1971-11-26 | 1973-05-01 | W Hunt | Position locating systems |
| US4122435A (en) * | 1975-05-06 | 1978-10-24 | Lgz Landis & Gyr Zug Ag | Apparatus and method for producing an electrical signal responsive to handwriting characteristics |
| US4128829A (en) * | 1977-12-30 | 1978-12-05 | International Business Machines Corporation | Signature verification method and apparatus utilizing both acceleration and pressure characteristics |
| US4142175A (en) * | 1978-06-12 | 1979-02-27 | International Business Machines Corporation | Pressure sensing device and transducer arrangement |
| US4240065A (en) * | 1978-12-13 | 1980-12-16 | Wigmore Professional Data Services Ltd. | Position sensing apparatus |
| US4317005A (en) * | 1979-10-15 | 1982-02-23 | Bruyne Pieter De | Position-determining system |
| US4263592A (en) * | 1979-11-06 | 1981-04-21 | Pentel Kabushiki Kaisha | Input pen assembly |
| US4345239A (en) * | 1980-06-20 | 1982-08-17 | International Business Machines Corporation | Apparatus for determining pen acceleration |
| US4357672A (en) * | 1980-07-30 | 1982-11-02 | Science Accessories Corporation | Distance ranging apparatus and method |
| JPS5798078A (en) * | 1980-12-12 | 1982-06-18 | Fujitsu Ltd | Writing device |
| US4495644A (en) * | 1981-04-27 | 1985-01-22 | Quest Automation Public Limited Company | Apparatus for signature verification |
| US4513437A (en) * | 1982-06-30 | 1985-04-23 | International Business Machines Corporation | Data input pen for Signature Verification |
| US4578674A (en) * | 1983-04-20 | 1986-03-25 | International Business Machines Corporation | Method and apparatus for wireless cursor position control |
| DE3584734D1 (de) * | 1984-05-11 | 1992-01-09 | Mitsubishi Electric Corp | Schaltgeraet. |
| US4751741A (en) * | 1984-07-19 | 1988-06-14 | Casio Computer Co., Ltd. | Pen-type character recognition apparatus |
| DE3582968D1 (de) * | 1984-07-25 | 1991-07-04 | Hitachi Ltd | Tablettartige koordinateneingabevorrichtung unter verwendung elastischer wellen. |
| US4654648A (en) * | 1984-12-17 | 1987-03-31 | Herrington Richard A | Wireless cursor control system |
| US4862152A (en) * | 1985-01-25 | 1989-08-29 | Milner Ronald E | Sonic positioning device |
| US4695831A (en) * | 1985-05-06 | 1987-09-22 | Humphrey Instruments, Inc. | Light pen having actuating accelerometer |
| SU1357986A1 (ru) * | 1985-05-22 | 1987-12-07 | Войсковая Часть 27177-Л | Съемник координат дл устройства считывани графической информации |
| US5226091A (en) * | 1985-11-05 | 1993-07-06 | Howell David N L | Method and apparatus for capturing information in drawing or writing |
| US4719578A (en) * | 1985-12-09 | 1988-01-12 | Mitsubishi Jukogyo Kabushiki Kaisha | Profiling control apparatus and control method thereof |
| CH669676A5 (zh) * | 1986-01-23 | 1989-03-31 | Zellweger Uster Ag | |
| US4972496A (en) * | 1986-07-25 | 1990-11-20 | Grid Systems Corporation | Handwritten keyboardless entry computer system |
| US5227614A (en) * | 1986-08-15 | 1993-07-13 | Norand Corporation | Core computer processor module, and peripheral shell module assembled to form a pocket size data capture unit |
| JPS6373386A (ja) * | 1986-09-17 | 1988-04-02 | Nec Corp | 手書文字認識装置 |
| US4703511A (en) * | 1986-10-09 | 1987-10-27 | Paul Conoval | Writing input and dynamics regeneration device |
| US4845684A (en) * | 1986-12-09 | 1989-07-04 | International Business Machines Corporation | Acoustic contact sensor for handwritten computer input |
| US4814552A (en) * | 1987-12-02 | 1989-03-21 | Xerox Corporation | Ultrasound position input device |
| US5022086A (en) * | 1988-12-20 | 1991-06-04 | Sri International, Inc. | Handwriting apparatus for information collection based on force and position |
| US5051736A (en) * | 1989-06-28 | 1991-09-24 | International Business Machines Corporation | Optical stylus and passive digitizing tablet data input system |
| EP0413606A3 (en) * | 1989-08-18 | 1991-04-10 | Matsushita Electric Industrial Co., Ltd | Pen-type computer input device |
| US5054088A (en) * | 1989-09-20 | 1991-10-01 | International Business Machines Corporation | Signature verification data compression for storage on an identification card |
| US4991148A (en) * | 1989-09-26 | 1991-02-05 | Gilchrist Ian R | Acoustic digitizing system |
| US5361310A (en) * | 1990-01-19 | 1994-11-01 | Fujitsu Limited | Handwriting entry processing system using keyboard and mouse interfaces requiring no modification of an application program |
| US5214615A (en) * | 1990-02-26 | 1993-05-25 | Will Bauer | Three-dimensional displacement of a body with computer interface |
| IL96620A0 (en) * | 1990-12-23 | 1991-09-16 | Marc Zuta | Electrical input device and method |
| US5142506A (en) * | 1990-10-22 | 1992-08-25 | Logitech, Inc. | Ultrasonic position locating method and apparatus therefor |
| US5077802A (en) * | 1991-02-11 | 1991-12-31 | Ecole Polytechnique | Apparatus and method for digitizing and segmenting a handwriting movement based on curvilinear and angular velocities |
| JP2726594B2 (ja) * | 1991-04-01 | 1998-03-11 | 八洲電機株式会社 | 記憶ペン |
| US5111512A (en) * | 1991-05-14 | 1992-05-05 | At&T Bell Laboratories | Method for signature verification |
| US5247137A (en) * | 1991-10-25 | 1993-09-21 | Mark Epperson | Autonomous computer input device and marking instrument |
| US5343537A (en) * | 1991-10-31 | 1994-08-30 | International Business Machines Corporation | Statistical mixture approach to automatic handwriting recognition |
| US5315667A (en) * | 1991-10-31 | 1994-05-24 | International Business Machines Corporation | On-line handwriting recognition using a prototype confusability dialog |
| US5294792A (en) * | 1991-12-31 | 1994-03-15 | Texas Instruments Incorporated | Writing tip position sensing and processing apparatus |
| US5333209A (en) * | 1992-03-24 | 1994-07-26 | At&T Bell Laboratories | Method of recognizing handwritten symbols |
| US5319721A (en) * | 1992-04-14 | 1994-06-07 | International Business Machines Corporation | Methods and apparatus for evolving a starter set of handwriting prototypes into a user-specific set |
| US5280457A (en) * | 1992-07-31 | 1994-01-18 | The Administrators Of The Tulane Educational Fund | Position detecting system and method |
| GB9217774D0 (en) * | 1992-08-21 | 1992-10-07 | Pen Corp The Ltd | Computer pen |
| US5308936A (en) * | 1992-08-26 | 1994-05-03 | Mark S. Knighton | Ultrasonic pen-type data input device |
| US5337149A (en) * | 1992-11-12 | 1994-08-09 | Kozah Ghassan F | Computerized three dimensional data acquisition apparatus and method |
| US5434371A (en) * | 1994-02-01 | 1995-07-18 | A.T. Cross Company | Hand-held electronic writing tool |
-
1994
- 1994-02-04 IL IL10856694A patent/IL108566A0/xx unknown
- 1994-04-13 US US08/227,275 patent/US5517579A/en not_active Expired - Fee Related
-
1995
- 1995-02-01 DE DE69527101T patent/DE69527101T2/de not_active Expired - Fee Related
- 1995-02-01 EP EP95300619A patent/EP0666543B1/en not_active Expired - Lifetime
- 1995-02-01 AT AT95300619T patent/ATE219588T1/de active
- 1995-02-02 ZA ZA95811A patent/ZA95811B/xx unknown
- 1995-02-03 CA CA002141836A patent/CA2141836A1/en not_active Abandoned
- 1995-02-03 AU AU11548/95A patent/AU1154895A/en not_active Abandoned
- 1995-02-04 KR KR19950002123A patent/KR950033780A/ko not_active Application Discontinuation
- 1995-02-05 CN CN95101407A patent/CN1128380A/zh active Pending
- 1995-02-06 JP JP1816695A patent/JPH0836462A/ja active Pending
- 1995-02-13 TW TW084101241A patent/TW403877B/zh not_active IP Right Cessation
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1105347C (zh) * | 1998-07-08 | 2003-04-09 | 大腾电子企业股份有限公司 | 电脑输入指标装置 |
| CN105900047A (zh) * | 2014-01-08 | 2016-08-24 | 微软技术许可有限责任公司 | 具有静电和无线电链路的显示器系统 |
| CN105900047B (zh) * | 2014-01-08 | 2018-11-16 | 微软技术许可有限责任公司 | 具有静电和无线电链路的显示器系统 |
| CN111397510A (zh) * | 2020-03-24 | 2020-07-10 | 青岛罗博智慧教育技术有限公司 | 一种数字轨迹记录装置及坐标校准方法 |
Also Published As
| Publication number | Publication date |
|---|---|
| IL108566A0 (en) | 1994-05-30 |
| DE69527101T2 (de) | 2003-01-02 |
| EP0666543A2 (en) | 1995-08-09 |
| US5517579A (en) | 1996-05-14 |
| TW403877B (en) | 2000-09-01 |
| ZA95811B (en) | 1996-07-18 |
| KR950033780A (zh) | 1995-12-26 |
| ATE219588T1 (de) | 2002-07-15 |
| EP0666543B1 (en) | 2002-06-19 |
| EP0666543A3 (en) | 1996-06-05 |
| AU1154895A (en) | 1995-08-17 |
| JPH0836462A (ja) | 1996-02-06 |
| DE69527101D1 (de) | 2002-07-25 |
| CA2141836A1 (en) | 1995-08-05 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN1128380A (zh) | 利用多种传感技术的手写输入设备 | |
| CN1191536C (zh) | 手形手势识别装置及识别方法 | |
| CN1161687C (zh) | 手写体匹配技术 | |
| CN1215433C (zh) | 联机文字识别装置及方法 | |
| US7336827B2 (en) | System, process and software arrangement for recognizing handwritten characters | |
| JP5211334B2 (ja) | 手書き記号の認識方法及び装置 | |
| CN1091906C (zh) | 模式识别方法和系统以及模式数据处理系统 | |
| Kim et al. | A lexicon driven approach to handwritten word recognition for real-time applications | |
| US20120251006A1 (en) | Feature design for character recognition | |
| CN1758265A (zh) | 生物信息输入装置、认证装置、处理法和程序及记录介质 | |
| CN1711516A (zh) | 运动检测装置 | |
| CN1162795A (zh) | 模式识别设备与方法 | |
| CN1196103C (zh) | 语音识别设备和方法以及记录了语音识别程序的记录媒体 | |
| CN101866417B (zh) | 一种手写体维吾尔字符识别方法 | |
| CN1225484A (zh) | 地址识别设备和方法 | |
| CN104008363A (zh) | 手写轨迹的检测、规范化和在线识别以及异常字根的收集 | |
| CN1625766A (zh) | 手运动跟踪和笔迹识别设备与方法 | |
| CN1571980A (zh) | 字符串识别 | |
| EP1969489A1 (en) | Table detection in ink notes | |
| CN1664846A (zh) | 基于统计结构特征的联机手写汉字识别方法 | |
| CN1234128A (zh) | 特征信息附予方法、物体抽取方法、立体模型生成方法及其装置 | |
| EP2064618A2 (en) | Mobile device with acoustically-driven text input and method thereof | |
| US7142715B2 (en) | Arabic handwriting recognition using feature matching | |
| CN1658220A (zh) | 目标检测 | |
| JP2021056750A (ja) | データ入力支援装置、データ入力支援方法及びプログラム |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| C01 | Deemed withdrawal of patent application (patent law 1993) | ||
| WD01 | Invention patent application deemed withdrawn after publication |