CN1150749A

CN1150749A - 根据稳态荧光寿命检测分析物

Info

Publication number: CN1150749A
Application number: CN95193149.0A
Authority: CN
Inventors: 拉尔夫·祖克曼
Original assignee: Individual
Current assignee: Individual
Priority date: 1994-04-21
Filing date: 1995-04-19
Publication date: 1997-05-28
Also published as: EP0758212A4; US5515864A; EP0758212B1; US5626134A; JPH09512446A; ATE296052T1; US5495850A; DE69534228D1; CA2187735C; WO1995028875A1; AU691285B2; AU2424595A; DE69534228T2; CA2187735A1; JP3579424B2; EP0758212A1

Abstract

通过荧光寿命的稳态测定，在体内和体外测定分析物浓度的方法和设备。由分析物淬灭的荧光团可自由进行布朗旋转。用连续的线偏振光(24)照射荧光团(12)。把发射的荧光分解为平行于和垂直于激励光偏振面的矢量分量(36，38)。应用了使荧光各向异性与淬灭剂浓度相关联的数学函数。对于不淬灭激发态的分析物，把已知量的分析物结合到淬灭剂分子或能量转移受主上，在标记的载体分子上，建立了标记的分析物和未标记的分析物竞争位置的竞争反应。应用了使在载体标记的发射带处的荧光各向异性与分析物浓度相关联的经验确定的数学函数。

Description

根据稳态荧光寿命检测分析物

分子态氧(molecular oxygen)是动物的细胞功能所必需的，相反对植物酶例如对固氮酶来说则不需有O₂。动物特别是哺乳动物，在其维持生命过程中绝对地依赖O₂的连续供应与利用。这对于高耗O₂的组织例如神经组织与肌肉，它们是横纹的与平滑的，尤其如此。对这些组织中断供氧，时间短至几分钟就会造成细胞死亡并丧失掉对于器官功能的关键功能。此外，正是组织中的氧浓度而不是血液或其它体液中的氧浓度，最终支持着细胞功能。因此，测量体液和组织中的氧浓度对于临床医学至关重要，在许多血管疾病中，如动脉硬化症、糖尿病、镰形血球病以及一些损害创口治疗的例子等，会发生损害向组织供氧的情况。这样自然会有众多的专利涉及到测量血液与体液中氧浓度的方法与装置，本发明人的美国专利No.5186173(以后称作Zuckerman 173专利)第一次涉及到在体内测量组织的氧浓度。

这些专利，尽管每一个都致力于对体液或组织PO₂进行无损检测，但苦于种种缺陷而妨碍了它们广泛用于临床医学。为了满足无损检测的需要，近来的专利转向于光学方法，这些方法涉及到由分子氧(dioxygen)来淬灭染料的磷光或荧光。例如美国专利No.4476870(Peterson等)等一类专利开发了种种导管设计，将荧光物质例如苝封装于一个可插入血管的密封导管中，而应用光纤方法测量了它的由血液中O₂产生的荧光淬灭。这种装置虽然测量体液或血液PO₂，但存在两种缺陷。首先，只有在试剂导管插到血管内之前于外部校准之后才能精确测量血中的PO₂；其次，这样的技术没有提供任何几何形态方面的信息，这是由于PO₂是在单一位置即在试剂导管顶端测量的结果。在美国专利No.4,810,655中，Khalil等人的目的在于通过测量荧光寿命而不是强度来避免在每次使用前需要对导管事先校准。尽管从理论上说，直接寿命系统应避免作事先校准的需要，但实际上如Khalil等的专利中表4所示，所用卟啉的荧光寿命会因曝光而变化，使得在使用前仍需要校准。此外，时间分辨的直接寿命系统在实施中不方便，且精度也不如稳态方法。Vanderkooi与Wilson(美国专利No.4947850)开发了以测定O₂敏感试剂物质的荧光寿命为基础的方法，这类物质例如有牢固地结合到清蛋白上的金属卟啉，它发生荧光现象的时标为十分之几毫秒(10^-3sec)，且其荧光寿命可被分子氧缩短(淬灭)。这里的O₂敏感的试剂是一种发荧光的分子，可以注入到血流中，由此可以测定成像的组织血管内血液中PO₂的几何形态。但由于金属卟啉以及Vanderkooi所述的其它试剂的自淬灭，这些试剂分子不能独立使用。这就是说，自淬灭使得试剂浓度在衰变时间中的相关变化大于由分子氧引起的变化。由于在注射位置的漏泄和不同的动物或人的血液量的不同，不可能知道血液中精确的试剂浓度，他们就必须改进试剂来消除自淬灭。正如美国专利No.4,947,850(3列15行)所述：“优选的是采用卟啉类，而所述组分子最好同与荧光组分结合的蛋白质组分混合，清蛋白……组份是优选的”。正如Vanderkooi，J.等在其论文“根据荧光淬灭来测量分子氧浓度的光学方法(An Optical Method for Measurement of DioxygenConcentration Based Upon Quenching of Phosphorescence)”J.Biol.Chem.，262(12)：5476-5482中所述，没有清蛋白或其它分子量大的蛋白质结合到试剂分子上时，这种方法是不能投入工作的。当通过静脉注射到血液中时，分子量大的蛋白质(M.W.＝67000)将阻碍试剂分子通过关节处或血管壁上的类脂薄膜，因而限制了血液中氧浓度的测量。类似地，美国专利No.4,579,430(Bille)公开了一种发明，可以测定视网膜血管内氧的饱和度，O₂结合到血红蛋白中的百分率。正如以前一些专利所揭示的，在许许多多的疾病中，尽管确信组织成为缺氧的，但血液中的氧饱和度和氧浓度保持正常。上述疾病包括糖尿病、早熟的视网膜病、以及高血压病与动脉硬化症。类似地，在长时间的外科手术例如改道手术、颈动脉手术中以及在长期的精心照护下时，血液中的氧浓度和/或饱和度是受到仔细监控和保持的，但已知由于缺氧而发生过从中等到严重程度的脑损伤。正是组织中的氧浓度关系到它的功能与健康，除了血氧浓度或饱和度以外，组织的氧浓度还取决于组织的耗氧率、血液流速与血管的管径。为此，特别重要的是能在空间中和在时间上测量组织中的PO₂。

Zuckerman 173专利中描述了组织中PO₂的无损伤性几何形态测量。在这份专利中，是把高度脂溶性的试剂物质例如钠的芘丁酯盐经静脉或腹腔注入，或在适当时局部应用。这种脂溶性的生物相容性的试剂物质离开血液而聚集于组织细胞的双层脂膜中。在此，一旦芘丁酸盐聚集于组织细胞的双层脂膜内后，这种试剂实质上就是组织本身。这一事实以及专利中详细描述到的数字图像系统得以首次对组织氧浓度作出几何形态测定，有助于保证组织的健康与功能。Zucherman 173专利中根据Stern-Volmer方程，通过测量荧光强度来测量以荧光强度表示的O₂浓度。Zucherman 173专利的发明虽然能首次在空间与时间上对组织PO₂进行了无损检测，但存在着两方面的缺陷而不能用于临床，当前限用于实验室的动物研究。最显著的限制是由于这样的事实：荧光强度取决于芘丁酸盐在组织内空间中的浓度，而这一浓度则由于组织内细胞脂质组份的空间差而不同，同时荧光强度还取决于组织氧浓度的空间分布。为了解决上述问题和在多个位置上抽取氧浓度，各位置上的荧光强度与同一位置在组织中PO₂为0mmHg(不存在氧)时的荧光强度成比例。这可以在实验结束时使动物在100％N₂中呼吸来实现。这样的试验程序不能在临床上用于人体，因为这无疑将导致细胞死亡，显然会使大脑受伤或死亡。Zucherman 173专利发明的第二种缺陷是血液在芘丁酸盐发射波长处对荧光强度的滤光效应。这可以在实验室环境中通过独立地测量成像的组织血管中血液的光密度作出相似的校正。

Zuckerman 173专利中装置与方法两方面的缺陷可以通过直接测量荧光寿命(衰减)来取代测量强度而避免。在给定的PO₂下和给定的组织中来测量荧光寿命时，一旦用实验室校准的仪器测量过后，就不需在临床时使组织中的PO₂为0mmHg，这是因为荧光衰变常数与芘丁酸盐的浓度无关，且类似地不受血管中血液吸收的影响。但是，荧光寿命是在毫微秒(10^-9)的时标上发生，除了直接需要笨重而昂贵的设备来在多个位置上测量如此短的荧光寿命外，还要求在紫外激励波长下对组织作强脉冲的激光激励(脉冲宽度＜20毫微秒)，以取得有效的信噪比。由于芘丁酸盐和其它荧光试剂分子的量子效率一般＜0.5，不能转换为荧光发射的辐射的光子吸收将转化为热，使组织受伤。在强激光脉冲下使受伤的组织用于时间分辨的直接测定荧光寿命中时，在强激光脉冲后产生的组织损伤，是这种方法在体内使用的主要缺点。

在此需要一种通过间接测量荧光寿命的稳态的，而不是由时间分辨的过程进行体内的氧浓度分布的测量的方法。

鉴于现有技术的缺陷，希望能有这样的方法，它能以多种形式使用，并允许通过间接测定荧光寿命以在空间与时间上来测定体液、血液与组织中的PO₂。这种方法允许构制O₂敏感的导管，它可以插入血管中而不需在每次使用前进行烦琐的外部校准。类似地，通过静脉注入生物相容性的脂溶性荧光染料同时应用数字图像处理技术，这种方法就可测定组织PO₂的分布以及成像的组织血管中的血液PO₂。通过外延，应用光学系列分区的整套方法，就能在成像的组织体积内用层析X射线照相法首次测定出组织与血液PO₂在三维空间中的分布。最重要的是这样一种方法有可能出色地用于人体血管、代谢和其它疾病的诊断与医治。此外，整套的用于间接地稳态测定荧光寿命的方法完全有可能同样用来在时间与空间上测定分子氧以外的，对生物和对身体有重要意义的许多其它物质的浓度。

因此，本发明的一般目的在于提供这样的方法与设备，通过荧光寿命的稳态测定，在体内与体外测定对生物与身体都重要的许多物质的空间浓度与分布。

本发明的另一个目的在于提供用来在体内对组织与体液的氧浓度或成像的组织内的PO₂的分布进行测定的方法与设备，同时提供用光纤导管来测量血液或体液中PO₂的方法与设备。

本发明的又一个目的在于提供利用荧光寿命为分子态氧淬灭的荧光试剂物质，在体内测定组织与体液氧浓度的方法与设备，同时通过测量荧光试剂物质的各向异性来测定氧浓度或PO₂。

本发明的再一个目的在于提供能精确的，无损伤性地在体内测定组织与体液氧浓度并具有可重复性结果的方法与设备。

本发明上述的和其它的目的是通过提供借助对荧光寿命的稳态测定，在体内和体外来测定对生物与身体都重要的许多物质的浓度与分布的方法和设备来实现的。一般情形下，其激发态被涉及的物质所淬灭的荧光团单独地或者在结合到适当粘度的介质中的载体分子上时可以自由地进行布朗运动；所分析的物质是在被光强烈吸收的波长下连续线偏振光照射。发射出的荧光分解成它的平行于和垂直于激励光偏振面的矢量分量，这样便可以计算被照射试样的荧光各向异性(anisotropy)。应用使荧光团的荧光各向异性与淬灭剂浓度相关联的数字函数，确定此淬灭剂的浓度。为了测定本身不淬灭激发态的物质的浓度，使一定量的测量物质与淬灭剂分子或能量转换受主分子结合，同时构成一种竞争性反应，其中试样内的荧光标记物质同无标记物质在标记的载体分子上竞争位置。非标记物质的浓度增加到取代载体分子上的标记物质的程度，载体荧光团的发光寿命增加。荧光各向异性是在载体分子上荧光标记的发射光谱带上测量，而测量的物质的浓度是通过应用一使荧光各向异性与被测物质浓度相关联的经验数字函数测定的。

在淬灭剂分子氧的具体情形下，通过提供在体内对组织和体液的氧浓度或成像的组织内的PO₂的分布测定的方法和设备，以及提供用光纤导管来测量血液或体液PO₂的方法来达到本发明的目的。在第一种方法中，是把脂溶性的、具有生物相容性的荧光试剂物质投到动物体内并聚集于它的组织细胞的双层类脂膜内。在第二种方法中，荧光试剂物质与分子量大的蛋白质结合而使其保留于例如血一类的体液内。在第三种方法中描述了一种导管设计，其中在导管的端部测量PO₂，此端部含有溶解于粘滞的非极性溶剂中的荧光试剂物质。在描述到的所有方法中，优选的荧光试剂物质其荧光寿命是由分子态氧淬灭，而氧浓度或PO₂是通过测量荧光试剂物质的荧光各向异性来测定的。含有生物相容性的荧光试剂物质的体液或组织或是在导管端部内非极性溶剂中的荧光试剂物质，在波长为此荧光体强吸收的连续线偏振紫外光下照射。发射出的荧光分解成平行于和垂直于激励光偏振面的矢量分量，由此可以计算被照试样的荧光各向异性。成像试样中组织和/或体液的PO₂。或是密封的端部中流体的PO₂，是应用使可被O₂淬灭的荧光团的荧光各向异性与氧浓度或分压相关联的数字函数来确定的。

结合附图参看下面的详细描述，可以更好地理解本发明的其它目的与许多相应的特点，其中：

图1是作为含此荧光团的溶液的氧分压(PO₂)的函数的溶解于非极性溶剂中O₂可淬灭的荧光团的荧光各向异性的理论曲线图。对于发生于活体组织细胞脂质中的众所周知的布朗旋转运动范围，据方程6导出了一族曲线。在各种旋转运动速率下，荧光各向异性随PO₂的增加而单调增加。

图2示意地说明了一种成像设备，它用于测定已成像试样中组织与体液中的PO₂的几何分布。

图3是本发明的用于测定与密封的光纤导管端部接触的流体中的氧浓度或PO₂的设备。

图4示意地表明(微处理机设计的)数据处理机，可用来进行测定导管端部的PO₂所需的计算。MUX指乘法器；T指温度，而G是用来校正分光镜在线偏振光的平行平面和垂直平面中传输效率的经验常数。I₁与I₂是荧光发射的分别平行和垂直于激励光偏振面的分解强度。

图5是曲线图，表示在平行于(上图)和垂直于(下图)一弧立和充满的牛眼视网膜内视网膜小动脉上测量的PO₂水平。平行于此小动脉的PO₂的纵向下降值由指出的理论函数拟合(实线)，而垂直于此小动脉的测量出的PO₂则是由Krogh的数字模型拟合(实线)。R²是测定系数。

后附的清单A是采用“视频图像采集、处理与分析用软件”(1993年出版，Biometric Imaging公司)的源编码。

本发明致力于解决现有技术中存在的几个问题。本发明根据这样一个普通承认的物理原理：荧光团对光子的吸收与发射是通过在荧光体分子骨架内具有清晰定向的电偶极子跃迁矩而发生的。在含有随机取向荧光体的非极性溶剂或双层脂膜中，只有适当取向的分子才能被线偏振光激励，这样就形成了受激的与发荧光的分子的不平衡取向。这种各向异性及其转动张弛反映在发射光的偏振上。由线偏振光脉冲感应的时间分辨的荧光各向异性的情形可由下述方程描述：

A(t)＝A₀e^{-6
Rt} (1)

式中的A为荧光各向异性，t是脉冲激励后的观察时间，R是平均分子转动时间，以弧度/秒表示，而A₀是不存在布朗转动时于“冻结”态中的荧光各向异性。但当荧光各向异性是在稳态和连续激励下测量时，A便是时间分辨的衰变的平均值与由强度衰变加权的时间的比值：

