CN1119481A - 在电视中检测，识别和插入广告的设备和方法 - Google Patents
在电视中检测，识别和插入广告的设备和方法 Download PDFInfo
- Publication number
- CN1119481A CN1119481A CN94191471.2A CN94191471A CN1119481A CN 1119481 A CN1119481 A CN 1119481A CN 94191471 A CN94191471 A CN 94191471A CN 1119481 A CN1119481 A CN 1119481A
- Authority
- CN
- China
- Prior art keywords
- advertisement
- place
- obj
- short
- cxxflags
- 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
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04H—BROADCAST COMMUNICATION
- H04H60/00—Arrangements for broadcast applications with a direct linking to broadcast information or broadcast space-time; Broadcast-related systems
- H04H60/56—Arrangements characterised by components specially adapted for monitoring, identification or recognition covered by groups H04H60/29-H04H60/54
- H04H60/59—Arrangements characterised by components specially adapted for monitoring, identification or recognition covered by groups H04H60/29-H04H60/54 of video
-
- G—PHYSICS
- G01—MEASURING; TESTING
- G01S—RADIO DIRECTION-FINDING; RADIO NAVIGATION; DETERMINING DISTANCE OR VELOCITY BY USE OF RADIO WAVES; LOCATING OR PRESENCE-DETECTING BY USE OF THE REFLECTION OR RERADIATION OF RADIO WAVES; ANALOGOUS ARRANGEMENTS USING OTHER WAVES
- G01S3/00—Direction-finders for determining the direction from which infrasonic, sonic, ultrasonic, or electromagnetic waves, or particle emission, not having a directional significance, are being received
- G01S3/78—Direction-finders for determining the direction from which infrasonic, sonic, ultrasonic, or electromagnetic waves, or particle emission, not having a directional significance, are being received using electromagnetic waves other than radio waves
- G01S3/782—Systems for determining direction or deviation from predetermined direction
- G01S3/785—Systems for determining direction or deviation from predetermined direction using adjustment of orientation of directivity characteristics of a detector or detector system to give a desired condition of signal derived from that detector or detector system
- G01S3/786—Systems for determining direction or deviation from predetermined direction using adjustment of orientation of directivity characteristics of a detector or detector system to give a desired condition of signal derived from that detector or detector system the desired condition being maintained automatically
- G01S3/7864—T.V. type tracking systems
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T15/00—3D [Three Dimensional] image rendering
- G06T15/04—Texture mapping
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T15/00—3D [Three Dimensional] image rendering
- G06T15/10—Geometric effects
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04H—BROADCAST COMMUNICATION
- H04H60/00—Arrangements for broadcast applications with a direct linking to broadcast information or broadcast space-time; Broadcast-related systems
- H04H60/35—Arrangements for identifying or recognising characteristics with a direct linkage to broadcast information or to broadcast space-time, e.g. for identifying broadcast stations or for identifying users
- H04H60/48—Arrangements for identifying or recognising characteristics with a direct linkage to broadcast information or to broadcast space-time, e.g. for identifying broadcast stations or for identifying users for recognising items expressed in broadcast information
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
- H04N5/00—Details of television systems
- H04N5/222—Studio circuitry; Studio devices; Studio equipment
- H04N5/262—Studio circuits, e.g. for mixing, switching-over, change of character of image, other special effects ; Cameras specially adapted for the electronic generation of special effects
- H04N5/2628—Alteration of picture size, shape, position or orientation, e.g. zooming, rotation, rolling, perspective, translation
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
- H04N5/00—Details of television systems
- H04N5/222—Studio circuitry; Studio devices; Studio equipment
- H04N5/262—Studio circuits, e.g. for mixing, switching-over, change of character of image, other special effects ; Cameras specially adapted for the electronic generation of special effects
- H04N5/272—Means for inserting a foreground image in a background image, i.e. inlay, outlay
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
- H04N5/00—Details of television systems
- H04N5/222—Studio circuitry; Studio devices; Studio equipment
- H04N5/262—Studio circuits, e.g. for mixing, switching-over, change of character of image, other special effects ; Cameras specially adapted for the electronic generation of special effects
- H04N5/272—Means for inserting a foreground image in a background image, i.e. inlay, outlay
- H04N5/2723—Insertion of virtual advertisement; Replacing advertisements physical present in the scene by virtual advertisement
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
- H04N7/00—Television systems
- H04N7/16—Analogue secrecy systems; Analogue subscription systems
- H04N7/162—Authorising the user terminal, e.g. by paying; Registering the use of a subscription channel, e.g. billing
- H04N7/165—Centralised control of user terminal ; Registering at central
Abstract
用于视频传输诸如体育比赛的、在其背景上带有特定目标物理图像的现场活动的一种系统(图7和8)和方法(图1)，其中这些物理图像在电子上用预选的虚拟图像替换，从而实际中遮挡着物理图像的一部分的目标或影子将由观众看成为遮挡着虚拟图像的相同部分，而遮挡着物理图像的运动员或球的运动将遮挡着替换后的虚拟图像的对应区域，这样替换后的电子虚拟图像将保持在该活动的背景上，恰如原始图像。
Description
本发明涉及把小的视频图象叠加到大的视频图象上的设备和方法。
国际体育比赛或者其它的盛况一般会引起许多国家的观众的兴趣和关心。例如，奥运会、超级杯、世界杯、重大的兰球和足球比赛、汽车赛等等都在此类之中。这些活动通常都通过电视向大量的各国观众现场直播。在举行这些比赛的地方如体育场或赛场上，以标牌、宣传画或者图板和广告牌上的其它陈列品的种种方式，利用任何尚未占用的包括比赛场地在内的合适空地，到处都提供了广告空间。
这些陈列品大部分是印刷品的形式，由于这个性质，它们不频繁改变，至少保持一天、一个比赛系列或整个赛季，而且它们基本上以当地观众为对象。在来自不同国家的两个队互相进行比赛的情况下，通常这样布置广告，从而使得体育馆的一侧带有以一个国家的观众为对象的广告，而体育馆的另一侧带有以另一个国家的观众为对象的广告。
在这种情况下，电视摄象机从相对的两侧为它们各自的观众拍摄活动。这样当然在后勤支持上是复杂的，并且限制了在比赛中被
代表的任一国家中所能观看比赛的角度。
现有广告方法中的另一个限制是对广告牌安放的严格安全要求，从而不会干扰比赛，不会影响体育场里观众的观看，也不会对运动员造成危险。陈列品一定不要太靠近比赛的实际场地，从而不分散运动员的注意。
重大国际体育比赛上的现有广告系统的最严重弊端在于：尽管比赛向全球直播，但是由于其广泛的国际性展示，在体育场里的实际的物理广告只能迎合那些具有全球性市场的产品。
本地的登广告者只有通过在电视屏幕上叠加本地信息或者通过中断比赛的实况，才能够利用这种世界范围播放的比赛。
现有系统的另一个弊端在于：由于电视摄象机扫描的原因，在很长的时间后标牌显得太模糊从而使电视观众看不清。在许多别的情况下，电视观众只能看到标牌的一部分因此看不懂标牌。
在这里引用为参考资料的下述文献说明高斯边缘检测：
J.F.Canny，“A Computational approach to edge detection”(边缘检测的一种计算方法)，IEEE Trans.Pattern Analysis and Machine Intel-ligence，Vol.8，pp.679-698，Novenaber，1986.
本发明涉及一种系统和方法，这种系统和方法在视频帧内检测、识别和定标适当的不同目标和区域并且把存储在该系统的存储器里的虚拟图象插入到这些区域里，以致在各个区域前面的并从观看上遮挡着这些区域一部分的所有物体或影子在视频传输中将会看成处在含有虚拟图象的区域前面并且遮挡着这些区域中相同的部位。
本发明的一个特殊特征是实时操作该系统。本发明还提供了操作该系统的设备。本发明特别适用于运动场内的广告。
本发明的一个目的是，提供一种用于视频传输诸如体育比赛的现场活动(其在背景上有特定目标的物理图像)的系统和方法。这种系统和方法中在电子上互换物理图象和预选的虚拟图象，从而在实际中遮挡着物理图象一部分的目标或影子将由观众看成为遮挡着虚拟图象的相同部分，而遮挡着物理图象的运动员们或球的运动将遮挡着替换后的虚拟图象的对应区域，这样替换后的电子虚拟图象将保持在该活动的背景上，恰如原始图象那样。
在本发明的一种最佳实施方式里，自动地检测、识别和定位一幅电视画面中要被替换的物理图象并且替换物理图象，从而电视观众不能察觉到该原始图象。在该实施方式里在线路广播期间回路中不需要有人存在。
因为相同的物理图象可由布置在球场周围不同位置上的多个电视摄象机所拍摄，并且各个摄象机通常具有连续可变焦镜头，所以，本系统能在所有可能的空间方位上检测和识别某一物理目标并且能够放大该目标。
本系统还能明确地识别物理目标的尺度和透视性并且能把插入的虚拟图象规范到相同的透视性。
本发明的另一个目的是提供一种在视频传输中向预定的“自由”背景区插入虚拟图象的系统和方法，这些“自由”背景区如运动场地自身一般不适于展示实物标牌。
在本发明的一种最佳实施方式里，自动地执行对这些自由区的检测和识别任务。
本发明的另一个目的是自动地识别，由于摄象机扫描或颤动而造成的物理广告牌显得模糊的情况，并且用清楚的标牌来代替模糊
的标牌，或者也可以向代替标牌施加相同的模糊度从而使它显得类似于邻近的标牌。
本发明的另一个目的是自动地识别在摄象机的视场里只能看到广告牌的一小部分的情况，并且用原始广告牌的全部图象来代替这一小部分。
本发明的另一个目的是自动地识别所拍摄的广告牌图象分辨率对于电视观众是不够的情况，并且在电子上用较大的虚拟广告牌来代替它以使观众能够方便地获得它们的信息。
本发明的再一个目的是在一系列视频帧中执行上述的插入。
本发明的另一个目的是在实时下提供上述用于电子互换虚拟图象或者电子插入虚拟图象的系统和方法。
本发明的另一个目的是提供一种系统和方法，用于实时地把同一个活动向不同国家的观众进行电视转播，其中用不同的电子信息置换实际陈列品所占有的空间。
本发明的另一个目的是提供一种系统和方法，以在实时转播体育馆内所进行的比赛期间，通过插入电子虚拟图象把实际陈列品未占用的可用空间用于广告。
本发明的另一个目的是提供一种视频传输中所使用的设备，用于在实时视频传输一项活动期间，在不影响该活动的实际传输的前提下，互换物理图象和虚拟图象或者把虚拟图象插入到未使用的背景区域里。
根据本发明的一种最佳实施方式，提供了一种用于转播由电视摄象机拍摄的现场活动的系统和方法，其中在电子上用虚拟图象替代或者把虚拟图象叠加到从物理陈列品中选出的目标和预选的背景
区上，该系统和方法包括：一个关于活动场所及其中目标的电子数据库，一个存储用来代替这些目标的数字化虚拟图象的存储器；用于抓获并数字化视频的设备；用于在数字化的视频帧里自动搜索目标并在其中检测目标的设备；用于对目标进行定位、验证和识别的设备；用于将检测的目标与数据库里的对应目标进行比较的设备；用于对原始图象进行定标和识别其透视性并且把虚拟替代图象变换成相同标度和相同透视性的设备；用于对一系列帧实时视频跟踪一个被检测出的目标并且用于识别目标放大率(变焦)或透视性变化的设备；用于区分遮挡住部分被检测目标的非背景物体和影子的设备；用于在电子上把目标和影子从原始视频帧转换到替代帧中的设备；用于在观众不会察觉变换的前提下把电子变换后的虚拟图象插入到电视帧中以代替目标中的原始图象的设备；用于接收和存储虚拟图象并生成虚拟图象数据库的设备；用于在活动之前或者活动期间(学习系统)生成场所数据库的设备；以及视频信号输入输出设备。
为此本系统采用一种特殊方法利用下述一个或多个属性自动地检测和识别多个目标。这些属性是：
—几何一诸如从各个角度和各个放大率下所看到的广告牌的物理外形(矩形或平行线属性)，
—标语和图形的纹理—诸如广告画中的纹理，
—字符识别，
—场地线或球场线一其用作为标明自由场地区的依据，
具有代表性形状和纹理的标准物体一诸如柱子、篮板、篮筐和/或运动员的运动衫，
—颜色，以及
—暂时遮挡要被替换的图象的一部分的物体和影子。
本方法在任何拍摄角度下、任何拍摄范围内和任何变焦状态下，并且最好在实时下清晰地识别目标对象，从而使电视观众不会觉察出原始广告牌。本方法通常在任一帧中识别相当大量的目标(在一极端情况下多至20个目标或更多)。
通过下述方式从背景图象中区分出遮挡物和遮挡的影子：
把检测出的目标(被部分遮挡)和存储在系统数据库里的相同目标进行比较。两者之间平滑的且经过处理的差值图象成为形成一部分遮挡物的被遮面图象。这个过程也可以通过使用相关窗口并识别因堵塞而造成的低值相关系数来完成，
运动检测—识别相对于背景运动的物体，
纹理和几何形状—将运动员、球或影子与标牌、标语或图形图象等区分开，以及
颜色—和颜色的深浅。
因为电视网通常不能接受可觉察的交换，电子交换最好是瞬时的和不会被观众注意到的。可替代地，有可能在连续“淡化”原始图象的同时加强虚拟图象。
最好避免对目标和图象的错误识别。
被代替的目标应该定位到子象素精度，从而对于该目标处于摄象机的视场之内的全部视频系列帧，替代目标相对于各帧在空间上是固定的。这种精度归因于这个事实，即人的眼睛对子象素的运动是敏感的。
本方法最好使用专用的并行和流水线处理硬件，这种硬件允许同时进行本处理所涉及的大量操作。
本发现的方法最好使用两种任选的子系统：
a)数字图象转换器和存储器—包括用于数字转换的电光扫描仪和用于构造存储诸如广告等图象的存储器部件的虚拟图象存储器。该系统还可能以其它方式输入诸如广告的图象，如通过数字接口(磁盘、光盘、通信链路)或视频端口，并且还可能包括“在现场”设计虚拟图象(如标语)的图形程序和人机接口。
b)场所“学习”和存储系统—用于在诸如体育场或赛场的场所建立目标及固定物体的数据库，包括：标牌(位置、形状、颜色和类型—一次性的、季节性的等等)、场地标记(线、颜色、球门/篮筐、柱子)、等等。
这两个子系统可以脱机操作或者可以作为基本系统的一部分。该系统能在实况过程中“学习”场地的细节并且能够为以后的使用建立/更新其数据库。这也可以利用活动开始前的拍摄试验来完成。
本方法涉及下述步骤：
当现场电视片或预先记录的电视片被发送时，发生下述步骤：
1)帧抓获和数字化一抓获各视频帧、数字化各象素值并存到系统存储器里，
2)搜索—扫描被拍摄的视频帧以检测实际物理陈列品(象存储在存储器里的图符)或者检测适宜插入的其规格已被预先定义的背景区。在检测之后，为了明确无误的识别，对怀疑的目标(即陈列品)进行检验。这是通过利用象边缘相关和区域匹配法、字符识别、神经网络技术等等的标准模式识别技术，对陈列品上的信息和图象或者对颜色和纹理属性进行识别来完成的。在完成目标(陈列品)识别并且完成准确定位之后，计算其光学放大率和透视度并且利用数
据库中该场所的布局，顺序预测帧内所有其它已存储目标(陈列品)的位置，以向系统提供同一视频帧内附加目标的建设性搜索线索。
3)被遮挡表面的识别—当在一个帧内可靠地识别出给定消息区域或者陈列品区时，该目标(陈列品)和其适当定标的存储图象(图符)进行比较。在对结果进行适当的平滑和处理之后，那些被一个物体如运动员的身体、球或影子等暂时遮挡的陈列品的区域被揭示出来。这些表面的象素地址被存储起来，从而在以后把这些表面叠加到替代后的图象上。
4)定标、透视变换和替代—当识别和定位一个物理图象陈列品或一个自由位置后，搜索系统的存储器以找出将要替代或插入的所需虚拟图象。然后首先规范被交换的虚拟图象(补片)以获得原始实际图象中的适当尺寸和透视性并且移掉已识别出的被遮挡表面，这样交换后的图象看起来象是场地上的背景陈列品或者是场地上绘制的陈列品。
5)实时视频跟踪—通常一给定的陈列品可被看到几秒钟，然后它再移出摄象机的视场。本系统最好利用以前的帧信息在这一系列帧中跟踪这一给定的陈列品。为做到这一点，可执行常规的视频跟踪技术，诸如边缘、形心或相关跟踪技术。这些方法应该包括子象素精度估值。在未把目标图符存储到系统存储器里的情况下或者向自由区进行插入的情况下，跟踪运动员或球对于识别遮挡部分也是有帮助的。
这样根据本发明的一种最佳实施方式提供了广告插入设备，其包括一个场地抓获器和一个广告插入器。场地抓获器对至少一个代
表着体育设施至少一部分的场地进行抓获和数字化，广告插入器用作把内容随时间变化的广告插入到至少一个场地上。
并且根据本发明的一种最佳实施方式，该广告插入器包括一个广告地点检测器，以在不在与体育设施有关的广告地点的位置的基础上进行至少一个广告地点的检测。
而且根据本发明的一种最佳实施方式该广告插入器把一个广告插入到处在体育设施中被部分占用的广告地点处的至少一个场地上。
而且根据本发明的一种最佳实施方式，广告的内容按预定的时间表改变。
另外，根据本发明的一种最佳实施方式，广告的内容按照外部输入而变化。
而且根据本发明的一种最佳实施方式，该广告插入器还包括一个观众噪声评定器，用于检测和评定观众产生的噪声水平并且向广告插入器提供噪声水平输入并使得其中广告的内容随噪声水平输入而变化。
根据本发明的一种最佳实施方式另外还提供了一种广告插入方法，包括对至少一个代表着体育设施至少一部分的场地进行抓获和数字化，并且把内容随时间变化的广告插入到至少一个场地上。
通过下述详细说明、结合附图和附录将更全面地了解和领会本发明。附图和附录是：
图1是根据本发明的方法的一个最佳实施方式中所需进行的进程和任务的逻辑流程图；
图2是根据本发明的一个最佳实施方式里的基本模块和子系统
模块的方块图；
图3是基本处理单元的方块图；
图4说明根据本发明的一个最佳实施方式里的一种最小基本联机系统；
图5说明根据本发明的一种最小基本脱机系统；
图6说明根据本发明的一种最佳实施方式适用于有线电视应用的一个系统；
图7是一个用于广告地点检测和广告插入的实时系统的简化方块图，该系统根据本发明的一种最佳实施方式构造和运行；
图8是图7的并行处理机和控制器的简化方块图；
图9是用于广告地点检测和广告插入的实时系统的另外一种的实施方式；
图10A是图7的并行处理机和控制器的一种最佳操作方法的简化流程图，其中仅识别一个广告地点并且仅向该地点插入单个广告；
图10B是图7的并行处理机和控制器的一种最佳操作方法的简化流程图，其中识别多个广告地点并且向这些地点插入多个内容相同或者不同的相应广告；
图11是实现图10A和图10B的分段步骤的一种最佳方法的简化流程图；
图12是用来执行图10A和图10B的广告内容识别步骤的一种最佳模型匹配方法的简化流程图；
图13是用于执行图10A和图10B的定位步骤的一种最佳方法的简化流程图；
图14是用于执行图10A和10B的跟踪步骤的一种最佳方法的简化流程图；
图15是用于执行图10A和10B的堵塞分析步骤的一种最佳方法的简化流程图；
图16是用于执行图10A和10B的广告插入步骤的一种最佳方法的简化流程图；
图17是在和图7的广告地点检测/插入设备使用的摄象机监视设备的简化方块图；
图18是用于为考虑来自至少一个停播摄象机的图象而对图15的堵塞分析过程的输出进行处理的一种最佳方法的简化流程图；
图19是用于对主要关心的运动物体进行检测和跟踪的一种最佳方法的简化流程图；以及
附录A是实现用于广告地点检测和广告插入的非实时系统的计算机软件程度，其是根据本发明的另外一种实施方式而构造和运行的。
现参见图1，在本发明的一种最佳实施方式里，设计了一种系统和方法，以实时地自动地执行用人造图象代替物理目标，即使本发明的较简单方式可在脱机下使用。
当操作该系统时，所需要的模块在图2的方块图中表示，它们包括：
一个基本处理单元；
一个供选择的光扫描仪/数字化仪，用于从静止图中建立人造图象的数据库；以及
用于建立体育场数据库、由电视摄像机、数字化仪和存储器组
成的光学子系统。如上面所述那样，还有其它的建立人造图象数据库的方法。场所(体育场)的数据库也可从比赛开始之前的拍摄试验中建立或甚至利用“学习”过程的方式在比赛过程中逐步建立，或者利用由体育场业主、广告商或电视网提供的数据建立。
图2表示系统中所使用设备的方块图，其中1、2…n为不同位置处的多个电视摄像机，它们是普通的电视网摄象机，3代表图3中所说明的基本处理单元，子系统4变换和存储人造图象，而子系统5是关于活动场所及其中目标的“学习”和存储系统。输出6可通过电缆、光纤或无线发送。它也可被显示和/或被记录。
实时操作该系统所需的基本处理单元如图3中所示。该模块包括：
一个获取彩色图象的帧抓获器；
多个图象存储器；
一个快速并行处理器；
一个程序存储器；
要被替代的人造图象、以及场所布局和目标图符的多个数据库；
一个用于控制、本地显示和记录的人/机接口；以及
一个图象数模转换器。
上述设备用于实时地在各电视帧中自动地确定体育场内的适当区域，这些区域具有物理陈列品或者适用于包含这样的陈列品，该设备还用于把存储在系统存储器里的虚拟图象代替这些物理陈列品或者把虚拟图象插入到这些区域里从而做为背景上的广告。
对于观众来讲，这些电子插入的图象看起来似乎就定位于体育场里的物理陈列品，而且所有发生在实际物理陈列品前面的动作对
观众而言同样发生在虚拟图象的前面。
图4表示根据本发明的一个方面的一个联机系统，其包括电视摄像机10、视频处理单元12和提供所需人/机接口的工作站14。
图5表示根据本发明的一个方面的一个基本脱机系统。在该情况下，电视录象带20、电视盒式录象机或电视录象盘代替电视摄象机作为输入，该输入被处理单元22和工作站24处理以提供带有替换后图象的录象带输出26。
图5说明了本发明的系统的另一应用，即一个有线电视中心。中心30接收来自站32和34的传输。这些传输由处理单元22和工作站24处理并从中心带着更换后的广告向用户广播。
尽管本发明的一种最佳系统把遮挡物和影子叠加到虚拟图象上，但作为本发明的一部分仍准备了一种不太复杂但便宜得多的系统，这就是一种和遮挡物无关的用虚拟图象代替物理图象的系统。
这样的系统可以很快地用于在无遮挡区，如体育场的高处，更换图象。
尽管本方面的一种最佳实施方式自动地检测和识别各视频帧中的一给定广告牌，作为本发明的一部分还准备了一种不太复杂的系统。在这种不太复杂的系统里对一给定的要被替换的标牌的选择是由回路中的操作员“人工地”利用诸如光笔或光标(用鼠标器操作)等标识器完成的。
该系统主要是脱机的。当实时联机使用这个系统时，因为在通常情况下每次只能在几秒的短暂时间连续看到该标牌，从而操作员很难进行标识任务。
在这种操作方式下电视观众仍然会看到替换。这会烦扰观众并
且在许多情况下不会得到电视网的许可。
从上述对本发明的说明中，很明显上述的系统、方法和设备可具有多种应用。此外，还有可能把诸如标语或图形广告之类的虚拟图象采用到运动员的队服上，特别当运动员处于特写镜头时。在这种情况下，运动员的轮廓或者至少他的运动衫或头盔将是插入虚拟图象的目标。
另一种可能的应用是自动生成连续电视片，其只显示那些出现预先选定的特殊目标的片断，而排除这些目标不出现的片断。这种电视片可用于分析和监视特殊目标的活动，例如在整场队式比赛中各个运动员的表现。这允许在不必为各运动员重放整盘录象带的情况下在整场比赛中跟踪各个运动员。
本发明的另一应用是产生诸如广告等目标的统计数据，例如一个广告在屏幕上出现的次数和累计时间，并相应地记帐。
插入图象的形式可以是固定的、闪烁的或滚动的图象，或者可以是动画片或视频剪辑。
图7是根据本发明的一种最佳实施方式构造和运行的用于广告地点检测和广告插入的实时系统的简化方块图。
图7中的设备包括视频输入源100，诸如电视摄象机、盒式录象带、广播、视频盘或有线传输，其通过一个合适的接插件最好和场地抓获器110连接，或者与一个帧抓获器连接。此后，术语“场地抓获器”的使用意味着包括帧抓获器。
场地抓获器110向并行处理器和控制器120提供抓获后的和数字化后的场地，在下面，参考图8将详细说明并行处理器和控制器，它最好和视频显示器130相连，视频显示器向用户提供该系统的广
告地点检测和广告插入操作的交互指示。光笔140最好和视频显示器130相联。
根据本发明的一种备择的实施方式，该系统从用户接收一个在视场内存在一个或多个要被替换的广告及它或它们的位置的指示。用户的输入可以，例如，借助光笔140提供。由用户提供的指示可以包括一个广告内部位置的单独指示，如该广告的近似中心，或者可以包括要被替换的广告的二个相对顶点或者全部四个顶点的相应的二个或四个指示。
可选地，用户还可以提供广告内容的指示。例如，可以把识别要被替换广告的标题菜单设置在视频显示器130上的邻近比赛场地或与比赛场地重叠的显示上，而且用户可利用光笔识别适当的标题。
设置了广告图象和广告布置数据库150，它可存储于任何适当类型的存储器里，诸如内存和象硬盘之类的辅助存储器里。广告图象和广告布置数据库150通常存储着多个广告图象、(典型情况下是静物图象)包含着要被替代的图象和/或要被插入到比赛场地图象中的图象，它们或者代替现有的广告或者插入到现尚未被广告占据的位置上。
如果事先知道多个要被代替的广告的布局，数据库150还可包括多个要被代替的广告的布局的指示。通常布局的指示不包括各广告相对于比赛场地的位置指示，而包括被代替的多个广告在场地上将被布置的顺序指示。例如，一列20个并列广告可以比赛场地的三个侧面布置。数据库150则包括广告布局顺序的指示。
数据库150里的广告图象可由场地抓获器110或者任何其它合适的广告图象源160提供，广告图象说可以是但不限于是一种图象
生成单元，诸如图象处理工作站、扫描仪或其它彩色读取装置、任何类型的存储设备(如硬盘、CD ROM驱动器)或者接到上述任一装置的通信链路。
经过适当的接插件，该系统的视频输出可提供给适当的装置以向观众提供无线的或有线的传输。
图8是图7的并行处理器和控制器120的简化方块图。并行处理器/控制器120最好包括广告地点检测/内容识别单元170、多个并行跟踪模块180、堵塞分析和广告插入单元190、视频编码器200和控制器210。
图8的广告地点检测和内容识别单元170可以在适当多个的适当图象处理板的基础上构造，例如美国Ariel公司的商用Ariel Hydra板。每块这种板最好装有四个TMS 320C40数字信号处理器，一个64MB的DRAM，一个1MB的SRAM和一个VME总线接口。最好给这些板增加一个特别设计的协处理器以执行分段任务。这些处理板根据图11和图12的广告地点检测和内容识别方法编程，附录A的一部分是基于该方法的。例如，附录A程序中的适当部分可以转换为汇编语言，其结果码可以装入到图象处理板的数字信号处理器里。
各个并行跟踪模块180可以在一个或多个诸如美国Ariel公司的商用Ariel Hydra板的图象处理板的基础上实现。各个Ariel Hydra板最好装有四个TMS320C40数字信号处理器，一个64MB的DRAM，一个1MB的SRAM和一个VME总线接口。根据图14的跟踪方法这些图象处理板被编程以进行并行操作。附录A的一部分是基于图14的跟踪方法的。例如，附录A程序中的适当部分可以转换为汇编语言，其结果码可以装入到图象处理板的数字信号处理器里。
堵塞分析和广告插入单元190同样地可以基于一块或多块纹理映象板，如Fairehild公司的带有适当总线桥路的Thru-D板，并根据图15和图16的堵塞分析和广告插入方法编程。附录A的一部分是基于这个方法的。例如，附录A程序的适当部分可转换成汇编语言，其结果码可以装入到纹理映象板的处理器里。
视频编码器200运行以实现D/A转换。
控制器210，例如，可由按图10A-10B的控制方法编程的486PC组成。附录A的一部分是基于该控制方法的。例如，附录A程序的适当部分可以适用于Intel公司的486PC处理器。
图9是实时广告地点检测和广告插入系统的另外一种实施方式的简化方块图。在图9的设备内，一个带有自己的视频显示器220和自己的场地抓获器(未示出)的常规工作站212，例如装有视频板和适当软件的Silicon Graphics公司的Onyx工作站，代替了图7中的下述单元：场地抓获器110，除了广告场地检测和内容识别单元170和其跟踪模块180之外的并行处理器和控制器120，视频显示器，和数据库150。
该工作站的软件可以基于附录A中实现图10A-10B中方法的那一部分，并适当地转换到工作站的环境下，但是附录A中的某些功能最好被略去，特别是：
a.略去分别对应于图10A-10B中分段、广告内容识别和跟踪步骤320、330和310的广告地点检测和跟踪功能，并用图9中的专用硬件230代替以实现实时；并且
b.最好略去纹理映象功能(图16中的第二和第三步骤，纹理映象功能最好构成广告插入功能的一部分)，并且替代地由工作站本身
提供的纹理映象功能来实现。
图9中的专用硬件230可以类似于图8的广告地点检测/内容识别单元170和并行跟踪模块180。
附录A是一个实现本发明的非实时的计算机软件程序，其可在，例如，连带着诸如Imaging MFG板的常规帧抓获器的486PC上运行。现参照图10A-16描述附录A的方法。
图10A是操作图7中并行处理器和控制器120最佳方法的简化流程图，其中只识别单个广告地点并且在该地点上只插入单个广告图象。
图10B是操作图7中并行处理器和控制器120最佳方法的简化流程图，其中识别多个广告地点并且把多个内容相同或不同的相应广告图象分别插入到这些地点上。
图10B的方法通常包括下述与图10A中的步骤相类似的步骤，为了简化不再单独描述图10A中的步骤。
步骤290：从图1的场地抓获器接收一个数字化后的视频场地。
步骤300：判定是否在当前的场地里的至少一个广告是否也已出现在以前的场地中(并已由相同的摄象机播放)。如果是，当前的场地叫做“连续”场地并且分段、内容识别和定位步骤320、330和340最好仅由跟踪步骤310代替。如果不是，当前的场地叫做“新”场地。
如果该场地是“连续”场地，根据在以前的场地中已存在的至少一个广告对多个广告进行跟踪(步骤310)，这是因为当前场地是一个“连续”场地。
如果该场地是一个“新”场地，要插入一个广告的地点在步骤
320、330和340中被识别。对多个要处理的广告中的各个广告进行循环处理。最好反对第一个要处理的广告进行分段和内容识别步骤320和330。
在步骤320，通常检测出一对大体平行的线段并且对场地上的图象进行分段。特别地，把位于这两条检测出的平行线之间的场地部分和场地的其余部分相分开，这两条平行线通常对应着一系列广告的顶部和底部边界。
通常，分段步骤320进行广告分段，而不考虑：它们相对于成象摄象机的透视角度、成象摄象机镜头的变焦状态、该广告在视场(电视场)中的位置、成象摄象机相对于地面的角度取向以及电视摄象机的位置。
分段步骤320通常识别空的或已占据的广告场地，其工作不是基于位置的，而是例如基于下述的而又不限下述的、单独的或任一组合的因素：
a.广告边界的几何属性，如基本上平行的顶部线和底部线或者如在一个基本矩形的形状中排列的四个顶点；
b.一种颜色或颜色的一种组合或一种颜色模式，事先已知它们将出现在广告图象中；
c.广告图象的空间频带(通常事先已知)。通常，已知的空间频带是用广告的高度规范的，广告的高度可由，例如，计算一对检测出的水平线之间的距离推导出，而这一对水平线已知为广告序列的顶部和底部边界。
在步骤330里，两条基平平行线之间部分上的内容与要被代替的广告的已存储内容进行匹配。
即使在体育比赛期间出现切换(在同时拍摄体育比赛的多个摄象机输出之间的转换，通常是突变的)，步骤320和330允许识别广告地点并且允许把其内容与一已存储的模型进行匹配。通常，每次切换时，执行步骤320和330，从而在该切换的前几个很少的场地上识别该广告。在出现下一次切换之前，通常跟踪该已识别的广告(步骤310)。
在步骤340，在子象素精度上定位广告。
最后，对每个广告进行堵塞分析(步骤350)并把替代的广告插入到广告地点上(步骤360)。或者，用一个广告增强步骤来代替阻塞分析和广告插入步骤，在广告增强步骤里利用常规的轮廓清晰化技术加强现有广告而不是替代它。
任选地，通常在堵塞分析步骤350之后执行收费累加步骤362。在收费累加步骤里，累计各广告的费用。费用可按各种适当的基础计算。例如，通过把广告的显示时间加上至少50％的广告来阻塞时间来计算总时间，再乘以单位时间的固定收费可以确定该费用。或者，可以各时间间隔，如每秒，计算广告未阻挡部分的比例。可选择地，可调整被显示区的显示时间和总加时时间以考虑比赛过程。例如，被显示区的显示时间或总加时时间可和外部提供的指示广告显示期间比赛紧张度的系数相乘。高紧张度可以，例如，意味着比赛进入加时期或者在显示期间或恰在显示前出现进球之类的重要事件。或者，该紧张度系数可由系统自身提供。例如，语音识别单元可以识别体育评论员发出的象“进球”之类的重要单词。
根据本发明的另外一种实施方式，如果在比赛场地上事先定位和找到了标明内容事先已知的、要被代替广告的位置的物理界标，可
以分别略去分段和广告内容识别步骤320和330。
图11是实现图10A和图10B中分段步骤320的最佳方法的简化流程图。
图11的方法最好包括下述步骤：
步骤380：接收一个新场地，并且因为随后的步骤在低分辨率下执行可能已足够，最好降低其分辨率。例如：可使用一低通滤波器把750×500象素场地降低到128×128象素。
步骤390：供选择地，低分辨率图象被平滑，即通过中值滤波或低通滤波，从而消掉与搜索长线或大体水平线的任务无关的信息。
步骤400：利用任何适当的边缘检测方法检测边缘和线段(双侧边缘)，如Canny方法(J.F.Canny，“A computational approach to edgedetection”，IEEE Trans.Pattern Analysis and Machine Intelligence，Vol.8，pp.679-698，November，1986。)
步骤404：步骤400中检测出的边缘被变细并且利用常规的连通分析技术把其上的组成部分连接起来。这些边缘是受到阈值限制的，从而去掉分层度太小的边缘。
步骤408：成对地比较步骤400和步骤410所检测出的边缘以找出条带，即比较一对长的平行线或近似平行线。如果没有这样的对，结束该方法。
步骤412：找出各条带的空间频谱并且剔除那些其空间频率内容和广告所期望的空间频带不相符的条带。通常剔除准则是这样的，即留下多于一个，诸如3或4个，的条带。
步骤416：对剩下的条带进行排序并且选择等级最高的条带。赋于条带的等级取决于该条带包含广告的可能性。例如，在场地上半
部分的最低位置处的条带比在它上面的条带赋有更高的等级，因为在它上面的条带更可能是体育场部分的图象。位置最低的条带更可能是通常位于体育场下方的广告。
邻近场地底部的条带被赋于低等级，因为当比赛场地几乎不被显示时(这是不太可能的)，广告只能朝向电视场的底部被拍摄。
图12是实现图10A和10B中广告内容识别步骤330的一种最佳模型匹配方法的简化流程图。或者，如上面参照图1时所述，可由用户提供广告内容识别。
图12的方法最好在低分辨率下(如前面参照图11中的步骤380所述0进行。图12的方法最好包括下述步骤：
步骤420：对图11的分段步骤320中识别的各个几乎平行的条带进行随后的步骤424、430、436、440、444和452。
步骤424：计算各条带两条线之间的距离和角度并且从其中确定该条带被拍摄的尺度和近似透视度。
步骤430：在准备期间，各个广告模型被划分成多个窗口。对各个广告模型的各个窗口执行步骤436、440和444。例如，例如有5个各划分成6个窗口的模型，该步骤执行30次。
步骤436；在当前几乎平行的条带中，对适当定标的当前模型窗口K执行一维相似搜索。通常，可对当前条带中的各个象素计算互相关函数。
步骤440：步骤436中得到的互相关函数值被阈值。例如，超过0.6的值被赋于值1(相关)而低于0.6的值可被赋为值0(不相关)。根据其对应窗口的“重要性”，各个1值被加数。最好在准备阶段确定各个窗口的“重要性”，从而使含有较多信息的窗口要比含
有少量信息的窗口更“重要”。
步骤444：在这个阶段已经计算出加数的阈值后的互相关函数值，它表示沿该条带各部分的内容(即沿该条带以单个象素距离分开的多个窗口中各个窗口的内容)与已知要出现在该条带里的各个模型广告的各个窗口的内容之间的匹配结果。
对组成一个模型标语或一个模型条带的所有窗口累加加数的阈值后的互相关函数值。
步骤452：进行该条带中一系列广告模型的近似位置的判定。可知，一旦确定了一个广告模型的位置，因为知道该成象条带的尺度和近似透视度，同时也确定了同一序列中其它广告模型的位置。
图13是实现图10A和10B中准确定位步骤340的一种最佳方法的简化流程图。在图13中，通过图12的方法近似定位后的广告模型以子象素精度定位。通常只对新的场地进行精确定位。对于“连续的”场地，最好通过视频跟踪测量广告的位置。
图13的方法最好包括下述步骤：
步骤460：从图12中可以得到每个被检测广告的下述信息：广告内的一个位置，如它的一个顶点、图象中广告的换算高度及其近似透视度。这些信息用于计算各个被检测广告的四个顶点。
步骤464：计算透视变换，该透视变换说明如何把典型矩形模型变换成被检测的广告区，由于其相对于成象摄象机的姿势该被检测的广告区通常是非矩形的。
步骤468：利用步骤464中计算的透视变换，把多个模型跟踪窗口的各个窗口的内容映射到电视场地中，多个模型跟踪窗口是在准备阶段由模型划分成的。
步骤470：对各个模型跟踪窗口执行步骤472和476。
步骤472：当前的模型跟踪窗口移过在电视场地中定义的一个搜索区。对该搜索区内的模型跟踪窗口的每个位置，计算相似误差函数(如互相关函数或差的绝对值和)。通常，模型跟踪窗口在搜索区内具有8×8或16×16个不同的位置。
步骤476：找出当前模型跟踪窗口的最小相似误差函数。最好该最小值是在子象素精度下找出的，即通过把一条二维抛物线拟合到步骤472中生成的相似误差函数并计算抛物线的最小值。这个最小值在“子象素精度上”对应于电视场地内当前模型跟踪窗口的最好位置。
如果(步骤480)对所有的跟踪窗口相似误差函数最小值都高，即所有的跟踪窗口都不能很好地和视频场地匹配，则(步骤482)结束对该当前帧的处理并且对下一个帧执行从步骤320开始的图10A中的方法。
步骤484：剔除带有高相似误差最小值的跟踪窗口。通常大约保留30个跟踪窗口。
步骤488是判定是否通过匹配跟踪窗口进行另一次迭代的停止准则。通常，如果发现跟踪窗口的中心相对于最后一次迭代所确定的中心是收敛的，终止处理。否则的话，该方法返回到步骤464。
步骤490：一旦跟踪窗口的各位置收敛，重新计算广告图象和模型图象之间的透视变换。
图14是实现图10A和10B的跟踪步骤310的一种最佳方法的简化流程图。图14的方法最好包括下述步骤：
步骤492：在模型跟踪窗口上进行透视变换并把其内容映射到
视频场地里。该步骤利用系统有关在以前的场地里广告位置的知识并且，最好，预测拍摄体育比赛的摄象机的扫描速度。
步骤496：对各个模型跟踪窗口执行步骤498和500，它们可分别类似于图13的步骤472和476。
步骤508和512可类似于图13的步骤488和490。
步骤510：如果窗口中心位置尚未收敛，重复步骤492，但是，这次，纹理变换基于以前迭代的透视变换。
步骤520：最好暂时性地平滑透视变换的各系数，由于摄象机扫描动作的平滑，可以假定不连续性是噪音。
图15是实现图10A和10B的堵塞分析步骤350的一种最佳方法的简化流程图。图15的方法最好包括下述步骤：
步骤530：从广告图象的透视变换模型中除去电视场地里的广告图象，该透视变换模型是在图14的步骤512中计算的，或者，对于一个新的场地是在图13中步骤490中计算的。
步骤534：最好通过检查步骤530中计算的差值证实广告图象和所存储广告间的同一性。如果广告图象和所存储的广告是不相同的，不对当前场地进行更多的处理。代之以从图10B的步骤320开始处理下一个场地。
步骤538：从在步骤530中计算出的差值图象中滤去内部边缘效应，因为内部边缘被认为是人为造成的。
步骤542：差值图象里的大块非黑区域被定义为堵塞区域。
步骤546：最好暂时性地平滑该堵塞映象，因为堵塞过程可被认为连续的。
图16是实现图10A和10B的广告插入步骤360的一种最佳方
法。图16的方法最好包括下述步骤：
步骤560：把替换广告模型(即存储器里的广告)的分辨率调整到对应于被替换广告的成象分辨率。通常，一个单个模型是以几种不同的分辨率存储的。
步骤570：利用三线(tri-Linear)插值法把替换广告变换到并且纹理匹配到电视场地境地里。该步骤通常基于图14中步骤512的结果，或者对于新的场地基于图13中步骤490的结果。
步骤580：消除重叠效应。
步骤590：根据堵塞映象键入替换象素。替换象素的值可以完全替换现有值，也可以如通过一种加权平均值和现有值结合。例如，第二种替换方式可以用于边缘象素而第一种替换方式可以用于中间的象素。
图17是摄象机监视设备的简化方块图，该设备和常规电视摄象机及图7的广告地点检测/插入设备一起使用。如果图7的并行处理器和控制器和图8中所示的一样，则不需要图17的设备并代之以使用常规电视摄象机。但是，可供选择地，通过去掉图8的单元170可以除掉该系统的自动检测和内容识别特性。在这种情况下，最好设置图17的设备，在体育场或比赛场地与电视摄象机一同工作。
图17的设备提供摄象机信息，包括“正在广播”摄象机的特性、其镜头变焦状态和其FOV中心的方向。这个信息可以和如体育场内广告的位置及内容等已知信息一起使用，以检测、识别和甚至相略地跟踪各个广告。
图17的设备包括：
(a)多个常规电视摄象机600，在图17中示出其中的一个；
(b0对于每一个摄象机600有一个摄象机FOV(视场)中心方向测量单元610，通常在该电视摄象机600的支架上至少安装测量单元610的一部分；
(c)对于每个摄象机600有一个摄象机镜头变焦状态监视单元620，其通常安装在该摄象机600的支架上。该监视单元620接收直接来自摄象机的变焦机构的指示变焦状态的输出；
(d)“正在广播”摄象机识别单元630，作用为从多个电视摄象机600中识别出正在广播的那个摄象机。该信息通常可从广播系统控制单元中得到。广播系统控制单元通常从制片人接收一个选择正在广播摄象机的人工输入；以及
(e)一个摄象机信息视频混合器640，作用为把单元610、620和630的输出混合到广播中去。可以采用任何适当的混合方式，诸如混合到音频通道，混合到时间码或者混合到视频信号本身。
摄象机FOV方向测量单元610可以利用下述任何一种方法来实现，特别是：
a.连带着两个倾角计的在摄象机上的NFM(北方向定位模块)，用于测量相对于FOV中心方向的本地重力矢量角的两个分量；
b.基于GPS—(全球定位系统)的方向测量系统；
c.三角测量—把两个RF(射频)源定位在比赛场地或体育场中的两个已知位置中并把一个RF接收机放在摄象机上；
d.与一个在摄象机外的位置传感检测器相配合的一个在摄象机上的瞄准激光指示器，作用为测量激光指示器产生的射束点方向。
图18是处理图15的堵塞分析过程的输出以便考虑来自至少一个停播摄象机图象的一种任选方法的简化流程图。如果采用图18的
方法，设置一个视频压缩器和混合器700以和电视摄象机一起工作，这些摄象机如图2中所示在比赛场地或体育场拍摄活动。压缩器和混合器700的输出包括由所有的摄象机但不包括正在“广播”的摄象机所拍摄的压缩图象并混有广播信号，该输出被广播到如图7所示的远程广告地点检测/插入系统。由图2的压缩器和混合器700提供的传输首先在图18的步骤710里被译码和脱压缩。
步骤720：对由“正在广播”的摄象机所拍摄的各个广告地点重复步骤730、740和750。
步骤730：尽管有可能使用来自多于一个的“停播”摄象机的信息，最好只利用单个“停播”摄象机处理各个广告地点，并在步骤730选择单个“停播”摄象机。例如，如果设有图17的设备，可以比较各个“停播”摄象机的摄象机FOV方向测量单元610的输出以便识别出其FOV方向和“正在广播”的摄象机的FOV方向差别最大的“停播”摄象机。或者，特别如果略去图17的设备时，可通过对各个“停播”摄象机所产生的图象进行初步分析来选择单个“停播”摄象机从而排出最有用的“停播”摄象机。例如，可以把各个“停播”摄象机生成的图象和当前正被处理的广告的存储模型相匹配。这样，实际的图象可能变形，然后对于每个“停播”摄象机将实际图象从存储的模型中减去，从而得到该摄象机和该广告的堵塞面积的一种评估。然后可以选择堵塞面积最小的摄象机。
步骤740：所选择的“停播”摄象机的广告图象被转变到由“正在广播”的摄象机所拍摄的广告地点上。
步骤750：从“正在广播”的图象上减去被转变的“停播”广告图象，对该差值图象进行滤波，以便在象素水平的精度上计算出堵
塞物体的边界。
根据本发明的一种最佳实施方式，要被插入到比赛场地特定位置上或其它位置上的广告可随时间变化。这种变化可以根据预定的时间表，或者根据外部输入。例如，可以设置一个语音识别单元，其作用为识别在音频通道(它伴随系统的视频输入)上的关键词，比如词“进球”或词“加时”。以这种方式，可以计划在特定时刻，如刚刚进球后或加时赛期间，插入广告。
在本说明书里，术语“广告地点”指的是在其处插入广告的一个位置，。如果一个现有广告占据着这个广告地点，新的广告代替该现有广告。但是，广告地点不是必须由现有广告占据的。术语“堵塞”指的是被一个在其前面的物体(通常是一个运动物体)部分或全部遮蔽的一个广告地点。
本发明的一个独特之处在于，当需要在一个较大的图象里跟踪一个广告地点时，不用跟踪全部图象，而仅需要跟踪广告地点本身。
另一个独特的特点是可以设置“特别的”广告，诸如移动的、闪烁的或以其它方式变化的广告、电视片广告、带有变化背景的广告和带有数字化效果的广告。
可以理解，即附录A所描述的特定实施方式只是用来提供一种本发明的特别详细的公开，而不是用来作为限制的。
上面所说明的设备和方法的应用不限于对广告的检测、跟踪和替换或者加强。所公开的设备和方法可以，例如，用于检测和跟踪主要关心的运动物体，如图19中所示，诸如热点运动员和诸如球、球拍、球棒和其它的运动器械。这些运动物体的图象还可通过加上包括如制造商的标识等广告在内的一条“尾迹”予以修改。
可以理解，即为清楚起见在分开的实施方式的范围内所说明的本发明的不同特点也可以在单个实施方式中组合提供。相反地，为简明起见在各单个实施方式的范围内说明的本发明的各种特点也可以单独提供或者以一种适当的子组合提供。
本领域的技术人员可以理解本发明不限制于上面所表示和所说明的方式。相反，本发明的范围完全由下述权利要求所规定。
APPENDIX A
<dp n="d31"/>
#include″comp_fnc.h″
int_cdecl compare_short_pnt(const void *elem1，const void *elem2)
{int i；double t1，t2；
double a；
t1＝**(double**)elem1；t2＝**(double**)elem2；
a＝t1-t2；
i＝(a？((a＜0)？1：-1)：0)；
return i；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int_cdecl compare_GOOD_DIR_LINE(const void *elem1，const void
*elem2)
{int i；double t1，t2；
double a；
t1＝((GOOD_DIR_LINE*)elem1)-＞Qual；t2＝((GOOD_DIR_LINE*)elem2)-
＞Qual；
a＝t1-t2；
i＝(a？((a＜0)？1：-1)：0)；
return i；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int_cdecl compare_array_elem(const void *elem1，const void *elem2)
{int i；
double a；
a＝**(double**)elem1-**(double**)elem2；
i＝(a？((a＜0)？1：-1)：0)；
return i；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d32"/>
#ifndef COR_FNC
#define COR_FNC
#include″projctn8.h″
#include″pic_mch8.h″
#include″res_mch8.h″
typedef struct
{double md[3]，var[3]；}AVERAGE_VEC；
AVERAGE_VEC average(PCT tag，double Thr，
COLOR_VEC(*p_funct)(COLOR_RGB p1，double Thresh_mdl))；
COLOR_VEC template_conv_1(PCT target，PCT win，double
Thr，COLOR_VEC int_v，
COLOR_VEC(*p_funct)(COLOR_RGB p1，double
Thresh_mdl))；
COLOR_VEC template_abs_diff_1(PCT target，PCT win，double
Thr，COLOR_VEC int_v，
COLOR_VEC(*p_funct)(COLOR_RGB p1，double Thresh_mdl)，
AVERAGE_VEC t，AVERAGE_VEC w)；
COLOR_VEC Correlation(COLOR_VEC conv，AVERAGE_VEC
t，AVERAGE_VEC w，
COLOR_VEC int_v)；
COLOR_VEC Correlation_single_1(COLOR_VEC conv，AVERAGE_VEC
t，AVERAGE_VEC w，
COLOR_VEC int_v)；
AVERAGE_VEC LineMoments(PCT &T，DIR_LINE Line，short map)；
double Quality(AVERAGE_VEC *UpLineQuality)；
#endif
<dp n="d33"/>
#ifndef LIBR
#define LIBR
#include″projctn8.h″
#include″pic_mch8.h″
#include″res_mch8.h″
∥#include″lin_trn7.h″
#define NAME_LENGTH 40
#define GRAPHMODE _VRES256COLOR
#endif
<dp n="d34"/>
typedef struct{
int cols，rows；
int bpp；
}PHDR；
<dp n="d35"/>
#ifndef PIC_MCH
#define PIC_MCH
#include＜vmemory.h＞
#include＜graph.h＞
#include″projctn8.h″
#define MEDIAN_AREA 49
typedef unsigned char byte；
typedef struct
{short r，g，b；}
COLOR_RGB；
class PCT
{public：
short s_rows，s_cols；
unsigned char_far *buffer_now；
unsigned char_far **pict；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
PCT()
{buffer_now＝NULL；
pict＝NULL；
s_rows＝s_cols＝0；
}
void free_PCT()
{int i；
if(！pict)return；
for(i＝0；i＜s_rows；i++)
free((void_far*)pict[i])；
buffer_now＝NULL；
pict＝NULL；
}
void put_str(short y，unsigned char *B)
{
if(y＜s_rows)
{buffer_now＝pict[y]；
int i；
for(i＝0；i＜3*s_cols；i++)
*buffer_now++＝*B++；
}
}
void put_pix(short y，short x，COLOR_RGB p)
{
if((y＜s_rows)&&(x＜s_cols))
buffer_now＝ pict[y]+3*x；
PutNextPix(p)；
}
<dp n="d36"/>
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
inline COLOR_RGB get_next(void)
{COLOR_RGB t；
t.r＝*buffer_now++；
t.g＝*buffer_now++；
t.b＝*buffer_now++；
return t；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
inline COLOR_RGB get_pixel(short y，short x)
{
if((y＜s_rows)&&(x＜s_cols))
buffer_now＝pict[y]+3*x；
return get_next()；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝
void PutNextPix(COLOR_RGB p)；
PCT(short n_cols，short n_rows)；
void load_template(PCT source，SCR_PNT left_up_scr)；
COLOR_RGB get_median_pixel(short y，short x，short neibour)；
int load_file_rgb(const char *name)；
}；
void sign_present_RGB(PCT pict_scr，SCR_PNT left_up)；
PCT sign_storage_rgb(const char *name，struct_videoconfig vc)；
COLOR_RGB *make_palette()；
short color_num(short r，short g，short b)；
void write_sign_rgb(char *name，PCT pict_now)；
#endif
<dp n="d37"/>
#ifndef PIC_PRO
#define PIC_PRO
#include ＜stdlib.h＞
#include ＜direct.h＞
#include＜afx.h＞
#include＜pic mch7.h＞
#include″filemnp.h″
#define STR_MAX 4
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝
const SCR_PNT z_0(0，0)；
class PRT：public PCT
{public：
∥information
CString PathName；
CString FRAME_Number；
CString STRING_name；
CString SIGN_name；
short Pos；∥Position in the string
long NumberOfChk，MaxNum；
double *Charact；
∥models
PRT∷-PRT()
{this-＞free_PCT()；
Pos＝0；
if(MaxNum)
delete Charact；
Charact＝NULL；
MaxNum＝NumberOfChk＝0；
}
∥＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
PRT∷PRT()
{NumberOfChk＝MaxNum＝s_cols＝s_rows＝0；
Charact＝NULL；pict＝NULL；
}
∥＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
PRT∷PRT(short n_cols，short n_rows)
{*(PCT*)this＝PCT∷PCT(n_cols，n_rows)；
NumberOfChk＝MaxNum＝0；
Charact＝NULL；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int read_proto_SGN(char ext[]＝″.sgn″)
{
CString new_name(′′，80)；
PathName＝MakeName(PathName)；
new_name＝PathName+ext；
char now[80]；
<dp n="d38"/>
FILE*datfp；
if(！(datfp＝fopen((const char*)new_name，″r″))return 1；
if(fscanf(datfp，″％*[^\n]s″)＝＝EOF)goto ERR；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto ERR；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto ERR；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
ERR；FRAME_Number＝now；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
ERR；STRING_name＝now；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto ERR；SIGN_name＝now；
FRAME_Number.MakeUpper()；
STRING_name.MakeUpper()；
SIGN_name.MakeUpper()；
fclose(datfp)；
return 0；
ERR：fclose(datfp)；return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int proto_storage_rgb(char *name，struct_videoconfig vc)
{*(PCT*)this＝sign_storage_rgb(name，vc)；
if(！s_cols)return 1；
PathName＝MakeName(name)；
if(read_proto_SGN())
{free PCT()；
return 1；
}
return 0：
}
∥＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
int read_proto_DBC(FILE*datfp)
{
char now[80]；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
ERR；PathName＝MakeName(now)；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
ERR；FRAME_Number＝now；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
ERR；STRING_name＝now；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto ERR；SIGN_name＝now；
if(fscanf(datfp，″％d″，&(this-＞s_cols))＝＝EOF)goto ERR；
FRAME_Number.MakeUpper()；
STRING_name.MakeUpper()；
SIGN_name.MakeUpper()；
return 1；
ERR：return 0；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝
int alloc_Charact_dbl(long Num)
<dp n="d39"/>
{
if(！(Charact＝new double[Num]))return 1；
MaxNum＝Num；NumberOfChk＝0；
return 0；
}
∥＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
void free_Charact()
{delete Charact；
Charact＝NULL；
}
∥＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
int read_Charact_dbl(FILE*inp，long Num)
{short i；
double d；
if(MaxNum＜(NumberOfChk+Num))return 1；
for(i＝0；i＜Num；i++)
{if(fscanf(inp，″％If″，&d)＝＝EOF)return 1；
if(fabs(d)＜1.0e-4)d＝0；
Charact[NumberOfChk]＝d；
NumberOfChk++；
}
return 0；
}
∥＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
double CorrValue(short WNum，short Pnum)
{return(*(Charact+(long)WNum*s_cols+Pnum))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝
∥＝＝＝＝＝＝RETURN NUMBER OF STRIPS
int read_target_SGN(SCR_PNT vrt[][4]，char ext[]＝″.sgs″)
{int n＝0，j，FLG，s；
CString new_name(′′，80)；
PathName＝MakeName(PathName)；
new_name＝PathName+ext；
char now[80]；
FILE*datfp；
if(！(datfp＝fopen((const char*)new_name，″r″)))return 1；
if(fscanf(datfp，″％*[^\n]s″)＝＝EOF)goto OUT；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto OUT；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto OUT；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
OUT；STRING_name＝now；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto OUT；SIGN_name＝now；
if((s＝PathName.ReverseFind(′\\′))＜0)
s＝PathName.ReverseFind(′：′)；
FRAME_Number＝
PathName.Right(PathName.GetLength()-s)；
<dp n="d40"/>
STRING_name.MakeUpper()；
SIGN_name.MakeUpper()；
do{
for(j＝0；j＜4；j++)
if((FLG＝fscanf(datfp，″％d ％d″，&(vrt[n][j].c)，&(vrt[n][j].r)))＝＝EOF)
goto OUT；
n++；
}
while(n＜STR_MAX-1)；
OUT：fclose(datfp)；return n；
}
∥＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
}；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#define UnKnown-1
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
typedef struct
{short n；∥voiting numbers
short pos；∥position in string
double value；∥value
}RSLT_old；
∥＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
void HistCollect(short NOfWin，short St，short Fin，PRT &Db)；
RSLT_old LineEstimation(short TagSize，PRT &Db，short NOfWin，
short WSize，double Thr)；
int Linelnf(const PRT &P，PRT T，short rw，short Xpos，struct_videoconfig vc)；
double Linlnter(PRT &P，short WNum，short WSize，double Pt)；
void HistThresh(short*H，short*BotThr，short*TopThr，short num)；
#endif
<dp n="d41"/>
#ifndef PROJCTN
#define PROJCTN
#include＜math.h＞
#include＜graph.h＞
typedef struct{
double x，y，z；
}PNT；
class SCR_PNT
{public：
short c，r；
SCR_PNT(){c＝0；r＝0；}
SCR_PNT(short x，short y){c＝x；r＝y；}
}；
∥PT-＞SCR PNT conversion∥
#define PT_SCR(p，scr) (scr).c＝(short)(p).u；(scr).r＝(short)(p).v；
∥SCR PNT-＞PT converson
#define INT_PT(scr，dbl) (dbl).u＝(double)((scr).c)；\
(dbl).v＝(double)((scr).r)；
class PT
{public：
double u，v；
PT(double x，double y){u＝x；v＝y；}
PT(SCR_PNT p1){u＝(double)p1.c；v＝(double)p1.r，}
PT(){u＝0；v＝0；}
}；
class LINE_PROJECTION；
class DIR_LINE
{friend class LINE_PROJECTION；
private：
double a，b，c； ∥a*u+b*v+c＝0
PT st_pnt，end_pnt；
public：
DIR_LINE(PT p1，PT p2)
{st_pnt＝p1；
end_pnt＝p2；
#ifdef DEBUG
_moveto((short)st_pnt.u，(short)st_pnt.v)；
_lineto((short)end_pnt.u，(short)end_pnt.v)；
#endif
a＝p2.v-p1.v；
b＝p1.u-p2.u；
c＝p1.v*p2.u-p1.u*p2.v； ∥a*x+b*y+c＝0
}
∥————————————————
DIR_LINE(SCR_PNT p1，SCR_PNT p2)
<dp n="d42"/>
{st_pnt＝PT∷PT(p1)；
end_pnt＝PT∷PT(p2)；
#ifdef DEBUG
_moveto((short)st_pnt.u，(short)st pnt.v)；
_lineto((short)end_pnt.u，(short)end_pnt.v)；
#endif
a＝end_pnt.v-st_pnt.v：
b＝st_pnt.u-end_pnt.u；
c＝st_pnt.v*end_pnt.u-st_pnt.u*end_pnt.v； ∥
a*x+b*y+c＝0
}
DIR_LINE()
{st_pnt.u＝st_pnt.v＝
end_pnt.u＝end_pnt.v＝a＝b＝c＝0；
}
PT PT_for_P(double p)
{PT t；
t.u＝st_pnt.u+p*(end_pnt.u-st_pnt.u)；
t.v＝st_pnt.v+p*(end_pnt.v-st_pnt.v)；
return t；
}
double U_for_V(double v){return(a？(-c-b*v)/a：0)；}
double V_for_U(double u){return(b？(-c-a*u)/b：0)；}
double a_for_line(){return a；}
double b_for_line(){return b；}
double c_for_line(){return c；}
double RATIO_for_PT(PT p) ∥relative point position at line
{double dx，dy，dro；
dx＝end_pnt.u-st_pnt.u；
dy＝end_pnt.v-st_pnt.v；
if(fabs(dx)＞fabs(dy))
{if(！dx)return 0；
dro＝(p.u-st_pnt.u)/dx；
}
else
{
if(！dy)return 0；
dro＝(p.v-st_pnt.v)/dy；
}
return dro；
}
int Left_Right(int col，int row)
∥+1 if point to the left hand from start to end
∥ 0 otherwise
{
return(((a*col+b*row+c)＞＝0)？0：1)；
}
<dp n="d43"/>
PT Start_p(){return st_pnt；}
PT End_p(){return end_pnt；}
friend int U_dist(DIR_LINE I)；
friend PT cross_line(DIR_LINE Line1，DIR_LINE Line2)；
friend int INside(DIR_LINE I1，DIR_LINE I2，DIR_LINE I3，DIR_LINE I4，int
col，int row)；
}；
class LINE_PROJECTION
{
private：
double proj_prm；∥
public：
DIR_LINE RI，Prj；
LINE_PROJECTION(){
DIR_LINE I1；Rl＝I1；Prj＝I1；
proj_prm＝0；
}
LINE_PROJECTION(DIR_LINE I1，PT p，DIR_LINE pr，PT p_pr)；
double Ro_for_P(double P)
{return((P*(1+proj_prm))/(1+P*proj_prm))；
}
double P_for_Ro(double Ro)
{return(Ro/(1+(1-Ro)*proj_prm))；
}
friend DIR_LINE Line_for_PT_pr(LINE_PROJECTION line1，PT pr1，
LINE_PROJECTION line2，PT pr2)；
friend DIR_LINE Line_for_PT_rl(LINE_PROJECTION line1，PT p1，
LINE_PROJECTION line2，PT p2)；
}；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
class GOOD_DIR_LINE：public DIR_LINE
{public：
double Qual；
GOOD_DIR_LINE(){Qual＝0；}
GOOD_DIR_LINE(SCR_PNT St，SCR_PNT End)
{Qual＝0；
*(DIR_LINE*)this＝DIR_LINE∷DIR_LINE(St，End)；
}
∥ void OnDraw(short incr)
∥ {PT st＝Start_p()，stp＝End_p()；
∥ _moveto((short)st.u，(short)(st.v+incr))；
∥ _lineto((short)stp.u，(short)(stp.v+incr))；
∥ }
}；
typedef struct{LINE_PROJECTION L_left，L_mid，L_right；
<dp n="d44"/>
DIR_LINE I01，I12，I23，I30；
DIR_LINE I01_pr，I12_pr，I23_pr，I30_pr，
}
RECT_RESOLVED；
#endif
<dp n="d45"/>
#ifndef RES_MCH
#define RES_MCH
#include＜graph.h＞
#include″projctn8.h″
#include″pic_mch8.h″
#define NTSC 0
#define HSI 1
#define New_plan 2
#define RGB 3
#define LUMIN_THR 4
#define IHS 5
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
typedef struct
{double c[3]；
}COLOR_VEC；
void GRAPH_OUT(int ex＝0)；
int GRAPHICS_START(struct_videoconfig *vc，short GR_mode)；
void match_vertex(SCR_PNT *v)；
int_cdecl c_comp(const void *elem1，const void *elem2)；
short interpol(short*s，double x，double y)；
COLOR_RGB INTER_pix_color_rgb(PCT p1，PT PT_now)；
COLOR_RGB INTER_pix_color_rgb_median(PCT p1，PT PT_now)；
const COLOR_VEC NORM_RGB＝{256，1，1}；
const COLOR_VEC NORM_simple＝{256，256，256}；
COLOR_VEC(*PointColorFunct(short M))(COLOR_RGB p1，double
Thresh_mdl)；
COLOR_VEC color_space_NTSC(COLOR_RGB p1，double Thresh_mdl)；
COLOR_VEC color_space_RGB(COLOR_RGB p1，double Thresh_mdl)；
COLOR_VEC color_space_NEW(COLOR_RGB p1，double Thresh_mdl)；
COLOR_VEC color_space_RGB_simple(COLOR_RGB p1，double
Thresh_mdl)；
COLOR_VEC color_space_LUMIN_THR(COLOR_RGB p1，double
Thresh_mdl)；
COLOR_VEC color_space_IHS(COLOR_RGB p1，double Thresh_mdl)；
#endif
<dp n="d46"/>
#ifndef VICAL8
#define VICAL8
#include＜vmemory.h＞
typedef unsigned char byte；
unsigned char_far **virtalloc(short xdim，short ydim)；
#endif
<dp n="d47"/>
#include″comp_fnc.h″
int_cdecl compare_short_pnt(const void *elem1，const void *elem2)
{int i；double t1，t2；
double a；
t1＝**(double**)elem1；t2＝**(double**)elem2；
a＝t1-t2；
i＝(a？((a＜0)？1：-1)；0)；
return i；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int_cdecl compare_GOOD_DIR_LINE(const void *elem1，const void
*elem2)
{int i；double t1，t2；
double a；
t1＝((GOOD_DIR_LINE*)elem1)-＞Qual；t2＝((GOOD_DIR_LINE*)elem2)-
＞Qual；
a＝t1-t2；
i＝(a？((a＜0)？1：-1)：0)；
return i；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int_cdecl compare_array_elem(const void *elem1，const void *elem2)
{int i；
double a；
a＝**(double**)elem1-**(double**)elem2；
i＝(a？((a＜0)？1：-1)：0)；
return i；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d48"/>
#include＜stdio.h＞
#include＜stdlib.h＞
#include＜conio.h＞
#include＜float.h＞
#include＜graph.h＞
#include″cor_fnc8.h″
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
AVERAGE_VEC average(PCT tag，double Thr，
COLOR_VEC(*p_funct)(COLOR_RGB p1，double Thresh_mdl))
{short r_t，c_t，n＝0，i；
AVERAGE_VEC z＝{{0，0，0}，{0，0，0}}；
COLOR_VEC t_p；
for(r_t＝0；r_t＜tag.s rows；r_t++)
for(c_t＝0；c_t＜tag.s_cols；c_t++)
{n++；
t_p＝p_funct(tag.get_pixel(r_t，c_t)，Thr)；
for(i＝0；i＜3；i++)
{
z.md[i]+＝t_p.c[i]；
z.var[i]+＝t_p.c[i]*t_p.c[i]；
}
}
double rr，nrev；
nrev＝n？1.0/n：0；
for(i＝0；i＜3；i++)
{rr＝(z.md[i]*＝nrev)；
z.var[i]＝z.var[i]*nrev；
}
return z；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
COLOR_VEC template_conv_1(PCT target，PCT win，double
Thr，COLOR_VEC int_v，
COLOR_VEC(*p_funct)(COLOR_RGB p1，double Thresh_mdl))
{short i，r，c，n；
COLOR_VEC w_p，t_p；
COLOR_VEC res＝{0，0，0}；
for(n＝r＝0；
(r＜target.s_rows)‖(r＜win.s_rows)；r++)
for(c＝0；
(c＜target.s_cols)‖(c＜win.s_cols)；c++)
{n++；
w_p＝p_funct(win.get_pixel(r，c)，Thr)；
t_p＝p_funct(target.get_pixel(r，c)，Thr)；
for(i＝0；i＜3；i++)
<dp n="d49"/>
if(int_v.c[i])
res.c[i]+＝w_p.c[i]*t_p.c[i]；
}
double nrev；
nrev＝n？1.0/n：0；
for(i＝0；i＜3；i++)
res.c[i]＝res.c[i]*nrev；
return res；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
COLOR_VEC template_abs_diff_1(PCT target，PCT win，double
Thr，COLOR_VEC int_v，
COLOR_VEC(*p_funct)(COLOR_RGB p1，double Thresh_mdl)，
AVERAGE_VEC t，AVERAGE_VEC w)
{short i，r，c，n；
COLOR_VEC w_p，t_p；
COLOR_VEC res＝{0，0，0}，nor＝{0，0，0}；
for(n＝r＝0；
(r＜target.s_rows)‖(r＜win.s_rows)；r++)
for(c＝0；
(c＜target.s_cols)‖(c＜win.s_cols)；c++)
{n++；
w_p＝p_funct(win.get_pixel(r，c)，Thr)；
t_p＝p_funct(target.get_pixel(r，c)，Thr)；
for(i＝0；i＜3；i++)
if(int_v.c[i])
{res.c[i]+＝fabs(w_p.c[i]-t_p.c[i]-w.md[i]+t.md[i])；
nor.c[i]+＝_max(fabs(w_p.c[i]-w.md[i])，fabs(t_p.c[i]-t.md[i]))；
∥ nor.c[i]+＝2*fabs(w_p.c[i]-w.md[i])；
}
}
for(i＝0；i＜3；i++)
if(int_v.c[i]&&nor.c[i])
res.c[i]＝1-res.c[i]/nor.c[i]；
return res；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝
COLOR_VEC Correlation(COLOR_VEC conv，AVERAGE_VEC
t，AVERAGE_VEC w，
COLOR_VEC int_v)
{COLOR_VEC out；
int i；
double p，g；
for(i＝0；i＜3；i++)
if(inf_v.c[i])
<dp n="d50"/>
{p＝(conv.c[i]-t.md[i]*w.md[i])；
g＝(t.var[i]-t.md[i]*t.md[i])*(w.var[i]-w.md[i]*w.md[i])；
out.c[i]＝g？p*p/g：0；
out.c[i]＝(p＞0)？out.c[i]：-out.c[i]；
}
else
out.c[i]＝0.0；
return out；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝
/*COLOR_VEC Correlation_single_1(COLOR_VEC conv，AVERAGE_VEC
t，AVERAGE_VEC w，
COLOR_VEC int_v)
{COLOR_VEC out；
int i；
double sngl_conv＝0；
double sngl_var＝0；
for(i＝0；i＜3；i++)
if(int_v.c[i])
{
sngl_conv+＝conv.c[i]；
sngl_var+＝t.var[i]+w.var[i]；
}
out.c[0]＝out.c[1]＝out.c[2]＝sngl_conv/sngl_var；
return out；
}*/
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
AVERAGE_VEC LineMoments(PCT &T，DIR_LINE Line，short map)
{COLOR_RGB col；
COLOR_VEC vc；
AVERAGE_VEC out＝{{0.0，0.0，0.0}，{0.0，0.0，0.0}}；
PT now；
short length＝U_dist(Line)；
double d；
short j，i，k，ST_X.END_X，now_X；
double relen，delta_V；
PT st，stop；
if(length＜0)
{st＝Line.End_p()；
stop＝Line.Start_p()；
length＝fabs(length)；
}
else
{st＝Line.Start_p()；stop＝Line.End_p()；
<dp n="d51"/>
}
relen＝length？1.0/length：0；
ST_X＝(short)st.u；END_X＝(short)stop.u；
if(delta_V＝(stop.v-st.v)*relen)
for(d＝st.v+0.5，now_X＝ST_X；now_X＜END_X；now_X++，d+＝delta_V)
{
∥ now.u＝ST_X；now.v＝d；
∥ col＝INTER_pix_color_rgb(T，now)；
col＝T.get_pixel((short)d，now_X)；
switch(map)
{case NTSC：；
case New_plan：；
case HSI：；
case IHS：{
vc＝PointColorFunct(map)(col，0)；
for(k＝0；k＜3；k++)
out.md[k]+＝vc.c[k]；
break；
}
case RGB：{
out.md[0]+＝col.r；∥out.var[0]+＝col.r*col.r；
out.md[1]+＝col.g；∥out.var[1]+＝col.g*col.g；
out.md[2]+＝col.b；∥out.var[2]+＝col.b*col.b；
break；
}
case LUMIN_THR：{
out.md[0]+＝col.r+col.g+col.b；
break；
}
}；
}；
for(j＝0；j＜3；j++)
{
out.md[j]*＝relen；
∥ out.var[j]/＝length；
}
return out；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
double Quality(AVERAGE_VEC*UpLineQuality)
{short i，j；
double out，out_even＝0，out_odd＝0，out2 even，out2_odd，sum＝0；
for(j＝0；j＜3；j++)
{
sum+＝(UpLineQuality+0)-＞md[j]+(UpLineQuality+1)-＞md[j]+
<dp n="d52"/>
(UpLineQuality+2)-＞md[j]+(UpLineQuality+3)-＞md[j]；
out2_even＝(UpLineQuality+0)-＞md[j]+(UpLineQuality+1)-＞md[j]-
(UpLineQuality+2)-＞md[j]-(UpLineQuality+3)-＞md[j]；
out2_even*＝out2_even；
out2_odd＝(UpLineQuality+0)-＞md[j]-(UpLineQuality+1)-＞md[j]-
(UpLineQuality+2)-＞md[j]+(UpLineQuality+3)-＞md[j]；
out2_odd*＝out2_odd；
out_even+＝out2_even；
out_odd+＝out2_odd；
}
out＝(out_even+out_odd)*0.001；
return out；
}
<dp n="d53"/>
#include＜stdlib.h＞
#include＜stdio.h＞
#include＜graph.h＞
#include＜math.h＞
#include＜io.h＞
#include＜fcntl.h＞
#include＜string.h＞
#include＜float.h＞
#include＜malloc.h＞
#include″phdr.h″
#include″vical8.h″
#include″pic_mch8.h″
int cols，rows；
PHDR inhdr，
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝
void PCT∷PutNextPix(COLOR_RGB p)
{
*buffer_now++＝(unsigned char)p.r；
*buffer_now++＝(unsigned char)p.g；
*buffer_now++＝(unsigned char)p.b；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
int_cdecl compare_lum(const void *elem 1，const void *elem2)
{int i；COLOR_RGB t1，t2；
double a；
t1＝**(COLOR_RGB**)elem1；t2＝**(COLOR_RGB**)elem2；
a＝(t1.r+t1.g+t1.b-t2.r-t2.g-t2.b)；
i＝(a？((a＜0)？1：-1)：0)；
return i；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
COLOR_RGB PCT∷get_median_pixel(short y，short x，short neibour)
{COLOR_RGB t＝{0，0，0}，
s[MEDIAN_AREA]，*lum_order[MEDIAN_AREA]；
short n，i，j，xnow，ynow；
int x3＝3*x；
unsigned char_far*buffer1；
for(n＝0，i＝-neibour；i＜＝neibour；i++)
<dp n="d54"/>
for(j＝-neibour；j＜＝neibour；j++)
if(((ynow＝y+i)＜s_rows)&&((xnow＝x+j)＜s_cols))
{
buffer1＝(unsigned char_far*)pict[ynow]；
t.r＝*(buffer1+xnow*3+0)；
t.g＝*(buffer1+xnow*3+1)；
t.b＝*(buffer1+xnow*3+2)；
s[n]＝t；
*(lum_order+n)＝s+n；
n++；
}
qsort((void*)lum_order，n，sizeof(COLOR_RGB*)，compare_lum)；
t＝*lum_order[(n+1)＞＞1]；
return t；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
PCT∷PCT(short n_cols，short n_rows)
{
pict＝
(unsigned char_far**)virtalloc(3*n_cols，n_rows)；
if(！pict)
{fprintf(stderr，″No memory for picture″)；
s_cols＝0；
s_rows＝0；
return；
}
buffer_now＝pict[0]；
s_cols＝n_cols；
s_rows＝n_rows；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void PCT∷load_template(PCT source，SCR_PNT left_up_scr)
{
short r_now，c_now；
COLOR_RGB color_p；
unsigned char*BUF，*B；
BUF＝(unsigned char*)malloc((size_t)
(sizeof(unsigned char)*3*s_cols))；
if(！BUF){fprintf(stderr，″BUF″)；exit(-1)；}
for(r_now＝0；r_now＜s_rows；r_now++)
{for(B＝BUF，c_now＝0；c_now＜s_cols；c_now++)
{
color_p＝
source.get_pixel(r_now+left_up_scr.r，c_now+left_up_scr.c)；
*B++＝color_p.r；
*B++＝color_p.g；
*B++＝color_p.b；
}
<dp n="d55"/>
put_str(r_now，BUF)；
}
free((void*)BUF)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
int PCT∷load_file_rgb(const char *name)
{ int er_r；short bytes；
int y，infd；
short ysize，xsize；
char name_of_file[18]；
FILE *datfp；
strcat(strcpy(name_of_file，name)，″.rgb″)；
datfp＝fopen(name_of_file，″rb″)；
infd＝_fileno(datfp)；
if(infd＜＝0)
{ printf(″bad name 1″)；
rerurn(1)；
}
er_r＝_read(infd，&inhdr，sizeof(PHDR))；
xsize＝cols＝inhdr.cols；
ysize＝rows＝inhdr.rows；
if(ysize＞s_rows)
ysize＝s_rows；
if(xsize＞s_cols)
xsize＝s_cols；
s_cols＝xsize；
s_rows＝ysize；
bytes＝3*xsize；
byte Buf[2040]；
for(y＝0；y＜ysize；y++){
read(infd，Buf，3*cols)；
put_str(y，(unsigned char*)Buf)；
}
fclose(datfp)；
return 0：
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
PCT sign_storage_rgb(const char *name，struct_videoconfig vc)
{int er_r；
<dp n="d56"/>
PCT pict_now；
char name_of_file[40]；
FILE*datfp；
strcat(strcpy(name_of_file，name)，″.rgb″)；
int infd；
short ysize，xsize；
datfp＝fopen(name_of_file，″rb″)；
infd＝_fileno(datfp)；
if(infd＜＝0)
{ printf(″bad name 1″)；
return(pict_now)；
}
er_r＝read(infd，&inhdr，sizeof(PHDR))；
if(er_r＜0)
{ printf(″bad name 1″)；
return(pict_now)；
}
fclose(datfp)；
xsize＝cols＝inhdr.cols；
ysize＝rows＝inhdr.rows；
if(ysize＞vc.numypixels)
ysize＝vc.numypixels；
if(xsize＞vc.numxpixels)
xsize＝vc.numxpixels；
pict_now＝PCT∷PCT(xsize，ysize)；
if(pict_now.s_cols)
pict_now.load_file_rgb(name)；
return(pict_now)；
}
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝***/
void sign_present_RGB(PCT pict_scr，SCR_PNT left_up)
{short x，y，xsize，ysize；
COLOR_RGB t；
xsize＝ pict_scr.s_cols；
ysize＝ pict_scr.s_rows；
short c；
for(y＝0；y＜ysize；y++)
{pict_scr.buffer_now＝pict_scr.pict[y]；
for(x＝0；x＜xsize；x++)
{
t＝pict_scr.get_next()；
_setcolor(color_num(t.r＞＞2，t.g＞＞2，t.b＞＞2))；
_setpixel(x+left_up.c，y+left_up.r)；
}
}
}
<dp n="d57"/>
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝
const int stepr＝9，stepg＝9，stepb＝21；
COLOR_RGB*make_palette()
{COLOR_RGB *plt＝NULL；
long now，Lut[256]；
long dr，dg，db；
short i，j，k，num；
for(i＝0，db＝0；i＜4；i++，db+＝stepb)
for(j＝0，dg＝0；j＜8；j++，dg+＝stepg)
for(k＝0，dr＝0；k＜8；k++，dr+＝stepr)
{now＝(db＜＜16)|(dg＜＜8)|dr；
num＝(i＜＜6)|(j＜＜3)|k；
Lut[num]＝now；
}
_remapaIlpalette((long_far*)Lut)；
return plt；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
short color_num(short r，short g，short b)
{short num，i，j，k；
i＝(b+(stepb＞＞1))/stepb；
j＝(g+(stepg＞＞1))/stepg；
k＝(r+(stepr＞＞1))/stepr；
num＝(i＜＜6)|(j＜＜3)|k；
return num；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void write_sign_rgb(char *name，PCT pict_now)
{int er_r，；
char name_of_file[80]；
strcat(strcpy(name_of_file，name)，″.rgb″)；
FILE*datfp；
int y，infd；
datfp＝fopen(name_of_file，″wb″)；
infd＝_fileno(datfp)；
if(infd＜＝0)
printf(″bad name 1″)；
inhdr.cols＝pict_now.s_cols；
inhdr.rows＝pict_now.s_rows；
inhdr.bpp＝3；
er_r＝_write(infd，(void*)(&inhdr)，sizeof(PHDR))；
for(y＝0；y＜pict_now.s_rows；y++)
{
<dp n="d58"/>
#ifdef VIRTUAL
void_far *buffer1；
if((buffer1＝(void_far*)_vload(pict_now.pict[y]，_VM_CLEAN))＝＝
NULL)
{_vheapterm()；exit(-1)；
}
#else
void*buffer1；
buffer1＝(void*)pict_now.pict[y]；
#endif
er_r＝_write(infd，buffer1，sizeof(char)*pict_now.s_cols*3)；
}
fclose(datfp)；
strcat(strcpy(name_of_file，name)，″.sgn″)；
datfp＝fopen(name_of_file，″w″)；
fprintf(datfp，″％s \n 0 0\n″，name)；
fprintf(datfp，″％d 0\n″，pict_now.s_cols-1)；
fprintf(datfp，″％d ％d\n″，pict_now.s_cols-1，pict_now.s_rows-1)；
fprintf(datfp，″0％d\n″，pict_now.s_rows-1)；
fclose(datfp)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝
<dp n="d59"/>
#include＜stdlib.h＞
#include＜stdio.h＞
#include＜graph.h＞
#include＜math.h＞
#include＜io.h＞
#include＜fcntl.h＞
#include＜string.h＞
#include＜float.h＞
∥#include＜malloc.h＞
∥#indude″phdr.h″
∥#include″vical8.h″
#include″picture.h″
∥int cols，rows；
∥PHDR inhdr；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
COLOR_RGB PCT∷get_median_pixel(short y，short x，short neibour)
{COLOR_RGB t＝{0，0，0}，
s[MEDIAN_AREA]，*lum_order[MEDIAN_AREA]；
short n，i，j，xnow，ynow；
int x3＝3*x；
unsigned char_far*buffer1；
for(n＝0，i＝-neibour；i＜＝neibour；i++)
for(j＝-neibour；j＜＝neibour；j++)
if(((ynow＝y+i)＜s_rows)&&((xnow＝x+j)＜s_cols))
{
buffer1＝(unsigned char_far*)pict[ynow]；
t.r＝*(buffer1+xnow*3+0)；
t.g＝*(buffer1+xnow*3+1)；
t.b＝*(buffer1+xnow*3+2)；
s[n]＝t；
*(lum_order+n)＝s+n；
n++；
}
qsort((void*)lum_order，n，sizeof(COLOR_RGB*)，compare_lum)；
t＝*lum_order[(n+1)＞＞1]；
return t；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
PCT∷PCT(short n_cols，short n_rows)
{
pict＝
(unsigned char_far**)virtalloc(3*n_cols，n_rows)；
if(！pict)
{fprintf(stderr，″No memory for picture″)；
s_cols＝0；
s_rows＝0；
<dp n="d60"/>
return；
}
buffer_now＝pict[0]；
s_cols＝n_cols；
s_rows＝n_rows；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void PCT∷load_template(PCT source，SCR_PNT left_up_scr)
{
short r_now，c_now；
COLOR_RGB color_p；
unsigned char*BUF，*B；
BUF＝(unsigned char*)mailoc((size_t)
(sizeof(unsigned char)*3*s_cols))；
if(！BUF){fprintf(stderr，″BUF″)；exit(-1)；}
for(r_now＝0；r_now＜s_rows；r_now++)
{for(B＝BUF，c_now＝0；c_now＜s_cols；c_now++)
{
color_p＝
source.get_pixel(r_now+left_up_scr.r，c_now+left_up_scr.c)；
*B++＝color_p.r；
*B++＝color_p.g；
*B++＝color_p.b；
}
put_str(r_now，BUF)；
}
free((void*)BUF)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
int PCT∷load_file_rgb(const char*name)
{ int er_r；short bytes；
int y，infd；
short ysize，xsize；
char name_of_file[18]；
FILE*datfp；
strcat(strcpy(name_of_file，name)，″.rgb″)；
datfp＝fopen(name_of_file，″rb″)；
infd＝_fileno(datfp)；
if(infd＜＝0)
{ printf(″bad name 1″)；
return(1)；
}
er_r＝_read(infd，&inhdr，sizeof(PHDR))；
xsize＝cols＝inhdr.cols；
ysize＝rows＝inhdr.rows；
<dp n="d61"/>
if(ysize＞s_rows)
ysize＝s_rows；
if(xsize＞s_cols)
xsize＝s_cols；
s_cols＝xsize；
s_rows＝ysize；
bytes＝3*xsize；
byte Buf[2040]；
for(y＝0；y＜ysize；y++){
read(infd，Buf，3*cols)；
put_str(y，(unsigned char*)Buf)；
}
fclose(datfp)；
return 0；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
PCT sign_storage_rgb(const char*name，struct_videoconfig vc)
{ int er_r；
PCT pict_now；
char name_of_file[40]；
FILE *datfp；
strcat(strcpy(name_of_file，name)，″.rgb″)；
int infd；
short ysize，xsize；
datfp＝fopen(name_of_file，″rb″)；
infd＝_fileno(datfp)；
if(infd＜＝0)
{ printf(″bad name 1″)；
return(pict_now)；
}
er_r＝_read(infd，&inhdr，sizeof(PHDR))；
if(er_r＜0)
{ printf(″bad name 1″)；
return(pict_now)；
}
fclose(datfp)；
xsize＝cols＝inhdr.cols；
ysize＝rows＝inhdr.rows；
if(ysize＞vc.numypixels)
ysize＝vc.numypixels；
if(xsize＞vc.numxpixels)
<dp n="d62"/>
xsize＝vc.numxpixels；
pict_now＝PCT∷PCT(xsize，ysize)；
if(pict_now.s_cols)
pict_now.load_file_rgb(name)；
return(pict_now)；
}
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝***/
void sign_present_RGB(PCT pict_scr，SCR_PNT left_up)
{short x，y，xsize，ysize；
COLOR_RGB t；
xsize＝ pict_scr.s_cols；
ysize＝ pict_scr.s_rows；
short c；
for(y＝0；y＜ysize；y++)
{pict_scr.buffer_now＝pict_scr.pict[y]；
for(x＝0；x＜xsize；x++)
{
t＝pict_scr.get_next()；
_setcolor(color_num(t.r＞＞2，t.g＞＞2，t.b＞＞2))；
_setpixel(x+left_up.c，y+left_up.r)；
}
}
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝
const int stepr＝9，stepg＝9，stepb＝21；
COLOR_RGB*make_palette()
{COLOR_RGB*plt＝NULL；
long now，Lut[256]；
long dr，dg，db；
short i，j，k，num；
for(i＝0，db＝0；i＜4；i++，db+＝stepb)
for(j＝0，dg＝0；j＜8；j++，dg+＝stepg)
for(k＝0，dr＝0；k＜8；k++，dr+＝stepr)
{now＝(db＜＜16)|(dg＜＜8)|dr；
num＝(i＜＜6)|(j＜＜3)|k；
Lut[num]＝now；
}
_remapallpalette((long_far*)Lut)；
return plt；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
short color_num(short r，short g，short b)
{short num，i，j，k；
i＝(b+(stepb＞＞1))/stepb；
<dp n="d63"/>
j＝(g+(stepg＞＞1))/stepg；
k＝(r+(stepr＞＞1))/stepr；
num＝(i＜＜6)|(j＜＜3)|k；
return num；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void write_sign_rgb(char*name，PCT pict_now)
{ int er_r；；
char name_of_file[80]；
strcat(strcpy(name of_file，name)，″.rgb″)；
FILE*datfp；
int y，infd；
datfp＝fopen(name_of_file，″wb″)；
infd＝_fileno(datfp)；
if(infd＜＝0)
printf(″bad name 1″)；
inhdr.cols＝pict_now.s_cols；
inhdr.rows＝pict_now.s_rows；
inhdr.bpp＝3；
er_r＝_write(infd，(void*)(&inhdr)，sizeof(PHDR))；
for(y＝0；y＜pict_now.s_rows；y++)
{
#ifdef VIRTUAL
void_far*buffer1；
if((buffer1＝(void_far*)vload(pict now.pict[y]，_VM_CLEAN))＝＝
NULL)
{_vheapterm()；exit(-1)；
}
#else
void *buffer1；
buffer1＝(void*)pict_now.pict[y]；
#endif
er_r＝_write(infd，buffer1，sizeof(char)*pict_now.s_cols*3)；
}
fclose(datfp)；
strcat(strcpy(name_of_file，name)，″.sgn″)；
datfp＝fopen(name_of_file，″w″)；
fprintf(datfp，″％s \n 0 0\n″，name)；
fprintf(datfp，″％d 0\n″，pict_now.s_cols-1)；
fprintf(datfp，″％d ％d \n″，pict_now.s_cols-1，pict_now.s_rows-1)；
fprintf(datfp，″0％d\n″，pict_now.s_rows-1)；
fclose(datfp)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝
<dp n="d64"/>
#include＜graph.h＞
#include＜stdlib.h＞
#include＜iostream.h＞
#include″projctn8.h″
∥For Constructor Calculate ratio of Lengthes.
∥FOR CONSTRUCTOR Fill Members
∥88888888888
LINE_PROJECTION∷LINE_PROJECTION
(DIR_LINE I1，PT p，DIR_LINE pr，PT p_pr)
{double P，Ro；
Rl＝I1；
Prj＝pr；
P＝I1.RATIO_for_PT(p)；
Ro＝pr.RATIO_for_PT(p_pr)；
if(P&&(1-Ro))
{proj_prm＝(Ro-P)/(P*(1-Ro))；returrn；}；
cout＜＜″LINE UNRESOLVABLE\n″；
}
PT cross_line(DIR_LINE Line1，DIR_LINE Line2)
{PT out；
double det；
if(det＝Line1.a*Line2.b-Line2.a*Line1.b)
{out.u＝(Line1.b*Line2.c-Line1.c*Line2.b)/det；
out.v＝(Line1.c*Line2.a-Line2.c*Line1.a)/det；
}
else out.u＝out.v＝0；
#ifdef DEBUG
_setcolor(0)；
_ellipse(_GFILLINTERIOR，(short)(out.u-1)，(short)(out.v-1)，
(short)(out.u+1)，(short)(out.v+1))；
#endif
return out；
}
∥Bield real space line connecting points X1 and X2
///X1 belongs to line1.X2 to line2：
∥PT pr1-projection X1
∥PT pr2-projection X2
∥LINE_PROJECTION line1，line2
DIR_LINE Line_for_PT_pr(LINE_PROJECTION line1，PT pr1，
LINE_PROJECTION line2，PT pr2)
{
double P，Ro；
PT p1，p2；
<dp n="d65"/>
Ro＝line1.Prj.RATIO_for_PT(pr1)； ∥relative point position at line
P＝line1.P_for_Ro(Ro)；
p1＝line1.RI.PT_for_P(P)；
Ro＝line2.Prj.RATIO_for_PT(pr2)； ∥relative point position at line
P＝line2.P_for_Ro(Ro)；
p2＝line2.RI.PT_for_P(P)；
DIR_LINE In(p1，p2)；
return(In)；
}
∥Bield projection line connecting points p1 and p2
///p1 belongs to line1，p2 to line2：
∥PT p1-projection X1
∥PT p2-projection X2
∥LINE_PROJECTION line1，line2
DIR_LINE Line_for_PT_rl(LINE_PROJECTION line1，PT p1，
LINE_PROJECTION line2，PT p2)
{double P，Ro；
PT p1pr，p2pr；
P＝line1.RI.RATIO_for_PT(p1)； ∥relative point position at line
Ro＝line1.Ro_for_P(P)；
p1pr＝line1.Prj.PT_for_P(Ro)；
P＝line2.RI.RATIO_for_PT(p2)； ∥relative point position at line
Ro＝line2.Ro_for_P(P)；
p2pr＝line2.Prj.PT_for_P(Ro)；
DIR_LINE ln(p1pr，p2pr)；
return(In)；
}
∥＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝1 if point P in quagrangle
int INside(DIR_LINE I1，DIR_LINE I2，DIR_LINE I3，DIR_LINE I4，int col，int row)
{return(I1.Left_Right(col，row)&&I2.Left_Right(col，row)&&
I3.Left_Right(col，row)&&I4.Left_Right(col，row))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int U_dist(DIR_LINE I)
{return(I.end_pnt.u-I.st_pnt.u)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d66"/>
#include＜stdlib.h＞
#include＜vmemory.h＞
#include″res_mch8.h″
#define AVERAGE
#define SMOOSE_INT 1
extem double GAMMA；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝
COLOR_VEC(*PointColorFunct(short M))(COLOR_RGB p1，double
Thresh_mdl)
{switch(M)
{case NTSC：return(color_space_NTSC)；
case New_plan：return(color_space_NEW)；
case HSI：return(color_space_RGB)；
case RGB：return(color_space_RGB_simple)；
case LUMIN_THR：return(color_space_LUMIN_THR)；
case IHS：return(color_space_IHS)；
}；
return NULL；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void GRAPH_OUT(int ex).
{
_displaycursor(_GCURSORON)；
_setvideomode(_DEFAULTMODE)；
if(ex)exit(ex)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝
int GRAPHICS_START(struct_videoconfig *p_vc，short GR_mode)
{
_displaycursor(_GCURSOROFF)；
_setvideomode(GR_mode)；
if(_grstatus()＜0)return(1)；
_getvideoconfig(p_vc)；
make_palette()；
return 0；
}
∥—————————————sorting vertexes
int_cdecl c_comp(const void *elem 1，const void *elem2)
{
if(((SCR_PNT*)elem1)-＞c＞((SCR_PNT*)elem2)-＞c)
return 1；
else
if(((SCR_PNT*)elem1)-＞c＜((SCR_PNT*)elem2)-＞c)
<dp n="d67"/>
return-1；
else return 0；
}
∥———————————
void match_vertex(SCR_PNT*v)
{SCR_PNT vrt[4]；
int i；
for(i＝0；i＜4；i++)
vrt[i]＝*(v+i)；
qsort((void*)vrt，4，sizeof(SCR_PNT)，c_comp)；
if(vrt[0].r＜vrt[1].r)
{*(v+3)＝vrt[0]；*(v+2)＝vrt[1]；}
else
{*(v+3)＝vrt[1]；*(v+2)＝vrt[0]；}
if(vrt[2].r＜vrt[3].r)
{*v＝vrt[2]；*(v+1)＝vrt[3]；}
else
{*v＝vrt[3]；*(v+1)＝vrt[2]；}
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
inline short interpol(short*s，double x，double y)
{double r＝s[0]+x*y*(s[0]-s[1]+s[2]-s[3])+x*(s[1]-s[0])+y*(s[3]-s[0])；
return((short)r)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
∥ONLY FOR INTER_pix_color_rgb
∥and INTER_pix_color_rgb_median
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝
inline COLOR_RGB BE_linear(COLOR_RGB*p，double x_fract，double
y_fract)
∥loop over coolr
{short s[4]；
COLOR_RGB out_col；
s[0]＝p[0].r；
s[1]＝p[1].r；
s[2]＝p[2].r；
s[3]＝p[3].r；
out_col.r＝(short)interpol(s，x_fract，y_fract)；
s[0]＝p[0].g；
s[1]＝p[1].g；
s[2]＝p[2].g；
s[3]＝p[3].g；
out_col.g＝(short)interpol(s，x_fract，y_fract)；
s[0]＝p[0].b；
s[1]＝p[1].b；
s[2]＝p[2].b；
s[3]＝p[3].b；
<dp n="d68"/>
out_col.b＝(short)interpol(s，x_fract，y_fract)；
return out_col；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝
COLOR_RGB INTER_pix_color_rgb(PCT p1，PT PT_now)
{
int col0＝(int)PT_now.u，
row0＝(int)PT_now.v；
double x_fract＝PT_now.u-col0，y_fract＝PT_now.v-row0；
COLOR_RGB p[4]；
p[0]＝p1.get_pixel(row0，col0)；
p[1]＝p1.get_next()；
p[3]＝p1.get_pixel(row0+1，col0)；
p[2]＝p1.get_next()；
return(BE_linear(p，x_fract，y_fract))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
COLOR_RGB INTER_pix_color_rgb_median(PCT p1，PT PT_now)
{
int col0＝(int)PT_now.u，
row0＝(int)PT_now.v；
double x_fract＝PT_now.u-col0，y_fract＝PT_now.v-row0；
COLOR_RGB p[4]；
p[0]＝p1.get_median_pixel(row0，col0，SMOOSE_INT)；
p[1]＝p1.get_median_pixel(row0，col0+1，SMOOSE_INT)；
p[2]＝p1.get_median_pixel(row0+1，col0+1，SMOOSE_INT)；
p[3]＝p1.get_median_pixel(row0+1，col0，SMOOSE_INT)；
return(BE_linear(p，x_fract，y_fract))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#define NTSCr(c)((c).r*0.6-(c).g*0.28-(c).b*0.32)
#define NTSCg(c)(0.21*(c).r-0.52*(c).g+0.31*(c).b)
#define NTSCw(c)(0.3*(c).r+0.59*(c).g+0.11*(c).b)
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
COLOR_VEC color_space_NTSC(COLOR_RGB p1，double Thresh_mdl)
{COLOR_VEC out＝{0，0，0}；
if((out.c[0]＝NTSCw(p1))＞Thresh_mdl)
{out.c[1]＝NTSCr(p1)；
out.c[2]＝NTSCg(p1)；
}
out.c[0]*＝0.6；
return out；
}
<dp n="d69"/>
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝
#define RGBr(c)(c).r
#define RGBg(c)(c).g
#define RGBw(c)((c).r+(c).g+(c).b)
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
COLOR_VEC color_space_RGB(COLOR_RGB p1，double Thresh_mdl)
{COLOR_VEC out＝{0，0，0}；
if((out.c[0]＝RGBw(p1))＞Thresh_mdl)
{out.c[1]＝RGBr(p1)/out.c[0]；
out.c[2]＝RGBg(p1)/out.c[0]；
}
out.c[0]*＝0.33333333333333333*GAMMA；
return out；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝
COLOR_VEC color_space_LUM(COLOR_RGB p1，double Thresh_mdl)
{COLOR_VEC out＝{0，0，0}；
out.c[2]＝out.c[1]＝out.c[0]＝RGBw(p1)*0.33333333333333333；
return out；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝
#define RGBSr(c)(c).r
#define RGBSg(c)(c).g
#define RGBSw(c)(c).b
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
COLOR_VEC color_space_RGB_simple(COLOR_RGB p1，double
Thresh_mdl)
{COLOR_VEC out＝{0，0，0}；
out.c[0]＝(RGBSr(p1)＞Thresh_mdl)？RGBSr(p1)：0；
out.c[1]＝(RGBSg(p1)＞Thresh_mdl)？RGBSg(p1)：0；
out.c[2]＝(RGBSw(p1)＞Thresh_mdl)？RGBSw(p1)：0；
return out；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥#define NEWr(c)(0.4*((c).r+(c).g)-{c).b)
∥For interval normalisation 0.4-＞0.5
#define NEWr(c)(0.5*((c).r+(c).g)-(c).b)
#define NEWg(c) ((c).r-(c).g)
#define NEWw(c) ((c).r+(c).g+(c).b)
<dp n="d70"/>
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
COLOR_VEC color_space_NEW(COLOR_RGB p1，double Thresh_mdl)
{COLOR_VEC out＝{0，0，0}；
if((out.c[0]＝NEWw(p1))＞Thresh_mdl)
{
out.c[1]＝NEWr(p1)；
out.c[2]＝NEWg(p1)；
∥ out.c[1]＝NEWr(p1)/out.c[0]；
∥ out.c[2]＝NEWg(p1)/out.c[0]；
}
out.c[0]*＝0.6666666666666666；
return out；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
#define LMNr(c)(c).r
#define LMNg(c) (c).g
#define LMNw(c) (((c).r+(c).g+(c).b)*0.33333333333)
#define Thresh_LUMINEN 136
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
COLOR_VEC color_space_LUMIN_THR(COLOR_RGB p1，double
Thresh_mdl)
{COLOR_VEC out＝{0，0，0}；
double t；
out.c[2]＝out.c[1]＝out.c[0]＝((t＝LMNw(p1))＞Thresh_mdl)？t：0；
return out；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
const double SQ3＝(sqrt(3.0))；
const double P105＝(asin(1.0))；
#define min3(c)(_min((c).r，_min((c).g，(c).b)))
#define max3(c)(_max((c).r，_max((c).g，(c).b)))
#define IHSh(c，d) (atan(SQ3*((c).g-(c).b)/d))
#define IHSi(c) (((c).r+(c).g+(c).b)*0.33333333333)
#define IHSs(c)((double)(max3(c)-min3(c))/(double)(max3(c)+min3(c)))
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
COLOR_VEC color_space_IHS(COLOR_RGB p1，double Thresh_mdl)
{COLOR_VEC out＝{0，0，0)；
double r＝2*p1.r-p1.g-p1.b；
out.c[1]＝IHSi(p1)；
out.c[2]＝out.c[1]？IHSs(p1)：0；
<dp n="d71"/>
if(fabs(out.c[2])＜Thresh_mdl)
out.c[0]＝0；
else
out.c[0]＝r？IHSh(p1，r)：(((p1.g-p1.b)＜0)？-PI05：PI05)；
return out；
}
<dp n="d72"/>
#include＜stdlib.h＞
#include＜stdio.h＞
#include＜vmemory.h＞
#include＜malloc.h＞
unsigned char_far**virtalloc(short xdim，short ydim){
int y，j；
unsigned char_far**mem；
mem＝(unsigned char_far**)malloc(ydim*sizeof(unsigned char
_far**))；
if(mem＝＝NULL)
return(NULL)；
for(y＝0；y＜ydim；y++){
if((mem[y]＝(unsigned char_far*)malloc(xdim*sizeof(char)))＝＝
NULL)
{
printf(″NO MEMORY MAX size＝％d″，y)；
for(j＝0；j＜y；j++)
free((void*)mem[j])；
free((void*)mem)；
return(NULL)；
}
}
return(mem)；
}
<dp n="d73"/>
ORIGIN＝PWB
ORIGIN_VER＝2.0
PROJ＝LNS_CORR
PROJFILE＝LNS_CORR.MAK
BUILDDIR＝obj
DEBUG＝0
BRFLAGS＝/o obj\$(PROJ).bsc
BSCMAKE＝bscmake
SBRPACK＝sbrpack
NMAKEBSC1＝set
NMAKEBSC2＝nmake
BROWSE＝1
CC＝cl
CFLAGS_G＝/W2/BATCH/FR$*.sbr/Zn
CFLAGS_D＝/f/Zi/Od
CFLAGS_R＝/f-/Ot/Oi/Ol/Oe/Og/Gs
CXX＝cl
CXXFLAGS_G＝/AL/W4/G2/D_DOS/BATCH/FR$*.sbr/Zn
CXXFLAGS_D＝/f-/Od/FPi87/Zi/DMICI/DSINGLE_WIN
CXXFLAGS_R＝/f-/Ot/Ol/Og/Oe/Oi/FPi87/Gs/DMICI/DSINGLE_WIN
MAPFILE_D＝NUL
MAPFILE_R＝NUL
LFLAGS_G＝/NOI/STACK：32000/BATCH/ONERROR：NOEXE
LFLAGS_D＝/CO/FAR/PACKC
LFLAGS_R＝/EXE/FAR/PACKC
LINKER＝link
ILINK＝ilink
LRF＝echo＞NUL
ILFLAGS＝/a/e
LLIBS_G＝graphics lafxcr
CVFLAGS＝/25/S
RUNFLAGS＝..\win4\S160_0..\win4\S160_auto1
FILES＝LNS_CORR.CPP..\LIB\VICALLOC.CPP..\LIB\PROJCTN7.CPP\
..\LIB\PIC_M7.CPP..\LIB\RES_MCH7.CPP COR_FNC.CPP
COR_WIN.CPP
OBJS＝obj\LNS_CORR.obj obj\VICALLOC.obj obj\PROJCTN7.obj
obj\PIC_M7.obj\
obj\RES_MCH7.obj obj\COR_FNC.obj obj\COR_WIN.obj
SBRS＝obj\LNS_CORR.sbr obj\VICALLOC.sbr obj\PROJCTN7.sbr
obj\PIC_M7.sbr\
obj\RES_MCH7.sbr obj\COR_FNC.sbr obj\COR_WIN.sbr
all：obj\$(PROJ).exe
.SUFFIXES：
.SUFFIXES：
.SUFFIXES：.obj.sbr.cpp
<dp n="d74"/>
obj\LNS_CORR.obj：LNS_CORR.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\string.h C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\io.h
C：\C700\INCLUDE\time.h\
C：\C700\INCLUDE\ctype.h C：\C700\INCLUDE\iostream.h\
C：\C700\MFC\INCLUDE\afx.h LNS_CORR.h cor_win.h
c：\ilya\lib\vicalloc.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\MFC\INCLUDE\afx.inl..\LIB\projctn7.h..\LIB\pic_mch7.h\
..\LIB\res_mch7.h c：\ilya\lib\lin_tm7.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\math.h
！IF$(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c$(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\LNS_CORR.obj LNS_CORR.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c$(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\LNS_CORR.obj LNS_CORR.CPP
＜＜
！ENDIF
obj\LNS_CORR.sbr：LNS_CORR.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\string.h C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\io.h
C：\C700\INCLUDE\time.h\
C：\C700\INCLUDE\ctype.h C：\C700\INCLUDE\iostream.h\
C：\C700\MFC\INCLUDE\afx.h LNS_CORR.h cor_win.h
c：\ilya\lib\vicalloc.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\MFC\INCLUDE\afx.inl..\LIB\projctn7.h..\LIB\pic_mch7.h\
..\LIB\res_mch7.h c：\ilya\lib\lin_trn7.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\LNS_CORR.sbr LNS_CORR.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\LNS_CORR.sbr LNS_CORR.CPP
＜＜
<dp n="d75"/>
！ENDIF
obj\VICALLOC.obj：..\LIB\VICALLOC.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\vmemorv.h\
C：\C700\INCLUDE\nalloc.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\VICALLOC.obj..\LIB\VICALLOC.CPP
＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\VICALLOC.obj..\LIB\VICALLOC.CPP
＜＜
！ENDIF
obj\VICALLOC.sbr：..\LIB\VICALLOC.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\malloc.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\VICALLOC.sbr..\LIB\VICALLOC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\(PROJ).rsp
/Zs$(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\VICALLOC.sbr..\LIB\VICALLOC.CPP
＜＜
！ENDIF
obj\PROJCTN7.obj：..\LIB\PROJCTN7.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h
..\LIB\projctn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\PROJCTN7.obj..\LIB\PROJCTN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c$(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PROJCTN7.obj..\LIB\PROJCTN7.CPP
＜＜
！ENDIF
<dp n="d76"/>
obj\PROJCTN7.sbr：..\LIB\PROJCTN7.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h
..\LIB\projctn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PROJCTN7.sbr..\LIB\PROJCTN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PROJCTN7.sbr..\LIB\PROJCTN7.CPP
＜＜
！ENDIF
obj\PIC_M7.obj：..\LIB\PIC_M7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\graph.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\io.h C：\C700\INCLUDE\fcntl.h
C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\malloc.h..\LIB\phdr.h\
c：\ilya\lib\vicalloc.h..\LIB\pic_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\projctn7.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c$(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\PIC_M7.obj..\LIB\PIC_M7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PIC_M7.obj..\LIB\PIC_M7.CPP
＜＜
！ENDIF
obj/PIC_M7.sbr：..\LIB\PIC_M7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\graph.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\io.h C：\C700\INCLUDE\fcntl.h
C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\malloc.h..\LIB\phdr.h\
c：\ilya\lib\vicalloc.h..\LIB\pic_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\proictn7.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
<dp n="d77"/>
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PIC_M7.sbr..\LIB\PIC_M7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PIC_M7.sbr..\LIB\PIC_M7.CPP
＜＜
！ENDIF
obj\RES_MCH7.obj：..\LIB\RES_MCH7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
C：\C700\INCLUDE\graph.h..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\RES_MCH7.obj..\LIB\RES_MCH7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c$(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\RES_MCH7.obj..\LIB\RES_MCH7.CPP
＜＜
！ENDIF
obj\RES_MCH7.sbr：..\LIB\RES_MCH7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
C：\C700\INCLUDE\graph.h..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\RES_MCH7.sbr..\LIB\RES_MCH7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\RES_MCH7.sbr..\LIB\RES_MCH7.CPP
＜＜
！ENDIF
obj\COR_FNC.obj：COR_FNC.CPP C：\C700\INCLUDE\stdio.h
C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\float.H\
C：\C700\INCLUDE\graph.h cor_fnc.h..\LIB\pic_mch7.h
..\LIB\res_mch7.h\
C：\C700\INCLUDE\vmemory.h..\LIB\projctn7.h
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
<dp n="d78"/>
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\COR_FNC.obj COR_FNC.CPP
＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\COR_FNC.obj COR_FNC.CPP
＜＜
！ENDIF
obj\COR_FNC.sbr：COR_FNC.CPP C：\C700\INCLUDE\stdio.h
C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\float. H\
C：\C700\INCLUDE\graph.h cor_fnc.h..\LIB\pic_mch7.h
..\LIB\res_mch7.h\
C：\C700\INCLUDE\vmemory.h..\LIB\projctn7.h
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\COR_FNC.sbr COR_FNC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs$(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\COR_FNC.sbr COR_FNC.CPP
＜＜
！ENDIF
obj\COR_WIN.obj：COR_WIN.CPP C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\nalloc.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\string.h LNS_CORR.h cor_fnc.h..\LIB\projctn7.h\
..\LIB\pic_mch7.h..\LIB\res_mch7.h c：\ilya\lib\lin_trn7.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\COR_WIN.obj COR_WIN.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\COR_WIN.obj COR_WIN.CPP
＜＜
！ENDIF
obj\COR_WIN.sbr：COR_WIN.CPP C：\C700\INCLUDE\vmemory.h\
<dp n="d79"/>
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\malloc.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\string.h LNS_CORR.h cor_fnc.h..\LIB\projctn7.h\
..\LIB\pic_mch7.h..\LIB\res_mch7.h c：\ilya\lib\lin\trn7.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\COR_WIN.sbr COR_WIN.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\COR_WIN.sbr COR_WIN.CPP
＜＜
！ENDIF
obj\$(PROJ).bsc：$(SBRS)
$(BSCMAKE)@＜＜
$(BRFLAGS)$(SBRS)
＜＜
obj\$(PROJ).exe：$(OBJS)
-$(NMAKEBSC1)MAKEFLAGS＝
-$(NMAKEBSC2)$(NMFLAGS)-f$(PROJFILE)obj\$(PROJ).bsc
！IF $(DEBUG)
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS＝+^
)
$@
$(MAPFILE_D)
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_D：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_D)；
＜＜
！ELSE
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
$(MAPFILE_R)
<dp n="d80"/>
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_R：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_R)；
＜＜
！ENDIF
$(LINKER)@obj\$(PROJ).Irf
.cpp.obj：
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Fo$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Fo$@ $＜
＜＜
！ENDIF
.cpp.sbr：
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FR$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FR$@ $＜
＜＜
！ENDIF
run：obj\S(PROJ).exe
obj\$(PROJ).exe $(RUNFLAGS)
debug：obj\$(PROJ).exe
CV$(CVFLAGS)obj\$(PROJ).exe $(RUNFLAGS)
<dp n="d81"/>
void corr_win_proto(PCT win_source，PCT Proto，SCR_PNT win_size
，short win_step，double CORR_THRESH，
short *StripEnds)；
<dp n="d82"/>
∥ Module calculates correlation functions of PROTO_1 and set of
∥prototypes.Set of prototypes′names is defined by a MASK correspondes
∥to names generated by MAKEPRB and has next structure：
∥ [path]&RRW_P.rgb
∥Where
∥ [path]-optional name of directory；
∥ & -first letter of file name
∥ RR -two digits corresponding to prototype′s hight
∥ (RR＝16|32|48|64)
∥ W -number corresponding to window number(see
MAKEPRB
∥ description.
∥ P prototype Number
∥ MASK includes ONLY[path]&RRW_ and programme will
∥calculate correlation functions for prototypes with P from 0 to
∥first not existing number.
∥COMMAND STRING
∥
∥Ins_corr＜PROTO_1_Name＞＜MASK＞[CommandFile]
∥
∥ ＜PROTO_1_Name＞ File name of PROTOTYPE without
extention
∥ ＜MASK＞ Mask for prototypes FileNames without extention
and
∥ Prototype′s number.
∥ [CommandFile] Optional ASCI file with a run time parameters.
∥
∥INPUT
∥ RGB files of prototypes and corresponding.SGN files created by
∥module MAKEPRB.
∥RUN TIME parameters：
∥
∥ 0 0 0 0 -shift for all cases have to be 0
∥ ＜CalorSpace＞
∥ We have used 1-as worked only with a luminance
∥ ＜Window width＞
∥ We have used 8
∥SEE ALSO FILE″LNS CORR.INI″
∥OUTPUT
∥ Correlation functions in PROTO 1.DBC file.
#include＜stdlib.h＞
#include＜conio.h＞
#include＜stdio.h＞
#include＜string.h＞
#include＜graph.h＞
#include＜float.H＞
<dp n="d83"/>
#include＜io.h＞
#include＜time.h＞
#include＜ctype.h＞
#include＜iostream.h＞
#include＜afx.h＞
#include″LNS_CORR.h″
#include″cor_win2.h″
#include″vicalloc.h″
char f_name[40]＝″_″，FILE_name[40]＝″_″，FRAME_Name[40]＝″_″，
ARGV_1[30]＝″_″，
STRING_name[40]＝″_″，SIGN_name[40]＝″_″，TAG_name[9]＝″_″，
drive[3]＝″_″，dir[30]＝″_″，
ext[5]＝″_″，*tag_frame；
double GAMMA＝1.0，CORR_THRESH＝0.0，Thresh_mdl＝0.0；
short MAP；
short VOITING＝3，TAG_hight；
struct_videoconfig vc；
FILE*datres；
int FLG_WRIGHT＝0；
double sh[4]＝{0，0，0，0}；
PCT pict_target，pict_proto；
FILE *out_rslt；
int picture_inf(char *name，SCR_PNT *vertexes)；
int picture_inf_num(char *name，SCR_PNT *vertexes，short n)；
int get_number()；∥INITIALISATION GRAPHICMODE，GET SCALE
int get_number_3()；∥INITIALISATION GRAPHICMODE，GET SCALE
void get_shift_f(FILE *f，double *sh)；∥INITIALISATION GRAPHICMODE，
GET SCALE
void get_shift(double *sh)；∥INITIALISATION GRAPHICMODE，GET SCALE
int get_number_3_f(FILE *f)；∥INITIALISATION GRAPHICMODE，GET
SCALE
int picture_inf_num_2(char *name，SCR_PNT *vertexes，short n，char *ext)；
int picture_inf_num_new(char *name，SCR_PNT *vertexes，short n)；
∥$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$
short PRESENT_HIGHT＝32，CALC_HIGHT＝32；
FILE *INP_PROTOCOL；
FILE *PROTOCOL；
CString PROTOCOL_NAME；
CString PROTOCOL_START；
CString PROTO1_HEADER＝CString∷CString(
<dp n="d84"/>
″PROTO_File\tFRAME_Name\tSTRING_name\tS_name\tSLength\tWinLengt
h\tSPACE\n″)；
CString PROTO_TAG_HEADER＝CString∷CString(
″TAG_File\tFRAME_Name\tSTRING_name\tS_Name\tLegnth\tCOMM\n″)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝
void init_protocol(char *name)
{short FLG；
FLG＝_access(PROTOCOL_NAME，0)；∥0 if exist
PROTOCOL＝fopen(PROTOCOL_NAME，″a″)；
if(FLG)
fprintf(PROTOCOL，″AUTO and CROSS correlation functions \n ％s″，
PROTO1_HEADER)；
PROTOCOL_START＝name；
PROTOCOL_START+＝″\t″；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝
int open_inp_prot(char *name)
{if(！(INP_PROTOCOL＝fopen(name，″r″)))return 1；
∥split first str
fscanf(INP_PROTOCOL，″％*[^\n]s″)；
return 0；
}
∥$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$
∥return file name without extwntion in″name″and TRUE 1 if file exist；
int next_pict(char *name，char *mask，char *ext，int num)
∥if num＝-2 initalisation；
∥ -1 next
∥ ＞0 adding this # to mask
∥NULL if notexist file with″.rgb″
{static int now；
char full_name[80]；
strcpy(name，mask)；
if(num＝＝-2)now＝0；
else if(num＝＝-1)
now++；
else if(num＜0)return 1；
else now＝num；
_itoa(now，name+strlen(name)，10)；
strcat(strcpy(full_name，name)，ext)；
∥1 if file exist
return(！_access(ful_name，0))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝
<dp n="d85"/>
#include＜fstream.h＞
int ReadStrlnf(char *name，short *StD)
{ifstream InpF；
char a[80]；
strcat(strcpy(a，name)，″.str″)；
short i；
InpF.open(a，ios∷in|ios∷nocreate)；
if(InpF.fail())
{InpF.clear(0)；
return 1；
}
InpF.gettine(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
i＝0；
do
{
InpF＞＞StD[i++]；
if(InpF.eof()‖i＞17)
{StD[-i]＝-1；
break；
}
InpF＞＞StD[i++]；
}
while(1)；
InpF.close()；
return 0；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
SCR_PNT winsize；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝
int main(int argc，char *argv[])
{int FLG_F＝0，FLG_WRIGHT＝0；
FILE *datainf；
short winstep，map_stnd；
short n＝0；
SCR_PNT t_pos；
if((argc ！＝3)&&(argc ！＝4))
{
printf(″target-file proto_file_mask \n″)；
FLG_F＝0；
return(1)；
}
<dp n="d86"/>
else
if(argc＝＝4)
{FLG_F＝1；
if(！(datainf＝fopen(argv[3]，″r″)))return 0；
}
if(FLG_F)
{get_shift_f(datainf，sh)；∥ GET SCALE
get_number_3_f(datainf)；∥ GET SCALE
}
else
{get_shift(sh)；∥GET SCALE 0
get_number_3()；
}
strcpy(ARGV_1，argv[1])；
PROTOCOL_NAME＝argv[1]；
PROTOCOL_NAME+＝″.dbc″；
init_protocol(argv[1])；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝GRAPHICS START
if(GRAPHICS_START(&vc，GRAPHMODE))exit(-1)；
∥＝＝＝＝＝＝＝＝＝TARGET PICTURE name and vartexes
SCR_PNT target_pos； ∥CONSTRACTOR default 0，0
short StrDescr[17]；
_splitpath(argv[1]，drive，dir，TAG_name，ext)；
pict_target＝sign_storage_rgb(argv[1]，vc)；
if(ReadStrlnf(argv[1]，StrDescr))
{printf(″STR PROTO not exist″)；GRAPH_OUT(-1)；return-1；
}；
winsize.r＝pict_target.s_rows；
winstep＝winsize.c；
∥″PROTO_File\tFRAME_Name\tSTRING_name\tS_name\SLength\tWinLengt
h\tSPACE\n″)；
fprrintf(PROTOCOL，″％s ％8s\t％6s\t％12s\t％4d\t％4d\t％12s\n％s″，
(const char
*)PROTOCOL_START，FRAME_Name，STRING_name，SIGN_name，
pict_target.s_cols，winsize.c，SP[MAP]，
(const char*) PROTO_TAG_HEADER)；
∥＝＝＝＝＝＝＝＝＝PROTOTYPE LOOP OVER names
char proto_name[NAME_LENGTH]，buff[4]；
SCR_PNT proto_pos，z；
∥loop over masks
∥return file name without extention in″name″and TRUE 1 if file exist；
short proto_number＝0；∥# 0；
while(next_pict(proto_name，argv[2]，″.rgb″，proto_number))
{proto_number＝-1；∥next；
SCR_PNT pr_v[4]；
<dp n="d87"/>
∥PROTO INFORMATION IN PROTOCOL
pict_proto＝sign_storage_rgb(proto_name，vc)；
picture_inf_num_2(proto_name，pr_v，0，″.str″)；∥only for SIGN_name
∥″TAG_File\tFRAME_Name\tSTRING_name\tS_Name\tLegnth\n″)
fprintf(PROTOCOL，″％12s\t ％8s\t ％6s\t ％12s\t ％4d\n″，
proto_name，FRAME_Name，STRING_name，SIGN_name，pict_proto.s_cols)；
TAG_hight＝pict_proto.s_rows；
∥TARGET PRESENTATION
_clearscreen(_GCLEARSCREEN)；
proto_pos.c＝target_pos.c＝10；
proto_pos.r＝(target_pos.r＝10)+pict_target.s_rows+5；
sign_present_RGB(pict_target，target_pos)；
sign_present_RGB(pict_proto，proto_pos)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
corr_win_proto(pict_target，pict_proto，
winsize，winstep，CORR_THRESH，StrDescr)；
pict_proto.free_PCT()；
}
_displaycursor(_GCURSORON)；
_setvideomode(_DEFAULTMODE)；
pict_target_free_PCT()；
fclose(PROTOCOL)；
return(0)；
}
∥
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝
void get_shift_f(FILE *f，double *sh)∥INITIALISATION GRAPHICMODE，
GET SCALE
{int i；
for(i＝0；i＜4；i++)
{
fscanf(f，″％If ％If\n″，sh+i++，sh+i)；
}
}
∥
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝
void get_shift(double *sh)∥INITIALISATION GRAPHICMODE，GET SCALE
{int i；
cout＜＜″vertexes shift over rows(top_right，bottom_right，bottom_left，
top_left ％\n″；
for(i＝0；i＜4；i++)
cin＞＞sh[i]；
}
<dp n="d88"/>
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
int get_number_3()∥INITIALISATION GRAPHICMODE，GET SCALE
{int R；
_displaycursor(_GCURSORON)；
_setvideomode(_DEFAULTMODE)；
cout＜＜″[＜0 EXIT]，color_map(0-NTSC，1-HSI，2-NEW，3-RGB，4-
LUMIN THR 5-HSI\n″；
cout＜＜″WIN_SIZE\n″；
cin＞＞MAP＞＞winsize.c；
_displaycursor(_GCURSOROFF)；
_setvideomode(GRAPHMODE)；
make_palette()；
return R；
}
∥***************************
int get_number_3_f(FILE *f)∥INITIALISATION GRAPHICMODE，GET
SCALE
{int R；
fscanf(f，″％d ％d″，&MAP，&(winsize.c))；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int picture_inf(char *name，SCR_PNT *vertexes)
{int i；
char new_name[25]；
FILE *datfp；
strcat(strcpy(new_name，name)，″.sgn″)；
if(！(datfp＝fopen(new_name，″r″)))return 0；
fscanf(datfp，″％s\n″，new_name)；
for(i＝0；i＜4；i++)
fscanf(datfp，″％d ％d\n″，&(vertexes[i].c)，&(vertexes[i].r))；
fclose(datfp)；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int picture_inf_num_2(char *name，SCR_PNT *vertexes，short n，char
*ext＝″.sgn″)
{int i，j；
char new_name[45]；
FILE *datfp；
strcat(strcpy(new_name，name)，ext)；
if(！(datfp＝fopen(new_name，″r″)))return 0；
fscanf(datfp，″％*s ％*s ％*s ％*s ％*s\n″)；
fscanf(datfp，″％*s ％*s ％*s ％*s″，&f_name，&FILE_name，&FRAME_Name，
&STRING_name，&SIGN_name)；
for(j＝0；j＜n+1；j++)
<dp n="d89"/>
for(i＝0；i＜4；i++)
if(fscanf(datfp，″％d ％d\n″，&(vertexes[i].c)，&(vertexes[i].r))＝＝EOF)
{fclose(datfp)；return 0；}
fclose(datfp)；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
/*void write_sign_inf(char *pr，PCT pict_now)
{char fl_fp[50]，f_name[9]；
int FLG；
FILE *dathere，*database；
_splitpath(pr，drive，dir，f_name，ext)；
strcat(strcpy(fl_fp，pr)，″.sgn″)；
dathere＝fopen(fl_fp，″w″)；
FLG＝_access(″PROTODB.1″，0)；∥-1 if not exist
if(！(database＝fopen(″PROTODB.1″，″a″)))
{strcpy(fl_fp，″CAN NOT CREATE D_BASE FILE″)；
exit(-1)；}
fprintf(dathere，″WIN_name_FILE_name FRAME_Name STRING_name
SIGN_name\n″)；
fprintf(dathere，″％8s ％9s ％10s ％11s ％9s\n″，f_name，FILE_name，
FRAME_Name，STRING_name，SIGN_name)；
if(FLG)
fprintf(database，″WIN_name FILE_name FRAME_Name STRING_name
SIGN_name\n″)；
fprintf(database，″％8s ％9s ％10s ％11s ％9s\n″，f_name，FILE_name，
FRAME_Name，STRING_name，SIGN_name)；
fprintf(dathere，″％d 0\n″，pict_now.s_cols-1)；
fprintf(dathere，″％d ％d\n″，pict_now.s_cols-1，pict_now.s_rows-1)；
fprintf(dathere，″0％d\n″，pict_now.s_rows-1)；
fprintf(dathere，″0 0\n″)；
fclose(dathere)；
fclose(database)；
}*/
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int picture_inf_num(char *name，SCR_PNT *vertexes，short n)
{int i，j；
char new_name[25]；
FILE *datfp；
strcat(strcpy(new_name，name)，″.sgn″)；
if(！(datfp＝fopen(new_name，″r″)))return 0；
fscanf(datfp，″％s\n″，new_name)；
<dp n="d90"/>
for(j＝0；j＜n+1；j++)
for(i＝0；i＜4；i++)
if(fscanf(datfp，″％d ％d\n″，&(vertexes[i].c)，&(vertexes[i].r))＝＝EOF)
{fclose(datfp)；return 0；}
fclose(datfp)；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int picture_inf_num_new(char *name，SCR_PNT *vertexes，short n)
{int i，j；
char new_str[80]；
FILE *datfp；
int r，FLG＝0；
strcat(strcpy(new_str，name)，″.sgn″)；
if(！(datfp＝fopen(new_str，″r″)))rerurn 0；
r＝fscanf(datfp，″％[^\n]s″，new_str)；
r＝fscanf(datfp，″％[^\n]s″，new_str)；
if(_iscsymf((int)new_str[0]))∥FILE INFORMATION)
∥(letter or underscore)
{sscanf(new_str，″％s ％s ％s ％s″，&FILE_name，&FRAME_Name，
&STRING_name，&SIGN_name)；
r＝fscanf(datfp，″％[^\n]s″，new_str)；
}
for(j＝0；j＜n+1；j++)
for(i＝0；i＜4；i++)
{if(FLG)
if(fscanf(datfp，″％[^\n]s″，new_str)＝＝EOF)
{fclose(datfp)；return 0；}
FLG＝1；
sscanf(new_str，″％d ％d″，&(vertexes[i].c)，&(vertexes[i].r))；
}
fclose(datfp)；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d91"/>
}
∥—————————————————————
/*COLOR_VEC int_value_1(PCT w，double Thr，
COLOR_VEC(*p_funct)(COLOR_RGB p1，double
Thresh_mdl)，AVERAGE_VEC w_av)
{COLOR_VEC col，sum[9][9]，out，c1；
const COLOR_VEC z＝{0，0，0}；
short h_t，v_t，i，x，y，h，v，
half_x＝w.s_cols＞＞1，half_y＝w.s_rows＞＞1，
quot_x＝w.s_cols＞＞2，quot_y＝w.s_rows＞＞2；
long n；
for(h＝0；h＜HOR_HARM+1；h++)
for(v＝0；v＜VERT_HARM+1；v++)
sum[v][h].c[0]＝sum[v][h].c[1]＝sum[v][h].c[2]＝0.0；
n＝w.s_cols*w.s_rows；
n*＝n；
for(y＝0；y＜w.s_rows；y++)
for(v＝0；v＜VERT_HARM+1；v++)
{
v_t＝y*((v+1)＞＞1)；
v_t＝(v_t+(v & 0x0001？quot_y：0))/half_y；
v_t &＝0x0001；
for(x＝0；x＜w.s_cols；x++)
{col＝p_funct(w.get_pixel(y，x)，Thr)；
c1＝sign_for_col(v_t，col)；
for(h＝0；h＜HOR_HARM+1；h++)
{
h_t＝x*((h+1)＞＞1)；
h_t＝(h_t+(h & 0x0001 ？quot_x：0))/half_x；
h_t &＝0x0001；
c1＝sign_for_col(h_t，c1)；
for(i＝0；i＜3；i++)
sum[v][h].c[i]+＝c1.c[i]；
}
}
}
double s0，dd，max_v＝0，th；
for(dd＝i＝0；i＜3；i++)
{for(s0＝h＝0；h＜HOR_HARM+1；h++)
for(v＝0；v＜VERT_HARM+1；v++)
if(h‖v)
s0+＝sum[v][h].c[i]*sum[v][h].c[i]；
s0/＝n；
dd＝w_av.var[i]+w_av.md[i]*w_av.md[i]；
out.c[i]＝(dd？s0/dd：1)；
max_v＝(max_v＜out.c[i])？out.c[i]：max_v；
}
<dp n="d92"/>
for(i＝0；i＜3；i++)
{th＝out.c[i]/max_v；
∥ THRESHOLDING
if(th＜0.2)
out.c[i]＝0；
}
return out；
}*/
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝
COLOR_VEC(*PointColFunct())(COLOR_RGB p1，double Thresh_mdl)
{switch(MAP)
{case NTSC：return(color_space_NTSC)；
case New_plan：return(color_space_NEW)；
case HSI：return(color_space_RGB)；
case RGB：return(color_space_RGB_simple)；
case LUMIN_THR：return(color_space_LUMIN_THR)；
case IHS：return(color_space_IHS)；
}；
return NULL；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
const short CH_HIGHT_D＝100，CH_BASE_D＝470，
CH_HIGHT＝100，CH_BASE＝450，t_pos＝40；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
double scale_fact＝1；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void corr_win_proto(PCT win_source，PCT Proto，SCR_PNT win_size
，short win_step，double CORR_THRESH，short *StripEnds)
{
short i；
char mess[40]；
short F＝0；
COLOR_VEC(*p_funct)(COLOR_RGB p1，double Thresh_mdl)；
p_funct＝PointColFunct()；
PCT win(win_size.c，win_size.r)；
PCT tag(win_size.c，win_size.r)；
SCR_PNT st_t，st_win；
AVERAGE_VEC middle_win[64]，middle_tag；
const AVERAGE_VEC z＝{{0，0，0}，{0，0，0}}；
COLOR_VEC *corr_now，cr；
const COLOR_VEC z_col＝{0.0，0.0，0.0}；
int line_size＝win_source.s_cols+Proto.s_cols；
∥memory allocation
<dp n="d93"/>
if((corr_now＝(COLOR_VEC*)malloc(
sizeof(COLOR_VEC)*(size_t)line_size*3))＝＝NULL)
{printf(″WIN NOT MEMORY″)；return；}；
st_t.r＝0；
double dd；
st_win.r＝0；
short k，FLG_COL＝1；
short StripStart，StripStop；
short PartNum；
k＝PartNum＝0；
while(StripEnds[PartNum]＞＝0)
{StripStart＝StripEnds[PartNum++]；
StripStop＝StripEnds[PartNum++]；
for(st_win.c＝StripStart；
st_win.c+win_size.c＜＝StripStop；st_win.c+＝win_step，k++)
{
FLG_COL＝1；
for(i＝0；i＜line_size；corr_now[i++]＝z_col)；
win.load_template(win_source，st_win)；
middle_win[k]＝average(win，Thresh_mdl，p_funct)；
#ifdef MICI
#endif
const COLOR_VEC z_UNIT＝{1.0，1.0，1.0}；
for(st_t.c＝0；st_t.c＜＝Proto.s_cols-win_size.c；st_t.c++)
{
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
tag.load_template(Proto，st_t)；
middle_tag＝average(tag，Thresh_mdl，p_funct)；
∥DIFF ABS VALUES
#ifdef SINGL_VAL
cr＝template_conv_1(tag，win，Thresh_mdl，z_UNIT，p_funct)；
strcpy(mess，″VECTOR Approach to CORRELATION″)；
corr_now[st_t.c]＝Correlation_single_1(cr，middle_tag，middle_win[k]，z_
UNIT)；
#ifdef ABS_VALUE
strcpy(mess，″DIFF ABS VALUES/max ABS VALUES″)；
cr＝
template_abs_diff_1(tag，win，Thresh_mdl，z_UNIT，p_funct，
middle_tag，middle_win[k])；
#else
cr＝template_conv_1(tag，win，Thresh_mdl，z_UNIT，p_funct)；
strcpy(mess，″PEARSON CORR.″)；
corr_now[st_t.c]＝Correlation(cr，middle_tag，middle__win[k]，z_UNIT)；
#endif
<dp n="d94"/>
#endif
∥ONLY LUMINANCE
∥ strcat(mess，″ALL 3 COMP″)；
strcat(mess，″Only 0 COMP″)；
corr_now[st_t.c].c[1]＝corr_now[st_t.c].c[2]＝
corr_now[st_t.c].c[0]；
#ifdef MICI
draw_color_corr_1(
corr_now[st_t.c]，FLG_COL，CH_HIGHT_D，CH_BASE_D，CORR_THRESH，
st_t.c，Proto.s_cols)；
FLG_COL＝0；
#endif
}
∥＝＝＝＝＝＝FILL PROTOCOL
∥$ WILL BE USED AS SEPARATOR FOR READING
fprintf(PROTOCOL，″$\t％s\t$\t％4d\t$\n″，mess，st_win.c)；
for(i＝0：i＜Proto.s_cols；i++)∥ONLY 0 COMP
fprintf(PROTOCOL，″％6g\t″，corr_now[i].c[0])；
fprintf(PROTOCOL，″\n″)；
}
}
win.free_PCT()；
tag.free_PCT()；
free((void*)corr_now)；
return；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void draw_chart(double *dist_line，short n，double max_value，
short CH_HIGHT，
short CH_BASE，double THRESH，
short t_pos)
{short i，j；
double p，
crit＝max_value；
if(！max_value)
for(i＝0；i＜n；i++)
crit＝(dist_line[i]＞crit)？dist_line[i]：crit；
else crit＝max_value；
if(！crit)
crit＝1；
p＝CH_HIGHT*(1-THRESH/crit)；
_moveto(0，CH_BASE-CH_HIGHT)；
<dp n="d95"/>
_lineto(n，CH_BASE-CH_HIGHT)；
_moveto(0，CH_BASE-(short)p)；
_lineto(n，CH_BASE-(short)p)；
_moveto((short)0，(short)CH_BASE)；
for(i＝0；i＜_min(n，vc.numxpixels)；i++)
{j＝CH_BASE-CH_HIGHT+(short)(dist_line[i]*CH_HIGHT/crit)；
if(j＜0)
∥ getch()
；
else
if(！_lineto(i，j))
∥ getch()
；
}
if(t_pos)
_settextposition(t_pos，30)；
char buffer[30]；
sprintf(buffer，″MAX＝％f10″，crit)；
_outtext(buffer)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
void draw_int(short st，short w，COLOR_VEC intr)
{short CH_HIGHT＝100，
CH_BASE＝200；
double p；
_setcolor(color_num(240，240，240))；
_setcolor(color_num(240，0，0))；
p＝CH_BASE-CH_HIGHT*intr.c[0]；
_moveto(st，(short)p)；
_lineto(st+w，(short)p)；
_setcolor(color_num(0，240，0))；
p＝CH_BASE_CH_HIGHT *intr.c[1]；
_moveto(st，(short)p)；
_lineto(st+w，(short)p)；
_setcolor(color_num(0，0，240))；
p＝CH_BASE-CH_HIGHT *intr.c[2]；
_moveto(st，(short)p)；
_lineto(st+w，(short)p)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void draw_color_corr(COLOR_VEC corr，COLOR_RGB*corr_old，short F，
short CH_HIGHT，
short CH_BASE，double THRESH，
short pos_now)
{double p；
short j；
<dp n="d96"/>
ORIGIN＝PWB
ORIGIN_VER＝2.0
PROJ＝mtchstr
PROJFILE＝mtchstr.mak
BUILDDIR＝obj
DEBUG＝1
BRFLAGS＝/o obj\$(PROJ).bsc
BSCMAKE＝bscmake
SBRPACK＝sbrpack
NMAKEBSC1＝set
NMAKEBSC2＝nmake
BROWSE＝1
CC＝cl
CFLAGS_G＝/W2/BATCH/FR$*.sbr/Zn
CFLAGS_D＝/f/Zi/Od
CFLAGS_R＝/f-/Ot/Oi/Ol/Oe/Og/Gs
CXX＝cl
CXXFLAGS_G＝/AL/W4/G2/Gy/D_DOS/BATCH/FR$*.sbr/Zn
CXXFLAGS_D＝/f-/Od/FPi87/Zi/DMYDEBUG/DRUN/D_DEBUG
/DSINGL_VAL
CXXFLAGS_R＝/f-/Os/Ol/Og/Oe/Oi/FPi87/DMYDEBUG/DRUN
/DSINGL_VAL
MAPFILE_D＝NUL
MAPFILE_R＝obj\$(PROJ).map
LFLAGS_G＝/NOI/STACK：32000/BATCH/ONERROR；NOEXE
LFLAGS_D＝/CO/EXE/FAR/PACKC/PACKD
LFLAGS_R＝/MAP/EXE/FAR/PACKC
LINKER＝link
ILINK＝ilink
LRF＝echo＞NUL
ILFLAGS＝/a/e
LLIBS_R＝LAFXCR
LLIBS_D＝LAFXCRD
LLIBS_G＝graphics
CVFLAGS＝/25/S
RUNFLAGS＝c：\ilya\tst\t6315e c：\ilya\win4\u160_matchng.ini
FILES＝MTCHSTR.CPP..\LIB\VICALLOC.CPP..\LIB\PROJCTN7.CPP
..\LIB\L_TRN7.CPP\
..\LIB\PIC_M7.CPP..\LIB\RES_MCH7.CPP FILEMNP.CPP
MTCHTPL2.CPP\
COR_FNC2.CPP
OBJS＝obj\MTCHSTR.obj obj\VICALLOC.obj obj\PROJCTN7.obj
obj\L_TRN7.obj\
obj\PIC_M7.obj obj\RES_MCH7.obj obj\FILEMNP.obj
obj\MTCHTPL2.obj\
obj\COR_FNC2.obj
<dp n="d97"/>
SBRS＝obj\MTCHSTR.sbr obj\VICALLOC.sbr obj\PROJCTN7.sbr
obj\L_TRN7.sbr\
obj\PIC_M7.sbr obj\RES_MCH7.sbr obj\FILEMNP.sbr
obj\MTCHTPL2.sbr\
obj\COR_FNC2.sbr
all：obj\$(PROJ).exe
.SUFFIXES：
.SUFFIXES：
.SUFFIXES：.obj.sbr.cpp
obj\MTCHSTR.obj：MTCHSTR.CPP C：\C700\INCLUDE\stdlib.h
C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\graph.h C：\C700\INCLUDE\float.H
C：\C700\INCLUDE\time.h\
C：\C700\INCLUDE\ctype.h C：\C700\INCLUDE\fstream.h\
C：\C700\MFC\INCLUDE\afx.h matchng.h PIC_PRO.h MtchTpl2.h
shift.h\
filemnp.h C：\C700\INCLUDE\iostream.h
C：\C700\MFC\INCLUDE\afx.inl\
c：\ilya\lib\mylib.h C：\C700\INCLUDE\direct.h..\LIB\pic_mch7.h\
..\LIB\projctn7.h..\LIB\res_mch7.h..\LIB\lin_trn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\vmemory.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\MTCHSTR.obj MTCHSTR.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\MTCHSTR.obj MTCHSTR.CPP
＜＜
！ENDIF
obj\MTCHSTR.sbr：MTCHSTR.CPP C：\C700\INCLUDE\stdlib.h
C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\graph.h C：\C700\INCLUDE\float.H
C：\C700\INCLUDE\time.h\
C：\C700\INCLUDE\ctype.h C：\C700\INCLUDE\fstream.h\
C：\C700\MFC\INCLUDE\afx.h matchng.h PIC_PRO.h MtchTpl2.h
shift.h\
filemnp.h C：\C700\INCLUDE\iostream.h
C：\C700\MFC\INCLUDE\afx.inl\
<dp n="d98"/>
c：\ilya\lib\mylib.h C：\C700\INCLUDE\direct.h..\LIB\pic_mch7.h\
..\LIB\projctn7.h..\LIB\res_mch7.h..\LIB\lin_trn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\vmemory.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\MTCHSTR.sbr MTCHSTR.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\MTCHSTR.sbr MTCHSTR.CPP
＜＜
！ENDIF
obj\VICALLOC.obj：..\LIB\VICALLOC.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\malloc.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\VICALLOC.obj..\LIB\VICALLOC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\VICALLOC.obj..\LIB\VICALLOC.CPP
＜＜
！ENDIF
obj\VICALLOC.sbr：..\LIB\VICALLOC.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\vmemorv.h\
C：\C700\INCLUDE\malloc.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\VICALLOC.sbr..\LIB\VICALLOC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\VICALLOC.sbr..\LIB\VICALLOC.CPP
＜＜
！ENDIF
obj\PROJCTN7.obj：..\LIB\PROJCTN7.CPP C：\C700\INCLUDE\graph.h\
<dp n="d99"/>
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h
..\LIB\projctn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\PROJCTN7.obj..\LIB\PROJCTN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PROJCTN7.obj..\LIB\PROJCTN7.CPP
＜＜
！ENDIF
obj\PROJCTN7.sbr：..\LIB\PROJCTN7.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h
..\LIB\projctn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PROJCTN7.sbr..\LIB\PROJCTN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PROJCTN7.sbr..\LIB\PROJCTN7.CPP
＜＜
！ENDIF
obj\L_TRN7.obj：..\LIB\L_TRN7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\malloc.h..\LIB\vicalloc.h..\LIB\lin trn7.h\
C：\C700\INCLUDE\vmemory.h..\LIB\projctn7.h..\LIB\res_mch7.h\
..\LIB\pic_mch7.h C：\C700\INCLUDE\math.h
C：\C700\INCLUDE\graph.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\L_TRN7.obj..\LIB\L_TRN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
<dp n="d100"/>
$(CXXFLAGS_R)/Foobj\L_TRN7.obj..\LIB\L_TRN7.CPP
＜＜
！ENDIF
obj\L_TRN7.sbr：..\LIB\L_TRN7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\malloc.h..\LIB\vicalloc.h..\LIB\lin_trn7.h\
C：\C700\INCLUDE\vmemory.h..\LIB\projctn7.h..\LIB\res_mch7.h\
..\LIB\pic_mch7.h C：\C700\INCLUDE\math.h
C：\C700\INCLUDE\graph.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\L_TRN7.sbr..\LIB\L_TRN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\L_TRN7.sbr..\LIB\L_TRN7.CPP
！ENDIF
obj\PIC_M7.obj：..\LIB\PIC_M7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\graph.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\io.h C：\C700\INCLUDE\fcntl.h
C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\malloc.h..\LIB\phdr.h\
..\LIB\vicalloc.h..\LIB\pic_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\projctn7.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\PIC_M7.obj..\LIB\PIC_M7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PIC_M7.obj..\LIB\PIC_M7.CPP
＜＜
！ENDIF
obj\PIC_M7.sbr：..\LIB\PIC_M7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\graph.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\io.h C：\C700\INCLUDE\fcntl.h
C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\malloc.h..\LIB\phdr.h\
..\LIB\vicalloc.h..\LIB\pic_mch7.h C：\C700\INCLUDE\vmemory.h\
<dp n="d101"/>
..\LIB\projctn7.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PIC_M7.sbr..\LIB\PIC_M7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs.$(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PIC_M7.sbr..\LIB\PIC_M7.CPP
＜＜
！ENDIF
obj\RES_MCH7.obj：..\LIB\RES_MCH7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
C：\C700\INCLUDE\graph.h..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\RES_MCH7.obj..\LIB\RES_MCH7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\RES_MCH7.obj..\LIB\RES_MCH7.CPP
＜＜
！ENDIF
obj\RES_MCH7.sbr：..\LIB\RES_MCH7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
C：\C700\INCLUDE\graph.h..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\RES_MCH7.sbr..\LIB\RES_MCH7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\RES_MCH7.sbr..\LIB\RES_MCH7.CPP
＜＜
！ENDIF
obj\FILEMNP.obj：FILEMNP.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\string.h C：\C700\INCLUDE\io.h\
C：\C700\MFC\INCLUDE\afx.h C：\C700\INCLUDE\direct.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\time.h\
C：\C700\MFC\INCLUDE\afx.inl
！IF $(DEBUG)
<dp n="d102"/>
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\FILEMNP.obj FILEMNP.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\FILEMNP.obj FILEMNP.CPP
＜＜
！ENDIF
obj\FILEMNP.sbr：FILEMNP.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\string.h C：\C700\INCLUDE\io.h\
C：\C700\MFC\INCLUDE\afx.h C：\C700\INCLUDE\direct.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\time.h\
C：\C700\MFC\INCLUDE\afx.inl
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\FILEMNP.sbr FILEMNP.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\FILEMNP.sbr FILEMNP.CPP
＜＜
！ENDIF
obj\MTCHTPL2.obj：MTCHTPL2.CPP C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\malloc.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\string.h matchng.h MtchTpl2.h cor_fnc2.h\
c：\ilya\lib\mylib.h..\LIB\proictn7.h..\LIB\pic_mch7.h\
..\LIB\res_mch7.h PIC_PRO.h..\LIB\lin_trn7.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\direct.h C：\C700\MFC\INCLUDE\afx.h filemnp.h\
C：\C700\INCLUDE\time.h C：\C700\MFC\INCLUDE\afx.inl
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\MTCHTPL2.obj MTCHTPL2.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\MTCHTPL2.obj MTCHTPL2.CPP
＜＜
！ENDIF
<dp n="d103"/>
obj\MTCHTPL2.sbr：MTCHTPL2.CPP C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\malloc.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\string.h matchng.h MtchTpl2.h cor_fnc2.h\
c：\ilya\lib\mylib.h..\LIB\projctn.7.h..\LIB\pic_mch7.h\
..\LIB\res_mch7.h PIC_PRO.h..\LIB\lin_trn7.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\direct.h C：\C700\MFC\INCLUDE\afx.h filemnp.h\
C：\C700\INCLUDE\time.h C：\C700\MFC\INCLUDE\afx.inl
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\MTCHTPL2.sbr MTCHTPL2.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\MTCHTPL2.sbr MTCHTPL2.CPP
＜＜
！ENDIF
obj\COR_FNC2.obj：COR_FNC2.CPP C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\graph.h cor_fnc2.h\
..\LIB\pic_mch7.h..\LIB\res_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\COR_FNC2.obj COR_FNC2.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\COR_FNC2.obj COR_FNC2.CPP
＜＜
！ENDIF
obj\COR_FNC2.sbr：COR_FNC2.CPP C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\graph.h cor_fnc2.h\
..\LIB\pic_mch7.h..\LIB\res_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\COR_FNC2.sbr COR_FNC2.CPP
<dp n="d104"/>
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\COR_FNC2.sbr COR_FNC2.CPP
＜＜
！ENDIF
obj\$(PROJ).bsc：$(SBRS)
$(BSCMAKE)@＜＜
$(BRFLAGS)$(SBRS)
＜＜
obj\$(PROJ).exe：$(OBJS)
-$(NMAKEBSC1)MAKEFLAGS＝
-$(NMAKEBSC2)$(NMFLAGS)-f$(PROJFILE)obj\$(PROJ).bsc
！IF $(DEBUG)
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
$(MAPFILE_D)
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_D：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_D)；
＜＜
！ELSE
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
$(MAPFILE_R)
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_R：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_R)；
＜＜
！ENDIF
$(LINKER)@obj\$(PROJ).lrf
<dp n="d105"/>
.cpp.obj：
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Fo$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Fo$@$＜
＜＜
！ENDIF
.cpp.sbr：
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FR$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FR$@$＜
＜＜
！ENDIF
run：obj\$(PROJ).exe
obj\$(PROJ).exe$(RUNFLAGS)
debug：obj\$(PROJ).exe
CV $(CVFLAGS)obj\$(PROJ).exe$(RUNFLAGS)
<dp n="d106"/>
∥return file name without extwntion in″name″and TRUE 1 if file exist；
int next_pict(char*name，char *mask，char*ext，int num)；
∥if num＝-2 initalisation；
∥ -1 next
∥ ＞0 adding this # to mask
∥ and reinialise to this #
∥NULL if notexist file with″.ext″
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
short MaskDecoding(char *msk)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
CString MakeName(char *p)；
CString MakeName(CString N)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d107"/>
#ifndef MATCHNG
#define MATCHNG
#include″mylib.h″
#define EXTANTION″.sg2″
#define MaxProtoNum 40
#define MaxWinNum 40
#define PRESENT_HIGHT 32
#define MaxSignSize 256
∥
#define CALCULATION_HIGHT 16
#endif
<dp n="d108"/>
#ifndef TEMPLT
#define MtchTPLT
#include″projctn7.h″
#include″pic_mch7.h″
#include″res_mch7.h″
#include″pic_pro.h″
#define NTSC 0
#define HSI 1
#define New_plan 2
#define RGB 3
#define LUMIN_THR 4
#define IHS 5
class RsltNow
{public：
short voices；∥voiting numbers
double value；∥value
RsltNow∷RsltNow(){voices＝0；value＝0；}
RsltNow∷RsltNow(short d，double v){voicas＝d；value＝v；}
}；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
class RSLT
{public：
RsltNow R；
short pos；∥position in string
short ShNumb；
short ProtoNum；
short StrNum；
RSLT∷RSLT(){}；
RSLT∷RSLT(short num，short p，double v，
short shft，short pro，short st)
{R＝RsltNow∷RsltNow(num，v)；
pos＝p；
ShNumb＝shft：
ProtoNum＝pro；
StrNum＝st；
}
}；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
double CalcCorrThresh(short*Hst，short HDim，short NPntAboveThr，
int PlusThresh，double PrcntLvl＝0)；
double CorrelationEstim(double C，double MinVal，double MaxVal，
void*Addlnf＝NULL)；
void MatchForProtoStr(PCT &T，PRT &P，SCR_PNT winsize，short winstep，
double *CorrThresh，RsltNow *NowRslt，
short *StripEnds)；
#endif
<dp n="d109"/>
#ifndef PIC_PRO
#define PIC_PRO
#include ＜stdlib.h＞
#include ＜direct.h＞
#include＜afx.h＞
#include＜pic_mch7.h＞
#include″filemnp.h″
#define STR_MAX 4
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝
const SCR_PNT z-0(0，0)；
class PRT：public PCT
{public：
∥information
CString PathName；
CString FRAME_Number；
CString STRING_name；
CString SIGN_name；
short Pos； ∥Position in the string
long NumberOfChk，MaxNum；
double *Charact；
∥models
PRT∷-PRT()
{this-＞free_PCT()；
Pos＝0；
if(MaxNum)
delete Charact；
Charact＝NULL；
MaxNum＝NumberOfChk＝0；
}
∥——————————————————
PRT∷PRT()
{NumberOfChk＝MaxNum＝s_cols＝s_rows＝0；
Charact＝NULL；pict＝NULL；
}
∥———————————————————————
PRT∷PRT(short n_cols，short n_rows)
{*(PCT*)this＝PCT∷PCT(n_cols，n_rows)；
NumberOfChk＝MaxNum＝0；
Charact＝NULL；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int read_proto_SGN(char ext[]＝″.sgn″)
{
CString new_name(′′，80)；
PathName＝MakeName(PathName)；
new_name＝PathName+ext；
char now[80]；
<dp n="d110"/>
FILE*datfp；
if(！(datfp＝fopen((const char*)new_name，″r″)))return 1；
if(fscanf(datfp，″％*[^\n]s″)＝＝EOF)goto ERR；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto ERR；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto ERR；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
ERR；FRAME_Number＝now；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
ERR；STRING_name＝now；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto ERR；SIGN_name＝now；
FRAME_Number.MakeUpper()；
STRING_name.MakeUpper()；
SIGN_name.MakeUpper()；
fclose(datfp)；
return 0；
ERR：fclose(datfp)；return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int proto_storage_rgb(char*name，struct_videoconfig vc，char*ext＝″.sgn″)
{*(PCT*)this＝sign_storage_rgb(name，vc)；
if(！s_cols)return 1；
PathName＝MakeName(name)；
if(read_proto_SGN(ext))
{free_PCT()；
return 1；
}
return 0；
}
∥—————————————————————————
int read_proto_DBC(FILE *datfp)
{
char now[80]；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
ERR；PathName＝MakeName(now)；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
ERR；FRAME_Number＝now；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
ERR；STRING_name＝now；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto ERR；SIGN_name＝now；
if(fscanf(datfp，″％d″，&(this-＞s_cols))＝＝EOF)goto ERR；
FRAME_Number.MakeUpper()；
STRING_name.MakeUpper()；
SIGN_name.MakeUpper()；
return 1；
ERR：return 0；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝
int alloc_Charact_dbl(long Num)
<dp n="d111"/>
{
if(！(Charact＝new double[Num]))return 1；
MaxNum＝Num；NumberOfChk＝0；
return 0；
}
∥—————————————————————
void free_Charact()
{delete Charact；
Charact＝NULL；
}
∥—————————————————————
int read_Charact_dbl(FILE*inp，long Num)
{short i；
double d；
if(MaxNum＜(NumberOfChk+Num))return 1；
for(i＝0；i＜Num；i++)
{if(fscanf(inp，″％If″，&d)＝＝EOF)return 1；
if(fabs(d)＜1.0e-4)d＝0；
Charact[NumberOfChk]＝d；
NumiberOfChk++；
}
return 0；
}
∥—————————————————————
double CorrValue(short WNum，short Pnum)
{return(*(Charact+(long)WNum*s_cols+Pnum))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝
∥＝＝＝＝＝＝RETURN NUMBER OF STRIPS
int read_target_SGN(SCR_PNT vrt[][4]，char ext[]＝″.sgs″)
{int n＝0，j，FLG，s；
CString new_name(′′，80)；
PathName＝MakeName(PathName)；
new_name＝PathName+ext；
char now[80]；
FILE *datfp；
if(！(datfp＝fopen((const char*)new_name，″r″)))return 1；
if(fscanf(datfp，″％*[^\n]s″)＝＝EOF)goto OUT；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto OUT；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto OUT；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto
OUT；STRING_name＝now；
if(fscanf(datfp，″％s″，now)＝＝EOF)goto OUT；SIGN_name＝now；
if((s＝PathName.ReverseFind(′\\′))＜0)
s＝PathName.ReverseFind(′：′)；
FRAME_Number＝
PathName.Right(PathName.GetLength()-s)；
<dp n="d112"/>
STRING_name.MakeUpper()；
SIGN_name.MakeUpper()；
do{
for(j＝0；j＜4；j++)
if(FLG＝fscanf(datfp，″％d ％d″，&(vrt[n][j].c)，&(vrt[n][j].r)))＝＝EOF)
goto OUT；
n++；
}
while(n＜STR_MAX-1)；
OUT：fclose(datfp)；return n；
}
∥———————————————————————————————————————
}；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#define UnKnown-1
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
typedef struct
{short n；∥voiting numbers
short pos；∥position in string
double value；∥value
}RSLT_old；
∥————————————————————————
void HistCollect(short NOfWin，short St，short Fin，PRT &Db)；
RSLT_old LineEstimation(short TagSize，PRT &Db，short NOfWin，
short WSize，double Thr)；
int Linelnf(const PRT &P，PRT T，short rw，short Xpos，struct_videoconfig vc)；
double Linlnter(PRT &P，short WNum，short WSize，double Pt)；
void HistThresh(short*H，short*BotThr，short *TopThr，short num)；
#endif
<dp n="d113"/>
#include″lin_trn7.h″
double VShift[][4]＝{
{0.0，0.0，0.0，0.0}
，{-2，+2，+2，-2]
，{+2，-2，-2，+2}
∥，{0.125，0，0，0.125}
∥，{-0.125，0，0，-0.125}
∥，{0，0.125，0.125，0}
∥，{0，-0.125，-0.125，0}
∥，{0.125，0.125，0.125，0.125}
∥ ，{-0.125，-0.125，-0.125，-0.125}
∥}；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝ ，{0.1875，0，0，0.1875}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝ ，{-0.1875，0，0，-0.1875}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝ {0，0.1875，0.1875，0}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝ {0，-0.1875，-0.1875，0}
∥ ，{0.1875，0.1875，0.1875，0.1875}
∥ {-0.1875，-0.1875，-0.1875，-0.1875}
∥ ，{0.35，0.35，0.35，0.35}
}；
void VrtxCalculation(PRT &T，double sh[4]，SCR_PNT NewV[4]，
SCR_PNT OldV[4])
{short j，k，MaxV；
MaxV＝T.s_rows；
match_vertex(OldV)；
SCR_PNT v[4]；
/*＝＝＝＝＝＝＝＝＝＝＝
DIR_LINE top(OldV[3]，OldV[0])，down(OldV[1]，OldV[2])；
DIR_LINE top_new，down_new；
vert_for_map(*((PCT*)(&T))，top，down，&top_new，&down_new)；
PT st1＝down_new.Start_p()，st2＝top_new.Start_p()，
end1＝down_new.End_p()，end2＝top_new.End_p()；
PT_SCR(st2，v[3])；
PT_SCR(end2，v[0])；
PT_SCR(st1，v[1])；
PT_SCR(end1，v[2])；
match_vertex(v)；
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/
v[0]＝OldV[0]；v[1]＝OldV[1]；v[2]＝OldV[2]；v[3]＝OldV[3]；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
for(j＝0；j＜4；j++)
{
NewV[j]c＝v[j]c；
k＝((j％2)？j-1：j+1)；
if(fabs(sh[j])＜1)
{NewV[j].r＝(sh[j]？(short)((v[j]r-v[k].r)*sh[j])+
<dp n="d114"/>
v[j].r：v[j].r)；
}
else
NewV[j].r＝v[j].r+sh[j]；
NewV[j].r＝_max(0，_min(NewV[j].r，MaxV-1))；
}
while((NewV[1].r-NewV[0].r)＜8)
{NewV[1].r＝_min(NewV[1].r++，MaxV-1)；
if((NewV[1].r-NewV[0].r)＜8)
NewV[0].r＝_max(0，NewV[0].r-)；
}
while((NewV[2].r-NewV[3].r)＜8)
{NewV[2].r＝_min(NewV[2].r++，MaxV-1)；
if((NewV[2].r-NewV[3].r)＜8)
NewV[3].r＝_max(0，NewV[3].r-)；
}
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d115"/>
#include＜stdlib.h＞
#include＜string.h＞
#include＜io.h＞
#include＜afx.h＞
#include＜direct.h＞
∥return file name without extwntion in″name″and TRUE 1 if file exist；
int next_pict(char *name，char *mask，char *ext，int num)
∥if num＝-2 initalisation；
∥ -1 next
∥ ＞0 adding this # to mask
∥ and reinialise to this #
∥NULL if notexist file with″.ext″
{static int now；
char full_name[80]；
strcpy(name，mask)；
if(num＝＝-2)now＝0；
else if(num＝＝-1}
now++；
else if(num＜0)return 0；
else now＝num；
_itoa(now，name+strien(name)，10)；
strcat(strcpy(full_name，name)，ext)；
∥1 if file exist
return(！_access(full_name，0))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝
short MaskDecoding(char *msk)
{char *p，nm[40]；
strcpy(nm，msk)；
if(p＝strrchr(nm，(int)′\\′))
p+＝2；
else
if(p＝strrchr(nm，(int)′：′))
p+＝2：
else
p＝nm+1；
*(p+2)＝′\0′；
return((short)atoi(p))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
CString MakeName(CString N)
{
short k＝(N.Spanlncluding(″\t″))GetLength()；
char *p，fp[80]；
p＝((char*)(const char*)N)+k；
CString M＝p；
<dp n="d116"/>
if(M.Find(′：′)＜0)
{if(M.GetAt(0)＝＝′\\′)
{M＝′：′+M；
M＝(char)(_getdrive()-1+′A′)+M；
}
else
M＝_fullpath(fp，(const char*)M，80)；
}
M：MakeLower()；
return M；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
CString MakeName(char *p)
{CString M(p)；
return(MakeName(M))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d117"/>
#include＜vmemory.h＞
#include＜stdio.h＞
#include＜stdlib.h＞
#include＜conio.h＞
#include＜malloc.h＞
#include＜float.h＞
#include＜graph.h＞
#include＜string.h＞
#include″matchng.h″
#include″mtchtpl2.h″
#include″cor_fnc2.h″
#define MAX_LINE 1024
∥extem short NumberOfWin；
extem double GAMMA，Thresh_mdl；
extem short MAP；
extem short VOITING；
extem struct_videoconfig vc；
#define ProbValue(S，x) (2*(double)(x)/((S)-1.0)-1.0)
void draw_color_corr_1(COLOR_VEC corr，short F，double THRESH，
short pos_now)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝
double CalcCorrThresh(short *Hst，short HDim，short NPntAboveThr，
int PlusThresh，double PrcntLvl)
{double out；
short sum＝0，N＝0，ist，incr；
if(PicntLvl)
{for(ist＝0；ist＜HDim；N+＝Hst[ist++])；
NPntAboveThr＝short(N*PrcntLvl+0.5)；
}
∥————————————————————————————
if(PlusThresh)
{ist＝HDim；incr＝-1；}
else
{ist＝-1；incr＝1；}
∥POINT PARAMETER；
do{
ist+＝incr；
sum+＝*(Hst+ist)；
}
while((sum＜NPntAboveThr)&&(ist＞＝0)&&(ist＜HDim))；
out＝ProbValue(HDim，ist)；
return out；
}
<dp n="d118"/>
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝
double CorrelationEstim(double C，double MinVal，double MaxVal，
void*Addlnf)
{
if(C＜MinVal)return MinVal；
if(C＞MaxVal)return MaxVal；
return C；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝
COLOR_VEC(*PointColFunct())(COLOR_RGB p1，double Thresh_mdl)
{switch(MAP)
{case NTSC：return(color_space_NTSC)；
case New_plan：return(color_space_NEW)；
case HSI：return(color_space_RGB)；
case RGB：return(color_space_RGB_simple)；
case LUMIN_THR：return(color_space_LUMIN_THR)；
case IHS：return(color_space_IHS)；
}；
return NULL；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
const short CH_HIGHT＝80，CH_BASE＝470；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void MatchForProtoStr(PCT &T，PRT &P，SCR_PNT winsize，short winstep，
double*CorrThresh，RsltNow*NowRslt，
short*StripEnds)
{
_setcolor(color_num(0，0，0))；
_rectangle(_GFILLINTERIOR，0，CH_BASE-3*CH_HIGHT-(CH_HIGHT＞＞1)，
vc.numxpixels，CH_BASE)；
double crmdl；
short i；
char mess[40]；
short F＝1；
COLOR_VEC(*p_funct)(COLOR_RGB p1，double Thresh_mdl)；
p_funct＝PointColFunct()；
∥ PCT win(winsize.c，winsize.r)；
∥ PCT tag(winsize.c，winsize.r)；
SCR_PNT st_t，st_win；
AVERAGE_VEC middle_win，middle_tag；
const AVERAGE_VEC z＝{{0，0，0}，{0，0，0})；
COLOR_VEC cr；
<dp n="d119"/>
const COLOR_VEC z_col＝{0.0，0.0，0.0}；
st_t.r＝0；
st_win.r＝0；
short k，StripStart，StripStop；
double ValueNow[1024]；
∥double *ValueNow＝new double[P.s_cols+T.s_cols]；
short PartNum；
k＝PartNum＝0；
while(StripEnds[PartNum]＞＝0)
{StripStart＝StripEnds[PartNum++]；
StripStop＝StripEnds[PartNum++]；
for(st_win.c＝StripStart；
st_win.c+winsize.c＜＝StripStop；st_win.c+＝winstep，k++)
{
F＝1；
middle_win＝average2(P，Thresh_mdl，winsize，st_win，p_funct)；
const COLOR_VEC z_UNIT＝{1.0，1.0，1.0)；
for(i＝0；i＜P.s_cols+T.s_cols；ValueNow[i++]＝O.0)；
for(st_t.c＝0；st_t.c＜＝T.s_cols-winsize.c；st_t.c++)
{
short EndPointOfProNow＝P.s_cols+st_t.c-st_win.c；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
middle_tag＝average2(T，Thresh_mdl，winsize，st_t，p_funct)；
∥DIFF ABS VALUES
#ifdef SINGL_VAL
cr＝template_conv_2(T，P，Thresh_mdl，z_UNIT，winsize，st_t，st_win，
p_funct)；
∥ strcpy(mess，″VECTOR Approach to CORRELATION″)；
cr＝Correlation_single_1(cr，middle_tag，middle_win，z_UNIT)；
crmdl＝cr.c[0]；
#else
#ifdef ABS_VALUE
∥ strcpy(mess，″DIFF ABS VALUES/max ABS VALUES″)；
cr＝
template_abs_diff_1(tag，win，Thresh_mdl，z_UNIT，p_funct，
middle_tag，middle_win)；
#else
cr＝template_conv_1(tag，win，Thresh_mdl，z_UNIT，p_funct)；
strcpy(mess，″PEARSON CORR.″)；
cr＝Correlation(cr，middle_tag，middle_win，z_UNIT)；
crmdl＝0.333333*(cr.c[0]+cr.c[1]+cr.c[2])；
#endif
#endif
if(crmdl＞CorrThresh[k])
<dp n="d120"/>
ValueNow[EndPointOfProNow]＝crmdl；
draw_color_corr_1(cr，F，0.3，EndPointOfProNow)；
F＝0；
}
double old＝0，next，Val，now；
next＝ValueNow[0]；
for(i＝0；i＜P.s_cols+T.s_cols；i++)
{
now＝next；
next＝(i＝＝P.s_cols+T.s_cols-1)？0：ValueNow[i+1]；
Val＝_max(_max(now，next)，old)；
if(Val)
{NowRslt[i].value+＝Val；
NowRslt[i].voices++；
}
old＝now；
}
}
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝delete(ValueNow)；
return；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void draw_color_corr_1(COLOR_VEC corr，short F，
double THRESH，
short pos_now)
{
short j，k，l，i，st；
static short pos_old；
short POS；
static COLOR_RGB corr_old；
POS＝10+pos_now；
_setcolor(color_num(240，240，240))；
if(F)
{
corr_old.r＝k＝CH_BASE-2*CH_HIGHT-40；
st＝CH_HIGHT/10；
for(i＝0；i＜3；i++)
{
_moveto(10，k-CH_HIGHT)；
_lineto(10，k)；
_lineto(10+vc.numxpixels，k)；
_moveto(10，k-CH_HIGHT*THRESH)；
_lineto(10+vc.numxpixels，k-CH_HIGHT*THRESH)；
for(l＝0，j＝1；j＜11；j++)
{l+＝st；
<dp n="d121"/>
_moveto(
(j＝＝5)？5：((j＝＝10)？0：7)
，k-l)；
_lineto(10，k-l)；
}
k+＝(CH_HIGHT+20)；
}
corr_old.g＝corr_old.r+CH_HIGHT+20；
corr_old.b＝corr_old.g+CH_HIGHT+20；
pos_old＝10；
}
_setcolor(color_num(240，240，240))；
k＝CH_BASE；
_moveto(pos_old，corr_old.b)；
j＝k-(short)(corr.c[2]*CH_HIGHT)；
_lineto((short)(POS)，j)；
corr_old.b＝j；
k-＝(CH_HIGHT+20)；
_moveto(pos_old，corr_old.g)；
j＝k-(short)(corr.c[1]*CH_HIGHT)；
_lineto((short}(POS)，j)；
corr_old.g＝j；
k-＝(CH_HIGHT+20)；
_moveto(pos_old，corr_old.r)；
j＝k-(short)(corr.c[0]*CH_HIGHT)；
_lineto((short)(POS)，j)；
corr_old.r＝j；
pos_old＝POS；
}
<dp n="d122"/>
#include＜stdlib.h＞
#include＜conio.h＞
#include＜stdio.h＞
#include＜string.h＞
#include＜graph.h＞
#include＜float.H＞
#include＜time.h＞
#include＜ctype.h＞
#include＜fstream.h＞
#include＜afx.h＞
#include″matchng.h″
#include″PIC PRO.h″
#include″MtchTpl2.h″
#include″shift.h″
#include″filemnp.h″
#ifdef_DEBUG
#define new DEBUG_NEW
#endif
∥input Par
∥Files＜frame＞.RGB；＜frame＞.sgs；＜proto′s＞.RGB；＜proto′s＞.hs2
short PlusThresnPnt；∥Threshold for histogramme Number Of Points
double MinimalVal； ∥for CorrThresh
double MaximaIVal；
short HighVoiceThreshold＝6；
short median＝0；
short MAP＝1； ∥ Color Space
short WinNum；
double CorrThresh[MaxWinNum]；
int Introduction(int arg，char*a)；
short NumberOfWin，HistDim；
CString BestName[2]＝{CString∷CString(30)，CString∷CString(30)}；
#define MaxNumberOfPoints 1024
RsltNow NowRslt[MaxNumberOfPoints]；
short ReadHist(const char *PName，short ***H)；
const short NumberOfShifts＝sizeof(VShift)/(4*sizeof(double))；
void FreeHist(short NOfWin，short **H)；
void draw_DMF(RsltNow Now，short F，short CH_HIGHT，short CH_BASE，
short pos_now，double scale)；
double GAMMA＝1.0，CORR_THRESH＝0.0，Thresh_mdl＝0.0；
short VOITING＝3，TAG_hight；
<dp n="d123"/>
struct_videoconfig vc；
ofstream LineC；
const char clean[]＝″
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝
int ReadStrinf(char *name，short *StD)
{ifstream InpF；
char a[80]；
strcat(strcpy(a，name)，″.str″)；
short i；
InpF.open(a，ios∷in|ios∷nocreate)；
if(InpF.fail())
{InpF.clear(0)；
return 1；
}
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
i＝0；
do
{
InpF＞＞StD[i++]；
if(InpF.eof()‖i＞17)
{StD[-i]＝-1；
break；
}
InpF＞＞StD[i++]；
}
while(1)；
InpF.close()；
return 0；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void PUT_NO_MATCH(void)
{ _settextposition(vc.numtextrows-2，0)；
_outtext(clean)；
_settextposition(vc.numtextrows-2，0)；
_outtext(″NO MATCH″)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void FillProtocol(char *m，short StrN，const char *name，RSLT now，int
AskMess)
{char mess[40]，*p；
LineC＜＜StrN＜＜″\t″＜＜name＜＜″\t″＜＜now.ShNumb＜＜″\t″＜＜now.pos＜＜″\t″＜＜
now.R.voices＜＜″\t″＜＜now.R.value＜＜″\t″；
<dp n="d124"/>
if(AskMess)
{if(now.R.value)
{
_settextposition(vc.numtextrows-2，0)；
_outtext(clean)；
_settextposition(vc.numtextrows-2，0)；
sprintf(mess，″％s V＝％6g N＝％2d″，m，now.R.value，now.R.voices)；
_outtext(mess)；
p＝mess；
-while(！isspace((int)(*p++＝(char)getche())))；
*(-p)＝′\0′；
LineC＜＜″\t″＜＜mess；
}
else
LineC＜＜″\t NO MATCH″；
}
LineC＜＜″\n″；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void PresentRslt(char *m，PRT &T，RSLT &R，SCR_PNT *V，short hight，short
row_n，
char*p_msk，short CL)
{
SCR_PNT p_p(10，row_n)；
if(R.R.value)
{
if(CL)
{
_setcolor(color_num(0，0，0))；
_rectangle(_GFILLINTERIOR，0，p_p.r，
680，p_p.r+36)；
}
_setcolor(color_num(240，240，240))；
PCT t_map＝linear_transform(T，V，hight)；
∥PCT t_map＝linear_transform_cont(T，V，hight)；
sign_Present_RGB(t_map，p_p)；
t_map.free_PCT；
p_p.r+＝20；
char p_name[40]；
PRT P；
next_pict(p_name，p_msk，″.rgb″，R.ProtoNum)；
if(P.proto_storage_rgb(p_name，vc，″.str″))
{printf(″RGB PROTO not exist″)；GRAPH_OUT(-1)；
}；
p_p.c＝10+R.pos-P.s_cols；
sign_present_RGB(P，p_p)；
FillProtocol(m，R.StrNum，(const char*)P.SIGN_name，
R，TRUE)；
<dp n="d125"/>
P.free_PCT；
}
else
{
PUT_NO_MATCH()；
}
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
CString PROTOCOL_NAME；
∥＝＝＝＝＝＝＝＝＝＝＝＝ OpenLineCollection
void OpenLineCol(const char*name)
{LineC.open(name，ios∷out|ios∷app|ios∷nocreate)；
if(LineC.fail())
{LineC.clear(0)；
LineC.open(name，ios∷out|ios∷app|ios∷noreplace)；
if(LineC.fail()}
{LineC.clear(0)；
cout＜＜″CAN NOT OPEN FILE″＜＜name；
GRAPH_OUT(-1)；
}
}
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝
int main(int argc，char* argv[])
{
short **Hist；
const int PlusDir＝TRUE；
short StrDescr[17]；∥ONLY 6 partition for string
if(Introduction(argc.argv[argc-1]))return-1；
short CalcHight＝MaskDecoding(argv[2])； ∥PROTOTYPE HIGHT
∥＝＝＝＝＝＝＝ GRAPHICS START
if(GRAPHICS_START(&vc，GRAPHMODE))GRAPH_OUT(-1)；
PROTOCOL_NAME＝argv[1]；
PROTOCOL_NAME+＝″.mch″；
OpanLineCol((const char*)PROTOCOL_NAME)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝TARGET LOADING & MEMORY PARAMETERS
DEFINITION
PRT TARGET；
PRT PROTO；
PCT target_map；
const SCR_PNT proto_pos(10，30)，target_pos(10，10)；
<dp n="d126"/>
SCR_PNT
TARGET_vrt[STR_MAX][4]，NewVrt[STR_MAX][NumberOfShifts][4]；
if(TARGET.proto_storage_rgb(argv[1]，vc))
{printf(″RGB TARGET not exist″)； GRAPH_OUT(-1)；
return-1；
}
int NumberOfStrips＝TARGET.read_target_SGN(TARGET_vrt，EXTANTION)；
LineC＜＜″MAP \tPlusThresnPnt \tMinimalVal \tMaximalVal \n″；
LineC＜＜MAP＜＜″\t″＜＜PlusThresnPnt＜＜″\t″＜＜MinimalVal
＜＜″\t″＜＜MaximalVal＜＜″\t″＜＜median＜＜′\n′；
LineC＜＜″File\t″＜＜argv[1]＜＜″\t″＜＜TARGET.SIGN_name＜＜″\n″；
LineC＜＜″S#\t PROTO\t Sh\t Pos\t V\t Value\t Res\n″；
if(！NumberOfStrips)
{LineC＜＜″Did NOT find strips\n″；
LineC.close()；
printf(″Did not find lines″)；GRAPH_OUT(-1)；
return-1；
}
char proto_name[40]；
short ProtoNumber＝0；
RSLT BestRslts[2]；
BestRslts[0]＝RSLT∷RSLT(0，0，0，-1，0，0)；
BestRslts[1]＝RSLT∷RSLT(0，0，0，-1，0，0)；
RSLT BestNowRslts[2]；
∥ New Vertexes Calculation
short StripNumber；
short ShiftNumber；
for(StripNumber＝0；StripNumber＜NumberOfStrips；StripNumber++)
for(ShiftNumber＝0；ShiftNumber＜NumberOfShifts；ShiftNumber++) ∥
return NewVrt after reordering
VrtxCalculation(TARGET，VShift[ShiftNumber]，
NewVrt[StripNumber][ShiftNumber]，
TARGET_vrt[StripNumber])；
∥ LOOP OVER STRIPS
for(StripNumber＝0；StripNumber＜NumberOfStrips；StripNumber++)
{
∥ LOOP OVER PROTOTYPE
short ProtoNumber＝0；
while(next_pict(proto_name，argv[2]，″.rgb″，ProtoNumber)) ∥RGB
proto EXIST
{
∥ LOCAL QUALITY
BestNowRslts[0]＝RSLT∷RSLT(0，0，0，-1，0，0)；
BestNowRslts[1]＝RSLT∷RSLT(0，0，0，-1，0，0)；
<dp n="d127"/>
∥＝＝＝＝＝＝＝＝Proto Loading
if(PROTO.proto_storage_rgb(proto_name，vc，″.str″))
{printf(″RGB PROTO not exist″)；GRAPH_OUT(-1)；return-1；
}；
_clearscreen(_GCLEARSCREEN)；
sign_present_RGB(PROTO，proto_pos)；
if(ReadStrlnf(proto_name，StrDescr))
{printf(″SGN PROTO not exist″)；GRAPH_OUT(-1)；return-1；
}；
∥＝＝＝＝＝＝＝＝＝＝ HIST reading
CString HName(′-′，60)；
HName＝proto_name；
HName+＝″.hs2″：
∥here read size of windows from Hist and so on
SCR_PNT WinSize；
short winstep，NoHist；
WinSize.r＝CalcHight；
NoHist＝0；
if(！(WinSize.c＝ReadHist((const char*)HName，&Hist)))
{printf(″Did not find Hist ％s″，proto_name)；
NoHist＝1；
WinSize.c＝8；
NumberOfWin＝MaxWinNum；}
winstep＝WinSize.c；
∥————MEMORY ALLOCATION & inicialisation FOR Decision Making
short i；
for(i＝0；i＜MaxWinNum；CorrThresh[i++]＝-1.0)；
for(i＝0；i＜NumberOfWin；i++)
{if(NoHist)
CorrThresh[i]＝0.3；
else
{
CorrThresh[i]＝CalcCorrThresh(*(Hist+i)，HistDim，
PlusThresnPnt，PlusDir，0)；
CorrThresh[i]＝CorrelationEstim(CorrThresh[i]，
MinimalVal，
MaximalVal，NULL)；
}
}
if(！NoHist)
FreeHist(NumberOfWin，Hist)；
∥！！！！！！！Correlation Threshold for all windows
short NumberOfPoints：
∥＝＝＝＝＝＝＝＝＝＝＝＝＝LOOP OVER SHIFTS
for(ShiftNumcer＝0；ShiftNumber＜NumberOfShifts；
ShiftNumber++)
{if(NewVrt[StripNumber][ShiftNumber][0].r＜0)continue；
<dp n="d128"/>
target_map＝linear_transform(TARGET，
∥ target_map＝linear_transform_cont(TARGET，
NewVrt[StripNumber][ShiftNumber]，CalcHight)；
NumberOfPoints＝PROTO.s_cols+target_map.s_cols；
_setcolor(color_num(0，0，0))；
_rectangle(_GFILLINTERIOR，0，0，
vc.numxpixels，proto_pos.r-1)；
sign_present_RGB(target_map，target_pos)；
∥—.Result Initialisation For Every SHIFT
for(i＝0；i＜MaxNumberOfPoints；i++)
NowRslt[i]＝RsltNow∷RsltNow()；
∥＝＝＝＝＝＝＝＝＝＝ Proto Calculation
MatchForProtoStr(target_map，PROTO，WinSize，winstep，
CorrThresh，NowRslt，StrDescr)；
target_map.free_PCT()；
∥correct filling The BEST For Shift，Proto，Strip
#ifdef MYDEBUG
double scale＝-1；
for(i＝0；i＜NumberOfPoints；i++)
scale＝_max(scale，NowRslt[i].value)；
#endif
for(i＝0；i＜NumberOfPoints；i++)
{
if(NowRslt[i].value＞BestNowRslts[0].R.value)
{
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Not repeat small shifts
if(abs(i-BestNowRslts[0].pos)＞＝4)
BestNowRslts[1]＝BestNowRslts[0]；
BestNowRslts[0].pos＝i；
BestNowRslts[0].R＝NowRslt[i]；
BestNowRslts[0].ShNumb＝ShiftNumber；
BestNowRslts[0].ProtoNum＝ProtoNumber；
BestNowRslts[0].StrNum＝StripNumber；
if(BestNowRslts[0].R.voices＞＝HighVoiceThreshold)
{BestRslts[0]＝BestNowRslts[0]；
BestRslts[1]＝RSLT∷RSLT(0，0，0，-1，0，0)；
PROTO.free_PCT()；
BestName[0]＝PROTO.SIGN_name；
gcto DIRECT_DECISION；
}
}
else
if((Nc：vRslt[i].value＞BestNowRslts[1].R.value)&&
(aos(i-BestNowRslts[0].pos)＞＝4))
{
BestNowRslts[1].pos＝i；
<dp n="d129"/>
BestNowRslts[1].R＝NowRslt[i]；
BestNowRslts[1].ShNumb＝ShiftNumber；
BestNowRslts[1].ProtoNum＝ProtoNumber；
BestNowRslts[1].StrNum＝StripNumber；
}
}
∥—— May be presentation for analyses
#ifdef MYDEBUG
short F＝1；
short CH_HIGHT＝100，CH_BASE＝190；
_setcolor(color_num(0，0，0))；
_rectangle(_GFILLINTERIOR，0，CH_BASE-CH_HIGHT，
vc.numxpixels，CH_BASE)；
if(scale)
{
for(i＝0；i＜NumberOfPoints；i++)
{draw_DMF(NowRslt[i]，F，CH_HIGHT，CH_BASE，
i-PROTO.s_cols，scale)；
F＝0；
}
#ifndef RUN
getch()；
#endif
}
else
PUT_NO_MATCH()；
#endif
}∥Shift closed
PROTO.free_PCT()；
ProtoNumber++；
∥＝＝＝＝＝＝＝＝＝＝PROTOCOL PROTO
OUTPUT＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#ifdef MYDEBUG
short pp2＝10，CL2＝TRUE；
for(i＝0；i＜2；i++)
{
PresentRslt(″PROTO SHIFT RSLT？″，TARGET，BestNowRslts[i]，
NewVrt[BestNowRslts[i].StrNum][BestNowRslts[i].ShNumb]，
CalcHight，pp2，argv[2]，CL2)；
CL2＝FALSE；
pp2＝50；
}
#else
FillProtocol(″PROTO SHIFT RSLT？″，StripNumber，(const char*)
PROTO.SIGN_name，
BestNowRslts[0]，FALSE)；
#endif
<dp n="d130"/>
∥ GLOBAL MAX
for(i＝0；i＜2；i++)
if(BestNowRslts[i].R.value＞BestRslts[0].R.value)
{BestRslts[1]＝BestRslts[0]；
BestRslts[0]＝BestNowRslts[i]；
BestName[1]＝BestName[0]；
BestName[0]＝PROTO.SIGN_name；
}
else
if(BestNowRslts[i].R.value＞BestRslts[1].R.value)
{BestRslts[1]＝BestNowRslts[i]；
BestName[1]＝PROTO.SIGN_name；
}
∥——
} ∥Proto closed
} ∥Strips Closed
∥ GLOBAL PROTOCOL OUTPUT
DIRECT_DECISION：
#ifdef MYDEBUG
short i；
short Rows n＝10，Blanc＝TRUE；
LineC＜＜″Result.....................\n″；
_clearscreen(_GCLEARSCREEN)；
for(i＝0；i＜2；i++)
{
PresentRslt(″GLOBAL RSLT
？″，TARGET，BestRslts[i]，NewVrt[BestRslts[i].StrNum][BestRslts[i].ShNumb]，
CalcHight，Rows_n，argv[2]，Blanc)；
Blanc＝FALSE；
Rows_n+＝50；
}
#else
FillProtocol(″GLOBAL RSLT？″，，(const char*)BestRslts[0].StrNum，
(const char*)BestName[0]；
BestRslts[0]，FALSE)；
#endif
∥
LineC.close()；
TARGET.free_PCT()；
GRAPH_OUT(0)；
return 0；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
short RaadHist(const cnar*PName，short***H)
{char p[80]；
ifstream HFile；
HFile.open(PName.ios∷in|ios∷nocreate)；
<dp n="d131"/>
if(HFile.fail())
{HFile.clear(0)；
cout＜＜″CAN NOT OPEN FILE″＜＜PName＜＜″\n″；
return 0；
}
HFile.getline(p，80)；∥LineC＜＜″Histogrammes\n″；
HFile.getline(p，80)；∥＜＜argv[1]＜＜″\t″＜＜prototype.SIGN name＜＜′\n′；
HFile＞＞p＞＞NumberOfWin；∥＜＜NumberOfWin＜＜′\n′；
HFile＞＞p＞＞HistDim；∥″NumberOfBins-1\t″＜＜HistDim＜＜′\n′；
HFile.getline(p，80)；∥″Win_pos\n″；
HFile.getline(p，80)；∥″Win_pos\n″；
(*H)＝new(short(*[NumberOfWin]))；
short n，j，i，WindowSize；
for(i＝0；i＜NumberOfWin；i++)
(*H)[i]＝new short[HistDim]；
for(j＝0；j＜NumberOfWin；j++)
{if(j＝＝1)
HFile＞＞WindowSize；
else
HFile＞＞n；
for(i＝0；i＜HistDim；i++)
HFile＞＞(*H)[j][i]；
}
HFile.close()；
return(WindowSize)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝
void FreeHist(short NOfWin，short **H)
{short i；
for(i＝0；i＜NOfWin；i++)
delete H[i]；
delete H；
}
∥
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝
int get_number_match()∥INITIALISATION GRAPHICMODE，GET SCALE
{
GRAPH_OUT()；
cout＜＜″MAP PlusThresnPnt MinimalVal MaximalVal
HighVoiceThreshold median\n″；
<dp n="d132"/>
cin
＞＞MAP＞＞PlusThresnPnt＞＞MinimalVal＞＞MaximalVal＞＞HighVoiceThreshold
＞＞median；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ GRAPHICS START
if(GRAPHICS_START(&vc，GRAPHMODE))GRAPH_OUT(-1)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
return 1；
}
∥**********************************
int get_number_match_f(FILE*f)∥INITIALISATION GRAPHICMODE，GET
SCALE
{
fscanf(f，″％*[^\n]s″)；
fscanf(f，″％d ％d ％lf ％lf ％d
％d″，&MAP，&PlusThresnPnt，&MinimalVal，&MaximalVal，
&HighVoiceThreshold，&median)；
∥Threshold for histogramme Number Of Points
∥for CorrThresh
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝INTRODUCTION
int Introduction(int arg，char *a)
{
int FLG_F＝0；
FILE *datainf；
short n＝0；
if((arg！＝3)&&(arg！＝4))
{
printf(″target-file proto_file_mask\n″)；
FLG_F＝0；
return(1)；
}
else
if(arg＝＝4)
{FLG_F＝1；
if(！(datainf＝fopen(a，″r″)))return 0；
}
if(FLG_F)
{get_number_match_f(datainf)；∥ GET SCALE AND PARAMETERS
fclose(datainf)；
}
else
get_number_maton()；
return 0；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥——Graphic Output
<dp n="d133"/>
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝
void draw_DMF(RsltNow Now，short F，short CH_HIGHT，
short CH_BASE，
short pos_now，double scale)
{
short j，k，l，st；
static short real_size，pos_old；
short POS；
static double old_Y；
POS＝10+pos_now；
_setcolor(color_num(240，240，240))；
if(F)
{
old_Y＝k＝CH_BASE；
st＝CH_HIGHT/10；
_moveto(10，k-CH_HIGHT)；
_lineto(10，k)；
_lineto(680，k)；
_moveto(10，k-CH_HIGHT)；
_lineto(680，k-CH_HIGHT)；
for(l＝0，j＝1；j＜11；j++)
{l+＝st；
_moveto(
(j＝＝5)？5：((j＝＝10)？0：7)
，k-l)；
_lineto(10，k-l)；
}
pos_old＝10；
}
_moveto(Pos_old，old_Y)；
j＝CH_BASE-(short)(Now.value*CH_HIGHT/scale)；
_lineto((short)(POS)，j)；
old_Y＝j；
pos_old＝POS；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d134"/>
ORIGIN＝PWB
ORIGIN_VER＝2.0
PROJ＝STRNEW
PROJFILE＝STRNEW.MAK
BUILDDIR＝obj
DEBUG＝1
BRFLAGS＝/o obj\$(PROJ).bsc
BSCMAKE＝bscmake
SBRPACK＝sbrpack
NMAKEBSC1＝set
NMAKEBSC2＝nmake
BROWSE＝1
CC＝cl
CFLAGS_G＝/W2/BATCH/FR$*.sbr/Zn
CFLAGS_D＝/f/Zi/Od
CFLAGS_R＝/f-/Ot/Oi/Ol/Oe/Og/Gs
CXX＝cl
CXXFLAGS_G＝/AL/W4/G2/D_DOS/BATCH/FR$*.sbr/Zn
CXXFLAGS_D＝/f-/Ob1/Od/FPi87/Zi/DMYDEBUG/DRUN/D_DEBUG
CXXFLAGS_R＝/f-/Os/Ol/Og/Oe/Oi/FPi87/Gs/DMYDEBUG/DRUN
MAPFILE_D＝NUL
MAPFILE_R＝NUL
LFLAGS_G＝/NOI/STACK：32000/BATCH/ONERROR：NOEXE
LFLAGS_D＝/CO/FAR/PACKC
LFLAGS_R＝/EXE/FAR/PACKC
LINKER＝link
ILINK＝ilink
LRF＝echo＞NUL
ILFLAGS＝/a/e
LLIBS_R＝LAFXCR
LLIBS_D＝LAFXCRD
LLIBS_G＝graphics
CVFLAGS＝/25/S
RUNFLAGS＝TST\t10284o plnew.ini
FILES＝COR_FNC8.CPP PIC_M8.CPP VICAL8.CPP RES_MCH8.CPP
PROJCTN8.CPP\
COMP_FNC.CPP STRNEW.CPP
OBJS＝obj\COR_FNC8.obj obj\PIC_M8.obj obj\VICAL8.obj
obj\RES_MCH8.obj\
obj\PROJCTN8.obj obj\COMP_FNC.obj obj\STRNEW.obj
SBRS＝obj\COR_FNC8.sbr obj\PIC_M8.sbr obj\VICAL8.sbr
obj\RES_MCH8.sbr\
obj\PROJCTN8.sbr obj\COMP_FNC.sbr obj\STRNEW.sbr
all：obj\$(PROJ).exe
.SUFFIXES：
<dp n="d135"/>
.SUFFIXES：
.SUFFIXES：.obj.sbr.cpp
obj\COR_FNC8.obj：COR_FNC8.CPP C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\float.h C：\C700\INCLUDE\graph.h cor_fnc8.h
projctn8.h\
pic_mch8.h res_mch8.h C：\C700\INCLUDE\math.h
C：\C700\INCLUDE\vmemory.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\COR_FNC8.obj COR_FNC8.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\COR_FNC8.obj COR_FNC8.CPP
＜＜
！ENDIF
obj\COR_FNC8.sbr：COR_FNC8.CPP C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\float.h C：\C700\INCLUDE\graph.h cor_fnc8.hprojctn8.h\
pic_mch8.h res_mch8.h C：\C700\INCLUDE\math.h
C：\C700\INCLUDE\vmemory.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\COR_FNC8.sbr COR_FNC8.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\COR_FNC8.sbr COR_FNC8.CPP
＜＜
！ENDIF
obj\PIC_M8.obj：PIC_M8.CPP C：\C700\INCLUDE\stdlib.h
C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\graph.h C：\C700\INCLUDE\math.h
C：\C700\INCLUDE\io.h\
C：\C700\INCLUDE\fcntl.h C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.h C：\C700\INCLUDE\malloc.h phdr.h vical8.h\
pic_mch8.h C：\C700\INCLUDE\vmemory.h projctn8.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
<dp n="d136"/>
$(CXXFLAGS_D)/Foobj\PIC_M8.obj PIC_M8.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PIC_M8.obj PIC_M8.CPP
＜＜
！ENDIF
obj\PIC M8.sbr：PIC M8.CPP C：\C700\INCLUDE\stdlib.h
C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\graph.h C：\C700\INCLUDE\math.h
C：\C700\INCLUDE\io.h\
C：\C700\INCLUDE\fcntl.h C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.h C：\C700\INCLUDE\malloc.h phdr.h vical8.h\
pic_mch8.h C：\C700\INCLUDE\vmemory.h projctn8.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PIC_M8.sbr PIC_M8.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PIC_M8.sbr PIC_M8.CPP
＜＜
！ENDIF
obj\VICAL8.obj：VICAL8.CPP C：\C700\INCLUDE\stdlib.h
C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\vmemory.h C：\C700\INCLUDE\malloc.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\VICAL8.obj VICAL8.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\VICAL8.obj VICAL8.CPP
＜＜
！ENDIF
obj\VICAL8.sbr：VICAL8.CPP C：\C700\INCLUDE\stdlib.h
C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\vmemory.h C：\C700\INCLUDE\malloc.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
<dp n="d137"/>
$(CXXFLAGS_D)/FRcbj\VICAL8.sbr VICAL8.CPP
＜＜
！ELSE
@$(CXX)@＜＜coj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRcoj\VICAL8.sbr VICAL8.CPP
＜＜
！ENDIF
obj\RES_MCH8.obj：RES_MCH8.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h res_mch8.h
C：\C700\INCLUDE\graph.h\
projctn8.h pic_mch8.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\RES_MCH8.obj RES_MCH8.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\RES_MCH8.obj RES_MCH8.CPP
＜＜
！ENDIF
obj\RES_MCH8.sbr：RES_MCH8.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h res_mch8.h
C：\C700\INCLUDE\graph.h\
projctn8.h pic_mch8.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRcbj\RES_MCH8.sbr RES_MCH8.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\RES_MCH8.sbr RES_MCH8.CPP
＜＜
！ENDIF
obj\PROJCTN8.obj：PROJCTN8.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h projctn8.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
<dp n="d138"/>
$(CXXFLAGS_D)/Foobj\PROJCTN8.obj PROJCTN8.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PROJCTN8.obj PROJCTN8.CPP
＜＜
！ENDIF
obj\PROJCTN8.sbr：PROJCTN8.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h projctn8.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PROJCTN8.sbr PROJCTN8.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PROJCTN8.sbr PROJCTN8.CPP
＜＜
！ENDIF
obj\COMP_FNC.obj：COMP_FNC.CPP comp_fnc.h projctn8.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\graph.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\COMP_FNC.obj COMP_FNC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\COMP_FNC.obj COMP_FNC.CPP
＜＜
！ENDIF
obj\COMP_FNC.sbr：COMP_FNC.CPP comp_fnc.h projctn8.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\graph.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\COMP_FNC.sbr COMP_FNC.CPP
＜＜
<dp n="d139"/>
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\COMP_FNC.sbr COMP_FNC.CPP
＜＜
！ENDIF
obj\STRNEW.obj：STRNEW.CPP C：\C700\INCLUDE\stdlib.h
C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\graph.h C：\C700\INCLUDE\float.h\
C：\C700\MFC\INCLUDE\afx.h C：\C700\INCLUDE\fstream.h\
C：\C700\INCLUDE\time.h mylibmd.h comp_fnc.h cor_fnc8.h\
C：\C700\INCLUDE\ctype.h C：\C700\MFC\INCLUDE\afx.inl\
C：\C700\INCLUDE\iostream.h projctn8.h pic_mch8.h res_mch8.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h C：\C700\INCLUDE\vmemory.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\STRNEW.obj STRNEW.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\STRNEW.obj STRNEW.CPP
＜＜
！ENDIF
obj\STRNEW.sbr：STRNEW.CPP C：\C700\INCLUDE\stdlib.h
C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\graph.h C：\C700\INCLUDE\float.h\
C：\C700\MFC\INCLUDE\afx.h C：\C700\INCLUDE\fstream.h\
C：\C700\INCLUDE\time.h mylibmd.h comp_fnc.h cor_fnc8.h\
C：\C700\INCLUDE\ctype.h C：\C700\MFC\INCLUDE\\afx.inl\
C：\C700\INCLUDE\iostream.h projctn8.h pic_mch8.h res_mch8.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h C：\C700\INCLUDE\vmemory.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\STRNEW.sbr STRNEW.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
<dp n="d140"/>
$(CXXFLAGS_R)/FRobj\STRNEW.sbr STRNEW：CPP
＜＜
！ENDIF
obj\&(PROJ).bsc：$(SBRS)
$(BSCMAKE)@＜＜
$(BRFLAGS)$(SBRS)
＜＜
obj\$(PROJ).exe：$(OBJS)
-$(NMAKEBSC1)MAKEFLAGS＝
-$(NMAKEBSC2)$(NMFLAGS)-f$(PROJFILE)obj\$(PROJ).bsc
！IF $(DEBUG)
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
$(MAPFILE_D)
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_D：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_D)；
＜＜
！ELSE
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
$(MAPFILE_R)
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_R：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_R)；
＜＜
！ENDIF
$(LINKER)@obj\$(PROJ).lrf
.cpp.obj：
！IF $(DEBUG)
<dp n="d141"/>
@$(CXX)@＜＜obj\$(PROJ).rsp
/c$(CXXFLAGS_G)
$(CXXFLAGS_D)/Fo$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Fo$@$＜
＜＜
！ENDIF
.cpp.sbr：
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FR$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FR$@$＜
＜＜
！ENDIF
run：obj\$(PROJ).exe
obj\$(PROJ).exe$(RUNFLAGS)
debug：obj\$(PROJ).exe
CV$(CVFLAGS)obj\$(PROJ).exe$(RUNFLAGS)
<dp n="d142"/>
∥ LINE SELECTION
∥COMMAND STRING
∥
∥Ins_corr＜TARGET_name＞[CommandFile]
∥
∥ ＜TARGET_name＞ File name of FRAME without extention
∥ [CommandFile] Optional ASCI file with a run time parameters.
∥
∥INPUT
∥ RGB files of frame(field)and corresponding.SGN files created by
∥module PLINE.
∥RUN TIME parameters：
∥
∥fscanf(f，″％d％d％d″，&MinSlope，&MaxSlope，&SlopeStep，)；
∥SEE ALSO FILE″PLiNes.lni″
∥OUTPUT
∥ TARGET_name.stp -all local max lines；
∥ TARGET_name.pn2 -lines after cleaning selected；
∥ TARGET_name.pln -Strips selected；
∥ LINEDET.002 -result collection for analises.
∥ includes keyboard information for analyse.
#include＜stdlib.h＞
#include＜conio.h＞
#include＜stdio.h＞
#include＜string.h＞
#include＜graph.h＞
#include＜float.H＞
#include＜afx.h＞
#include＜fstream.h＞
#include＜time.h＞
#include″mylibmd.h″
#include″COMP_FNC.h″
#include″COr_FNC8.h″
#include＜ctype.h＞
short MaxStripNumber＝16；
short DistanceThresh＝10；
short DetectorWidthPlus＝4；
short MinSlope＝-20，MaxSlope＝20，SlopeStep＝2；
GOOD_DIR_LINE_huge Lines[300]；
AVERAGE_VEC_huge AverageForLines[300]；
struct_videoconfig vc；
double GAMMA＝1.0，CORR_THRESH＝0，Thresh_mdl＝0；
short VOITING＝0，MAP＝0；
char f_name[40]＝″_″，FILE_name[40]＝″_″，FRAME_Name[40]＝″_″；
<dp n="d143"/>
PCT pict_target，target_map；
void WriteLines(GOOD_DIR_LINE *L，short MaxN，const char *name)；
void WritePears(GOOD_DIR_LINE *L，short MaxN，const char *name，short
PMax)；
int_cdecl compare_array_elem(const void *elem1，const vcid *elem2)；
int Introduction(int arg，char *a)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝
ofstream LineC；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int main(int argc，char* argv[])
{short i，j；
char *p，mess[128]，clean[]＝″ ″；
if(Introduction(argc，argv[argc-1]))return-1；
∥PROTOCOL OUTPUT
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ GRAPHICS START
if(GRAPHICS_START(&vc，GRAPHMODE))GRAPH_OUT(-1)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝TARGET PICTURE name and vertexes
SCR_PNT target_pos(0，0)； ∥CONSTRACTOR default 0，0
pict_target＝sign_storage_rgb(argv[1]，vc)；
sign_present_RGB(pict_target，target_pos)；
∥＝＝＝＝＝＝＝＝＝
SCR_PNT StartPnt(0，0)，EndPnt(pict_target.s_cols-1，0)；
short Slope.Start，Stop；
GOOD_DIR_LINE LocalMax[51]；
∥DEBUG
∥GRAPH_OUT(0)；
∥ LOOP over SLOPE
for(Slope＝MinSlope；Slope＜＝MaxSlope；Slope+＝SlopeStep)
{
_settextposition(vc.numtextrows-3，0)；
printf(″Slope ％d″，Slope)；
Start＝_max(0，-Slope)；
Stop＝_min(pict_target.s_rows，pict_target.s_rows-Slope)；
∥ LINE Calculation
for(EndPnt.r＝(StartPnt.r＝Start)+Slope；
StartPnt.r＜Stop；StartPnt.r++，EndPnt.r++)
{
Lines[StartPnt.r]＝
GOOD_DIR_LINE∷GOOD_DIR_LINE(StartPnt，EndPnt)；
<dp n="d144"/>
AverageForLines[StartPnt.r]＝LineMoments(pict_target，Lines[StartPnt.r]，MAP)
；
}
∥ Line Estimation
short StartRow，Q0，QUp，QDown；
for(StartRow＝Start；StartRow＜Stop-
DetectorWidthPlus；StartRow++)
Lines[StartRow].Qual＝Quality(AverageForLines+StartRow)；
∥DEBUG
#ifdef DBG0
_clearscreen(_GCLEARSCREEN)；
sign_present_RGB(pict_target，target_pos)；
for(StartRow＝Start；StartRow＜Stop-DetectorWidthPlus；StartRow++)
{_moveto(0，StartRow)；
_lineto(10，StartRow+Slope+1)；
_moveto(255，StartRow+Slope+1)；
_lineto(255+(short)(Lines[StartRow].Qual*0.5)，StartRow+Slope+1)；
_settextposition(vc.numtextrows-2，0)；
_outtext(clean)；
_settextposition(vc.numtextrows-2，0)；
sprintf(mess，″Quality＝％6g″，Lines[StartRow].Qual)；
_outtext(mess)；*/
}
getch()；
#endif
Line Selection
for(QUp＝0，StartRow＝_max(0，-Slope)；
StartRow＜Stop；StartRow++)
{
Q0＝Lines[StartRow].Qual；
QDown＝(StartRow！＝Stop-1)？Lines[StartRow].Qual：0；
if((Q0＞＝QDown)&&(Q0＞＝QUp))
{LocalMax[50]＝Lines[StartRow]；
∥including in consideration
qsort((void*)LocalMax，51，sizeof(GOOD_DIR_LINE
)，
compare_GOOD_DIR_LINE)；
}
QUp＝Q0；
}
}∥ End Sloce LOOP
CString ProName(argv[1])；
ProName+＝″.pln″；
WriteLines(LocalMax.51，(const char*)ProName)；
<dp n="d145"/>
∥ line grouping
PT st_main，end_main，st_scnd，end_scnd；
for(i＝0；i＜5；i++)
if(LocalMax[i].Qual＞0)
{st_main＝LocalMax[i].Start_p()；
end_main＝LocalMax[i].End_p()；
for(j＝i+1；j＜51；j++)
if(LocalMax[j].Qual＞0)
{st_scnd＝LocalMax[j].Start_p()；
end_scnd＝LocalMax[j].End_p()；
if((fabs(st_main.v-st_scnd.v)＜DistanceThresh)‖
(fabs(end_main.v-end_scnd.v)＜Distance Thresh))
LocalMax[j].Qual＝0.0；
}
}
qsort((void*)LocalMax，51，sizeof(GOOD_DIR_LINE)，
compare_GOOD_DIR_LINE)；
ProName＝argv[1]；
ProName+＝″.stp″；
WriteLines(LocalMax，51，(const char*)ProName)；
ProName＝argv[1]；
ProName+＝″.pn2″；
WritePears(LocalMax.51，(const char*)ProName，MaxStripNumber)；
GRAPH_OUT()；
pict_target.free_PCT()；
return(0)；
}
∥
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝
int get_number_plines()∥INITIALISATION GRAPHICMODE，GET SCALE
{
GRAPH_OUT()；
cout＜＜″MinSlope-20，MaxSlope 20，SlopeStep2 DistanceThresh 10
MAP \n″；
cout＜＜
″NTSC 0 ColorPlanl 1 New_plan 2 RGB 3 LUMIN_THR 4 IHS 5
\n″；
cin＞＞MinSlope＞＞MaxSlope＞＞SlopeStep＞＞DistanceThresh＞＞MAP；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ GRAPHICS START
if(GRAPHICS_START(&vc，GRAPHMODE))GRAPH_OUT(-1)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
return 1；
}
<dp n="d146"/>
∥**************************
int get_number_plines_f(FILE*f)∥INITIALISATION GRAPHICMODE，GET
SCALE
{
fscanf(f，″％*[^\n]s″)；
fscanf(f，″％d％d％d％d
％d″，&MinSlope，&MaxSlope，&SlopeStep，&DistanceThresh，
&MAP)；
∥Threshold for histogramme Number Of Points
∥for CorrThresh
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝INTRODUCTION
int Introduction(int arg，char *a)
{
int FLG_F＝0；
FILE *datainf；
short n＝0；
if((arg！＝2)&&(arg！＝3))
{
printf(″target-file \n″)；
FLG_F＝0；
return(1)；
}
else
if(arg＝＝3)
{FLG_F＝1；
if(！(datainf＝fopen(a，″r″)))return 0；
}
if(FLG_F)
{get_number_plines_f(datainf)；∥ GET SCALE AND PARAMETERS
fclose(datainf)；
}
else
get_number_plines()；
return 0；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void WriteLines(GOOD_DIR_LINE *L，short MaxN，const char *name)
{
LineC.open(name，ios∷out‖ios∷trunc)；
if(LineC.fail())
{LineC.clear(0)；
cout＜＜″CAN NOT OPEN StripCollection″；
GRAPH_OUT(-1)；
}
LineC＜＜″#\t st_X\t st_Y\t end_X \t end_y \t Value\n″；
∥OUTPUT all 51 line
<dp n="d147"/>
short i；
PT st.end；
for(i＝0；i＜MaxN；i++)
if((L+i)-＞Qual＞0)
{st＝(L+i)-＞Start_p()；end＝(L+i)-＞End_p()；
LineC＜＜i＜＜″\t″＜＜(short)st.u＜＜″\t″＜＜(short)st.v+2＜＜
″\t″＜＜end.u＜＜″\t″＜＜end.v+2＜＜
″\t″＜＜(L+i)-＞Qual＜＜″\n″；
}
LineC.close()；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
void WritePears(GOOD_DIR_LINE *L，short MaxN，const char *name，short
PMax)
{
LineC.open(name，ios∷out‖ios∷trunc)；
if(LineC.fail())
{LineC.clear(0)；
cout＜＜″CAN NOT OPEN StripCollection″；
GRAPH_OUT(-1)；
}
LineC＜＜″Strip_Collection \n″；
∥OUTPUT 16 pears
short i，n＝0，j；
PT st，end，st2，end2；
for(i＝0；i＜MaxN-1；i++)
if((L+i)-＞Qual＞0)
{st＝(L+i)-＞Start_p()；end＝(L+i)-＞End_p()；
for(j＝i+1；(n＜PMax)&&(j＜MaxN)；j++)
if((L+j)-＞Qual＞0)
{n++；
LineC＜＜(short)st.u＜＜″\t″＜＜
(short)st.v+2＜＜″\t″＜＜end.u＜＜″\t″＜＜end.v+2＜＜′\n′；
st2＝(L+j)-＞Start_p()；end2＝(L+j)-＞End_p()；
LineC＜＜(short)st2.u＜＜″\t″＜＜
(short)st2.v+2＜＜″\t″＜＜end2.u＜＜″\t″＜＜
end2.v+2＜＜′\n′；
}
}
LineC.close()；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
<dp n="d148"/>
ORIGIN＝PWB
ORIGIN_VER＝2.0
PROJ＝LN_DEC2
PROJFILE＝LN_DEC2.mak
BUILDDIR＝obj
DEBUG＝1
BRFLAGS＝/o obj\$(PROJ).bsc
BSCMAKE＝bscmake
SBRPACK＝sbrpack
NMAKEBSC1＝set
NMAKEBSC2＝nmake
BROWSE＝1
CC＝cl
CFLAGS_G＝/W2/BATCH/FR$*.sbr/Zn
CFLAGS_D＝/f/Zi/Od
CFLAGS_R＝/f-/Ot/Oi/Ol/Oe/Og/Gs
CXX＝cl
CXXFLAGS_G＝/AL/W4/G2/D DOS/BATCH/FR$*.sbr/Zn
CXXFLAGS_D＝/f-/Od/FPi87/Zi/DMICI/DSINGLE_WIN/D_DEBUG
CXXFLAGS_R＝/f-/Ot/Ol/Og/Oe/Oi/FPi87/Gs/DMICI/DSINGLE_WIN
MAPFILE_D＝NUL
MAPFILE_R＝NUL
LFLAGS_G＝/NOI/STACK：32000/BATCH/ONERROR：NOEXE
LFLAGS_D＝/CO/FAR/PACKC
LFLAGS_R＝/EXE/FAR/PACKC
LINKER ＝link
ILINK＝ilink
LRF＝echo＞NUL
ILFLAGS＝/a/e
LLIBS_R＝LAFXCR
LLIBS_D＝LAFXCRD
LLIBS_G＝graphics
CVFLAGS＝/25/S
RUNFLAGS＝\ilya\pnewline\tst\t0234e In_dec.ini
FILES＝..\LIB\VICALLOC.CPP..\LIB\PROJCTN7.CPP..\LIB\PIC_M7.CPP\
..\LIB\RES_MCH7.CPP..\LIB\L_TRN7.CPP LN_TPL1.CPP
LN_DEC2.CPP
OBJS＝obj\VICALLOC.obj obj\PROJCTN7.o bj obj\PIC_M7.obj
obj\RES_MCH7.obj\
obj\L_TRN7.obj obj\LN_TPL1.obj obj\LN_DEC2.obj
SBRS＝obj\VICALLOC.sbr obj\PROJCTN7.sbr obj\PIC_M7.sbr
obj\RES_MCH7.sbr\
obj\L_TRN7.scr obj\LN_TPL1.sbr obj\LN_DEC2.sbr
all：obj\$(PROJ).exe
.SUFFIXES：
<dp n="d149"/>
.SUFFIXES：
.SUFFIXES：.obj.sbr.cpp
obj\VICALLOC.obj：..\LIB\VICALLOC.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\malloc.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\VICALLOC.obj..\LIB\VICALLOC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\VICALLOC.obj..\LIB\VICALLOC.CPP
＜＜
！ENDIF
obj\VICALLOC.sbr：..\LIB\VICALLOC.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\malloc.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\VICALLOC.sbr..\LIB\VICALLOC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\VICALLOC.sbr..\LIB\VICALLOC.CPP
＜＜
！ENDIF
obj\PROJCTN7.obj：..\LIB\PROJCTN7.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h
..\LIB\projctn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Focbj\PROJCTN7.obj..\LIB\PROJCTN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Focbj\PROJCTN7.obj..\LIB\PROJCTN7.CPP
＜＜
<dp n="d150"/>
！ENDIF
obj\PROJCTN7.sbr：..\LIB\PROJCTN7.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h
..\LIB\projctn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PROJCTN7.sbr..\LIB\PROJCTN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PROJCTN7.sbr..\LIB\PROJCTN7.CPP
＜＜
！ENDIF
obj\PIC_M7.obj：..\LIB\PIC_M7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\graph.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\io.h C：\C700\INCLUDE\fcntl.h
C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.h C：\C700\INCLUDE\malloc.h..\LIB\phdr.h\
..\LIB\vicalloc.h..\LIB\pic_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\projctn7.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\PIC_M7.obj..\LIB\PIC_M7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PIC_M7.obj..\LIB\PIC_M7.CPP
＜＜
！ENDIF
obj\PIC_M7.sbr：..\LIB\PIC_M7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\graph.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\io.h C：\C700\INCLUDE\fcntl.h
C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.h C：\C700\INCLUDE\malloc.h..\LIB\phdr.h\
..\LIB\vicalloc.h..\LIB\pic_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\projctn7.h
！IF $(DEBUG)
<dp n="d151"/>
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PIC_M7.sbr..\LIB\PIC_M7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PIC_M7.sbr..\LIB\PIC_M7.CPP
＜＜
！ENDIF
obj\RES_MCH7.obj：..\LIB\RES_MCH7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
C：\C700\INCLUDE\graph.h..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foob.j\RES_MCH7.obj..\LIB\RES_MCH7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\RES_MCH7.obj..\LIB\RES_MCH7.CPP
＜＜
！ENDIF
obj\RES_MCH7.sbr：..\LIB\RES_MCH7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
C：\C700\INCLUDE\graph.h..\LIB\Projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\RES_MCH7.sbr..\LIB\RES_MCH7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\RES_MCH7.sbr..\LIB\RES_MCH7.CPP
＜＜
！ENDIF
obj\L_TRN7.obj：..\LIB\L_TRN7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\malloc.h..\LIB\vicalloc.h..\LIB\lin_trn7.h\
C：\C700\INCLUDE\vmemory.h..\LIB\projctn7.h..\LIB\res_mch7.h\
..\LIB\pic_mch7.h C：\C700\INCLUDE\math.h
C：\C700\INCLUDE\graph.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
<dp n="d152"/>
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\L_TRN7.obj..\LIB\L_TRN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\L_TRN7.obj..\LIB\L_TRN7.CPP
＜＜
！ENDIF
obj\L_TRN7.sbr：..\LIB\L_TRN7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\malloc.h..\LIB\vicalloc.h..\LIB\lin_trn7.h\
C：\C700\INCLUDE\vmemory.h..\LIB\projctn7.h..\LIB\res_mch7.h\
..\LIB\pic_mch7.h C：\C700\INCLUDE\math.h
C：\C700\INCLUDE\graph.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\L_TRN7.sbr..\LIB\L_TRN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\L_TRN7.sbr..\LIB\L_TRN7.CPP
＜＜
！ENDIF
obj\LN_TPL1.obj：LN_TPL1.CPP C：\C700\INCLUDE\stdio.h
C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\malloc.h\
C：\C700\INCLUDE\float.h C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\string.h C：\C700\INCLUDE\ctype.h match5.h\
..\LIB\pic_mch7.h..\LIB\projctn7.h..\LIB\res_mch7.h\
..\LIB\lin_trn7.h C：\C700\INCLUDE\vmemory.h
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\LN_TPL1.obj LN_TPL1.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\LN_TPL1.obj LN_TPL1.CPP
＜＜
！ENDIF
<dp n="d153"/>
obj\LN_TPL1.sbr：LN_TPL1.CPP C：\C700\INCLUDE\stdio.h
C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\malloc.h\
C：\C700\INCLUDE\float.h C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\string.h C：\C700\INCLUDE\ctype.h match5.h\
..\LIB\pic_mch7.h..\LIB\projctn7.h..\LIB\res_mch7.h\
..\LIB\lin_trn7.h C：\C700\INCLUDE\vmemory.h
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\LN_TPL1.sbr LN_TPL1.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\LN_TPL1.sbr LN_TPL1.CPP
＜＜
！ENDIF
obj\LN_DEC2.obj：LN_DEC2.CPP C：\C700\INCLUDE\stdlib.h
C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\graph.h C：\C700\INCLUDE\float.h\
C：\C700\MFC\INCLUDE\afx.h C：\C700\INCLUDE\fstream.h\
C：\C700\INCLUDE\time.h match5.h..\LIB\vicalloc.h\
C：\C700\INCLUDE\ctype.h C：\C700\MFC\INCLUDE\afx.inl\
C：\C700\INCLUDE\iostream.h..\LIB\projctn7.h..\LIB\pic_mch7.h\
..\LIB\res_mch7.h..\LIB\lin_trn7.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\LN_DEC2.obj LN_DEC2.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\LN_DEC2.obj LN_DEC2.CPP
＜＜
！ENDIF
obj\LN_DEC2.sbr：LN_DEC2.CPP C：\C700\INCLUDE\stdlib.h
C：\C700\INCLUDE\conio.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\graph.h C：\C700\INCLUDE\float.h\
C：\C700\MFC\INCLUDE\afx.h C：\C700\INCLUDE\fstream.h\
<dp n="d154"/>
C：\C700\INCLUDE\time.h match5.h..\LIB\vicalloc.h\
C：\C700\INCLUDE\ctype.h C：\C700\MFC\INCLUDE\afx.inl\
C：\C700\INCLUDE\iostream.h..\LIB\projctn7.h..\LIB\pic_mch7.h\
..\LIB\res_mch7.h..\LIB\lin_trn7.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\LN_DEC2.sbr LN_DEC2.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\LN_DEC2.sbr LN_DEC2.CPP
＜＜
！ENDIF
obj\$(PROJ).bsc：$(SBRS)
$(BSCMAKE)@＜＜
$(BRFLAGS)$(SBRS)
＜＜
obj\$(PROJ)exe：$(OBJS)
-$(NMAKEBSC1)MAKEFLAGS＝
-$(NMAKEBSC2)$(NMFLAGS)-f$(PROJFILE)obj\$(PROJ).bsc
！IF $(DEBUG)
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
$(MAPFILE_D)
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_D：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_D)；
＜＜
！ELSE
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
<dp n="d155"/>
$(MAPFILE_R)
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_R：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_R)；
＜＜
！ENDIF
$(LINKER)@obj\$(PROJ).lrf
.cpp.obj：
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Fo$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Fo$@$＜
＜＜
！ENDIF
.cpp.sbr：
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FR$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FR$@$＜
＜＜
！ENDIF
run：obj\$(PROJ).exe
obj\$(PROJ).exe $(RUNFLAGS)
debug：obj\$(PROJ).exe
CV $(CVFLAGS)obj\$(PROJ).exe$(RUNFLAGS)
<dp n="d156"/>
#ifndef MATCH
#define MATCH
#include″projctn7.h″
#include″pic_mch7.h″
#include″res_mch7.h″
#include″lin_trn7.h″
∥#include″tem_plt7.h″
#define NAME_LENGTH 40
#define GRAPHMODE _VRES256COLOR
∥COLOR_RGB INTER_pix_color_rgb(PCT p1，PT PT_now)；
#endif
<dp n="d157"/>
∥ STRIP SELECTION
∥ Module gets a strips after line detection(module plines
∥and selects two lines with a maximumm informational
∥contents(frequency approach).
∥COMMAND STRING
∥
∥lns_corr＜TARGET_name＞[CommandFile]
∥
∥ ＜TARGET_name＞File name of FRAME without extention
∥ [CommandFile] Optional ASCI file with a run time parameters.
∥
∥INPUT
∥＝＝＝＝＝＝＝ATTENTION
∥ LN_DEC2 used .pn2 files-output PLNEW modules
∥ RGB files of frame(field)and corresponding.SGN files created by
∥module PLINE.
∥RUN TIME parameters：
∥
∥＜four number＞ -shift of strips vertexes relative to original＞
∥＜V H_low H_up Hight Width＞-Five integer：
∥ V -The highest vertical harmonic；
∥ H_low，H_up -The lowest and highest horisontal harmonics；
∥ Hight，Width -Hight and Width of windowfor analyses.
∥＜Gap HalfScrWeight PosWeight＞-Integer and two float＜1：
∥ Gap -range unsensetivites to screen position；
∥ HalfScrWeight -Additional weght if an upper line is
∥ in upper half of screen
∥ PosWeight -Additional weght if miuddle line belower
∥ then middle line of another line.
∥SEE ALSO FILE″LN_DEC.Ini″
∥OUTPUT
∥ TARGET_name.SG2 -Strips selected；
∥ LINEDET.002 -result collection for analyses，
∥ includes keyboard information to analyse.
∥＝＝＝＝＝＝＝ATTENTION
∥LN_DEC2 OUTPUT
∥ TARGET_name.SG2 -Strips selected；
∥ LINEDET.002 -result collection for analyses，
∥ inciudes keyboard information to analyse.
#include＜stdlib.h＞
#include＜conio.h＞
#include＜stdio.h＞
#include＜string.h＞
#include＜graph.h＞
#include＜float.H＞
#include＜afx.h＞
#include＜fstream.h＞
#include＜time.h＞
<dp n="d158"/>
#include″match5.h″
#include″vicalloc.h″
#include＜ctype.h＞
short PRESENT_HIGHT；
short GAP＝8；
double HalfScrWeight＝0.1，PosWeight＝0.1；
short TAG_hight；
struct_videoconfig vc；
SCR_PNT vrt_target[4]；
FILE *datres；
double sh[4]＝{0，0，0，0}；
double GAMMA＝1.0，CORR_THRESH＝0，Thresh_mdl＝0；
short VOITING＝0，MAP＝0；
char f_name[40]＝″_″，FILE_name[40]＝″_″，FRAME_Name[40]＝″_″，
STRING_name[40]＝″_″，SIGN_name[40]＝″_″；
PCT pict_target，target_map；
short win_hight，win_lenth；
short HOR_HARM_I，HOR_HARM_h，VERT_HARM_1；
int_cdecl compare_array_elem(const void *elem1，const void *elem2)；
int Picturelnf(const char *name，SCR_PNT *vertexes，short n)；
∥int picture_inf_num_new(char *name，SCR_PNT *vertexes，short n)；
void get_shift_f(FILE *f，double *sh)；∥INITIALISATION GRAPHICMODE，
GET SCALE
void get_shift(double *sh)；∥INITIALISATION GRAPHICMODE，GET SCALE
int get_number_3()；
int get_number_3_f(FILE *f)；
double GlobalWinCalc(PCT target_map，
SCR_PNT win_size，short winpos)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝
ofstream LineC；
∥＝＝＝＝＝＝＝＝＝＝＝＝ OpenStripCollection
void OpenStripCol(const char*name)
{LineC.open(name，ios∷out|ios∷app|ios∷out|ios∷nocreate)；
if(LineC.fail())
{LineC.clear(0)；
LineC.open(name，ios∷out|ios∷app|ios∷out|ios∷noreplace)；
if(LineC.fail())
{LineC.clear(0)；
cout＜＜″CAN NOT OPEN StripCollection″；
GRAPH_OUT(-1)；
}
else
LineC＜＜″StripAnalysCollection \n″；
}
<dp n="d159"/>
LineC＜＜″Name #1\tVERT_HARM_I\t″＜＜
″HOR_HARM_I\t HOR_HARM_h\t WindowLength\n″；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int main(int argc，char* argv[])
{
char *p，mess[128]，clean[]＝″ ″；
SCR_PNT line_vrt[20][4]；
int FLG_F＝0；
FILE *datainf；
short n＝0；
SCR_PNT t_pos；
if((argc！＝2)&&(argc！＝3))
{
printf(″target-file\n″)；
FLG_F＝0；
return(1)；
}
else
if(argc＝＝3)
{FLG_F＝1；
if(！(datainffopen(argv[2]，″r″)))return 0；
}
if(FLG_F)
{get_shift_f(datainf，sh)；∥ GET SCALE
get_number_3_f(datainf)；
}
else
{get_shift(sh)；∥ GET SCALE
get_number_3()；
}
∥PROTOCOL OUTPUT
CString ProName(″linedet.002″)；
strcpy(f_name，argv[1])；
OpenStripCol((const char*)ProName)；
LineC＜＜f_name＜＜″\t″＜＜VERT_HARM1＜＜″\t″＜＜HOR_HARM_I＜＜″\t″
＜＜HOR_HARM_h＜＜″\t″＜＜win_lenth＜＜′\n′；
LineC＜＜″GAP＝″＜＜GAP＜＜″\tHalfScrWeight＝″＜＜HalfScrWeight＜＜
″\tPosWeight＝″＜＜PosWeight＜＜′\n′；
LineC＜＜″Line #\t Hight \t Value\t Comm\n″；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ GRAPHICS START
if(GRAPHICS_START(&vc，GRAPHMODE))GRAPH_OUT(-1)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝TARGET PICTURE name and vertexes
SCR_PNT target_pos；∥CONSTRACTOR default 0，0
pict_tarrget＝sign_storage_rgb(argv[1]，vc)；
∥＝＝＝＝＝＝＝＝＝PROTOTYPE initialisation
short j，k；
<dp n="d160"/>
double res[20]；
for(j＝0；j＜20；res[j++]＝0.0)；
CString FName(′′，80)；
FName＝argv[1]；
FName+＝″.pn2″；
while(Picturelnf((const char*)FName，vrt_target，n++))
{
SCR_PNT vrt[4]；
match_vertex(vrt_target)；
for(j＝0；j＜4；j++)
{
vrt[j].c＝vrt_target[j].c；
k＝((j％2)？j-1：j+1)；
if(fabs(sh[j])＜1)
{vrt[j].r＝(sh[j]？(short)((vrt_targe[j].r-vrt_target[k].r)*sh[j])+
vrt_target[j].r.vrt_target[j].r)；
}
else
vrt[j].r＝vrt_target[j].r+sh[j]；
}
#define CALC_HIGHT 16
TAG_hight＝(short)(vrt[2].r-vrt[3].r+vrt[1].r-vrt[0].r+2)*0.5；
if(TAG_hight＜10)continue；
target_map＝linear_transform_cont(pict_target，vrt，CALC_HIGHT)；
if(！target_map.s_cols)
{printf(″TOO NARROW LINES″)；continue；}
match_vertex(vrt)；
PRESENT_HIGHT＝16；
_clearscreen(_GCLEARSCREEN)；
target_pos.c＝10；
target_pos.r＝10；
sign_present_RGB(target_map，target_pos)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
SCR_PNT win_size(128，4)；
short winpos；
win_size.r＝(win_hight＞0)？_min(win_hight，CALC_HIGHT)：CALC_HIGHT；
win_size.c＝(win_lenth＞0)？_min(win_lenth，target_map.s_cols)
：target_map.s_cols；
winpos＝(CALC_HIGHT-win_size.r)/2；
const double scale＝(double)PRESENT_HIGHT/CALC_HIGHT；
∥ RESULTS AND VERTEXES
res[n-1]＝GlobalWinCalc(target_map，win_size，winpos)；
for(j＝0；j＜4；j++)
line_vrt[n-1][j]＝vrt[j]；
target_map.free_PCT()；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d161"/>
LineC＜＜n-1＜＜″\t″＜＜TAG_hight＜＜″\t″＜＜res[n-1]＜＜″\t″；
∥LineC＜＜″Line#\t Hight\t Value\t Comm_1 \t COMM_2 \n″；
sprintf(mess，″File Name″)；
_settextposition(vc.numtextrows-2，0)；
_outtext(clean)；
_settextposition(vc.numtextrows-2，0)；
_outtext(mess)；
p＝mess；
while(！isspace((int)(*p++＝(char)getche())))；
*(-p)＝′\0′；
LineC＜＜mess＜＜″\t\n″；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
}
∥——DECISION MAKING
short i，nl[5]，up_ln[5]，top_ln[5]；
short best＝0，scnd＝0；
double *nmb[20]，weight[5]＝{0，0，0，0，0}；
for(i＝0；i＜20；i++)nmb[i]＝res+i；
qsort((void*)nmb，20，sizeof(double*)，compare_array_elem)；
for(i＝0；i＜5；i++)
{if(！(*nmb[i]))break；
nl[i]＝nmb[i]-res；
up_ln[i]＝line_vrt[nl[i]][3].r+line_vrt[nl[i]][0].r；
top_ln[i]＝line_vrt[nl[i]][2].r+line_vrt[nl[i]][2].r；
weight[i]＝*nmb[i]；
}
if(weight[0])
{if((up_ln[1]+top_ln[1])＞(up_ln[0]+top_ln[0]-GAP))
weight[1]*＝(1.0+PosWeight)；
if(up_ln[1]＞pict_target.s_rows)
weight[1]*＝(1.0+HalfScrWeight)；
if(up_ln[0]＞pict_target.s_rows)
weight[0]*＝(1.0+HalfScrWeight)；
scnd＝(best＝(weight[0]＜weight[1])？1：0)？0：1；
∥——DESCISION OUTPUT
target_pos.c＝10；
target_pos.r＝10；
_clearscreen(_GCLEARSCREEN)；
target_map＝linear_transform_cont(pict_target，line_vrt[nl[best]]，16)；
sign_present_RGB(target_map，target_pos)；
target_map.free_PCT()；
if(weight[scnd])
{
target_pos.r+＝20；
target_map＝linear_transform_cont(pict_target，line_vrt[nl[scnd]]，16)；
sign_present_RGB(target_map，target_pos)；
<dp n="d162"/>
target_map.free_PCT()；
}
sprintf(mess，″Result 1_res＝％6g w＝％6g 2_res＝％6f W＝％6f \0″，
*nmb[best]，weight[best]，*nmb[scnd]，weight[scnd])；
char Sn1[20]；
_settextposition(vc.numtextrows-2，1)；
_outtext(clean)；
_settextposition(vc.numtextrows-2，0)；
_outtext(mess)；
p＝Sn1；
while(！isspace((int)(*p++＝(char)getche())))；
*(-p)＝′\0′；
strcat(mess，Sn1)；
LineC＜＜mess＜＜′\n′；
LineC.close()；
∥picture presentation
_clearscreen(_GCLEARSCREEN)；
target_pos.c＝0；
target_pos.r＝0；
target_map＝linear_trnsform_cont(pict_target，line_vrt[nl[best]]，16)；
sign_present_RGB(pict_target，target_pos)；
_setcolor(color_num(240，240，240))；
_moveto(line_vrt[nl[best]][3].c，line_vrt[nl[best]][3].r)；
_lineto(line_vrt[nl[best]][0].c，line_vrt[nl[best]][0].r)；
_moveto(line_vrt[nl[best]][2].c，line_vrt[nl[best]][2].r)；
_lineto(line_vrt[nl[best]][1].c，line_vrt[nl[best]][1].r)；
getch()；
if(weight[scnd])
{
_setcolor(color_num(240，240，0))；
_moveto(line_vrt[nl[scnd]][3].c，line_vrt[nl[scnd]][3].r)；
_lineto(line_vrt[nl[scnd]][0].c，line_vrt[nl[scnd]][0].r)；
_moveto(line_vrt[nl[scnd]][2].c，line_vrt[nl[scnd]][2].r)；
_lineto(line_vrt[nl[scnd]][1].c，line_vrt[nl[scnd]][1].r)；
getch()；
}
strcat(strcpy(f_name，argv[1])，″.sg2″)；
LineC.open(f_name，ios∷out)；
LineC＜＜″After Str Selection\n″；
LineC＜＜argv[1]＜＜″＿＿″＜＜Sn1＜＜″\t″＜＜Sn1＜＜′\n′；
for(j＝0；j＜4；j++)
LineC＜＜line_vrt[nl[best]][j].c＜＜″\t″＜＜line_vrt[nl[best]][j].r＜＜′\n′；
if(weight[scnd])
for(j＝0；j＜4；j++)
LineC＜＜line_vrt[nl[scnd]][j].c＜＜″\t″＜＜line_vrt[nl[scnd]][j].r＜＜′\n′；
LineC.close()；
∥END DECISION
<dp n="d163"/>
}
else
{
LineC.open(f_name，ios∷out)；
LineC＜＜″After Str Selection\n″；
LineC＜＜argv[1]＜＜″＿＿″＜＜″＿＿\t＿＿\n″；
LineC.close()；
cout＜＜″Lines not proposed″；
}
GRAPH_OUT()；
pict_target.free_PCT()；
target_map.free_PCT()；
fclose(datres)；
return(0)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int_cdecl compare_array_elem(const void *elem1，const void *elem2)
{int i；
double a；
a＝**(double**)elem1-**(double**)elem2；
i＝(a？((a＜0)？1：-1)：0)；
return i；
}
∥
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝
void get_shift_f(FILE *f，double *sh)∥INITIALISATION GRAPHICMODE，
GET SCALE
{
fscanf(f，″％If ％If ％If ％If′，sh，sh+1，sh+2，sh+3)；
}
∥
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝
void get_shift(double *sh)∥INITIALISATION GRAPHICMODE，GET SCALE
{int i；
cout＜＜″vertexes shift over rows(top_right，bottom_right，bottom_left，
top_left ％\n″；
for(i＝0；i＜4；i++)
cin＞＞sh[i]；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
int get_number_3()
{
GRAPH_OUT()；
<dp n="d164"/>
cout＜＜″VERT_HARM＜16 HOR_HARM_start＜16
HOR_HARM_stop，win_hight win_lenth″；
cin
＞＞VERT_HARM_1＞＞HOR_HARM_l＞＞HOR_HARM_h＞＞win_high＞＞win_lent
h；
cout＜＜″GAP HalfScrWeight％PosWeight％″；
cin＞＞GAP＞＞HalfScrWeight＞＞PosWeight；
HalfScrWeight/＝100.0；
PosWeight/＝100.0；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ GRAPHICS START
if(GRAPHICS_START(&vc，GRAPHMODE))GRAPH_OUT(-1)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
rerurn 0；
}
∥**************************
int get_number_3_f(FILE*f)
{fscanf(f，″％d ％d ％d ％d ％d″，&VERT_HARM_1，
&HOR_HARM_l，&HOR_HARM_h，&win_hight，&win_lenth)；
fscanf(f，″％d％lf％lf′，&GAP，&HalfScrWeight，&PosWeight)；
HalfScrWeight/＝100.0；
PosWeight/＝100.0；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int Picturelnf(const char *name，SCR_PNT *vertexes，short n)
{int i，j；
ifstream datfp；
char new_str[80]；
int r，FLG＝0；
datfp.open(name，ios∷in)；
if(datfp.fail()).
{datfp.clear(0)；
cout＜＜″CAN NOT OPEN InfFiie″＜＜name＜＜″\n″；
GRAPH_OUT(-1)；
}
datfp.getline(new_str，80)；
for(j＝0；j＜n+1；j++)
for(i＝0；i＜4；i++)
{datfp＞＞(vertexes+i)-＞c＞＞(vertexes+i)-＞r；
if(datfp.eof())
{datfp.close()；return 0；}
}
datfp.close()；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d165"/>
#include＜stdio.h＞
#include＜stdlib.h＞
#include＜conio.h＞
#include＜malloc.h＞
#include＜float.h＞
#include＜graph.h＞
#include＜string.h＞
#include＜ctype.h＞
#include″match5.h″
∥#include″tem_plt7.h″
#include″pic_mch7.h″
#define MAX_LINE 1024
extem short TAG_hight；
extem struct_videoconfig vc；
extem char f_name[40]，FILE_name[40]，FRAME_Name[40]，
STRING_name[40]， SIGN_name[40]；
typedef struct
{double md[3]，var[3]；}AVERAGE_VEC；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝
extem short HOR_HARM_l；
extem short HOR_HARM_h；
extem shortVERT_HARM_1；
∥———————————————————————
double calcul_power(PCT win，short x_scale，double *vr)
{const short
VERT_HARM＝VERT_HARM_1*2，HOR_HARM＝HOR_HARM_h*2，
HOR_HARM_s＝HOR_HARM_I？HOR_HARM_I*2-1：HOR_HARM_I；
const short THR＝16；
double sum[19][19]；
COLOR_RGB col；
double pow＝0，mid＝0；
short c1；
long l_now；
long n；
short h_t，v_t，x，y，h，v，half_x，half_y，quot_x，quot_y；
n＝win.s_cols*win.s_rows；
half_y＝win.s_rows＞＞1；
quot_y＝win.s_rows＞＞2；
∥！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
half_x＝x_scale＞＞1；
quot_x＝x_scale＞＞2：
∥ half_x＝win.s_rows＞＞1；
∥ quot_x＝win.s_rows＞＞2；
∥ half_x＝win.s_cols＞＞1；
∥ quot_x＝win.s_cols＞＞2；
∥！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
<dp n="d166"/>
for(h＝0；h＜HOR_HARM+1；h++)
for(v＝0；v＜VERT_HARM+1；v++)
sum[v][h]＝0；
for(y＝0；y＜win.s_rows：y++)
for(x＝0；x＜win.s_cols；x++)
{col＝win.get_pixel(y，x)；
l_now＝col.r+col.b+col.g；
l_now＝(l_now＞THR)？l_now：0；
mid+＝l_now：
pow+＝l_now*1_now；
for(v＝0；(v＜VERT_HARM+1)&&(((v+1)＞＞1)＜＝quot_y)；v++)
{
v_t＝y*((v+1)＞＞1)；∥HARMONIC#＝(v+1)＞＞1
v_t＝(v_t+(v & 0x0001？quot_y：0))/half_y；
v_t &＝0x0001；∥1 if y_pos in 2nd half
c1＝v_t？l_now：-l_now；
for(h＝HOR_HARM_s；(h＜HOR_HARM+1)&&(((h+1)＞＞1)＜＝quot_x)；h++)
{
h_t＝x*((h+1)＞＞1)；
h_t＝(h_t+(h & 0x0001？quot_x：0))/half_x；
h_t&＝0x0001；
sum[v][h]+＝h_t？c1：-c1；
}
}
}
double s0，dd；
for(s0＝h＝0；h＜HOR_HARM+1；h++)
for(v＝0；v＜VERT_HARM+1；v++)
if(h‖v)
s0+＝(double)sum[v][h]*sum[v][h]；
s0/＝n；
*vr＝(dd＝(pow-mid*mid/n))？s0/dd：0；
∥return add_out；
return(s0/(n*100.0))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
double GlobalWinCalc(PCT target_map，
SCR_PNT win_size，short winpos)
{
double centr_pow；
double pow_now；
long n_fr＝0；
double mid_pow＝0；
double rev_fr；
PCT win(win_size.c，win_size.r)；
SCR_PNT st_t，st_win；
<dp n="d167"/>
st_win.r＝winpos；
for(st_win.c＝0；st_win.c＜target_map.s_cols-win_size.c+1；st_win.c++)
{
win.load_template(target_map，st_win)；
pow_now＝calcul_power(win，target_map.s_rows，&centr_pow)；
mid_pow+＝pow_now；
n_fr++；
}
rev_fr＝1.0/n_fr；
mid_pow*＝rev_fr；
win.free_PCT()；
return mid_pow；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d168"/>
ORIGIN＝PWB
ORIGIN_VER＝2.0
PROJ＝LNS_CORR
PROJFILE＝LNS_CORR.MAK
BUILDDIR＝obj
DEBUG＝0
BRFLAGS＝/o obj\$(PROJ).bsc
BSCMAKE＝bscmake
SBRPACK＝sbrpack
NMAKEBSC1＝set
MAKEBSC2＝nmake
BROWSE ＝1
CC＝cl
CFLAGS_G＝/W2/BATCH/FR$*.sbr/Zn
CFLAGS_D＝/f/Zi/Od
CFLAGS_R＝/f-/Ot/Oi/Ol/Oe/Og/Gs
CXX＝cl
CXXFLAGS_G＝/AL/W4/G2/DDOS/BATCH/FR$*.sbr/Zn
CXXFLAGS_D＝/f-/Od/FPi87/Zi/DMICI/DSINGLE_WIN
CXXFLAGS_R＝/f-/Ot/Ol/Og/Oe/Oi/FPi87/Gs/DMICI/DSINGLE_WIN
MAPFILE_D＝NUL
MAPFILE_R＝NUL
LFLAGS_G＝/NOI/STACK：32000/BATCH/ONERROR：NOEXE
LFLAGS_D＝/CO/FAR/PACKC
LFLAGS_R＝/EXE/FAR/PACKC
LINKER＝link
ILINK＝ilink
LRF＝echo＞NUL
ILFLAGS＝/a/e
LLIBS_G＝graphics lafxcr
CVFLAGS＝/25/S
RUNFLAGS＝..\win4\S160_0..\win4\S160_auto1
FILES＝LNS_CORR.CPP..\LIB\VICALLOC.CPP..\LIB\PROJCTN7.CPP\
..\LIB\PIC_M7.CPP..\LIB\RES_MCH7.CPP COR_FNC.CPP
COR_WIN.CPP
OBJS＝obj\LNS_CORR.obj obj\VICALLOC.obj obj\PROJCTN7.obj
obj\PIC_M7.obj\
obj\RES_MCH7.obj obj\COR_FNC.obj obj\COR_WIN.obj
SBRS＝obj\LNS_CORR.sbr obj\VICALLOC.sbr obj\PROJCTN7.sbr
obj\PIC_M7.sbr\
obj\RES_MCH7.sbr obj\COR_FNC.sbr obj\COR_WIN.sbr
all：obj\$(PROJ).exe
.SUFFIXES：
.SUFFIXES：
.SUFFIXES：.obj.sbr.cpp
<dp n="d169"/>
obj\LNS_CORR.obj：LNS_CORR.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\string.h C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\io.h
C：\C700\INCLUDE\time.h\
C：\C700\INCLUDE\ctype.h C：\C700\INCLUDE\iostream.h\
C：\C700\MFC\INCLUDE\afx.h LNS_CORR.h cor_win.h
c：\ilya\lib\vicalloc.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istrearm.h C：\C700\INCLUDE\ostream.h\
C：\C700\MFC\INCLUDE\afx.inl..\LIB\proictn7.h..\LIB\pic_mch7.h\
..\LIB\res_mch7.h c：\ilya\lib\lin_trn7.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\LNS_CORR.obj LNS_CORR.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\LNS_CORR.obj LNS_CORR.CPP
＜＜
！ENDIF
obj\LNS_CORR.sbr：LNS_CORR.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\string.h C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\io.h
C：\C700\INCLUDE\time.h\
C：\C700\INCLUDE\ctype.h C：\C700\INCLUDE\iostream.h\
C：\C700\MFC\INCLUDE\afx.h LNS_CORR.h cor_win.h
c：\ilya\lib\vicalloc.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\MFC\INCLUDE\afx.inl..\LIB\projctn7.h..\LIB\pic_mch7.h\
..\LIB\res_mch7.h c：\ilya\lib\lin_trn7.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRcbj\LNS_CORR.sbr LNS_CORR.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\LNS_CORR.sbr LNS_CORR.CPP
＜＜
<dp n="d170"/>
！ENDIF
obj\VICALLOC.obj：..\LIB\VICALLOC.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\malloc.h
！IF $(DEBUG)
@$(CXX)@＜＜cbj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\VICALLOC.obj..\LIB\VICALLOC.CPP
＜＜
！ELSE
@$(CXX)@＜＜cbj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Focbj\VICALLOC.obj..\LIB\VICALLOC.CPP
＜＜
！ENDIF
obj\VICALLOC.sbr：..\LIB\VICALLOC.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\malloc.h
！IF$(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\VICALLOC.sbr..\LIB\VICALLOC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\VICALLOC.sbr..\LIB\VICALLOC.CPP
＜＜
！ENDIF
obj\PROJCTN7.obj：..\LIB\PROJCTN7.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h
..\LIB\projctn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Focbj\PROJCTN7.obj..\LIB\PROJCTN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜cbj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Focbj\PROJCTN7.obj..\LIB\PROJCTN7.CPP
＜＜
！ENDIF
<dp n="d171"/>
obj\PROJCTN7.sbr：..\LIB\PROJCTN7.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h
..\LIB\projctn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜cbj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRcbj\PROJCTN7.sbr..\LIB\PROJCTN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRcbj\PROJCTN7.sbr..\LIB\PROJCTN7.CPP
＜＜
！ENDIF
obj\PIC_M7.obj：..\LIB\PIC_M7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\graph.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\io.h C：\C700\INCLUDE\fcntl.h
C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\malloc.h..\LIB\phdr.h\
c：\ilya\lib\vicalloc.h..\LIB\pic_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\projctn7.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\PIC_M7.obj..\LIB\PIC_M7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PIC_M7.obj..\LIB\PIC_M7.CPP
＜＜
！ENDIF
obj\PIC_M7.sbr：..\LIB\PIC_M7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\graph.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\io.h C：\C700\INCLUDE\fcntl.h
C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\malloc.h..\LIB\phdr.h\
c：\ilya\lib\vicalloc.h..\LIB\pic_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\projctn7.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
<dp n="d172"/>
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PIC_M7.sbr..\LIB\PIC_M7.CPP
＜＜
！ELSE
@$(CXX)@＜＜cbj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PIC_M7.sbr..\LIB\PIC_M7.CPP
＜＜
！ENDIF
obj\RES_MCH7.obj：..\LIB\RES_MCH7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
C：\C700\INCLUDE\graph.h..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\RES_MCH7.obj.\LIB\RES_MCH7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\RES_MCH7.obj..\LIB\RES_MCH7.CPP
＜＜
！ENDIF
obj\RES_MCH7.sbr：..\LIB\RES_MCH7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
C：\C700\INCLUDE\graph.h..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\RES_MCH7.sbr..\LIB\RES_MCH7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\RES_MCH7.sbr..\LIB\RES_MCH7.CPP
＜＜
！ENDIF
obj\COR_FNC.obj：COR_FNC.CPP C：\C700\INCLUDE\stdio.h
C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\float.H\
C：\C700\INCLUDE\graph.h cor_fnc.h..\LIB\pic_mch7.h
..\LIB\res_mch7.h\
C：\C700\INCLUDE\vmemory.h..\LIB\prpjctn7.h
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
<dp n="d173"/>
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\COR_FNC.obj COR_FNC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\COR_FNC.obj COR_FNC.CPP
＜＜
！ENDIF
obj\COR_FNC.sbr：COR_FNC.CPP C：\C700\INCLUDE\stdio.h
C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\float.H\
C：\C700\INCLUDE\graph.h cor_fnc.h..\LIB\pic_mch7.h
..\LIB\res_mch7.h\
C：\C700\INCLUDE\vmemory.h..\LIB\projctn7.h
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\COR_FNC.sbr COR_FNC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\COR_FNC.sbr COR_FNC.CPP
＜＜
！ENDIF
obj\COR_WIN.obj：COR_WIN.CPP C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\malloc.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\string.h LNS_CORR.h cor_fnc.h..\LIB\projdn7.h\
..\LIB\pic_mch7.h..\LIB\res_mch7.h c：\ilya\lib\lin_trn7.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\COR_WIN.obj COR_WIN.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Fcobj\COR_WIN.obj COR_WIN.CPP
＜＜
！ENDIF
obj\COR_WIN.sbr：COR_WIN.CPP C：\C700\INCLUDE\vmemory.h\
<dp n="d174"/>
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\malloc.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\string.h LNS_CORR.h cor_fnc.h..\LIB\projctn7.h\
..\LIB\pic_mch7.h..\LIB\res_mch7.h c：\ilya\lib\lin_trn7.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRcbj\COR_WIN.sbr COR_WIN.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRcbj\COR_WIN.sbr COR_WIN.CPP
＜＜
！ENDIF
obj\$(PROJ).bsc：$(SBRS)
$(BSCMAKE)@＜＜
$(BRFLAGS)$(SBRS)
＜＜
obj\(PROJ).exe：$(OBJS)
-$(NMAKEBSC1)MAKEFLAGS＝
-$(NMAKEBSC2)$(NMFLAGS)-f$(PROJFILE)obj\$(PROJ).bsc
！ IF $(DEBUG)
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
$(MAPFILE_D)
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_D：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_D)；
＜＜
！ELSE
$(LRF)@＜＜obj\$(PROJ).Irf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
$(MAPFILE_R)
<dp n="d175"/>
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_R：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_R)；
＜＜
！ENDIF
$(LINKER)@obj\$(PROJ).lrf
.cpp.obj：
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAG S_D)/FoS@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Fo$@$＜
＜＜
！ENDIF
.cpp.sbr：
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FR$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FR$@$＜
＜＜
！ENDIF
run：obj\$(PROJ).exe
obj\$(PROJ).exe$(RUNFLAGS)
debug：obj\$(PROJ).exe
CV$(CVFLAGS)obj\$(PROJ).exe $(RUNFLAGS)
<dp n="d176"/>
∥ Module calculates correlation functions of PROTO_1 and set of
∥prototypes.Set of prototypes′names is defined by a MASK correspondes
∥to names generated by MAKEPRB and has next structure：
∥ [path]&RRW_P.rgb
∥/Where
∥ [path]-optional name of directory；
∥ & -first letter of file name
∥ RR -two digits corresponding to prototype′s hight
∥ (RR＝16|32|48|64)
∥ W -number corresponding to window number(see
MAKEPRB
∥ description.
∥ P prototype Number
∥ MASK includes ONLY[path]&RRW_ and programme will
∥calculate correlation functions for prototypes with P from 0 to
∥first not existing number.
∥COMMAND STRING
∥
∥lns_corr＜PROTO_1_Name＞＜MASK＞[CommandFile]
∥
∥ ＜PROTO_1_Name＞ File name of PROTOTYPE without
extention
∥ ＜MASK＞ Mask for prototypes FileNames without extention
and
∥ Prototype′s number
∥ [CommandFile] Optional ASCI file with a run time parameters.
∥
∥INPUT
∥ RGB files of prototypes and corresponding.SGN files created by
∥module MAKEPRB.
∥RUN TIME parameters：
∥
∥ 0 0 0 0 -shift for all cases have to be 0
∥ ＜CalorSpace＞
∥ We have used 1-as worked only with a luminance
∥ ＜Window width＞
∥ We have used 8
∥SEE ALSO FILE″LNS_CORR.INI″
∥OUTPUT
∥ Correlation functions in PROTO_1.DBC file.
#include＜stdlib.h＞
#include＜conio.h＞
#include＜stdio.h＞
#include＜string.h＞
#include＜graph.h＞
#include＜float.H＞
<dp n="d177"/>
#include＜io.h＞
#include＜time.h＞
#include＜ctype.h＞
#include＜iostream.h＞
#include＜afx.h＞
#include″LNS_CORR.h″
#include″cor_win2.h″
#include″vicalloc.h″
char f_name[40]＝″_″，FILE_name[40]＝″_″，FRAME_Name[40]＝″_″，
ARGV_1[30]＝″_″，
STRING_name[40]＝″_″，SIGN_name[40]＝″_″，TAG_name[9]＝″_″，
drive[3]＝″_″，dir[30]＝″_″，
ext[5]＝″_″，*tag_frame；
double GAMMA＝1.0，CORR_THRESH＝0.0，Thresh_mdl＝0.0；
short MAP；
short VOITING＝3，TAG_hight；
struct_videoconfig vc；
FILE*datres；
int FLG_WRIGHT＝0；
double sh[4]＝{0，0，0，0}；
PCT pict_target，pict_proto：
FILE *out_rslt；
int picture_inf(char *name，SCR_PNT *vertexes)；
int picture_inf_num(char *name，SCR_PNT *vertexes，short n)；
int get_number()；∥INITIALISATION GRAPHICMODE，GET SCALE
int get_number_3()；∥INITIALISATION GRAPHICMODE，GET SCALE
void get_shift_f(FILE *f，double *sh)；∥INITIALISATION GRAPHICMODE，
GET SCALE
void get_shift(double *sh)；∥INITIALISATION GRAPHICMODE，GET SCALE
int get_number_3_f(FILE *f)；∥INITIALISATION GRAPHICMODE，GET
SCALE
int picture_inf_num_2(char *name，SCR_PNT *vertexes，short n，char *ext)；
int picture_inf_num_new(char *name，SCR_PNT *vertexes，short n)；
∥$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$
short PRESENT_HIGHT＝32，CALC_HIGHT＝32；
FILE *INP_PROTOCOL；
FILE *PROTOCOL；
CString PROTOCOL_NAME；
CString PROTOCOL_START；
CString PROTO1_HEADER＝CString∷CString(
<dp n="d178"/>
″PROTO_File\tFRAME_Name\tSTRING_name\tS_name\tSLength\tWinLengt
h\tSPACE\n″)；
CString PROTO_TAG_HEADER＝CString∷CString(
″TAG_File\tFRAME_Name\tSTRING_name\tS_Name\tLegnth\tCOMM\n″)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝
void init_protocol(char *name)
{short FLG；
FLG＝_access(PROTOCOL_NAME，0)；∥0 if exist
PROTOCOL＝fopen(PROTOCOL_NAME，″a″)；
if(FLG)
fpnntf(PROTOCOL.″AUTO and CROSS correlation functions \n ％s″，
PROTO1_HEADER)；
PROTOCOL_START＝name；
PROTOCOL_START+＝″\t″；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝
int open_inp_prot(char *name)
{if(！(INP_PROTOCOL＝fopen(name，″r″)))return 1；
∥split first str
fscanf(INP_PROTOCOL，″％*[^\n]s″)；
return 0；
｝
∥$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$
∥return file name without extwntion in″name″and TRUE 1 if file exist；
int next_pict(char *name，char *mask，char *ext，int num)
∥if num＝-2 initalisation；
∥ -1 next
∥ ＞0 adding this#to mask
∥NULL if notexist file with″.rgb″
{static int now；
char full_name[80]；
strcpy(name，mask)；
if(num＝＝-2)now＝0；
else if(num＝＝-1)
now++；
else if(num＜0)return 1；
else now＝num；
_itoa(now，name+strlen(name)，10)；
strcat(strcpy(full_name，name)，ext)；
∥1 if file exist
return(！_access(full_name，0))；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝
<dp n="d179"/>
#include＜fstream.h＞
int ReadStrlnf(char *name，short *StD)
{ifstream InpF；
char a[80]；
strcat(strcpy(a，name)，″.str″)；
short i；
InpF.open(a，ios∷in|ios∷nocreate)；
if(InpF.fail())
{InpF.clear(0)；
return 1；
}
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
InpF.getline(a，80，′\n′)；
i＝0；
do
{
InpF＞＞StD[i++]；
if(InpF.eof()‖i＞17)
{StD[-i]＝-1；
break；
}
InpF＞＞StD[i++]；
}
while(1)；
InpF.close()；
return 0；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
SCR_PNT winsize；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝
int main(int argc，char* argv[])
{int FLG_F＝0，FLG_WRIGHT＝0；
FILE *datainf；
short winstep，map_stnd；
short n＝0；
SCR_PNT t_pos；
if((argc！＝3)&&(argc！＝4))
{
printf(″target-file proto_file_mask\n″)；
FLG_F＝0；
return(1)；
}
<dp n="d180"/>
else
if(argc＝＝4)
{FLG_F＝1；
if(！(datainf＝fopen(argv[3]，″r″)))return 0；
}
if(FLG_F)
{get_shift_f(datainf，sh)；∥ GET SCALE
get_number_3_f(datainf)；∥ GET SCALE
}
else
{get_shift(sh)；∥GET SCALE 0
get_number_3()；
}
strcpy(ARGV_1，argv[1])；
PROTOCOL_NAME＝argv[1]；
PROTOCOL_NAME+＝″.dbc″；
init_protocol(argv[1])；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ GRAPHICS START
if(GRAPHICS_START(&vc，GRAPHMODE))exit(-1)；
∥＝＝＝＝＝＝＝＝＝TARGET PICTURE name and vertexes
SCR_PNT target_pos； ∥CONSTRACTOR default 0，0
short StrDescr[17]；
_splitpath(argv[1]，drive，dir，TAG_name，ext)；
pict_target＝sign_storage_rgb(argv[1]，vc)；
if(ReadStrlnf(argv[1]，StrDescr))
{printf(″STR PROTO not exist″)；GRAPH_OUT(-1)；return-1；
}；
winsize.r＝pict_target.s_rows；
winstep＝winsize.c；
∥″PROTO_File\tFRAME_Name\tSTRING_name\tS_name\SLength\tWinLengt
h\tSPACE\n″)；
fprintf(PROTOCOL，″％s％ 8s\t％6s\t％12s\t％4d\t％4d\t％12s\n％s″，
(const char
*)PROTOCOL_START，FRAME_Name，STRING_name，SIGN_name，
pict_target.s_cols，winsize.c，SP[MAP]，
(const char*) PROTO_TAG_HEADER)；
∥＝＝＝＝＝＝＝＝＝PROTOTYPE LOOP OVER names
char proto_name[NAME_LENGTH]，buff[4]；
SCR_PNT proto_pos.z；
∥loop over masks
∥return file name without extention in″name″″and TRUE 1 if file exist，
short proto_number＝0；∥#0；
while(next_pict(proto_name，argv[2]，″.rgb″，proto_number))
{proto_humber＝-1；∥next；
SCR_PNT pr_v[4]；
<dp n="d181"/>
∥PROTO INFORMATION IN PROTOCOL
pict_proto＝sign_storage_rgb(proto_name，vc)；
picture_inf_num_2(proto_name，pr_v，0，″.str″)；∥only for SIGN_name
∥″TAG_File\tFRAME_Name\tSTRING_name\tS_Name\tLegnth\n″)
fprintf(PROTOCOL，″％12s\t ％8s\t ％6s\t ％12s\t ％4d\n″，
proto_name，FRAME_Name，STRING_name，SIGN_name，pict_proto.s_cols)；
TAG_hight＝Pict_proto.s_rows；
∥TARGET PRESENTATION
_clearscreen(_GCLEARSCREEN)；
proto_pos.c＝target_pos.c＝10；
proto_pos.r＝(target_pos.r＝10)+pict_target.s_rows+5；
sign_present_RGB(pict_target，target_pos)；
sign_present_RGB(pict_proto，proto_pos)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
corr_win_proto(pict_target，pict_proto，
winsize，winstep，CORR_THRESH，StrDescr)；
pict_proto.free_PCT()；
}
_displaycursor(_GCURSORON)；
_setvideomode(_DEFAULTMODE)；
pict_target.free_PCT()；
fclose(PROTOCOL)；
return(0)；
}
∥
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝
void get_shift_f(FILE *f，double *sh)∥INITIALISATION GRAPHICMODE，
GET SCALE
{int i；
for(i＝0；i＜4；i++)
{
fscanf(f，″％lf ％lf\n″，sh+i++，sh+i)；
}
}
∥
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝
void get_shift(double *sh)∥INITIALISATION GRAPHICMODE，GET SCALE
{int i；
cout＜＜″vertexes shift over rows(top_right，bottom_right，bottom_left，
top_left ％\n″；
for(i＝0；i＜4；i++)
cin＞＞sh[i]；
}
<dp n="d182"/>
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝
int get_number_3()∥INITIALISATION GRAPHICMODE，GET SCALE
{int R；
_displaycursor(_GCURSORON)；
_setvideomode(_DEFAULTMODE)；
cout＜＜″[＜0 EXIT]，color_map(0-NTSC，1-HSI，2-NEW，3-RGB，4-
LUMIN_THR 5-HSI\n″；
cout＜＜″WIN_SIZE\n″；
cin＞＞MAP＞＞winsize.c；
_displaycursor(_GCURSOROFF)；
_setvideomode(GRAPHMODE)；
make_palette()；
return R；
}
∥***************************
int get_number_3_f(FILE *f)∥INITIA LISATION GRAPHICMODE，GET
SCALE
{int R；
fscanf(f，″％d ％d″，&MAP，&(winsize.c))；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int picture_inf(char *name，SCR_PNT *vertexes)
{int i；
char new_name[25]；
FILE *datfp；
strcat(strcpy(new_name，name)，″.sgn″)；
if(！(datfp＝fopen(new_name，″r″)))return 0；
fscanf(datfp，″％s\n″new_name)；
for(i＝0；i＜4；i++)
fscanf(datfp，″％d ％d\n″，&(vertexes[i].c)，&(vertexes[i].r))；
fclose(datfp)；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int picture_inf_num_2(char *name，SCR_PNT *vertexes，short n，char
*ext＝″.sgn″)
{int i，j；
char new_name[45]；
FILE *datfp；
strcat(strcpy(new_name，name)，ext)；
if(！(datfp＝fopen(new_name，″r″)))return 0；
fscanf(datfp，″％*s ％*s ％*s ％*s ％*s \n″)；
fscanf(datfp，″％s ％s ％s ％s ％s″，&f_name，&FILE_name，&FRAME_Name，
&STRING_name，&SIGN_name)；
for(j＝0；j＜n+1；j++)
<dp n="d183"/>
for(i＝0；i＜4；i++)
if(fscanf(datfp，″％d ％d\n″，&(vertexes[i]c)，&(vertexes[i].r))＝＝EOF)
{fclose(datfp)；return 0；}
fclose(datfp)；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
/*void write_sign_inf(char*pr，PCT pict_now)
{char fl_fp[50]，f_name[9]；
int FLG；
FILE *dathere，*database；
_splitpath(pr，drive，dir，f_name，ext)；
strcat(strcpy(fl_fp，pr)，″.sgn″)；
dathere＝fopen(fl_fp，″w″)；
FLG＝_access(″PROTODB.1″，0)；∥-1 if not exist
if(！(database＝fopen(″PROTODB.1″，″a″)))
{strcpy(fl_fp，″CAN NOT CREATE D_BASE FILE″)；
exit(-1)；}
fpnntf(dathere，″WIN_name FILE_mame FRAME_Name STRING_name
SIGN_name\n″)；
fprintf(dathere，″％8s ％9s ％10s ％11s ％9s\n″，f_name，FILE_name，
FRAME_Name，STRING_name，SIGN_name)；
if(FLG)
fprintf(database，″WIN_name FILE_name FRAME_Name STRING_name
SIGN_name\n″)；
fprintf(database，″％8s ％9s ％10s ％11s ％9s \n″，f_name，FILE_name，
FRAME_Name，STRING_name，SIGN_name)；
fprintf(dathere，″％d 0\n″，pict_now.s cols-1)；
fprintf(dathere，″％d ％d \n″，pict_now.s_cols-，pict_now.s_rows-1)；
fprintf(dathere，″0 ％d\n″，pict_now.s_rows-1)；
fprintf(dathere，″0 0\n″)；
fclose(dathere)；
fclose(database)；
}*/
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int picture_inf_num(char *name，SCR_PNT *vertexes，short n)
{int i，j；
char new_name[25]；
FILE *datfp；
strcat(strcpy(new_name，name)，″.sgn″)；
if(！(datfp＝fopen(new_name，″r″)))return 0；
fscanf(datfp，″％s\n″，new_name)；
<dp n="d184"/>
for(j＝0；j＜n+1；j++)
for(j＝0；i＜4；i++)
if(fscanf(datfp，″％d ％d\n″，&(vertexes[i].c)，&(vertexes[i].r))＝＝EOF)
{fclose(datfp)；return 0；}
fclose(datfp)；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
int picture_inf_num_new(char *name，SCR_PNT *vertexes，short n)
{int i，j；
char new_str[80]；
FILE *datfp；
int r，FLG＝0；
strcat(strcpy(new_str，name)，″.sgn″)；
if(！(datfp＝fopen(new_str，″r″)))return 0；
r＝fscanf(datfp，″％[^\n]s″，new_str)；
r＝fscanf(datfp，″％[^\n]s″，new_str)；
if(_iscsymf((int)new_str[0]))∥FILE INFORMATION)
∥(letter or underscore)
{sscanf(new_str，″％s ％s ％s ％s″，&FILE_name，&FRAME_Name，
&STRING_name，&SIGN_name)；
r＝fscanf(datfp，″％[^\n]s″，new_str)；
}
for(j＝0；j＜n+1；j++)
for(i＝0；i＜4；i++)
{if(FLG)
if(fscanf(datfp，″％[^\n]s″，new_str)＝＝EOF)
{fclose(datfp)；return 0；}
FLG＝1；
sscanf(new_str，″％d ％d″，&(vertexes[i].c)，&(vertexes[i].r))；
}
fclose(datfp)；
return 1；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
<dp n="d185"/>
#include＜vmemory.h＞
#include＜stdio.h＞
#include＜stdlib.h＞
#include＜conio.h>
#include＜malloc.h＞
#include＜float.h＞
#include＜graph.h＞
#include＜string.h＞
#include″lns_corr.h″
∥#include″tem_plt7.h″
#include″cor_fnc.h″
∥#include″deb_out.h″
#define MAX_LINE 1024
extem FILE*PROTOCOL；
extem double GAMMA，Thresh_mdl；
extem short MAP；
extem short VOITING；
extem struct_videoconfig vc；
extem char f_name[40]， FILE_name[40]，FRAME_Name[40]，
STRING_name[40]，SIGN_name[40]；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝
void draw_int(short st，short w，COLOR_VEC intr)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝
void draw_color_corr_1(COLOR_VEC corr，short F，
short CH_HIGHT，
short CH_BASE，double THRESH，
short pos_now，short size)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void draw_chart(double *dist_line，short n，double max_value＝0，
short CH_HIGHT＝100，
short CH_BASE＝480，double THRESH＝0，
short t_pos＝60)；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#define HOR_HARM 2
#define VERT_HARM 4
∥—————————————————————
inline COLOR_VEC sign_for_col(short d，COLOR_VEC col)
{COLOR_VEC out；
int i；
for(i＝0；i＜3；i++)
out.c[i]＝d？col.c[i]：-col.c[i]；
return out；
<dp n="d186"/>
}
∥—————————————————————
/*COLOR_VEC int_value_1(PCT w，double Thr，
COLOR_VEC(*p_funct)(COLOR_RGB p1，double
Thresh_mdl)，AVERAGE_VEC w_av)
{COLOR_VEC col，sum[9][9]，out，c1；
const COLOR_VEC z＝{0，0，0}；
short h_t，v_t，i，x，y，h，v，
half_x＝w.s_cols＞＞1，half_y＝w.s_rows＞＞1，
quot_x＝w s_cols＞＞2，quot_y＝w.s_rows＞＞2；
long n；
for(h＝0；h＜HOR_HARM+1；h++)
for(v＝0；v＜VERT_HARM+1；v++)
sum[v][h].c[0]＝sum[v][h].c[1]＝sum[v][h].c[2]＝0.0；
n＝w.s_cols *w.s_rows；
n*＝n；
for(y＝0；y＜w.s_rows；y++)
for(v＝0；v＜VERT_HARM+1；v++)
{
v_t＝y*((v+1)＞＞1)；
v_t＝(v_t+(v & 0x0001？quot_y：0))/half_y；
v_t &＝0x0001；
for(x＝0；x＜w.s_cols；x++)
{col＝p_funct(w.get_pixel(y，x)，Thr)；
c1＝sign_for_col(v_t，col)；
for(h＝0；h＜HOR_HARM+1；h++)
{
h_t＝x*((h+1)＞＞1)；
h_t＝(h_t+(h & 0x0001？quot_x：0))/half_x；
h_t &＝0x0001；
c1＝sign_for_col(h_t，c1)；
for(i＝0；i＜3；i++)
sum[v][h].c[i]+＝c1.c[i]；
}
}
}
double s0，dd，max_v＝0，th；
for(dd＝i＝0；i＜3；i++)
{for(s0＝h＝0；h＜HOR_HARM+1；h++)
for(v＝0；v＜VERT_HARM+1；v++)
if(h‖v)
s0+＝sum[v][h].c[i]*sum[v][h].c[i]；
s0/＝n；
dd＝w_av.var[i]+w_av.md[i]*w_av.md[i]；
out.c[i]＝(dd？s0/dd：1)；
max_v＝(max_v＜out.c[i])？out.c[i]：max_v；
}
<dp n="d187"/>
for(i＝0；i＜3；i++)
{th＝out.c[i]/max_v；
∥ THRESHOLDING
if(th＜0.2)
out.c[i]＝0；
}
return out：
}*/
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝
COLOR_VEC(*PointColFunct())(COLOR_RGB p1，double Thresh_mdl)
{switch(MAP)
{case NTSC：return(color_space_NTSC)；
case New_plan：return(color_space_NEW)；
case HSI：return(color_space_RGB)；
case RGB：return(color_space_RGB_simple)；
case LUMIN_THR：return(color_space_LUMIN_THR)；
case IHS：return(color_space_IHS)；
}；
return NULL；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
const short CH_HIGHT_D＝100，CH_BASE_D＝470，
CH_HIGHT＝100，CH_BASE＝450，t_pos＝40；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
double scale_fact＝1；
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void corr_win_proto(PCT win_source，PCT Proto，SCR_PNT win_size
，short win_step，double CORR_THRESH，short *StripEnds)
{
short i；
char mess[40]；
short F＝0；
COLOR_VEC(*p_funct)(COLOR_RGB p1，double Thresh_mdl)；
p_funct＝PointColFunct()；
PCT win(win_size.c，win_size.r)；
PCT tag(win_size.c，win_size.r)；
SCR_PNT st_t，st_win；
AVERAGE_VEC middle_win[64]，middle_tag；
const AVERAGE_VEC z＝{{0，0，0}，{0，0，0}}；
COLOR_VEC *corr_now，cr；
const COLOR_VEC z_col＝{0.0，0.0.0.0}；
int line_size＝win_source.s_cols+Proto.s_cols；
∥memory allocation
<dp n="d188"/>
if((corr_now＝(COLOR_VEC*)malloc(
sizeof(COLOR_VEC)*(size_t)line_size *3))＝＝NULL)
{printf(″WIN NOT MEMORY″)；return；}；
st_t.r＝0；
double dd；
st_win.r＝0；
short k，FLG_COL＝1；
short StripStart，StripStop；
short PartNum；
k＝PartNum＝0；
while(StripEnds[PartNum]＞＝0)
{StripStart＝StripEnds[PartNum++]；
StipStop＝StripEnds[PartNum++]；
for(st_win.c＝StripStart；
st_win.c+win_size.c＜＝StripStop；st_win.c+＝win_step，k++)
{
FLG_COL＝1；
for(i＝0；i＜line_size；corr_now[i++]＝z_col)；
win.load_template(win_source，st_win)；
middle_win[k]＝average(win，Thresh_mdl，p_funct)；
#ifdef MICI
#endif
const COLOR_VEC z_UNIT＝{1.0，1.0，1.0}；
for(st_t.c＝0；st_t.c＜＝Proto.s_cols-win_size.c；st_t.c++)
{
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
tag.load_template(Proto，st_t)；
middle_tag＝average(tag，Thresh_mdl，p_funct)；
∥DIFF ABS VALUES
#ifdef SINGL_VAL
cr＝template_conv_1(tag，win，Thresh_mdl，z_UNIT，p_funct)；
strcpy(mess，″VECTOR Approach to CORRELATION″)；
corr_now[st_tc]＝Correlation_single_1(cr，middle_tag，middle_win[k]，z_
UNIT)；
#ifdef ABS_VALUE
strcpy(mess，″DIFF ABS VALUES/max ABS VALUES″)；
cr＝
template_abs_diff_1(tag，win，Thresh_mdl，z_UNIT，p_funct，
middle_tag，middle_win[k])；
#else
cr＝template_conv_1(tag，win，Thresh_mdl，z_UNIT，p_funct)；
strcpy(mess，″PEARSON CORR.″)；
corr_now[st_t.c]＝Correlation(cr，middle_tag，middle_win[k]，z_UNIT)；
#endif
<dp n="d189"/>
#endif
∥ONLY LUMINANCE
∥ strcat(mess，″ALL 3 COMP″)；
strcat(mess，″Only 0 COMP″)；
corr_now[st_t.c].c[1]＝corr_now[st_tc].c[2]＝
corr_now[st_t.c].c[0]；
#ifdef MICI
draw_color_corr_1(
corr_now[st_t.c]，FLG_COL，CH_HIGHT_D，CH_BASE_D，CORR_THRESH，
st_t.c，Proto.s_cols)；
FLG_COL＝0；
#endif
}
∥＝＝＝＝＝＝FILL PROTOCOL
∥$ WILL BE USED AS SEPARATOR FOR RFADING
fprintf(PROTOCOL″$\t％s\t$\t％4d\t$\n″，mess，st_win.c)；
for(i＝0；i＜Proto.s_cols：i++)∥ONLY 0 COMP
fprintf(PROTOCOL，″％6g\t″，corr_now[i].c[0])；
fprintf(PROTOCOL，″\n″)；
}
}
win.free_PCT()；
tag.free_PCT()；
free((void*)corr_now)；
return；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void draw_chart(double *dist_line，short n，double max_value，
short CH_HIGHT，
short CH_BASE，double THRESH，
short t_pos)
{short i，j；
double p，
crit＝max_value；
if(！max_value)
for(i＝0；i＜n；i++)
crit＝(dist_line[i]＞crit)？dist_line[i]：crit；
else crit＝max_value；
if(！crit)
crit＝1；
p＝CH_HIGHT*(1-THRESH/crit)；
_moveto(0，CH_BASE-CH_HIGHT)；
<dp n="d190"/>
_lineto(n，CH_BASE-CH_HIGHT)；
_moveto(0，CH_BASE-(short)p)；
_lineto(n，CH_BASE-(short)p)；
_moveto((short)0，(short)CH_BASE)；
for(i＝0；i＜_min(n，vc.numxpixels)；i++)
{j＝CH_BASE-CH_HIGHT+(short)(dist_line[i]*CH_HIGHT/crit)；
if(j＜0)
∥ getch()
else
if(！_lineto(i，j))
∥ getch()
}
if(t_pos)
_settextposition(t_pos，30)；
char buffer[30]；
sprintf(buffer，″MAX＝％f10″，crit)；
_outtext(buffer)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝
void draw_int(short st，short w，COLOR_VEC intr)
{short CH_HIGHT＝100，
CH_BASE＝200；
double p：
_setcolor(color_num(240，240，240))；
_setcolor(color_num(240，0，0))；
p＝CH_BASE-CH_HIGHT*intr.c[0]；
_moveto(st，(short)p)；
_lineto(st+w，(short)p)；
_setcolor(color_num(0，240，0))；
p＝CH_BASE-CH_HIGHT*intr.c[1]；
_moveto(st，(short)p)；
_lineto(st+w，(short)p)；
_setcolor(color_num(0，0，240))；
p＝CH_BASE-CH_HIGHT*intr.c[2]；
_moveto(st，(short)p)；
_lineto(st+w，(short)p)；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
void draw_color_corr(COLOR_VEC corr，COLOR_RGB *corr_old，short F，
short CH_HIGHT，
short CH_BASE，double THRESH，
short pos_now)
{double p；
short j；
<dp n="d191"/>
if(F)
{
_setcolor(color_num(240，240，240))；
p＝CH_HIGHT*(1-THRESH)；
_moveto(0，CH_BASE-CH_HIGHT)；
_lineto(512，CH_BASE-CH_HIGHT)；
_moveto(0，CH_BASE-(short)p)；
_lineto(512，CH_BASE-(short)p)；
}
_setcolor(color_num(240，240，240))；
_moveto(pos_now，corr_old-＞r)；
j＝CH_BASE-CH_HIGHT+(short)(corr.c[0]*CH_HIGHT)；
_lineto(pos_now+1，j)；
corr_old-＞r＝j；
_moveto(pos_now，corr_old-＞g)；
_setcolor(color_num(240，0，0))；
j＝CH_BASE-CH_HIGHT+(short)(corr.c[1]*CH_HIGHT_；
_lineto(pos_now+1，j)；
corr_old-＞g＝j；
_moveto(pos_now，corr_old-＞b)；
_setcolor(color_num(0，240，0))；
j＝CH_BASE-CH_HIGHT+(short)(corr.c[2]*CH_HIGHT)；
_lineto(pos_now+1，j)；
corr_old-＞b＝j；
}
∥＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝
void draw_color_corr_1(COLOR_VEC corr，short F，
short CH_HIGHT，
short CH_BASE，double THRESH，
short pos_now，short size)
{
short j，k，l，i，st；
static short real_size，pos_old；
short POS；
static COLOR_RGB corr_old；
real_size＝size*scale_fact；
POS＝10+pos_now*scale_fact；
_setcolor(color_num(240，240，240))；
if(F)
{
-setcolor(color_num(0，0，0))
_rectangle(_GFILLINTERIOR，0，CH_BASE-3*CH_HIGHT-
(CH_HIGHT_D＞＞1)，
real_size，CH_BASE)；
_setcolor(color_num(240，240，240))；
corr_old.r＝k＝CH_BASE-2*CH_HIGHT-40；
st＝CH_HIGHT/10；
for(i＝0；i＜3；i++)
<dp n="d192"/>
{
_moveto(10，k-CH_HIGHT)；
_lineto(10，k)；
_lineto(10+real_size，k)；
_moveto(10，k-CH_HIGHT*THRESH)；
_lineto(10+real)size，k-CH_HIGHT*THRESH)；
for(l＝0，j＝1；j＜11；j++)
{l+＝st；
_moveto(
(j＝＝5)？5：((j＝＝10)？0：7)
，k-l)；
_lineto(10，k-l)；
}
k+＝(CH_HIGHT+20)；
}
corr_old.g＝corr_old.r+CH_HIGHT+20；
corr_old.b＝corr_old.g+CH_HIGHT+20；
pos_old＝10；
}
_setcolor(color_num(240，240，240))；
k＝CH_BASE；
_moveto(pos_old，corr_old.b)；
j＝k-(short)(corr.c[2]*CH_HIGHT)；
_lineto((short)(POS)，j)；
corr_old.b＝j；
k-＝(CH_HIGHT+20)；
_moveto(pos_old，corr_old.g)；
j＝k-(short)(corr.c[1]*CH_HIGHT)；
_lineto((short)(POS)j)；
corr_old.g＝j；
k-＝(CH_HIGHT+20)；
_moveto(pos_old，corr_old.r)；
j＝k-(short)(corr.c[0]*CH_HIGHT)；
_lineto((short)(POS)，j)；
corr_old.r＝j；
pos_old＝POS；
}
<dp n="d193"/>
void corr_win_proto(PCT win_source，PCT Proto，SCR_PNT win_size
，short win_step，double CORR_THRESH，
short *StripEnds)；
<dp n="d194"/>
ORIGIN＝PWB
ORIGIN_VER＝2.0
PROJ＝PRT_ANL2
PROJFILE＝PRT_ANL2.MAK
BUILDDIR＝obj
DEBUG＝1
BRFLAGS＝/o obj\$(PROJ).bsc
BSCMAKE＝bscmake
SBRPACK＝sbrpack
NMAKEBSC1＝set
NMAKEBSC2＝nmake
BROWSE＝1
CC＝cl
CFLAGS_G＝/W2/BATCH/FR$*.sbr
CFLAGS_D＝/f/Zi/Od
CFLAGS_R＝/f-/Ot/Oi/Ol/Oe/Og/Gs
CXX＝cl
CXXFLAGS_G＝/AL/W4/G2/D_DOS/BATCH/FR$*.sbr
CXXFLAGS_D＝/f-/Od/FPi87/Zj/DMICI/DSINGLE_WIN
CXXFLAGS_R＝/f-/Ot/Ol/Og/Oe/Oi/FPi87/Gs/DMICI/DSINGLE_WIN
MAPFILE_D＝NUL
MAPFILE_R＝NUL
LFLAGS_G＝/NOI/STACK：32000/BATCH/ONERROR：NOEXE
LFLAGS_D＝/CO/FAR/PACKC
LFLAGS_R＝/EXE/FAR/PACKC
LINKER＝link
ILINK＝ilink
LRF＝echo＞NUL
ILFLAGS＝/a/e
LLIBS_G＝graphics lafxcr
CVFLAGS＝/25/S
RUNFLAGS＝..\win4\s160_0 corrthr.06
PACK_SBRS＝1
FILES＝PRT_ANL2.CPP..\LIB\VICALLOC.CPP..\LIB\PROJCTN7.CPP\
..\LIB\PIC_M7.CPP..\LIB\RES_MCH7.CPP PRT_2MD.CPP
OBJS＝obj\PRT_ANL2.obj obj\VICALLOC.obj obj\PROJCTN7.obj
obj\PIC_M7.obj\
obj\RES_MCH7.obj obj\PRT_2MD.obj
SBRS＝obj\PRT_ANL2.sbr obj\VICALLOC.sbr obj\PROJCTN7.sbr
obj\PIC_M7.sbr\
obj\RES_MCH7.sbr obj\PRT_2MD.sbr
all：obj\$(PROJ).exe
.SUFFIXES：
.SUFFIXES：
.SUFFIXES：.obj.sbr.cpp
<dp n="d195"/>
obj\PRT_ANL2.obj：PRT_ANL2.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\string.h C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\time.h
C：\C700\INCLUDE\ctype.h\
C：\C700\INCLUDE\fstream.h C：\C700\MFC\INCLUDE\afx.h prt anls.h\
PIC_PRO.h C：\C700\INCLUDE\iostream.h
C：\C700\MFC\INCLUDE\afx.inl\
..\LIB\projctn7.h ..\LIB\pic_mch7.h ..\LIB\res_mch7.h\
c：\ilya\lib\lin_trn7.h C：\C700\INCLUDE\direct.h
C：\C700\INCLUDE\ios.h\
C：\C700\INCLUDE\streamb.h C：\C700\INCLUDE\istream.h\
C：\C700\INCLUDE\ostream.h C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\vmemory.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\PRT_ANL2.obj PRT_ANL2.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PRT_ANL2.obj PRT_ANL2.CPP
＜＜
！ENDIF
obj\PRT_ANL2.sbr：PRT_ANL2.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\conio.h C：\C700\INCLUDE\stdio.h\
C：\C700\INCLUDE\string.h C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\time.h
C：\C700\INCLUDE\ctype.h\
C：\C700\INCLUDE\fstream.h C：\C700\MFC\INCLUDE\afx.h prt_anls.h\
PIC PRO.h C：\C700\INCLUDE\iostream.h
C：\C700\MFC\INCLUDE\afx.inl\
..\LIB\projctn7.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
c：\ilya\lib\lin_trn7.h C：\C700\INCLUDE\direct.h
C：\C700\INCLUDE\ios.h\
C：\C700\INCLUDE\streamb.h C：\C700\INCLUDE\istream.h\
C：\C700\INCLUDE\ostream.h C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\vmemory.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PRT_ANL2.sbr PRT_ANL2.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
<dp n="d196"/>
$(CXXFLAGS_R)/FRobj\PRT_ANL2.sbr PRT_ANL2.CPP
＜＜
！ENDIF
obj\VICALLOC.obj：..\LIB\VICALLOC.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\malloc.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\VICALLOC.obj..\LIB\VICALLOC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\VICALLOC.obj..\LIB\VICALLOC.CPP
＜＜
！ENDIF
obj\VICALLOC.sbr：..\LIB\VICALLOC.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\malloc.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\VICALLOC.sbr..\LIB\VICALLOC.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\VICALLOC.sbr..\LIB\VICALLOC.CPP
＜＜
！ENDIF
obj\PROJCTN7.obj：..\LIB\PROJCTN7.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h
..\LIB\projctn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\PROJCTN7.obj..\LIB\PROJCTN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PROJCTN7.obj..\LIB\PROJCTN7.CPP
<dp n="d197"/>
＜＜
！ENDIF
obj\PROJCTN7.sbr：..\LIB\PROJCTN7.CPP C：\C700\INCLUDE\graph.h\
C：\C700\INCLUDE\stdlib.h C：\C700\INCLUDE\iostream.h
..\LIB\projctn7.h\
C：\C700\INCLUDE\ios.h C：\C700\INCLUDE\streamb.h\
C：\C700\INCLUDE\istream.h C：\C700\INCLUDE\ostream.h\
C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PROJCTN7.sbr..\LIB\PROJCTN7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PROJCTN7.sbr..\LIB\PROJCTN7.CPP
＜＜
！ENDIF
obj\PIC_M7.obj：..\LIB\PIC_M7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\graph.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\io.h C：\C700\INCLUDE\fcntl.h
C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\malloc.h..\LIB\phdr.h\
..\LIB\vicalloc.h..\LIB\pic_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\projctn7.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\PIC_M7.obj..\LIB\PIC_M7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PIC_M7.obj..\LIB\PIC_M7.CPP
＜＜
！ENDIF
obj\PIC_M7.sbr：..\LIB\PIC_M7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\graph.h
C：\C700\INCLUDE\math.h\
C：\C700\INCLUDE\io.h C：\C700\INCLUDE\fcntl.h
C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\float.H C：\C700\INCLUDE\malloc.h..\LIB\phdr.h\
..\LIB\vicalloc.h..\LIB\pic_mch7.h C：\C700\INCLUDE\vmemory.h\
..\LIB\projctn7.h
<dp n="d198"/>
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PIC_M7.sbr..\LIB\PIC_M7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PIC_M7.sbr..\LIB\PIC_M7.CPP
＜＜
！ENDIF
obj\RES_MCH7.obj：..\LIB\RES_MCH7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
C：\C700\INCLUDE\graph.h..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\RES_MCH7.obj..\LIB\RES_MCH7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\RES_MCH7.obj..\LIB\RES_MCH7.CPP
＜＜
！ENDIF
obj\RES_MCH7.sbr：..\LIB\RES_MCH7.CPP C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\vmemory.h..\LIB\pic_mch7.h..\LIB\res_mch7.h\
C：\C700\INCLUDE\graph.h..\LIB\projctn7.h C：\C700\INCLUDE\math.h
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\RES_MCH7.sbr..\LIB\RES_MCH7.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\RES_MCH7.sbr..\LIB\RES_MCH7.CPP
＜＜
！ENDIF
obj\PRT_2MD.obj：PRT_2MD.CPP C：\C700\INCLUDE\io.h
C：\C700\INCLUDE\iostream.h\
C：\C700\INCLUDE\fstream.h prt_anls.h PIC_PRO.h
C：\C700\INCLUDE\ios.h\
C：\C700\INCLUDE\streamb.h C：\C700\INCLUDE\istream.h\
C：\C700\INCLUDE\ostream.h..\LIB\projctn7.h..\LIB\pic_mch7.h\
..\LIB\res_mch7.h c：\ilya\lib\lin_trn7.h C：\C700\INCLUDE\stdlib.h\
<dp n="d199"/>
C：\C700\INCLUDE\direct.h C：\C700\MFC\INCLUDE\afx.h\
C：\C700\INCLUDE\math.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\graph.h C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\time.h\
C：\C700\MFC\INCLUDE\afx.inl
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Foobj\PRT_2MD.obj PRT_2MD.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Foobj\PRT_2MD.obj PRT_2MD.CPP
＜＜
！ENDIF
obj\PRT_2MD.sbr：PRT_2MD.CPP C：\C700\INCLUDE\io.h
C：\C700\INCLUDE\iostream.h\
C：\C700\INCLUDE\fstream.h prt_anls.h PIC_PRO.h
C：\C700\INCLUDE\ios.h\
C：\C700\INCLUDE\streamb.h C：\C700\INCLUDE\istream.h\
C：\C700\INCLUDE\ostream.h..\LIB\projctn7.h..\LIB\pic_mch7.h\
..\LIB\res_mch7.h c：\ilya\lib\lin_trn7.h C：\C700\INCLUDE\stdlib.h\
C：\C700\INCLUDE\direct.h C：\C700\MFC\INCLUDE\afx.h\
C：\C700\INCLUDE\math.h C：\C700\INCLUDE\vmemory.h\
C：\C700\INCLUDE\graph.h C：\C700\INCLUDE\string.h\
C：\C700\INCLUDE\stdio.h C：\C700\INCLUDE\time.h\
C：\C700\MFC\INCLUDE\afx.inl
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FRobj\PRT_2MD.sbr PRT_2MD.CPP
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FRobj\PRT_2MD.sbr PRT_2MD.CPP
＜＜
！ENDIF
obj\$(PROJ).bsc：$(SBRS)
$(BSCMAKE)@＜＜
$(BRFLAGS)$(SBRS)
＜＜
obj\$(PROJ).exe：$(OBJS)
-$(NMAKEBSC1)MAKEFLAGS＝
<dp n="d200"/>
-$(NMAKEBSC2)$(NMFLAGS)-f $(PROJFILE)obj\$(PROJ).bsc
！IF $(DEBUG)
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
$(MAPFILE_D)
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_D：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_D)；
＜＜
！ELSE
$(LRF)@＜＜obj\$(PROJ).lrf
$(RT_OBJS：＝+^
)$(OBJS：＝+^
)
$@
$(MAPFILE_R)
$(LIBS：＝+^
)+
$(LLIBS_G：＝+^
)+
$(LLIBS_R：＝+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_R)；
＜＜
！ENDIF
$(LINKER)@obj\$(PROJ).lrf
.cpp.obj：
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_D)/Fo$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/c $(CXXFLAGS_G)
$(CXXFLAGS_R)/Fo$@$＜
＜＜
！ENDIF
.cpp.sbr：
<dp n="d201"/>
！IF $(DEBUG)
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_D)/FR$@$＜
＜＜
！ELSE
@$(CXX)@＜＜obj\$(PROJ).rsp
/Zs $(CXXFLAGS_G)
$(CXXFLAGS_R)/FR$@$＜
＜＜
！ENDIF
run：obj\$(PROJ).exe
obj\$(PROJ).exe $(RUNFLAGS)
debug：obj\$(PROJ).exe
CV$(CVFLAGS)obj\$(PROJ).exe$(RUNFLAGS)
<dp n="d202"/>
#ifndef PIC_PRO
#define PIC_PRO
#include ＜stdlib.h＞
#include ＜direct.h＞
#include ＜afx.h＞
#include ＜pic_mch7.h＞
//===================================================
CString MakeName(char *p)；
CString MakeName(CString N)；
//===================================================
=======
const SCR_PNT z_0(0，0)；
class PRT：public PCT
{public：
//information
CString PathName；
CString FRAME_Number；
CString STRING_name；
CString SIGN_name；
short Pos；//Position in the string
long NumberOfChk，MaxNum；
double *Charact；
//models
PRT∷-PRT()
{this-＞free_PCT()；
Pos=0；
if(MaxNum)
delete Charact；
Charact=NULL；
MaxNum=NumberOfChk=0；
}
//----------------------------------
PRT∷PRT()
{NumberOfChk=MaxNum=s_cols=s_rows=0；
Charact=NULL；pict=NULL；
}
//---------------------------------------------
PRT∷PRT(short n_cols，short n_rows)
{*(PCT*)this=PCT∷PCT(n_cols，n_rows)；
NumberOfChk=MaxNum=0；
Charact=NULL；
}
//===================================================
int read_proto_SGN()
{
CString new_name(′′，80)；
PathName=MakeName(PathName)；
<dp n="d203"/>
new_name=PathName+＂.sgn＂；
char now[80]；
FILE *datfp；
if(!(datfp=fopen((const char*)new_name，＂r＂)))return 1；
if(fscanf(datfp，＂％*[^\n]s＂)==EOF)goto ERR；
if(fscanf(datfp，＂％s＂，now)==EOF)goto ERR；
if(fscanf(datfp，＂％s＂，now)==EOF)goto ERR；
if(fscanf(datfp，＂％s＂，now)==EOF)goto
ERR；FRAME_Number=now；
if(fscanf(datfp，＂％s＂，now)==EOF)goto
ERR；STRING_name=now；
if(fscanf(datfp，＂％s＂，now)==EOF)goto ERR；SIGN_name=now；
FRAME_Number.MakeUpper()；
STRING_name.MakeUpper()；
SIGN_name.MakeUpper()；
fclose(datfp)；
return 0：
ERR：fclose(datfp)；return 1；
}
//===========================================================================
int proto_storage_rgb(char *name，struct_videoconfig vc)
{*(PCT*)this=sign_storage_rgb(name，vc)；
if (!s_cols)return 1；
PathName=MakeName(name)；
if(read_proto_SGN())
{free_PCT()；
return 1；
}
return 0；
}
//-----------------------------------------------
int read_proto_DBC(FILE *datfp)
{
char now[80]；
if(fscanf(datfp，＂％s＂，now)==EOF)goto
ERR；PathName=MakeName(now)；
if(fscanf(datfp，＂％s＂，now)==EOF)goto
ERR；FRAME_Number=now；
if(fscanf(datfp，＂％s＂，now)==EOF)goto
ERR；STRING_name=now；
if(fscanf(datfp，＂％s＂，now)==EOF)goto ERR；SIGN_name=now；
if(fscanf(datfp，＂％d＂，&(this-＞s_cols))==EOF)goto ERR；
FRAME_Number.MakeUpper()；
STRING_name.MakeUpper()；
SIGN_name.MakeUpper()；
return 1；
ERR：return 0；
}
<dp n="d204"/>
//============================================================
===
int alloc_Charact_dbl(long Num)
{
if(!(Charact=new double[Num]))return 1；
MaxNum=Num；NumberOfChk=0；
return 0；
}
//---------------------------------------------
void free_Charact()
{delete Charact；
Charact=NULL；
}
//--------------------------------------------
int read_Charact_dbl(FILE *inp，long Num)
{short i；
double d；
if(MaxNum＜(NumberOfChk+Num))return 1；
for(i=0；i＜Num；i++)
{if(fscanf(inp，＂％If＂，&d)==EOF)return 1；
if(fabs(d)＜1.0e-4)d=0；
Charact[NumberOfChk]=d；
NumberOfChk++；
}
return 0；
}
//----------------------------------------------
double ConValue(short WNum，short Pnum)
{return (*(Charact+(long)WNum*s_cols+Pnum))；
}
//----------------------------------------------
}；
//==================================================================
#define UnKnown-1
//==================================================================
=
typedef struct
{short n；//voiting numbers
short pos；//position in string
double value；//value
}RSLT；
//----------------------------------------------
void HistCollect(short NOfWin，short St，short Fin，PRT &Db)；
RSLT LineEstimation(short TagSize，PRT &Db，short NOfWin，
short WSize，double Thr)；
int Linelnf(const PRT &P，PRT T，short rw，short Xpos，struct_videoconfig vc)；
double Linlnter(PRT &P，short WNum，short WSize，double Pt)；
<dp n="d205"/>
void HistThresh(short*H，short*BotThr，short*TopThr，short num)；
#endif
<dp n="d206"/>
#ifndef DECISION
#define DECISION
#include ＜iostream.h＞
#include ＂PIC_PRO.h＂
#define UnKnown -1
//===================================================================
=
typedef struct
{short n；//voiting numbers
short pos；//position in string
double value；//value
} RSLT；
//-----------------------------------------------
void HistThresh(short *H，short *BotThr，short *TopThr，short num)
void HistCollect (short **His，short NOfWin，PRT &Db)；
RSLT LineEstimation(short TagSize，PRT Db，short NOfWin，
short WSize，double Thr)；
int WriteLinelnf(PRT &P，PRT T，short rw，short Xpos)；
<dp n="d207"/>
#ifndef LNS_CORR
#define LNS_CORR
#include ＂projctn7.h＂
#include ＂Pic_mch7.h＂
#include ＂res_mch7.h＂
#include ＂lin_tm7.h＂
//#include ＂tem_plf7.h＂
#define NAME_LENGTH 40
#define GRAPHMODE _VRES256COLOR
#define HistDim 101
#endif
<dp n="d208"/>
// PRT_ANLS
// Module analyses file PROTO_1.dbc(output of LNS_CORR)，
//calculates histogramme functions of PROTO_1 in file PROTO_1.hs2.
//Bisides that it asks a possibilites to connect PROTO_1
//with another sign in one strip.
//
//COMMAND STRING
//
//prt_anls ＜PROTO_1_Name＞[CommandFile]
//
// ＜PROTO_1_Name＞ File name of PROTOTYPE without
extention
// [CommandFile] Optional ASCI file with a run time parameters.
//
//INPUT
// .DBC，.RGB files of prototypes and corresponding .SGN files created
by
//modules LNS_CORR and MAKEPRB.
//RUN TIME parameters：
//
// ＜CORR_THR＞ threshold for sign linking
// We have used 0.6；
// If cross correlation axceede the＜CORR_THR＞the number of
// string will be asked.Negative number cause not including the
// connection in list.
//SEE ALSO FILE＂PRT ANLS.INI＂
//OUTPUT
// PROTO_1.HS2 - Histogramme；
// LINECOL.PRT-File collects an information about sign linking
// in accordance with＜CORR_THR＞and our response.
// FILE structure：
//(example file string start after char # that not belongs to file
//*****0 pos in str**************************************************
// #LineCollection
// #Line # FName #1 FName #2 Pos ...
// #1 c：\ilya\winps\s160_0 c：\ilya\winps\s160_6 18
// #1 c：\ilya\winps\s160_0 c：\ilya\winps\s160_15 37
//EOF
//Here 1 Line number named through the keyboard
//....s160_0-PROTO_1 name；
//....s160_6 and s160_15 name of prototypes linked with a PROTO_1
// in one strip；
//18 and 37 positions of corresponding prototypes start relative to
//0 colomn of PROTO_1(PROTO_1 STARTS in 0 colormn of PROTO_1)
#include ＜stdlib.h＞
#include ＜conio.h＞
#include ＜stdio.h＞
#include ＜string.h＞
<dp n="d209"/>
#include ＜graph.h＞
#include ＜float.H＞
#include ＜time.h＞
#include ＜ctype.h＞
#include ＜fstream.h＞
#include ＜afx.h＞
#include ＂prt_anls.h＂
#include ＂PIC_PRO.h＂
#define MaxNumOfPicks 20
const short MaxNumOfWin=25；
#define MaxProtNum 25
short Hist[MaxNumOfWin][HistDim]；
char LineColName[]=＂linecol.prt＂；
char f_name[40]=＂_＂，FILE_name[40]=＂_＂， FRAME_Name[40]=＂_＂，
STRING_name[40]＝＂_＂，SIGN_name[40]=＂_＂；
double GAMMA=1.0，CORR_THRESH=0.0，Thresh_mdl=0.0；
short MAP；
short VOITING=3，TAG_hight；
struct_videoconfig vc；
double sh[4]={0，0，0，0}；
int get_number_4()；//INITIALISATION GRAPHICMODE，GET SCALE
int get_number_4_f(FILE *f)；//INITIALISATION GRAPHICMODE，GET
SCALE
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$
CString PROTOCOL_NAME；
fstream LineC；
//============= OpenLineCollection
void OpenLineCol(const char*name)
{ LineC.open(name，ios∷outlios∷applios∷outlios∷noc，eate)；
if(LineC.fail())
{LineC.clear(0)；
LineC.open(name，ios∷outlios∷applios∷outlios∷noreplace)；
if(LineC.fail())
{LineC.clear(0)：
cout＜＜＂CAN NOT OPEN LineCollection＂；
GRAPH_OUT(-1)；
}
}
}
//======================================================================
===
SCR_PNT winsize；
<dp n="d210"/>
//===========================================================
======
int main(int argc，char* argv[])
{
int FLG_F=0；
FILE *da；ainf；
short n=0；
SCR_PNT t_pos；
if((argc !=2)&&(argc !=3))
{
printf(＂proto_file\n＂)；
FLG_F=0；
return(1)；
}
else
if(argo==3)
{FLG_F=1；
if(!(datainf=fopen(argv[2]，＂r＂)))return 0；
}
if(FLG_F)
get_number_4_f(datainf)；//GET SCALE
else
get_number_4()；
PRT prototype；
//=============== GRAPHICS START
if(GRAPHICS_START(&vc，GRAPHMODE))GRAPH_OUT(-1)；
//
if(prototype. proto_storage_rgb(argv[1]，vc))
{printf(＂SGN TARGET not exist＂)；GRAPH_OUT(-1)；
}
//READ .DBC FILE AND STORED Correlation Function
//========= PROTOTYPE LOOP OVER DBASE .dbc
PRT DbProto[MaxProtNum]；
CStnng DbName=argv[1]；
DbName+=＂.dbc＂；
FILE *Db=fopen((const char *)DbName，＂r＂)；
if(!Db)
{printf(＂DBase not exist＂)； GRAPH_OUT(-1)；}
//DEBUG Split two rows
short WinSize；
char AA [128]，SPACE[14]；
fscanf(Db.＂％[^\n]s＂，AA)；
fscanf(Db.＂％[^\n]s＂，AA)；
fscanf(Db.＂％*s ％*s ％*s ％*s ％*s ％d ％s＂，&WinSize，SPACE)；
const MaxNumberOfWin=30；
short NumberOfWin=0；//=prototype.s_cols/WinSize；
<dp n="d211"/>
short iDbProto=0；
fscanf(Db.＂％[^\n]s＂，AA)；
short i，j；
while(DbProto[iDbProto].read_proto_DBC(Db))
{
if(DbProto[iDbProto].alloc_Charact_dbl(MaxNumberOfWin*DbProto[iDbProto]
.s_cols))
{printf(＂NOT MEMORY for datat＂)；GRAPH_OUT(-1)；}
fscanf(Db，＂％[^\n]s＂，AA)； //DEBUG Split one row
while(!feof(Db))
{
NumberOfWin++；
if(DbProto[iDbProto]read_Charact_dbl(Db，DbProto[iDbProto].s_cols))
{printf(＂END of DB＂)；GFAPH_OUT(-1)；}
fscanf(Db，＂％[^\n]s＂，AA)；//DEBUG Split one row
}
iDbProto++；
}
fclose(Db)；
//END READ .DBC FILE AND STORED Correlation Function
OpenLineCol(LineColName)；
LineC＜＜ ＂LineCollection \nLine #\t FName #1\t FName #2\t Pos ... \n＂；
//LOOP over targets
int LN，p；
RSLT LineEst；
short St. Fin；
for(i=0：i＜MaxNumOfWin；i++)
for (j=0；j＜HistDim；Hist[i][j++]=0)；
//Miki′s Threshold
short PrNumber=-1；
for(i=0；i＜iDbProto；i++)
if(DbProto[i].PathName==prototype. PathName)
{PrNumber=i；break；}
//IF AutoCorr absence PrNumber=-1
//Line linking and noise calculation
for(i=0：i＜iDbProto；i++)
{St=0；
Fin=DbProto[i].s_cols；
if(i!=PrNumber)
{LineEst=LineEstimation(prototype.s_cols，DbProto[i]，NumberOfWin，
WinSize，CORR_THRE
SH)；
if(LineEst.n)
{
p=LineEst. pos-DbProto[i].s_cols；//DbProtoStart
<dp n="d212"/>
LN=LineInf(prototype，DbProto[i]，vc.numtextrows，p+10，vc)；
if(LN＞=0)
{if(p＞0)
St=prototype.s_cols-p；
else
Fin=-p；
LineC＜＜LN＜＜′\t′＜＜prototype.PathName＜＜′\t′＜＜
DbProto[i].PathName＜＜′\t′＜＜p＜＜′\n′；
}
}
}
//Histogramm calculation
HistCollect(NumberOfWin，St，Fin，DbProto[i])；
}
LineC.close()；
//RESULT OUT
PROTOCOL_NAME=argv[1]；
PROTOCOL_NAME+=＂.hs2＂；
OpenLineCol((const char*)PROTOCOL_NAME)；
LineC＜＜＂Histogrammes\n＂；
LineC＜＜argv[1]＜＜＂\t＂＜＜prototype.SIGN_name＜＜′\n′；
LineC＜＜＂NumberOfWindows\t＂＜＜NumberOfWin＜＜′\n′；
LineC＜＜＂NumberOfBins\t＂＜＜HistDim＜＜′\n′；
LineC＜＜＂Win_pose\n＂；
for(j=0；j＜NumberOfWin；j++)
{LineC＜＜j*WinSize＜＜＂\t＂；
for(i=0；i＜HistDim；i++)
LineC＜＜Hist[j][i]＜＜＂\t＂；
LineC＜＜′\n′；
}
LineC.close；
//CORRELATION PROCESSING
GRAPH_OUT()；
return(0)：
}
//
=========================================================================
=========
/*void gei_shift_f(FILE *f，double * sh)//INITIALISATION GRAPHICMODE，
GET SCALE
{iht i；
fo*(i=0；i＜4；i++)
{
fscanf(f，＂％If ％If\n＂，sh+i++，sh+i)；
}
}
<dp n="d213"/>
//
=============================================================================
===========
void get_shift(double * sh)//INITIALISATION GRAPHICMODE，GET SCALE
{int i；
cout＜＜＂vertexes shift over rows(top_right，bottom_right，bottom_left，
top_left ％\n＂；
for(i=0；i＜4；i++)
cin＞＞sh[i]；
}*/
//===========================================================================
=============
int get_number_4()//INITIALISATION GRAPHICMODE，GET SCALE
{int R；
GRAPH_OUT()；
cout＜＜＂CORR_THRESH \n＂；
cin＞＞CORR_THRESH；
//================ GRAPHICS START
if(GRAPHICS_START(&vc，GRAPHMODE))GRAPH_OUT(-1)；
//================
return R；
}*****************
//****************
int get_number_4_f(FILE *f)//INITIALISATION GRAPHICMODE，GET
SCALE
{
fscanf(f，＂％If＂，&CORR_THRESH)；
return 1；
}
//============================================================================
/*int picture_inf_num_new(char *name，SCR_PNT *vertexes，short n)
{int i，j；
char new_str[80]；
FILE *datfp；
int r.FLG=0；
strcat(strcpy(new_str，name)，＂.sgn＂)；
if(!(catfp=fopen(new_str，＂r＂)))return 0；
r=fscanf(datfp，＂％[^\n]s＂，new_str)；
r=fscanf(datfp，＂％[^\n]s＂，new_str)；
if(_iscsymf((int)new_str[0]))//FILE INFORMATION)
//(letter or underscore)
{sscanf(new_str，＂％s ％s ％s ％s＂，&FILE_name，&FRAME_Name，
&STRING_name，&SIGN_name)；
r＝fscanf(datfp，＂％[^\n]s＂，new_str)；
}
for(j=0；j＜n+1；j++)
for(i=0；i＜4；i++)
{if(FLG)
if(fscanf(datfp，＂％[^\n]s＂，new_str)==EOF)
<dp n="d214"/>
{fclose(datfp)；return 0；}
FLG=1；
sscanf(new_str，＂％d ％d＂，&(vertexes[i].c)，&(vertexes[i].r))；
}
fclose(datfp)；
return 1；
}*/
//===========================================================================
<dp n="d215"/>
#include ＜io.h＞
#include ＜iostream.h＞
#include ＜fstream.h＞
#include ＂prt_anls.h＂
#include ＂PIC_PRO.h＂
extem const short MaxHistSize；
extem const short MaxNumOfWin；
extem short Hist[][HistDim]；
#define Histogramm(i，x)(Hist[(i)][(short)(0.5*((x)+1)*(HistDim-1)+0.5)]++)
//===========================================================================
===
void HistCollect(short NOfWin，short St，short Fin，PRT &Db)
{short i，j；
double val；
for(i=0；i＜NOfWin；i++)
for(j=St；j＜Fin；j++)
{
val=Db.CorrValue(i，j)；
Histogramm(i，val)；
}
}
//======================================================================
=
RSLT LineEstimation(short TagSize，PRT &Db，short NOfWin，short
WSize，double Thr)
{RSLT out={0，-1，0.0}；
short i.j.EndPosDb=0，k；
double *DMF=new double[k=Db.s_cols+TagSize]；
for(i=0；i＜k；DMF[i++]=0.0)；
double val；
for(i=0：i＜NOfWin；i++)
for(j=0；j＜Db.s_cols；j++)
{
val=Db.CorrValue(i，j)；
if，(val＞Thr)
{EndP osDb=i*WSize-j+Db.s_cols；
DMF[EndPosDb]+=val；
out.n++；
}
}
if(out.n)
for(i=0：i＜k；i++)
if(out.value＜DMF[i])
{out.value=DMF[i]；
out.pos=i；
}
delete DMF；
<dp n="d216"/>
return out；
}
//=============================================================================
====
int Linelnf(const PRT &P，PRT T，short rw，short Xpos，struct_videoconfig vc)
{SCR_PNT PR(10，10)，TG(0，18)；
char mess[80]=＂LineNum [＜0] UnKnown＂；
int out=UnKnown；
TG.c=Xpos；
_settextposition(rw，1)；
*((PCT*)&T)=
sign_storage_rgb((const char*)(T.PathName)，vc)；
if(T.s_cols)
{_setcolor(color_num(0，0，0))；
_rectangle(_GFILLINTERIOR，0，0，680，60)；
sign_present_RGB(P，PR)；
sign_present_RGB(T，TG)；
T.free_PCT()；
_setcolor(color_num(240，240，240))；
_outtext(mess)；
cin＞＞out；
}
else
{
sprintf(mess，＂％s from ％s RGB UNAGCESIBLE＂，
(const char*)(P.SIGN_name)，
(const char*)(T.STRING_name))；
_outtext(mess)；
}
return out；
}
///=============================================================================
========
double CorVal(PRT &P，short WNum，short y)
{double v1；
if(y＜0)v1=P.CorrValue(WNum，0)；
else{if(y＞=P.s_cols)v1=P.CorrValue(WNum，P.s_cols-1)；
else v1=P.CorrValue(WNum，(short)y)；
}
return v1；
}
//=============================================================================
===============
#define VALUE(X)((X)＜(P.s_cols-WSize))?CorVal(P，WNum，
(X))：CorVal(P，WNum，(X-1))
//=============================================================================
======
double Linlnter(PRT &P，short WNum，short WSize，double Pt)
{double y1，y0，x=WNum*WSize+Pt；
<dp n="d217"/>
short x1，x0；
x0=(short)x；
x1=(x0＞x)?x0-1：x0+1；
y1=CorVal(P，WNum，x1)；
y0=CorVal(P，WNum，x0)；
return(y0+(x-x0)*(y1-y0)/(x1-x0))；
}
//============================================================================
==========
void HistThresh(short *H，short *BotThr，short *TopThr，short num)
{short S=0；
*BotThr=0；
*TopThr=-HistDim-1；
while((S+=H[(*ropThr)-])＜num)；
S=0；
while((S+=H[(*BotThr)++])＜num)；
}
//==============================================================================
CString MakeName(CString N)
{
short k=(N.Spanlncluding(＂\t＂)).GetLength()；
char *p，fp[80]；
p=((char*)(const char *)N)+k；
CString M=p；
if(M.Find(′：′)＜0)
{if(M.GetAt(0)==′\\′)
{M=′：′+M；
M=(char)(_getdrive()-1+′A′)+M；
}
else
M=_fullpath(fp，(const char*)M，80)；
}
M.MakeLower()；
return M：
}
CString MakeName(char *p)
{CString M(p)；
return(MakeName(M))；
}
//=================================================================================
=======================
<dp n="d218"/>
ORIGIN=PWB
ORIGIN_VER=2.1.49
PROJ=TRACK
PROJFILE=TRACK.MAK
DEBUG=1
NMAKEBSC1=set
NMAKEBSC2=nmake
CC=cl
CFLAGS_G=/AL/W2/G2/GA/DMSC/DMFG_/DWIN/DPAS/DDLL/GEf
/Zp/BATCH\
/FR$*.sbr
CFLAGS_D=/f-/Od/FPi87/Zi/Gs
CFLAGS_R=/f-/Os/Og/Oe/FPi87/Gs
CXX=cl
CXXFLAGS_G=/G2/W2/GA/GEf/Zp/BATCH/FR$*.sbr
CXXFLAGS_D=/f/Zi/Od/Gs
CXXFLAGS_R=/f-/Oe/Og/Os/Gs
MAPFILE_D=NUL
MAPFILE_R=NUL
LFLAGS_G=/STACK：16000/BATCH/ONERROR：NOEXE
LFLAGS_D=/CO/NOF
LFLAGS_R=/NOF
LLIBS_G=c：\c700\windev\lib\LIBW.LIB c：\c700\windev\lib\commdlg.lib\
c：\visnplus\lib\win_ai.lib c：\visnplus\lib\nfgmm.lib\
c：\visnplus\lib\iffdll.lib
LINKER=link
ILINK=ilink
LRF=echo＞NUL
ILFLAGS=/a/e
RC=rc-K
LLIBS_R=/NOD：LLIBC7 LLIBC7W
LLIBS_D=LLIBCEW/NOD：LLIBC7
BRFLAGS=/o $(PROJ).bsc
BSCMAKE=bscmake
SBRPACK=sbrpack
BROWSE=1
PACK_SBRS=1
<dp n="d219"/>
FILES=BITMAP.C MIN_MAG.C PERSP.C TRACK C TRACK DEF
TRACK.RC LIB.C LINES. C\
QRSOLV.C
DEF_FILE=TRACK DEF
OBJS=BITMAP.obj MIN_MAG.obj PERSP.obj TRACK obj LIB.obj
LINES.obj\
QRSOLV.obj
RESS=TRACK res
SBRS=BTTMAP.sbr MIN_MAG.sbr PERSP.sbr TRACK.sbr LIB.sbr
LINES.sbr\
QRSOLV.sbr
all：$(PROJ).exe
.SUFFIXES：
.SUFFIXES：
.SUFFIXES：.obj .sbr .res .c .rc
BITMAP.obj：BITMAP.C const.h bitmap.h lines.h track.h min_mag.h lib.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_D)/FoBITMAP.obj BITMAP.C
＜<
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_R)/FoBITMAP.obj BITMAP.C
＜＜
!ENDIF
BITMAP.sbr：BITMAP.C const.h bitmap.h lines.h track.h min_mag.h lib.h
!IF $(DEBUG)
@$(CC) @＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_D)/FRBITMAP.sbr BITMAP.C
＜＜
<dp n="d220"/>
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_R)/FRBITMAP.sbr BITMAP.C
＜＜
!ENDIF
MIN_MAG.obj：MIN_MAG.C const.h bitmap.h lines.h track.h persp.h
min_mag.h\
lib.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_D)/FoMIN_MAG.obj MIN_MAG.C
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_R)/FoMIN_MAG.obj MIN_MAG.C
＜＜
!ENDIF
MIN_MAG.sbr：MIN_MAG.C const.h bitmap.h lines.h track.h persp.h
min_mag.h\
lib.h
!IF $(DEBUG)@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_D)/FRMIN_MAG.sbr MIN_MAG.C
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_R)/FRMIN_MAG.sbr MIN_MAG.C
＜＜
!ENDIF
<dp n="d221"/>
PERSP.obj：PERSP.C const.h bitmap.h lines.h track.h persp.h min_mag.h
lib.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_D)/FoPERSP.obj PERSP.C
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_R)/FoPERSP.obj PERSP.C
＜＜
!ENDIF
PERSP.sbr：PERSP.C const.h bitmap.h lines.h track.h persp.h min_mag.h
lib.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_D)/FRPERSP.sbr PERSP.C
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_R)/FRPERSP.sbr PERSP.C
＜＜
!ENDIF
TRACK obj：TRACK C const.h bitmap.h persp.h lines.h track.h min_mag.h
lib.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_D)/FoTRACK.obj TRACK.C
＜＜
!ELSE
@s(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
<dp n="d222"/>
$(CFLAGS_R)/FoTRACK.obj TRACK.C
＜＜
!ENDIF
TRACK.sbr：TRACK C const.h bitmap.h persp.h lines.h track.h min_mag.h
lib.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_D)/FRTRACK.sbr TRACK.C
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_R)/FRTRACK.sbr TRACK.C
＜＜
!ENDIF
TRACK.res：TRACK RC track.h frames.dlg
$(RC)$(RCELAGS1)/r/fo TRACK.res TRACK.RC
LIB.obj：LIB.C const.h bitmap.h persp.h lines.h track.h min_mag.h lib.h
!IF $(DEBUG)
@$(CC)@＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_D)/FoLIB.obj LIB.C
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_R)/FoLIB.obj LIB.C
＜＜
!ENDIF
LIB.sbr：LIB.C const.h bitmap.h persp.h lines.h track.h min_mag.h lib.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
<dp n="d223"/>
$(CFLAGS_D)/FRLIB.sbr LIB.C
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_R)/FRLIB.sbr LIB.C
＜＜
!ENDIF
LINES.obj：LINES.C const.h bitmap.h persp.h lines.h track.h min_mag.h lib.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_D)/FoLINES.obj LINES.C
＜＜
!ELSE
@$(CC) @＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_R)/FoLINES.obj LINES.C
＜<
!ENDIF
LINES.sbr：LINES.C const.h bitmap.h persp.h lines.h trackh min_mag.h lib.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_D)/FRLINES.sbr LINES.C
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_R)/FRLINES.sbr LINES.C
＜＜
!ENDIF
QRSOLV.obj：QRSOLV.C qrsolv.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
<dp n="d224"/>
/c $(CFLAGS_G)
$(CFLAGS_D)/FoQRSOLV.obj QRSOLV.C
＜<
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_R)/FoQRSOLV.obj QRSOLV.C
＜＜
!ENDIF
QRSOLV.sbr：QRSOLV.C qrsolv.h
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_D)/FRQRSOLV.sbr QRSOLV.C
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_R)/FRQRSOLV.sbr QRSOLV.C
＜＜
!ENDIF
$(PROJ).bsc：$(SBRS)
$(BSCMAKE)@＜＜
$(BRFLAGS)$(SBRS)
＜＜
$(PROJ).exe：$(DEF_FILE)$(OBJS)$(RESS)
-$(NMAKEBSC1)MAKEFLAGS=
-$(NMAKEBSC2)$(NMFLAGS)-f $(PROJFILE)$(PROJ).bsc
!IF $(DEBUG)
$(LRF)@＜＜$(PROJ).lrf
$(RT_OBJS：=+^
)$(OBJS：=+^
)
$@
<dp n="d225"/>
$(MAPFILE_D)
$(LIBS：=+^
)+
$(LLIBS_G：=+^
)+
$(LLIBS_D：=+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_D)；
＜＜
!ELSE
$(LRF)@＜＜$(PROJ).lrf
$(RT_OBJS：=+^
)$(OBJS：=+^
)
$@
$(MAPFILE_R)
$(LIBS：=+^
)+
$(LLIBS_G：=+^
)+
$(LLIBS_R：=+^
)
$(DEF_FILE)$(LFLAGS_G)$(LFLAGS_R)；
＜＜
!ENDIF
$(LINKER)@$(PROJ).lrf
$(RC)$(RCFLAGS2)$(RESS)$@
.c.obj：
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
$(CFLAGS_D)/Fo$@ $＜
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/c $(CFLAGS_G)
<dp n="d226"/>
$(CFLAGS_R)/Fo$@ $＜
＜＜
!ENDIF
.c.sbr：
!IF $(DEBUG)
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_D)/FR$@ $＜
＜＜
!ELSE
@$(CC)@＜＜$(PROJ).rsp
/Zs $(CFLAGS_G)
$(CFLAGS_R)/FR$@ $＜
＜＜
!ENDIF
.rc.res：
$(RC)$(RCFLAGS1)/r/fo $@ $＜
run：$(PROJ).exe
WX $(WXFLAGS)$(PROJ).exe $(RUNFLAGS)
debug：$(PROJ).exe
WX/p $(WXFLAGS)CVW $(CVFLAGS)$(PROJ).exe $(RUNFLAGS)
<dp n="d227"/>
NAME TRANSFORM
DESCRIPTION ′Changing signs′
EXETYPE WINDOWS
STUB ′WINSTUB.EXE′
CODE PRELOAD MOVEABLE DISCARDABLE
DATA PRELOAD MOVEABLE MULTIPLE
HEAPSIZE 1024
STACKSIZE 8192
<dp n="d228"/>
#include ＜windows.h＞
#include ＂track.h＂
#include ＂frames.dlg＂
trans MENU
{
POPUP ＂File＂
{
MENUITEM ＂Open...＂，IDM_OPEN
MENUITEM ＂Write...＂，IDM_WRITE
}
POPUP ＂&Pick sign＂
{
MENUITEM ＂&Original＂，IDM_PICK_ORIG
MENUITEM ＂&Substitue＂，IDM_PICK_SUBST
MENUITEM ＂&Load Orig＂，IDM_LOAD_ORIG
MENUITEM ＂&Pick Comers＂，IDM_PICK_CORNERS
}
MENUITEM ＂&change sign＂，IDM_CHANGE
POPUP ＂&Method＂
{
MENUITEM ＂&Bilinear＂，IDM_BILINEAR
MENUITEM ＂&Trilinear＂，IDM_TRILINEAR
MENUITEM ＂&SplitMode＂，IDM_SPLIT
}
MENUITEM ＂&Info＂，IDM_INFO
POPUP＂&MFG＂
{
MENUITEM ＂&Init＂ DISP_INIT
MENUITEM ＂&Grab＂ DISP_GRAB
MENUITEM ＂&Snap＂ DISP_SNAP
MENUITEM ＂&Load Pict＂ DISP_LOAD
MENUITEM ＂&Load Field＂ DISP_LOAD_FIELD
MENUITEM ＂&Draw＂ DISP_DRAW
<dp n="d229"/>
MENUITEM ＂&Clean＂ DISP_CLEAN
MENUITEM ＂&Wipe＂ DISP_WIPE
}
MENUITEM ＂&Start track＂，IDM_START_TRACK
MENUITEM ＂&Tracking＂，IDM_AUTO_TRACK
POPUP ＂&V-Disk＂
{
MENUTTEM ＂&Init＂，SONY_INIT
MENUITEM ＂&Go to＂，SONY_FRAME
MENUITEM ＂&Replace＂，SONY_RECORD
MENUITEM ＂&Close＂，SONY_END
}
}
<dp n="d230"/>
frames DIALOG 19，22，126，57
STYLE DS_MODALFRAME|WS_POPUP|WS_VISIBLE|WS_CAPTION|
WS_SYSMENU
CAPTION ＂Edit Frames＂
FONT 8，＂MS Sans Serif＂
BEGIN
LTEXT ＂From Frame＂，101，10，4，48，8
LTEXT ＂To Frame＂，102，10，22，56，8
EDITTEXT 103，67，4，45，13，ES_AUTOHSCROLL
EDITTEXT 104，67，21，45，14，ES_AUTOHSCROLL
PUSHBUTTON ＂OK＂，105，7，39，40，14
PUSHBUTTON ＂Cancel＂，106，72，38，40，14
END
<dp n="d231"/>
long FAR PASCAL_export WndProc(HWND，UINT，UINT，LONG)；
DWORD GetDiblnfoHeaderSize(BYTE huge*)；
int PASCAL GetDibWidth(BYTE huge*)；
int PASCAL GetDibHeight(BYTE huge*)；
BYTE huge* GetDibBitsAddr(BYTE huge*)；
DWORD GetDrawTableSize(BYTE huge*)；
BYTE huge* ReadDib(HWND，char*，int*，int*)；
int PASCAL display_information(HWND)；
int PASCAL teach_grey_pallete(HWND，int)；
BYTE huge* ReadRGB(HWND，char*，int*，int*)；
int PASCAL draw_rgb_picture(HWND，HDC)；
int PASCAL teach_rgb_pallete(HWND)；
int PASCAL get_file_type_by_name(char*)；
int PASCAL create_poly_src_dst()；
int PASCAL keep_subst(HWND，MYBITMAP*)；
BYTE PASCAL get_palette_index(BYTE，BYTE，BYTE)；
int PASCAL WriteGreyRgb(HWND hwnd，char*szFileName，MYBITMAP
*Bmap)；
int PASCAL get_in_series_flag()；
int PASCAL smooth_values(double，double*，double*，int，double*)；
int PASCAL enlarge_area_of_noise(MYBITMAP*，MYBITMAP*)；
#define GREY_MODEL 1
#define COLOR_MODEL 2
#define RGBA_MODEL 3
#define IN_BILINEAR 2
#define IN_TRILINEAR 3
#define FILE_IS_BMP 1
#define FILE_IS_RGB 2
#define FILE_IS_UNKNOWN
#define AF_ZOOM 102
#define AF_ANGLE 104
#define AF_OK 105
#define AF_CANCEL 106
<dp n="d232"/>
#define PER_WIDTH 103
#define PER_HEIGHT 104
#define PER_FROM_TOP 107
#define PER_FROM_BOTTOM 108
#define PER_OK 109
#define PER_CANCEL 110
#define IDM_OPEN 100
#define IDM_PICK 101
#define IDM_CHANGE 104
#define IDM_PERSPECTIVE 102
#define IDM_INFO 103
#define IDM_WRITE 105
#define IDM_PICK_ORIG 106
#define IDM_PICK_SUBST 107
#define IDM_LOAD_ORIG 108
#define IDM_PICK_CORNERS 109
#define IDM_NEAREST 110
#define IDM_BILINEAR 111
#define IDM_TRILINEAR 112
#define IDM_SPLIT 114
#define IDM_START_TRACK 150
#define IDM_AUTO_TRACK 151
#define DISP_SNAP 200
#define DISP_GRAB 201
#define DISP_LOAD 202
#define DISP_DRAW 203
#define DISP_CLEAN 204
#define DISP_WIPE 205
#define DISP_INIT 206
#define DISP_LOAD_FIELD 207
#define IDM_DEBUG 300
<dp n="d233"/>
#define SONY_HEADER 400
#define SONY_FRAME 401
#define SONY_RECORD 402
#define SONY_INIT 403
#define SONY_END 404
#define SONY_FROM_FR 103
#define SONY_TO_FR 104
#define SONY_OK 105
#define SONY_CANCEL 106
typedef struct phdr{
int cols，rows；
int bp；
}PHDR：
typedef BYTE TRIPLE[3]；
typedef struct edge{
double xs，ys；
double xe，ye；
int vertical；
LINE I；
}EDGE：
typedef struct shift{
double dx，dy；
double sim；/* minimal value of sum of abs.diff.(MAD)
maximal value of correlation (COR)*/
}SHIFT：
typedef struct sign{
MYBITMAP *Bmap；
MYBITMAP *BmapGrey；
TRACK_POINTS TrPoints；
}SIGN；
<dp n="d234"/>
#include＜math.h＞
#include＜stdio.h＞
typedef unsigned char byte；
typedef struct{
unsigned long
r：8，
g：8，
b：8，
a：8；
}RGBA
typedef struct{
double x；
double y；
}RPOINT；
typedef struct{
byte r，g，b；
}MYRGB；
typedef enum{
Grey，Rgb，Rgba
}BMTYPE；
typedef struct{
int cols，rows；
BMTYPE typ；
BYTE huge *gpic；
}MYBITMAP；
typedef double LUMARR[7][7]；
#define BITMAP_PLACE(bm，i，j)\
*((BYTE huge*)((bm-＞gpic)+(DWORD)(i)*(DWORD)(bm-
＞cols)+(DWORD)(j)))
#define BITMAP_PLACE_PTR(bm，i，j)\
<dp n="d235"/>
(BYTE huge*)((bm-＞gpic)+(DWORD)(i)*(DWORD)(bm-＞cols)+(DWORD)(j))
#define BITMAP_RGB_PLACE(bm，ij) \
*((BYTE huge*)((bm-＞gpic)+((DWORD)(i)*(DWORD)(bm-
＞cols)+(DWORD)(j))*(DWORD)3))
#define BITMAP_RGB_PLACE_PTR(bm，ij)\
(BYTE huge*)((bm-＞gpic)+((DWORD)(i)*(DWORD)(bm-
＞cols)+(DWORD)(j))*(DWORD)3)
#define MIN(a，b)((a)＜(b)?(a)：(b))
#define MAX(a，b)((a)＞(b)?(a)：(b))
#define DLVLS 3
#define ILVLS 1
#define MAX_NO_OF_TR_WIN 30
typedef struct{
double x，y；
}PNT；
typedef struct{
double Af[3][3]；
double Ab[3][3]；
} Affine_Transform；
typedef struct{
double Pf[3][3]；
double Pb[3][3]；
}Perspective_Transform；
typedef struct track_points{
POINT TrackP[NUM_OF_TRACK_POINTS]；
int NumOfPoints；
}TRACK_POINTS；
typedef struct shift_points{
RPOINT TrackP[NUM_OF_TRACK_POINTS]；
<dp n="d236"/>
int NumOfPoints；
}SHIFT_POINTS；
typedef struct tr_win{
RPOINT Center；
double Xdir；
double Ydir；
}TR_WIN；
MYBITMAP FAR* bm_alloc(int，int，BMTYPE)；
double PASCAL bilinear(double，double，MYBITMAP FAR*)；
double PASCAL bilinear_red(double，double，MYBITMAP FAR*)；
double PASCAL bilinear_green(double，double，MYBITMAP FAR*)；
double PASCAL bilinear_blue(double，double，MYBITMAP FAR*)；
int PASCAL multmat(HWND，int，int，int，double*，double*，double*)；
double PASCAL resample_trilinear(MYBITMAP FAR*
，double，double，double，int)；
double PASCAL resample_trilinear_red(MYBITMAP FAR*
，double，double，double，int)；
double PASCAL resample_trilinear_blue(MYBITMAP FAR*
，double.double，double，int)；
double PASCAL resample_trilinear_green(MYBITMAP FAR*
，double，double，double，int)；
int PASCAL build_pyramid(HWND，MYBITMAP FAR*)；
int PASCAL bm_free(MYBITMAP FAR*)；
int PASCAL create_lum_bmap(MYBITMAP*，MYBITMAP**)；
int PASCAL duplicate_bmap(MYBITMAP*，MYBITMAP**，int)；
int PASCAL create_grey_bounded_bitmap(RECT，MYBITMAP*，MYBITMAP
**)；
int PASCAL substract_bitmaps(RECT，MYBITMAP*，MYBITMAP*，MYBITMAP
**)；
int PASCAL insert_grey_bounded_bitmap(RECT，MYBITMAP*，MYBITMAP
*)；
int PASCAL get_mask_bitmap(HWND，MYBITMAP*，int，MYBITMAP**)；
int PASCAL find_horiz_line(MYBITMAP*，POINT，POINT，RPOINT*)；
int PASCAL find_vertic_line(MYBITMAP*，POINT，POINT，RPOINT*)；
double PASCAL bilinear_rgb(double，double，MYBITMAP FAR*，double*)；
<dp n="d237"/>
int PASCAL copy_grey_rect_fron_frame(MYBITMAP*，MYBITMAP*，RECT)
；
int PASCAL build_alpha_map(MYBITMAP**，MYBITMAP*，RPOINT*)；
int PASCAL split_bitmap(MYBITMAP*，int，int)；
int PASCAL split_bitmap_frame(MYBITMAP*，MYBITMAP**，MYBITMAP**)；
int PASCAL sum_grey_bitmap_value(MYBITMAP*，DWORD*)；
int PASCAL filter_noises_by_rects(MYBITMAP*，RECT，int，int，MYBITMAP
*)；
<dp n="d238"/>
#define VALUE_IN(array，i，j，cols)*(array+(DWORD)(i)*(DWORD)(cols)+(j))
#define X_DIM 1
#define Y_DIM 2
int PASCAL I_cp_int_arr_to_RPOINT(RPOINT*，int*，int*，int)；
int PASCAL I_quad_in_new_origin(RPOINT*，RPOINT*，int，int，int)；
int PASCAL find_extremes_in_1dim(RPOINT*，int，int，double*，double*)；
int PASCAL find_best_cluster(HWND，int，RPOINT*，RPOINT*，int
*，int，int*，int*，
RPOINT*，int*)；
int PASCAL I_copy_RPOINT_array(RPOINT*，RPOINT*，int)；
int PASCAL I_copy_int_array(int*，int*，int)；
int PASCAL I_find_bound_rect(RPOINT*，RECT*)；
int PASCAL print_transform(HFILE，char*，Perspective_Transform*)；
int PASCAL insert_new_vertexes(RPOINT *CurrVert，RPOINT *Vert1，
RPOINT *Vert2，
RPOINT *Vert3，RPOINT *Vert4，double *Wheight，int num，RPOINT
*NewVert)；
int PASCAL transform_rpoint_arr(RPOINT*，RPOINT
*，int，Perspective_Transform)；
<dp n="d239"/>
#define FAC 16
#define LOBES 2
#define FSIZE(LOBES*FAC)
#define CORR_WINDOWX 8
#define CORR_WINDOWY 6
MYBITMAP FAR*minify(HWND，MYBITMAP FAR*，int)；
int PASCAL sinc_filter(int)；
MYBITMAP FAR *hminify(HWND，MYBITMAP FAR*，int)；
MYBITMAP FAR *vminify(HWND，MYBITMAP FAR*，int)；
int PASCAL lpf1 D(BYTE huge*，int，int，BYTE huge*)；
int PASCAL lpf1D_rgb(BYTE huge*，int，int，BYTE huge*)；
int PASCAL edge_refine(MYBITMAP*，EDGE*，int)；
int PASCAL h_refine(MYBITMAP*，double*，double*，int)；
int PASCAL v_refine(MYBITMAP*，double*，double*，int)；
int PASCAL sub_pixel_interp(double，double，double，double*，double *em)；
int PASCAL xysolve(HWND，MYBITMAP*，MYBITMAP*，SHIFT*，TR_WIN*，
int，
TRACK_POINTS*，
TRACK_POINTS*，Perspective_Transform*，HFILE，
TRACK_POINTS*，RPOINT*)；
int PASCAL xysrch(HWND，MYBTTMAP*，MYBITMAP*，SHIFT
*，POINT，POINT，
int，int，int，int)；
int PASCAL sub_pixel_refine(int，int，int，int，SHIFT*)；
int PASCAL find_average_shift(HWND，int，SHIFT
*，SHIFT_POINTS，SHIFT_POINTS，
Perspective_Transform*)；
int PASCAL Quad2Quad(HWND，RPOINT srcpnts[4]，RPOINT dstpnts[4]，
Perspective_Transform *)；
int PASCAL copy_transform(Perspective_Transform*，Perspective_Transform
*)；
int PASCAL Thin_Perspective(HWND，SHIFT_POINTS，SHIFT_POINTS
，int，
<dp n="d240"/>
Perspective_Transform*)；
int PASCAL trans_grey_frame_to_fields(HWND，RPOINT*，RPOINT*，
MYBITMAP*，RPOINT*，MYBITMAP**，MYBITMAP**)；
<dp n="d241"/>
#define det2(a11，a12，a21，a22)(a11*a22-a12*a21)
int PASCAL perspective(HWND，MYBITMAP FAR*，MYBITMAP
FAR*，RPOINT*，RPOINT*，int，
Perspective_Transform*)；
int PASCAL Rectan2Quad(HWND，RPOINT*，RPOINT
*，Perspective_Transform*)；
int PASCAL Perspective_map(MYBITMAP FAR*，Perspective_Transform*，
MYBITMAP FAR*，RPOINT*，int)；
RPOINT bPerspective(RPOINT，Perspective_Transform*)；
RPOINT PASCAL dPerspective(RPOINT，Perspective_Transform*)；
int PASCAL check_if_rect(RPOINT*)；
RPOINT PASCAL fPerspective(RPOINT，Perspective_Transform*)
int PASCAL median_filter_5(HWND，MYBITMAP*)；
int PASCAL get_tresh_for_occ(MYBITMAP*，int*)；
int PASCAL perspective_mask(HWND，MYBITMAP*，MYBITMAP*，
MYBITMAP*，
RPOINT*，RPOINT*，int，int，MYBITMAP*)；
int PASCAL Perspective_map_mask(MYBITMAP FAR
*，Perspective_Transform*，
MYBITMAP FAR*，MYBITMAP*，RPOINT*，int，int，MYBITMAP*)；
int PASCAL Quad2Rectan(HWND，RPOINT*，RPOINT
*，Perspective_Transform*)；
int PASCAL perspective_al(HND，MYBITMAP FAR*，MYBITMAP FAR
*，MYBITMAP*，
RPOINT*，RPOINT*，int，Perspective_Transform*)；
int PASCAL Perspective_map_al(MYBITMAP*，Perspective_Transform*，
MYBITMAP*，MYBITMAP*，RPOINT*，int)；
int PASCAL Perspective_near_map(MYBITMAP*，Perspective_Transfor
m*，
MYBITMAP*，RPOINT*，int)；
int PASCAL perspective_near(HWND，MYBITMAP*，MYBITMAP*，
RPOINT*，RPOINT*，int，Perspective_Transform*)；
<dp n="d242"/>
#include ＜windows.h＞
#include ＜windowsx.h＞
#include ＜commdlg.h＞
#include ＜stdlib.h＞
#include ＜bios.h＞
#include ＂const.h＂
#include ＂bitmap.h＂
#include ＂persp.h＂
#include ＂lines.h＂
#include ＂track.h＂
#include ＂min_mag.h＂
#include ＂lib.h＂
#undef RGB
#include ＜mfghost.h＞
#define UNTIL_FRAME 420
#define UNTIL_PICT 4
int PASCAL bitmap_for_display(HWND，HDC，MYBITMAP FAR*，RECT)；
int PASCAL draw_to_screen(MYBITMAP*，int，int)；
int PASCAL create_disp_bmap(MYBITMAP*，MYBITMAP**，RECT)；
int PASCAL pick_sign(HWND，UINT，UINT，LONG)；
int PASCAL change_sign(HWND，UINT，UINT，LONG)；
int PASCAL add_tracking_point(HWND，UINT，UINT，LONG)；
int PASCAL change_sign_by_tracking(HWND，int)；
int PASCAL WriteRgb(HWND，char*，MYBITMAP*)；
int PASCAL create_norrn_bmap(HWND，MYBITMAP*.MYBITMAP**，RECT)；
int PASCAL keep_orig(HWND，MYBITMAP*)；
int PASCAL pick_original(HWND，UINT，UINT，LONG)；
int PASCAL create_mask_bmap(HWND.MYBITMAP*.RPOINT*，RPOINT
*，RECT.MYBITMAP**)：
int PASCAL WriteGreyRgb(HWND hwnd，char *szFileName，MYBITMAP
*Bmap)：
int PASCAL add_clean_points(HWND，UINT，UINT，LONG)；
BOOL FAR PASCAL_export FramesDIg(HWND，UINT，UINT，LONG)；
UINT FAR PASCAL_export TimerProc(HWND，UINT，UINT，LONG)；
int PASCAL SonySearch(HWND，int，int)；
int PASCAL SonyRecord(HWND，int)；
int PASCAL load_field_from_card(HWND，int)；
int PASCAL load_picture_from_card(HWND)；
intPASCAL load_picture_from_file(HWND，char*)；
int PASCAL draw_field_to_screen(HWND，MYBITMAP *.int)；
int PASCAL WriteSign(HWND，char*，SIGN*)；
int PASCAL ReadSign(HWND，char*，SIGN*)；
int PASCAL pick_comers(HWND，UINT，UINT，LONG)；
int PASCAL get_fittness_of_vertexes(HWND，RECT，MYBITMAP*，RPOINT
*，DWORD*)；
int PASCAL replace_sign(HWND，RPOINT*)；
<dp n="d243"/>
int PASCAL create_subs_sign(HWND hwnd)；
int PASCAL fill_mask_rect(MYBITMAP*)；
int PASCAL ValidateOccRects(MYBITMAP*)；
int PASCAL copy_into_valid_rects()；
char szAppName[]=＂Trans＂；
static BYTE huge * lpRgb；
static BYTE huge * lpGreyRgb；
static BYTE huge * lpPtr；
static BYTE huge * lpRepaint；
static BYTE huge * lpDisplay；
static BYTE huge * lpBits；
PALETFEENTRY FAR *ppalentr；
PALETTEENTRY FAR ppalsys[256]；
BYTE FAR ColorTable[32][32][32]；
HPALETTE glhpal，hpalprev；
LOGPALETTE lgcpal；
RECT GIBound；
WORD glModelColor=COLOR_MODEL；
char stBufferZoom[50]；
char stBufferAngle[50]；
char stBufferWidth[50]；
int OrgX[8]，OrgY[8]；
int SignX[4]，SignY[4]；
char stBufferHeight[50]；
char stBufferFrTop[50]；
char stBufferFrBot[50]；
RPOINT SrcPoly[4]，DstPoly[4]，KeepPoly[4]；
RPOINT BstDsl[4]；
int InterpMode=IN_BILINEAR；
MYBITMAP FAR *SrcBmap=NULL；
MYBITMAP FAR *SrcLumap=NULL；
MYBITMAP FAR *SubstBmap=NULL；
MYBITMAP FAR *Subs=NULL；
MYBITMAP FAR *Dispmap=NULL；
MYBITMAP FAR *Normap=NULL；
MYBITMAP FAR *MskBmap=NULL；
SIGN OriginSign；
RECT ClientRect；
int IsRgb；
int FileType；
int SubstCols，SubstRows；
int OrigCols，OrigRows；
int CurrP，UnderPicking，UnderChanging，UnderTracking；
UnderOrig，UnderComers；
int InClean；
BYTE huge* lpSubst；
BYTE rpixarr[758]；
TRACK_POINTS TrackBase，TrackCurr；
<dp n="d244"/>
Perspective_Transform BasicTransf；
Perspective_Transform ShiftTransf；
int CleanX[2]；
int CleanY[2]；
int CleanCount；
static FARPROC lpfnTimeProc；
static LONG RecFrame=20908；
static int SearchFrame=15662；
int TimeElapsed；
static int PortNumber；
int FromFr；
static int ToFr=UNTIL_PICT；
int PictCount=0；
int IsOddLine=0；
static DWORD Ticks
int Waslnit=0；
int SplitMode=0；
OFSTRUCT of；
HFILE hFile；
int NumberOfField=0
double Vert1[4]，Vert2[4]，Vert3[4]，Vert4[4]；
double VertWeight[]={2.0，2.0，3.0，3.0}；
static int InSerieMode=0；
static int ReplaceFlag=1；
int DummyFrames=0；
#define DYMMIES 0
RECT ValidOccRects[5]；
int NumOfValidOccRects；
RECT OcclusionRects[5]；
int NumOfOccRects；
int PASCAL WinMain(HANDLE hlnstance，HANDLE hPrevlnstance，
LPSTR lpszCmdLine，int nCrndShow)
{
HWND hwnd；
MSG msg；
WNDCLASS wndclass；
if(!hPrevlnstance)
{
wndclass.style=CS_HREDRAW|CS_VREDRAW；
wndclass.lpfnWndProc=WndProc；
wndclass.cbClsExtra=0；
wndclass.cbWndExtra=0；
wndclass.hlnstance=hlnstance；
wndclass.hlcon=NULL；
wncclass.hCursor=LoadCursor(NULL，IDC_ARROW)；
wndclass.hbrBackground=GetStockObject(WHITE_BRUSH)；
wndclass.lpszMenuName=szAppName；
<dp n="d245"/>
wndclass.lpszClassName=szAppName；
RegisterClass(&wndclass)；
}
hwnd=CreateWindow(szAppName，＂Transformations＂，
WS_OVERLAPPEDWINDOW，
CW_USEDEFAULT，CW_USEDEFAULT，
CW_USEDEFAULT，CW_USEDEFAULT，
NULL，NULL，hlnstance，NULL)；
ShowWindow(hwnd，nCmdShow)；
UpdateWindow(hwnd)；
while(GetMessage(&msg，NULL，0，0))
{
TranslateMessage(&msg)；
DispatchMessage(&msg)；
}
return msg.wParam；
}
long FAR PASCAL_export WndProc(HWND hwnd，UINT message，UINT
wParam，
LONG IParam)
{
static char szFileName L_MAX_PATH]，
szTitleName [_MAX_FNAME+_MAX_EXT]；
static char* szFilter[]={＂RGB Files(*.RGB)＂，***.rgb＂，
***}；
static OPENFILENAME ofn；
static FARPROC lpfnFramesProc；
static HANDLE hinst；
HDC hdc；
PAINTSTRUCT ps；
char DebugString[100]；
WORD cxClient，cyClient；
HPALETTE hpal；
DWORD i，j；
int k；
char RgbFileName[50]；
RECT ToValidate，recp；
DWORD Size；
int DstRows，DstCols；
int ToCopy；
int gaoi，raoi，baoi；
PHDR header；
<dp n="d246"/>
BYTE huge * PtrRgb；
char DataBuffer[10]，InputBuffer[10]；
DCB dcb；
static int kemel[]={
1，1，1，
1，1，1，
1，1，1}；
switch(message){
case WM_CREATE：
ofn.IStructSize=sizeof(OPENFILENAME)；
ofn.hwndOwner=hwnd；
ofn.lpstrFilter=szFilter[0]；
ofn.lpstrFile=szFileName；
ofn.nMaxFile=_MAX_PATH；
ofn.lpstrFileTitle=szTitleName；
ofn.nMaxFileTitle=_MAX_FNAME+_MAX_EXT；
ofn.lpstrDefExt=＂bmp＂；
hinst=((LPCREATESTRUCT)IParam)-＞hlnstance；
lpfnFramesProc=
MakeProclnstance((FARPROC)FramesDlg，hinst)；
lpfnTimeProc=MakeProclnstance((FARPROC)TimerProc，hinst)；
lgcpal.palNumEntries=256；
lgcpal.palVersion=0x300；
lgcpal.palPalEntry[0].peRed=0；
lgcpal.palPalEntry[0].peGreen=0；
lgcpal.palPalEntry[0].peBlue=0；
lgcpal.palPalEntry[0].peFlags=PC_NOCOLLAPSE；
hFile=OpenFile(＂map.dif＂，&of，OF_CREATE|OF_WRITE)；
OriginSign.Bmap=NULL；
OriginSign.BmapGrey=NULL；
return 0；
case WM_SIZE：
cxClient=LOWORD(IParam)；
cyClient=HIWORD(IParam)；
return 0；
case WM_COMMAND：
switch(wParam){
case IDM_OPEN：
ofn.lpstrlnitialDir=＂c：\\work\\trans＂；
if(GetOpenFileName(&ofn)){
FileType=gel_file_type_by_name(szFileName)；
if(FileType==FILE_IS_RGB){
load_picture_from_file(hwnd，szFileName)；
InvalidateRect(hwnd，NULL，TRUE)；
}
}
break；
<dp n="d247"/>
case IDM_WRITE：
ofn.lpstrlnitialDir=＂c：\\work\\trans＂；
if(GetOpenFileName(&ofn)){
FileType=get_file_type_by_name(szFileName)；
if(FileType==FILE_IS_RGB){
WriteRgb(hwnd，szFileName，SrcBmap)；
}else{
MessageBox(hwnd，＂File must be .rgb＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
}
}
break；
case IDM_PICK_SUBST：
if(SrcBmap==NULL){
MessageBox(hwnd，＂No Source Bitmap＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
}
UnderPicking=1；
CurrP=0；
SetCapture(hwnd)；
SetCursor(LoadCursor(NULL，IDC_CROSS))；
break；
case IDM_PICK_ORIG：
if(SrcBmap==NULL){
MessageBox(hwnd，＂No Source Bitmap＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
}
UnderOrig=1；
CurrP=0；
SetCapture(hwnd)；
SetCursor(LoadCursor(NULL，IDC_CROSS))；
break；
case IDM_PICK_CORNERS：
if(SrcBmap==NULL){
MessageBox(hwnd，＂No Source Bitmap＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
}
UnderComers=1：
CurrP=0；
SetCapture(hwnd)：
SetCursor(LoadCursor(NULL，IDC_CROSS))；
break；
<dp n="d248"/>
case IDM_LOAD_ORIG：
ReadSign(hwnd，＂orig.sgn＂，&OriginSign)；
break；
case IDM_CHANGE：
UnderChanging=1；
if(lpSubst==NULL){
MessageBox(hwnd，＂No Model Bitmap＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
}
SetCapture(hwnd)；
SetCursor(LoadCursor(NULL，IDC_CROSS))；
break；
case IDM_BILINEAR：
InterpMode=IN_BILINEAR；
break；
case IDM_TRILINEAR：
InterpMode=IN_TRILINEAR；
break；
case IDM_SPLIT：
SplitMode=1-SplitMode
break；
case IDM_INFO：
display_information(hwnd)
break；
case IDM_START_TRACK：
UnderTracking=1；
OriginSign.TrPoints.NumOfPoints=0；
TrackBase.NumOfPoints=0 ；
TrackCurr.NumOfPoints=0；
SetCapture(hwnd)；
SetCurscr(LoadCursor(NULL，IDC_CROSS))；
break；
case IDM_ALTO_TRACK：
//Ticks = GetTickCount()；
change_sign_by_tracking(hwnd，1)；
//sprintf(DebugStdng，＂Track+Change ％Id＂，
// GetTickCount()-Ticks)；
//MessageBox (hwnd，DebugString，
// szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
case DISP_INIT：
mfg_loadcnf(′＂′)；
mfg_init()；
Waslnit=1；
break；
case DISP_SNAP：
<dp n="d249"/>
if(Waslnit==0){
MessageBox(hwnd，＂Need to Initialize MFG＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
}
mfg_setvframe(RGB)；
mfg_dacmode(TRUE_24)；
mfg_snap(CAMERA，PAGE1)；
break；
case DISP_GRAB：
if(Waslnit==0){
MessageBox(hwnd，＂Need to Initialize MFG＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
}
mfg_setvframe(RGB)；
mfg_dacmode(TRUE_24)；
rnfg_grab(CAMERA，PAGE1)；
break；
case DISP_DRAW：
if(Waslnit==0){
MessageBox(hwnd，＂Need to Initialize MFG＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
}
draw_to_screen(SrcBmap，0，SrcBmap-＞rows)；
//draw_to_screen(SrcBmap，120，200)；
break；
case DISP_CLEAN：
if(Waslnit==0){
MessageBox(hwnd，＂Need to Initialize MFG＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
}
SetCapture(hwnd)；
SetCursor(LoadCursor(NULL，IDC_CROSS))；
InClean=1；
break；
case DISP_WIPE：
if(Waslnit==0){
MessageBox(hwnd，＂Need to Initialize MFG＂，
szAppName，MB_ICONEXCLAMATION
MB_OK)；
break；
}
<dp n="d250"/>
mfg_wipe(0)；
InSerieMode=1；
//create_subs_sign(hwnd)；
SetTimer(hwnd，1，500，lpfnTimeProc)；//To Be
REMOVED
break；
case DISP_LOAD：
if(Waslnit==0){
MessageBox(hwnd，＂Need to Initialize MFG＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
}
//load_picture_from_card(hwnd)；
sprintf(RgbFileName，＂pict％d.rgb＂，PictCount++)；
WriteRgb(hwnd，RgbFileName，SrcBmap)；
InvalidateRect(hwnd，NULL，TRUE)；
break；
case DISP_LOAD_FIELD：
if(Waslnit==0){
MessageBox(hwnd，＂Need to Initialize MFG＂，
szAppName，MB_ICONEXCLAMATION|
MB_OK)；
break；
}
load_field_from_card(hwnd，0)；
InvalidateRect(hwnd，NULL，TRUE)；
break；
case SONY_INIT：
PortNumber=OpenComm(＂COM2＂，1024，128)；
spdntf(DebugString，＂PortNumber ％d＂，PortNumber)；
MessageBox(hwnd，DebugString，
szAppName，MB_ICONEXCLAMATION|MB_OK)；
k=BuildCommDCB(＂COM2：1200，n，8，1＂，&dcb)；
k=SetCommState(&dcb)；
break；
case SONY_FRAME：
if(DialogBox(hinst，＂frames＂，hwnd，lpfnFramesProc)){
sscanf(stBufferWidth，＂％d＂，&FromFr)；
sscanf(stBufferHeight，＂％d＂，&ToFr)；
}
//SonySearch(hwnd，FromFr，PortNumber)；
//TimeElapsed=0；
//SetTimer(hwnd，1，500，lpfnTimeProc)；
break；
case SONY_RECORD：
ReplaceFlag=1-ReplaceFlag；
//SonyRecord(hwnd，PortNumber)；
break；
<dp n="d251"/>
case SONY_END：
k=CloseComm(PortNumber)；
break；
}
break；
case WM_LBUTTONDOWN：
if(UnderPicking==1){
pick_sign(hwnd，message，wParam，lParam)；
}
if(UnderOrig==1){
pick_original(hwnd，message，wParam，lParam)；
}
if(UnderComers==1){
pick_comers(hwnd，message，wParam，lParam)；
}
if(UnderChanging==1){
change_sign(hwnd，message，wParam，lParam)；
}
if(UnderTracking==1){
add_tracking_point(hwnd，message，wParam，lParam)；
}
if(InClean==1){
add_clean_points(hwnd，message，wParam，lParam)；
}
return 0；
case WM_RBUTTONDOWN：
if(UnderTracking==1){
SetCursor(LoadCursor(NULL，IDC_ARROW))；
ReleaseCapture()；
UnderTracking=0；
create_lum_bmap(OriginSign.Bmap，&(OnginSign.BmapGrey))；
WriteSign(hwnd，＂orig.sgn＂，&OriginSign)；
}
return 0；
case WM_MOUSEMOVE：
if(UnderPicking==1||UnderChanging==1||UnderOrig==1)
sprintf(DebugString，＂％d，％d＂，LOWORD(lParam)，HIWORD(lParam))；
recp.left=recp.top=400；
recp.bottom=420；
recp.right=480；
InvalidateRect(hwnd，&recp，TRUE)；
}
return 0；
case WM_PAINT：
if(InSerieMode==1){
hdc=BeginPaint(hwnd，&ps)；
EndPaint(hwnd，&ps)；
<dp n="d252"/>
break；
}
hdc=BeginPaint(hwnd，&ps)；
ToValidate=ps.rcPaint；
if(UnderPicking==1||UnderChanging==1||UnderOrig==1){
TextOut(hdc，ToValidate.left，ToValidate.top，DebugString，lstrlen(DebugString))
；
}else{
if(SrcBmap !=NULL){
glhpal=CreatePalette(&lgcpal)；
if(glhpal==NULL)
MessageBox(hwnd，＂PALLET NOT CREATED＂，
szAppName，MB_ICONEXCLAMATION|MB_OK)；
SetPaletteEntries(glhpal，0，256，ppalentr)；
hpalprev=SelectPalette(hdc，glhpal，FALSE)；
RealizePalette(hdc)；
if(bitmap_for_display(hwnd，hdc，SrcBmap，ToValidate)==0){
DeleteObject(glhpal)；
EndPaint (hwnd，&ps)；
return 0；
}
SetStretchBItMode(hdc，COLORONCOLOR)；
SetDIBitsToDevice(hdc，0，0，Dispmap-＞cols，
Dispmap-＞rows，0，0，0，Dispmap-＞rows，
(LPSTR)(Dispmap-＞gpic)，
(LPBITMAPINFO)IpDisplay，DIB_RGB_COLORS)；
DeleteObject(glhpal)；
}
}//End Of Else
EndPaint(hwnd，&ps)；
return 0；
case WM_DESTROY；
_lclose(hFile)；
if(IpDisplay !=NULL){
GlobalFreePtr(IpDisplay)；
}
bm_free(SrcBmap)；
bm_free(SrcLumap)；
bm_free(Dispmap)；
bm_free(Normap)；
bm_free(SubstBmap)；
bm_free(Subs)；
bm_free(MskBmap)；
KillTimer(hwnd.1)；
PostQuitMessage(0)；
return 0；
}
<dp n="d253"/>
return DefWindowProc(hwnd，messag，wParam，lParam)；
}
int PASCAL teach_grey_pallete(HWND hwnd，int Entries)
{
int i；
UINT rc；
char Debug[100]；
if(ppalentr !=NULL){
GlobalFreePtr(ppalentr)；
ppalentr=NULL；
}
ppalentr=(PALETTEENTRY FAR*)GlobalAllocPtr(GMEM_MOVEABLE
，Entries*sizeof(RGBQUAD))；
for(i=0；i＜Entries；i++){
ppalentr[i].peRed=i；
ppalentr[i].peGreen=i；
ppalentr[i].peBlue=i；
ppalentr[i].peFlags=PC_NOCOLLAPSE；
}
return 1；
}
int PASCAL get_in_series_flag()
{
return InSerieMode；
}
int PASCAL display_information(HWND hwnd)
{
char Debug[100]；
if(SrcBmap==NULL){
MessageBox(hwnd，＂No Source Bitmap＂，szAppName，
MB_ICONEXCLAMATION|MB_OK)；
return 1；
}
sprintf(Debug，＂Width=％d Height=％d＂，SrcBmap-＞cols，SrcBmap-＞rows)；
MessageBox(hwnd，Debug，szAppName，MB_ICONEXCLAMATION|
MB_OK)；
return 1；
}
<dp n="d254"/>
BOOL FAR PASCAL_export FramesDlg(HWND hdlg，UINT message，UINT
wParam，
LONG IParam)
{
switch(message){
case WM INITDIALOG：
return TRUE；
case WM_COMMAND：
switch(wParam){
case SONY_FROM_FR：
GetDlgltemText(hdlg，PER_WIDTH，(LPSTR)stBufferWidth，50)；
return TRUE；
break；
case SONY_TO_FR：
GetDlgltemText(hdlg，PER_HEIGHT，(LPSTR)stBufferHeight，50)；
return TRUE；
break；
case SONY_OK：
EndDialog(hdlg，TRUE)；
return TRUE；
break；
case SONY_CANCEL：
EndDialog(hdlg，FALSE)；
return TRUE；
break；
}
}
return FALSE；
BYTE huge* ReadRGB(HWND hwnd，char*FileNarne，int*Width，int*Height)
{
HFILE hFile；
PHDR phdr，
DWORD Size；
HDC hdc；
DWORD offset；
DWORD i，j；
BYTE Red，Green，Blue；
HPALETTE hpal；
int ColorFactor；
BYTE huge*PtrRgb；
BYTE huge*IpRead；
int SizeToRead；
<dp n="d255"/>
int Incr；
if(-1==(hFile=_lopen(FileName，OF_READ|
OF_SHARE_DENY_WRITE)))
return NULL；
_lread(hFile，(LPSTR)&phdr，sizeof(PHDR))；
if(glModelColor==GREY_MODEL)ColorFactor=1；
if(glModelColor==COLOR_MODEL)ColorFactor=3；
Size=(DWORD)phdr.cols*(DWORD)phdr.rows*(DWORD)ColorFactor；
*Width=phdr.cols；
*Height=phdr.rows；
IpRgb=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
PtrRgb=IpRgb；
offset=0；
SizeToRead=(DWORD)(phdr.cols)*(DWORD)3；
IpRead=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，
SizeToRead)；
while(offset＜Size){
if(glModelColor==GREY_MODEL){
_lread(hFile，LPSTR)IpRead，SizeToRead)；
for(i=0；i＜SizeToRead；i+=3){
*(PtrRgb+offset)=(*(IpRead+i)+*(IpRead+i+1)+
*(IpRead+i+2))/3；
offset++；
}
}else{//COLOR_MODEL
_lread(hFile，(LPSTR)(PtrRgb+offset)，SizeToRead)；
offset+=SizeToRead；
}
}
GlobalFreePtr(IpRead)；
if(glModelColor==GREY_MODEL){
teach_grey_pallete(hwnd，256)；
}else{
teach_rgb_pallete(hwnd)；
}
_lclose(hFile)；
return PtrRgb；
int PASCAL teach_rgb_pallete(HWND hwnd)
{
int pl，i，j，k；
int red，blue，green；
UINT rc；
char Debug[100]；
int Scale[6]={0，64，128，150，192，255}；
int Fine[4]={32，96，171，224}；
<dp n="d256"/>
if(ppalentr !=NULL){
GlobalF reePtr(ppalentr)；
ppalentr=NULL；
}
ppalentr=(PALETTEENTRY FAR*)GlobalAllocPtr(GMEM_MOVEABLE
，256*sizeof(RGBQUAD))；
for(i=10；i＜245；i++){
ppalentr[i].peRed=i；
ppalentr[i].peGreen=i；
ppalentr[i].peBlue=i；
ppalentr[i].peFlags=PC_RESERVED；
}
return 1；
}
int PASCAL get_file_type_by_name(char*FileName)
{
int i，len；
len=strlen(FileName)-1；
for(i=len；i＞0；i-){
FileName[i]=toupper(FileName[i])；
if(FileName[i]==′.′){
i++；
break；
}
}
if(strcmp(FileName+i，＂RGB＂)==0)return FILE_IS_RGB；
return FILE_IS_UNKNOWN；
int PASCAL create_poly_src_dst()
{
SrcPoly[0].x=SrcPoly[0].x=0.0；
SrcPoly[1].x=SubstBmap-＞cols；//SubstCols；
SrcPoly[1].y=0.0；
SrcPoly[2].x=SubstBmap-＞cols；//SubstCols；
SrcPoly[2].y=SubstBmap-＞rows；//SubstRows；
SrcPoly[3].x=0.0；
SrcPoly[3].y=SubstBmap-＞rows；//SubstRows；
l_cp_int_arr_to_RPOINT(DstPoly，OrgX，OrgY，4)；
return 1；
<dp n="d257"/>
}
int PASCAL keep_subst(HWND hwnd，MYBITMAP *Bmap)
{
DWORD i，j；
HFILE hFile；
PHDR phdr；
DWORD Size；
DWORD offset；
DWORD Cols；
BYTE huge*Ptr；
DWORD Width，Adjust；
SubstCols=phdr.cols=abs(OrgX[1]-OrgX[0])；
SubstRows=phdr.rows=abs(OrgY[2]-OrgY[1])；
phdr.bp=3；
Size=(DWORD)(phdr.cols)*(DWORD)(phdr.rows)*(DWORD)3；
IpSubst=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
offset=0；
Cols=(DWORD)(phdr.cols)*(DWORD)3；
Ptr=Bmap-＞gpic；
Width=(DWORD)(SrcBmap-＞cols)*(DWORD)3；
Adjust=(DWORD)(OrgX[0])*(DWORD)3；
for(i=0；i＜phdr.rows；i++){
for(j=0；j＜Cols；j++){
*(IpSubst+offset+j)=*(Ptr+
((DWORD)Width*(DWORD)(OrgY[0]+i))+Adjust+j)；
}
offset+=Cols；
}
SubstBmap=bm_alloc(SubstCols，SubstRows，glModelColor)；
SubstBmap-＞gpic=IpSubst；
return 1；
}
int PASCAL keep_orig(HWND hwnd，MYBITMAP *Bmap)
{
DWORD i，j；
HFILE hFile；
PHDR phdr；
DWORD Size；
DWORD offset；
BYTE huge*IpModel；
DWORD Cols；
BYTE huge*Ptr；
DWORD Width，Adjust；
<dp n="d258"/>
OrigCols=phdr.cols=abs(OrgX[1]-OrgX[0])；
OrigRows=phdr.rows=abs(OrgY[2]-OrgY[1])；
phdr.bp=24；
Size=(DWORD)(phdr.cols)*(DWORD)(phdr.rows)*(DWORD)3；
IpModel=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
offset=0；
Cols=(DWORD)(phdr.cols)*(DWORD)3；
Ptr=Bmap-＞gpic；
Width=(DWORD)(SrcBmap-＞cols)*(DWORD)3；
Adjust=(DWORD)(OrgX[0])*(DWORD)3；
for(i=0；i＜phdr.rows；i++){
Ptr=Bmap-＞gpic+((DWORD)Width*(DWORD)(OrgY[0]+i))+Adjust；
for(j=0；j＜Cols；j++){
*(lpModel+offset+j)=*(Ptr++)；
}
offset+=Cols；
}
bm_free(OriginSign.Bmap)；
bm_free(OriginSign.BmapGrey)；
OriginSign.Bmap=bm_alloc(OrigCols，OrigRows，glModelColor)；
OriginSign.Bmap-＞gpic=IpModel；
WriteRgb(hwnd，＂orig.rgb＂，OriginSign.Bmap)；
return 1；
}
int PASCAL bitmap_for_display(HWND hwnd，HDC hdc，MYBITMAP FAR
*Bmap，RECT ToValidate)
{
LONG Size，i，j；
BYTE huge*TmpB；
BYTE huge*Tmp；
BYTE huge*Ptr；
char Debug[100]；
GetSystemPaletteEntries(hdc，(UINT)0，(UINT)256，ppalsys)；
Size=40+(DWORD)(sizeof(RGBQUAD))*(DWORD)256；
if(IpDisplay !=NULL){
GlobalFreePtr(IpDisplay)；
}
IpDisplay=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
IpBits=IpDisplay+40+(DWORD)(sizeof(RGBQUAD))*(DWORD)256；
Ptr=IpDisplay+40；
<dp n="d259"/>
((BITMAPINFOHEADER huge*)IpDisplay)-＞biSize=40；
((BITMAPINFOHEADER huge*)IpDisplay)-＞biWidth=Bmap-＞cols；
((BITMAPINFOHEADER huge*)IpDisplay)-＞biHeight=Bmap-＞rows；
((BITMAPINFOHEADER huge*)IpDisplay)-＞biPlanes=1；
((BITMAPINFOHEADER huge*)IpDisplay)-＞biBitCount=8；
((BITMAPINFOHEADER huge*)IpDisplay)-＞biCompression=0；
((BITMAPINFOHEADER huge*)IpDisplay)-＞biSizelmage=0；
((BITMAPINFOHEADER huge*)IpDisplay)-＞biXPelsPerMeter=0；
((BITMAPINFOHEADER huge*)IpDisplay)-＞biYPelsPerMeter=0；
((BITMAPINFOHEADER huge*)IpDisplay)-＞biClrUsed=0；
((BITMAPINFOHEADER huge*)IpDisplay)-＞biClrlmportant=0；
for(i=0；i＜256；i++){
(BYTE)*(Ptr+(DWORD)(i*sizeof(RGBQUAD)))=ppalsys[i].peBlue；
(BYTE)*(Ptr+(DWORD)(i*sizeof(RGBQUAD)+1))=ppalsys[i].peGreen；
(BYTE)*(Ptr+(DWORD)(i*sizeof(RGBQUAD)+2))=ppalsys[i].peRed；
(BYTE)*(Ptr+(DWORD)(i*sizeof(RGBQUAD)+3))=0；
}
retun(create_disp_bmap(Bmap，&Dispmap，ToValidate))；
}
int PASCAL draw_to_screen(MYBITMAP *Bmap，int FromLine，int ToLine)
{
int i，j；
BYTE huge *Ptr；
BYTE huge *PtrR；
BYTE huge *PtrG；
BYTE huge *PtrB；
int Cols；
Cols=Bmap-＞cols；
Ptr=Bmap-＞gpic；
Ptr+=(DWORD)FromLine*(DWORD)Cols*(DWORD)3；
PtrR=Ptr；
PtrG=Ptr+1；
PtrB=Ptr+2；
mfg_setgframe(R)；
for(i=FromLine；i＜ToLine；i++){
for(j=0；j＜Cols；j++){
rpixarr[j]=*PtrR；
PtrR+=3；
}
mfg_bwhline(PAGE0，0，i，Cols，rpixarr)；
}
mfg_setgframe(G)；
for(i=FromLine；i＜ToLine；i++){
for(j=0；j＜Cols；j++){
rpixarr[j]=*PtrG；
PtrG+=3；
<dp n="d260"/>
}
mfg_bwhline(PAGE0，0，i，Cols，rpixarr)
}
mfg_setgframe(B)；
for(i=FromLine；i＜ToLine；i++){
for(j=0；j＜Cols；j++){
rpixarr[j]=*PtrB；
PtrB+=3；
}
mfg_bwhline(PAGE0，0，i，Cols，rpixarr)
}
return 1；
}
int PASCAL create_disp_bmap(MYBITMAP *Bmap，MYBITMAP
**LumBmap，RECT ToValidate)
{
BYTE huge*Tmp；
BYTE huge*TmpB；
int ToPad；
int Cols，Rows；
DWORD Size；
int i，j；
long k；
int RowLimit；
if(Nonnap==NULL)return 0；
Cols=Bmap-＞cols；
Rows=Bmap-＞rows；
ToPad=Cols％4；
if(ToPad＞0)ToPad=4-ToPad；
Tmp=Bmap-＞gpic；
if(ToValidate.top==0){
if(*LumBmap !=NULL)bm_free(*LumBmap)；
*LumBmap=bm_alloc(Cols+ToPad，Rows，GREY_MODEL)；
Size=(DWORD)(Cols+ToPad)*(DWORD)Rows；
(*LumBmap)-＞gpic=(BYTE
huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
RowLimit=min(Rows，ToValidate.bottom)；
for(i=RowLimit；i＞ToValidate.top；i-){
Tmp=Normap-＞gpic+(DWORD)(i-1)*(DWORD)Cols；
<dp n="d261"/>
TmpB=(*LumBmap)-＞gpic+(Rows-i)*(DWORD)(Cols+ToPad)；
for(j=0；j＜Cols；j++){
*(TmpB++)=*(Tmp++)；
}
for(j=0；j＜ToPad；j++){
*(TmpB++)=0；
}
}
return 1；
}
int PASCAL pick_sign(HWND hwnd，UINT message，UINT wParam，LONG
IParam)
{
OrgX[CurrP]=LOWORD(IParam)；
OrgY[CurrP]=HIWORD(IParam)；
CurrP++；
if(CurrP==2){
OrgX[2]=OrgX[1]；
OrgY[2]=OrgY[1]；
OrgY[1]=OrgY[0]；
OrgX[3]=OrgX[0]；
OrgY[3]=OrgY[2]；
UnderPicking=0；
CurrP=0；
SetCursor(LoadCursor(NULL，IDC_ARROW))；
ReleaseCapture()；
keep_subst(hwnd，SrcBmap)；
if(InterpMode==IN_TRILINEAR)
build_pyramid(hwnd，SubstBmap)；
}
return 1；
}
int PASCAL add_clean_points(HWND hwnd，UINT message，UINT wParam，
LONG IParam)
{
static int kemel[]={
1，1，1，
1，1，1，
1，1，1}；
int gaoi，raoi，baoi；
int DifX，DifY；
CleanX[CleanCount]=LOWORD(IParam)；
CleanY[CleanCount]=HIWORD(IParam)；
CleanCount++；
<dp n="d262"/>
if(CleanCount==2){
InClean=0；
CleanCount=0；
SetCursor(LoadCursor(NULL，IDC_WAIT))；
DifX=CleanX[1]-CleanX[0]；
DifY=CleanY[1]-CleanY[0]；
gaoi=mfg_gaoi_fbcreate(G，CleanX[0]，CleanY[0]，DifX，DifY)；
mfg_median(gaoi，gaoi，3，3，kemel)；
raoi=mfg_gaoi_fbcreate(R，CleanX[0]，CleanY[0]，DifX，DifY)；
mfg_median(raoi，raoi，3，3，kemel)；
baoi=mfg_gaoi_fbcreate(B，CleanX[0]，CleanY[0]，DifX，DifY)；
mfg_median(baoi，baoi，3，3，kemel)；
SetCursor(LoadCursor(NULL，IDC_ARROW))；
ReleaseCapture()；
//SetTimer(hwnd，1，40，lpfnTimeProc)；
}
return 1；
}
int PASCAL pick_comers(HWND hwnd，UINT message，UINT wParam，
LONG IParam)
{
RPOINT CoefsH1，CoefsH2，CoefsV1，CoefsV2；
POINT Point1，Point2；
char String[100]；
OrgX[CurrP]=LOWORD(IParam)；
OrgY[CurrP]=HIWORD(IParam)；
CurrP++；
if(CurrP==4){
UnderComers=0；
CurrP=0；
SetCursor(LoadCursor(NULL，IDC_ARROW))；
ReleaseCapture()；
}
return 1；
}
int PASCAL pick_original(HWND hwnd，UINT message，UINT wParam，
LONG IParam)
{
RPOINT CoefsH1，CoefsH2，CoefsV1，CoefsV2；
POINT Point1，Point2；
char String[100]；
OrgX[CurrP]=LOWORD(IParam)；
<dp n="d263"/>
OrgY[CurrP]=HIWORD(IParam)；
CurrP++；
if(CurrP==2){
OrgX[2]=OrgX[1]；
OrgY[2]=OrgY[1]；
OrgY[1]=OrgY[0]；
OrgX[3]=OrgX[0]；
OrgY[3]=OrgY[2]；
UnderOrig=0；
CurrP=0；
SetCursor(LoadCursor(NULL，IDC_ARROW))；
ReleaseCapture()；
keep_orig(hwnd，SrcBmap)；
}
return 1；
}
int PASCAL change_sign(HWND hwnd，UINT message，UINT wParam，
LONG IParam)
{
RECT Bound；
RPOINT Pt0，Pt1，Pt2，Pt3；
POINT Point1，Point2；
RPOINT SrcPnts[4]；
char String[100]；
DWORD FromTime，ToTime；
EDGE Edge1，Edge2，Edge3，Edge4；
char DebugString[50]；
MYBITMAP *AlphaMap；
OrgX[CurrP]=LOWORD(IParam)；
OrgY[CurrP]=HIWORD(IParam)；
CurrP++；
if(CurrP==4){
UnderChanging=0；
CurrP=0；
SetCursor(LoadCursor(NULL，IDC_ARROW))；
ReleaseCapture()；
create_poly_src_dst()；
l_find_bound_rect(DstPoly，&Bound)；
//create_mask_bmap(hwnd，OriginSign.BmapGrey，SrcPoly，DstPoly，Bound，&M
skBmap)；
//Ticks=GetTickCount()；
build_alpha_map(&AlphaMap，SrcBmap，DstPoly)；
//perspective_al(hwnd，SubstBmap，SrcBmap，AlphaMap，SrcPoly，
<dp n="d264"/>
// DstPoly，glModelColor，&BasicTransf)；
bm_free(AlphaMap)；
perspective(hwnd，SubstBmap，SrcBmap，SrcPoly，
DstPoly，glModelColor，&BasicTransf)；
//sprintf(DebugString，＂Change ％ld＂，GetTickCount()-Ticks)；
//MessageBox(hwnd，DebugString，
// szAppName，MB_ICONEXCLAMATION|MB_OK)；
//perspective_mask(hwnd，SubstBmap，SrcBmap，SrcPoly，
// DstPoly，glModelColor，InterpMode，MskBmap)；
create_norm_bmap(hwnd，SrcBmap，&Norrnap，Bound)；
InvalidateRect(hwnd，&Bound，TRUE)；
}
return 1；
}
int PASCAL add_tracking_point(HWND hwnd，UINT message，UINT wParam，
LONG IParam)
{
int Place；
Place=OriginSign.TrPoints.NumOfPoints；
if(Place＞=NUM_OF_TRACK_POINTS){
MessageBox(hwnd，＂Cannot track more than 30 points＂，
szAppName，MB_ICONEXCLAMATION|MB_OK)；
SetCursor(LoadCursor(NULL，IDC_ARROW))；
ReleaseCapture()；
UnderTracking=0；
create_lum_bmap(OriginSign.Bmap，&(OriginSign.BmapGrey))；
WriteSign(hwnd，＂orig.sgn＂，&OriginSign)；
return 1；
}
OriginSign.TrPoints.TrackP[Place].x=LOWORD(IParam)；
OriginSign.TrPoints.TrackP[Place].y=HIWORD(IParam)；
TrackBase.TrackP[Place].x=LOWORD(IParam)；
TrackBase.TrackP[Place].y=HIWORD(IParam)；
TrackCurr.TrackP[Place].x=LOWORD(IParam)；
TrackCurr.TrackP[Place].y=HIWORD(IParam)；
OriginSign.TrPoints.NumOfPoints++；
TrackBase.NumOfPoints++；
TrackCurr.NumOfPoints++；
return 1；
}
int PASCAL change_sign_by_tracking(HWND hwnd，int ToDisplay)
{
Perspective_Transform NewTransf；
Perspective_Transform Tp；
<dp n="d265"/>
Perspective_Transform TpCurr；
RECT Bound；
iht i，k；
double DiffiUp，DiffDown；
double u，v，w；
char String[100]；
int dx，dy；
DWORD Size；
int Cols，Rows；
RPOINT SrcPnts[4]；
RPOINT RPointln，RPointOut；
SHIFT Shift；
SHIFT Shifts[NUM_OF_TRACK_POINTS]；
double DstX，DstY；
RECT Rectan；
MYBITMAP *DestBmap；
RPOINT CrnPoly[4]；
TRACK_POINTS ModelPoints；
TRACK_POINTS DBasePoints；
RPOINT DiffArr[MAX_NO_OF_TR_WIN]；
MYBITMAP *AlphaMap；
TR_WIN Windows[MAX_NO_OF_TR_WIN]；
//create_subs_sign(hwnd)；
sprintf(String，＂\n\n\t\tNew Frame\＂)；
_lwrite(hFile，String，strlen(String))；
l_cp_int_arr_to_RPOINT(SrcPnts，SignX，SignY，4)；
Quad2Quad(hwnd，SrcPnts，DstPoly，&TpCurr)；
l_find_bound_rect(DstPoly，&Rectan)；
Cols=Rectan.nght-Rectan.left+1；
Rows=Rectan.bottom-Rectan.top+1；
DestBmap=bm_alloc(Cols，Rows，GREY_MODEL)；
Size=(DWORD)Cols*(DWORD)Rows；
DestBmap-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
l_quad_in_new_origin(CrnPoly，DstPoly，Rectan.left，Rectan.top，4)；
for(i=0；i＜4；i++){
sprintf(String，＂％d：Dst ％lf，％lf Cm ％lf，％lf Src ％lf，％lf\n＂，
i，DstPoly[i].x，DstPoly[i].y，CmPoly[i].x，CmPoly[i].y，
SrcPnts[i].x，SrcPnts[i].y)；
_lwrite(hFile，String，strlen(String))；
}
Quad2Quad(hwnd，SrcPnts，CmPoly，&Tp)；
<dp n="d266"/>
TrackCurr.NumOfPoints=0；
ModelPoints.NumOfPoints=0；
DBasePoints.NumOfPoints=0；
for(i=k=0；i＜OriginSign.TrPoints.NumOfPoints；i++){
RPointln.x=(double)OriginSign.TrPoints.TrackP[i].x；
RPointln.y=(double)OriginSign.TrPoints.TrackP[i].y；
RPointOut=fPerspective(RPointln，&Tp)；
if(RPointOut.x＜=CORR_WINDOWX||RPointOut.x＞=(Cols-
CORR_WINDOWX-1))continue；
if(RPointOut.y＜=CORR_WINDOWY||RPointOut.y＞=(Rows-
CORR_WINDOWY-1))continue；
ModelPoints.TrackP[k].x=(int)(RPointOut. x+0.5)；
ModelPoints.TrackP[k].y=(int)(RPointOut.y+0.5)；
if(ModelPoints.TrackP[k].x＞RPointOut.x){//To minus DiffArr
DiffArr[k].x=(double)ModelPoints.TrackP[k].x-RPointOutx；
}else{
DiffArr[k].x=RPointOut.x-(double)ModelPoints.TrackP[k].x；
}
if(ModelPoints.TrackP[k].y＞RPointOut.y){
DiffArr[k].y=(double)ModelPoints.TrackP[k].y-RPointOut.y；
}else{
DiffArr[k].y=RPointOut.y-(double)ModelPoints.TrackP[k].y；
}
DBasePoints.TrackP[k].x=OriginSign. TrPoints.TrackP[i].x；
DBasePoints.TrackP[k].y=OriginSign.TrPoints.TrackP[i].y；
RPointOut=fPerspective(RPointln，&TpCurr)；
TrackCurr.TrackP[k].x=(int)(RPointOut.x+0.5)；
TrackCurr.TrackP[k].y=(int)(RPointOut.y+0.5)；
if(TrackCurr.TrackP[k].x＞RPointOut.x){//To minus DiffArr
DiffArr[k].x+=(double)TrackCurr.TrackP[k].x-RPointOut.x；
}else{
DiffArr[k].x+=RPointOut.x-(double)TrackCurr.TrackP[k].x；
}
if(TrackCurr.TrackP[k].y＞RPointOut.y){
DiffArr[k].y+=(double)TrackCurr.TrackP[k].y-RPointOut.y；
}else{
DiffArr[k].y+=RPointOut.y-(double)TrackCurr.TrackP[k].y；
}
k++；
TrackCurr.NumOfPoints++；
DBasePoints.NumOfPoints++；
ModelPoints.NumOfPoints++；
}
perspective(hwnd，OriginSign.BmapGrey，DestBmap，SrcPnts，
CmPoly，GREY_MODEL，&BasicTransf)；
xysolve(hwnd，Normap，DestBmap，Shifts，Windows，9，&ModelPoints，
&TrackCurr，&NewTransf，hFile，&DBasePoints，DiffArr)；
<dp n="d267"/>
bm_free(DestBmap)；
for(i=0；i＜4；i++){
sprintf(String，＂Before ％d -％lf，％lf\n＂，i，SrcPnts[i].x，SrcPnts[i].y)；
_lwrite(hFile，String，strlen(String))；
//DstX=SrcPnts[i].x*NewTransf.Pf[0][0]+
// SrcPnts[i].y*NewTransf.Pf[1][0]+NewTransf.Pf[2][0]；
//DstY=SrcPnts[i].x*NewTransf.Pf[0][1]+
// SrcPnts[i].y*NewTransf.Pf[1][1]+NewTransf.Pf[2][1]；
//w=SrcPnts[i].x*NewTransf.Pf[0][2]+
// SrcPnts[i].y*NewTransf.Pf[1][2]+NewTransf.Pf[2][2]；
DstX=CmPoly[i].x*NewTransf.Pf[0][0]+
CmPoly[i].y*NewTransf.Pf[1][0]+NewTransf.Pf[2][0]；
DstY=CmPoly[i].x*NewTransf.Pf[0][1]+
CmPoly[i].y*NewTransf.Pf[1][1]+NewTransf.Pf[2][1]；
w=CmPoly[i].x*NewTransf.Pf[0][2]+
CmPoly[i].y*NewTransf.Pf[1][2]+NewTransf.Pf[2][2]；
DstPoly[i].x=DstX/w；
DstPoly[i].y=DstY/w；
sprintf(String，＂Vertex ％d -％lf，％lf\n＂，i，DstPoly[i].x，DstPoly[i].y)；
_lwrite(hFile，String，strlen(String))；
}
l_find_bound_rect(DstPoly，&GlBound)；
/* OCCLUSION
create_mask_bmap(hwnd，OriginSign.BmapGrey，SrcPnts，DstPoly，GlBound，&
MskBmap)；
fill_mask_rect(MskBmap)；
ValidateOccRects(MskBmap)；
copy_into_valid_rects()；
*/
//Ticks=GetTickCount()；
build_alpha_map(&AlphaMap，SrcBmap，DstPoly)；
//WriteGreyRgb(hwnd，＂alp.rgb＂，AlphaMap)；
perspective_al(hwnd，SubstBmap，SrcBmap，AlphaMap，SrcPoly，
DstPoly，glModelColor，&BasicTransf)；
//Perspective_map_al(Subs，&NewTransf，SrcBmap，AlphaMap，
// DstPoly，glModelColor)；
//perspective_mask(hwnd，SubstBmap，SrcBmap，AlphaMap，SrcPoly，
//TESTS
// DstPoly，glModelColor，InterpMode，MskBmap)；//TESTS
bm_free(AlphaMap)；
create_norm_bmap(hwnd，SrcBmap &Normap，GIBound)；//TESTS
if(ToDisplay==1){
InvalidateRect(hwnd，&GlBound，TRUE)；
}
return 1；
<dp n="d268"/>
int PASCAL WriteRgb (HWND hwnd，char *szFileName，MYBITMAP *Bmap)
{
PHDR phdr；
DWORD i.Offset；
long int Size；
HFILE hFile；
OFSTRUCT lpOpenBuff；
UINT ToWrite；
phdr.cols=Bmap-＞cols；
phdr.rows=Bmap-＞rows；
phdr.bp=24；
Size=(DWORD)phdr.cols*(DWORD)phdr.rows*(DWORD)3；
hFile=OpenFile(szFileName，&lpOpenBuff，OF_CREATE|OF_WRITE)；
_lwrite(hFile，&phdr，sizeof(phdr))；
Offset=0；
while(Size＞0){
ToWrite=min(32768ul，Size)；
_lwrite(hFile，Bmap-＞gpic+Offset，ToWrite)；
Offset+=ToWrite；
Size=ToWrite；
}
_lclose(hFile)；
return 1；
}
int PASCAL WriteGreyRgb (HWND hwnd，char *szFileName，MYBITMAP
*Bmap)
{
PHDR phdr；
DWORD i，Offset；
long int Size；
HFILE hFile；
OFSTRUCT lpOpenBuff；
UINT ToWrite；
BYTE huge *RgbArr；
BYTE huge *GreyTmp；
BYTE huge *Tmp；
DWORD GreySize；
phdr.cols=Bmap-＞cols；
phdr.rows=Bmap-＞rows；
<dp n="d269"/>
phdr.bp=24；
Size=(DWORD)phdr.cols*(DWORD)phdr.rows*(DWORD)3；
RgbArr=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
hFile=OpenFile(szFileName，&lpOpenBuff，OF_CREATE|OF_WRITE)；
_lwrite(hFile，&phdr，sizeof(phdr))；
Tmp=RgbArr；
GreyTmp=Bmap-＞gpic；
GreySize=(DWORD)phdr.cols*(DWORD)phdr.rows；
for(i=0；i＜GreySize；i++){
*(Tmp++)=*(GreyTmp)；
*(Tmp++)=*(GreyTmp)；
*(Tmp++)=*(GreyTmp++)；
}
Offset=0；
while(Size＞0){
ToWrite=min(32768ul，Size)；
_lwrite(hFile，RgbAn+Offset，ToWrite)；
Offset+=ToWrite；
Size=ToWrite；
}
_lclose(hFile)；
GlobalFreePtr(RgbArr)；
return 1；
}
int PASCAL WriteSign(HWND hwnd，char *szFileName，SIGN *Sign)
{
DWORD i，Number；
HFILE hFile；
OFSTRUCT lpOpenBuff；
char String[100]；
Number=Sign-＞TrPoints.NumOfPoints；
sprintf(String，＂％05d\n＂，10*Number+9+11)；
hFile=OpenFile(szFileName，&lpOpenBuff，OF_CREATE|OF_WRITE)；
_lwrite(hFile，String，strlen(String))；
_lwrite(hFile，＂orig.rgb\n＂，9)；
sprintf(String，＂％05d ％05d ％05d ％05d ％05d ％05d ％05d ％05d\n＂，
OrgX[0]，OrgY[0]，OrgX[1]，OrgY[1]，OrgX[2]，OrgY[2]，OrgX[3]，OrgY[3])；
_lwrite(hFile，String，strlen(String))；
sprintf(String，＂％05d\n＂，Number)；
<dp n="d270"/>
_lwrite(hFile，String，strlen(String))；
for(i=0；i＜Number；i++){
sprintf(String，＂％4d ％4d\n＂，Sign-＞TrPoints.TrackP[i].x，
Sign-＞TrPoints.TrackP[i].y)；
_lwrite(hFile，String，strlen(String))；
}
_lclose(hFile)
return 1；
}
int PASCAL ReadSign(HWND hwnd，char *szFileName，SIGN *Sign)
{
DWORD i，Number；
HFILE hFile；
OFSTRUCT lpOpenBuff；
char String[100]；
int NumOfBytes；
int NumOfPoints；
int Xval，Yval；
int Width，Height；
BYTE huge *Ptr；
hFile=OpenFile(szFileName，&lpOpenBuff，OF_READ)；
_lread(hFile，String，6)；//Size of bytes in File.
String[5]=′\0′；
sscanf(String，＂％d＂，&NumOfBytes)；
_lread(hFile，String，9)；//RGB File Name.
String[8]=′\0′；
Ptr=ReadRGB(hwnd，String，&Width，&Height)；
bm_free(Sign-＞Bmap)；
Sign-＞Bmap=bm_alloc(Width，Height，glModelColor)；
Sign-＞Bmap-＞gpic=Ptr；
create_lum_bmap(Sign-＞Bmap，&(Sign-＞BmapGrey))；
//WriteGreyRgb(hwnd，＂greyorg.rgb＂，Sign-＞BmapGrey)；
_tread(hFile，String，48)；
sscanf(String，＂％d ％d ％d ％d ％d ％d ％d ％d＂，&(SignX[0])，&(SignY[0])，
&(SignX[1 ])，&(SignY[1])，&(SignX[2])，&(SignY[2])，
&(SignX[3])，&(SignY[3]))；
_lread(hFile，String，6)；//Number of Points.
String[5]=′\0′；
sscanf(String，＂％d＂，&NumOfPoints)；
for(i=0；i＜NumOfPoints；i++){
_lread(hFile，String，10)；
String[9]=‘\0′；
<dp n="d271"/>
sscanf(String，＂％d ％d＂，&Xval，&Yval)；
Sign-＞TrPoints.TrackP[i].x=Xval；
Sign-＞TrPoints.TrackP[i].y=Yval；
}
Sign-＞TrPoints.NumOfPoints=NumOfPoints；
_lclose(hFile)；
return 1；
}
int PASCAL create_norm_bmap(HWND hwnd，MYBITMAP *Bmap，MYBITMAP
**NormBmap，
RECT ToValidate)
{
BYTE huge*TmpNorm；
BYTE huge*Tmp；
int Cols，Rows；
DWORD Size；
long i，j，k；
int RowLimit；
Cols=Bmap-＞cols；
Rows=Bmap-＞rows；
if(ToValidate.top==0){
if(*NormBmap !=NULL)bm_free(*NormBmap)；
*NormBmap=bm_alloc(Cols，Rows，GREY_MODEL)；
Size=(DWORD)Cols*(DWORD)Rows；
(*NormBmap)-＞gpic=(BYTE
huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
}
RowLimit=min(Rows，ToValidate.bottom)；
i=ToValidate.top；
Tmp=Bmap-＞gpic+(DWORD)i*(DWORD)Cols*(DWORD)3；
TmpNorm=(*NormBmap)-＞gpic+(DWORD)i*(DWORD)Cols；
while(i＜RowLimit){
for(j=0；j＜Cols；j++){
*(TmpNorm++)=(BYTE)((double)(*(Tmp++))*0.299+
(double)*(Tmp++)*0.587+(double)*(Tmp++)*0.114)；
}
i++；
}
return 1；
}
<dp n="d272"/>
int PASCAL create_mask_bmap(HWND hwnd，MYBITMAP
*GreyMdlBmap，RPOINT *SrcPoly，
RPOINT *DstPoly，RECT Bound.MYBITMAP
**MaskBmap)
{
MYBITMAP *BoundedBmap=NULL；
MYBITMAP *DiffBmap=NULL；
int Tresh；
char String[100]；
DWORD FromTime，ToTime；
DWORD Sum；
//WriteGreyRgb(hwnd，＂model.rgb＂，GreyMdlBmap)；
create_grey_bounded_bitmap(Bound，Normap，&BoundedBmap)；//Copy the
area to
//be changed into a
//separate bitmap.
//WriteGreyRgb(hwnd，＂boundO.rgb＂，BoundedBmap)；
perspective(hwnd，GreyMdlBmap，Normap，SrcPoly，
DstPoly，GREY_MODEL，&BasicTransf)；
//perspective_near(hwnd，GreyMdlBmap，Normap，SrcPoly，
// DstPoly，GREY_MODEL，&BasicTransf)；
//Perform perspective
//grey of the current sign
//with itself into NormBmap.
substract_bitmaps(Bound，Norrnap，BoundedBmap，&DiffBmap)；//Subtract
BoundedBmap
//from the transformed
//sign area in NormBmap.
sum_grey_bitmap_value(DiffBmap，&Sum)；
//spnntf(String，＂Sum is ％ld＂，Sum)；
//MessageBox(hwnd，String，szAppName，MB_ICONEXCLAMATION|
MB_OK)；
//WriteGreyRgb(hwnd，＂diff.rgb＂，DiffBmap)；
insert_grey_bounded_bitmap(Bound，BoundedBmap，Normap)；//retrieve
original
//picture into Normap.
median_filter_5(hwnd，DiffBmap)； //Creates a median
//filter on Diffbmap.
WriteGreyRgb(hwnd，＂diff1.rgb＂，DiffBmap)；
<dp n="d273"/>
get_tresh_for_occ(DiffBmap，&Tresh)；
//Gets the treshold
//for occlusion.
//sprintf(String，＂Tresh Value=％d＂，Tresh)；
//MessageBox(hwnd，String，szAppName，MB_ICONEXCLAMATION|
MB_OK)；
get_mask_bitmap(hwnd，DiffBmap，Tresh，MaskBmap)；
WriteGreyRgb(hwnd，＂diff2.rgb＂，*MaskBmap)；
bm_free(BoundedBmap)；
bm_free(DiffBmap)；
return 1；
}
int PASCAL SonySearch(HWND hwnd，int frame，int port)
{
char str[6]；
int i，input；
const int N_TRY=5；
char DataBuffer[128]；
char InputBuffer[128]；
int len；
int ErrCode；
char Stnng[50]；
COMSTAT IpStat；
sprintf(str，＂％05d＂，frame)；
DataBuffer[0]=0x43；//Search
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，InputBuffer，1)；
ErrCode=GetCommError(port，&lpStat)；
//sprintf(String，＂Error Code=％d＂，EnCode)；
//MessageBox(hwnd，String，szAppName，MB_ICONEXCLAMATION|
MB_OK)；
}
DataBuffer[0]=0x55；//Frame mode
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，lnputBuffer，1)；
}
for(i=0；i＜5；i++){
<dp n="d274"/>
DataBuffer[0]=str[i]；//Integer
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，InputBuffer，1)；
}
}
DataBuffer[0]=0x40；//Enter
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，InputBuffer，1)
}
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x01){
ReadComm(port，lnputBuffer，1)
}
return((int)(InputBurffer[0]))；
int PASCAL SonyRecord(HWND hwnd，int port)
{
char str[6]；
int i，input；
const int N_TRY=5；
BYTE DataBuffer[128]；
char InputBuffer[128]；
int len；
char Stnng[50]；
int ErrCode；
COMSTAT lpStat；
//sprinff(String，＂Before Frame Mode＂)；
//MessageBox(hwnd，String，szAppName，MB_ICONEXCLAMATION|
MB_OK)；
DataBuffer[0]=0x55；//FRAME # MODE
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，InputBuffer，1)；
//ErrCode=GetCommError(port，&lpStat)；
//sprintf(String，＂Error Code=％d＂，ErrCode)；
//MessageBox (hwnd，String，szAppName，MB_ICONEXCLAMATION|
MB_OK)；
}
<dp n="d275"/>
//sprintf(String，＂After Frame Mode＂)；
//MessageBox(hwnd，String，szAppName，MB_ICONEXCLAMATION|
MB_OK)；
DataBuffer[0]=0xEF；//BLANK SEARCH DISABLE
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，InputBuffer，1)；
}
//sprintf(String，＂After Blank enable Mode＂)；
//MessageBox(hwnd，String，szAppName，MB_ICONEXCLAMATION|
MB_OK)；
sprintf(str，＂％05ld＂，RecFrame)；
sprintf(String，＂STR=**％s***，str)；
DataBuffer[0]=0xE0；//REC StndBy
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
Readgomm(port，lnputBuffer，1)；
}
while(InputBuffer[0] !=0x01){
ReadComm(port，InputBuffer，1)
}
//sprintf(String，＂After Rec StandBy＂)；
//MessageBox(hwnd.String，szAppName，MB_ICONEXCLAMATION|
MB_OK)；
for(i=0；i＜5；i++){
DataBuffer[0]=str[i]；//Integer
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，lnputBuffer，1)；
}
}
DataBuffer[0]=0x40；//Enter
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，lnputBuffer，1)；
}
RecFrame++；
sprintf(str，＂％05ld＂，RecFrame)；
for(i=0；i＜5；i++){
<dp n="d276"/>
DataBuffer[0]=str[i]；//Integer
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，InputBuffer，1)；
}
}
DataBuffer[0]=0x40；//Enter
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，InputBuffer，1)；
}
DataBuffer[0]=0x40；//Enter
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，InputBuffer，1)；
}
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x01){
ReadComm(port，InputBuffer，1)；
}
DataBuffer[0]=0xE6；//Frame Rec Mode
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，InputBuffer，1)；
}
DataBuffer[0]=0xE9；//Record
WriteComm(port，DataBuffer，1)；
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x0A){
ReadComm(port，lnputBuffer，1)；
}
InputBuffer[0]=0x00；
while(InputBuffer[0] !=0x01){
ReadComm(port，InputBuffer，1)；
}
return((int)(InputBuffer[0]))；
}
static char RgbFileName[50]；
UINT FAR PASCAL_export TimerProc(HWND hwnd，UINT message，UINT
wParam.
LONG IParam)
<dp n="d277"/>
{
DWORD Sum；
int i；
switch(TimeElapsed){
case 0：
KillTimer(hwnd，1)；
if(PictCount＞=ToFr){
InSerieMode=0；
break；
}
sprintf(RgbFileName，＂pict％d.rgb＂，PictCount++)；
load_picture_from_file(hwnd，RgbFileName)；
TimeElapsed++；
SetTimer(hwnd，1，40，lpfnTimeProc)；
break；
case 1：
KillTimer(hwrd，1)；
//SendMessage(hwnd，WM_COMMAND，IDM_AUTO_TFACK，0)；
if(DummyFrames＜DYMMIES){
DummyFrames++；
TimeElapsed++；
SetTimer(hwnd，1，40，lpfnTimeProc)；
break；
}
if(ReplaceFlag==1){
change_sign_by_tracking(hwnd，0)；
}
TimeElapsed++；
SetTimer(hwnd，1，40，lpfnTimeProc)；
break；
case 2：
KillTimer(hwnd，1)；
draw_field_to_screen(hwnd，SrcBmap，IsOddLine)；
//draw_to_screen(SrcBmap，0，SrcBmap-＞cols)；
TimeElapsed++；
SetTimer(hwnd，1，40，lpfnTimeProc)；
break；
case 3：
KillTimer(hwnd，1)；
if(IsOddLine==1){ //TTTTTTT
SonyRecord(hwnd，PortNumber)；//TTTTTTT
//IsOddLine=1-IsOddLine；
//TimeElapsed=0；
//break；
} //TTTTTTTT
IsOddLine=1-IsOddLine；
TimeElapsed++；
SetTimer(hwnd，1,1000，lpfnTimeProc)；
<dp n="d278"/>
break；
case 4：TimeElapsed++；
break；
default：
TimeElapsed=0；
break；
}
return 1；
}
/*
UINT FAR PASCAL_export TimerProc(HWND hwnd，UINT message，UINT
wParam，
LONG IParam)
{
DWORD Sum；
int i；
switch(TimeElapsed){
case 0：
KillTimer(hwnd，1)；
//MessageBox(hwnd，＂Before Search＂，szAppName，
MB_ICONEXCLAMATION|MB_OK)；
SonySearch(hwnd，SearchFrame，PortNumber)；
SearchFrame++；
//MessageBox(hwnd，＂After Search＂，szAppName，
MB_ICONEXCLAMATION|MB_OK)；
mfg_setvframe(RGB)；
mfg_dacmode(TRUE_24)；
TimeElapsed++；
mfg_snap(CAMERA，PAGE1)；
SetTimer(hwnd，1，40，lpfnTimeProc)
break；
case 1：
KillTimer(hwnd，1)；
if(PictCount＞=ToFr){
InSerieMode=0；
break；
}
sprintf(RgbFileName，＂pict％d，rgb＂，PictCount++)；
load_field_from_card(hwnd，0)；
WriteRgb(hwnd，RgbFileName，SrcBmap)；
sprintf(RgbFile Name，＂pict％drgb＂，PictCount++)；
load_field_from_card(hwnd，1)；
WriteRgb(hwnd，RgbFileName，SrcBmap)；
SetTimer(hwnd，1，40，lpfnTimeProc)；
<dp n="d279"/>
TimeElapsed++；
break；
default：
TimeElapsed=0；
break；
}
return 1；
}
*/
int PASCAL load_field_from_card(HWND hwnd，int NumOfField)
{
DWORD Size；
BYTE huge *RedBytes；
BYTE huge *GreenBytes；
BYTE nuge *BlueBytes；
int j，k；
DWORD Ticks；
char Stnng[50]；
Ticks=GetTickCount()；
//Size=(DWORD)572*(DWORD)768*(DWORD)3；
Size=(DWORD)286*(DWORD)768*(DWORD)3；
if(SrcBmap !=NULL)bm_free(SrcBmap)；
SrcBmap=bm_alloc(768，286，glModelColor)；
SrcBmap-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
RedBytes=SrcBmap-＞gpic；
GreenBytes=SrcBmap-＞gpic+1；
BlueBytes=SrcBmap-＞gpic+2；
mfg_setgframe(R)；
for(k=NumOfField；k＜572；k++){
mfg_brhline(PAGE0，0，k++，768，rpixarr)；
for(j=0；j＜768；j++){
*RedBytes=rpixarr[j]；
RedBytes+=3；
}
}
mfg_setgframe(G)；
for(k=NumOfField；k＜572；k++){
mfg_brhline(PAGE0，0，k++，768，rpixarr)；
for(j=0；j＜768；j++){
*GreenBytes=rpixarr[j]；
GreenBytes+=3；
}
}
mfg_setgframe(B)；
for(k=NumOfField；k＜572；k++){
<dp n="d280"/>
mfg_brhline(PAGE0，0，k++，768，rpixarr)；
for(j=0；j＜768；j++){
*BlueBytes=rpixarr[j]；
BlueBytes+=3；
}
}
sprintf(String，＂Time=％ld＂，GetTickCount()-Ticks)；
MessageBox(hwnd，szAppName，String，MB_ICONEXCLAMATION|
MB_OK)；
teach_rgb_pallete(hwnd)；
FileType=FILE IS RGB；
GetClienlRect(hwnd，&ClientRect)；
create_norm_bmap(hwnd，SrcBmap，&Normap，ClientRect)；
return 1；
}
int PASCAL load_picture_from_card(HWND hwnd)
{
DWORD Size；
BYTE huge *RedBytes；
BYTE huge *GreenBytes；
BYTE huge *BlueBytes；
int j，k；
Size=(DWORD)572*(DWORD)768*(DWORD)3；
if(SrcBmap !=NULL)bm_free(SrcBmap)；
SrcBmap=bm_alloc(768，572，glModelColor)；
SrcBmap-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
RedBytes=SrcBmap-＞gpic；
GreenBytes=SrcBmap-＞gpic+1；
BlueBytes=SrcBmap-＞gpic+2；
mfg_setgframe(R)；
for(k=0；k＜572；k++){
mfg_brhline(PAGE0，0，k，768，rpixarr)；
for(j=0；j＜768；j++){
*RedBytes=rpixarr[j]；
RedBytes+=3；
}
}
mfg_setgframe(G)；
for(k=0；k＜572；k++){
mfg_brhline(PAGE0，0，k，768，rpixarr)；
for(j=0；j＜768；j++){
*GreenBytes=rpixarr[j]；
GreenBytes+=3；
}
}
<dp n="d281"/>
mfg_setgframe(B)；
for(k=0；k＜572；k++){
mfg_brhline(PAGE0，0，k，768，rpixarr)；
for(j=0；j＜768；j++){
*BlueBytes=rpixarr[j]；
BlueBytes+=3；
}
}
//if(InterpMode==IN_TRILINEAR)
//build_pyramid(hwnd，SrcBmap)；
teach_rgb_pallete(hwnd)；
FileType=FILE_IS_RGB；
GetClientRect(hwnd，&ClientRect)；
create_norm_bmap(hwnd，SrcBmap，&Normap，ClientRect)；
return 1；
}
int PASCAL load_picture_from_file(HWND hwnd，char *FileName)
{
int ColorFactor；
int Width，Height；
DWORD SrcSize；
DWORD i；
if(glModelColor==GREY_MODEL) {
ColorFactor=1；
lpGreyRgb=ReadRGB(hwnd，FileName，&Width，&Height)；
lpPtr=lpGreyRgb；
}
if(glModelColor==COLOR_MODEL){
ColorFactor=3；
lpPtr=ReadRGB(hwnd，FileName，&Width，&Height)；
}
IsRgb=1；
bm_free(SrcBmap)；
SrcBmap=bm_alloc(Width，Height，glModelColor)；
if(SrcBmap==NULL){
MessageBox(hwnd，szAppName，＂bm_alloc
Failed!＂，MB_ICONEXCLAMATION|MB_OK)；
return 0；
}
SrcSize=(DWORD)Width*(DWORD)(Height)*(DWORD)(ColorFactor)；
SrcBmap-＞gpic=lpPtr；
if(SplitMode==1 && SrcBmap !=NULL){
split_bitmap(SrcBmap，SrcBmap-＞typ，30)；// NEW CALL
}
GetClientRect(hwnd，&ClientRect)；
<dp n="d282"/>
create_norm_bmap(hwnd，SrcBmap，&Normap，ClientRect)；
return 1；
}
int PASCAL draw_field_to_screen(HWND hwnd，MYBITMAP *Bmap，int
IsOdd)
{
int i，j；
BYTE huge *Ptr；
BYTE huge *PtrR；
BYTE huge *PtrG；
BYTE huge *PtrB；
int Cols，Rows；
IsOdd=1-IsOdd；//PATCH
Cols=Bmap-＞cols；
Rows=(DWORD)(Bmap-＞rows)*(DWORD)2；
Ptr=Bmap-＞gpic；
//Ptr+=(DWORD)IsOdd*(DWORD)Cols*(DWORD)3；
PtrR=Ptr；
PtrG=Ptr+1；
PtrB=Ptr+2；
nfg_setgframe(R)；
for(i=IsOdd；i＜Rows；i+=2){
for(j=0；j＜Cols；j++){
rpixarr[j]=*PtrR；
PtrR+=3；
}
//PtrR+=(DWORD)Cols+(DWORD)3；
mfg_bwhline(PAGE0，0，i，Cols，rpixarr)；
}
mfg_setgfiame(G)；
for(i=IsOdd；i＜Rows；i+=2){
for(j=0；j＜Cols；j++){
rpixarr[j]=*PtrG；
PtrG+=3；
}
//PtrG+=(DWORD)Cols+(DWORD)3；
mfg_bwhline(PAGE0，0，i，Cols，rpixarr)；
}
mfg_setgframe(B)；
for(i=IsOdd；i＜Rows；i+=2){
for(j=0；j＜Cols；j++){
rpixarr[j]=*PtrB；
PtrB+=3；
}
//PtrB+=(DWORD)Cols+(DWORD)3；
mfg_bwhline(PAGE0，0，i，Cols，rpixarr)；
}
<dp n="d283"/>
return 1；
}
int PASCAL get_fittness_of_vertexes(HWND hwnd，RECT Bound，MYBITMAP
*Bmap
RPOINT *DstPnts，DWORD *Sum)
{
MYBITMAP *BoundedBmap=NULL；
MYBITMAP *DiffBmap=NULL；
RPOINT SrcPnts[4]；
l_cp_int_arr_to_RPOINT(SrcPnts，SignX，SignY，4)；
create_grey_bounded_bitmap(Bound，Normap，&BoundedBmap)；//Copy the
area to
//be changed into a
//separate bitmap.
perspective(hwnd，Bmap，Normap，SrcPnts，
DstPnts，GREY_MODEL，&BasicTransf)；
//Perform perspective
//grey of the current sign
//with itself into NormBmap.
substract_bitmaps(Bound，Normap，BoundedBmap，&DiffBmap)；//Subtract
BoundedBmap
//from the transformed
//sign area in NormBmap.
sum_grey_bitmap_value(DiffBmap，Sum)；
bm_free(BoundedBmap)；
bm_free(DiffBmap)；
return 1；
}
int PASCAL replace_sign(HWND hwnd，RPOINT *Dest)
{
MYBITMAP *AlphaMap；
build_alpha_map(&AlphaMap，SrcBmap，Dest)；
perspective_al(hwnd，SubstBmap，SrcBmap，AlphaMap，SrcPoly
Dest，glModelColor，&BasicTransf)；
bm_free(AlphaMap)；
create_norm_bmap(hwnd，SrcBmap，&Normap，GlBound)
return 1；
}
<dp n="d284"/>
int PASCAL smooth_values(double NewVal，double *OutVal，double *ValArr，
int Num，double *Wheight)
{
int i；
double SumW=0.0；
double Calc；
for(i=0；i＜Num-1；i++){
ValArr[i]=ValArr[i+1]；
}
ValArr[Num-1]=NewVal；
Calc=0；
for(i=0；i＜Num；i++){
Calc+=ValArr[i]*Wheight[i]；
SumW+=Wheight[i]；
}
*OutVal=Calc/SumW；
return 1；
}
int PASCAL create_subs_sign(HWND hwnd)
{
//Perspective_Transform TpCurr；
Perspective_Transform BasicTransf；
RECT Rectan；
int Cols，Rows；
DWORD Size；
RPOINT SrcPnts[4]；
RPOINT CmPoly[4]；
//Quad2Quad(hwnd，SrcPoly，DstPoly，&TpCurr)；
l_find_bound_rect(DstPoly，&Rectan)；
Cols=Rectan.right-Rectan.left+1；
Rows=Rectan.bottom-Rectan.top+1；
l_quad_in_new_origin(CrnPoly.DstPoly，Rectan.left，Rectan.top，4)；
bm_free(Subs)；
Subs=bm_alloc(Cols，Rows，COLOR_MODEL)；
Size=(DWORD)Cols*(DWORD)Rows*(DWORD)3；
Subs-＞gpic=(BYTE huge*)GlcbaiAllocPtr(GMEM_MOVEABLE，Size)；
perspective(hwnd，SubstBmap，Subs，SrcPoly，
CmPoly，COLOR_MODEL，&BasicTransf)；
<dp n="d285"/>
return 1；
}
int PASCAL fill_mask_rect(MYBITMAP *Bmap)
{
int i，j，k，l；
int Cols，Rows；
int Count；
int Index=0；
Cols=Bmap-＞cols；
Rows=Bmap-＞rows；
Count=0；
for(i=0；i＜Cols；i++){
if(BITMAP_PLACE(Bmap，0，i)==0)Count++
else{
if(Count＞0){
OcclusionRects(Index].top=0；
OcclusionRects[Index].left=i-Count+1；
OcclusionRects[Index].bottom=Rows；
OcclusionRects[Index].right=i/*+Count/3 */；// IF BUG i.
Index++；
Count=0；
}
}
}
if(Index==0 && NumOfValidOccRects＞0){
OcclusionRects[0]=ValidOccRects[0]；
OcclusionRects[0].right=min(OcclusionRects[0].right+2，Cols-1)；
OcclusionRects[0].bottom=Rows；
for(k=OcclusionRects[0].top；k＜OcclusionRects[0].bottom；k++){
for(l=OcclusionRects[0].left；l＜OcclusionRects[0].right；l++){
BITMAP_PLACE(Bmap，k，l)=0；
}
}
Index=1；
}
NumOfOccRects=Index；
return 1；
}
int PASCAL ValidateOccRects(MYBITMAP *Bmap)
{
int i，j，k，l；
RECT Intersection；
int Index=0；
<dp n="d286"/>
for(j=0；j＜NumOfValidOccRects；j++){
for(i=0；i＜NumOfOccRects；i++){
IntersectRect(&Intersection，&(OcclusionRects[i])，&(ValidOccRects[j]))；
if(intersection.bottom==0){
for(k=OcclusionRects[i].top；k＜OcclusionRects[i].bottom；k++)
{
for(l=OcclusionRects[i].left；l＜OcclusionRects[i].right；l++){
BITMAP_PLACE(Bmap，k，l)=1；
}
}
}
}
}
return 1；
}
int PASCAL copy_into_valid_rects()
{
int i；
for(i=0；i＜NumOfOccRects；i++){
ValidOccRects[i]=OcclusionRects[i]；
}
NumOfValidOccRects=NumOfOccRects；
return 1；
}
int PASCAL enlarge_area_of_noise(MYBITMAP *From，MYBITMAP *Bmap)
{
int i，j；
int Cols，Rows；
RECT Rectan；
Cols=Bmap-＞cols；
Rows=Bmap-＞rows；
for(j=4；j＜Cols-4；j+=3){
for(i=4；i＜Rows-4；i++){
Rectan.top=i-3；
Rectan.left=j-3；
Rectan.right=j+3；
Rectan.bottom=i+3；
filter_noises_by_rects(From，Rectan，8，25，Bmap)；
}
}
return 1；
}
<dp n="d287"/>
#include ＜windows.h＞
#include ＜windowsx.h＞
#include ＜commdlg.h＞
#include ＜stdlib.h＞
#include ＜math.h＞
#include ＂const.h＂
#include ＂bitmap.h＂
#include ＂lines.h＂
#include ＂track.h＂
#include ＂min_mag.h＂
#include ＂lib.h＂
RECT Screen；
MYBITMAP FAR *dMaps[1+DLVLS]；
MYBITMAP FAR *iMaps[1+ILVLS]；
int PASCAL refine_alpha_edges(MYBITMAP*)；
int PASCAL get_longest_occlusion(MYBITMAP*，int，int)；
MYBITMAP FAR*bm_alloc(int xdim，int ydim，BMTYPE typ)
{
MYBITMAP FAR* bm；
bm={MYBITMAP FAR*)
GlobalAllocPtr(GMEM_MOVEABLE，sizeof(MYBITMAP))；
if(bm==NULL)
return NULL；
bm-＞typ=typ；
bm-＞cols=xdim；
bm-＞rows=ydim；
bm-＞gpic=NULL；
return(bm)；
}
<dp n="d288"/>
double PASCAL bilinear(double xs，double ys，MYBITMAP FAR* bmap)
{
int yi=(int)ys；
double dy=ys-(double)yi；
int xi=(int)xs；
double dx=xs-(double)xi；
double g00，g01，g10，g11，g1，g2；
if(xi＜0||xi＞=bmap-＞cols)
return(-1.0)；
if(yi＜0||yi＞=bmap-＞rows)
return(-1.0)；
g00=BITMAP_PLACE(bmap，yi，xi)；
g01=(xi==bmap-＞cols-1?g00：BITMAP_PLACE(bmap，yi，xi+1))；
g10=(yi==bmap-＞rows-1?g00：BITMAP_PLACE(bmap，yi+1，xi))；
g11=(xi==bmap-＞cols-1||yi==bmap-＞rows-1?
g00：BITMAP_PLACE(bmap，yi+1，xi+1))；
g1=g00+(g01-g00)*dx；
g2=g10+(g11-g10)*dx；
return(g1+(g2-g1)*dy)；
}
double PASCAL bilinear_red(double xs，double ys，MYBITMAP FAR* bmap)
{
int yi=(int)ys；
double dy=ys-(double)yi；
int xi=(int)xs；
double dx=xs-(double)xi；
double g00，g01，g10，g11，g1，g2；
if(xi＜0||xi＞=bmap-＞cols)
return(-1.0)；
if(yi＜0||yi＞=bmap-＞rows)
return(-1.0)；
g00=BITMAP_RGB_PLACE(bmap，yi，xi)；
<dp n="d289"/>
g01=(xi==bmap-＞cols-1?g00：
*(BITMAP_RGB_PLACE_PTR(bmap，yi，xi+1)))；
g10=(yi==bmap-＞rows-1?g00
：*(BITMAP_RGB_PLACE_PTR(bmap，yi+1，xi)))；
g11=(xi==bmap-＞cols-1||yi==bmap-＞rows-1?
g00：*{BITMAP_RGB_PLACE_PTR(bmap，yi+1，xi+1)))；
g1=g00*(1.0-dx)+g01*dx；
g2=g10*(1.0-dx)+g11*dx；
return(g1*(1.0-dy)+g2*dy)；
double PASCAL bilinear_green(double xs，double ys，MYBITMAP FAR*
bmap)
{
int yi=(int)ys；
double dy=ys-(double)yi；
int xi=(int)xs；
double dx=xs-(double)xi；
double g00，g01，g10，g11，g1，g2；
if(xi＜0||xi＞=bmap-＞cols)
return(-1.0)；
if(yi＜0||yi＞=bmap-＞rows)
return(-1.0)；
g00=*(BrTMAP_RGB_PLACE_PTR(bmap，yi，xi)+1)；
g01=(xi==bmap-＞cols-1?g00：
*(BITMAP_RGB_PLACE_PTR(bmap，yi，xi+1)+1))；
g10=(yi==bmap-＞rows-1?g00：
*(BITMAP_RGB_PLACE_PTR(bmap，yi+1，xi)+1))；
g11=(xi==bmap-＞cols-1||yi==bmap-＞rows-1?
g00：*(BITMAP_RGB_PLACE_PTR(bmap，yi+1，xi+1)+1))；
g1=g00*(1.0-dx)+g01*dx；
g2=g10*(1.0-dx)+g11*dx；
return(g1*(1.0-dy)+g2*dy)；
}
<dp n="d290"/>
double PASCAL bilinear_blue(double xs，double ys，MYBITMAP FAR* bmap)
{
int yi=(int)ys；
double dy=ys-(double)yi；
int xi=(int)xs；
double dx=xs-(double)xi；
double g00，g01，g10，g11，g1，g2；
if(xi＜0||xi＞=bmap-＞cols)
return(-1.0)；
if(yi＜0||yi＞=bmap-＞rows)
return(-1.0)；
g00=*(BITMAP_RGB_PLACE_PTR(bmap，yi，xi)+2)；
g01=(xi==bmap-＞cols-1?g00
：*(BITMAP_RGB_PLACE_PTR(bmap，yi，xi+1)+2))；
g10={yi==bmap-＞rows-1?g00
：*(BITMAP_RGB_PLACE_PTR(bmap，yi+1，xi)+2))；
g11=(xi==bmap-＞cols-1||yi==bmap-＞rows-1?
g00：*(BITMAP_RGB_PLACE_PTR(bmap，yi+1，xi+1)+2))；
g1=g00*(1.0-dx)+g01*dx；
g2=g10*(1.0-dx)+g11*dx；
return(g1*(1.0-dy)+g2*dy)；
}
int PASCAL multmat(HWND hwnd，int Ma，int Na，int Nb，double *A，double
*B，double *C)
{
int i，j，k；
for(i=0；i＜Ma；i++){
for(j=0；j＜Nb；j++){
C[(DWORD)i*(DWORD)Nb+(DWORD)j]=0.0；
for(k=0；k＜Na；k++){
C[(DWORD)i*(DWORD)Nb+(DWORD)j]+=
A[(DWORD)i*(DWORD)Na+(DWORD)k]*
B[(DWORD)k*(DWORD)Nb+(DWORD)j]；
}
<dp n="d291"/>
}
}
return 1；
}
double PASCAL resample_trilinear(MYBITMAP FAR* bmap，double xs，
double ys，
double D，int ColorModel)
{
int id，i，mag；
double fMag，hMag；
double g1，g2，alpha，g；
if(D＜=1.0)//magnified pyramid level not used
return(bilinear(xs，ys，bmap))；
id=(int)ceil(D)；
for(i=1；i＜=DLVLS；i++){
mag=(1＜＜i)；
if(mag＞=id)
break；
}
if(i＞DLVLS)//interplation is bi-linear
return(bilinear(xs，ys，dMaps[ILVLS]))；
fMag=mag；
hMag=mag/2；
g1=bilinear(xs/hMag，ys/hMag，dMaps[i-1])；
g2=bilinear(xs/fMag，ys/fMag，dMaps[i])；
alpha=(D-hMag)/hMag；
g=g1*(1.0-alpha)+g2*alpha；
return(g)；
}
double PASCAL resample_trilinear_red(MYBITMAP FAR* bmap，double xs，
double ys，
<dp n="d292"/>
double D，int ColorModel)
{
int id，i，mag；
double fMag，hMag；
double g1，g2，alpha，g；
if(D＜=1.0)//magnified pyramid level not used
return(bilinear_red(xs，ys，bmap))；
id=(int)ceil(D)；
for(i=1；i＜=DLVLS；i++){
mag=(1＜＜i)；
if(mag＞=id)
break；
}
if(i＞DLVLS)//interplation is bi-linear
return(bilinear_red(xs，ys，dMaps[ILVLS]))；
fMag=mag；
hMag=mag/2；
g1=bilinear_red(xs/hMag，ys/hMag，dMaps[i-1])；
g2=bilinear_red(xs/fMag，ys/fMag，dMaps[i])；
alpha=(D-hMag)/hMag；
g=g1*(1.0-alpha)+g2*alpha；
return(g)；
}
double PASCAL resample_trilinear_green(MYBITMAP FAR* bmap，double
xs，double ys，
double D，int ColorModel)
{
int id，i，mag；
double fMag，hMag；
double g1，g2，alpha，g；
if(D＜=1.0)//magnified pyramid level not used
<dp n="d293"/>
return(bilinear_green(xs，vs，bmap))；
id=(int)ceil(D)；
for(i=1；i＜=DLVLS；i++){
mag=(1＜＜i)；
if(mag＞=id)
break；
}
if(i＞DLVLS)//interplation is bi-linear
return(bilinear_green(xs，ys，dMaps[ILVLS]))；
fMag=mag；
hMag=mag/2；
g1=bilinear_green(xs/hMag，ys/hMag，dMaps[i-1])；
g2=bilinear_green(xs/fMag，ys/fMag，dMaps[i])；
alpha=(D-hMag)/hMag；
g=g1*(1.0-alpha)+g2*alpha；
return(g)；
}
double PASCAL resample_trilinear_blue(MYBITMAP FAR* bmap，double xs，
double ys，
double D，int ColorModel)
{
int id，i，mag；
double fMag，hMag；
double g1，g2，alpha，g；
if(D＜=1.0)//magnified pyramid level not used
return(bi1linear_blue(xs，ys，bmap))；
id=(int)ceil(D)；
for(i=1；i＜=DLVLS；i++){
mag=(1＜＜i)；
if(mag＞=id)
break；
}
<dp n="d294"/>
if(i＞DLVLS)//interplation is bi-linear
return(bilinear_blue(xs，ys，dMaps[ILVLS]))；
fMag=mag；
hMag=mag/2；
g1=bilinear_blue(xs/hMag，ys/hMag，dMaps[i-1])；
g2=bilinear_blue(xs/fMag，ys/fMag，dMaps[i])；
alpha=(D-hMag)/hMag；
g=g1*(1.0-alpha)+g2*alpha；
return(g)；
int PASCAL build_pyramid(HWND hwnd，MYBITMAP FAR*SrcBmap)
{
int i；
dMaps[0]=iMaps[0]=SrcBmap；
for(i=1；i＜=DLVLS；i++){
dMaps[i]=minify(hwnd，dMaps[i-1]，2)；
}
return 1；
}
int PASCAL bm_free(MYBITMAP FAR* BtMap)
{
if(BtMap!=NULL){
GlobalFreePtr(BtMap-＞gpic)；
GlobalFreePtr(BtMap)；
}
return 1；
}
int PASCAL find_honz_line(MYBITMAP *Bmap，POINT Point1，POINT Point2，
RPOINT *Line)
{
<dp n="d295"/>
int i，j，Ri，Rj；
double Luma1[7][7]；
double Luma2[7][7]；
double r，g，b；
double Tresh=70；
RPOINT Found1，Found2；
int Found；
for(i=Point1.y-3，Ri=0；Ri＜7；i++，Ri++){
for(j=Point1.x-3，Rj=0；Rj＜7；j++，Rj++){
r=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j))；
g=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j)+1)；
b=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j)+2)；
Luma1[Ri][Rj]=r*0.299+g*0.587+b*0.114；
}
}
for(i=Point2.y-3，Ri=0；Ri＜7；i++，Ri++){
for(j=Point2.x-3，Rj=0；Rj＜7；j++，Rj++){
r=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j))；
g=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j)+1)；
b=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j)+2)；
Luma2[Ri][Rj]=r*0.299+g*0.587+b*0.114；
}
}
Found=0；
Found1.x=Point1.x；
Found1.y=Point1.y；
for(i=1；i＜6 && Found==0；i++){
for(j=0；j＜6；j++){
if(fabs(Luma1[i-1][j]-Luma1[i][j])＞=Tresh){
if(fabs(Luma1[i-1][j+1]-Luma1[i][j+1])＞=Tresh||
fabs(Luma1[i+1][j+1]-Luma1[i][j+1])＞=Tresh){
Found1.x=Point1.x-3+j；
Found1.y=Point1.y-3+i；
Found=1；
break；
}
}
<dp n="d296"/>
}
}
Found=0；
Found2.x=Point2.x；
Found2.y=Point2.y；
for(i=1；i＜6 && Found==0；i++){
for(j=0；j＜6；j++){
if(fabs(Luma2[i-1][j]-Luma2[i][j])＞=Tresh){
if(fabs(Luma2[i-1][j+1]-Luma2[i][j+1])＞=Tresh||
fabs(Luma2[i+1][j+1]-Luma2[i][j+1])＞=Tresh){
Found2.x=Point2.x-3+j；
Found2.y=Point2.y-3+i；
Found=1；
break；
}
}
}
}
Line-＞y=(Found2.x*Found1.y-Found2.y*Found1.x)/(Found2.x-Found1.x)；
Line-＞x=(Found1.y-Line-＞y)/Found1.x；
return 1；
}
int PASCAL find_vertic_line(MYBITMAP *Bmap，POINT Point1，POINT
Point2，RPOINT *Line)
{
int i，j，Ri，Rj；
double Luma1[7][7]；
double Luma2[7][7]；
double r，g，b；
double Tresh=70；
RPOINT Found1，Found2；
int Founc；
for(i=Point1.y-3，Ri=0；Ri＜7；i++，Ri++){
for(j=Point1.x-3，Ri=0；Rj＜7；j++，Rj++){
<dp n="d297"/>
r=*(BITMAP_RGB_PLACE_PTR(Bmap，ij))；
g=*(BITMAP_RGB_PLACE_PTR(Bmap，ij)+1)；
b=*(BITMAP_RGB_PLACE_PTR(Bmap，ij)+2)；
Luma1[Ri][Rj]=r*0.299+g*0.587+b*0.114；
}
}
for(i=Point2.y-3，Ri=0；Ri＜7；i++，Ri++){
for(j=Point2.x-3，Rj=0；Rj＜7；j++，Rj++){
r=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j))；
g=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j)+1)；
b=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j)+2)；
Luma2[Ri][Rj]=r*0.299+g*0.587+b*0.114；
}
}
Found=0；
Found1.x=Point1.x；
Found1.y=Point1.y；
for(i=0；i＜6 && Found==0；i++){
for(j=0；j＜6；j++){
if(fabs(Luma1[i][j]-Luma1[i][j+1])＞=Tresh){
if(fabs(Luma1[i+1][j]-Luma1[i+1][j+1])＞=Tresh){
Found1.x=Point1.x-3+j；
Found1.y=Point1.y-3+i；
Found=1；
break；
}
}
}
}
Found=0；
Found2.x=Point2.x；
Found2.y=Point2.y；
for(i=0；i＜6 && Found==0；i++){
for(j=0；j＜6；j++){
if(fabs(Luma2[i][j]-Luma2[i][j+1])＞=Tresh){
if(fabs(Luma2[i+1][j]-Luma2[i+1][j+1])＞=Tresh){
Found2.x=Point2.x-3+j；
Found2.y=Point2.y-3+i；
<dp n="d298"/>
Found=1；
break；
}
}
}
}
if(Found2.x==Found1.x){
Line-＞y=0.0；
Line-＞x=Found1.x；
}else{
Line-＞y=(Found2.x*Found1.y-Found2.y*Found1.x)/(Found2.x-Found1.x)；
Line-＞x=(Found1.y-Line-＞y)/Found1.x；
}
return 1；
}
#define HSx 5/* Half search area (x) */
#define HSy 5/* Half search area (y) */
#define HWx 4/* Half correlation window (x) */
#define HWy 4/* Half correlation window (y) */
int PASCAL create_lum_bmap(MYBITMAP *Bmap，MYBITMAP **LumBmap)
{
BYTE huge*Tmp；
BYTE huge*TmpB；
int Cols，Rows；
DWORD Size；
DWORD i；
Cols=Bmap-＞cols；
Rows=Bmap-＞rows；
Tmp=Bmap-＞gpic；
<dp n="d299"/>
bm_free(*LumBmap)；
*LumBmap=bm_alloc(Cols，Rows，GREY_MODEL)；
Size=(DWORD)Cols*(DWORD)Rows；
(*LumBmap)-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE.Size)
；
TrmpB=(*LumBmap)-＞gpic；
Tmp=Bmap-＞gpic；
for(i=0；i＜Size；i++){
*(TmpB++)=(BYTE)((double)(*(Tmp++))*0.299+
(double)*(Tmp++)*0.587+(double)*(Tmp++)*0.114)；
}
return 1；
}
int PASCAL duplicate_bmap(MYBITMAP *FrBmap，MYBITMAP **ToBmap，int
Type)
{
BYTE huge*Tmp；
BYTE huge*TmpB；
int Cols，Rows；
DWORD Size；
DWORD i；
int ColorFactor=1；
Cols=FrBmap-＞cols；
Rows=FrBmap-＞rows；
if(Type==COLOR_MODEL)ColorFactor=3；
Tmp=FrBmap-＞gpic；
if(*ToBmap !=NULL)bm_free(*ToBmap)；
*ToBmap=bm_alloc(Cols，Rows，Type)；
Size=(DWORD)Cols*(DWORD)Rows*(DWORD)ColorFactor；
<dp n="d300"/>
(*ToBmap)-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
TmpB=(*ToBmap)-＞gpic；
Tmp=FrBmap-＞gpic；
for(i=0；i＜Size；i++){
*(TmpB++)=*(Tmp++)；
}
return 1；
}
int PASCAL create_grey_bounded_bitmap(RECT area，MYBITMAP
*Bmap，MYBITMAP **BoundBmap)
{
int i，j；
int Cols，Rows；
DWORD Size；
BYTE huge* Tmp；
Cols=area.right-area.left；
Rows=area.bottom-area.top；
bm_free(*BoundBmap)；
*BoundBmap=bm_alloc(Cols，Rows，GREY_MODEL)；
Size=(DWORD)Cols*(DWORD)Rows；
(*BoundBmap)-＞gpic=(BYTE
huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
Trmp=(*BoundBmap)-＞gpic；
for(i=area.top；i＜area.bottom；i++){
for(j=area.left；j＜area.right；j++){
*(Tmp++)=BITMAP_PLACE(Bmap，i，j)；
}
}
return 1；
}
<dp n="d301"/>
int PASCAL substract_bitmaps(RECT area，MYBITMAP *From，MYBITMAP
*Subs，
MYBITMAP **Diff)
{
DWORD Size；
int Cols，Rows；
int i；j；
BYTE huge* Tmp；
Cols=Subs-＞cols；
Rows=Subs-＞rows；
bm_free(*Diff)；
*Diff=bm_alloc(Cols，Rows，GREY_MODEL)；
Size=(DWORD)Cols*(DWORD)Rows；
(*Diff)-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
Tmp=(*Diff)-＞gpic；
for(i=area.top；i＜area.bottom；i++){
for(j=area.left；j＜area.right；j++){
*(Tmp++)=(BYTE)abs((int)(BTTMAP_PLACE(From，i，j)-
BITMAP_PLACE(Subs，i-area.top，j-area.left)))；
}
}
return 1；
}
int PASCAL insert_grey_bounded_bitmap(RECT area，MYBITMAP *Tolnsert，
MYBITMAP *Into)
{
int i，j；
for(i=area.top；i＜area.bottom；i++){
for(j=area.left；j＜area.right；j++){
BITMAP_PLACE(Into，i，j)=
BITMAP_PLACE(Tolnsert，i-area.top，j-area.left)；
}
}
<dp n="d302"/>
return 1；
}
int PASCAL copy_grey_rect_from_frame(MYBITMAP *Into，MYBITMAP
*From，
RECT area)
{
int i，j；
for(i=area.top；i＜area.bottom；i++){
for(j=area.left；j＜area.right；j++){
BITMAP_PLACE(Into，i-area.top，j-area.left)=BITMAP_PLACE(From，i，j)
}
return 1；
}
int PASCAL build_alpha_map(MYBITMAP **AlphaMap，MYBITMAP
*SrcBmap，RPOINT *Vertex)
{
int i，j；
RECT Rectan；
int Cols，Rows；
SEG lines[4]；
DWORD Size；
RPOINT Points[4]；
double Xval，Xmin，Xmax；
int Curr；
Cols=SrcBmap-＞cols；
Rows=SrcBmap-＞rows；
l_find_bound_rect(Vertex，&Rectan)；
for(i=0；i＜3；i++){
mksegment(Vertex[i].x，Vertex[i].y，Vertex[i+1].x，Vertex[i+1].y，&(lines[i]))；
}
<dp n="d303"/>
mksegment(Vertex[3].x，Vertex[3].y，Vertex[0].x，Vertex[0].y，&(lines[3]))；
*AlphaMap=bm_alloc(Cols，Rows，GREY_MODEL)；
Size=(DWORD)Cols*(DWORD)Rows；
(*AlphaMap)-＞gpic=
(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE|
GMEM_ZEROINIT，Size)；
for(i=Rectan.top；i＜Rectan.bottom；i++){
Curr=0；
for(j=0；j＜4；j++){
if(lines[j].a !=0.0){
Xval=-1.0*(lines[j].b*(double)i+lines[i].c)/lines[j].a；
if(Xval＜=Cols && Xval＞=0){
if(i＜=(int)(lines[j].ymax)&& i＞=(int)(lines[j].ymin))
Points[Curr++].x=Xval；
}
}
}
Xmin=Points[0].x
Xmax=Xmin；
for(j=1；j＜Curr；j++){
Xmin=min(Points[j].x，Xmin)；
Xmax=max(Points[j].x，Xmax)；
}
for(j=(int)Xmin；j＜=(int)Xmax；j++){
BITMAP_PLACE((*AlphaMap)，i，j)=1；
}
}
refine_alpha_edges(*AlphaMap)；
return 1；
}
int PASCAL split_bitmap(MYBITMAP *Bmap，int ColorModel，int FromRow)
{
DWORD i，k；
int Cols，Rows；
DWORD Place；
BYTE huge *Dup；
int ColorFactor；
<dp n="d304"/>
DWORD Offset，Size，Offset2；
ColorFactor=3；
Cols=Bmap-＞cols；
Rows=Bmap-＞rows；
Size=(DWORD)Rows*(DWORD)Cols*(DWORD)ColorFactor；
Rows=(Bmap-＞rows-FromRow)/2；
if(ColorModel==GREY_MODEL)ColorFactor=1；
Offset=(DWORD)FromRow*(DWORD)Cols*(DWORD)ColorFactor；
Place=(DWORD)Rows*(DWORD)Cols*(DWORD)ColorFactor；
Dup=Bmap-＞gpic+Size-Offset*(DWORD)2；
Offset2=Offset*(DWORD)2；
for(i=0；i＜Offset2；i++){
*(Dup++)=*(Bmap-＞gpic+Place+i)；
}
Dup=Bmap-＞gpic+Place；
k=0；
for(i=Offset；i＜Place；i++){
*(Dup+k++)=*(Bmap-＞gpic+i)；
}
Size=(DWORD)Cols*(DWORD)6*(DWORD)ColorFactor；//6 Rows of
Black.
for(i=0；i＜Size；i++){
*(Dup++)=0；
}
return 1；
}
int PASCAL refine_alpha_edges(MYBITMAP* AlphaMap)
{
int i，j；
int Cols.Rows；
BYTE Far.Close；
int Count=0；
Cols=AlphaMap-＞cols；
Rows=AlphaMap-＞rows；
<dp n="d305"/>
Far=170；
Close=85；
for(i=2；i＜Rows；i++){
for(j=2；j＜Cols-1；j++){
if(BITMAP_PLACE(AlphaMap，i，j)==1){
/*
if(BITMAP_PLACE(AlphaMap，i，j-1)==0){
BITMAP_PLACE(AlphaMap，i，j-2)=Far；
BITMAP_PLACE(AlphaMap，i，j-1)=Close；
}
if(BITMAP_PLACE(AlphaMap，i，j+1)==0){
BITMAP_PLACE(AlphaMap，i，j+2)=Far；
BITMAP_PLACE(AlphaMap，i，j+1)=Close；
j++；
}
*/
if(BITMAP_PLACE(AlphaMap，i-1，j)==0){
BITMAP_PLACE(AlphaMap，i，j)=Far；
BITMAP_PLACE(AlphaMap，i+1，j)=Close；
}
if(BITMAP_PLACE(AlphaMap，i+1，j)==0){
BITMAP_PLACE(AlphaMap，i，j)=Far；
BITMAP_PLACE(AlphaMap，i-1，j)=Close；
}
}
}
}
/*
for(i=2；i＜Rows；i++){
for(j=2；j＜Cols；j++){
if(BITMAP_PLACE(AlphaMap，i，j)＞2 &&
BITMAP_PLACE(AlphaMap，i，j-1)==0){
Array[Count].x=j-1；
Array[Count++].y=i；
}
}
}
<dp n="d306"/>
for(i=0；i＜Count-1；i++){
Len=Anay[i].x-Array[i+1].x；
if(Len==0)continue；
Unit=256/Len；
Line=Array[i].y；
for(j=Array[i].x，k=1；Len＞0；Len-){
BITMAP_PLACE(AlphaMap，Line，j)=(DWORD)Unit*(DWORD)k；
j-；
k++；
}
}
*/
return 1；
}
/*
int PASCAL get_mask_bitmap(HWND hwnd，MYBITMAP *Bmap，int
Tresh，MYBITMAP **MaskBmap)
{
int Cols，Rows；
BYTE huge *Tmp；
BYTE huge *BmapPtr；
DWORD Size，indx；
int i，j，k；
int Limit，Count，Value；
MYBITMAP *ToBmap；
Cols=Bmap-＞cols；
Rows=Bmap-＞rows；
bm_free(*MaskBmap)
*MaskBmap=bm_alloc(Cols，Rows，GREY_MODEL)；
Size=(DWORD)Cols*(DWORD)Rows；
(*MaskBmap)-＞gpic=(BYTE
huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
Tmp=(*MaskBmap)-＞gpic；
BmapPtr=Bmap-＞gpic；
for(indx=0；indx＜Size；indx++){
<dp n="d307"/>
if(*(BmapPtr++)＜=Tresh){
*(Tmp++)=1；
}else{
*(Tmp++)=0；
}
}
duplicate_bmap(*MaskBmap，&ToBmap，GREY_MODEL)；
enlarge_area_of_noise(ToBmap，*MaskBmap)；
WriteGreyRgb(hwnd，＂mask0，rgb＂，*MaskBmap)；
bm_free(ToBmap)；
Limit=Rows/3；
for(j=0；j＜Cols；j++){//0 Means Occlusion.1 Means OK.
Count=get_longest_occlusion(*MaskBmap，j，Rows)；
if(Count＜Limit){
Value=1；//
//for(i=0；i＜Rows；i++){
// BITMAP_PLACE((*MaskBmap)，i，j)=1；
//}
}else Value=0；//
for(i=0；i＜Rows；i++){//
BITMAP_PLACE((*MaskBmap)，i，j)=Value；//
} //
}
Count=0；
for(j=0；j＜Cols；j++){
if(BITMAP_PLACE((*MaskBmap)，0，j)==0)Count++；
else{
if(Count==0)continue；
if(Count＜6){
for(k=j-Count；Count＞0；Count-， k++){
for(i=0；i＜Rows；i++){
BITMAP_PLACE((*MaskBmap)，i，k)=1；
}
}
}else{//Count＞=6
<dp n="d308"/>
for(i=0；i＜Rows；i++){
if(j＞(Count+12))Limit=j-(Count+12)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+11))Limit=j-(Count+11)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+1o))Limit=j-(Count+10)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+9))Limit=j-(Count+9)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+8))Limit=j-(Count+8)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+7))Limit=j-(Count+7)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+6))Limit=j-(Count+6)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+5))Limit=j-(Count+5)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+4))Limit=j-(Count+4)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+3))Limit=j-(Count+3)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+2))Limit=j-(Count+2)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
if(j＞(Count+1))Limit=j-(Count+1)；
else Limit=0；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
<dp n="d309"/>
BITMAP_PLACE((*MaskBmap)，i，j-Count)=0；
BITMAP_PLACE((*MaskBmap)，i，j)=0；
Limit=min(j+1，Cols-1)；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
Limit=min(j+2，Cols-1)；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
Limit=min(j+3，Cols-1)；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
Limit=min(j+4，Cols-1)；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
Limit=min(j+5，Cols-1)；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
Limit=min(j+6，Cols-1)；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
Limit=min(j+7，Cols-1)；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
Limit=min(j+B，Cols-1)；
BITMAP_PLACE((*MaskBmap)，i，Limit)=0；
}
j=min(j+6，Cols-1)；
Count=0；
}
}
}
return 1；
}
*/
int PASCAL get_mask_bitmap(HWND hwnd，MYBITMAP *Bmap，int
Tresh，MYBITMAP **MaskBmap)
{
int Cols，Rows；
BYTE huge *Tmp；
BYTE huge *BmapPtr；
DWORD Size indx；
int i，j，k；
int Limit，Count. Value；
MYBITMAP *TempBmap；
<dp n="d310"/>
RECT Rectan；
Cols=Bmap-＞cols；
Rows=Bmap-＞rows；
TempBmap=bm_alloc(Cols，Rows，GREY_MODEL)；
Size=(DWORD)Cols*(DWORD)Rows；
TempBmap-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
Tmp=TempBmap-＞gpic；
BmapPtr=Bmap-＞gpic；
for(indx=0；indx＜Size；indx++){
if(*(BmapPtr++)＜=Tresh){
*(Tmp++)=1；
}else{
*(Tmp++)=0；
}
}
Limit=Rows/3；
for(j=0；j＜Cols；j++){//0 Means Occlusion.j Means OK
Count=get_longest_occlusion(TempBmap，j，Rows)；
if(Count＞=Limit){
BITMAP_PLACE(TempBmap，0，j)=0；
}else{
BITMAP_PLACE(TempBmap，0，j)=1；
}
}
Count=0；
for(j=0；j＜Cols；j++){
if(BITMAP_PLACE(TempBmap，0，j)==0)Count++；
else{
if(Count==0)continue；
if(Count＜6){
for(k=j-Count；Count＞0；Count-，k++){
for(i=0；i＜Rows；i++){
BITMAP_PLACE(TempBmap，i，k)=1；
}
<dp n="d311"/>
}
}else{//Count＞=6
for(k=j-Count；Count＞0；Count-，k++){
for(i=0；i＜Rows；i++){
BITMAP_PLACE(TempBmap，i，k)=0；
}
}
for(i=0；i＜Rows；i++){
if(j＞(Count+5))Limit=j-(Count+5)；
else Limit=0；
BITMAP_PLACE(TempBmap，i，Lirnit)=0；
if(j＞(Count+4))Limit=j-(Count+4)；
else Limit=0；
BITMAP_PLACE(TempBmap，i，Lirmit)=0
if(j＞(Count+3))Limit=j-(Count+3)；
else Limit=0；
BITMAP_PLACE(TempBmap，i，Limit)=0
if(j＞(Count+2))Limit=j-(Count+2)；
else Limit=0；
BITMAP_PLACE(TempBrmap，i，Limit)=0
if(j＞(Count+1))Limit=j-(Count+1)；
else Limit=0；
BITMAP_PLACE(TempBmap，i，Limit)=0
Limit=min(j+1，Cols-1)；
BITMAP_PLACE(TempBmap，i，Limit)=0；
Limit=min(j+2，Cols-1)；
BITMAP_PLACE(TempBmap，i，Limit)=0；
Limit=min(j+3，Cols-1)；
BITMAP_PLACE(TempBrmap，i，Limit)=0；
Limit=min(j+4，Cols-1)；
BITMAP_PLACE(TempBmap，i，Limit)=0；
Limit=min(j+5，Cols-1)；
BITMAP_PIACE(TempBmap，i，Limit)=0；
j=min(j+5.Cols-1)；
}
}
Count=0；
}
<dp n="d312"/>
}
duplicate_bmap(TempBmap，MaskBmap，GREY_MODEL)；
//WriteGreyRgb(hwnd，＂mask0.rgb＂，*MaskBmap)；
for(i=5；i＜Rows-5；i++){
for(j=5；j＜Cols-5；j++){
if(BITMAP_PLACE(TempBmap，i，j)==0){
Rectan.top=i-5；
Rectan.left=j；
Rectarn.bottom=i+5；
Rectan.right=j+5；
filter_noises_by_rects(TempBmap，Rectan，6，30，*MaskBmap)；
Rectan.left=j-5；
Rectan.right=j；
filter_noises_by_rects(TempBmap，Rectan，6，30.*MaskBmap)；
Rectan.right=j+5；
filter_noises_by_rects(TempBmap，Rectan，11，55.*MaskBmap)；
}
}
}
bm_free(TempBmap)；
//WriteGreyRgb(hwnd，＂mask1.rgb＂，*MaskBmap)；
//Limit=Rows/4；
for(j=1；j＜Cols-2；j++){//0 Means Occlusion.1 Means OK
//Count=get_longest_occlusion(*MaskBmap，j，Rows)
if(BITMAP_PLACE((*MaskBmap)，0，j-1)==1 &&
(BITMAP_PLACE((*MaskBmap)，0，j+2)==1||
BITMAP_PLACE((*MaskBmap)，0，j+1)==1){
for(i=0；i＜Rows；i++){
BITMAP_PLACE((*MaskBmap)，i，j)=1；
}
}
}
//WriteGreyRgb hwnd，＂mask2 rgb＂，*MaskBmap)
return 1；
}
int PASCAL get_longest_occlusion(MYBITMAP *Bmap，in；col，int rows)
<dp n="d313"/>
{
int i；
int Count=0；
int Longest=0；
for(i=0；i＜rows；i++){
if(BITMAP_PLACE(Bmap，i，col)==0)Count++；
else{
if(Count＞Longest){
Longest=Count；
Count=0；
}
}
}
if(Count＞Longest){
Longest=Count；
}
return Longest；
}
double PASCAL bilinear_rgb(double xs，double ys，MYBITMAP FAR* bmap，
double *Ptr)
{
int yi=(int)ys；
double dy=ys-(double)yi；
int xi=(int)xs；
double dx=xs-(double)xi；
double g00，g01，g10，g11，g1，g2；
BYTE huge *PtrX1；
BYTE huge *PtrY1；
BYTE huge *PtrX1Y1；
BYTE huge *PtrXY；
PtrXY=BITMAP_RGB_PLACE_PTR(bmap，yi，xi)；
PtrX1=BITMAP_RGB_PLACE_PTR(bmap，yi，xi+1)；
PtrY1=BITMAP_RGB_PLACE_PTR(bmap，yi+1，xi}；
PtrX1Y1=BITMAP_RGB_PLACE_PTR(bmap，yi+1，xi+1)；
<dp n="d314"/>
g00=PtrXY[0]；
g01=(xi==bmap-＞cols-1?g00：PtrX1[0])；
g10=(yi==bmap-＞rows-1?g00：PtrY1[0])；
g11=(xi==bmap-＞cols-1||yi==bmap-＞rows-1?g00：PtrX1Y1[0])；
g1=g00*(1.0-dx)+g01*dx；
g2=g10*(1.0-dx)+g11*dx；
Ptr[0]=g1*(1.0-dy)+g2*dy；
g00=PtrXY[1]；
g01=(xi==bmap-＞cols-1?g00：PtrX1[1])；
g10=(yi==bmap-＞rows-1?g00：PtrY1[1])；
g11=(xi==bmap-＞cols-1||yi==bmap-＞rows-1?g00：PtrX1Y1[1])；
g1=g00*(1.0-dx)+g01*dx；
g2=g10*(1.0-dx)+g11*dx；
Ptr[1]=g1*(1.0-dy)+g2*dy；
g00=PtrXY[2]；
g01=(xi==bmap-＞cols-1?g00：PtrX1[2])；
g10=(yi==bmap-＞rows-1?g00：PtrY1[2])；
g11=(xi==bmap-＞cols-1||yi==bmap-＞rows-1?g00：PtrX1Y1[2])；
g1=g00*(1.0-dx)+g01*dx；
g2=g10*(1.0-dx)+g11*dx；
Ptr[2]=g1*(1.0-dy)+g2*dy；
return(0.0)；
}
int PASCAL split_bitmap_frame(MYBITMAP *SrcBmap，MYBITMAP **F1，
MYBITMAP **F2)
{
int Rows，Cols，MidRows；
DWORD Size，Limit，indx；
int i，ColorFactor；
BYTE huge*CurrPtr；
BYTE huge*Ptr；
Rows=SrcBmap-＞rows；
Cols=SrcBmap-＞cols；
<dp n="d315"/>
if(SrcBmap-＞typ==COLOR_MODEL)ColorFactor=3；
else ColorFactor=1
if(Rows ％2==0){
MidRows=Rows/2
}else{
MidRows=Rows/2+1；
}
Size=(DWORD)MidRows*(DWORD)Cols*(DWORD)ColorFactor；
*F1=bm_alloc(Cols，MidRows，SrcBmap-＞typ)；
(*F1)-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
Limit=(DWORD)Cols*(DWORD)ColorFactor；
CurrPtr=(*F1)-＞gpic；
for(i=0；i＜Rows；i+=2){
ff(ColorFactor==1){
Ptr=BITMAP_PLACE_PTR(SrcBmap，i，0)；
}else{
Ptr=BITMAP_RGB_PLACE_PTR(SroBmap，i，0)；
}
for(indx=0；indx＜Limit；indx++){
*(CurrPtr++)=*(Ptr++)；
}
}
MidRows=Rows-MidRows；
Size=(DWORD)MidRows*(DWORD)Cols*(DWORD)ColorFactor；
*F2=bm_alloc(Cols，MidRows，SrcBmap-＞typ)；
(*F2)-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
CurrPtr=(*F2)-＞gpic；
for(i=1；i＜Rows；i+=2){
if(ColorFactor==1){
Ptr=BITMAP_PLACE_PTR(SrcBmap，i，0)；
}else{
Ptr=BITMAP_RGB_PLACE_PTR(SrcBmap，i，0)；
}
for(inox=0；indx＜Limit；indx++){
*(CurrPtr++)=*(Ptr++)；
}
}
<dp n="d316"/>
return 1；
}
int PASCAL sum_grey_bitmap_value(MYBITMAP *Bmap，DWORD *Sum)
{
DWORD i；
int Cols，Rows；
DWORD Size；
DWORD CurrSum；
BYTE huge *Ptr；
Cols=Bmap-＞cols；
Rows=Bmap-＞rows
Ptr=Bmap-＞gpic；
Size=(DWORD)Cols*(DWORD)Rows；
CurrSum=0；
for(i=0；i＜Size；i++){
CurrSum+=*(Ptr++)；
}
*Sum=CurrSum；
return 1；
}
int PASCAL filter_noises_by_rects(MYBITMAP *Source，RECT Rectan，int
LowLimit，
int HighLimit，MYBITMAP *Target)
{
int i，j；
int Count=0；
int Left，Right，Top，Bottom；
int Value；
Left=Rectan.left；
Top=Rectan.top；
Right=Rectan.right；
<dp n="d317"/>
Bottom=Rectan.bottom；
for(i=Top；i＜Bottom；i++){
for(j=Left；j＜Right；j++){
if(BITMAP_PLACE(Source，i，j)==0)Count++；
}
}
Value=-1；
if(Count＜LowLimit)Value=1；
if(Count＞HighLimit)Value=0；
if(Value==-1)return 1；
for(i=Top；i＜Bottom；i++){
for(j=Left；j＜Right；j++){
BITMAP_PLACE(Target，i，j)=Value；
}
}
return 1；
}
<dp n="d318"/>
/*
* int qrsolv(M，size，b)
*
* Solves the linear system：Mx=b using the QR Decomposition.
* On output b is overwritten by the solution x.
* Algorithm：
* 1)qrdecomp M into Q & R(coded in M，m1，m2).
* 2)multiply b by Q(transpose).
* 3)R_solve Rx=Q(transpose)b.
*
*C Implementaion：Dr.I.Wilf.
*/
#define ORDER 8
#include＜math.h＞
#include＂qrsolv.h＂
int qrsolv(m，size，b)
double m[ORDER][ORDER]；
int size；
double b[ORDER]；
{
int i，
j：
double tau，
m1[ORDER]，
m2[ORDER]：
if(qroecomp(m，size，m1，m2)＜0)return 0；
//error(＂singularity in qrdecomp()\n＂)；
for(j=0；j＜(size-1)；j++){
tau=0；
for(i=j；i＜size：i++)
tau+=m[i][j]*b[i]；
tau/=m1[j]；
for(i=j；i＜size：i++)
b[i]=tau*m[i][j]；
}
b[size-1]/=m2[size-1]；
<dp n="d319"/>
rsolv(m，size，m2，b)；
}
/*
*Compute the QR decomposition of a square matrix m using the
Stewart
*algorithm.
*Upon termination，thr decomposition is stored in m，m1 and m2 as
*follows：
*R is contained in the upper triangle of m except that its main
*diagonal is contained in m2，and Q(transpos)=Q(n-1)*...*Q(1)
*where Q(j)=l-(Uj*Uj(transpos)/Pj)where
*Uj[i]=0，i=1-＞i-1，Uj[i]=m[i][j]，i=j-＞n，Pj=m1[j].
*
*Stewart，G.W.，Introduction to matrix Computations，Academic Press
*New York(1973).
*
*C Implementaion：Dr.I.Wilf.
*/
int qrdecomp(m，size，m1，m2)
double m[ORDER][ORDER]；
double m1[ORDER]，
m2[ORDER]；
{
int i，
k，
j；
double eta，
t，
sigma，
tau：
for(L=0；k＜(size-1)；k++){
eta=0.0；
for(i=k；i＜size；i++)
if(fabs(m[i][k])＞eta)
eta=fabs(m[i][k])；
if(eta==0.0)
<dp n="d320"/>
return(-1)；
/* form Qk and premultiply m by it */
t=0；
for(i=k；i＜size；i++){
m[i][k]/=eta；
t+=m[i][k]*m[i][k]；
}
if(m[k][k]＞=0.0)
sigma=sqrt(t)；
else
sigma=-sqrt(t)；
m[k][k]+=sigma；
m1[k]=sigma*m[k][k]；
m2[k]=(-eta*sigma)；
tau=0；
for(j=k+1；j＜size；j++){
tau=0；
for(i=k；i＜size；i++)
tau+=m[i][k]*m[i][j]；
tau/=m1[k]；
for(i=k；i＜sie；i++)
m[i][j]=tau*m[i][k]；
}
}
m2[size-1]=m[size-1][size-1]；
return(0).
}
/*
*rsolv(m，size，m2.b)
*solve Rx=b for c where the upper triangular matrix R is
*stored in M，m2
*
*C Implementaion：D；I Wilf.
*/
rsolv(m，size.m2.b)
double m[ORDER][ORDER]；
double m2[ORDER]，
<dp n="d321"/>
b[ORDER]；
{
int i，
j；
double s；
for(i=size-2；i＞=0；i-){
s=)；
for(j=i+1；j＜size；j++)
s+=m[i}{j]*b[j]；
b[i]=(b[i]-s)/m2[i]；
}
}
<dp n="d322"/>
#include ＜windows.h＞
#include ＜windowsx.h＞
#include ＜commdlg.h＞
#include ＜stdlib.h＞
#include ＜bios.h＞
#include ＂const.h＂
#include ＂bitmap.h＂
#include ＂persp.h＂
#include ＂lines.h＂
#include ＂track.h＂
#include ＂min_mag.h＂
#include ＂lib.h＂
int PASCAL l_cp_int_arr_to_RPOINT(RPOINT *Rpoint，int *ArrX，int *AnY，int
num)
{
int i；
for(i=0；i＜num；i++){
Rpoint[i].x=ArrX[i]；
Rpoint[i].y=ArrY[i]；
}
return 1；
}
int PASCAL l_quad_in_new_origin(RPOINT *NewQuad，RPOINT *Quad，
int Xorg，int Yorg，int num)
{
int i；
for(i=0；i＜num；i++){
NewQuad[i].x=Quad[i].x-Xorg；
NewQuad[i].y=Quad[i].y-Yorg；
}
return 1；
}
<dp n="d323"/>
int PASCAL l_copy_RPOINT_array(RPOINT *To，RPOINT *From，int num}
{
int i；
for(i=0；i＜num；i++){
To[i]=From[i]；
}
return 1；
}
int PASCAL l_copy_int_array(int *To，int *From，int num)
{
int i；
for(i=0；i＜num；i++){
To[i]=From[i]；
}
return 1；
}
int PASCAL l_find_bound_rect(RPOINT *Vertexes，RECT *Rectan)
{
Rectan-＞left
=(int)min(min(min(Vertexes[0].x，Vertexes[1].x)，Vertexes[2].x)，Vertexes[3].x)
Rectan-＞top=
(int)min(min(min(Vertexes[0].y，Vertexes[1].y)，Vertexes[2].y)，Vertexes[3].Y)；
Rectan-＞right
=(int)max(max(max(Vertexes[0].x，Vertexes[1].x)，Vertexes[2].x)，Vertexes[3].x)；
Rectan-＞bottom=
(int)max(max(max(Vertexes[0].y，Vertexes[1].y)，Vertexes[2].y)，Vertexes[3].y)；
return 1；
}
<dp n="d324"/>
int PASCAL find_extremes_in_1dim(RPOINT *Points，int Number，int Dim，
double *MaxVal，double *MinVal)
{
int i；
double MaxNum，MinNum；
if(Dim==X_DIM){
MaxNum=MinNum=Points[0].x；
for(i=1；i＜Number；i++){
if(Points[i].x＞MaxNum){
MaxNum=Points[i].x；
continue；
}
if(Points[i].x＜MinNum){
MinNum=Points[i].x；
continue；
}
}
*MaxVal=MaxNum；
*MinVal=MinNum；
}
if(Dim==Y_DIM){
MaxNum=MinNum=Points[0].y；
for(i=1；i＜Number；i++){
if(Points[i].y＞MaxNum){
MaxNum=Points[i].y；
continue；
}
if(Points[i].y＜MinNum){
MinNum=Points[i].y；
continue；
}
}
*MaxVal=MaxNum；
*MinVal=MinNum；
}
<dp n="d325"/>
return 1；
}
int PASCAL find_best_cluster(HWND hwnd，int Number，RPOINT *Points，
RPOINT *Cluster，int *NumCluster，int Dim，
int *Indexes，int *Clustlndex，RPOINT *NotCluster，int *Notlndexes)
{
int i，j，k；
int Count NCount；
int Distance；
int Range；
double MaxNum，MinNum；
int *DistArray；
double *SumArray；
double MaxSum；
double MaxNumbers，Value
int Maxlndex；
if(Number==0)return 0；
find_extremes_in_1dim(Points，Number，Dim，&MaxNum，&MinNum)；
Range=(int)(fabs(MaxNum-MinNum+0.5))；
DistArray=(int *)GlobalAllocPtr(GMEM_MOVEABLE，
(DWORD)sizeof(int)*(DWORD)Number*(DWORD)Range
)；
SumAnay=(double *)GlobalAllocPtr(GMEM_MOVEABLE，
(DWORD)sizeof(double)*(DWORD)Number)；
for(i=0；i＜Number；i++){
SumArray[i]=0.0；
for(j=0；j＜Range；j++){
VALUE_IN(DistArray，i，j，Range)=0；
}
}
for(i=0；i＜Number；i++){
for(j=0；j＜Number；j++){
if(i==j)continue；
for(k=1；k＜=Range；k++){
if(Dim==X_DIM){
<dp n="d326"/>
if(fabs(Points[i].x-Points[i].x)＜=(double)k){
VALUE_IN(DistArray，i，k-1，Range)+=1；
}
}else{
if(fabs(Points[j].y-Points[i].y)＜=(double)k){
VALUE_IN(DistArray，i，k-1，Range)+=1；
}
}
}
}
}
MaxSum=0.0；
Maxlndex=0；
for(i=0；i＜Number；i++){
for(j=0；j＜Range；j++){
SumArray[i]+=(double)(VALUE_IN(DistArray，i，j，Range))/(double)(j+1)；
}
if(SumArray[i]＞MaxSum){
Maxlndex=i；
MaxSum=SumArray[i]；
}
}
MaxNumbers=0.0；
for(i=0；i＜Range；i++){
Value=(double)(VALUE_IN(DistAnay，Maxlndex，i，Range))/(double)(i+1)；
if(Value＞MaxNumbers){
MaxNumbers=Value；
Distance=i+1；
}
}
if(Range==1 && MaxNumbers＜=2){
GlobalFreePtr(SurnArray)；
GlobalFreePtr(DistArray)；
return 0；
<dp n="d327"/>
}
if(Range＞1 && MaxNumbers＜(double)Number/((double)Range+0.01)){
GlobalFreePtr(SumArray)；
GlobalFreePtr(DistArray)；
return 0；
}
Count=NCount=0；
for(j=0；j＜Number；j++){
if(Dim==X_DIM){
if(fabs(Points[j].x-points[Maxlndex].x)＜=(double)Distance){
Cluster[Count]=Points[j]；
Clustlndex[Count++]=indexes[j]；
}else{
NotCluster[NCount]=Points[j]；
Notlndexes[NCount++]=Indexes[j]；
}
}else{
if(fabs(Points[j].y-Points[Maxlndex].y)＜=(double)Distance){
Cluster[Count]=Points[j]；
Clustlndex[Count++]=Indexes[j]；
}else{
NotCluster[NCount]=Points[i]；
Notlndexes[NCount++]=Indexes[j]；
}
}
}
*NumCluster=Count；
GlobalFreePtr(SumArray)；
GlobalFreePtr(DistArray)；
return 1；
}
int PASCAL print_transform(HFILE hFile，char * Head，Perspective_Transform
*Tp)
{
<dp n="d328"/>
int j；
char String[50]；
_lwrite(hFile，Head，strlen(Head))；
for(j=0；j＜3；j++){
sprintf(String，＂\n％lf，％If，％lf\n＂，Tp-＞Pf[j][0]，
Tp-＞Pf[j][1]，TP-＞Pf[j][2])；
_lwrite(hFile，String，strlen(String))；
}
return 1；
int PASCAL insert_new_vertexes(RPOINT *CurrVert，RPOINT *Vert1，
RPOINT *Vert2，
RPOINT *Vert3，RPOINT *Vert4，double *Wheight，int num，RPOINT
*NewVert
{
int i；
RPOINT Delta[4]；
double Sum；
Sum=Wheight[0]+Wheight[1]+Wheight[2]；
for(i=0；i＜num-1；i++){
Vert1[i]=Vert1[i+1]；
Vert2[i]=Vert2[i+1]；
Vert3[i]=Vert3[i+1]；
Vert4[i]=Vert4[i+1]；
}
Vert1[num-1]=CurrVert[0]；
Vert2[num-1]=CurrVert[1]；
Vert3[num-1]=CurrVert[2]；
Vert4[num-1]=CurrVert[3]；
for(i=0；i＜num-1；i++){
Delta[i].x=Vert1[i+1].x-Vert1[i].x；
Delta[i].y=Vert1[i+1].y-Vert1[i].y；
}
<dp n="d329"/>
Delta[2].x=(Delta[2].x*Wheight[2]+Delta[1].x*Wheight[1]+
Delta[0].x*Wheight[0])/Sum；
Delta[2].y=(Delta[2].y*Wheight[2]+Delta[1].y*Wheight[1]+
Delta[0].y*Wheight[0])/Sum；
NewVert[0].x=Vert1[2].x+Delta[2].x；
NewVert[0].y=Vert1[2].y+Delta[2].y；
for(i=0；i＜num-1；i++){
Delta[i].x=Vert2[i+1].x-Vert2[i].x；
Delta[i].y=Vert2[i+1].y-Vert2[i].y；
}
Delta[2].x=(Delta[2].x*Wheight[2]+Delta[1].x*Wheight[1]+
Delta[0].x*Wheight[0])/Sum；
Delta[2].y=(Delta[2].y*Wheight[2]+Delta[1].y*Wheight[1]+
Delta[0].y*Wheight[0])/Sum；
NewVert[1].x=Vert2[2].x+Delta[2].x；
NewVert[1].y=Vert2[2].y+Delta[2].y；
for(i=0；i＜num-1；i++){
Delta[i].x=Vert3[i+1].x-Vert3[i].x；
Delta[i].y=Vert3[i+1].y-Vert3[i].y；
}
Delta[2].x=(Delta[2].x*Wheight[2]+Delta[1].x*Wheight[1]+
Delta[0].x*Wheight[0])/Sum；
Delta[2].y=(Delta[2].y*Wheight[2]+Delta[1].y*Wheight[1]+
Delta[0].y*Wheight[0])/Sum；
NewVert[2].x=Vert3[2].x+Delta[2].x；
NewVert[2].y=Vert3[2].y+Delta[2].y；
for(i=0；i＜nurn-1；i++){
Delta[i].x=Vert4[i+1].x-Vert4[i].x；
Delta[i].y=Vert4[i+1].y-Vert4[i].y；
}
Delta[2].x=(Delta[2].x*Wheight[2]+Delta[1].x*Wheight[1]+
Delta[0].x*Wheight[0])/Sum；
Delta[2].y=(Delta[2].y*Wheight[2]+Delta[1].y*Wheight[1]+
Delta[0].y*Wheight[0])/Sum；
NewVert[3].x=Verl4[2].x+Delta[2].x；
<dp n="d330"/>
NewVert[3].y=Vert4[2].y+Delta[2].y；
return 1；
}
int PASCAL transform_rpoint_arr(RPOINT *SrcPnts，RPOINT *DstPnts，
int num，Perspective_Transform TpCurr)
{
double DstX，DstY，w；
int i；
for(i=0；i＜num；i++){
DstX=SrcPnts[i].x * TpCurr.Pf[0][0]+
SrcPnts[i].y * TpCurr.Pf[1][0]+TpCurr.Pf[2][0]；
DstY=SrcPnts[i].x * TpCurr.Pf[0][1]+
SrcPnts[i].y * TpCurr.Pf[1][1]+TpCurr.Pf[2][1]；
w=SrcPnts[i].x * TpCurr.Pf[0][2]+
SrcPnts[i].y * TpCurr.Pf[1][2]+TpCurr.Pf[2][2]；
DstPnts[i].x=DstX/w；
DstPnts[i].y=DstY/w；
}
return 1；
}
<dp n="d331"/>
#include ＜windows.h＞
#include ＜windowsx.h＞
#include ＜commdlg.h＞
#include ＜stdlib.h＞
#include ＂const.h＂
#include ＂pitmap.h＂
#include ＂lines.h＂
#include ＂track.h＂
#include ＂persp.h＂
#include ＂min_mag.h＂
#include ＂lib.h＂
int PASCAL improve_diff_bmap(MYBITMAP *，MYBITMAP *)；
int PASCAL copy_rect_bmap(int，int，MYBITMAP *，MYBITMAP *)；
int PASCAL perspective(HWND hwnd，MYBITMAP FAR *SrcBmap，
MYBITMAP FAR *DstBmap，
RPOINT* SrcPnts，RPOINT * DstPnts，int ColorModel，
Perspective_Transform *Tp)
{
//Rectan2Quad(hwnd，SrcPnts，DstPnts，Tp)；
Quad2Quad(hwnd，SrcPnts，DstPnts，Tp)；
Perspective_map(SrcBmap，Tp，DstBmap，DstPnts，ColorModel)；
return TRUE；
}
int PASCAL perspective_near(HWND hwnd，MYBITMAP FAR *SrcBmap，
MYBITMAP FAR *DstBmap，
RPOINT* SrcPnts，RPOINT * DstPnts，int ColorModel，
Perspective_Transform *Tp)
{
//Rectan2Quad(hwnd，SrcPnts，DstPnts，Tp)；
Quad2Quad(hwnd，SrcPnts，DstPnts，Tp)；
Perspe=tive_near_map(SrcBmap，Tp，DstBmap，DstPnts，ColorModel)；
<dp n="d332"/>
return TRUE；
}
int PASCAL Rectan2Quad(HWND hwnd，RPOINT *src_pts，RPOINT
*dst_pts，
Perspective_Transform *Tp)
{
double x0，y0，x1，y1，x2，y2，x3，y3；
double dx1，dy1，dx2，dy2，dx3，dy3；
double denom；
double a11，a12，a13，a21，a22，a23，a31，a32，a33；
double A[3][3]，B[3][3]；
/* Verify that src_pts do form a rectangle */
if(check_if_rect(src_pts)==FALSE){
MessageBox(hwnd，＂Source is not a rectangle＂，
＂Perspective trans.＂，MB_ICONEXCLAMATION|MB_OK)；
return NULL；
}
/* Solve for transformation from[(0，0)，(1，1)]-＞Quad */
x0=dst_pts[0].x；
y0=dst_pts[0].y；
x1=dst_pts[1].x；
y1=dst_pts[1].y；
x2=dst_pts[2].x；
y2=dst_pts[2].y；
x3=dst_pts[3].x；
y3=dst_pts[3].y；
dx1=x1-x2；
dy1=y1-y2；
dx2=x3-x2；
dy2=y3-y2；
dx3=x0-x1+x2-x3；
dy3=y0-y1+y2-y3；
<dp n="d333"/>
/*if dx3=dy3=0：transformation is affine */
/*otherwise：transformation is perspective */
/*
*Forward transformation：
*[x_，y_，w_]=[u，v，1]Pf
*where：|a11 a12 a13|Pf=|a21 a22 a23||a31 a32 a33|
* Then：[x，y]=[x_/w_，y_/w_]
*/
denom=det2(dx1，dx2，dy1，dy2)；
a13=det2(dx3，dx2，dy3，dy2)/denom；
a23=det2(dx1，dx3，dy1，dy3)/denom；
a11=x1-x0+a13*x1；
a21=x3-x0+a23*x3；
a31=x0；
a12=y1-y0+a13*y1；
a22=y3-y0+a23*y3；
a32=y0；
a33=1.0；
{
A[0][0]=a11；
A[0][1]=a12；
A[0][2]=a13；
A[1][0]=a21；
A[1][1]=a22；
A[1][2]=a23；
A[2][0]=a31；
A[2][1]=a32；
A[2][2]=a33；
}
<dp n="d334"/>
/* pre-multiply by the matrix converting src_pts-＞[(0，0)，(1，1)]*/
{
double xs=src_pts[0].x；
double ys=src_pts[0].y；
double xe=src_pts[2].x；
double ye=src_pts[2].y；
double dx=xe-xs；
double dy=ye-ys；
B[0][0]=1.0/dx；
B[1][0]=0.0；
B[2][0]=-xs/dx；
B[0][1]=0.0；
B[1][1]=1.0/dy；
B[2][1]=-ys/dy；
B[0][2]=0.0；
B[1][2]=0.0；
B[2][2]=1.0；
multmat(hwnd，3，3，3，(double*)B，(double*)A，(double*)(TP-＞Pf))；
}
/*
* Backward transformation；
*
*[u_，v_，w_]=[x，y，1]Pb
*
*where：|A11 A12 A13|Pb=|A21 A22 A23||A31 A32 A33|
*
*is the inverse of Pf.
*
*Then：[u，v]=[u_/w_，v_/w_]
*/
{
a11=Tp-＞Pf[0][0]；
a12=Tp-＞Pf[0][1]；
a13=Tp-＞Pf[0][2]；
<dp n="d335"/>
a21=Tp-＞Pf[1][0]；
a22=Tp-＞Pf[1][1]；
a23=Tp-＞Pf[1][2]；
a31=Tp-＞Pf[2][0]；
a32=Tp-＞Pf[2][1]；
a33=Tp-＞Pf[2][2]；
}
Tp-＞Pb[0][0]=a22*a33-a23*a32；
Tp-＞Pb[0][1]=a13*a32-a12*a33；
Tp-＞Pb[0][2]=a12*a23-a13*a22；
Tp-＞Pb[1][0]=a23*a31-a21*a33；
Tp-＞Pb[1][1]=a11*a33-a13*a31；
Tp-＞Pb[1][2]=a13*a21-a11*a23；
Tp-＞Pb[2][0]=a21*a32-a22*a31；
Tp-＞Pb[2][1]=a12*a31-a11*a32；
Tp-＞Pb[2][2]=a11*a22-a12*a21；
return 1；
}
int PASCAL Quad2Rectan(HWND hwnd，RPOINT *src_pts，RPOINT
*dst_pts，
Perspective_Transform *Tp)
{
double Tmp；
Rectan2Quad(hwnd，dst_pts，src_pts，Tp)；
Tmp=Tp-＞Pf[0][0]；
Tp-＞Pf[0][0]=Tp-＞Pb[0][0]；
Tp-＞Pb[0][0]=Tmp；
Tmp=Tp-＞Pf[0][1]；
Tp-＞Pf[0][1]=Tp-＞Pb[0][1]；
Tp-＞Pb[0][1]=Tmp；
Tmp=Tp-＞Pf[0][2]；
<dp n="d336"/>
Tp-＞Pf[0][2]=Tp-＞Pb[0][2]；
Tp-＞Pb[0][2]=Tmp
Tmp=Tp-＞Pf[1][0]
Tp-＞Pf[1][0]=Tp-＞Pb[1][0]
Tp-＞Pb[1][0]=Tmp；
Tmp=Tp-＞Pf[1][1]；
Tp-＞Pf[1][1]=Tp-＞Pb[1][1]
Tp-＞Pb[1][1]=Tmp；
Tmp=Tp-＞Pf[1][2]；
Tp-＞Pf[1][2]=Tp-＞Pb[1][2]
Tp-＞Pb[1][2]=Tmp；
Tmp=Tp-＞Pf[2][0]；
Tp-＞P[2][0]=Tp-＞Pb[2][0]
Tp-＞Pb[2][0]=Tmp；
Tmp=Tp-＞Pf[2][1]；
Tp-＞Pf[2][1]=Tp-＞Pb[2][1]
Tp-＞Pb[2][1]=Tmp；
Tmp=Tp-＞Pf[2][2]；
Tp-＞Pf[2][2]=Tp-＞Pb[2][2]
Tp-＞Pb[2][2]=Tmp；
return 1：
}
int PASCAL check_if_rect(RPOINT* Points)
{
if(Points[0].x !=Points[3].x)return FALSE；
if(Points[1].x !=Points[2].x)return FALSE；
if(Points[0].y !=Points[1].y)return FALSE；
if(Points[2].y !=Points[3].y)return FALSE；
<dp n="d337"/>
return TRUE；
}
int PASCAL Perspective_near_map(MYBITMAP
*src_bmap，Perspective_Transform* Tp，
MYBITMAP *dst_bmap，RPOINT *dst_pts，int ColorModel)
{
RECT r，Screen；
DWORD i，j；
DWORD Size；
BYTE huge *Ptr；
double RcBil；
int Colsmin1，Rowsmin1；
double y_dst；
double x_dst；
RPOINT uv，xy；
double D；
BYTE huge *Colors；
int uy，ux；
/* Find bounding rectangle of dst_pts */
l_find_bound_rect(dst_pts，&r)；
Colsmin1=src_bmap-＞cols-1；
Rowsmin1=src_bmap-＞rows-1；
Colors=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，3)；
for(i=r.top；i＜r.bottom；i++){
y_dst=(double)i；
for(j=r.left；j＜r.right；j++){
x_dst=(double)j；
D=1.0；
xy.x=x_dst；
xy.y=y_dst；
uv=bPerspective(xy，Tp)；
if(uv.x＜0.0||uv.x＞=(double)(src_bmap-＞cols-1)
<dp n="d338"/>
continue；
if(uv.y＜0.0||uv.y＞=(double)(src_bmap-＞rows-1))
continue；
uy=(int)(uv.y+0.5)；
ux=(int)(uv.x+0.5)；
if(ColorModel==GREY_MODEL){
RcBil=BITMAP_PLACE(src_bmap，uy，ux)；
BITMAP_PLACE(dst_bmap，ij)=(BYTE)RcBil；
}else{//COLOR_MODEL
Ptr=BITMAP_RGB_PLACE_PTR(dst_bmap，i，j)；
Colors=BITMAP_RGB_PLACE_PTR(src_bmap，uy，ux)；
Ptr[0]=(BYTE)Colors[0]；
Ptr[1]=(BYTE)Colors[1]；
Ptr[2]=(BYTE)Colors[2]；
}
}
}
GlobalFreePtr(Colors)；
return(0)；
}
int PASCAL Perspective_map(MYBITMAP FAR
*src_bmap.Perspective_Transform* Tp，
MYBITMAP FAR *dst_bmap，RPOINT *dst_pts，int ColorModel)
{
RECT r，Screen；
DWORD i，j；
DWORD Size；
BYTE huge *Ptr；
double RcBil；
int Colsmin1，Rowsmin1；
double y_dst；
double x_dst；
RPOINT uv，xy；
double D；
double Colors[3]；
<dp n="d339"/>
/* Find bounding rectangle of dst_pts */
l_find_bound_rect(dst_pts，&r)
Colsmin1=src_bmap-＞cols-1
Rowsmin1=src_bmap-＞rows-1；
for(i=r.top；i＜r.bottom；i++){
y_dst=(double)i；
for(j=r.left；j＜r.right；j++){
x_dst=(double)j；
D=1.0；
xy.x=x_dst；
xy.y=y_dst；
uv=bPerspective(xy，Tp)；
if(uv.x＜0.0||uv.x＞=(double)(src_bmap-＞cols))
continue；
if(uv.y＜0.0||uv.y＞=(double)(src_bmap-＞rows))
continue；
if(ColorModel==GREY_MODEL){
RcBil=(BYTE)bilinear(uv.x，uv.y，src_bmap)；
if(RcBil==-1.0)continue；
BITMAP_PLACE(dst_bmap，ij)=(BYTE)RcBil；
}else{//COLOR_MODEL
Ptr=BITMAP_RGB_PLACE_PTR(dst_bmap，i，j)；
bilinear_rgb(uv.x，uv.y，src_bmap，Colors)；
Ptr[0]=(BYTE)Colors[0]；
Ptr[1]=(BYTE)Colors[1]；
Ptr[2]=(BYTE)Colors[2]；
}
}
}
return(0)；
}
<dp n="d340"/>
RPOINT bPerspective(RPOINT xy，Perspective_Transform *Tp)
{
RPOINT uv；
double x=xy.x；
double y=xy.y；
double u_=x*Tp-＞Pb[0][0]+y*Tp-＞Pb[1][0]+Tp-＞Pb[2][0]；
double v_=x*Tp-＞Pb[0][1]+y*Tp-＞Pb[1][1]+Tp-＞Pb[2][1]；
double w_=x*Tp-＞Pb[0][2]+y*Tp-＞Pb[1][2]+Tp-＞Pb[2][2]；
uv.x=u_/w_；
uv.y=v_/w_；
return(uv)；
}
RPOINT PASCAL fPerspective(RPOINT xy，Perspective_Transform *Tp)
{
RPOINT uv；
double x=xy.x；
double y=xy.y；
double u_=x*Tp-＞Pf[0][0]+y*Tp-＞Pt[1][0]+Tp-＞Pf[2][0]；
double v_=x*Tp-＞Pf[0][1]+y*Tp-＞Pf[1][1]+Tp-＞Pf[2][1]；
double w_=x*Tp-＞Pf[0][2]+y*Tp-＞Pf[1][2]+Tp-＞Pf[2][2]；
uv.x=u_/w_；
uv.y=v_/w_；
return(uv)；
}
/*
double PASCAL dPerspective(RPOINT xy，Perspective_Transform *Tp)
{
double Du，D，D；
double Dux，Duy；
double Dvx，Dvy；
double x=xy.x；
double y=xy.y；
<dp n="d341"/>
double u_=x*Tp-＞Pb[0][0]+y*Tp-＞Pb[1][0]+Tp-＞Pb[2][0]；
double v_=x*Tp-＞Pb[0][1]+y*Tp-＞Pb[1][1]+Tp-＞Pb[2][1]；
double w_=x*Tp-＞Pb[0][2]+y*Tp-＞Pb[1][2]+Tp-＞Pb[2][2]；
double u_x=Tp-＞Pb[0][0]；
double u_y=Tp-＞Pb[1][0]；
double v_x=Tp-＞Pb[0][1]；
double v_y=Tp-＞Pb[1][1]；
double w_x=Tp-＞Pb[0][2]；
double w_y=Tp-＞Pb[1][2]；
Dux=(u_x*w-u*w_x)/(w_*w_)；
Duy=(u_y*w-u*w_y)/(w_*w_)；
Du=sqrt(Dux*Dux+Duy*Duy)；
Dvx=(v_x*w-v*w_x)/(w_*w_)；
Dvy=(v_y*w-v*w_y)/(w_*w_)；
Dv=sqrt(Dvx*Dvx+Dvy*Dvy)；
D=max(Du，Dv)；
return(D)；
}
*/
#define MEDIAN_EDGE 5
#define MEDIAN_SIDE 2
int PASCAL median_filter_5(HWND hwnd，MYBITMAP *Bmap)
{
int i，j，k，l，n；
int MecVec[MEDIAN_EDGE*MEDIAN_EDGE]；
BYTE IndexArr[256]；
int Median；
MYBITMAP *Tmpmap；
BYTE huge *TmpPtr；
<dp n="d342"/>
BYTE huge *BmapPtr；
DWORD Size，Pl；
DWORD FromTime，ToTime；
char String[100]；
int Sum；
int RowLimit，ColLimit；
TmpBmap=bm_alloc(Bmap-＞cols，Bmap-＞rows，GREY_MODEL)；
Size=(DWORD)Bmap-＞cols*(DWORD)Bmap-＞rows；
TmpBmap-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVF_ABLE，Size)；
BmapPtr=Bmap-＞gpic；
TmpPtr=TmpBmap-＞gpic；
for(Pl=0；Pl＜Size；Pl++){
*(TmpPtr++)=*(BmapPtr++)；
}
for(i=0；i＜Bmap-＞rows；i++){
for(j=0；j＜Bmap-＞cols；j++){
if(BITMAP_PLACE(TmpBmap，ij)＜=24){
BTTMAP_PLACE(TmpBmap，ij)=0；
}
}
}
WriteGreyRgb(hwnd，＂no48.rgb＂，TrmpBmap)；
//FromTime=GetTickCount()；
RowLimit=Bmap-＞rows-3；
for(i=2；i＜RowLimit；i++){
for(k=0；k＜256；k++)IndexArr[k]=0；
for(j=0；j＜5；j++){
IndexArr[BITMAP_PLACE(TmpBmap，i-2，j)]+=1；
IndexArr[BITMAP_PLACE(TmpBmap，i-1，j)]+=1；
IndexArr[BITMAP_PLACE(TmpBmap，i，j)]+=1；
IndexArr[BITMAP_PLACE(TmpBmap，i+1，j)]+=1；
IndexArr[BITMAP_PLACE(TmpBmap，i+2，j)]+=1；
}
for(Sum=k=0；k＜256；k++){
Sum+=IndexArr[k]；
if(Sum＞=13){
<dp n="d343"/>
BITMAP_PLACE(TmpBmap，i.2)=k；
break；
}
}
ColLimit=Bmap-＞cols-3；
for(j=3；j＜ColLimit；j++){
IndexArr[BITMAP_PLACE(TmpBmap，i-2，j-3)]=1；
IndexArr[BITMAP_PLACE(TmpBmap，i-1，j-3)]=1；
IndexArr[BITMAP_PLACE(TmpBmap，i，j-3)]=1；
IndexArr[BITMAP_PLACE(TmpBmap，i+1，j-3)]=1；
IndexArr[BITMAP_PLACE(TmpBmap，i+2，j-3)]=1；
IndexArr[BITMAP_PLACE(TmpBmap，i-2，j+2)]+=1；
IndexArr[BITMAP_PLACE(TmpBmap，i-1，j+2)]+=1；
IndexArr[BITMAP_PLACE(TmpBmap，i，j+2)]+=1；
IndexArr[BITMAP_PLACE(TmpBmap，i+1，j+2)]+=1；
IndexArr[BITMAP_PLACE(TmpBmap，i+2，j+2)]+=1；
for(Sum=k=0；k＜256；k++){
Sum+=IndexArr[k]；
if(Sum＞=13){
BITMAP_PLACE(TmpBmap，i，j)=k；
break；
}
}
}
}
WriteGreyRgb(hwnd，＂med5.rgb＂，TmpBmap)；
//ToTime=GetTickCount()；
//sprintf(String，＂Time elapsed=％lu＂，ToTime-FromTime)；
//MessageBox(hwnd，String，＂Median Calc＂，MB_ICONEXCLAMATION|
MB_OK)；
improve_diff_bmap(Bmap，TmpBmap)；
bm_free(TmpBmap)；
return 1；
}
int PASCAL improve_diff_bmap(MYBITMAP *Bmap，MYBITMAP *TmpBmap)
<dp n="d344"/>
{
int i，j；
int ICount，JCount；
int Frj；
int Limit；
int Cols，Rows；
Frj=0；
JCount=0；
Cols=Bmap-＞cols；
Rows=Bmap-＞rows；
Limit=Bmap-＞rows/8
for(j=0；j＜Cols；j++){
ICount=0；
for(i=0；i＜Rows；i++){
if(BITMAP_PLACE(TmpBmap，i，j)!=0)ICount++；
}
if(ICount＜Limit)JCount++；
else{
if(JCount＞0){
copy_rect_bmap(Frj，JCount，TmpBmap，Bmap)；
JCount=0；
}
Frj=j+1；
}
}
return 1；
}
int PASCAL copy_rect_bmap(int FromCol，int NumCols，MYBITMAP
*From，MYBTTMAP *To)
{
int i，j；
int Until；
Until=FromCol+NumCols；
for(j=FromCol；j＜Until；j++){
<dp n="d345"/>
for(i=0；i＜From-＞rows；i++){
BITMAP_PLACE(To，i，j)=BITMAP_PLACE(From，i，j)；
}
}
return 1；
}
int PASCAL get_tresh_for_occ(MYBITMAP *Bmap，int *Tresh)
{
DWORD Size，n；
BYTE huge *TmpPic；
DWORD IndexArr[256]；
int i；
DWORD Sum，MidSize；
for(i=0；i＜256；i++){
IndexArr[i]=0；
}
Size=(DWORD)(Bmap-＞cols)*(DWORD)(Bmap-＞rows)；
TmpPic=Bmap-＞gpic；
for(n=1；n＜Size；n++){
IndexArr[*(TmpPic++)]+=1
}
MidSize=Size/2；
Sum=0；
for(i=0；i＜256；i++){
Sum+=IndexArr[i]；
if(Sum＞=MidSize){
*Tresh=i；
break；
}
}
if(*Tresh＜32)*Tresh=32；
return 1；
}
<dp n="d346"/>
int PASCAL perspective_mask(HWND hwnd，MYBITMAP
*SrcBmap，MYBITMAP *DstBmap，
MYBITMAP * Alpha，RPOINT *SrcPnts，RPOINT *DstPnts，int
ColorModel，
int interpolation，MYBITMAP *MaskBmap)
{
Perspective_Transform Tp；
//Rectan2Quad(hwnd，SrcPnts，DstPnts，&Tp)；
Quad2Quad(hwnd，SrcPnts，DstPnts，&Tp)；
Perspective_map_mask(SrcBmap，&Tp，DstBmap，Alpha，
DstPnts，ColorModel，
interpolation，MaskBmap)；
return 1；
}
int PASCAL Perspective_map_mask(MYBITMAP FAR
*src_bmap，Perspective_Transform* Tp，
MYBITMAP FAR *dst_bmap，MYBITMAP * Alpha，RPOINT *dst_pts，int
ColorModel，
int interpolation，MYBITMAP *MaskBmap)
{
RECT r，Screen；
DWORD i，j；
DWORD Size；
BYTE huge *Ptr；
double RcBil；
double Colors[3]；
int AlphaNumber；
/* Find bounding rectangle of dst_pts */
l_find_bound_rect(dst_pts，&r)；
for(i=r.top；i＜r.bottom；i++){
double y_dst=(double)i；
<dp n="d347"/>
for(j=r.left；j＜r.right；j++){
double x_dst=(double)j；
RPOINT uv，xy；
double D=1.0；
xy.x=x_dst；
xy.y=y_dst；
uv=bPerspective(xy，Tp)；
if(uv.x＜0.0||uv.x＞=(double)(src_bmap-＞cols))
continue；
if(uv.y＜0.0||uv.y＞=(double)(src_bmap-＞rows))
continue；
if(ColorModel==GREY_MODEL){
RcBil=(BYTE)bilinear(uv.x，uv.y，stc_bmap)；
if(RcBil==-1.0||
BITMAP_PLACE(MaskBmap，i-r.top，j-r.left)==0)
continue；
BITMAP_PLACE(dst_bmap，i，j)=(BYTE)RcBil；
}else{//COLOR_MODEL
Ptr=BITMAP_RGB_PLACE_PTR(dst_bmap，i，j)；
RcBil=bilinear_rgb(uv.x，uv.y，src_bmap，Colors)；
if(RcBil==-1.0||
BITMAP_PLACE(MaskBmap，i-r.top，j-r.left)==0)continue
if(BITMAP_PLACE(MaskBmap，i-r.top，j-r.left)==2){
Ptr[0]=
(BYTE)((double)((DWORD)Colors[0]*(DWORD)128+
(DWORD)Ptr[0]*(DWORD)128)/256.0)；
Ptr[1]=
(BYTE)((double)((DWORD)Colors[1]*(DWORD)128+
(DWORD)Ptr[1]*(DWORD)128)/256.0)；
Ptr[2]=
(BYTE)((double)((DWORD)Colors[2]*(DWORD)128+
(DWORD)Ptr[2]*(DWORD)128)/256.0)；
<dp n="d348"/>
continue；
}
AlphaNumber=BITMAP_PLACE(Alpha，i，j)；
if(AlphaNumber＞1){
Ptr[0]=
(BYTE)((double)((DWORD)Colors[0]*(DWORD)(256-
AlphaNumber)+
(DWORD)Ptr[0]*(DWORD)AlphaNumber)/256.0)；
Ptr[1]=
(BYTE)((double)((DWORD)Colors[1]*(DWORD)(256-
AlphaNumber)+
(DWORD)Ptr[1]*(DWORD)AlphaNumber)/256.0)；
Ptr[2]=
(BYTE)((double)((DWORD)Colors[2]*(DWORD)(256-
AlphaNumber)+
(DWORD)Ptr[2]*(DWORD)AlphaNumber)/256.0)；
}else{
Ptr[0]=(BYTE)Colors[0]；
Ptr[1]=(BYTE)Colors[1]；
Ptr[2]=(BYTE)Colors[2]；
}
}
}
}
return (0)；
}
int PASCAL perspective_al(HWND hwnd，MYBITMAP FAR *SrcBmap，
MYBITMAP FAR *DstBmap，MYBITMAP *Alpha，
RPOINT* SrcPnts，RPOINT*DstPnts，int ColorModel，
Perspective_Transform *Tp)
{
//Rectan2Quad(hwnd，SrcPnts，DstPnts，Tp)；
<dp n="d349"/>
Quad2Quad(hwnd，SrcPnts，DstPnts，Tp)；
Perspective_map_al(SrcBmap，Tp，DstBmap，Alpha，DstPnts，ColorModel)；
return TRUE；
}
int PASCAL Perspective_map_al(MYBITMAP
*src_bmap，Perspective_Transform *Tp，
MYBITMAP *dst_bmap，MYBITMAP *Alpha，RPOINT *dst_pts，int ColorModel)
{
RECT r，Screen；
DWORD i，j；
DWORD Size；
BYTE huge *Ptr；
double RcBil；
int Colsmin1，Rowsmin1；
double y_dst；
double x_dst；
RPOINT uv，xy；
double D；
double Colors[3]；
int AlphaNumber；
/* Find bounding rectangle of dst_pts */
l_find_bound_rect(cst_pts，&r)；
Colsmin1=src_bmap-＞cols-1；
Rowsmin1=src_bmap-＞rows-1；
for(i=r.top；i＜r.bottom；i++){
y_dst=(double)i；
for(j=r.left；j＜r.right；j++){
x_dst=(double)j；
D=1.0；
xy.x=x_dst；
xy.y=y_dst；
<dp n="d350"/>
uv=bPerspective(xy，Tp)；
if(uv.x＜0.0||uv.x＞=(double)(src_bmap-＞cols))
continue；
if(uv.y＜0.0||uv.y＞=(double)(src_bmap-＞rows))
continue；
if(BITMAP_PLACE(Alpha，i，j)==0)continue；
if(ColorModel==GREY_MODEL){
RcBil=(BYTE)bilinear(uv.x，uv.y，src_bmap)；
if(RcBil==-1.0)continue；
BITMAP_PLACE(dst_bmap，i，j)=(BYTE)RcBil；
}else{//COLOR_MODEL
Ptr=BITMAP_RGB_PLACE_PTR(dst_bmap，i，j)；
bilinear_rgb(uv.x，uv.y，src_bmap，Colors)；
AlphaNumber=BITMAP_PLACE(Alpha，i，j)；
if(AlphaNumber＞1){
Ptr[0]=
(BYTE)((double)((DWORD)Colors[0]*(DWORD)(256-
AlphaNumber)+
(DWORD)Ptr[0]*(DWORD)AlphaNumber)/256.0)；
Ptr[1]=
(BYTE)((double)((DWORD)Colors[1]*(DWORD)(256-
AlphaNumber)+
(DWORD)Ptr[1]*(DWORD)AlphaNumber)/256.0)；
Ptr[2]=
(BYTE)((double)((DWORD)Colors[2]*(DWORD)(256-
AlphaNumber)+
(DWORD)Ptr[2]*(DWORD)AlphaNumber)/256.0)；
}else{
Ptr[0]=(BYTE)Colors[0]；
Ptr[1]=(BYTE)Colors[1]；
Ptr[2]=(BYTE)Colors[2]；
}
}
}
}
return(0)；
<dp n="d351"/>
}
<dp n="d352"/>
#include ＜windows.h＞
#include ＜windowsx.h＞
#include ＜commdlg.h＞
#include ＜stdlib.h＞
#include ＜bios.h＞
#include ＂const.h＂
#include ＂bitmap.h＂
#include ＂persp.h＂
#include ＂lines.h＂
#include ＂track.h＂
#include ＂min_mag.h＂
#include ＂lib.h＂
int PASCAL get_quad_segment_on_x(LINE，LINE，double，double，int
，RPOINT *)；
int PASCAL mkline(double x1，double y1，double x2，double y2，LINE *1)
{
l-＞a=y2-y1；
l-＞b=x1-x2；
l-＞c=-l-＞a*x1-l-＞b*y1；
return(1)；
}
int PASCAL mksegment(double x1，double y1，double x2，double y2，SEG *s)
{
s-＞a=y2-y1；
s-＞b=x1-x2；
s-＞c=-s-＞a*x1-s-＞b*y1；
s-＞xmax=max(x1，x2)
s-＞xmin=min(x1，x2)；
s-＞ymax=max(y1，y2)
s-＞ymin=min(y1，y2)；
return 1；
<dp n="d353"/>
int PASCAL get_point_on_segment(SEG s1，double param，RPOINT *Point)
{
if(param＜0.0||param＞1.0)return 0；
Point-＞x=param*(s1.xmax-s1.xmin)+s1.xmin；
Point-＞y=param*(s1.ymax-s1.ymin)+s1.ymin；
return 1；
}
//this function returns in DstPnts the points calculated relative to the
//Xparam and YParam always from the minimum.
int PASCAL get_shrinked_yquad(RPOINT *SrcPnts，double param，RPOINT
*DstPnts)
{
SEG seg1，seg2，seg3，seg4；
int i；
for(i=0；i＜4；i++){
DstPnts[i].x=SrcPnts[i].x
DstPnts[i].y=SrcPnts[i].y
}
mksegment(SrcPnts[1].x，SrcPnts[1].y，SrcPnts[2].x，SrcPnts[2].y，&seg2)；
mksegment(SrcPnts[3].x，SrcPnts[3].y，SrcPnts[0].x，SrcPnts[0].y，&seg4)；
if(get_point_on_segment(seg2，param，&(DstPnts[2]))==0)return 0；
get_point_on_segment(seg4，param，&(DstPnts[3]))；
return 1；
}
int PASCAL isect_lines(LINE l1，LINE l2，RPOINT *p)
{
<dp n="d354"/>
double x，y，w，eps；
x=l1.b*l2.c-l2.b*l1.c；
y=l1.c*l2.a-l2.c*l1.a；
w=l1.a*l2.b-l2.a*l1.b；
eps=0.0001；
if(fabs(w)＜=eps)
return(0)；
p-＞x=x/w；
p-＞y=y/w；
return(1)；
}
int PASCAL center_of_bounded_rect(RPOINT p1，RPOINT p2，RPOINT p3，
RPOINT p4，
RPOINT *Center，double *Xwidth，double *Ywidth)
{
RPOINT DownComer，UpComer；
RPOINT LeftComer，RightComer；
if(p2.y＞p1.y){
UpComer.x=p2.x
UpComer.y=p2.y
}else{
UpComer.x=p1.x
UpComer.y=p1.y
}
if(p3.y＞p4.y){
DownComer.x=p4.x；
DownComer.y=p4.y；
}else{
DownComer.x=p3.x；
DownComer.y=p3.y；
}
if(p1.x＞p4.x){
LeftComer.x=p1.x；
<dp n="d355"/>
LeftComer.y=p1.y
}else{
LeftComer.x=p4.x
LeftComer.y=p4.y
}
if(p2.x＞p3.x){
RightComer.x=p3.x；
RightComer.y=p3.y；
}else{
RightComer.x=p2.x
RightComer.y=p2.y；
}
*Xwidth=fabs(RightComer.x-LeftComer.x)/2.0 -2；
*Ywidth=fabs(UpComer.y-DownComer.y)/2.0-2；
Center-＞x=min(UpComer.x，DownComer.x)+fabs(UpComer.x-
DownComer.x)/2.0；
Center-＞y=min(UpComer.y，DownComer.y)+fabs(UpComer.y-
DownComer.y)/2.0；
return 1；
}
//This function gives back the center of each tracking window in the prototype
//and the width and height of each window in the transformed model.All
//the information is in the Windows array.
int PASCAL get_tracking_windows(RPOINT *Prot，RPOINT *Model，
int From，int To，TR_WIN *Windows)
{
double Xmax，Xmin；
double XModmax，XModmin；
double Xunit，XModunit；
double CurrX[20]；
RPOINT Cp1，Cp2，Cp3，Cp4；
<dp n="d356"/>
RPOINT Cp[4]；
RPOINT Mo[4]；
int i；
LINE UpLine，DownLine；
LINE UpModLine，DownModLine；
RPOINT p1，p2，p3，p4；
RPOINT mo1，mo2，mo3，mo4；
RPOINT DumCenterArr[20]；
p1=Prot[0]；
p2=Prot[1]；
p3=Prot[2]；
p4=Prot[3]；
mo1=Model[0]；
mo2=Model[1]；
mo3=Model[2]；
mo4=Model[3]；
Xnax=max(p1.x，p4.x)；
Xmin=min(p2.x，p3.x)；
Xunit=(Xmin-Xmax)/(double)(To-From)；
XModmax=max(mo1.x，mo4.x)；
XModmin=min(mo2.x，mo3.x)；
XModunit=(XModmin-XModmax)/(double)(To-From)；
mkline(p1.x，p1.y，p2.x，p2.y，&UpLine)；
mkline(p3.x，p3.y，p4.x，p4.y，&DownLine)；
mkline(mo1.x，mo1.y，mo2.x，mo2.y，&UpModLine)；
mkline(mo3.x，mo3.y，mo4.x，mo4.y，&DownModLine)；
for(i=From；i＜To-1；i++){
get_quad_segment_on_x(UpLine，DownLine，Xmax，Xunit，i，Cp)；
center_of_bounded_rect(Cp[0]，CP[1]，Cp[2]，Cp[3]，&(Windows[i]. Center)，
&(Windows[i].Xdir)，&(Windows[i].Ydir))；
get_quad_segment_on_x(UpModLine，
DownModLine，XModmax，XModunit，i，Mo)；
center_of_bounded_rect(Mo[0]，Mo[1]，Mo[2]，Mo[3]，&(DumCenterArr[i])，
&(Windows[i].Xdir)，&(Windows[i].Ydir))；
}
<dp n="d357"/>
return 1；
}
//This function gets two horizontal(approx)lines，a start point on
//X axis a unit and a number of segment，and returns in Vertexes the
//vertexes of a rectangle in the number segment which is bounded inside
//these two lines.
int PASCAL get_quad_segment_on_x(LINE UpLine，LINE DownLine，double
XStart，
double Xunit，int SegNum，RPOINT *Vertexes)
{
double StartPoint，EndPoint；
StartPoint=XStart+Xunit*SegNum；
EndPoint=StartPoint+Xunit；
Vertexes[0].y=(UpLine.a*StartPoint+UpLine.c)/-UpLine.b；
Vertexes[0].x=StartPoint；
Vertexes[1].y=(UpLinea*EndPoint+UpLine.c)/-UpLine.b；
Vertexes[1].x=EndPoint；
Vertexes[2].x=EndPoint；
Vertexes[2].y=(DownLine.a*EndPoint+DownLine.c)/-DownLine.b；
Vertexes[3].x=StartPoint；
Vertexes[3].y=(DownLine.a*StartPoint+DownLine.c)/-DownLine.b；
return 1；
}
<dp n="d358"/>
#include ＜windows.h＞
#include ＜windowsx.h＞
#include ＜math.h＞
#include ＜commdlg.h＞
#include ＜stdlib.h＞
#include ＂const.h＂
#include ＂bitmap.h＂
#include ＂lines.h＂
#include ＂track.h＂
#include ＂persp.h＂
#include ＂min_mag.h＂
#include ＂lib.h＂
#define SIZE 8
#define X_AXIS 1
#define Y_AXIS 2
#define MAXIMAL 1
#define MINIMAL 2
static double Fa[2*FSIZE+1]，*F；
int PASCAL LSE_Perspective(HWND，SHIFT_POINTS，SHIFT_POINTS
，int，
Perspective_Transform *)；
int PASCAL xPerspEqn(double，double，double，double *)；
int PASCAL yPerspEqn(double，double，double，double *)；
int PASCAL qrsolv8(HWND，double m[SIZE][SIZE]，int，double *)；
int PASCAL qrdecomp(double m[SIZF][SIZE]，int，double *，double *)；
int PASCAL rsolv(double m[SIZE][SIZE]，int，double *，double *)；
int PASCAL invertPerspective(double Pf[3][3]，double Pb[3][3])；
int PASCAL xTninEqn(double，double，double，double *)；
int PASCAL yThinEqn(double，double，double，double *)；
double PASCAL det3(double y[3][3])；
int PASCAL inv3(double y[3][3]，double z[3][3])；
int PASCAL tmSim(SHIFT_POINTS，SHIFT_POINTS，
int，Perspective_Transform *，
HFILE)；
int_cdecl dcomp(const void *a，const void *b)；
<dp n="d359"/>
double norm2(RPOINT a，RPOINT b)；
int PASCAL delete_exterme_point(SHIFT_POINTS，SHIFT_POINTS，
int，int，int *)；
MYBITMAP FAR*minify(HWND hwnd，MYBITMAP FAR*in，int fac)
{
MYBITMAP FAR *aux，*out；
/* Build windowed-sinc filter-table */
sinc_filter(fac)；
/* horizontally sub-sample in-＞aux */
aux=hminify(hwnd，in，fac)；
/* vertically sub-sample Mid-＞Out */
out=vminify(hwnd，aux，fac)；
bm_free(aux)；
return(out)；
}
MYBITMAP FAR *hminify(HWND hwnd，MYBITMAP FAR*in，int fac)
{
MYBITMAP FAR *out；
int y；
int OutCols；
int ColorFactor；
OutCols=in-＞cols/fac；
out=bm_alloc(OutCols，in-＞rows，in-＞typ)；
if(out==NULL)
return(NULL)；
if(in-＞typ==COLOR_MODEL)ColorFactor=3；
else ColorFactor=1；
<dp n="d360"/>
out-＞gpic=(BYTE huge*)
GlobalAllocPtr(GMEM_MOVEABLE，(DWORD)OutCols*(DWORD)(in-
＞rows)*
(DWORD)ColorFactor)；
if(in-＞typ==GREY_MODEL){
for(y=0；y＜in-＞rows；y++){
lpf1D(BITMAP_PLACE_PTR(in，y，0)，in-＞cols，fac，
BITMAP_PLACE_PTR(out，y，0))；
}
}
else{//COLOR MODEL
for(y=0；y＜in-＞rows；y++){
lpf1D_rgb(BITMAP_RGB_PLACE_PTR(in，y，0)，in-＞cols，fac，
BITMAP_RGB_PLACE_PTR(out，y，0))；
}
}
return(out)；
}
MYBITMAP FAR *vminify(HWND hwnd，MYBITMAP FAR *in，int fac)
{
MYBITMAP FAR *out；
int y，x；
BYTE huge *ivec；
BYTE huge *ovec；
int OutRows；
int ColorFactor；
OutRows=in-＞rows/fac；
out=bm_alloc(in-＞cols，OutRows，in-＞typ)；
if(out==NULL)
return(NULL)；
if(in-＞typ==COLOR_MODEL)ColorFactor=3；
else ColorFactor=1；
out-＞gpic=(BYTE huge*)
<dp n="d361"/>
GlobalAllocPtr(GMEM_MOVEAB LE，(DWORD)OutRows*(DWORD)(in-＞cols)*
(DWORD)ColorFactor)；
ivec=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，(DWORD)(in-
＞rows)*
(DWORD)ColorFactor)；
ovec=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，DWORD)(out-
＞rows)*
(DWORD)ColorFactor)；
if(in-＞typ==GREY_MODEL){
for(x=0；x＜in-＞cols；x++){
for(y=0；y＜in-＞rows；y++)
ivec[y]=BITMAP_PLACE(in，y，x)；
lpf1D(ivec，in-＞rows，fac，ovec)；
for(y=0；y＜out-＞rows；y++)
BITMAP_PLACE(out，y，x)=ovec[y]；
}
}
else{
for(x=0；x＜in-＞cols；x++)(
for(y=0；y＜in-＞rows；y++){
ivec[(DWORD)3*(DWORD)y]
*(BITMAP_RGB_PLACE_PTR(in，y，x))；
ivec[(DWORD)3*(DWORD)y+1]=
*((BITMAP_RGB_PLACE_PTR(in，y，x))+1)；
ivec[(DWORD)3*(DWORD)y+2]=
*((BITMAP_RGB_PLACE_PTR(in，y，x))+2)；
}
lpf1D_rgb(ivec，in-＞rows，fac，ovec)；
for(y=0；y＜out-＞rows；y++){
*(BITMAP_RGB_PLACE_PTR(out，y，x))=
ovec[(DWORD)3*(DWORD)y]；
*((BITMAP_RGB_PLACE_PTR(out，y，x))+1)=
ovec[(DWORD)3*(DWORD)y+1]；
*((BITMAP_RGB_PLACE_PTR(out，y，x))+2)=
ovec[(DWORD)3*(DWO RD)y+2]；
}
<dp n="d362"/>
}
}
return(out)；
}
int PASCAL sinc_filter(int fac)
{
int j；
int fsize=LOBES*fac；
double pie=acos(-1.0)；
double sum；
F=Fa+fsize；
for(j=-fsize；j＜=fsize；j++){
F[j]=1.0/(double)(2*fsize+1)；
}
/* Compute windowed sinc filter table */
for(j=-fsize；j＜=fsize；j++){
double x=(double)j/fac；
double z，w；
if(j==0){
z=1.0；
}
else{
z=sin(pie*x)/(pie*x)；
}
w=0.5+0.5*cos(pie*(double)j/(double)fsize)；
F[j]=z*w；
}
/* Normalize to unit integral */
<dp n="d363"/>
for(sum=0，j=-fsize；j＜=fsize；j++)
sum+=F[j]；
for(j=-fsize；j＜=fsize；j++)
F[j]/=sum；
return 1；
}
int PASCAL lpf1D(BYTE huge*in，int Dim，int fac，BYTE huge *out)
{
int i，j，k，x；
int dim=Dim/fac；
double acc；
for(k=i=0；i＜dim；k+=fac，i++){
acc=0.0；
for(j=-2*fac；j＜=2*fac；j++){
x=k+j；
/* zero padding */
if(x＞=0 && x＜Dim)
acc+=(double)(*(in+x))* F[j]；
}
if(acc＜0.0)
*(out+i)=0；
else if(acc＞255.0)
*(out+i)=255；
else
*(out+i)=(BYTE)(0.5+acc)；；
}
return 1；
}
int PASCAL lpf1D_rgb(BYTE huge* in，int Dim，int fac，BYTE huge *out)
{
<dp n="d364"/>
int i，j，k，x；
int dim=Dim/fac；
double accr，accg，accb；
DWORD CurrPl；
for(k=i=0；i＜dim；k+=fac，i++){
accr=accg=accb=0.0；
for(j=-2*fac；j＜=2*fac；j++){
x=k+j；
/* zero padding */
if(x＞=0 && x＜Dim){
accr+=(double)(*(in+((DWORD)3*(DWORD)x)))*F[j]；
accg+=(double)(*(in+((DWORD)3*(DWORD)x+1)))*F[j]；
accb+=(double)(*(in+((DWORD)3*(DWORD)x+2)))*F[j]；
}
}
CurrPl=(DWORD)3*(DWORD)i；
if(accr＜0.0)
*(out+CurrPl)=0；
else if(accr＞255.0)
*(out+CurrPl)=255；
else
*(out+CurrPl)=(BYTE)(0.5+accr)；；
CurrPl=(DWORD)3*(DWORD)i+1；
if(accg＜0.0)
*(out+CurrPl)=0；
else if(accg＞255.0)
*(out+CurrPl)=255；
else
*(out+CurrPl)=(BYTE)(0.5+accg)；
CurrPl=(DWORD)3*(DWORD)i+2；
<dp n="d365"/>
if(accb＜0.0)
*(out+CurrPl)=0；
else if(accb＞255.0)
*(out+CurrPl)=255；
else
*(out+CurrPl)=(BYTE)(0.5+accb)；；
}
return 1；
}
int PASCAL edge_refine(MYBITMAP *Bmap，EDGE *e，int Len)
{
double dx；
double dy；
int status；
dx=fabs(e-＞xe-e-＞xs)；
dy=fabs(e-＞ye-e-＞ys)；
if(dx＜dy)
e-＞vertical=1；
else
e-＞vertical=0；
if(e-＞vertical){
/* horizontal search for max.gradient */
if(status=h_refine(Bmap，&(e-＞xs)，&(e-＞ys)，Len})return(status)；
if(status=h_refine(Bmap，&(e-＞xe)，&(e-＞ye)，Len))return(status)；
}
else{
/* vertical search for max gradient */
if(status=v_refine(Bmap，&(e-＞xs)，&(e-＞ys)，Len))return(status)；
if(status=v_refine(Bmap，&(e-＞xe)，&(e-＞ye)，Len))return(status)；
}
return(0)；
}
<dp n="d366"/>
int PASCAL sub_pixel_interp(double ep，double ec，double en，double *zm，
double *em)
{
/* 1D sup-pixel estimation of the registration error minimum：
*ep=A(-1)^2+B(-1)+C=A-B+C
*ec=A(0)^2+B(0)+C=C
*en=A(+1)^2+B(+1)+C=A+B+C
*
*yields the following solution：
*/
double C=ec；
double A=(ep+en)/2.0-C；
double B=(en-ep)/2.0；
double z；
/* sup-pixel poistion estimate is zm */
z=*zm=-(B/(2.0*A))；
//*em=z*(A*z+B)+C；
*em=A*z*z+B*z+C；
return(0)；
}
#define EMAX 10000000L
#define R0 14/* search range */
#define RY 6/* Search range in Y direction*/
double Fxy[2*RY+1][2*R0+1]；
HFILE hFile；
OFSTRUCT of；
int PASCAL xysolve(HWND hwnd，MYBITMAP *CurrBmap，MYBITMAP
*DestBmap，
SHIFT *Shifts，TR_WIN *Windows，int WindowsNum，
TRACK_POINTS *TrBase，TRACK_POINTS *TrPoints.
<dp n="d367"/>
Perspective_Transform *NewTransf，HFILE hFile，
TRACK_POINTS*DBasep，RPOINT *DiffArr)
{
int k，num；
SHIFT i；
char String[50]；
int Wr=0；
int j；
double HalfX，HalfY；
SHIFT_POINTS InitPos，NewPos；
RPOINT ShiftVals[NUM_OF_TRACK_POINTS]；
int Indexes[NUM_OF_TRACK_POINTS]；
int Size，Counter；
int Remlndex；
for(k=0；k＜NUM_OF_TRACK_POINTS；k++){
Shifts[k].dx=Shifts[k].dy=Shifts[k].sim=0.0；
}
k=0；
Counter=0；
for(k=0；k＜TrPoints-＞NumOfPoints；k++){
//for(k=0；k＜WindowsNum；k++){
if(xysrch(hwnd，CurrBmap，DestBmap，&(Shifts[k])，
TrBase-＞TrackP[k]，TrPoints-＞TrackP[k]，
//(int)(Windows[k].Xdir)，(int)(Windows[k].Ydir)，10，4)!=0){
CORR_WINDOWX，CORR_WINDOWY，/*R0，RY*/10，5)!=0)
ShiftVals[Counter].x=Shifts[k].dx；
ShiftVals[Counter].y=Shifts[k].dy；
Indexes[Counter]=k；
Counter++；
}
}
for(k=0；k＜Counter；k++){
//InitPos.TrackP[k].x=(double)DBasep-＞TrackP[Indexes[k]].x；//
Replacing clustering.
<dp n="d368"/>
//InitPos.TrackP[k].y=(double)DBasep-＞TrackP[Indexes[k]].y； //
Replacing clustering.
InitPos.TrackP[k].x=(double)TrBase-＞TrackP[Indexes[k]].x； //
Replacing clustering.
InitPos.TrackP[k].y=(double)TrBase-＞TrackP[Indexes[k]].y； //
Replacing clustering.
NewPos.TrackP[k].x=TrPoints-＞TrackP[Indexes[k]].x+
ShiftVals[k].x-DiffArr[lndexes[k]].x；//Replacing clustering.
NewPos.TrackP[k].y=TrPoints-＞TrackP[Indexes[k]].y+
ShiftVals[k].y-DiffArr[Indexes[k]].y；//Replacing clustering.
}
Size=Counter；//Replacing clustering.
strcpy(String，＂lnitPos After Cluster\n＂)； //
_lwrite(hFile， String，strlen(String))； //
for(k=0；k＜Size；k++){ //
sprintf(String，＂％lf，％lf\n＂，lnitPos.TrackP[k].x，lnitPos.TrackP[k].y)；//
_lwrite(hFile，String，strlen(String))； //
} //
strcpy(String，＂\n\nNewPos After Cluster\n＂)； //
_lwrite(hFile，String，strlen(String))； //
for(k=0；k＜Size；k++){ //
sprintf(String，＂％lf，％lf\n＂，NewPos.TrackP[k].x，NewPos.TrackP[k].y)；//
_lwrite(hFile，String，strlen(String))； //
} //
_lwrite(hFile，＂\n\n\n＂，3)；
//Removing 20％ Of Bad Points
/*
delete_exterrne_point(InitPos，NewPos，Size，X_AXIS，&Remlndex)
for(j=Remlndex；j＜Size-1；j++){
InitPos.TrackP[j]=InitPos.TrackP[j+1]；
NewPos.TrackP[i]=NewPos.TrackP[j+1]；
}
Size-；
delete_exterrne_point(InitPos，NewPos，Size，Y_AXIS，&Remlndex)；
for(j=Remlndex；j＜Size-1；j++){
InitPos.TrackP[j]=InitPos.TrackP[j+1]；
<dp n="d369"/>
NewPos.TrackP[j]=NewPos.TrackP[j+1]；
}
Size-；
*/
if(get_in_series_flag()==1){
tmSim(InitPos，NewPos，Size，NewTransf，hFile)
}else{
tmSim(InitPos，NewPos，Size，NewTransf，hFile)
//LSE_Perspective(hwnd，InitPos，NewPos，Size，NewTransf)；
}
for(k=0；k＜Size；k++){
double DstX，DstY，w；
DstX=InitPos.TrackP[k].x*NewTransf-＞Pf[0][0]+
InitPos.TrackP[k].y*NewTransf-＞Pf[1][0]+NewTransf-
＞Pf[2][0]；
DstY=InitPos.TrackP[k].x*NewTransf-＞Pf[0][1]+
InitPos.TrackP[k].y*NewTransf-＞Pf[1][1]+NewTransf-
＞Pf[2][1]；
w=InitPos.TrackP[k].x*NewTransf-＞Pf[0][2]+
InitPos.TrackP[k].y*NewTransf-＞Pt[1][2]+NewTransf-
＞Pf[2][2]；
sprintf(String，＂％lf-＞％lf：：：％If-＞％lf\n＂，InitPos.TrackP[k].x，DstX/w，
InitPos.TrackP[k].y，DstY/w)；
_lwrite(hFile，String，strlen(String))；
}
for(j=0；j＜3；j++){ //
sprintf(String，＂\n％lf，％If，％If\n＂，NewTransf-＞Pf[j][0]，//
NewTransf-＞Pf[j][1]，NewTransf-＞ Pf[j][2])；//
_lwdte(hFile，String，strlen(String))； //
} //
return(1)；
}
int PASCAL xysrch(HWND hwnd，MYBITMAP*CurrBmap，MYBITMAP
*OriginSign，
<dp n="d370"/>
SHIFT *s，POINT pBase，POINT pLast，int CorWinX，int CorWinY，int XWin，int
YWin)
{
int x_0，y_0；
int dx，dy，k，l；
int x_n，y_n ；
int dj，dj；
double t，r；
int i；
double em；double e
char String[50]；
int long PixlnWin；
char Buffer[256]
long Tresh；
BYTE huge *CurrPtr
BYTE huge *ZeroPtr
int FromX，FromY；
double z，d，area；
x_0=pBase.x；
y_0=pBase.y；
FromX=pLast.x；
FromY.=pLast.y；
PixInWin=(DWORD)(CorWinX*2+1)*(DWORD)(CorWinY*2+1)；
Tresh=(DWORD)12*(DWORD)PixInWin；
//Fresh=(DWORD)4*(DWORD)PixInWin；
area=(2*CorWinY+1)*(2*CorWinX+1)；
em=1.0e20；
y_n=FromY-YWin-1；
for(dy=-YWin；dy＜=YWin；dy++){
y_n++；
for(dx=-XWin；dx＜=XWin；dx++){
x_n=FrornX+dx；
e=0.0；
<dp n="d371"/>
for(k=-CorWinY；k＜=CorWinY；k++){
CurrPtr=BITMAP_PLACE_PTR(CurrBmap，y_n+k，x_n)；
ZeroPtr=BITMAP_PLACE_PTR(OriginSign，y_0+k，x_0)；
for(l=-CorWinX；l＜=CorWirX；l++){
z=CurrPtr[l]-ZeroPtr[l]；
e=e+z*z；
}
}
e/=area；
Exy[dy+YWin][dx+XWin]=e；
/* update min.error */
if(e＜em){
em=e；
dj=dx；
di=dy；
}
}
}
s-＞dx=dj；
s-＞dy=dj；
if(em＞Tresh)return 0；
if(abs(dj)==XWin||abs(di)==YWin)return 0；
sub_pixel_refine(dj，di，dj+XWin，di+YWin，s)；
return 1；
}
int PASCAL sub_pixel_refine(int dj，int di，int dxlndex，int dylndex，SHIFT*s)
{
double deltax，deltay；
double simx，simy；
s-＞dx=dj；
s-＞dy=di；
s-＞sim=Exy[dylndex][dxlndex]；
<dp n="d372"/>
sub_pixel_interp(Exy[dylndex][dxlndex-1]，Exy[dylndex][dxlndex]，
Exy[dylndex][dxlndex+1]，&deltax，&simx)；
sub_pixel_interp(Exy[dylndex-1][dxlndex]，Exy[dylndex][dxlndex]，
Exy[dylndex+1][dxlndex]，&deltay，&simy)；
s-＞dx+=deltax；
s-＞dy+=deltay；
s-＞sim=(simx+simy)/2.0；
return(0)；
}
static double Mp[8][8]，Ap[8]；
double G[2*NUM_OF_TRACK_POINTS][8]；
double Gt[8][2*NUM_OF_TRACK_POINTS]；
double Fpr[2*NUM_OF_TRACK_POINTS]；
int PASCAL Quad2Quad(HWND hwnd，RPOINT srcpnts[4]，RPOINT
dstpnts[4]，
Perspective_Transform *Tp)
{
int i，j，k，status；
double x，y，u，v；
for(k=0；k＜4；k++){
x=dstpnts[k].x；
y=dstpnts[k].y；
u=srcpnts[k].x；
v=srcpnts[k].y；
Ap[k]=x；
<dp n="d373"/>
Ap[4+k]=y；
xPerspEqn(x，u，v，Mp[k])；
yPerspEqn(y，u，v，Mp[4+k])；
}
qrsolv8(hwnd，Mp，8，Ap)；
Tp-＞Pf[0][0]=Ap[0]；
Tp-＞Pf[1][0]=Ap[1]；
Tp-＞Pf[2][0]=Ap[2]；
Tp-＞Pf[0][1]=Ap[3]；
Tp-＞Pf[1][1]=Ap[4]；
Tp-＞Pf[2][1]=AP[5]；
Tp-＞Ff[0][2]=Ap[6]；
Tp-＞Pf[1][2]=Ap[7]；
Tp-＞Pf[2][2]=1.0；
status=invertPerspective(TP-＞Pf，Tp-＞Pb)；
return(1)；
}
int PASCAL copy_transform(Perspective_Transform
*To，Perspective_Transform *From)
{
int i，j；
for(i=0；i＜3；i++){
for(j=0；j＜3；j++){
To-＞Pf[i][j]=From-＞Pf[i][j]；
To-＞Pb[i][j]=From-＞Pb[i][j]；
}
}
return 1；
}
<dp n="d374"/>
int PASCAL LSE_Perspective(HWND hwnd，SHIFT_POINTS src_pts，
SHIFT_POINTS dst_pts，int pnum，Perspective_Transform *Tp)
{
int i，j，k，status；
double x，y，u，v；
if(pnum＜4){
MessageBox(hwnd，＂Cannot solve perspective with less than 3
points.＂
，＂Shifts＂，MB_ICONEXCLAMATION|MB_OK)；
return 0；
}
if(pnum==4){/* Quad2.Quad */
for(k=0；k＜4；k++){
x=dst_pts.TrackP[k].x；
y=dst_pts.TrackP[k].y；
u=src_pts.TrackP[k].x；
v=src_pts.TrackP[k].y；
Ap[k]=x；
Ap[4+k]=y；
xPerspEqn(x，u，v，Mp[k])；
yPerspEqn(y，u，v，Mp[4+k])；
}
else{
for(k=0；k＜pnum；k++){
x=dst_pts.TrackP[k].x；
y=cst_pts.TrackP[k].y；
u=src_pts.TrackP[k].x；
v=src_pts.TrackP[k].y；
Fpr[k]=x；
Fpr[pnum+k]=y；
<dp n="d375"/>
xPerspEqn(x，u，v，G[k])；
yPerspEqn(y，u，v，G[pnum+k])；
for(k=0；k＜2*pnum；k++){
for(j=0；j＜8；j++){
Gt[j][k]=G[k][j]；
}
}
for(i=0；i＜8；i++){
for(j=0；j＜8；j++){
Mp[i][j]=0.0；
for(k=0；k＜2*pnum；k++){
Mp[i][j]+=Gt[i][k]*G[k][j]；
}
}
}
for(j=0；j＜8；j++){
Ap[j] = 0；
for(k=0；k＜pnum*2；k++){
Ap[j]+=Gt[j][k]*Fpr[k]；
}
}
}
qrsolv8(hwnd，Mp，8，Ap)；
Tp-＞Pf[0][0]=Ap[0]；
Tp-＞Pf[1][0]=Ap[1]；
Tp-＞Pf[2][0]=Ap[2]；
Tp-＞Pf[0][1]=Ap[3]；
Tp-＞Pf[1][1]=Ap[4]；
Tp-＞Pf[2][1]=Ap[5]；
Tp-＞Pf[0][2]=Ap[6]；
Tp-＞Pf[1][2]=Ap[7]；
<dp n="d376"/>
Tp-＞Pf[2][2]=1.0；
status=invertPerspective(Tp-＞Pf，Tp-＞Pb)；
return(1)；
}
int PASCAL xPerspEqn(double x，double u，double v，double *xRow)
{
xRow[0]=u；
xRow[1]=v；
xRow[2]=1；
xRow[3]=0；
xRow[4]=0；
xRow[5]=0；
xRow[6]=-u*x；
xRow[7]=-v*x；
int PASCAL yPerspEqn(double y，double u，double v，double *yRow)
{
yRow[0]=0；
yRow[1]=0；
yRow[2]=0；
yRow[3]=u；
yRow[4]=v；
yRow[5]=1；
yRow[6]=-u*y；
yRow[7]=-v*y；
}
int PASCAL qrsolv8(HWND hwnd，double m[SIZE][SIZE]，int size，double
b[SIZE])
{
int i，
j；
<dp n="d377"/>
double tau，
m1[SIZE]，
m2[SIZE]；
if(qrdecomp(m，size，m1，m2)＜0){
MessageBox(hwnd，＂singularity in qrdecomp().＂
，＂Shifts＂，MB_ICONEXCLAMATION|MB_OK)；
return 0；
}
for(j=0；j＜(size-1)；j++){
tau=0.0；
for(i=j；i＜size；i++)
tau+=m[i][j]*b[i]；
tau/=m1[j]；
for(i=j；i＜size；i++)
b[i]=tau*m[i][j]；
}
b[size-1]/=m2[size-1]；
rsolv(m，size，m2，b)；
}
/*
* Compute the QR decomposition of a square matrix m using the
Stewart
* algorithm.
* Upon termination，thr decomposition is stored in m，m1 and m2 as
* follows：
* R is contained in the upper triangle of m except that its main
* diagonal is contained in m2，and Q(transpos)=Q(n-1)*...*Q(1)
* where Q(j)=l-(Uj*Uj(transpos)/Pj)where
* Uj[i]=0，i=1-＞j-1，Uj[i]=m[i][j]，i=j-＞n，Pj=m1[j].
*
* Stewart，G.W.，Introduction to matrix Computations，Academic Press，
* New York(1973).
*
* C Implementaion：Dr.I.Wilf.
*/
<dp n="d378"/>
int PASCAL qrdecomp(double m[SIZE][SIZE]，int size，double m1[SIZE]，
double m2[SIZE])
{
int i，k，j；
double eta，t，sigma，tau；
for(k=0；k＜(size-1)；k++){
eta=0.0；
for(i=k；i＜size；i++)
if(fabs(m[i][k])＞eta)
eta=fabs(m[i][k])；
if(eta==0.0)
return(-1)；
/* form Qk and premultiply m by it */
t=0；
for(i=k；i＜size；i++){
m[i][k]/=eta；
t+=m[i][k]*m[i][k]；
}
if(m[k][k]＞=0.0)
sigma=sqrt(t)；
else
sigma=-sqrt(t)；
m[k][k]+=sigma；
m1[k]=sigma*m[k][k]；
m2[k]=(-eta*sigma)；tau=0；
for(j=k+1；j＜size；j++){
tau=0；
for(i=k；i＜size；i++)
tau+=m[i][k]*m[i][j]；
tau/=m1[k]；
for(i=k；i＜size；i++)
m[i][j]=tau*m[i][k]；
}
}
m2[size-1]=m[size-1][size-1]；
return(0)；
<dp n="d379"/>
}
/*
* rsolv(m，size，m2，b)
* solve Rx=b for b，where the upper triangular matrix R is
* stored in M，m2.
* C Implementaion：Dr.I.Wilf.
*/
int PASCAL rsolv(double m[SIZE][SIZE]，int size，double *m2，double *b)
{
int i，j；
double s；
for(i=size-2；i＞=0；i-){
s=0；
for(j=i+1；j＜size；j++)
s+=m[i][j]*b[j]；
b[i]=(b[i]-s)/m2[i]；
}
}
int PASCAL invertPerspective(double Pf[3][3]，double Pb[3][3])
{
double a11=Pf[0][0]；
double a12=Pf[0][1]；
double a13=Pf[0][2]；
double a21=Pf[1][0]；
double a22=Pf[1][1]；
double a23=P1[1][2]；
double a31=Pf[2][0]；
double a32=Pf[2][1]；
double a33=Pf[2][2]；
Pb[0][0]=a22*a33-a23*a32；
Pb[0][1]=a13*a32-a12*a33；
Pb[0][2]=a12*a23-a13*a22；
<dp n="d380"/>
Pb[1][0]=a23*a31-a21*a33；
Pb[1][1]=a11*a33-a13*a31；
Pb[1][2]=a13*a21-a11*a23；
Pb[2][0]=a21*a32-a22*a31；
Pb[2][1]=a12*a31-a11*a32；
Pb[2][2]=a11*a22-a12*a21；
inv3(Pf，Pb)；
return(0)；
}
int PASCAL inv3(double y[3][3]，double z[3][3])
{
double b[2][2]，dety，detb；
int i，j，k，l，k1，l1；
dety=det3(y)；
if(dety==0.0)return(1)；
/* compute[].*/
for(i=0；i＜3；i++)
for(j=0；j＜3；j++){
for(k=0；k＜2；k++)
for(l=0；l＜2；l++){
if(l＜i)l1=l；
else l1=l+1；
if(k＜j)k1=k；
else k1=k+1；
b[k][l]=y[k1][l1]；
}
detb=b[0][0]*b[1][1]-b[1][0]*b[0][1]；
if(((i+j)％2)==0)z[i][j]=detb/dety；
else z[i][j]=(-detb)/dety；
}
}
double PASCAL det3(double y[3][3])
<dp n="d381"/>
{
short j，k，l；
double b[2][2]，det，detb；
det=0.0；
for(j=0；j＜=2；j++)
{
for(k=0；k＜=1；k++)
for(l=0；l＜=1；l++)
{
if(l＜j)b[k][l]=y[k+1][l]；
else b[k][l]=y[k+1][l+1]；
}
detb=b[0][0]*b[1][1]-b[0][1]*b[1][0]；
if((j％2)==0)det=det+y[0][j]*detb；
else det=det-y[0][i]*detb；
}
return(det)；
}
/*
int PASCAL invertPerspective(double Pf[3][3]，double Pb[3][3])
{
double a11，a12，a13，a21，a22，a23，a31，a32，a33；
a11=Pf[0][0]；
a12=Pf[0][1]；
a13=Pf[0][2]；
a21=Pf[1][0]；
a22=Pf[1][1]；
a23=Pf[1][2]；
a31=Pf[2][0]；
a32=Pf[2][1]；
a33=Pf[2][2]；
Pb[0][0]=a22*a33-a23*a32；
Pb[0][1]=a13*a32-a12*a33；
Pb[0][2]=a12*a23-a13*a22；
<dp n="d382"/>
Pb[1][0]=a23*a31-a21*a33；
Pb[1][1]=a11*a33-a13*a31；
Pb[1][2]=a13*a21-a11*a23；
Pb[2][0]=a21*a32-a22*a31；
Pb[2][1]=a12*a31-a11*a32；
Pb[2][2]=a11*a22-a12*a21；
return(0)；
}
*/
int PASCAL h_refine(MYBITMAP *Bmap，double *x，double *y，int Len)
{
int i，j，k，km；
int z=Len+1；
double u，gm；
double gmax
double a，b，c，d，e，f；
double Rx，Gx，Bx；
int rows，cols；
DWORD Size；
int EfectLen；
double *Gh；
i=(int)(*y+0.5)；
j=(int)(*x+0.5)；
cols=Bmap-＞cols；
rows=Bmap-＞rows；
if(j＜z||j＞(cols-z))return(1)；
if(i＜1||i＞(rows-2))return(1)；
EfectLen=(DWORD)Len*(DWORD)2+1；
Size=(DWORD)(sizeof(double))*(DWORD)Len*(DWORD)2+2；
Gh=(double *)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
for(k=-Len；k＜=Len；k++){
a=*(BITMAP_RGB_PLACE_PTR(Bmap，i-1，j+k-1))；
<dp n="d383"/>
b=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j+k-1))；
c=*(BITMAP_RGB_PLACE_PTR(Bmap，i+1，j+k-1))；
d=*(BITMAP_RGB_PLACE_PTR(Bmap，i-1，j+k))；
e=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j+k))；
f=*(BITMAP_RGB_PLACE_PTR(Bmap，i+1，j+k))；
Rx=a+2.0*b+c-d-2.0*e-f；
a=*(BITMAP_RGB_PLACE_PTR(Bmap，i-1，j+k-1)+1)；
b=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j+k-1)+1)；
c=*(BITMAP_RGB_PLACE_PTR(Bmap，i+1，j+k-1)+1)；
d=*(BITMAP_RGB_PLACE_PTR(Bmap，i-1，j+k)+1)；
e=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j+k)+1)；
f=*(BITMAP_RGB_PLACE_PTR(Bmap，i+1，j+k)+1)；
Gx=a+2.0*b+c-d-2.0*e-f；
a=*(BITMAP_RGB_PLACE_PTR(Bmap，i-1，j+k-1)+2)；
b=*(BTTMAP_RGB_PLACE_PTR(Bmap，i，j+k-1)+2)；
c=*(BITMAP_RGB_PLACE_PTR(Bmap，i+1，j+k-1)+2)；
d=*(BTTMAP_RGB_PLACE_PTR(Bmap，i-1，j+k)+2)；
e=*(BITMAP_RGB_PLACE_PTR(Bmap，i，j+k)+2)；
f=*(BITMAP_RGB_PLACE_PTR(Bmap，i+1，j+k)+2)；
Bx=a+2.0*b+c-d-2.0*e-f；
Gh[k+Len]=sqrt(Rx*Px+Gx*Gx+Bx*Bx)；
/* Find maximal response */
km=0；
gm=Gh[0]；
for(k=1；k＜EfectLen；k++){
if(Gh[k]＞gm){
km=kq
gm=Gh[k]；
}
}
if(km==0||km==EfectLen){
<dp n="d384"/>
GlobalFreePtr(Gh)；
return(1)；
}
sub_pixel_interp(Gh[km-1]，Gh[km]，Gh[km+1]，&u，&gmax)；
/* can threshold gmax to decide if edge detection was successful */
GlobalFreePtr(Gh)；
if(gmax＜100.0)return(1)；
*x+=u+km；
return(0)；
}
int PASCAL v_refine(MYBITMAP *Bmap，double *x，double *y，int Len)
{
int i，j，k，km；
int z=Len+1；
double v，gm；
double gmax；
int cols，rows；
DWORD Size；
int EfectLen；
double a，b，c，d，e，f；
double Ry，Gy，By；
double *Gh；
i=(int)(*y+0.5)；
j=(int)(*x+0.5)；
cols=Bmap-＞cols；
rows=Bmap-＞rows；
if(j＜z||i＞(cols-z))return(1)；
if(i＜1||i＞(rows-2))return(1)；
EfectLen=(DWORD)Len*(DWORD)2+1；
Size=(DWORD)(sizeof(double))*(DWORD)Len*(DWORD)2+2；
Gh=(double*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
for(k=-Len；k＜=Len；k++){
a=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k-1，j-1))；
<dp n="d385"/>
b=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k-1，j))；
c=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k-1，j+1))；
d=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k，j-1))；
e=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k，j))；
f=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k，j+1))；
Ry=a+2.0*b+c-d-2.0*e-f；
a=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k-1，j-1)+1)；
b=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k-1，j)+1)；
c=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k-1，j+1)+1)；
d=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k，j-1)+1)；
e=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k，j)+1)；
f=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k，j+1)+1)；
Gy=a+2.0*b+c-d-2.0*e-f；
a=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k-1，j-1)+2)；
b=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k-1，j)+2)；
c=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k-1，j+1)+2)；
d=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k，j-1)+2)；
e=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k，j)+2)；
f=*(BITMAP_RGB_PLACE_PTR(Bmap，i+k，j+1)+2)；
By=a+2.0*b+c-d-2.0*e-f；
Gh[k+Len]=sqrt(Ry*Ry+Gy*Gy+By*By)；
}
/* Find maximal response */
km=0；
gm=Gh[0]；
for(k=1；k＜EfectLen；k++){
if(Gh[k]＞gm){
km=k；
gm=Gh[k]；
}
}
if(km=0||km==EfectLen){
GlobalFreePtr(Gh)；
<dp n="d386"/>
return(1)；
}
sub_pixel_interp(Gh[km-1]，Gh[km]，Gh[km+1]，&v，&gmax)；
/* can threshold gmax to decide if edge detection was successful */
GlobalFreePtr(Gh)；
if(gmax＜100.0)return(1)；
*y+=v+km；
return(0)；
}
#define ORDER 8
#define NDATA 20
static double qrM[ORDER][ORDER]，qrA[ORDER]；
double qrG[2 * NDATA][ORDER]；
double qrGt[ORDER][2 * NDATA]；
double qrF[2 * NDATA]；
int PASCAL Thin_Perspective(HWND hwnd，SHIFT_POINTS src_pts，
SHIFT_POINTS dst_pts，int pnum，Perspective_Transform *Tp)
{
int i，j，k，status；
if(pnum＜3){
MessageBox(hwnd，＂Cannot solve perspective with less than 3
points.＂
，＂Shifts＂，MB_ICONEXCLAMATION|MB_OK)；
return 0；
}
for(k=0；k＜pnum；k++){
double x=dst_pts.TrackP[k].x；
double y=dst_pts.TrackP[k].y；
double u=src_pts.TrackP[k].x；
double v=src_pts.TrackP[k].y；
qrF[k]=x；
<dp n="d387"/>
qrF[pnum+k]=y；
xThinEqn(x，u，v，qrG[k])；
yThinEqn(y，u，v，qrG[pnum+k])；
continue；
}
for(k=0；k＜2 * pnum；k++){
for(j=0；j＜5；j++){
qrGt[j][k]=qrG[k][j]；
}
}
for(i=0；i＜5；i++)
for(j=0；j＜5；j++){
qrM[i][j]=0.0；
for(k=0；k＜2 * pnum；k++){
qrM[i][j]+=qrGt[i][k]*qrG[k][j]；
}
}
for(j=0；j＜5；j++){
qrA[j]=0；
for(k=0；k＜pnum *2；k++){
qrA[j]+=qrGt[j][k]*qrF[k]；
}
}
qrsolv(qrM，5，qrA)；
Tp-＞Pf[0][0]=qrA[0]；
Tp-＞Pf[1][0]=qrA[1]；
Tp-＞Pf[2][0]=qrA[2]；
Tp-＞Pf[0][1]=-qrA[1]；
Tp-＞Pf[1][1]=qrA[0]；
Tp-＞Pf[2][1]=qrA[3]；
Tp-＞Pf[0][2]=qrA[4]；
Tp-＞Pf[1][2]=0.0；
<dp n="d388"/>
Tp-＞Pf[2][2]=1.0；
status=invertPerspective(Tp-＞Pf，Tp-＞Pb)；
return(1)；
}
int.PASCAL xThinEqn(double x，double u，double v，double *xRow)
{
xRow[0]=u；
xRow[1]=v；
xRow[2]=1；
xRow[3]=0；
xRow[2]=-u*x；
return 1；
{
int PASCAL yThinEqn(double y，double u，double v，double *yRow)
{
yRow[0]=v；
yRow[1]=-u；
yRow[2]=0；
yRow[3]=1；
yRow[4]=-u * y；
return 1；
}
int PASCAL trans_grey_frame_to_fields(HWND hwnd，RPOINT
*SrcPnts，RPOINT *DstPnts，
MYBITMAP *SrcBmap，RPOINT *FrPnts，MYBITMAP **F1，MYBITMAP
**F2)
{
Perspective_Transform TpCurr，BasicTransf；
RPOINT FrDst[4]，CmPoly[4]；
RECT Rectan；
MYBITMAP *DestBmap；
DWORD Size；
int Cols，Rows；
<dp n="d389"/>
Quad2Quad(hwnd，FrPnts，DstPnts，&TpCurr)；
l_find_bound_rect(DstPnts，&Rectan)；
l_quad_in_new_origin(CmPoly，DstPnts，Rectan.left，Rectan.top，4)；
Cols=Rectan.right-Rectan.left+1；
Rows=Rectan.bottom-Rectan.top+1；
*F1=bm_alloc(Cols，Rows，GREY_MODEL)；
Size=(DWORD)Cols*(DWORD)Rows；
(*F1)-＞gpic=(BYTE huge*)GlobalAllocPtr(GMEM_MOVEABLE，Size)；
perspective(hwnd，SrcBmap，*F1，FrPnts，
CmPoly，GREY_MODEL，&BasicTransf)；
//split_bitmap_frame(SrcBmap，F1，F2)；
//bm_free(DestBmap)；
return 1：
}
#define NZOOM 256
#define WNUM 32
double rZooms[NZOOM]；
double rTheta[NZOOM]；
double rDx[WNUM]；
double rDy[WNUM]；
double ValArr[]={0.0，0.0，0.0，0.0}；
double Wheight[]={2.0，2.0，3.0，3.0}；
int PASCAL tmSim(SHIFT_POINTS mpts，SHIFT_POINTS fpts，int pnum，
Perspective_Transform *Tp，HFILE hFile)
{
double zoom，theta；
double zsin，zcos；
char String[50]；
double dx，dy；
double Orgtheta；
int i，j，nZoom=0；
double mlen，flen；
<dp n="d390"/>
double mtheta，ftheta；
if(pnum＞WNUM)
pnum=WNUM；
for(i=0；i＜pnum；i++)
for(j=i+1；j＜pnum；j++){
mien=norm2(mpts.TrackP[i]，mpts.TrackP[j])；
if(mien＜30.0)
continue；
flen=norm2(fpts.TrackP[i]，fpts.TrackP[j])；
mtheta=atan2(mpts.TrackP[j].x-mpts.TrackP[i].x，
mpts.TrackP[j].y-mpts.TrackP[i].y)；
ftheta=atar2.(fpts.TrackP[i].x-fpts.TrackP[i].x，
fpts.TrackP[j].y-fpts.TrackP[i].y)；
zoom=flen/mlen；
theta=ftheta-mtheta；
if(nZoom＜NZOOM){
rZooms[nZoom]=zoom；
rTheta[nZoom]=theta；
++nZoom；
}
{/* Tnmmed-mean estimate of theta */
double tavg=0.0；
int q1=nZoom /4；
int q3=3 * q1；
qsort((void*)rTheta，(size_t)nZoom，sizeof(double)，dcomp)；
for(i=q1；i＜q3；i++)
tavg+=rTheta[i]；
tavg/=(double)(q3-q1)；
<dp n="d391"/>
theta=tavg；
}
{/* Trimmed-mean estimate of zoom */
double zavg=0.0；
int q1=nZoom /4：
int q3=3 * q1；
qsort((void*)rZooms，(size_t)nZoom，sizeof(double)，dcomp)；
for(i=q1；i＜q3；i++)
zavg+=rZooms[i]；
zavg/=(double)(q3-q1)；
zoom=zavg；
}
//Orgtheta=theta；
//smooth_values(Orgtheta，&theta，ValArr，4，Wheight)；
sprintf(String，＂\n％ZOOM ％If，THETA ％lf\n＂，zoom，theta)；
_lwrite(hFile，String，strlen(String))；
zcos=zoom * cos(theta)；
zsin=zoom * sin(theta)；
for(i=0；i＜pnum；i++){
rDx[i]=fpts.TrackP[i].x-zcos * mpts.TrackP[i].x-
zsin * mpts.TrackP[i].y；
rDy[i]=fpts.TrackP[i].y+zsin * mpts.TrackP[i].x-
zcos * mpts.TrackP[i].y；
{/* Trimmed-mean estimate of dx */
double xavg=0.0；
int q1=pnum /4；
int q3=3 * q1；
qsort((void*)rDx，(size_t)pnum，sizeof(double)，dcomp)；
for(i=q1；i＜q3；i++)
xavg+=rDx[i]；
xavg /=(double)(q3-q1)；
dx=xavg；
<dp n="d392"/>
}
{/* Trimmed-mean estimate of dy */
double yavg=0.0；
int q1=pnum /4；
int q3=3*q1；
qsort((void*)rDy，(size_t)pnum，sizeof(double)，dcomp)；
for(i=q1；i＜q3；i++)
yavg+=rDy[i]；
yavg/=(double)(q3-q1)；
dy=yavg；
}
{/* Fill fwd.matrix */
Tp-＞Pf[0][0]=zcos；
Tp-＞Pf[1][0]=zsin；
Tp-＞Pf[2][0]=dx；
Tp-＞Pf[0][1]=-zsin；
Tp-＞Pf[1][1]=zcos；
Tp-＞Pf[2][1]=dy；
Tp-＞Pf[0][2]=0；
Tp-＞Pf[1][2]=0；
Tp-＞Pf[2][2]=1；
inv3(Tp-＞Pf，Tp-＞Pb)；
}
return(1)；
double norm2(RPOINT a，RPOINT b)
{
double dx=a.x-b.x；
double dy=a.y-b.y；
<dp n="d393"/>
return(sqrt(dx * dx+dy * dy))；
}
int_cdecl dcomp(const void *a，const void *b)/*(double *a，double *b)*/
{
if(*(double*)a==*(double*)b)return(0)；
return(*(double*)a＜*(double*)b?-1：1)；
}
int PASCAL delete_exterme_point(SHIFT_POINTS init，SHIFT_POINTS new，
int Size，int Axis，int *Index)
{
int i；
double Value，Tmp；
if(Axis=X_AXIS){
Value=-100.0；
for(i=0；i＜Size；i++){
if((Tmp=fabs(new.TrackP[i].x-iniLTrackP[i].x))＞Value){
Value=Tmp；
*Index=i；
}
}
}
if(Ais=Y_AXIS){
Value=-100.0；
for(i=0；i＜Size；i++){
if((Tmp=fabs(new.TrackP[i].y-init.TrackP[i].y))＞Value){
Value=Tmp；
*Index=i；
}
}
}
return 1；
}
Claims (35)
1.用于检测广告地点的设备，包括：
一个场地抓获器，用作抓获和数字化至少一个表示一个体育设施的至少一部分的场地；以及
一个广告地点检测器，用作不基于与体育设施有关的广告地点的位置，检测至少一个场地上的至少一个广告地点。
2.用于插入广告的设备，包括
一个场地抓获器，用作抓获和数字化至少一个表示一个体育设施的至少一部分的场地；以及
一个广告插入器，用作把一个广告的一部分插入到体育设施内一个被部分堵塞的广告地点处的至少一个场地上，其中被插入广告的部分对应于该广告地点未堵塞的部分。
3.根据权利要求2的设备，其中所述广告插入器包括一个广告地点检测器，其用作不基于与该体育设施有关的广告地点的位置，检测至少一个场地上的至少一个广告地点。
4.用于检测广告地点的设备，包括：
一个场地抓获器，用作抓获和数字化至少一个表示一个体育设施的至少一部分的场地；
一个广告地点检测器，用作在至少一个场地里检测至少一个广
告地点；以及
一个广告地点跟踪器，用作在不必跟踪一个全部场地的状态下跟踪由该广告地点检测器检测出的至少一个广告地点。
5.根据权利要求2的设备，其中所述广告插入器包括：
一个广告地点检测器，用作在至少一个场地里检测至少一个广告地点；以及
一个广告地点跟踪器，用作在不必跟踪一个全部场地的状态下跟踪由该广告地点检测器检测出的至少一个广告地点。
6.根据权利要求4或5的设备，其中所述广告地点检测器用作不基于与该体育设施有关的广告地点的位置，检测至少一个场地上的至少一个广告地点。
7.一种广播广告的方法，包括：
广播包括至少一个广告图象的一项活动的图象；
在该活动的图象中识别该广告图象并且只增强该广告图象。
8.根据权利要求7的方法，其中增强步骤包括使该广告图象的边缘轮廓清晰的步骤。
9.一种视频处理方法，包括：
在包括多个视频帧的视频系列中检测一个运动物体；并且
在该多个视频帧中的每个帧中向该运动物体插入一个广告。
10.检测广告图象的设备，包括：
一个场地抓获器，用作抓获和数字化至少一个表示一个体育设施的至少一部分的场地；
一个广告图象检测器，用作在至少一个场地里检测至少一个广告图象；以及
一个广告显示时间计数器，用作计算各广告图象的显示时间长度。
11.根据权利要求10的设备，其中所述时间计算器还用作存储各广告图象的除了其显示时间长度之外的至少一种显示时间的特性，该设备还包括一个广告收费计算机，其用作根据显示时间长度以及至少另一种显示时间特性计算广告费用。
12.根据权利要求11的设备，其中不同于显示时间长度的显示时间特性包括一种在加时期间内是否出现显示时间的指示。
13.根据权利要求11的设备，其中不同于显示时间长度的显示时间特性包括一种对各次显示和比赛开始之间的间隔的指示。
14.根据权利要求11的设备，其中不同于显示时间长度的显示时间的特性包括一种即将邻近一项重大活动的指示。
15.用于把音频广告混入到反映体育活动的音频通道上的设
备，该设备包括：
一个音频广告存储器，用作存储一条音频广告；以及
一个音频混合器，用作把该音频广告混合到反映该体育活动的一个音频通道上。
16.根据权利要求15的设备，还包括：
一个场地抓获器，用作抓获和数字化至少一个表示正进行体育活动的体育实施的至少一部分的场地；以及
一个视觉线索检测器，用作在至少一个场地里检测一个视觉线索并且根据该视觉线索控制该音频混合器的运行。
17.根据权利要求16的设备，其中该视觉线索包括对应于该音频广告的一个广告图象。
18.用于检测广告地点的设备，包括：
一个存储要被替换广告的图象的广告图象存储器；
一个场地抓获器，用于抓获和数字化至少一个表示一个体育实施的至少一部分的场地；以及
一个场地—存储匹配器，用作把一个场地的至少一部分与被替换广告的存储图象的至少一部分进行匹配，从而在该场地里识别被替换广告的至少一部分的图象。
19.根据权利要求18的设备，还包括一个广告地点检测器，用作在至少一个场地里识别至少一个广告地点的至少一条边缘。
20.一种广播方法，包括：
利用多个电视摄象机拍摄一项活动；以及
广播由多个所述电视摄象机产生的图象。
21.根据权利要求20的方法，其中广播的步骤还包括对各帧压缩除了一个摄象机之外的所有其他摄象机产生的图象并且把该压缩图象混合到由该单个剩余摄象机产生的代表该图象的信号上的步骤。
22.根据权利要求20的方法，还包括在一个远程位置接收该广播并且从中获得与在该活动中显示的至少一个广告有关的信息。
23.一种用于检测广告地点的方法，包括：
抓获和数字化至少一个表示一个体育设施的至少一部分的场地；以及
在不同于与该体育设施有关的广告地点的位置的基础上检测至少一个场地上的至少一个广告地点。
24.一种插入广告的方法，包括：
抓获和数字化至少一个表示一个体育设施的至少一部分的场地；以及
把一个广告的一部分插入到该体育设施内一个部分堵塞广告地点处的至少一个场地上，其中被插入广告的部分对应于该广告地点
未堵塞的部分。
25.一种检测广告地点的方法，包括
抓获和数字化至少一个表示一个体育设施的至少一部分的场地；
在至少一个场地里检测至少一个广告地点；以及
在不必跟踪一个全部场地的状态下跟踪由该广告地点检测器检测出的至少一个广告地点。
26.根据权利要求22的方法，其中有关该广告的信息包括有关该广告堵塞的信息。
27.一种检测广告图象的方法，包括：
抓获和数字化至少一个表示一个体育设施的至少一部分的场地；
在至少一个场地里检测至少一个广告图象；以及
统计各个广告图象的显示时间长度。
28.一种把音频广告插入到反映体育活动的音频通道上的方法，该方法包括：
存储一条音频广告；以及
把音频广告混入到反映该体育活动的一个音频通道上。
29.一种检测广告地点的方法，包括：
存储要被替换广告的一个图象；
抓获和数字化至少一个表示一个体育实施的至少一部分的场地；以及
把一个场地的至少一部分与被替换广告的存储图象进行匹配，从而在该场地内识别被替换广告的一个图象。
30.根据权利要求1的设备，其中广告地点检测器用作不基于该体育设施有关的广告地点的位置，检测至少一个场地上的至少一个部分堵塞的广告地点。
31.根据权利要求4的设备，其中广告地点跟踪器用作在不必跟踪一个全部场地的状态下跟踪由该广告地点检测器检测出的至少一个部分堵塞的广告地点。
32.根据权利要求18的设备，其中该广告在场地中被部分地堵塞并且其中场地—存储匹配器用作把一个场地的仅一个部分匹配到被替换广告的存储图象的仅一个部分上，从而识别该场地内被替换广告的仅一个部分的一个图象。
33.用于监视一个包括至少一个产生广播图象的电视摄象机的电视摄象机阵列的电视摄象机阵列监视系统，该系统包括：
对于每个电视摄象机，一个摄象机FOV中心方向测量单元；
对于每个电视摄象机，一个透镜变焦状态监视单元；以及一个视频混合器，该视频混合器用作把FOV方向测量单元及透镜变焦状
态监视单元的输出混合到被广播的信号上。
34.根据权利要求33的系统，其中该摄象机阵列包括多个电视摄象机并且还包括一个正在广播的摄象机识别单元，该单元用作从这些多个电视摄象机中识别出当前正在广播的那个电视摄象机。
35.根据权利要求33或34的系统，其中还包括一个远程广告检测器，用作接收广播信号并且从该信号上提取视频混合器的输出。
Applications Claiming Priority (4)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| IL104725 | 1993-02-14 | ||
| IL10472593A IL104725A (en) | 1993-02-14 | 1993-02-14 | System for exchanging sections of video background with virutal images |
| IL107266A IL107266A0 (en) | 1993-10-12 | 1993-10-12 | Application and method for detecting, identifying and incorporating advertisements in a video image |
| IL107266 | 1993-10-12 |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN1119481A true CN1119481A (zh) | 1996-03-27 |
Family
ID=26322578
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN94191471.2A Pending CN1119481A (zh) | 1993-02-14 | 1994-02-14 | 在电视中检测，识别和插入广告的设备和方法 |
Country Status (7)
| Country | Link |
|---|---|
| EP (1) | EP0683961B1 (zh) |
| CN (1) | CN1119481A (zh) |
| AT (1) | ATE192622T1 (zh) |
| AU (1) | AU6298794A (zh) |
| BR (1) | BR9406756A (zh) |
| DE (1) | DE69424276D1 (zh) |
| WO (1) | WO1995010919A1 (zh) |
Cited By (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104735466A (zh) * | 2015-03-31 | 2015-06-24 | 北京奇艺世纪科技有限公司 | 一种更换视频中商标图案的方法及装置 |
| CN106686405A (zh) * | 2016-12-28 | 2017-05-17 | 深圳市奥拓电子股份有限公司 | 一种视频转播方法及系统 |
| CN106792007A (zh) * | 2017-01-19 | 2017-05-31 | 深圳市奥拓电子股份有限公司 | 一种视频转播方法及系统 |
| WO2018133011A1 (zh) * | 2017-01-19 | 2018-07-26 | 深圳市奥拓电子股份有限公司 | 一种视频转播方法及系统 |
| CN108521597A (zh) * | 2018-03-21 | 2018-09-11 | 浙江口碑网络技术有限公司 | 直播信息动态展示方法及装置 |
| CN111988661A (zh) * | 2019-05-24 | 2020-11-24 | 米利雅得广告公开股份有限公司 | 将视觉对象合并到视频材料中 |
| CN113170229A (zh) * | 2018-11-19 | 2021-07-23 | 三星电子株式会社 | 显示装置、服务器、电子装置及其控制方法 |
| CN113507575A (zh) * | 2021-09-08 | 2021-10-15 | 上海英立视电子有限公司 | 一种人体自拍镜头生成方法及系统 |
Families Citing this family (36)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| IL110573A (en) * | 1994-08-04 | 1998-10-30 | Orad Hi Tec Systems Ltd | Video transmission device and method |
| WO1997000581A1 (en) * | 1995-06-16 | 1997-01-03 | Princeton Video Image, Inc. | System and method for inserting static and dynamic images into a live video broadcast |
| ES2134625T3 (es) * | 1995-06-16 | 1999-10-01 | Princeton Video Image Inc | Sistema y metodo para introducir inserciones, en tiempo real, en video, utilizando oclusion adaptativa con una imagen de referencia sintetica. |
| US5912700A (en) * | 1996-01-10 | 1999-06-15 | Fox Sports Productions, Inc. | System for enhancing the television presentation of an object at a sporting event |
| GB9514313D0 (en) * | 1995-07-13 | 1995-09-13 | Beattie Robert J | Live-ads |
| GB2305049B (en) * | 1995-09-08 | 2000-06-07 | Orad Hi Tec Systems Ltd | Electronic billboard replacement switching system |
| WO1997041683A1 (en) * | 1996-04-29 | 1997-11-06 | Princeton Video Image, Inc. | Audio enhanced electronic insertion of indicia into video |
| US5917553A (en) | 1996-10-22 | 1999-06-29 | Fox Sports Productions Inc. | Method and apparatus for enhancing the broadcast of a live event |
| JP3480648B2 (ja) * | 1996-11-12 | 2003-12-22 | ソニー株式会社 | ビデオ信号処理装置及びビデオ信号処理方法 |
| JPH10145674A (ja) * | 1996-11-12 | 1998-05-29 | Sony Corp | ビデオ信号処理装置及びビデオ信号処理方法 |
| RU99111072A (ru) * | 1996-11-27 | 2001-03-10 | Принстон Видео Имидж | Слежение движения с использованием эталонов текстуры изображения |
| US5862517A (en) * | 1997-01-17 | 1999-01-19 | Fox Sports Productions, Inc. | System for re-registering a sensor during a live event |
| US6252632B1 (en) | 1997-01-17 | 2001-06-26 | Fox Sports Productions, Inc. | System for enhancing a video presentation |
| US6133946A (en) * | 1998-01-06 | 2000-10-17 | Sportvision, Inc. | System for determining the position of an object |
| US6266100B1 (en) | 1998-09-04 | 2001-07-24 | Sportvision, Inc. | System for enhancing a video presentation of a live event |
| US6229550B1 (en) | 1998-09-04 | 2001-05-08 | Sportvision, Inc. | Blending a graphic |
| GB9907943D0 (en) | 1999-04-07 | 1999-06-02 | Pandora Int Ltd | Digital manipulation of video images |
| US6466275B1 (en) | 1999-04-16 | 2002-10-15 | Sportvision, Inc. | Enhancing a video of an event at a remote location using data acquired at the event |
| ES2264414T3 (es) * | 1999-07-19 | 2007-01-01 | Leo Vision | Camaras multiples, sistemas y metodos de insercion virtual e interactivo y alimentacion multiple. |
| US7075556B1 (en) | 1999-10-21 | 2006-07-11 | Sportvision, Inc. | Telestrator system |
| US7230653B1 (en) | 1999-11-08 | 2007-06-12 | Vistas Unlimited | Method and apparatus for real time insertion of images into video |
| US6909438B1 (en) | 2000-02-04 | 2005-06-21 | Sportvision, Inc. | Video compositor |
| US7206434B2 (en) | 2001-07-10 | 2007-04-17 | Vistas Unlimited, Inc. | Method and system for measurement of the duration an area is included in an image stream |
| US7444656B2 (en) | 2001-08-02 | 2008-10-28 | Intellocity Usa, Inc. | Post production visual enhancement rendering |
| DE60239067D1 (de) | 2001-08-02 | 2011-03-10 | Intellocity Usa Inc | Nachbereitung von anzeige änderungen |
| WO2008109608A1 (en) * | 2007-03-05 | 2008-09-12 | Sportvision, Inc. | Automatic measurement of advertising effectiveness |
| US8786415B2 (en) | 2010-02-24 | 2014-07-22 | Sportvision, Inc. | Tracking system using proximity and/or presence |
| US10210160B2 (en) | 2010-09-07 | 2019-02-19 | Opentv, Inc. | Collecting data from different sources |
| US9699503B2 (en) | 2010-09-07 | 2017-07-04 | Opentv, Inc. | Smart playlist |
| US8949871B2 (en) | 2010-09-08 | 2015-02-03 | Opentv, Inc. | Smart media selection based on viewer user presence |
| PT3340610T (pt) | 2010-09-20 | 2023-02-22 | Fraunhofer Ges Forschung | Processo para a distinção de segundo plano e primeiro plano de um cenário, bem como processo para a substituição de um segundo plano em imagens de um cenário |
| US9215383B2 (en) | 2011-08-05 | 2015-12-15 | Sportsvision, Inc. | System for enhancing video from a mobile camera |
| DE102016119639A1 (de) | 2016-10-14 | 2018-04-19 | Uniqfeed Ag | System zur dynamischen Kontrastmaximierung zwischen Vordergrund und Hintergrund in Bildern oder/und Bildsequenzen |
| DE102016119640A1 (de) | 2016-10-14 | 2018-04-19 | Uniqfeed Ag | System zur Erzeugung angereicherter Bilder |
| DE102016119637A1 (de) * | 2016-10-14 | 2018-04-19 | Uniqfeed Ag | Fernsehübertragungssystem zur Erzeugung angereicherter Bilder |
| CN111741327B (zh) * | 2019-03-25 | 2022-09-02 | 华为技术有限公司 | 一种媒体处理方法及媒体服务器 |
Family Cites Families (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| DE3310949A1 (de) * | 1983-03-23 | 1984-09-27 | MIT Datenspeicher GmbH, 1000 Berlin | Verfahren zur erkennung und zur modifizierung von objekten in einer beweglichen bildfolge einer bildszene |
| US4555726A (en) * | 1984-03-05 | 1985-11-26 | The United States Of America As Represented By The Secretary Of The Navy | Video target track valid indicator |
| FR2566934B1 (fr) * | 1984-06-29 | 1987-05-07 | Giraud Daniel | Procede d'affichage d'informations telles que par exemple des messages publicitaires sur un certain nombre de panneaux a elements d'affichage disposes dans un lieu de manifestations sportives et systeme pour la mise en oeuvre d'un tel procede |
| US4706119A (en) * | 1985-09-11 | 1987-11-10 | Shell Offshore Inc. | Camera vision axis inclination indication apparatus |
| US5021887A (en) * | 1989-12-13 | 1991-06-04 | Samsung Electronics Co., Ltd. | Method and circuit for composing still image of picture-in-picture |
| US5018215A (en) * | 1990-03-23 | 1991-05-21 | Honeywell Inc. | Knowledge and model based adaptive signal processor |
| WO1992010908A2 (en) * | 1990-12-14 | 1992-06-25 | Battelle Memorial Institute | High-speed video instrumentation system |
-
1994
- 1994-02-14 CN CN94191471.2A patent/CN1119481A/zh active Pending
- 1994-02-14 WO PCT/US1994/001679 patent/WO1995010919A1/en active IP Right Grant
- 1994-02-14 EP EP94910696A patent/EP0683961B1/en not_active Expired - Lifetime
- 1994-02-14 BR BR9406756A patent/BR9406756A/pt not_active Application Discontinuation
- 1994-02-14 AT AT94910696T patent/ATE192622T1/de not_active IP Right Cessation
- 1994-02-14 AU AU62987/94A patent/AU6298794A/en not_active Abandoned
- 1994-02-14 DE DE69424276T patent/DE69424276D1/de not_active Expired - Lifetime
Cited By (11)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104735466A (zh) * | 2015-03-31 | 2015-06-24 | 北京奇艺世纪科技有限公司 | 一种更换视频中商标图案的方法及装置 |
| CN106686405A (zh) * | 2016-12-28 | 2017-05-17 | 深圳市奥拓电子股份有限公司 | 一种视频转播方法及系统 |
| CN106686405B (zh) * | 2016-12-28 | 2019-12-10 | 深圳市奥拓电子股份有限公司 | 一种视频转播方法及系统 |
| CN106792007A (zh) * | 2017-01-19 | 2017-05-31 | 深圳市奥拓电子股份有限公司 | 一种视频转播方法及系统 |
| WO2018133011A1 (zh) * | 2017-01-19 | 2018-07-26 | 深圳市奥拓电子股份有限公司 | 一种视频转播方法及系统 |
| CN108521597A (zh) * | 2018-03-21 | 2018-09-11 | 浙江口碑网络技术有限公司 | 直播信息动态展示方法及装置 |
| CN113170229A (zh) * | 2018-11-19 | 2021-07-23 | 三星电子株式会社 | 显示装置、服务器、电子装置及其控制方法 |
| CN113170229B (zh) * | 2018-11-19 | 2023-09-19 | 三星电子株式会社 | 显示装置、服务器、电子装置及其控制方法 |
| CN111988661A (zh) * | 2019-05-24 | 2020-11-24 | 米利雅得广告公开股份有限公司 | 将视觉对象合并到视频材料中 |
| CN113507575A (zh) * | 2021-09-08 | 2021-10-15 | 上海英立视电子有限公司 | 一种人体自拍镜头生成方法及系统 |
| CN113507575B (zh) * | 2021-09-08 | 2021-11-26 | 上海英立视电子有限公司 | 一种人体自拍镜头生成方法及系统 |
Also Published As
| Publication number | Publication date |
|---|---|
| ATE192622T1 (de) | 2000-05-15 |
| EP0683961B1 (en) | 2000-05-03 |
| EP0683961A4 (zh) | 1996-01-10 |
| AU6298794A (en) | 1995-05-04 |
| EP0683961A1 (en) | 1995-11-29 |
| WO1995010919A1 (en) | 1995-04-20 |
| DE69424276D1 (de) | 2000-06-08 |
| BR9406756A (pt) | 1996-04-02 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN1119481A (zh) | 在电视中检测，识别和插入广告的设备和方法 | |
| CN1251149C (zh) | 通信装置和方法 | |
| CN1313974C (zh) | 图像处理设备和方法,以及图像捕获设备 | |
| CN1134975C (zh) | 图像处理装置 | |
| CN1259216A (zh) | 评诂两个信号序列之间差异的可视性的方法与装置 | |
| CN1192327C (zh) | 识别定位相对运动区域以及位移方向和速度的方法和装置 | |
| CN1253652A (zh) | 活动图像显示方法及其装置 | |
| CN1112039C (zh) | 配置主图像以使副图像重合在主图像上的多媒体光盘再生装置及方法 | |
| CN100348052C (zh) | 在多个比特流中分散表示信号单元的比特以增强错误恢复的信源编码信号单元 | |
| CN1167006C (zh) | 图象处理装置和方法 | |
| CN1132123C (zh) | 计算深度信息的方法和使用深度信息进行图象处理的方法 | |
| CN1143535C (zh) | 能有选择地使用传输流包含的多种浏览信息的广播接收装置 | |
| CN1149952A (zh) | 解码视频图像的装置和方法 | |
| CN1969297A (zh) | 图像处理设备和方法及图像拍摄设备 | |
| CN1248163C (zh) | 图像处理设备和方法 | |
| CN101237553B (zh) | 确定插值方法的程序、装置及方法 | |
| CN1947152A (zh) | 图像处理方法和设备、记录介质、及程序 | |
| US20110145883A1 (en) | Television receiver and method | |
| CN1845178A (zh) | 使用各向异性纹理映射的图像绘制方法和图像绘制设备 | |
| CN1856098A (zh) | 移动目标检测设备、方法和程序 | |
| CN1322445A (zh) | 发送、接收及发送和接收的设备及方法、记录介质和信号 | |
| CN1111464A (zh) | 图像处理装置及其方法和带图像处理装置的电子装置 | |
| CN1678076A (zh) | 图像处理装置及其方法 | |
| CN1287743A (zh) | 动图象合成装置 | |
| CN1465196A (zh) | 图像处理设备和方法、以及图像拍摄设备 |
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 |