A (τ) = \frac{{&Integral;}_{0}^{\infty} e^{- t / τ} A (t) dt}{{&Integral;}_{0}^{\infty} e^{- t / τ} dt} = \frac{1}{τ} {&Integral;}_{0}^{\infty} e^{- t / τ} A (t) dt - - - - (2)

式中τ是荧光体的荧光寿命。

进行变换，得到Perrin方程：

上式对于理想球形分子成为

\frac{A_{0}}{A} = \frac{1 + R_{g} T}{ηV} τ - - - - (4)

式中Rg是气体常数，T是温度，η是粘度，而V是荧光体的流体动态体积。

本发明是第一次考虑到聚集于非极性溶剂或双层脂膜中的O₂淬灭的荧光团例如钠的芘丁酸盐的情形，这种情形例如可在身体中所有组织细胞中见到。这种荧光团的荧光寿命可以通过下述形式的Stern-Volmer关系分别与氧浓度或氧分压关联：

式中α是本生溶解度系数，K_D是动态淬灭常数，而τ₀是不存在O₂时的荧光寿命。结合方程(3)与(5)得出一数学关系式，使氧分压与稳态荧光各向异性相关联：

P O_{2} = \frac{A_{0} - A (6 \overset{&OverBar;}{R} τ_{0} + 1)}{α K_{D} (A - A_{0})} - - - - (6)

因此上述方程(6)是本发明的中心的和新颖的思想，它表明这种稳态荧光各向异性测量手段可以用作一种精密的测量方法，这种方法能由简单的结构实施，进行(i)在可由O₂淬灭的荧光团聚集于组织细胞内的双层脂膜内后，在空间与时间上测定此组织的PO₂；(ii)在荧光团聚集于红血球的双层脂膜内后或对于与注入血流内的蛋白质结合的荧光团，测量血PO₂的几何形态分布；(iii)测定一可插入式导管端部的PO₂，此端部含有在非极性溶剂或脂类例如矿物油或石蜡油中的荧光团例如芘，由可透O₂的膜与试样分开。

方程(6)表示的在已知发生于组织细胞中的布朗旋转运动范围内的数字关系给明于图1中。如图1所示，稳态荧光各向异性在各种旋转速率下随PO₂的增加而按有序的方式增加。换言之，随着PO₂的增加，荧光团的荧光寿命缩短〔方程(5)〕，从而在荧光体的寿命期内减少了荧光体所扫掠过的角度。于是，荧光各向异性便随PO₂的增加而增加。在这种情形下影响荧光各向异性的其它变量除PO₂外还有双层脂膜的温度与粘度。但在成像的体内组织和/或血管的情形，众所周知身体本身能极好地控制这些变量。类似地，带有小体积的O₂敏感端部的导管将很快地与它插入到的血管内的血液温度达到平衡。此外，如方程(4)所示，在某些疾病状态下所遇到的身体或导管端部温度的稍许变化，可以由伴随进行的温度测量，和应用根据稳态的荧光各向异性的测量结果的上述方程计算PO₂进行精确补偿。

本发明具有直接式的荧光寿命系统的一切优点，而不需用强脉冲的激光激励也不会有由此对成像的试样带来的潜在的损伤。此外，避免了需用笨重和昂贵的设备来测量在40-135毫微秒范围内的荧光衰变。类似地，由于稳态连续荧光各向异性的测定乃是庞大数量的荧光衰变事件的时间平均，此种稳态测量结果必然比任何时间分辨方法精确。本发明是通过稳态各向异性的测量来测定PO₂，而美国专利No.4,476,870(Peterson)以及Zuckerman 173专利则是以荧光强度为所测变量。此外，本发明也不同于美国专利No.4,810,655(Khalil等)与美国专利No.4,947,850(Vanderkooi)所公开的发明，不同之处是这两种专利是通过直接测量磷光物质的寿命来测定PO₂的。发磷光的物质比起本发明优选的荧光物质有长得多的因而较易测量的寿命。在本发明中，通过荧光各向异性对荧光寿命作间接测量是在便于实施的构型下使用，由此来提供体内的组织与体液中PO₂的测定而不存在现有技术中的那些限制。

上面对于氧浓度或分压的测定虽然是就特殊情形提供了一套方法，但淬灭剂分子氧的浓度与荧光各向异性关系的数字推导式可以改写而用于激发态可以淬灭的任何荧光团的一般情形，由此测定淬灭剂的浓度。考虑更一般的情形，根据Stern-Volmer关系，方程(5)可以改写如下而用于荧光为某种物质淬灭的任何荧光团：

τ = \frac{τ_{0}}{1 + K_{D} [Q]} - - - - (7)

式中〔Q〕是给定荧光团的淬灭剂的浓度。类似地，可将荧光各向异性相对于淬灭剂浓度的关系的方程6改写成下式：

[Q] = \frac{A_{0} - A (6 \overset{&OverBar;}{R} τ_{0} + 1)}{K_{D} (A - A_{0})} - - - - (8)

结果是，本发明虽然是在淬灭剂分子氧的特殊情形下给出，但应视作用来测定激发态的任何淬灭剂浓度的普遍方法。在实际测定工作中，上述方法的分辨力对于给定的荧光团与淬灭剂可以优化，即把媒质的粘度因而是荧光团的旋转速度调节到荧光团能达到不存在淬灭剂时的荧光寿命。这对于脂溶性的荧光团可以通过选择适当粘度的类脂物来实现，而对于非脂溶性的荧光团来说，则可以使此荧光团在一种媒质中与具有足够的流体动态体积的载体分子结合来实现，上述媒质的粘度可以通过调节甘油-水混合物中的甘油浓度或是蔗糖-水媒质中的蔗糖浓度来处理。虽然不准备列出所有适应本发明的荧光团和淬灭剂类的清单，但可以考虑对其荧光寿命为质子淬灭的荧光团的荧光素或是荧光素衍生物进行pH的稳态测量。类似地，选取采用荧光团奎宁的相同的稳态方法，可以测定氯化物的浓度，或利用荧光团γ-芘丁酸盐可以测定碘化物的浓度。这样，内行的人显然可知，这里所给的普遍性方法可以通过选择适当的荧光团-淬灭剂的组合形式，处理粘度，据此在所需淬灭剂的浓度范围将荧光团的旋转速度调节到所遇到的荧光寿命范围，而用来测定多种离子和其它淬灭剂的浓度。

本发明除用来测定激发态的淬灭剂的浓度外，它的方法还可推广到测定试样中任何感兴趣的物质的浓度。在本发明的这一实施方案中，是使荧光团与对于涉及的物质具有高亲和性的较大的载体分子结合。类似地，使待测量的一定量的物质与载体荧光团的激发态的淬灭剂结合。这种有荧光标记的物质与含有一定数量待测定的无标记物质在一起，加到分析混合物中，在载体分子上形成对位置的竞争。这种竞争将使有淬灭剂标记的分子移出载体分子，由此延长载体荧光团的荧光寿命。载体荧光团寿命的延长随即便减小了在此载体荧光团发射波长下所测量的试样荧光各向异性。于是，在本发明的这一实施方案中，荧光各向异性将随浓度待测的物质的样品浓度的增加而减小。换言之，随着所分析物质的浓度增加，载体上淬灭剂的数量减少，于是便延长了载体荧光团〔方程(7)〕的荧光寿命，从而加大了载体荧光团在其寿命期中扫掠过的角度。于是，荧光各向异性随所测物质浓度的增加而减少。

对于用在本方法中的两种荧光团所作的一种有趣的选择将代表可进行Forster能量转移的施主分子与受主分子。Forster能量转移的基本形式涉及到以施主吸收区内波长的波来激励施主分子。少量的激励会以分子振动能(跃迁到电子激发的分子的最低振动态)的形式释放到周围环境中，其余的可以通过荧光发射或通过把能量转移给受主分子而释放。这种能量转移的效率取决于施主的量子产量、施主的发射光谱与受主的吸收光谱之间的重叠程度、以及施主与受主间的取向与距离。取决于上述条件所满足的程度，受主分子与施主分子在空间中的趋近将缩短施主荧光团的荧光寿命。当根据上述方法来应用施主-受主对时，在施主发射波长上测得的荧光团各向异性将随试样中所测物质浓度的增加而减少。应用Forster能量转移施主-受主对的显著优点是能把施主的吸收带移至较长的波长，由此便可以采用价廉的光源例如发光二极管(LED)与激光二极管。

下面用两个非限制性实施例说明采用能量转移的施主-受主对的实施方案。首先考虑一种设计用来探测激素(蛋白质)量的检测系统。反抗此蛋白质而增加的多克隆(polyclonal)抗体用FITC(荧光素异硫氰酸盐)标记，用作施主，一定量的蛋白质则以孔雀石绿异硫氰酸盐标记而用作适当的受主。这些标记了的分子与试样中无标记的蛋白质一起，混于提供适当粘度的甘油-水缓冲剂中。用FITC吸收波长的线偏振光照射此混合物，然后在FITC发射波长(施主发射)下测定试样的荧光各向异性。随着上述未标记的蛋白质(激素)在试样中的数量增加，它便胜过以受主荧光团标记的蛋白质，从而增加施主荧光寿命。于是，FITC发射频带(施主波长)处的荧光各向异性便作为试样中未标记的蛋白质浓度的函数随后者的增加而有序地减少。作为第二个实施例，考虑一种设计用来测量血糖水平的系统。这时可以用伴刀豆球蛋白A(ConA)作为载体分子，它对于葡萄糖有很高的亲和性，以用作施主荧光体的级联蓝(Cascade Blue)标记，并以一定量荧光团标记的葡萄糖，例如6-NBD-葡糖胺(6-(N-(7-硝基-2-噁-1，3-重氮-4-基)氨基)-6-脱氧葡萄糖)用作受主。在这一系统中，血中的葡萄糖将胜过荧光标记的葡萄糖，使得在Cascade蓝发射波段上测得的荧光各向异性减小。虽然上面给出了两个非限定性的实施例，但内行的人显然可知，这里提出的基本方法可用来测定一系列物质，例如糖化物、DNA碎片、激素、药物以及免疫球朊等的浓度。

下面的附图描述了用于组织中PO₂几何形态测定和成像组织的血管中血的PO₂几何形态测定的本发明的实施方案。此外还提出了不需在每次使用前校正的导管设计。内行的人可以容易地认识到，借鉴这里公开的内容，采用本发明的方法，通过改变所披露的设计形式，可以测定生物的或身体的其它试样的空间浓度与分布。

如下所示，通过以下方程，可以在普遍情形中有效地确定荧光各向异性，而在对于淬灭剂分子氧的特殊情形中作正式的描述：

A = \frac{I_{1} G - I_{&perp;}}{I_{1} G + I_{&perp;}} = \frac{A_{0} ({αK}_{D} P O_{2} + 1)}{6 \overset{&OverBar;}{R} τ_{0} + α K_{D} {PO}_{2} + 1} - - - - (9)

式中I₁与I_上是其电矢量分别平行于和垂直于线偏振激励辐射的荧光发射强度，G是经验校正系数用来校正分光镜在上述平行平面和垂直平面的传输效率，在此各向异性的正式定义中所用的其它符号与上述相同。

图2用来绘制成像组织的组织与血液中PO₂的几何形态的设备10的示意图。将一种可由O₂淬灭的，生物相容的试剂物质，例如在适当溶剂中或加入到脂质体中的钠的芘丁酸盐，经静脉注入主器官中。组织12由采用钨丝灯源16的光纤照明器14以非偏振可见光照明。高压泵灯18的辐射能由聚光透镜20聚光，由光闸22控制，并通过Glan-Thompson起偏振镜(Ealing公司)。此紫外光由激励滤光片26(340nm峰值，25mm半带通)光谱成形，然后由分光镜28(Omega光学公司)反射，它通过物镜30反射波长＜400nm的光到成像的组织。从激发的组织12发射出的荧光(波长＞400nm)由物镜30聚集，通过分光镜38，再通过发射光滤光片32，此滤光片通过400至420nm波长的光到渥拉斯顿(Wollaston)棱镜起偏振镜34，将发射的荧光分解成平行于和垂直激励偏振面的线偏振分量36与38。这两种矢量分量(I₁与I_)分别和同时地由两台摄像机40A与40B(例如Xybion型250)的CCD(电荷耦合器件)芯片检测。内行的人显然可知，具有足够空间分辨率的其它一些光探测器例如低扫描的急冷的CCD摄像机、SIT或ISIT管摄像机或光电二极管阵列(未示明)，也可以用来探测发射的荧光的平行分量与垂直分量的二维分布。前述两台摄像机的输出由两决数字化板42A与42B(例如Imaging Technologies公司或Data Translation公司以牌号DT3851所出售的)数字化，这两块数字化板是在微计算机44(例如IBM或克隆计算机，优选的是具有以33或66MHz工作的数据处理芯片)内。

这样的装置足以胜任工作和用在监视器46上显示之前进行相继的成像处理。

计算机应用Biometric Imaging公司生产的和享有版权的软件。这一软件的源编码附于本专利申请书中，可由校正文件校正CCD阵列内各像素位置上的斜率与偏移的变化，这样就可在探测器整个阵列上保证有均一的反应性。类似地，这一软件包可使此阵列内各像素强度定量化、过滤与平均化，并得以借助方程(9)在多个位置上计算各向异性，然后对各像素轨迹应用方程(6)变换为组织中PO₂的二维表示，典型的这种设备可以在约33毫秒内在空间中收集300000个以上的组织中PO₂的值。方程(6)中的常数值则是在校准试验中确定的，这些试验涉及到由氧微电极和用间接式寿命(各向异性)系统来同时测量组织中的PO₂.

如果由于内在的短荧光寿命(＜20毫微秒)的荧光素的存在，使组织在发射波长下的自发荧光显示出某种程度的各向异性，因而这些荧光素不会为生理级的O₂淬灭，于是这种“自发的各向异性”可以在注入生物相容的可由O₂淬灭的荧光试剂物质之前成像并存盘。这时，在注入可由O₂淬灭的荧光试剂物质之后，总的各向异性(A_总)与它的分量各向异性(“自发各向异性”或A_组织以及O₂依赖性的各向异性A_试剂)的关系表出于下述方程中：

式中的a+b＝1。O₂依赖性的各向异性于是可据下面的方程(11)从总的各向异性分出来，下式中的a是由试验方法确定的经验常数，其中组织中的PO₂是同时由O₂微电极和由荧光各向异性的光学测量方法测定。

应用上述软件包的程序，可以在一个像素接一个像素的基础上迅速而方便地进行这种校正。

本方法优于Zuckerman173专利发明的一个明显之处是，后者依赖于荧光强度的而不是各向异性的测量，这对内行的人来说是极易认识到的。具体地说，在该专利中，组织中PO₂的测量只能在可由O₂淬灭的荧光试剂物质已在成像组织内达到平衡(稳定)浓度后开始，这是因为空间与时间中的荧光强度既与组织中的试剂浓度也与组织中的PO₂有关。在本说明书中所描述的间接式寿命系统，对试剂浓度不敏感的荧光各向异性而不是强度是组织中PO₂的决定因素，允许一旦聚集的试剂物质足以提供适当的信噪比水平时就能开始PO₂的测量。类似地，这种各向异性的方法对试剂物质在新陈代谢影响下随时间降解并不敏感，这样就能在较长的时间范围内从几何形态上测定组织中的PO₂。

此时应该指出，前述清单A的软件包中包括有伪彩色程序，通过对组织中PO₂的不同的值分配不同的色泽，可以在二维空间中绘出组织中PO₂的光学图象，借助所附的标尺，临床医师可以迅速地解释组织中PO₂的分布。所写出的实施此间接式寿命系统的程序基本上可以“实时”地进行，由此可让临床医师立即观察到设计用来提高组织中氧合作用(例如通常用在糖尿性病视网膜病治疗中以激光处理来提高视网膜组织中的PO₂)治疗措施的效果。

由共焦技术或是应用例如前述清单A中所包含的数字重叠合法程序来进行光学系列分区，可将成像组织中的PO₂的间接寿命系统的能力从二维推广到三维。在此方式下，可以求得组织中PO₂的几何形态图，使组织与血液中的PO₂能在组织的体积内形成三维图像。这种三维信息可以很方便地伪彩色化，并借助三维重构算法在监控屏上绘出。光学系列分区与三维重构方法可使临床医师探测和治疗位于成像组织内不同深度处的组织中PO₂的异常区。

图3表示依据本发明构制的，按不需求在每次使用前进行校准的密封导管设计形式的。用来实现这种间接式荧光寿命系统的设备50。如在前述实施方案一样，由聚光透镜54聚集的高压汞灯52的幅射能经过光闸56控制，通过Glan-Thompson起偏振镜58(例如Ealing公司在产品目录号34-5223的牌号下所出售的)。由激励滤光片60(340nm峰值，25mm半带通)对紫外光进行光谱成形，然后为分光镜62(例如Omega Optical公司以牌号400DCLP出售的)反射，它反射＜400nm波长的光，通过物镜64。将单模保偏振玻璃光纤66(例如Ealiag公司以牌号HB450出售的)固定于物镜的焦点上。此纤维的芯径一般＜10微米，由此可以设计出极窄小的导管。在这种窄小的亚毫米级的导管中，线偏振光直接通到O₂敏感的端部68，而对于较大直径的导管，则把此光纤66安装准直透镜70的焦点上，用来给导管端部68提供均匀的照明。密封的O₂敏感的端部68包含一块石英板72，使光学部件与端部68中的非极性粘性媒质74分开。导管端部68含有例如石蜡或矿物油之类的，其中溶解有芘丁酸或芘76。芘的荧光寿命约为芘丁酸或其盐的形式的10倍，由此可以提高测量精度，有可能使PO₂的测量精度＜1mmHg。溶解于非极性粘滞溶剂中的可由O₂淬灭的试剂物质由例如聚乙烯的可透氧的薄膜78密封于上述导管中。还将一微热敏电阻80装入端部68内而得以同时测温并可根据方程(4)所述关系校准温度。由于光学上的可逆性，来自试剂端部68的线偏振荧光发射便谐单模保偏振光纤66返回，由物镜64聚光。波长＞400nm的光通过分光镜62，波长从400至420mm的光经发射滤光片82到渥拉斯顿棱镜起偏振镜84，将此发射出的荧光分解成平行于和垂直于激励偏振面的分量86A与86B。这两种矢量分量(I₁与I_)分别由可以是光电二极管或光电倍增管的两个光探测器88A与88B，同时检测。

由于这种导管的结构借助于一台简单的微处理机装置90能在单一的位置上即在导管的端部提供PO₂的测量值，可以根据方程(9)计算各向异性并据方程(6)使之与PO₂关联。这种一般的微处理机装置示意于图4中。此外，一旦上述方程中的关系与常数得以确定，它们便可以固定下来用于所制造的每一导管中，而每个导管不需一一在工厂中校正或在其用于临床使用之前校正。这表明本发明的导管的设计大大优于需要在工厂以及在现场中作经常性的重校的先前的设计。

实施例

为了测定视网膜组织中组织PO₂的几何形态分布，按以下所述构成成像设备并示意地表示于图2中。从当地的屠宰场取得牛眼并冰冻送至实验室，根据de Coo，Zonnenberg and Trap(Current Eye Research，12(4)，293-301，1933)的试验程序，用事先补充有108μM芘丁酸钠的氧合的无血清的MEM(最少的必备媒质)，对孤立的上述这只牛眼进行温度正常的动脉充注。在以含芘丁酸钠的MEM经1小时灌注后，这种生物相容性的荧光试剂物质达到视网膜组织中的平衡浓度，然后这只牛眼在进行组织PO₂测量的时间内单独用氧合的MEM进行充注。用透紫外光的玻璃制的通常的眼底检查用透镜(Optical Industries公司制)滤去角膜的折射，先在可见光下使网膜成像，选择的视网膜的区域含有网膜动脉。一旦建立了适当的取向，便截断可见光面以线偏振紫外光照射视网膜组织。用聚光透镜聚集高压汞灯的辐射能，由光闸控制，并使其通过Glan-Thompson起偏振镜(Ealing公司制)。此紫外光经激励滤光片(340nm峰值，25mm半带通)进行光谱成形，然后由分光镜(OmegaOpticol公司制)反射，此分光镜反射400nm以下的波长的光，通过物镜到达成像的视网膜组织上。由受激的组织发射的荧光(波长＞400nm)由物镜聚集，通过分光镜再经过一发射滤光片(后者透过400-420nm波长的光)到达渥拉斯顿棱镜起偏振镜，将发射出的荧光分解成平行于和垂直于激励偏振面的分量。这两个矢量分量(I1与IL)分别由两台摄像机(Xybion250型)的CCD芯片同时检测。

荧光发射的平行于和垂直于激励偏振面的两个矢量分量，由先前指出的以66MHz工作的计算机内的两块数字化板数字化并存储于硬盘(未示明)中。前述清单A中的计算机软件用于此计算机中，由此软件中的校正文件对CCD阵列内各像素位置上的斜率和偏移变化进行校正，从而保证在整个探测器阵列上有一致的响应度。类似地，此软件允许由方程(9)在多个位置上计算各向异性，并通过在各个像素位置上应用方程(6)而变换为组织PO₂的二维表示。这一方法能在约33毫秒内收集空间内视网膜组织PO₂的300 000个值。方程(6)中所用的常数值是在由氧微电极和间接式寿命(各向异性)系统同时测量组织中PO₂有关的校准试验中事先测定的。为了检验这一系统以及所求得的视网膜组织PO₂光学图像的有效性与精密性，在平行和垂直于视网膜动脉的两个方向上测量了PO₂梯度，在此，描述这些关系的数学函数可以根据氧扩散的数学关系预测同时也已在文献中充分地确立。这些测量结果示明于图5中。氧扩散的数学关系指出，在平行于动脉的组织中纵向PO₂的下降应呈线性关系，其斜率正比于此组织(M)的氧消耗率而反比于此动脉中含氧溶液的速度(V)乘以动脉直径(D)。如图5的上部图所示，沿此动脉长度方向上的组织中PO₂的测量值极其良好地符合此牢靠确立的线性关系，获得了0.96的线性拟合的确定系数(R²)，亦即对于预期的线性拟合，数据的方差为96％。类似地垂直于动脉的PO₂梯度应与Krogh模型的数学形式描述的单调下降函数一致。图5(下部图)中，已把Krogh模型以0.99的拟合优度(R²)与数据拟合，亦即根据预期的数学关系算得数据的方差为99％。图5中的数据于是表明，这种间接式的荧光寿命系统能提供无损伤性的可靠方法在空间与时间上来测定组织中PO₂。

本发明业已结合最佳实施例和图示的例子作了说明，内行的人在阅读了前面的说明后是能够对上面陈述的方法作出种种变更、替换或其它等形式的修正。因此应该指出。对此专利申请文件的保护仅由后附权利要求书中包括的定义及其等效内容限定。

Source code cxccrpted from″Software for the Acquisition.Manipulation

   and Analysis of Video Images”，1993.Biometric Imaging，Inc.
Pleasc noic that page numbers in this excerpt do not correspond to those in full document.
/*initial grabber */
#include＜stdio.h＞
#include＜dos.h＞
#define BASEMEM 0xD000/*memory base address*/
#define RB 0x300   /*pcplus regster base address*/
void ini_iut(void)；
void ini_reg(void)；
main()
{
int i；

       ini_reg()；

       ini_lut()；

       ini_reg()；

       ini_lut()；    /*why does it need twice？*/
}
void ini_lut(void)
{
int j；
unsigned char i；
outp(RB+1，0x00)；
for(j＝0；j＜＝255；j++)

          {         i＝j；

                    outp(RB+2，i)；outp(RB+3，i)；}
outp(RB+1，0x01)；
for(j＝0；j＜＝255；j++)

          {

                    i＝j；

                    outp(RB+2，i)；outp(RB+3，i)；}
outp(RB+1，0x02)；
for(j＝0；j＜＝255；j++)

          {      i＝j；

                     outp(RB+2，i)；outp(RB+3，i)；}
outp(RB+1，0x03)；
for(j＝0；j＜＝255；j++)

          {         i＝j；

                    outp(RB+2，i)；outp(RB+3，i)；}
}
void ini_reg(void)
{
				
				<dp n="d17"/>
outp(RB，0x16)；outp(RB+1，3)；outp(RB+2，0)；
outp(RB+3，0)；outp(RB+4，0x36)；outp(RB+5，0x02)；
outp(RB+6，0)；outp(RB+7，0)；outp(RB+8，0x40)；
outp(RB+9，0)；outp(RB+10，0)；      outp(RB+11，0)；
}
/*clean the screen*/
#include＜stdio.h＞
#include＜dos.h＞
#define BP 0x3F8    /*for coml.baseport register address*/
#define CONREG 0x300       /*pcplus regster base address*/
main()
{
int i，j，k，line；
unsigned int stat，ini_stat；
unsigned char huge*mem；
unsigned char huge*mem_keep；

        mem＝mem_keep＝(unsi8ned char huge*)MK_FP(0xD000，0)；

        ini_stat＝0x16；

        for(i＝0；i＜8；i++)

                  {

                  stat＝(i＜＜5)&amp;0xe0；

                  stat｜＝ini_stat；

                  outp(CONREG，stat)；

                  line＝64；

                  if(i＝＝7)line＝32；

                  for(j＝0；j＜line；j++)

                            {

                            for(k＝0；k＜640；k++)

                                    {

                                    *mem＝0；

                                    mem++；

                                    }

                              mem+＝(1024-640)；

                              }

                        mem＝mem_keep；

                        }
}
/*This program is used to get integrating image from CCD camera.
  Integrate signal is a positive impulse sent from port 0x3FC(modem
  control register，DTR&amp;RTS ON)，the snap signal from camera is sent
  to port 0x3FD(modems tatus register)                             */
#include＜stdio.h＞
#include＜dos.h＞
#include＜time.h＞
#include＜string.h>
				
				<dp n="d18"/>
#include＜alloc.h＞
#include＜dir.h＞
#define BASEMEM 0xD000    /*memory base address*/
#define BP 0x3F8    /*for coml.baseport register address*/
#define RB 0x300    /*pcplus regster base address*/
main()
{
int m，j，test_times，x1，y1，x2，y2，th，tm，ts，av1，av2，img_num，re_openfile，time_delay；
floati.i，ii，sample_value，test_value，av，zeit_interval，zeit；
char imname[30]，datname[30]，s1[30]，s2[30]，s3[30]，c，overwr；
FILE*fp，*datfile；
unsigned char*pixel，n，value；
unsigned char huge*mem；
long ZZ，ZZZ；
time_t anf_zeit，jetzt_zeit；
int odd，even，k；
struct ffblk ffblk；
prinif(″The datafile saves the information about your images，″)；
do{
overwr＝‘y’；
printf(″\ninput the datafile name--＞″)；
scanf(″％s″，datname)；  printf(″\n″)；
if(findfirst(datname，&amp; ffblk，0)＝＝0)
  
          {
          printf(″---Warning：the file already exists，overwrite it？(y)″)；

          overwr＝getche()；

          }
}while(overwr！＝‘y’)；
printf(″\m The name of your image has two attributes，\n″)；
printf(″the first is the NAME(e.g.‘myimage’)given by user；\n″)；
printf(″the second is the IMAGE ORDER，(1，2，3，...)determined by the program.\n″)；
printf(″The image sequence will be myimage1，myimage2，…….\n″)；
printf(″input image name--＞″)；
scanf(″％s″，s1)；printf(″\n″)；

         datfile＝fopen(datname，“wt″)；

         /*set output signal low*/

         mem＝(unsigned char huge*)MK_FP(BASEMEM，0)；

         outp(BP+4，0)；

         /*initiate grabber’s regsters*/
/*       inigrab()；
  */

         c＝”；

         do{

         if(c＝＝3)exit()；

         pribtf(″\n------------------------------\n″)；
				
				<dp n="d19"/>
    /*image grab*/

    value＝inp(RB+5)；

    outp(RB+5，value｜0xc0)；    /*  for(j＝0；j＜10000；j++){}；*/

    /*get area of interested*/

    printf(″if ready，type‘f’to freeze image and get AOI：″)；

    while((c＝getche())！＝‘f’)    {    if(c＝ ＝3)exit()；    )；

    printf(″\n″)；

    outp(RB+5，0x82)；    /*dosnap*/

    getaoi(&amp;x1，&amp;y1，&amp;x2，&amp;y2)；

    x1++；y1++；x2--；    y2-；

    area_ave(x1，y1，x2，y2，&amp;av)；

    printf(″the area size is ％d X％d.average value is ％f.\n″，

             x2-x1+1，y2-y1+1，av)；

    prinf(″AIO is OK？(y)″)；

    }while((c＝getche())！＝‘y’)；

    fprintf(datfile，″AOI size：(％d x ％d)；rectangular position：[(％d，％d)，(％d，％d)].\n″，
 
    x2-x1+1，y2-y1+1，x1-1，y1-1，x2+1，y2+1)；

    printf(″＼n″)；

    img_num＝0；

    time_delay＝0；
do{
/*  inigrab()；
*/  outp(BP+4，0)；

value＝inp(RB+5)；

outp(RB+5，value｜0xc0)；    /* do grab again*/
/*input integrateduration*/

printf(″---------------------------------------------------------\n″)；

if(time_delay＝＝0)

            {

            printf(″Delay time(sec.)：″)；

           scanf(″％f″，&amp;zeit)；    printf(″\n″)；

            time_delay＝l；

            }

    else

            {

            printf(″delayy time：％f sec.，change it？(y)：″，zeit)；

            if(getche()＝＝‘y’)

                     {

                     printf(″\ndelay time(sec.)：″)；

                     scanf(″％f″，&amp;zeit)；

                     }

            printf(″\n″)；

            }

    i＝zeit；

    ii＝i；

    test_times＝0；
				
				<dp n="d20"/>
    do{

    i＝ii；

    outp(RB，0x16)；value＝inp(RB+5)；outp(RB+5，value｜0xc0)；

    /*output integrating impulse*/
/*  printf(″integrating......″)；

    i*＝25000；
*/

    i*＝100000；

    while(i＞0)

             {

             outp(BP+4，3)；    /*set output signal high*/

             i--；

             }

    outp(RB+5，0x82)；

    for(i＝0；i＜10000；i++){}    /*for 386 i＜1000*/

    outp(BP+4，0)；    /*set output signal low*/

    /*wait for grab signal*/

    while(inp(BP+6)＝＝1){    }；

    /*get test value，if integrate not successful，do again*/

    outp(RB，((5＜＜5)&amp;0xe0)｜0x16)；

    test_value＝100；

    test_times++；

    }while(test_value＜10 &amp;&amp; test_times＜＝2.)；

    /*store image into disk*/

    show_time(&amp;th，&amp;tm，&amp;ts，&amp;jetzt_zeit)；

    area_ave(x1，y1，x2，y2，&amp;av)；

    rectangular_show(x1-1，y1-1，x2+1，y2+1，255)；

    av＝(2*av＜255)？2*av：255；

    av1＝av；    av*＝100；    av2＝av；    av1*＝100；

    av1＝av2-av1；  av2/＝100；    av/＝100；

    outp(RB，(((1＜＜5)&amp;0xe0)｜0x16))；

    /*      for(k＝0；k＜40；k++)

            {

            zz＝1024；    zz*＝k；    zz+＝10；

            printf(″％d″，*(mem+zz+10))；

            }

    printf(″\n″)；

    */

    odd＝even＝0；

    for(k＝0；k＜50；k++)

            {

            odd+＝*(mem+k)；even+＝*(mem+k+1024)；

            }

    if(odd＞even)  printf(″------this is the ODD field image.\n″，odd，even)；

    else    printf(″------this is the EVEN field image.\n″，odd，even)；

    printf(″------average value is ％d.％d，store image？(y)″，av2，av1)；
				
				<dp n="d21"/>
    if(getche()＝＝‘y’)

             {

             img_num++；

             printf(″\n″)；

             if(img_num＝＝1)    anf_zeit＝jetzt_zeit；

             zeit_interval＝jetzt_zeit-anf_zeit；

             zeit_interval/＝60；

             do(

                      overwr＝‘y’；

                      itoa(img_num，s2，10)；

                      strcpy(imname，s1)；

                      strcat(imname，s2)；

                      re_openfilk＝0；

                      printf(″the name of image ％d is＜％s＞，change it(y)：″，

                               img_num，imname)；

                      if(getche()＝＝‘y’)

                               {

                               printf(″＼nnew name：″)；

                               scanf(″％s″，imname)；

                               }

                    printf(″＼n″)；

                    if(findfirst(imname，&amp;ffblk，0)＝＝0)

                              {

                              printf(″---Warning：the file already exists，overwrite it？(y)″)；

                              overwr＝getche()；

                              }

             }while(overwr！＝‘y’)；

             fp＝fopen(imname，″wb″)；

             im_store(fp，x1，y1，x2，y2)；

             fclose(fp)；

             if(odd＞even)

             fprintf(datfile，″--％s：mean_value(％f)，time(％f min.)，odd field.\n″，

                     imname，av，zeit_interval)；

             else

             fprintf(datfile，″--％s：mean_value(％f)，time(％f min.)，even field.\n″，

                     imname，av，zeit_interval)；

             }
   printf(″\n″)；
   printf(″Press q to quit，any other key to continue.\n″)；
}while(getche()！＝‘q’)；
fclose(datfile)；
printf(″\n″)；
}
inigrab()
{
outp(RB，0x16)；outp(RB+1，3)；outp(RB+2，0)；
outp(RB+3，0)； outp(RB+4，36)；     outp(RB+5，0x02)；
outp(RB+6，0)； outp(RB+7，0)；outp(RB+8，0x40)；
outp(RB+9，0)； outp(RB+10，0)；     outp(RB+11，0)；
}
				
				<dp n="d22"/>
#define CONREG 0x300
getaoi(x1，y1，x2，y2)
int*x1，*y1，*x2，*y2；
{
float xx1，yy1，xx2，yy2；
start_end_point(&amp;xx1，&amp;yy1，&amp;xx2，&amp;yy2)；
*x1＝xx1；      *y1＝yy1；      *x2＝xx2；    *y2＝yy2；
rectangular_show(*x1，*y1，*x2，*y2，255)；
)
rectangular_show(x1，y1，x2，y2，br)
int x1，y1，x2，y2，br；
{
line_show(x1，y1，x2，y1，br)；
line_show(x2，y1，x2，y2，br)；
line_show(x2，y2，x1，y2，br)；
line_show(x1，y1，x1，y2，br)；
)
area_ave(x1，y1，x2，y2，av)
int x1，y1，x2，y2；
float*av；
{
int i，j，x，y，k，start_line，end_line，start_blc，end_blc，

       start_y_offset，end_y_offset，line_offset；
unsigned char huge*mem；
unsigned char huge*mem_keep；
unsigned char ini_stat，stat；
unsigned char p；
long zz，zzz，testv1，testv2；

         mem＝(unsigned char huge*)MK_FP(BASEMEM，0)；

         x＝x2-x1+1；

         start_blc＝y1/64；        end_blc＝(y2+1)/64；

         start_y_offset＝y1％64；  end_y_offset＝(y2+1)％64；

         mem_keep＝mem+x1；

         zz＝start_y_offset； zz*＝1024；zz+＝x1；

         mem+＝zz；

         /*fine the data line*/

         testv1＝testv2＝0；

         for(i＝0；i＜x；i++)

                   {

                   testv1+＝*(mem+i)；    testv2+＝*(mem+1024+i)；

                   }

         line_offset＝(testv1＞testv2)？0：1；

         ini_stat＝0x16；           zzz＝zz＝0；

         for(i＝start_blc；i＜＝end_blc；i++)

                  {

                  stat＝(i＜＜5)&amp;0xe0；

                  stat｜＝ini_stat；
				
				<dp n="d23"/>
    outp(CONREG，stat)；

    if(i＝＝start_blc)

              start_line＝start_y_offset+line_offset；

    else      start_line＝0+line offset；

    if(i＝＝end_blc)end_line＝end_y_offset；

              else    end_line＝64；

    for(j＝star_line；j＜end_line：j+＝2)

             {

             for(k＝0；k＜x；k++)

                     {

                     zzz+＝*mem；    zz++；

                     mem++；

                     }

             mem+＝(1024-x)；

             }

     mem ＝ mem_keep；

     }
*av＝zzz；   *av/＝zz；
}
point_show(xp，yp，br)
int xp，yp，br；
{
unsigned char huge*mem；
int block，y_offset；
unsigned char status；
long zz：
mem＝(unsigned char huge*)MK_FP(BASEMEM，0)；
block＝yp/64； y_offset＝yp％64；
zz＝1024；     zz*＝y_offset；  zz+＝xp；    mem+＝zz；
status＝((block＜＜5)&amp;0xe0)｜0x16；
outp(CONREG，status)；  *mem＝br；
}
line_show(x1，y1，x2，y2，br)
int x1，y1，x2，y2，br；
{
/*      start(small address)-----------＞end(big address)  */
int p，xx，yy，q，aa，delta_x，delta_y；
float qq，dx，dy；
long zzz，zz；
zz＝y1；zz*＝1024；    zz+＝x1；
zzz＝y2；       zzz*＝1024；   zzz+＝x2；
if(zz＞zzz)

         {

         xx＝x1；x1＝x2；x2＝xx；

         yy＝y1；y1＝y2；y2＝yy；

         }
delta_x＝x2-x1；    delta_y＝y2-y1；
				
				<dp n="d24"/>
/*printf(″delta_x：％f ％d ％d，delta_y：％f ％d ％d.\n″，delta_x，x2，x1，delta_y，y2，y1)；
*/
if(delta_x＝＝0)

         for(p＝0；p＜＝delta_y；p++)    point_show(x1，y1+p，br)；
if(delta_y＝＝0)

         for(p＝0；p＜＝delta_x；p++)    point_show(x1+p，y1，br)；
if(delta_x！＝0 &amp;&amp; delta_y！＝0)

         {

         aa＝(delta_x＞0)？1：-1；  dx＝delta_x；  dy＝delta_y；

         if(aa*delta_x＞＝delta_y)

                 for(p＝0；p＜＝aa*delta_x；p++)

                           {

                           qq＝(dy*p)/(dx*aa)+0.5；    q＝qq；

                           point_show(x1+aa*p，y1+q，br)；

                           }

    else

                   for(p=0；p＜delta_y；p++)

                           {

                           qq＝(dx*p)/(aa*dy)+aa*0.5；    q＝qq；

                           point_show(x1+q，y1+p，br)；

                           }
/*    printf(*--draw show ok.\n″)；

      */

      }
}
#define CONREG 0x300
start_end_point(x1，y1，x2，y2)
float*x1，*y1，*x2，*y2；
{
unsigned char huge*cross buf；
char b[4]；
int a，i，j，x，y，xx，yy，kx，ky，sx，sy，ex，ey；
x＝320；y＝240；
cross_buf＝(unsingned char buge*)calloc(41，1)；
for(i＝0；i＜2；i++)

          {

          xx＝x；yy＝y；

          do{

          if(i＝＝0)    printf(″current position---(％1d，％1d).\r″，xx，yy)；

          if(i＝＝1)

                   {

                   printf(″current position---(％1d，％1d)，AOI size(％1d，％1d).\r″，

                            xx，yy，xx-sx-1，yy-sy-1)；

                   if(xx-sx-1＜0||yy-sy-1＜0)

                            {

                            sound(600)；  delay(100)；    nosound()；

                            }
                   }
				
				<dp n="d25"/>
    kx＝xx；ky＝yy；

    move_cross(kx，ky，cross_buf)；

    a＝getch()；

    if(a＝＝56)     yy--；
    if(a＝＝57)     yy-＝10；

    if(a＝＝50)     yy++；

    if(a＝＝49)     yy+＝10；

    if(a＝＝52)     xx--；

    if(a＝＝55)     xx-＝10；

    if(a＝＝54)     xx++；

    if(a＝＝51)     xx+＝10；

    if(a＝＝48)     {xx＝320；yy＝240；    }

    if(a＞＝48 &amp;&amp; a＜＝57)  recover_cross(kx，ky，cross_buf)；

    }while(a！＝43)；

    if(i＝＝0)

              {

              sx＝xx；sy＝yy；point_show(sx，sy，255)；

              *x1＝xx；    *y1＝yy；

              printf(″\nup-left point(％d，％d).\n″，sx，sy)；

              }

    if(i＝＝1)

              {

              ex=xx；ey＝yy；point_show(ex，ey，255)；

              *x2＝xx，             *y2＝yy；
              printf(″\nlow-right point(％d，％d).\n″，ex，ey)；

              }

       }
}
move_cross(xp，yp，cross_buf)
int xp，yp；
unsigned char huge*cross_buf；
{
int i，xx，yy；
unsigned char huge*mem；
unsigned char huge*mem_keep；
int block，y_offset；
unsigned char status；
long zz；
mem＝mem_keep＝(unsigned char huge*)MK_FP(BASEMEM，0)；
for(i＝-10；i＜＝10；i++)

         {

         yy＝yp+i；     xx＝xp；

         block＝yy/64； y_offset＝yy％64；

         zz＝1024；     zz*＝y_offset；  zz+＝xx；   mem+＝zz；

         status＝(block＜＜5)&amp;0xe0)｜0x16；

         outp(CONREG，status)；

         *cross_buf＝*mem；     *mem＝255；  cross_buf++；

         mem＝mem_keep；

         }
				
				<dp n="d26"/>
mem＝mem_keep；
block＝yp/64；  y_offset＝yp％64；
status＝((block＜＜5)&amp;0xe0)｜0x16；
outp(CONREG，status)；
for(i＝-10；i＜＝10；i++)

         {

         mem＝mem_keep；    xx＝xp+i；

         zz＝1024；zz*＝y_offset；    zz+＝xx；    mem+＝zz；

         if(i！＝0)

                  {

                  *cross_buf＝*mem；  *mem＝255；  cross_buf++；

                  }

         }
}
recover_cross(xp，yp，cross_buf)
int xp，yp；
unsigned char huge*cross_buf；
{
int i，xx，yy；
unsigned char huge*mem；
unsigned char buge*mem_keep；
int block，y_offset；
unsigned char status；
long zz；
mem＝mem_keep＝(unsigned char huge*)MK_FP(BASEMEM，0)；
for(i＝-10；i＜＝10；i++)

         {

         mem＝mem_keep；

         yy＝yp+i；    xx＝xp；

         block＝yy/64；y_offset＝yy％64；
         zz＝1024；    zz*＝y_offset；    zz+＝xx；    mem+＝zz；

         status＝((block＜＜5)&amp;0xe0)｜0x16；

         outp(CONREG，status)；

         *mem＝*cross_buf；    cross_buf++；

         }
mem＝mem_keep；
block＝yp/64；y_offset＝yp％64；
status＝((block＜＜5)&amp;0xe0)｜0x16；
outp(CONREG，status)；
for(i＝-10；i＜＝10；i++)

         {

         mem＝mem_keep；

         xx＝xp+i；

         zz＝1024；    zz*＝y_offset；  zz+＝xx；    mem+＝zz；

         if(i！＝0)

                 {

                 *mem＝*cross_buf；     cross_buf++；

                 }

         }
}
im_store(fp，x1，y1，x2，y2)
FILE*fp；
int x1，y1，x2，y2；
				
				<dp n="d27"/>
{
int i，j，x，y，k，start_line，end_line，start_blc，cnd_blc，

       start_y_offset，end_y_offset；
unsigned char huge*mem；
unsigned char huge*mem_keep；
unsigned char ini_stat，stat；
unsigned char p；
long zz；
char ix[8]，iy[8]；

         mem＝(unsigned char huge*)MK_FP(BASEMEM，0)；

         x＝x2-x1+1；     y＝y2-y1+1；

         itoa(x，ix，10)；itoa(y，iy，10)；

         for(i＝0；i＜8；i++)       fputc(ix[i]，fp)；

         for(i＝0；i＜8；i++)       fputc(iy[i]，fp)；

         start_blc＝y1/64；                 end_blc＝(y2+1)/64；

         start_y_offset＝y1％64；           end_y_offset＝(y2+1)％64

         mem_keep＝mem+x1；

         zz＝start_y_offset；    zz*＝1024；    zz+＝x1；

         mem+＝zz；

         ini_stat＝0x16；

         for(i＝start_blc；i＜＝end_blc；i++)

                  {

                  stat＝(i＜＜5)&amp;0xe0；

                  stat｜＝ini_stat；

                  outp(CONREG，stat)；

                  if(i＝＝start_blc)    start_line＝start_y_offset；

                            else  start_line＝0；

                  if(i＝＝end_blc)end_line＝end_y_offset；

                            else  end_line＝64；

                  for(＝＝start_line；j＜end_line；j++)

                            {

                            for(k＝0；k＜x；k++)

                                    {

                                    p＝*mem；   fputc(p，fp)；

                                    mem++；

                                    }

                              mem+＝(1024-x)；

                              }

                        mem＝mem_keep；

                        }
printf(″------a％d X％d image is saved.\n″，x，y)；
}
#include＜time.h＞
show_time(th，tm，ts，jetzt_zeit)
int*th，*tm，*ts；
time_t*jetzt_zeit；
{
strud tm*timeptr；
time_t secsnow；
time(&amp;secsnow)；    *jetzt_zeit＝secsnow；
				
				<dp n="d28"/>
timeptr＝localtime(&amp;secsnow)；
printf(″-----current time is ％02d：％02d：％02d\n″，

         timeptr-＞tm_hour，timept-＞tm_min，timeptr-＞tm_sec)；
*th＝timeptr-＞tm_hour；
*tm＝timeptr-＞tm_min；
*ts＝timeptr-＞tm_sec；
}
#include″ypdef.h″
#include＜stdio.h＞
#include＜string.h＞
#include＜dos.h＞
#include＜alloc.h＞
#define BASEMEM 0xD000
#define CONREG 0x300
main()    
{
char imname[30]，outname[30]，calnamel[30]，calname2[30]；
unsigned char huge *image；
unsigned char huge *stdimage1；
unsigned char huge *stdimage2；
long zz；
int x，y，i，j，pp，field；
float ave0，ave1，ave2，ave3，p0，p1，p2，k，b；
do{
printf(″1.image with one field.\n″)；
printf(″2.image with both fields.\n″)；
scanf(″％d″，&amp;field)；     printf(″\n″)；
}while(field！＝1 &amp;&amp; field！＝2)；
printf(″image name：″)；
scanf(″％s″，imname)；    printf(″\n″)；
printf(″calibration image1：″)；
scanf(″％s″，calnamel)；   printf(″\n″)；
printf(″calibration image 2：″)；
scanf(″％s″，calname2)；  printf(″\n″)；
/*
zz＝y；  zz*＝x；
image＝(unsigned char huge*)farcalloc(zz，1)；
stdimage1＝(unsigned char huge*)farcalloc(zz，1)；
stdimage2＝(unsigned char huge*)farcalloc(zz，1)；
if(image＝＝NULL||stdimage1＝＝NULL||stdimage2＝＝NULL)

        {     printf(″fail to allocate.\n″)；    exit(1)；}
*/
stdimage1＝(unsigned char huge*)read_image(calname1，&amp;x，&amp;y)；
image_show(stdimage1，0，0，x，y)；
stdimage2＝(unsigned char huge*)read_image(calname2，&amp;x，&amp;y)；
image_show(stdimage2，50，50，x，y)；
image＝(unsigned char huge*)read_image(imname，&amp;x，&amp;y)；
image_show(image，100，100，x，y)；
ave1＝ave2＝0；
				
				<dp n="d29"/>
for(j＝0；j＜y；j++)

          fer(i＝0；i＜x；i++)

                    {

                    zz＝j；  zz*＝x；zz+＝i；

                    ave1+＝*(stdimage1+zz)；

                    ave2+＝*(stdimage2+zz)；

                    }
ave1/＝x；    ave1/=y；
ave2/＝x；    ave2/＝y；
if(field＝＝1)

         {    ave1*＝2；    ave2*＝2；    }
printf(″the average value of cal-image 1：％f.\n″，ave1)；
printf(″the average value of cal-image 2：％f.\n″，ave2)；
if(ave1＝＝ave2)

         {

         printf(″same average value.\n″)；

         exit()；

         }
ave0＝ave3＝0；
for(j＝0；j＜y；j++)

          for(i＝0；i＜x；i++)

                    {

                    zz＝j；zz*＝x；zz+＝i；

                    p0＝*(image+zz)；          ave3+＝p0；

                    p1＝*(stdimage1+zz)；

                    p2＝*(stdimage2+zz)；

                    k＝(p1-p2)/(ave1-ave2)；   b＝p2-k*ave2；

                    if(k！＝0)       p0＝(p0-b)/k+0.5；

                    ave0+＝p0；

                    pp＝p0；

                    if(pp＞＝255)    pp＝255；

                    if(pp＜＝0)      pp＝0；

                    point_show(i+150，j+150，pp)；

                    }
ave0/＝x；          ave0/＝y；
ave3/＝x；          ave3/＝y；
printf(″the average value of the image to be calibrated：％f.\n″，ave3)；
printf(″the average value of the calibrated image：％f\n″，ave0)；
printf(″\n″)；
printf(″save image？(y)：″)；
if(getche()＝＝‘y’)

         {

         printf(″\noutput image name：″)；

         scanf(″％s″，outname)；printf(″\n″)；

         save_image(outname，150，150，150+x-1，150+y-1)；

         }
printf(″\n＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ END
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝\n″)；
}
/″..........substract image2 from image1............*/
#include″ypdef.h″
#include＜stdio.h＞
				
				<dp n="d30"/>
#include＜dos.h＞
#include＜alloc.h＞
#include＜dir.h＞
#define BASEMEM 0xD000
#define CONREG 0xa00
main()
{
char imgname1[50]，imgname2[50]，outname[50]，overwr；
unsigned char huge*image；
unsigned char huge*board；
unsigned char huge*p；
int choice，c，i，j，x，y，ws，wrongname，pp，ppp；
long size，zz；
int n；
float s，s1，s2，s3；
struct ffblk ffblk；
/*read an image from disk into memory*/
printf(″％lu bytes free in ram.\n″，farcoreleft())；
printf(″        Image1-Image2                       \n″)；
printf(″Polarization=-----------X  Scale_factor    \n″)；
printf(″           Image1+Image2    \n″)；
printf(″\n″)；
printf(″the names of image1，image2，and scale_factor：″)；
scanf(″％s ％s ％r″，imgname1，imgname2，&amp;s)；
printf(″\n″)；
image＝(unsigned char huge*)read_image(imgname1，&amp;x，&amp;y)；
image_show(image，0，0，x，y)；
farfree((unsigned char far*)image)；
p＝(unsigned char huge*)farcalloc(1，1)；
image＝(unsigned char huge*)read_image(imgname2，&amp;x，&amp;y)；
for(j＝0；j＜y；j++)

          for(i＝0；i＜x；i++)

                    {

                    zz＝j；  zz*＝x；zz+＝i；

                    get_point_value(i，j，p)；  pp＝*p；

                    ppp＝*(image+zz)；

                    s1＝pp；s2＝ppp；    s3＝s*(s1-s2)/(s1+s2)+0.5；

                    pp＝s3；

                    if(pp＞255)    pp＝255；    if(pp＜0)    pp＝0；

                    point_show(i，j，pp)；

                    }
printf(″save image？(y)：″)；
if(getche()＝＝‘y’)

         {

         do{

         overwr＝‘y’；

         printf(″\noutput image name：″)；

         scanf(″％s″，outname)；  printf(″\n″)；

         if(findfirst(outname，&amp;ffblk，0)＝＝0)

                   {
				
				<dp n="d31"/>
            printf(″---Warning：the file already exists，overwrite it？(y)″)；

            overwr＝getche()；

            }

    }while(overwr！＝‘y’)；

    printf(″\n″)；

    save_image_screen(outname，0，0，x-1，y-1)；

    }
}
save_image_screen(imname，x1，y1，x2，y2)
char imname[50]；
int x1，y1，x2，y2；
{
int wrongname，i，j，y，k，start_line，end_line，start_blc，end_blc，

        start_y_offset，end_y_offset；
unsigned char huge*mem；
unsigned char huge*mem keep；
unsigned char ini_stat，stat；
unsigned char p；
long zz；
FILE*fp；
char ix[8]，iy[8]；
do{
wrongname＝0；
if((fp＝fopen(imname，″wb″))＝＝NULL)

          {

           wrongname＝1；

           printf(″wrong uame！try again：″)；

           scanf(″％s″，imname)；printf(″\n″)；

           }
}while(wrongname＝＝1)；
mem＝(unsigned char huge*)MK_FP(BASEMEM，0)；
x＝x2-x1+1；  y＝y2-y1+1；
itoa(x，ix，10)；  itoa(y，iy，10)；
for(i＝0；i＜8；i++)         fputc(ix[i]，fp)；
for(i＝0；i＜8；i++)         fputc(iy[i]，fp)；
start_b1c＝y1/64；              end_blc＝(y2+1)/64；
start_y_offset＝y1％64；          end_Y_offset＝(y2+1)％64；
mem_keep＝mem+x1；
zz＝start_y_offset；  zz*＝1024；    zz+＝x1；
mem+＝zz；

    ini_stat＝0x16；

    for(i＝start_blc；i＜＝end_blc；i++)

             {

             stat＝(i＜＜5)&amp;0xe0；

             stat｜＝ini_stat；

             outp(CONREG，stat)；

             if＝＝start_blc)    start_line＝start_y_offset；

                     else    start_line＝0；

             if(i＝＝end_blc)end_line＝end_y_offset；

                     else  end_line＝64；

             for(j＝start_line；j＜end_line；j++)

                      {
				
				<dp n="d32"/>
                    for(k＝0；k＜x；k++)

                            {

                            p＝*mem；    fputc(p，fp)；

                            mem++；

                            }

                      mem+＝(1024-x)；

                      }

                  mem＝mem_keep；

                  }
printf(″-----a ％d X ％d image％s is saved.\n″，x，y，imname)；
}
#include″ypdef.h″
#include＜stdio.h＞
#include＜alloc.h＞
#include＜dos.h＞
#include＜math.h＞
#define BASEMEM 0xD000
#define CONREG 0x300
#define XO 320
#define YO 240
main()
{
char imname[30]，outname[30]；
unsigned char huge*image；
int i，j，x，y，t1，t2；
long size，*hist；

         hist＝(long*)calloc(256，sizeof(long))；

         printf(″％lu bytes free.\n″，farcoreleft())；

         printf(″image name：″)；

         scanf(″％s″，imname)；    printf(″\n″)；

         ini_reg()；

         ini_lut()；

         image＝(unsigned char huge*)read_image(imname，&amp;x，&amp;y)；

         image_show(image，XO-x/2，YO-y/2，x，y)；

         histogram_image(image，x，y，bist)；

         /* 

         for(j＝0；j＜480；j++)

                   for(i＝533；i＜567；i++)point_show(i，j，0)；

         grey_level_show()；

         show_hist_vertical(hist)；                */

         move_cursor_equalize(image，x，y，&amp;t1，&amp;t2，hist)；

         equalize_mem(image，x，y，t1，t2)；

    　　 printf(″\nsave image？(y)：″)；

         if(getche()＝＝’y’)

                  {

                  printf(″\noutput equalized image name：″)；

                  scanf(″％s，outname″)；  printf(″\n″)；

                  save_image(outname，XO-x/2，YO-y/2，XO-x/2+x-1，YO-y/2+y-1)；

                  }
				
				<dp n="d33"/>
printf(″\n″)；
}
#define CONREG 0x300
move_cursor_equalize(image，x，y，t1，t2，hist)
unsigned char huge*image；
int x，y，*t1，*t2；
long*hist；
{
unsigned char huge *cross buf；
char b[4]；
int，a，i，j，t，xx，yy，kx，ky，sx，sy，ex，ey，k1，k2；
float tt；
cross_buf＝(unsigned char huge*)calloc(41，1)；
xx=610；        yy＝240；
printf(″move cursor to get threshold.″)；
do{

    for(k2＝0；k2＜480；k2++)

            for(k1＝533；k1＜639；k1++)  point_show(k1，k2，0)；

    grey_level_show()；

    show_hist_vertical(hist)；

    printf(″\n″)；

    for(i＝0；i＜2；i++)

    {

              if(i＝＝0)    printf(″move cursor to LOW cut-off grey level.\n″)；

              else          printf(″move cursor to HIGH cut-off grey level.\n″)；

              do{

              tt＝255；tt*＝yy；tt/＝480；    t＝tt；

              printf(″current threshold---％d.\r″，t)；

              kx＝xx；ky＝yy；
              save_move_cross(kx，ky，cress_buf)；

              a＝getch()；

              if(a＝＝56)    yy--；

              if(a＝＝57)    yy-＝10；
              if(a＝＝50)    yy++；

              if(a＝＝49)    yy+=10；

              if(a＝＝48)    yy＝240；

              recover_cross(kx，ky，cross_buf)；

              }while(a！＝43)；

              if(i＝＝0)     *t1＝yy；

              else         *t2＝yy；

              printf(″\n″)；

    }

    tt＝255；    tt*＝*t1；    tt/＝480；    *t1＝tt；

    tt＝255； tt*＝*t2；  tt/＝480；    *t2＝tt；

    equalize_screen(image，x，y，*t1，*t2)；

    printf(″\nOK？(y)；″)；
}while(getche()！＝″y″)；
				
				<dp n="d34"/>
}
save_move_cross(xp，yp，cross_buf)
int xp，yp；
unsigned char huge*cross buf；
{
int i，xx，yy；
unsigned char huge*mem；
unsigned char huge*mem keep；
int，block，y_offset；
unsigned char status；
long zz；
mem＝mem_keep＝(unsigned char huge*)MK_FP(BASEMEM，0)；
for(i＝-10；i＜＝10；i++)

         {

         yy＝yp+i；    xx＝xp；

         block＝yy/64；y_offset＝yy％64；

         zz＝1024；    zz*＝y_offset；  zz+＝xx；    mem+＝zz；

         status＝((block＜＜5)&amp;0xe0)｜0x16；

         outp(CONREG，status)；

         *cross_buf＝*mem；       *mem＝255；    cross_buf++；

         mem＝mem_keep；

         }
mem＝mem_keep；
block＝yp/64；  y_offset＝yp％64；
status＝((block＜＜5)&amp;0xe0)｜0x16；
outp(CONREG，status)；
for(i＝-10；i＜＝10；i++)

         {

         mem＝mem)_keep；    xx＝xp+i；

         zz＝1024；    zz*＝y_offset；  xx+＝xx；    mem+＝zz；

         if(i！＝0)

                 {

                 *cross_buf＝*mem；    *mem＝255；    cross_buf++；

                 }

         }
}
recover_cross(xp，yp，cross_buf)
int xp，yp；
unsigned char huge*cross_buf；
{
int i，xx，yy；
unsigned char huge*mem；
unsigned char huge*mem_keep；
int block，y_offset；
unsigned char status；
long zz；
mem＝mem_keep＝(unsigned char huge*)MK_FP(BASEMEM，0)；
for(i＝-10；i＜＝10；i++)

         {

         mem＝mem_keep；

         yy＝yp+i；    xx＝xp；
				
				<dp n="d35"/>
      block＝yy/64；  y_offset＝yy％64；

      zz＝1024；      zz*＝y_offset；  zz+＝xx；    mem+＝zz；

      status＝((block＜＜5)&amp;0xe0)｜0x16；

      outp(CONREG，status)；

      *mem＝*cross_buf；    cross_buf++；

      }
mem＝mem_keep；
block＝yp/64；    y_offset＝yp％64；
status＝((block＜＜5)&amp;0xe0)｜0x16；
outp(CONREG，status)；
for(i＝-10；i＜＝10；i++)

     {

     mem＝mem_keep；

     xx＝xp+i；

     zz＝1024；    zz*＝y_offset；  zz+＝xx；    mem+＝zz；

     if(i！＝0)

             {

             *mem＝*cross_buf；    cross_buf++；
             }

       }
}
grey_level_show()
{
int i，j，grey；
float g；
for(j＝0；j＜480；j++)

    {

    g＝j；  g*＝255；  g/＝480；    grey＝g；

    for(i＝610；i＜640；i++)

             {

             point_show(i，j，grey)；

             }

       }
number_display(0，578，6，7，9，255)；    line_show(567，0，571，0，255)；

                                          line_show(606，0，609，0，255)；
number_display(3，578，60，7，9，255)；
number_display(1，587，60，7，9，255)；

                                          line_show(567，60，571，60，255)；

                                          line_show(606，60，609，60，255)；
number_display(6，578，120，7，9，255)；
number_display(3，587，120，7，9，255)；

                                          line_show(567，120，571，120，255)；

                                          line_show(606，120，609，120，255)；
number_display(9，578，180，7，9，255)；
number_display(5，587，180，7，9，255)；

                                          line_show(567，180，571，180，255)；

                                          line_show(606，180，609，180，255)；
number_display(1，578，240，7，9，255)；
number_display(2，587，240，7，9，255)；
number_display(7，596，240，7，9，255)；

                                          line_show(567，240，571，240，255)；

                                          line_show(606，240，609，240，255)；
number_display(1，578，300，7，9，255)；
number_display(5，587，300，7，9，255)；
				
				<dp n="d36"/>
number_display(9，596，300，7，9，255)；

                                         line_show(567，300，571，300，255)；

    　　　　　　　　　　　　　　　　　　 line_show(606，300，609，300，255)；
number_display(1，578，360，7，9，255)；
number_display(9，587，360，7，9，255)；
number_display(1，596，360，7，9，255)；

    　　　　　　　　　　　　　　　　　　 line_show(567，360，571，360，255)；
   　　　　　　　　　　　　　　　　　　　line_show(606，360，609，360，255)；
number_display(2，578，420，7，9，255)；
number_display(2，587，420，7，9，255)；
number_display(3，596，420，7，9，255)；
　　　　　　　　　　　　　　　　　　　　 line_show(567，420，571，420，255)；

    　　　　　　　　　　　　　　　　　　 line_show(606，420，609，420，255)；
number_display(2，578，474，7，9，255)；
number_display(5，587，474，7，9，255)；
number_display(5，596，474，7，9，255)；

                                         line_show(567，479，571，479，255)；

    　　　　　　　　　　　　　　　　　　 line_show(606，479，609，479，255)；
}
equalize_screen(image，x，y，t1，t2)
unsigned cbar huge*image；
int x，y，t1，t2；
{
int，i，j，p，t；
long zz；
float k，b，w；
/*            function w＝[255/(t2-t1)]*(b-t1)    */
if(t1＞t2){   t＝t1；  t1＝t2；  t2＝t；  }
k＝255；      k＝(t2-t1)；
for(j＝YO-y/2；j＜YO-y/2+y；j++)

         {

         for(i＝XO-x/2；i＜XO-x/2+x；i++)

                 {

                 zz＝j-(YO-y/2)；zz*＝x；zz+＝(i-(XO-x/2))；

                         p＝*(image+zz)；

                         if(p＜＝t1)    point_show(i，j，0)；

                         if(p＞＝t2)    point_show(i，j，254)；

                         if(p＞t1 &amp;&amp; p＜t2)

                                  {

                                  b＝p-t1；    b*＝k；  p＝b；

                                  poiat_show(i，j，p)；

    　　　　　　　　　　　　　　　}

                      }

          }
printf(″\npress any key to display new color scale.\n″)；
getch()；
equalized_grey_level_show(t1，t2)；
}
equalize_mem(image，x，y，t1，t2)
				
				<dp n="d37"/>
unsigned char huge*image；
int x，y，t1，t2；
{
int i，j，t，p；
long zz；
float k，w，b；
if(t1＞t2)       {    t＝t1；  t1＝t2；  t2＝t；  }
k＝255；         k/＝(t2-t1)；
for(j＝0；j＜y；j++)

          {

          for(i＝0；i＜x；i++)

                    {

                    zz＝j；  zz*＝x；zz+＝i；

                    p＝*(image+zz)；

                    if(p＜＝t1)     *(image+zz)＝0；

                    if(p＞＝t2)     *(image+zz)＝254；

                    if(p＞t1 &amp;&amp; p＜t2)

                             {

                             w＝p-t1；    w*＝k；  p＝w；

                             *(image+zz)＝p；

                             }

                    }

          }
}
#define BASEMEM 0xD000    /*memory base address*/
#define RB 0x300 /*pcplus regster base address*/
ini_lut(void)
{
int j；
unsigned char i，ii；
/*initialize bank 0 to linear*/
outp(RB+1，0x00)；
for(j＝0；j＜＝255；j++)

          {         i＝j；

                    outp(RB+2，i)；  outp(RB+3，i)；  }
outp(RB+1，0x01)；
for(j＝0；j＜＝255；j++)

          {

                    i＝j；

                   outp(RB+2，i)；outp(RB+3，i)；  }
outp(RB+1，0x02)；
for(j＝0；j＜＝255；j++)

          {      i＝j；

                    outp(RB+2，i)；outp(RB+3，i)；  }
outp(RB+1，0x03)；
for(j＝0；j＜＝255；j++)

          {    i＝j；
				
				<dp n="d38"/>
                outp(RB+2，i)；  outp(RB+3，i)；)
/*initialize bank 4 to bit-plane-oriented */
outp(RB+1，0x82)；
for(j＝0；j＜＝255；j++)

           {    i＝j；  outp(RB+2，i)；

                ii＝0；

                if(i＜64 &amp;&amp; i＞0)                  ii＝128；

                if(i＞＝64 &amp;&amp; i＜＝128)    ii＝128-2*(i-64)；

                if(i＝＝255)             ii＝128；

                /*

                if((i &amp; 0x01)＝＝1)      ii＝36；

                if((i &amp; 0x02)＝＝2)      ii＝72；

                if((i &amp; 0x03)＝＝3)      ii＝108；

                if((i &amp; 0x04)＝＝4)      ii＝144；

                if((i &amp; 0x05)＝＝5)      ii＝180；

                if((i &amp; 0x06)＝＝6)      ii＝216；

                if((i &amp; 0x07)＝＝7)      ii＝252；

                */

                outp(RB+3，ii)；

           }
printf(″\n″)；
outp(RB+1，0x81)；
for(j＝0；j＜＝255；j++)

           {    i＝j；  outp(RB+2，i)；

                ii＝0；

                if(i＜64 &amp;&amp; i＞0)              ii＝i*2；

                if(i＞＝64 &amp;&amp; i＜192)  ii＝128；

                if(i＞＝192)           ii＝128-2*(i-192)；

                if(i＝＝254)           ii＝0；

                if(i＝＝255)           ii＝128；

                /*

                if((i &amp; 0x08)＝＝0x08) ii＝36；

                if((i &amp; 0x10)＝＝0x10) ii＝72；

                if((i &amp; 0x18)＝＝0x18) ii＝108；

                if((i &amp; 0x20)＝＝0x20) ii＝144；

　　            if((i &amp; 0x28)＝＝0x28) ii＝180；

　　            if((i &amp; 0x30)＝＝0x30) ii＝216；

　　            if((i &amp; 0x38)＝＝0x38) ii＝252；

　　            */

　　            outp(RB+3，ii)；

　　      }
printf(″\n″)；
outp(RB+1，0x80)；
for(j＝0；j＜＝255；j++)

　　      {     i＝j；  outp(RB+2，i)；

　　            ii＝0；

　　            if(i＞128 &amp;&amp; i＜192)    ii＝2*(i-128)；

　　            if(i＞＝192)            ii＝128；

　　            if(i＝＝254)            ii＝220；

　　            /*
				
				<dp n="d39"/>
 　　　　　　    if((i &amp; 0x40)＝＝0x40)  ii＝85；

　　　　　　　 　if((i &amp; 0x80)＝＝0x80)  ii＝170；
 　　　　　　　  if((i &amp; 0xc0)＝＝0xc0)  ii＝255；
   　　　　 　　 */

　　             outp(RB+3，ii)；

　　             }
}
ini_reg(void)
{
outp(RB，0x16)；outp(RB+1，3)；outp(RB+2，0)；
outp(RB+3，0)；outp(RB+4，0x36)；outp(RB+5，0x02)；
outp(RB+6，0)；outp(RB+7，0)；outp(RB+8，0x40)；
outp(RB+9，0)；outp(RB+10，0)；     outp(RB+11，0)；
}
/* display a number at(x，y)，size is(size_x X size_Y)    */
number_display(number，x，y，size_x，size_y，brightness)
int number，x，y，size_x，size_y，brightness；
{
int hx，hy，i，j，b；
b＝brightness；hx＝size_x/2；  hy＝size_y/2；
switch(number)
{
case 0：line_show(x-hx，y-hy，x+hx，y-hy，b)；

　　    line_show(x-hx，y-hy，x-hx，y+hy，b)；

　　    line_show(x-hx，y+hy，x+hx，y+hy，b)；

　　    line_show(x+hx，y-hy，x+hx，y+hy，b)；

　　    break；
case 1：line_show(x，y-hy，x，y+hy，b)；

　　    break；
case 2：line_show(x-hx，y-hy，x+hx，y_hy，b)；

　　    line_show(x+hy，y-hy，x+hx，y，b)；

　　    line_show(x+hy，y，x-hx，y，b)；

　　    line_show(x-hx，y，x-hx，y+hy，b)；

　　    line_show(x-hx，y+hy，x+hx，y+hy，b)；

　   　 break；
case 3：line_show(x-bx，y-hy，x+hx，y-hy，b)；

　　    line_show(x+hx，y-hy，x+hx，y+hy，b)；

　　    line_show(x-hx，y，x+hx，y，b)；

　　    line_show(x-hx，y+hy，x+hx，y+hy，b)；

　  　  break；
case 4：line_show(x-hx，y-hy，x-hx，y，b)；

　　    line-show(x-hx，y，x+hx，y，b)；

　　    line_show(x+hx，y-hy，x+hx，y+hy，b)；

　　    break；
				
				<dp n="d40"/>
case 5：line_show(x-hx，y-hy，x+hx，y-hy，b)；

　　    line_show(x-hx，y-hy，x-hx，y，b)；

　　    line_show(x-hx，y，x+hx，y，b)；

　　    line_show(x+hx，y，x+hx，y+hy，b)；

　　    line_show(x-hx，y+hy，x+hx，y+hy，b)；

　　    break；
case 6：line_show(x-hx，y-hy，x+hx，y-hy，b)；

　　    line_show(x-hx，y-hy，x-hx，y+hy，b)；

　　    line_show(x-hx，y，x+hx，y，b)；

　　    line_show(x-hx，y+hy，x+hx，y+hy，b)；

　　    line_show(x+hx，y，x+hx，y+hy，b)；

　　    break；
case 7：line_show(x-hx，y-hy，x+hx，y-hy，b)；

　　    line_show(x+hx，y-hy，x+hx，y+hy，b)；

　　    break；
case 8：line_show(x-hx，y-hy，x+hx，y-hy，b)；

　　    line_show(x-hx，y，x+hx，y，b)；

　　    line_show(x-hx，y+hy，x+hx，y+hy，b)；

　　    line_show(x-hx，y-hy，x-hx，y+hy，b)；

　　    line_show(x+hx，y-hy，x+hx，y+hy，b)；

　　    break；
case 9：line_show(x-hx，y-hy，x+hx，y-hy，b)；

　　    line_show(x-hx，y，x+hx，y，b)；

　　    line_show(x-hx，y+hy，x+hx，y+hy，b)；

　　    line_show(x-hx，y-hy，x-hx，y，b)；

　　    line_show(x+hx，y-hy，x+hx，y+hy，b)；

　　    break；
}
}
histogram_image(image，x，y，hist)
unsigned char huge*image；
int x，y；
long *hist；
{
int，i，j，z；
long zzz；
for(i＝0；i＜256；i++)    *(hist+i)＝0；
for(j＝0；j＜y；j++)

　　      for(i＝0；i＜x；i++)

　　                {

　　                zzz＝j；zzz*＝x；zzz+＝i；

　　                z＝*(image+zzz)；

　　                *(hist+z)+＝1；

　　                }
}
show_hist_vertical(hist)
long，*hist；
{
				
				<dp n="d41"/>
int i，ii，j，a，d；
float max，rate，g，gg；
double buf；
max＝0；/* ii＝0*/
for(i＝0；i＜256；i++)

　　      if(*(hist+i)＞max)    {    max＝*(hist+i)；/*    ii＝i；*/}
rate＝34/max；  a＝max；
/*
printf(″max＝％d，grey level＝％d.\n″，a，ii)；
*/
line_show(566，0，566，470，255)；
g＝479；g/＝255；
for(i＝0；i＜256；i++)

　　      {

　　      buf＝*(hist+i)；buf*＝rate；

　　      if(buf＞0 &amp;&amp; buf＜2)  a＝2；

　　      else                  a＝buf；

　　      gg＝i*g；      d＝gg；

　　      line_show(566-a，d，567，d，255)；

　　      }
}
/* get digits from a integer，nd is the number of the digits*/
integer_to_digit(integer，nd，d)
int integer，nd，*d；
{
int i，n；
n＝integer；
for(i＝0；i＜nd；i++)
    　　  {

　　      n/＝10；n*＝10；*(d+i)＝integer-n；    integer/＝10；  n/＝10；

　　      }
}
equalized_grey_level_show(t1，t2)
int t1，t2；
{
int，i，j，grey，d[3]，t；
float g，dt；
dt＝t2-t1；    dt/＝8；
for(j＝0；j＜480；j++)

　　      {

　　      g＝j；    g*＝255；    g/＝480；    grey＝g；

　　      for(i＝610；i＜640；i++)

　　               {

　　               point_show(i，j，grey)；

　　               }

　　      }
for(j＝0；j＜480；j++)

　　      for(i＝532；i＜610；i++) point_show(i，j，0)；
line_show(567，0，567，480，255)；
				
				<dp n="d42"/>
t＝t1；
integer_to_digit(t，3，&amp;d[0])；
number_display(d[2]，578，6，7，9，255)；
number_display(d[1]，587，6，7，9，255)；
number_display(d[0]，596，6，7，9，255)；

　　                                        line_show(567，0，571，0，255)；

　　                                        line_show(606，0，609，0，255)；
for(i＝60；i＜＝420；i+＝60)
{
j＝i/60；
t＝t1+j*dt；
integer_to_digit(t，3，&amp;d[0])；
number_display(d[2]，578，i，7，9，255)；
number_display(d[1]，587，i，7，9，255)；
number_display(d[0]，596，i，7，9，255)；

　　                                       line_show(567，i，571，i，255)；

　　                                       line_show(606，i，609，i，255)；
}
/*
t＝t1+2*dt；
integer_to_digit(t，3，&amp;d[0])；
number_display(d[0]，578，120，7，9，255)；
number_display(d[1]，587，120，7，9，255)；
number_display(d[2]，596，120，7，9，255)；

　　                                       line_show(567，120，571，120，255)；

　　                                       line_show(606，120，609，120，255)；
t＝t1+3*dt；
integer_to_
number_display(9，578，180，7，9，255)；
number_display(5，587，180，7，9，255)；

　　                                       line_show(567，180，571，180，255)；

　　                                       line_show(606，180，609，180，255)；
number_display(1，578，240，7，9，255)；
number_display(2，587，240，7，9，255)；
number_display(7，596，240，7，9，255)；
                                 　　      line_show(567，240，571，240，255)；

　　                                       line_show(606，240，609，240，255)；
number_display(1，578，300，7，9，255)；
number_display(5，587，300，7，9，255)；
number_display(9，596，300，7，9，255)；

　　                                       line_show(567，300，571，300，255)；

　　                                       line_show(606，300，609，300，255)；
number_display(1，578，360，7，9，255)；
number_display(9，587，360，7，9，255)；
number_display(1，596，360，7，9，255)；

　　                                       line_show(567，360，571，360，255)；

　　                                       line_show(606，360，609，360，255)；
number_display(2，578，420，7，9，255)；
number_display(2，587，420，7，9，255)；
number_display(3，596，420，7，9，255)；

　　                                       line_show(567，420，571，420，255)；

　　                                       line_show(606，420，609，420，255)；
*/
t＝t2；
integer_to_digit(t，3，&amp;d[0])；
				
				<dp n="d43"/>
number_display(d[2]，578，474，7，9，255)；
number_display(d[1]，587，474，7，9，255)；
number_display(d[0]，596，474，7，9，255)；

　　                                          line_show(567，479，571，479，255)；

　　                                          line_show(606，479，609，479，255)；
}
/* the PSF is a image file*/
/*     maximum neighbor：I＝c2[O(i)-c1 max(s1*O(j-1)，s1*O(j+1))]  */
/*

　　   convolution：  I＝H*O；
NO！   deconvolution：O(n)＝O(n-1)-a(I-O(n-1)*H)；
*/
/*modified maxnb2.c，after convolution，the convolved image will be saved
into hard disk，the memory requirement can be reduced，the saved cenvolved
images will be named after original image with wild card’.cv1’and’.cv2’*/
#include″ypdef.h″
#include＜stdio.h＞
#include＜alloc.h＞
#include＜dos.h＞
#include＜math.h＞
#define XO 320
#define YO 240
/*
void deconvolution(double huge*im，double huge *ob，int x，int y，

　　    double huge *h，int hx，int hy)；
*/
void convolution(unsigned char huge*im，double huge*ob，int x，int y，

　　    double huge *h，int hx，int hy)；
void matrix_sub(double huge *a，double huge*b，double huge*c，int x，int y)；
void matrix_scale(double huge *a，int x，int y，float c)；
void readdat_double(char datfile[30]，double huge*c，long size)；
void savedat_double(char datfile[30]，double huge*c，long size)；
void image_show_double(double huge*img，int sx，int sy，int x，int y)；
main()
{
char cname[30]，uname[30]，lname[30]，hname1[30]，hname2[30]，outname[30]，

    convname1[30]，convname2[30]；
unsigned char huge *im1；
unsigned char huge *im2；
unsigned char huge *im3；
double huge *im；
double huge *h1；
double huge *h2；
double max1，max2，weight1，weight2；
float kx，ky，xb，yb，pp1，pp2，c1，c2；
unsigned int xx，yy；
int hx，hy，x，y，i，j，redo，pp，p1，p2；
char sv；
long zz，size；
				
				<dp n="d44"/>
unsigned char huge *psf1；
unsigned char huge *psf2；
printf(″％lu bytes free in ram.\n″，farcoreleft())；
printf(″center，upper，lower image names，：″)；
scanf(″％s ％s ％s″，cname，uname，lname)；    printf(″\n″)；
printf(″up/low PSF image name：″)；
scanf(″％s ％s″，hname1.hname2)；              printf(″\n″)；
im1＝(unsigned char huge*)read_image(uname，&amp;x，&amp;y)；
image_show(im1，0，0，x，y)；
psf1＝(unsigned char huge*)read_image(hname1，&amp;hx，&amp;hy)；
psf2＝(unsigned char huge*)read_image(hname2，&amp;hx，&amp;hy)；
size＝x；       size*＝y；
im＝(double huge*)farcalloc(size，sizeof(double))；
/*
ob＝(double buge*)farcalloc(size，sizeof(double))；
*/
size＝hx；    size*＝hy；
h1＝(double huge*)farcalloc(size，sizeof(double))；
h2＝(double huge*)farcalloc(size，sizeof(double))；
for(zz＝0；zz＜size；zz++)

　　    {         *(h1+zz)＝*(psf1+zz)；  *(h2+zz)＝*(psf2+zz)；  }
weight1＝weight2＝0；
for(zz＝0；zz＜size；zz++)

　　    {

　　    if(*(h1+zz)＜0)*(h1+zz)*＝-1；

　　    if(*(h2+zz)＜0)*(h2+zz)*＝-1；

　　    weight1+＝*(h1+zz)；

　　    weight2+＝*(h2+zz)；

　　    }
printf(″\nweight＝％lf.\n″，weight1)；
for(zz＝0；zz＜size；zz++)

　　    {

　　    *(h1+zz)/＝weight1；  *(h2+zz)/＝weight2；

　　    printf(″％lf″，*(h1+zz))；

　　    }
/*    
if(im＝＝NULL||ob＝＝NULL)

　　    {

　　    printf(″no enough memory.\n″)；

　　    exit()；

　　    }
else

　　    printf(″％lu bytes allocated.\n″，size)；
*/
printf(″\n″)；
for(j＝0；j＜y；j++)

　　      for(i＝0；i＜x；i++)

　　                {
				
				<dp n="d45"/>
　　             zz＝j；  zz*＝x；  zz+＝i；

　　             *(im+zz)＝*(iml+zz)；

　　             }
convolution(im1，im，x，y，h1，hx，hy)；
/*
image_show_double(im，0，y，x，y)；
*/
strcpy(convname1，uname)；    strcat(convname1，″.cv1″)；
save_image(convname1，XO-x/2，YO-y/2，XO-x/2+x-1，YO-y/2+y-1)；
im2＝(unsigned char huge*)read_image(lname，&amp;x，&amp;y)；
image_show(im2，x，0，x，y)；
for(j＝0；j＜y；j++)

　　      for(i＝0；i＜x；i++)

　　      (

　　      zz＝j；  zz*＝x；  zz+＝i；

　　      *(im+zz)＝*(im2+zz)；

　　      }
convolution(im2，im，x，y，h2，hx，hy)；
strcpy(convname2，lname)；             strcat(convname2，″.cv2″)；
save_image(convname2，XO-x/2，YO-y/2，XO-x/2+x-1，YO-y/2+y-1)；
farfree((double far*)im)；
im3＝(unsigned char huge*)read_image(cname，&amp;x，&amp;y)；
image_show(im3，2*x，0，x，y)；
do{
printf(＂\ninput c1，c2：″)；    scanf(″％f ％f″，&amp;c1，&amp;c2)；    printf(″\n″)；
for(j＝0；j＜；j++)

　　      for(i＝0；i＜x；i++)

　　                {

　　                zz＝j；  zz*＝x； zz+＝i；

　　                p1＝*(im1+zz)；p2＝*(im2+zz)；

　　                pp1＝(p1＞p2)？p1：p2；  pp1*＝c1；

　　                pp2＝*(im3+zz)；

　　                pp2-＝pp1；    pp2*＝c2；

　　                if(pp2＜0)     pp2＝0；
　　                if(pp2＞255)   pp2＝255；

　　                pp＝pp2；

　　                point_show(XO-x/2+i，YO-y/2+j，pp)；

　                　}
printf(″OK？(y)″)；
}while(getche()！＝‘y’)；
primtf(″\nsave image？(y)″)；
if(getche()＝＝‘y’)

　　     {

　　     printf(″\noutput image name：″)；

　　     scanf(″％s″，outname)；printf(″\n″)；

　　     save_image(outname，XO-x/2，YO-y/2，XO-x/2+x-1，YO-y/2+y-1)；

　　     }
printf(″\n″)；
}
/*

　　     deconvolution：
				
				<dp n="d46"/>
               O(n)＝O(n-1)-a(I-O(n-1)*H)；
void deconvolution(double huge*im，double huge*ob，int x，int y，

        double huge *h，int hx，int hy)
{
int i，j，p，k1，k2；
long zz，z；
double huge *c；
zz＝x；zz*＝y；
c＝(double huge*)farcalloc(zz，sizeof(double))；
for(j＝0；j＜y；j++)

          for(i＝0；i＜x；j++)

                    {

                    zz＝j；zz*＝x；zz+＝i；

                    *(ob+zz)＝*(im+zz)；

                    }
for(i＝0；i＜1；i++)

          {

          printf(″\n---％d\n″，i)；

          convolution(c，ob，x，y，h，hx，hy)；

          image_show_double(c，0，0，x，y)；

          matrix_sub(im，c，c，x，y)；

          image_show_double(c，x+10，0，x，y)；

          matrix_scale(c，x，y，1.2)；

          matrix_sub(ob，c，ob，x，y)；
          matrix_scale(ob，x，y，0.9)；

          image_show_double(ob，2*(x+10)，0，x，y)；

          }
farfree((double far*)c)；
}
*/
/*

       convolution：    1M＝OB*H；

                        IM and OB have the same dimension(x，y)，

                        H’s dimension is(hx，hy)，if hx or hy is even

                        number it will be minus 1.
*/
void convolution(unsigned char huge *img，double huge *ob，int x，int y，

        double huge *h，int hx，int hy)
{
int hhx，hhy，i，j，k1，k2，yy，p；
double c，c1，c2；
long z1；
hhx＝(hx-1)/2；  hhy＝(hy-1)/2；
z1＝hhy；    z1*＝hx；    z1+＝hhx；
h+＝z1；
if(y＞36)    yy＝y/3；
				
				<dp n="d47"/>
else               yy＝y；
for(i＝0；i＜yy；i++)    printf(″_″)；    printf(″\r″)；
for(j＝0；j＜y；j++)

          {

          if(y＝＝xx)    printf(″+″)；

          else           if(j＝＝(j/3)*3)  printf(″+″)；

          for(i＝0；i＜x；i++)

                    {

                    z1＝j；  z1*＝x；z1+＝i；

                    c＝0；

                    for(k2＝-hhy；k2＜＝hhy；k2++)

                            for(k1＝-hhx；k1＜＝hhx；k1++)

                                    if((j+k2)＞＝0 &amp;&amp; (j+k2)＜y &amp;&amp;(i+k1)＞＝0 &amp;&amp;(i+k1)＜x)

                                           {

                                           c1＝*(ob+z1+k2*x+k1)；

    　　　　　　　　　　　　　　　　　　　 c2＝*(h+k2*hx+k1)；

                                           c+＝(c1*c2)；

                                           }

                p＝c；

                *(img+z1)＝p；

                point_show(XO-x/2+i，YO-y/2+j，p)；

                }

        }
}
void matrix_sub(double huge*a，double huge*b，double huge*c，int x，int y)
int i，j；
for(j＝0；j＜y；j++)

    　　　for(i＝0；i＜x；i++)

          {

          *c＝*a-*b；    a++；  b++；  c++；

          }
}
void matrix_scale(double huge*a，int x，int y，float c)
{
int，i，j；
for(j=0；j＜y；j++)

         for(i＝0；i＜x；i++)

                 {    (*a)*＝c；    a++；  }
}
#define SPEC_RANG 16
void savedat_double(char datfile[30]，double huge*c，long size)
{
FILE *fp；
double *buf；
int fnum，bufsize，i，j；
char fname[30]，s0[30]；
bufsize＝SPEC_RANG*16；
fnum＝size/bufsizc；
				
				<dp n="d48"/>
if(NULL＝＝(buf＝(double*)calloc(bufsize，sizeof(double))))

      {

      printf(″no enough memory，exit.\n″)；    exit(1)；

      }
for(i＝0；i＜fnum；i++)

      {

      for(j＝0；j＜bufsize；j++)

                {

                *(buf+j)＝*c；    c++；

                }

      itoa(i，s0，10)；

      strcpy(fname，datfile)；

      strcat(fname，s0)；

      if((fp＝fopen(fname，″wb″))＝＝NULL)

               {

               printf(″data file open failure.\n″)；

               exit(1)；

               }

      fwrite((double*)buf，sizeof(double)，bufsize，fp)；

      fclose(fp)；

      }
free((double*)buf)；
}
void readdat_double(char datfile[30]，double huge*c，long size)
{
FILE*fp；
double *buf；
int fnum，bufsize，i，j；
char fname[30]，s0[30]；
bufsize＝SPEC_RANG*16；
fnum＝size/bufsize；
if(NULL＝＝(buf＝(double*)calloc(bufsize，sizeof(double))))

      {

      printf(″no enough memory，exit.\n″)；exit(1)；

      }
for(i＝0；i＜fnum；i++)

      {

      itoa(i，s0，10)；

      strcpy(fname，datfile)；

      strcat(fname，s0)；

      if((fp＝fopen(fname，″rb″))＝＝NULL)

               {

               printf(″data file open failure.\n″)；

               exit(1)；

               }

      fread((double*)buf，sizeof(double)，bufsize，fp)；

      fclose(fp)；

      for(j＝0；j＜bufsize；j++)

                {    *c＝*(buf+j)；           c++；

                }

      }
free((double*)buf)；
}
				
				<dp n="d49"/>
void image_show_double(double huge *img，int sx，int sy，int x，int y)
{
int k1，k2，p；
long zz；
for(k2＝0；k2＜y；k2++)

        for(k1＝0；k1＜x；k1++)

                {

                zz＝k2；zz*＝x；zz+＝k1；

                p＝*(img+zz)；  if(p＜0)p＝-p；  if(p＞255)p＝255；

                point_show(sx+k1，sy+k2，p)；

                }
}
/*........image division，can save results as float number.........*/
#include″ypdef.h″
#include＜stdio.h＞
#include＜dos.h＞
#include＜alloc.h＞
#define BASEMEM 0xD000
#define CONREG 0x300
main()
{
char imgname1[50]，imgname2[50]，outname[50]，ffile[50]；
unsigned char huge *image；
unsigned char huge *board；
unsigned char huge *p；
int choice，c，i，j，x，y，ws，wrongname，pp，ppp；
long size，zz；
int n；
float s.p1，p2，p3；
FILE *fp；
/*read an image from disk into memory*/
printf(″％lu bytes free in ram.\n″，farcoreleft())；
printf(″div.＝(image1/image2)*scale_factor.\n″)；
printf(″the names of image1，image2，scale_factor：″)；
scanf(″％s ％s ％f″，imgname1，imgname2，&amp;s)；          printf(＂\n″)；
printf(″do you want to save division results as float number：(y)″)；
if(getche()＝＝‘y’)

         {

         printf(″\nfloat data file name：″)；

         scanf(″％s″，ffile)；    printf(″\n″)；

         }
fp＝fopen(ffile，″wb″)；
image＝(unsigned char huge*)read_image(imgname1，&amp;x，&amp;y)；
printf(″display imagel，\n″)；
image_show(image，0，0，x，y)；
farfree((unsigned char far*)image)；
p＝(unsigned char huge*)farcalloc(1，1)；
image＝(unsigned char huge*)read_image(imgname2，&amp;x，&amp;y)；
for(j＝0；j＜y；j++)
				
				<dp n="d50"/>
    for(i＝0；i＜x；i++)

              {

              zz＝j；  zz*＝x；  zz+＝i；

              get_point_value(i，j，p)；  pp＝*p；p1＝pp；

              ppp＝*(image+zz)；                p2＝ppp；

              p3＝(p1/p2)；

              fwrite(&amp;p3，sizeof(float)，1，fp)；

              p3*＝s；    pp＝p3；

              if(pp＞255)    pp＝255；

              point_show(i，j，pp)；

              }
fclose(fp)；
printf(″save image？(y)：″)；
if(getche()＝＝‘y’)

         {

         printf(″\noutput image name：″)；

         scanf(″％s″，outname)；     printf(＂\n″)；

         save_image_screen(outname，0，0，x-1，y-1)；

         }
}
save_image_screen(imname，x1，y1，x2，y2)
char imname[50]；
int x1，y1，x2，y2；
{
int wrongname，i，j，x，y，k，start_line，end_line，start_blc，end_blc，

        start_y_offset，end_y_offset；
unsigned char huge *mem；
unsigned char huge *mem_keep；
unsigned char ini_stat，stat；
unsigned char p；
long zz；
FILE*fp；
char ix[8]，iy[8]；
do{
wrongname＝0；
if((fp＝fopen(imname，″wb″))＝＝NULL)

         {

         wrongname＝1；

         printf(″wrong name！try again：″)；

         scanf(″％s″，imname)；     printf(″\n″)；

         }
}while(wrongname＝＝1)；
mem＝(unsigned char huge*)MK_FP(BASEMEM，0)；
x＝x2-x1+1；       y＝y2-y1+1；
itoa(x，ix，10)；  itoa(y，iy，10)；
for(i＝0；i＜8；i++)    fputc(ix[i]，fp)；
for(i＝0；i＜8；i++)    fputc(iy[i]，fp)；
start_blc＝y1/64；         end_blc＝(y2+1)/64；
start_y_offset＝y1％64；     end_y_offset＝(y2+1)％64；
mem_keep＝mem+x1；
zz＝start_y_offset；    zz*＝1024；    zz+＝x1；
mem+＝zz；
				
				<dp n="d51"/>
    ini_stat＝0x16；

    for(i＝start_blc；i＜＝end_blc；i++)

             {

             stat＝(i＜＜5)&amp;0xe0；

             stat｜＝ini_stat；

             outp(CONREG，stat)；

             if(i＝＝start_blc)      start_line＝start_y_offset；

                     else       start_line＝0；

             if(i＝＝end_blc)end_line＝end_y_offset；

                      else       end_line＝64；

             for(j＝start_line；j＜end_line；j++)

                      {

                      for(k＝0；k＜x；k++)

                             {

                             p＝*mem；    fputc(p，fp)；

                             mem++；

                              }

                      mem+＝(1024-x)；

                      }

                mem＝mem_keep；

                }
printf(″------a ％d X ％d image ％s is saved.\n″，x，y，imname)；
}
#include＜stdio.h＞
#include＜alloc.h＞
#include＜dos.h＞
#define BP 0x3F8  /* for coml.baseport register address*/
#define CONREG 0x300      /*pcplus regster base address*/
unsigned char huge *read_image(char imname{30}，int *x，int *y)：
void image_show(unsigned char huge *im_ad，int sx，int sy，int x，int y)；
main()
{
int x，y，sx，sy；
char imname[30]；
unsigned char huge*mem；
       printf(″％lu bytes free.\n″，farcoreleft())；

       printf(″input image file name，upper-left corner(sx，sy)：″)；

       scanf(″％s ％d ％d″，imname，&amp;sx，&amp;sy)；        printf(＂\n″)；

       mem＝(unsigned char huge*)read_image(imname，&amp;x，&amp;y)；

       image_show(mem，sx，sy，x，y)；

       printf(＂\n″)；
}

Claims

1.应用荧光寿命由给定的分析物淬灭的荧光试剂物质测定此分析物在一种粘性媒质中的浓度的方法，包括下述步骤：

(a)引入荧光寿命(τ)由给定分析物淬灭的荧光试剂物质至粘性媒质中，在该粘性媒质中，此荧光试剂分子自由进行布朗转动且此淬灭剂分析物的浓度有待确定；

(b)以能为荧光试剂物质强吸收的波长下的连续线偏振光照射上述媒质，产生出具有平行于和垂直于激励光偏振面的矢量分量的荧光；

(c)将来自上述被照射媒质发射的荧光分解成平行于和垂直于激励光偏振面的矢量分量；

(d)计算所照射的媒质在空间或时间中的荧光各向异性；以及

(e)应用使荧光各向异性与淬灭剂分析物浓度相关联的表现为方程形式的数学函数。

2.如权利要求1所述的应用荧光试剂物质的方法，它还包括选择下述方程的步骤：

τ = \frac{τ_{0}}{1 + K_{D} [Q]} - - - - (1)

式中〔Q〕是淬灭剂物质浓度，K_D是动态淬灭常数，而τ_o是不存在淬灭剂时的荧光寿命。

3.如权利要求1所述的应用荧光试剂物质的方法，它还包括选用下述方程的步骤：

[Q] = \frac{A_{0} - A (6 {\overset{&OverBar;}{R} τ}_{0} + 1)}{K_{D} (A - A_{0})} - - - - (2)

式中A为荧光各向异性，定义为

A = \frac{I_{1} G - I_{&perp;}}{I_{1} G + I_{&perp;}}

其中I₁和I_是以其电矢量分别平行于和垂直于线偏振激发辐射矢量的荧光发射强度，G是用来校正在此平行和垂直平面内传输效率的经验校正系数，R是平均分子转动时间，以弧度/秒表示，A₀是不存在布朗转动时“冻结”态中的荧光各向异性，K_D是动态淬灭常数，τ₀是不存在淬灭剂时的荧光寿命，而〔Q〕是待测的淬灭剂的浓度。

4.如权利要求1、2与3中任一项所述的应用荧光试剂物质的方法，其中所述淬灭物质是分子态氧。

5.如权利要求1或2中任一项所述的应用荧光试剂物质的方法，其中所述淬灭物质是分子氧并选择下述方程

式中〔Q₂〕是氧浓度，PO₂是氧分压，α是本生溶解度系数，K_D是动态淬灭常数，而τ₀是不存在O₂时的荧光寿命.

6.如权利要求1、3、4或5中任一项所述的应用荧光试剂物质的方法，它还包括选择下述方程的步骤：

P O_{2} = \frac{A_{0} - A (6 \overset{&OverBar;}{R} τ_{0} + 1)}{α K_{D} (A - A_{0})} - - - - (4)

式中A是是荧光各向异性，R是平均分子转动时间，以弧度/秒表示，A₀是在不存在布朗转动时于“冻结”态下的荧光各向异性，α是本生溶解度系数，K_D是动态淬灭常数，τ₀是不存在O₂时的荧光寿命，而PO₂是分子氧的分压。

7.如权利要求1所述的应用荧光试剂物质测定本身并非试剂物质荧光寿命淬灭剂的分析物的方法，包括下述步骤：

(a)使荧光试剂分子与对于此分析物有高度亲和性的载体结合，并把此种载体加到载体可在其中自由进行布朗转动的粘性媒质中；

(b)向上述媒质中加入数量已知的分析物，此分析物与淬灭剂或与载体上试剂分子荧光能量的能量转移受主结合；

(c)向上述媒质加入含有未知量的分析物的待分析试样中；

(d)用被结合到载体上的荧光试剂物质强吸收波长下的连续线偏振光照射上述媒质，形成具有平行于和垂直于此激励光偏振面的矢量分量的荧光；

(e)把由被照射媒质发射出的荧光分解成平行于和垂直于此激励光偏振面的矢量分量；

(f)计算被照射媒质在空间或时间上的荧光各向异性；以及

(g)应用使荧光各向异性与试样中分析物浓度相关联的经验确定的数学函数。

8.如权利要求4、5或6中任一项所述的应用荧光试剂物质的方法，其中测定了成像组织与血管中组织或血中PO₂的几何形态分布。

9.如权利要求8所述的应用荧光试剂物质的方法，其中有生物相容性的荧光试剂物质聚集于组织的双层脂膜与红血球膜中。

10.如权利要求8所述的应用荧光试剂物质的方法，其中的荧光试剂物质与分子质量大的蛋白质结合并保留于成像组织的血管中或保持于不同于血液的体液中。

11.如权利要求8所述的应用荧光试剂物质的方法，其中生物相容性的脂溶性荧光试剂物质为芘丁酸或其盐的形式。

12.如权利要求8所述的应用荧光试剂物质的方法，其中的脂溶性荧光试剂物质是以溶液形式通过静脉注入。

13.如权利要求8所述的应用荧光试剂物质的方法，其中脂溶性荧光试剂物质是结合在脂质体中经静脉注入的。

14.如权利要求8所述的应用荧光试剂物质的方法，其中的生物相容性的脂溶性荧光试剂物质是以溶液形式局部应用。

15.如权利要求1、2、3、4、5、6或7中任一项所述的应用荧光试剂物质的方法，其中，荧光试剂物质，粘性物质以及任何与淬灭剂或能量转移受主结合的其它物质可透过分析物的薄膜与此分析物分开，从而可构成一光学传感器。

16.如权利要求15所述的应用荧光试剂物质的方法，其中，荧光试剂物质选定为溶解于非极性溶剂中的芘而分析物是分子氧。

17.如权利要求15所述的应用荧光试剂物质的方法，其中，荧光试剂物质选定为溶解于非极性溶剂中的芘丁酸或其盐的形式，而分析物是分子氧。

18.如权利要求15、16或17中任一项所述的应用荧光试剂物质的方法，它还包括借助单模保偏振玻璃光纤，由线偏振光照射传感器成份的步骤。

19.如权利要求15、16、17或18中任一项所述的应用荧光试剂物质的使用方法，它还包括选择带传感器构成端部和根据方程(4)对于此传感器端部的温度来校正各向异性测量的热敏电阻的步骤：

\frac{A_{0}}{A} = \frac{1 + R_{g} T}{ηV} τ - - - - (5)

式中Rg是气体常数、T是温度、η是粘度、V是荧光团的流体动态体积、A是荧光各向异性、A₀是不存在布朗转动时“冻结”态下的荧光各向异性，而τ是荧光寿命。

20.如权利要求18所述的应用荧光试剂物质的方法，它还包括选择由单模保偏振玻璃光纤束构成的一批传感器的步骤，用以测定分析物在待测表面内的空间分布。

21.如权利要求1、2、3、4、5或6中任一项所述的应用荧光试剂物质的方法，其中，组织的或流体PO₂的或其它分析物的浓度在几何形态上的分布，是在成像组织的体积内由光学层析方法，进行光学切片分析测定的。

22.如权利要求21所述的应用荧光试剂物质的方法，其中，光学层析法是共焦显微法。

23.如权利要求21所述的应用荧光试剂物质的方法，其中的光学层析法是数字重叠合法。

24.如权利要求1、2、3、15、18、19或20中任一项所述的应用荧光试剂物质的方法，其中荧光试剂物质是荧光素或荧光素衍生物而分析物是pH。

25.如权利要求1、2、3、15、18、19或20中任一项所述的应用荧光试剂物质的方法，其中，荧光试剂物质是奎宁而分析物是氯化物离子。

26.如权利要求1、2、3、15、18、19或20中任一项所述的应用荧光试剂物质的方法，其中的荧光试剂物质是γ-芘丁酸而分析物是碘化物离子。

27.如权利要求7所述的应用荧光试剂物质的方法，其中，分析物是蛋白质而载体是抵抗此蛋白质而产生的抗体。

28.如权利要求7或27所述的应用荧光试剂物质的方法，其中，荧光素异硫氰酸盐是与载体结合而孔雀石绿异硫氰酸盐则与数量已知的分析物结合。

29.如权利要求7所述的应用荧光试剂物质的方法，其中，载体是伴刀豆球蛋白A(ConA)而分析物是葡萄糖。

30.如权利要求7或29所述的应用荧光试剂物质的方法，其中的级联蓝与载体伴刀豆球蛋白A结合而以已知量的NBD葡糖胺用作荧光结合的分析物。

31.用于流体内或组织内测量氧浓度或分压或另一种分析物浓度的光学组件(50)，此组件顺次包括：

(a)光源(52)；

(b)激励光通过的聚光透镜(54)；

(c)使激励光起偏振的第一起偏振装置(58)；

(d)激励光滤光用的激励光滤光装置(60)；

(e)导引激励光的分光镜(62)；

(f)激励光通过其焦点的物镜(64)；

(g)固定于激励光通过的物镜焦点上的单模保偏振玻璃光纤(66)，激励光由其通过；

(h)由远部与近部组成的导管，玻璃光纤(66)的终端邻接此远部，其中的远部包括：

(i)对O₂或其它分析物敏感的端部，其包括在此端部邻近固定的石英板(72)；

(ii)安装于此端部远端的O₂或其它分析物可透过的膜(78)；

(iii)用来测量流体中氧或其它分析物浓度或分压的试剂，其中，试剂是具有荧光寿命可被分析物淬灭的物质，此试剂位于石英板(72)与膜(78)之间；以及

(iv)测温装置(80)；

(i)当激励光照射到流体或组织上时用来使从此流体或组织上发射出的荧光聚焦的物镜(64)；

(j)导引上述发射出的荧光的分光镜(62)；

(k)对此发射出的荧光进行滤光的滤光装置(82)；

(l)第二起偏振装置(84)，用来将通过滤光装置(82)的上述发射出的紫外光分成相对于第一起偏振装置(58)的平行分量(86A)与垂直分量(86B)；

(m)光探测装置(88A与88B)，分别用来探测上述发射出的荧光的平行分量与垂直分量；以及

(n)处理装置(90)，用来处理光探测装置(88A与88B)的输出；

32.如权利要求31所述组件，其中，所说的物质选自由芘丁酸与芘所构成的组中。

33.如权利要求32所述组件，其中，所说的物质溶解于非极性粘性溶剂中。

34.如权利要求31所述组件，它还包括在光纤(66)与导管的石英板(72)之间的准直透镜(70)。

35.如权利要求31所述组件，其中所说的激励光是连续的线偏振紫外光，具有偏振面和被荧光试剂物质强吸收的波长，以具有发射出相对于此激励光偏振面的平行分量与垂直分量的荧光。

36.如权利要求31所述组件，它还包括用于控制激励光的光闸装置(56)，此光闸装置位于聚光透镜(54)与第一起偏振装置(58)之间。

37.用于测量流体或组织中氧浓度或分压或另一种分析物浓度的光学组件(10)，此组件依次包括：

(a)激励光源(18)；

(b)激励光通过的聚光透镜(20)；

(c)使激励光起偏振的第一起偏振装置(24)；

(d)对激励光滤光的激励光滤光装置(26)；

(e)导引激励光的分光镜(28)；

(f)激励光通过的具有焦点的物镜(30)；

(g)包括聚光透镜与可见光源(16)的光纤照明器(14)；而

(h)此物镜(30)用来在激励光照射到流体或组织(12)上时，将此流体或组织上发射出的荧光聚焦；

(i)此分光镜(28)用来导引上述发射出的荧光；

(j)对此发射出的荧光进行滤光的滤光装置(32)；

(k)第二起偏振装置(34)，用来将此通过滤光装置(32)的发射出的荧光分解成相对于第一起偏振装置(24)的平行分量(36)与垂直分量(38)；

(l)光探测装置，分别用来探测发射出的荧光的平行分量(40A)与垂直分量(40B)；以及

(m)处理装置(42A、42B、44)，用来处理上述光学装置(40A与40B)的输出。

38.借助光学传感器测量分析物浓度的光学组件，此组件依序包括：

(a)激励光光源；

(b)聚集与导引此激励光的装置；

(c)使此激励光起偏振的第一起偏振装置；

(d)选择适当激励光波长的装置；

(e)将偏振化的激励光导引至传感器的装置；

(f)光学传感器，其中，对荧光分析物敏感的试剂物质自由地进行布朗转动；

(g)用来使此传感器试剂物质发出的荧光聚集的装置；

(h)用来选择适当波长的荧光发射光的装置；

(i)第二起偏振装置，用来将发射出的荧光分解成相对于激励光偏振面的平行分量与垂直分量；

(j)用来探测所发射出的荧光的平行分量与垂直分量的光探测装置；以及

(k)处理此光探测装置的输出的处理装置。

39.用于测量试样的粘性媒质中分析物浓度的光学组件，此组件依序包括：

(a)激励光光源；

(b)聚集与导引此激励光的装置；

(c)使此激励光起偏振的第一起偏振装置；

(d)选择适当波长激励光的装置；

(e)将已偏振化的激励光导引至试样的装置；

(f)用来聚集由试样内荧光试剂物质发出的荧光的装置；

(g)用来选择适当波长荧光发射光的装置；

(h)用来将所发射出的荧光分解成相对于激励光偏振面的平行分量与垂直分量的装置；

(i)用来探测此发射出的荧光的平行与垂直分量的光探测装置；与

(j)用来处理光探测装置输出的处理装置。

40.测量氧浓度用的成份，这种成份由生物相容性的脂溶性荧光试剂物质构成，选自由芘丁酸或它在生理上可接受的载体液体中的盐形式构成的组中。

41.如权利要求40所述的成份，其中，所说的载体液体是生理盐水或二甲亚砜。

42.测量氧组成用的成份，这种成份包括选自芘丁酸或其与脂质体结合的盐形式构成的组中的，生物相容性的脂溶性的荧光试剂物质。

43.测量氧浓度用的成份，这种成份包括选自芘丁酸或其与用作载体分子的分子质量大的蛋白质结合的盐形式构成的组中的生物相容性的脂溶性的荧光试剂物质。

44.测量氧浓度用的成份，这种成份包括可由O₂淬灭的荧光寿命在约30至135毫微秒之间的生物相容性的荧光试剂物质，以及生理上可接收的载体液体。

45.测量氧浓度用的成份，这种成份包括可由O₂淬灭的荧光寿命在约30至135毫微秒之间的，包含在脂质体内的生物相容性的脂溶性的荧光探测物质。