CN1390332A - 用来显示和分析生物学序列数据的图形用户界面 - Google Patents

Abstract

一个用来搜寻和显示生物学数据的计算机研究工具。更具体地来说,本发明为对来自不同数据库的生物学数据进行计算机处理研究提供了一个计算机研究工具,并提供了一种新颖的图形用户界面,它显著增强了生物学数据的表示,视窗和数据库的逐级查询和交叉管理。本发明可以通过众多途径予以实现,包括作为系统,设备,方法,或者计算机可读介质等等。

Description

用来显示和分析生物学序列数据的图形用户界面

描述

版权声明

本专利文件公布的一部分，包括附录，含有隶属于版权保护的材料。版权所有者不反对在本专利文件或者专利公布出现在专利商标管理局专利文件的记录中时对其进行复制，但是版权所有者保留所有的版权。

参照相关的申请

本申请要求来自美国的序列号60/154.149，归档于1999年9月14日的临时申请和序列号为09/397,335，归档于1999年9月14日美国专利申请的优先权。这里结合了它们的索引条目。

技术领域

本发明与一个用来搜索和显示生物学数据的计算机研究工具相关。更具体的来讲，本发明与一个利用新颖的图形用户界面(GUI)对来自不同数据库的生物学数据执行计算机处理研究的计算机研究工具相关，它增强了生物学数据的图形表示法，以及相关数据的逐级查询和交叉导航(navigation)管理。

背景技术

由分子生物学和遗传学中的新兴技术所产生的数以万亿计的信息都被以数字的形式存储于世界范围内计算机数据库中。实际上，每天都有大约2000个核苷酸序列被存储于公共可访问的数据库中。面对这些数额庞大的多维数据，研究人员依靠于复杂的信息系统对这些生物学信息进行寻找，总结和解释。这就导致了生物信息学这一全新科学领域的创建，它结合了生物化学，数学，以及计算机的强大因素。生物信息学允许发展新型数据库和计算技术来帮助理解编译在广大序列数据集合中的生物学涵义。

A.生物化学回顾

对于序列数据的生物学涵义的理解可以从组成蛋白质的20个氨基酸的研究开始。脱氧核糖核酸(DNA)包含了这些结构的蓝图。DNA是由非常长的称为核苷的化学分子，组成。每个核苷包括四种氮基之一：腺嘌呤(A)，胸腺嘧啶(T)，胞核嘧啶(C)又叫氧氨嘧啶，以及鸟嘌呤(G)。DNA是核糖核酸(RNA)的模板，而RNA是蛋白质的模板。如DNA一样，RNA也是由核苷组成的。每个RNA核苷包括四种氮基之一。这些氮基与DNA的氮基的不同之处仅在于尿嘧啶(U)替代了胸腺嘧啶(T)。DNA的三个核苷编译了三个RNA的核苷，而RNA的核苷又依次编译了蛋白质的氨基酸。

蛋白质是氨基酸的高分子，而这些氨基酸在物理性质上呈现出很大的多样性，因此能够发挥广泛的生物学作用(也就是以共价键结合的氨基酸聚合体)。蛋白质的结构和作用依赖于它的氨基酸序列，而这是由制造它的RNA的核苷序列决定的。因此，氨基酸序列外观上的多样性是DNA和RNA存在许许多多排列的直接结果。其主要结构就是以共价键结合在一起的氨基酸序列。次级结构是多肽的氨基酸序列的结果。这种化学键接导致可以发展特殊形状(α螺旋，β薄片)的链。第三结构是α螺旋或者β薄片的三维折叠。第四结构则是蛋白质种不同多肽之间空间上的联系。

B.序列比较

序列比较在分子生物学，遗传学和蛋白质生物学中是一个非常强有力的工具。在通常情况下，一个新的DNA序列能够编码成什么蛋白质或者它是否能够编码成某种蛋白质都是未知的。如果你把新的编码序列与所有已知序列比较的话，很有可能会发现一条类似的序列。通常经过检验就可以确定根据结构在蛋白质之间存在的相似性属于哪个级别以及其作用特性。这种确定是由比较蛋白质的氨基酸序列做出的。根据观察，给出的蛋白质的第一结构与另一个非常近似。比较同源蛋白质的第一结构(进化相关的蛋白质)可以指明蛋白质氨基酸的哪一个残基和区域对于其作用是必须的，哪一个是作用小一些的，哪一个没有任何作用。被发现与近似蛋白质机能相近的序列被称为是同源的，保存代替的或是高度保存的。有一种用来将搜索序列与数据库中的已知序列进行快速比较的工具是BLAST搜索。BLAST搜索的优点就是其发现与关系相关序列相匹配序列的能力。其缺点就是它的精确计算有可能导致工作时间的变长。

C.生物学数据库

为了执行这些序列比较，需要访问数据库中的已知生物学数据。有许多不同的数据银行(数据库)，它们之中存储着诸如DNA和蛋白质序列数据的生物学信息，这些银行包括，诸如EMBL/GENBANK(核苷序列)的通用生物学数据库，SWISSPROT(蛋白质序列)，以及PDB/Protein Data Bank(蛋白质结构)。[这里结合了一些索引，举例来说，参见Frishman等人于1998年所著的生物信息学回顾的第14卷第7章的551～561页，“全面的，易于理解的，分布式智能数据库：现状”]。特别是，GenBank是所有公共可取用DNA序列的被注释的集合。到1999年8月为止在4,610,000个序列记录中大约有3,400,000,000个基。GenBank数据库包括了日本DNA数据库(DDBJ)，欧洲分子生物学实验室(EMBL)，以及美国国家生物技术信息中心NCBI的GenBank。SWISS-PROT是一个由Geneva大学的医学生物化学系维护的被注释的蛋白质序列数据库。由Brookhaven国家实验室维护的PDB/蛋白质数据库包含了所有的公共可用来解析的蛋白质结构。这些数据库包含大量使用起来相当棘手的原始序列数据。

为了提供更实用的生物学数据的形式，现在有大量的能够把来自多个原始数据源的信息结合在一起的派生或者结构化数据库，它可以包括与序列，结构，作用，以及进化相关的关系/前后对照的数据。派生数据库通常在原始数据上包含附加的描述材料或者在一定的关系定义基础上提供新颖的数据结构化。派生/结构化数据库通常会把蛋白质序列数据分配到可用的数据集(表单)中，将蛋白质序列按照亲属或者同族谱范围将蛋白质序列分类。蛋白质族谱就是一群能够从头到尾排列并且普遍具有小于55％的差异性的序列。同源范围是由明确定义的属性集或者特征集相区别的蛋白质子序列并可能出现在至少两个不同的亚科中。

一个结构化数据库的实例就是ProDom，它是蛋白质域数据库，由同源区域的自动编辑组成。数据库被设计成一个有助于分析蛋白质的区域排列和蛋白质族谱的工具。ProDom数据库的当前版本是利用基于递归式PSI-BLAST搜索的程序建立的。ProDom包含57,976个域族谱，它们被按照族谱中蛋白质序列数目递减分门别类。ProDom是通过自动序列比较从SWISS-PORT数据库中生成的。

同样，DOMO是一个同源蛋白质域族谱的数据库。DOMO是由包括类似搜索，域描述，多序列排列，以及图形设计等连续序列分析步骤获得的。DOMO已经对来自SWISS-PORT和PIR-国际序列数据库的83,054个非冗余蛋白质序列进行了分析并将99,058个域簇的数据库生成8,877个多序列排列。

另一个派生蛋白质序列数据库是Block数据库。块是与大部分蛋白质被高度保存区域相关的多列无缝片断。Block数据库的块是由在Prosite数据库中备份的蛋白质群中寻找高度保存片断而自动建立的。接着这些块会与SWISS-PORT数据库进行校准以获得随机分布的匹配标准。

D.研究生物学数据库

生物学数据库在通常情况下是根据非结构化(关键字)或者结构化(基于域的)搜索来进行查询的。数据库的非结构化查询是通过搜索记录的关键字或者ID来执行的。举例来说，名为“ecoli”的关键字查询可以获得一个以“ecoli”作为标识的蛋白质序列列表。结构化查询则是最仔细的查询，举例来说，它允许对包含所关心的特定蛋白质序列的数据库进行查询。

一个在GenBank数据库上进行研究的著名查询工具实例是ENTREZ搜索工具，它利用关键字进行搜索。如果查询结果的采样数过多，ENTREZ允许进行新查询条件的查询来相对限制采样数。于是研究人员就可以选择显示的所有与查询相匹配的条目或者条目子集来生成报告每个选择条目的摘要页。查询结果可以以多种格式或者标准报告来显示。大多数生物学家所熟悉的GenBank报告格式显示了原始GenBank条目。其他的常见的格式包括FASTA和ASN.1。ENTREZ的基因组分类拥有基于多图阵列的图形界面。显示图像说明了一系列基因和自然图，这些图是从各种粗略排序并使用对角线连接共同特性的原始资料中公布的。

另一个查询系统是SRS(序列检索系统)，它是在多个由EMBL支持的序列数据库中在Web基础上进行查询的。SRS对来自大约40个其他序列数据库的序列信息进行前后对照，这些数据库包括容纳有蛋白质和核苷序列信息，3D结构，疾病和显型信息，以及功能信息。SRS查询允许利用公共区(举例来说，ID，AccNumber，Description)对一个或多个数据库进行结构化查询。SRS以一系列的超文本链接显示结果。搜索可以通过引进前后对照来将范围扩大到其他数据库。

现在有许多域生物学序列数据的显示和分析的专利品，包括美国专利号591632；5884230；5878373；5873052；5873052；5864488；5856928；5842151；5799301；5795716；5724605；5724253；5706498；5701256；5600826；5598350；5595877；5577249；5557535；5524240；5453937；5187775；4939666；4923808；4771384；以及4704692；以及PCT专利号WO96/23078；以上所有这些专利都被结合到这里作为参考。

E.图形用户界面(GUI)

GUI的发展和增长极大地提高了用户在查询阶段和显示信息时域生物学数据库进行交互的简便性。一个常规的GUI显示包括一个拥有一个或多个图标的桌面象征，应用程序视窗，或者其他图形对象显示。通常情况下，一个数据处理系统用户利用一个图形指示器与GUI显示进行交互，用户可以使用图形指示器设备控制它，例如鼠标，轨迹球，或者操纵杆。举例来说，根据动态应用程序或者操作系统软件所允许的动作，用户可以通过将图形指示器指向图形对象并按下与图形指示器相关的按钮来在GUI显示中选择图标或者其他图形对象。另外，用户通常可以利用众所周知的拖拽技术在桌面上重新定位图标，应用程序视窗，以及其他图形对象。通过在GUI显示中操纵图形对象，用户可以控制其下的由图形对象以图形和直观方式表示的硬件设备和软件对象。

利用多任务处理器的用户界面还允许用户同时工作于多个任务，而每个任务都被限制于其自己的显示视窗那。界面允许多个视窗在显示屏上以重叠的关系显示。用户可以在临时添加更多视窗的同时在屏幕上保留一个视窗，而添加的视窗与原有视窗完全或者部分重叠在一起。这使用户可以将注意力从第一个视窗转向一个或多个其他的视窗来获得帮助和/或参考，以便于全部用户的交互作用能够得到改善。多个动态应用程序的视窗可以同时运行。视窗经常会被(动态或者静态地)联系在一起以便于在一个视窗结果中修改查询会导致其他相关视窗的显示数据发生改变，因此使这种更改传播出去。

现在有许多与图形用户界面相关的专利。举例来说，下面与图形用户界面相关的专利，虽然不是针对于生物学数据的，但是在这里作为参考得到了引用：美国专利号5,926,806 Mar shall等人；美国专利号5,544,352 Egger；美国专利号5,777,616 Bates等人；美国专利号5,812,804 Bates等人；美国专利号5,146,556 Hullot等人；美国专利号5,893,082 McCormick；美国专利号5,815,151Argiolas；美国专利号5,911,138 Li；美国专利号5,761,656Ben-Shachar；美国专利号5,404,442 Forster等人；美国专利号5,917,492 Bereiter等人；美国专利号4,710,763 Franke等人；美国专利号5,828,376 Solimene等人；美国专利号5,748,927Stein等人；美国专利号4,452,416 Hilton等人；以及5,721,900Banning。

F.生物学数据系统的图形用户界面

如在大多数行业中一样，生物学数据的软件用户界面已经从早期的DOS文本和命令行界面演变到以用户友好方式表示数据的直观屏幕图形。为了计算和分析来自各种生物学数据库的数据序列，研究人员经常要利用图形用户界面以不同的方式来查看生物学数据，包括多序列排列(MSA)，次级结构预测，序列的二维图形表示，以及系统发育树。

多序列排列按列显示了一组序列的同源残基。在2D图形表示中，序列被显示成方框示意图的形式，其中每个方块是空间导向的。系统发育树是根据从比较蛋白质中的氨基酸序列所获得的信息建立起来的系统树。系统发育树(固定和不固定的)是同一蛋白质族谱中的独立蛋白质序列之间进化差异的图形表示法。系统发育树的分支就是来自PAM矩阵的进化经过，其中的矩阵是一种根据关系相近蛋白质之间突变率的估算可以推断其亲疏关系的进化模块。

在ProDom界面中可以发现图形用户界面良好的例子。在ProDom中对共处同一同源域的特定序列蛋白质的查询结果可以用2D表示法显示，简化图谱和树，采用MSF格式的图，以及3D结构。特别是，2D图形示意图可以通过在单行上显示每个蛋白质来表示属于同族谱关系的蛋白质域排列，它是以超文本链接到SWISS-PROT的名称为开始，接着是方框示意图2D视图，其中每个方块都超文本链接到响应的ProDom条目。

大多数这些系统的局限性在于图形显示是静态和不相关的。把用户在图形显示中无法改善或者修改搜索标准定义成静态图形显示。而把用户为特定搜索修改图形显示，而剩下对特定搜索的图形显示并不会产生相应变化定义成无关图形显示(也就是说没有扩展)。这些局限性会使得对蛋白质的分析变得麻烦和费时。另外，这些系统的复杂性由于限制用户查看所有可能的关联而造成不正确和不完全分析。

因此，有必要在该技术领域内为用户对生物学数据进行计算机处理研究的友好工具提供更有效的方法来获得和查看数据库中的相关信息。这个系统需要为表示大量离散信息提供有效的显示途径，允许研究人员着眼于最具相关性的资料并发现新的函数关系。为了充分有效地分析信息，仍然需要通过允许用户查看任何数据的相关或无关数据增加了复杂性的图形用户界面同时显示一个或多个数据库。这些显示需要被连接在一起，以便于对于位于其中一个视窗中的一个或多个条目的选择可以导致其他显示视窗可区别地显示并对其他与选择相关的条目起作用。分级查询还需要允许用户在前面查询结果的基础上迅速发现新的关系。

本发明就是为了解决这些需求而设计的。

发明公开

一般而言，本发明是一个用来搜索和显示生物学数据的计算机研究工具。具体来讲，本发明为对来自不同数据库的生物学数据执行计算机处理研究提供了一个计算机研究工具，并为显著改善生物学数据的表示法，分级查询和视窗和数据库交叉导航提供了一个新颖的图形用户界面。

本发明可以以多种途径实现，包括作为系统，设备，方法，或者一个计算机可读介质。下面将讨论本发明的多种实施方案。

作为计算机系统，本发明的实施方案包括一个含有数据表单的数据库，显示设备以及处理器单元。显示设备拥有多个显示区域(视窗)。处理器单元用于访问数据库以检索来自于相应关系表单的数据并接着在显示区域中显示所获得的数据。处理器单元还可以探测到对与某个显示区域相关的选择并随后自动修改在与该选择相关的其他显示区域所显示的数据。选择是以图形化的直观方式进行的。一定选的改变，包括比例和限制，传播出去。

作为计算机显示屏的图形用户界面(GUI)，本发明的一个具体实施方案包括一些用来搜索和显示生物学数据的显示区域(“视窗”)，这些数据都是为了方便导航而连接在一起的。这里提供了多种格式来搜索和显示生物学数据。可以根据关键字，序列列表或族谱标识符(模块ID)来进行搜索。序列搜索结果是通过图形显示的，它示出查询选择的取样序列与和它们的相关模块相关的所有族谱之间的关系。关键字搜索结果是通过图形显示的，它可以表示与当前选择目录中模块一起的拥有查询关键字的所有序列。接着，所感兴趣的模块就会被选中，这样会生成一个与模块相关族谱的摘要视窗。族谱摘要视窗的显示提供了生物学数据的二维空间导向，它包括模块(被表示成方框示意图的形式)的可视位置，所选择族谱的每个序列可以有区别地显示出来，它们的位置排列与所有那些序列中其他模块具有相同的位置排列。显示为用户提供的另一个结果是生物学数据相关的多个序列队列以及次级结构预测(Vparse，Score，PredSI，PredSec)。显示的另一个结果是为用户提供了相关的系统发育树(根(rooted)或非根的(unrooted))。显示为用户提供的另一个结果是在族谱中选择的任意数目的实际蛋白质序列信息。

作为在计算机系统的显示设上显示数据的方法，数据被从与计算机系统相连的关系数据库中获得，显示的“视窗化”能力可以提供大量的显示区域，本发明的具体实施方案包括如下操作：通过数据库连接显示区域，以便于选择可以传播出去。这个方法还包括多目录示意图，浏览整个族谱，交叉转移以及传播到所有的目录和序列，传播到整个族谱，为蛋白质函数赋值，以及根据一定变化率进行无声/迅速的缩放。

作为一个包含在计算机系统的显示设备上显示数据的程序指令计算机可读介质，数据被从与计算机系统相连的数据库中获得，拥有“视窗化”能力的显示可以提供大量的显示区域，本发明的具体实施方案包括：用来通过数据库连接显示区域以便于将选择传播出去的计算机可读代码设备，多目录视图，浏览整个族谱，较差转移地传播到所有目录和序列，传播遍及所有的族谱，为蛋白质函数赋值，以及根据一定变化率进行无声/迅速的缩放(kA/kS)。

本发明具有众多优势。本发明的一个显著优势就是它允许用户直接将由一个或多个查询得到的数据作为进行新的查询的基础。通过这种交互式和分级式的生成查询活动，就使访问所有关于给定主题的信息成为可能。结果，会发现新的数据连接和关系。用户可以比传统途径更为充分和有效地查看相关的生物学信息。

所有的专利，专利申请，临时申请，以及这里引用和参考的出版物，或者已经从中安排的优先权受益的要求，都被通过它们与本发明详述讲授不相矛盾的程度上全部引用而结合在这里的。

附图的简要描述

图1是用于生物学数据的计算机处理搜索的硬件体系结构的首选实施方案的概述。

图2描述了一个本发明的首选实施方案中采用的典型三层客户服务器模块(1层/数据库服务器，2层/应用程序服务器，3层/客户机)。

图3描述了首选三层客户机/服务器的通信模式。

图4A描述了数据库实施方案的实体关系图。

图4B描述了另一种数据库实施方案的实体关系图。

图4C描述了DNA实体关系图。

图5描述了用户连接数据库的方框图。

图6是一个本发明首选实施方案的导航流程图，它说明了所有主要的窗口和可用选项。

图7描述了目录选择的视窗的屏幕显示实例。

图8描述了按名字查询的视窗的屏幕显示实例。

图9描述了模块族谱摘要(MFS)视窗的屏幕显示实例。

图10描述了按照序列查询的视窗的屏幕显示实例。

图11描述了序列查询结果(SSR)视窗的屏幕显示实例。

图12描述了按关键字查询的视窗的屏幕显示实例。

图13描述了关键字查询结果(KSR)视窗的屏幕显示实例。

图14描述了MSA视窗的屏幕显示实例。

图15描述了进化树视窗的屏幕显示实例。

图16描述了根据序列查询中的交互式和分级查询活动的连续屏幕显示实例。

图17描述了根据关键字查询中的交互式和分级建立查询活动的连续屏幕显示实例。

图18A描述了一个目录的MFS视窗。

图18B描述了带有次级目录选择的MFS视窗和一个在此视窗中的交互式和分级查询活动的连续屏幕显示。

图19描述了当被链接到MFS视窗和MSA视窗进化树视窗的屏幕显示，这时候高亮显示的选择会传播出去。

图20描述了说明在多MFS视窗中交互和分级建立查询的屏幕显示。

首选实施方案的详细描述

现在请参照示意图，这里将描述本发明的首选实施方案。

I.体系结构

图1是一个用于生物学数据的计算机处理搜索的硬件体系结构的首选实施方案的概述。该体系结构最好是由至少两个联网的计算机处理器(客户机组件和服务器组件)以及一个用来存储生物学数据的数据库。计算机处理器可以是目前通常能够在个人台式机(包括IBM，Dell，Machintosh)，便携式电脑，大型机，小型机，或者其它计算设备中找到的处理器。在本发明的联网客户机/服务器体系结构中，最好采用典型的三层客户服务器模块，具体如图2所示(1层/数据库服务器，2层/应用程序服务器，3层/客户机)。在最佳情况下，关系数据库管理系统(RDMS)，它或者作为应用程序服务器组件的一部分或者作为单独组件(RDB机器)，提供到数据库的界面。

在首选的数据库-中央客户机/服务器体系结构中，客户机应用程序通常会从应用程序服务器请求数据和数据相关服务，而应用程序服务器会对数据库服务器发出请求。服务器(或者作为应用程序服务器机器的一部分或者作为单独的RDB/关系数据库机器)对客户机请求做出响应并提供安全的访问共享数据的路径。

II.客户机

更具体地来讲，客户机组件是能够提供大范围能力和作用来运行应用程序的最佳独立个人计算机。客户机组件可以在任何操作系统之下运行且包括通信方法，输入方法，存储方法，以及显示方法。用户通过包括键盘，鼠标，或者两者都有的输入方法向计算机处理器中输入输入命令。同样的，输入方法可以包括任何用来传送信息或者命令的设备。显示包括计算机监视器，电视，LCD，LED，或者其他任何可以向用户传达信息的方法。在首选的实施方案中，用户界面是一个在Java程序设计语言(Sun微小系统)下编写和运行并作为Java兼容的浏览器或者Java虚拟机(JVM)的图形用户界面。GUI提供复杂的导航工具来打开染色体序列之间进化关系中的包。客户机和应用程序服务器通过Java的RMI(远程方法调用)进行通信。

III.服务器

服务器组件可以是一个个人计算机，小型机，或者是大型机，它可以提供数据管理，在客户机之间共享信息，网络管理以及安全性管理。数据库服务器(RDBMS-关系数据库管理系统)和应用程序服务器可以根据需要是相同的机器不同的主机。应用程序服务器最好是一个运行在支持UNIX的平台(举例来说，Linux，Irix，Solaris)上的Java应用程序(JDK Ver.1.1或者JRE)。数据库服务器最好是支持SQL的(例如MySQL，Oracle)。应用程序服务器和数据库服务器通过由RDBMS的JDBC(Java数据库连接)驱动器包含的协议通信的。应用程序服务器最好把客户机完全隔离于任何关系数据库的概念之外，客户机的角色是(Java)对象之一，而不是关系。

本发明还为客户机和服务器预想了其他的计算装置，包括在诸如大型机，计算机集合的单个机器上处理，或者其他合适的方法。

IV.客户/服务器通信

客户机和服务器计算机协同工作来完成本发明的处理过程。客户机于服务器之间的首选协议是RMI(通过虚拟机从Java到Java通信的远程方法调用)。RMI是一个由Java核心定义的标准。

客户机与其他机器相隔离就要求所有客户机都要从其服务器上获得诸如数据库连接或者查询状态的实例，就像所有关系数据客户机的容器一样。根服务器允许通过创建服务器实例进行连接自举。由此产生的三层通信模块见图3。

V.数据库硬件

数据库最好连接到数据库服务器组件并且可以是任何容纳数据的设备。举例来说，数据库可以由用于计算机的任何类型的磁性或者光学存储设备(例如，CDROM，内部硬磁盘机，磁带机)。数据库可以位于服务器组件的远端(可以通过调制解调器或者专线进行访问)或者位于服务器组件的本地。

VI.数据库类型(关系)

数据库最好是从现有生物学数据集合和/或数据库(例如，SwissProt，GentBank)建立/驱动的关系数据库，这些数据库可以根据项目之间的关系被组织和访问。在首选实施方案中，数据库是利用标准JDBC支持机制和数据类型与SQL可兼容的。关系数据库最好由大量的表单(实体)组成。表单的行表示记录(关于独立项目的信息集合)，而表单的列表示字段(记录的具体属性)。在这个最简单的概念中，关系数据库就是通过至少一个公共字段与其他条目“相关”的数据条目的集合。

举例来说，在首选实施方案中，数据库的各个部分可以根据识别数据库中同源蛋白质序列的族谱，为每个族谱构建多序列阵列，进化树，以及树上节点的祖先序列，为编码在蛋白质族谱中的蛋白质DNA序列构建相应的多阵列，将DNA序列中提取出的无记载的突变分配给DNA进化树的每个分支，这些分支是为族谱预测的次级结构，而这些预测的次级结构根据树根的祖先序列排列的。

预测结构模块以及它们相应的祖先序列模块可以用来组织蛋白质序列数据库以提供快速查询以及序列数据库的恢复。在这种情况下，为了应用利用在这里所参考美国专利号5,958,784中公布的方法预测的次级结构模块，在蛋白质族谱的进化历史中设置了预测的模块。进化历史是由蛋白质族谱成员序列的多列，连接到这些成员的进化树，以及在整个树概率组成重建的祖先序列定义的。

在本发明中，可以通过在专业领域中同源蛋白质集合的著名方法来构建多列，进化树，树节点上的祖先序列。这三个描述的元素是互锁的，这在专业领域中是人所共知的。当前为给定树构造祖先序列首选的方法是最大节省法，如(举例来说)在商用程序MacClade[W.P.Maddison，D.R.Madison，MacClade，发展史分析和特征的进化，Sinauer协助，Sunderland Ma(1992)]实现。树是利用最大节省法或最大概似法标准在它们得分基础上进行比较的，而是在考虑分数和对应已知实际情况的基础上进行选择的。

接下来，通过利用在DNA序列专业领域中众所周知的将蛋白质编码在蛋白质族谱中的方法构建一个相应的多列。多列是与蛋白质列同时构建的。在存在差异或者不明确的地方，氨基酸序列的列可以被调整为给出带有最大节省的DNA树的列。为给定树构造祖先DNA序列当前的首选方法是最大节省法。DNA和蛋白质树以及多列必须是合适的，这意味着当氨基酸被排列在蛋白质序列中时，相应的密码子排列在DNA队列中。依此类推，两棵进化树的连通性必须显示相同的进化关系。在氨基酸树的连通性被氨基酸序列没有唯一定义的地方，给出最大节省DNA树的树被用来在两棵树之间做出决定或者相等值是否需要重构。最后，在树的节点处被重构祖先氨基酸必须在这些节点上重构密码子。当祖先序列不明确时，并且DNA序列又不能解决这个不明确问题，那么重构的DNA序列必须是平行的不明确。即使从已知数据不能获得精确的重构，近似的重构也是有价值的，那么该树最好被限制与从生物学数据库(例如，遗传分类学)参考的蛋白质间的进化关系相对应。

接下来，DNA序列中的突变会被指定给DNA进化树的所有分支。这些可以是反映树的节点处的序列不确定性的部分突变。当遇到不确定性时，任选项具有相等的加权。沿着所有分支的突变被指定为“未知的”，这意味着这些突变对编码蛋白质序列并不具影响，和可以被指定为“压缩的”，这意味着它们确实对编码蛋白质序列有影响。在树节点处的重构序列出现不确定的时候会进行部分分配。

随后，会接着利用专业领域中著名的蛋白质工程学和生物工艺学方法[Jermann，T.M.，Opitz，J.G.，Stackhouse，J.，Benner，S.A.“偶蹄动物的核糖核酸酶总科的进化历史重构”Nature 374：57-59(1995)]在实验室中准备进化树的中间体。

美国专利号5,958,784中公布的方法可以接着被应用到所有蛋白质族谱中。对于所有蛋白质族谱，可以为该族谱预测次级结构，而这个预测的次级结构是根据树节点的祖先序列排列的。如果没有指定树节点，那么预测的次级结构根据为树重心附近的任意点计算的祖先序列排列。

多列的质量和重构祖先序列的精度在蛋白质被包括在分成超过150PAM个体的族谱中时会降低，其中PAM个体是每100个氨基酸接受的突变点数目，当在族谱所包括蛋白质序列对不超过至少40PAM个体或者更多偏离的情况下，由美国专利号5,958,784公布的方法使次级结构预测变差时，用于本发明的族谱最好包含至少多余40PAM个体偏离的蛋白质序列对，但是不能多余150PAM个体偏离。在更好的情况下，大部分蛋白质对都是40或者更多的PAM个体偏离而没有多于120PAM个体偏离的蛋白质对。然而，在蛋白质族谱中的序列通常是由数据库中序列的有效性决定的。

一旦由美国专利号5,958,784公布的方法预测次级结构模块按照上面所描述的那样被置入到进化关系中，可以以下列方法使用这个进化关系：

1.可迅速搜索的数据库

上面所提出的步骤提供了一个方法，可以将组织蛋白质序列数据库组织为可迅速搜索的形式。与根据这些步骤定义的族谱相关联的祖先序列和预测的次级结构是组成员单个蛋白质的序列以及结构的替代物。重构的祖先序列已拥有所有蛋白质序列的单一序列表示。与祖先序列相关联的预测的次级结构已拥有所有派生蛋白质的核心次级结构元素的单一结构模块表示。这样一来，祖先序列就可以替代派生序列，并且与之相对应的核心次级结构模块可以替代派生蛋白质的次级结构。

这就使得定义两个的代用数据库成为可能，一个数据库是用于序列的，而另一个是用于次级结构的。第一代用数据库是从所有在单个祖先序列数据库中得蛋白质族谱中集中得数据库，它位于最精确接近树节点的树节点上。如果不能确定根节点，为代用序列数据库选择的祖先序列就位于树的质心附近。第二代用数据库比包含族谱中所有蛋白质的实际序列或实际结构的完整数据库要小的多，这如同每个祖先序列表示许多派生蛋白质一样。

在代用数据库中搜索取样序列的同源体通常会以两个步骤执行。首先，取样序列(或者结构)与代用序列(或者结构)相匹配。搜索会生成一个重要的匹配，于是取样序列被确定为已经定义的一个族谱的成员。该取样序列接着与这个族谱的成员相匹配以确定在由族谱定义的进化树中它所适合的位置。在一个新的取样序列被纳入到族谱中时，多列，进化树，预测的次级结构以及重构祖先序列可以是不同的。如果是这样，不同的多列，进化树，以及预测的次级结构会被记录下来，而修改过的重构祖先序列和结构会被引入它们各自的代用数据库以备后用。

带有祖先序列的祖先序列的排列在探测较远的同族谱关系时具有一定的优势，这是因为祖先序列包含关于在基本家族谱中保存了什么氨基酸残基的信息，因此更有可能被保存于分级的基本家族谱之间。

VII.数据库表单

所有单独的表单(实体)都表示一个来自基础生物学数据集合/数据库的一些或者所有蛋白质序列之间的不同的互联纲要。特别是，在首选的实施方案中，用来存储生物学数据的关系数据库包括大量相关表单，其中每个表单都包含一个带有公共区域的属性，而公共区域带有至少一个数据库中其他表单中的属性。本发明是在关系数据库中存储的数据基础上为查看染色体序列之间进化关系的样子提出的。

使用图4A-4C的实体关系图表可以查看三种形式的纲要，这三个图阐明了每个数据类型的字段和数据类型之间的互联关系。下面是关于在一个本发明实施方案中表单(实体)集合以及关系键和属性的具体描述。当插入关系的时候，除了SeqAnnType表单的所有关系的ID字段被自动指定。特别是，图4C显示了DNA的实体关系图表。

1.AASequence表单

AASequence表单包含所有数据库中的氨基酸序列。每个序列正好属于一个序列数据库。

#	名字	类型	键	描述
					1	Id	INTEGER	P	内部id。也就是属于该序列的所有模块，序列注释利序列键的外部键。
2	SeqDBId	INTEGER		序列所属于的序列数据库。
					3	Description	VARchar(255)		序列的描述
4	Sequence	LONGVARchar		根据Alphabet.getAminoAlphabet()作为编码字符的序列本身。

2.Catalog表单Catalog表单包含所有数据库中的有效目录。

#	名字	类型	键	描述
					1	Id	INTEGER	P	内部id。也就是属于该目录下所有族谱

				的外部键。
					2	Name	VARchar(64)		外部表示的唯一名字。
3	Description	VARchar(255)	S	目录内容的描述
					4	Version	VARchar(16)		这个目录的版本(根据一些编号方式方案的数据或者版本)
5	DBVersion	INTEGER		这个目录的数据库格式版本，它被用来核实数据库与MC服务器的兼容性。
					6	ProfilePAM	Float[]		有效特点数据库的PAM列表。它存储耗时查询的结果。
7	NrModules	INTEGER		目录中模块的总数。它存促耗时查询的结果
					8	NrFamilies	INTEGER		目录中族谱的总数。它存储耗时查询的结果。

3.FamAnnotation表单

FamAnnotation表单包含所有族谱的所有注释。每条注释总是正好属于一个族谱。

#	名字	类型	键	描述
					1	Id	INTEGER	P	内部id。
2	FamId	INTEGER	F	对应族谱的外部键
					3	Annotation	ds.MSAAnnotation		族谱的MSA的注释

4.Family表单

Family表单包含所有目录的所有族谱。每个族谱总是正好属于一个目录并且包含一个模块的任意数目。

#	名字	类型	键	描述
					1	Id	INTEGER	P	内部id，也就是属于这个族谱的所有模块，特点以及MSA注释的外部键。
2	Name	VARchar(64)	S	在模块化过程中指定的这个族谱的名字。
					3	Modification	INTEGER	S	这个族谱中被指定名字的修改数目
4	CatId	INTEGER		包含目录的外部键
					5	Descriptio	VARchar(255)		关于这个族谱的描述(通常在模块化过

	n			程中自动产生)。
					6	Tree	ds.Tree		预先计算的这个族谱的植物种类树。

5.Module表单

Module表单包含所有目录的所有模块。每个模块总是正好属于一个序列和一个族谱。多序列的列被默认存储为Gaps结构，而可以根据它直接构建MSA。

#	名字	类型	键	描述
					1	Id	INTEGER	P	内部id。
2	SeqId	INTEGER	F	包含序列的外部键
					3	SeqStart	INTEGER		在包含序列(基于0)中的这个模块的起点
4	SeqLength	INTEGER		在包含序列中的这个模块的长度。
					5	FamId	INTEGER	F	包含序列的外部键。
6	FamIndex	INTEGER		在包含族谱中这个模块的索引。
					7	StartSignificance	Real		这个模块起点的意义。
8	EndSignificance	Real		这个模块终点的意义。
					9	Quality	Real		这个模块的总的质量。
10	MSAGaps	ds.Gaps		这个模块序列中被插入以获得MSA序列的缝隙。

6.Profile(简档)表单

Profile表单包含所有族谱的所有特点。每个特点总是正好属于一个族谱。对于每个族谱来说，在不同PAM可能有多个特点。

#	名字	类型	键	描述
					1	Id	INTEGER	P	内部id。
2	FamId	INTEGER	F	相对应族谱的外部键。
					3	Pam	REAL	S	从族谱的PAS中的PAM距离。
4	Sequence	BLOB		充满陈述(byte[])的实际特点序列。

7.SeqAnnotation表单

SeqAnnotation表单包含在这个数据库中所有序列的所有注释。每个注释正好属于一个序列。

#

名字

类型

键

描述

1	Id	INTEGER	P	内部id。
					2	SeqId	INTEGER	F	所包含序列的外部键。
3	SeqStart	INTEGER		位于所包含序列(基于0)中的这个注释的起点。
					4	SeqLength	INTEGER		位于所包含序列中的这个注释的长度。
5	Type	INTEGER	F	由SeqAnnType定义的序列注释类型。
					6	Desscription	VARchar(255)		除了由SeqAnnType提供的之外关于注释的描述。它可以是空缺的，也就是NULL。

8.SeqAnnType表单

SeqAnnType表单包含在这个数据库中所有序列注释的所有类型。它的主要目的就是为所有在GUI中显示的类型提供标准描述。这个实体比真正的数据库实体具有更多查找表单的特性。每个关系的Id属性是由手工分配的。一些ID的语义必须为例如GUI所了解，这样不同的注释可以被以不同方式显示出来。类型被集中在组(类型id范围)中，这些组的成员通常并不会互相交迭(例如，次级结构或者约束地点)。组是在mastercatalog.ds.SeqAnnGroup。

#	名字	类型	键	描述
					l	Id	INTEGER	P	内部id。
2	Tag	VARchar	S	在与这个类型(例如特征表单标签)相对应的原始注释数据库中使用的标签。
					3	Description	VARchar		关于注释的描述

9.SequenceDB表单SequenceDB表单包含所有在这个数据库中有效的序列数据库。

#	名字	类型	键	描述
					1	Id	INTEGER	P	内部id，也就是属于这个数据库的所有序列的外部键，所有目录都是根据数据库建立的。
2	Name	VARchar(16)	S	内部标识的唯一名字。
					3	Description	VARchar(16)		数据库内容的描述
4	Version	VARchar(16)		这个数据库的版本(根据

				一些编号方案的数据或者版本)。
					5	SearchKeys	String[]		对于序列搜索的有效搜索键列表。它存储一个耗时查询的结果。
6	SeqAnnTypes	String[]		有效序列注释的列表。它存储一个耗时查询的结果。

10.SequenceKey表单SequenceKdy表单包含序列的所有索引键，包括ID，编号，EC号码等等。分别存储这些键允许添加附加的键类型而无需修改数据库结构或者任何代码。更进一步来讲，经常会出现所有序列有相同的键。

#	名字	类型	键	描述
					1	Id	INTEGER	P	内部id。
2	KeyType	VARchar(16)		键类型，例如“EC”。
					3	KeyValue	VARchar(255)	S	键值，例如“4.2.2.1”。
4	SeqId	INTEGER	F	相应序列的外部键。

短(short)组和图表最好存储为BLOB(二进制大型对象)以防止设计中的实体数目的增长无法控制。只有可变大小的大数组可以通过适当规格化数据库被存储于它们各自的关系中。瞬时Java对象与持久型数据库关系(DB表单中的行)之间的映射是建立在每个关系的唯一“ID”(一个INTEGER)基础上的。因此对于数据库中其它对象的索引也总是INTEGER外部键。

对于每个表单来说都有一个子集，它的实例就是与关系相对应的Java对象，子集表示相应的实体并提供必要的SQL代码。

VIII.GUI

这里将就图形用户界面以及其数据库导航来描述本发明的实施。

本发明的图形用户界面允许用户浏览序列数据库，执行搜索，以及检查进化关系。举例来说，GUI是一个能够被用来沿着染色体序列跟随进化关系的浏览器；浏览可以提供交互树，多序列排列，以及族谱；可以使用新颖的将所有族谱表示为随机序列的方法搜索族谱数据库；进化率被先是在进化树上并提供了函数变化的证据。

如在大多数“视窗”应用程序中一样，所有本发明的显示屏幕都包含视窗标题栏，菜单栏(带有诸如文件，比较，以及类似的命令)，工具栏(带有诸如关闭，粘贴，清除，以及类似的选项)，以及一个信息显示区域。例如，信息显示区域可以显示一个查询视窗或者一个结果视窗。

图6是一个本发明首选实施方案的导航流程图，它说明了所有有用的主要视窗和选项。矩形表示视窗而圆形表示它们各自视窗中有效的选项。箭头指明了方向[而程序的每个层都是有颜色的代码]。

在最佳情况下，初始视窗是一个LOGIN视窗(没有显示出来)，用户可以在其中输入一个有效的用户名字和密码来访问系统。

经过成功的登录，CATALOG SELECTION WINDOW 100出现在用户的显示屏上，具体如图7中根据本发明的实施方案的实物示意图。CATALOGSELECTION WINDOW 100显示了由名字，版本，描述，族谱数以及模块数可选择的有效目录。

每个目录都被构建成可以提供数据库中(其中一些或者所有的)蛋白质序列之间关系的视图。不同的目录着重于蛋白质序列数据库的不同特点。举例来说，某个目录可能着重于重复蛋白质中的单位，另一个目录的重点在于构成整个基因(例如，一个基因产物目录)长度的列，而再一个则集中于蛋白质序列(例如，一个模块化的目录)之间的分歧的局部模式。目录是由模块的族谱组成的，每个模块定义了一个蛋白质序列的区域。这样一来，族谱就与不同蛋白质序列的区域通过具有生物学意义的途径联系起来。

在数据库配置中，Catalog表单(在前面描述过)包含了下面的内容：ID，Name，Description，Source，Version，DBVersion，ProfilePAM，NrModules，NRFamilies，MinFamId，MaxFamId，SearchKeys，SeqAnnTypes，RefSeqDBs。

可以包括在本发明中的目录实例包括下面的内容：

1.模块化的目录：在分歧(根据进化模块)的局部模式的

基础上蛋白质序列之间的关系描述。可以通过很多方法可以来构

建这个目录。公布的实例包括ProDom和DOMO。

2.基因产物目录：蛋白质序列之间的描述，其中的一个或

者更多个蛋白质必须包含整个基因。建立这种目录的方法实例可

以参见Monica Riley的关于E.coli基因组模块化的作品。

3.复制目录：形成至少20个残基的可标识复制的蛋白质区

域之间的描述。尽管DOMO数据库可以被更精确定义为一个模块

化目录，该数据库的某个特点说明了这种类型的特点。

4.条目目录：一个定义序列数据库结构的“典型”方法的

描述。在不同序列条目之间不存在明确的关系。它仅仅是一个数

据库中所有有效蛋白质序列的字典。

目录可以是数据库中所有数据的子集。通常情况下，这在对着重于所有基因产物(例如，正确的哺乳动物序列)具有生物学意义子集的模块化目录是非常(按科学的方法)实用的

可以通过双击显示的该目录查询视窗上的有效目录之一来选择该目录。你可以利用鼠标在工具栏的Open按钮上点击来任意选择一个目录条目。

有一个特殊的目录，“Sequence Entry目录”，它仅包含单个的蛋白质序列。这个目录必然不包括组名称，也不允许进行序列搜索；它仅提供对单个蛋白质序列的直接访问路径并且可以通过关键字来进行搜索。

一旦选择了一个目录，就可以通过几种不同的方法来搜索目录：a)通过目录族谱标识符，b)通过关键字，和c)通过序列。在首选的实施方案中，使用与每个搜索类型相对应的“标签”来选择查询类型。每个搜索方法可以生成唯一的结果，该结果可以为导航到相关模块提供一个充足的机制。所有这些方法并不是对一切目录都有效。(也就是说，如果没有族谱，也就不会有族谱标识符)。这些方法将在后面详加说明。

a).图8-根据名字搜索(族谱标识符/模块ID)：目录中的每个族谱最好拥有一个唯一定义特殊族谱的标识符。最佳情况下，这些族谱名字是在根据蛋白质序列数据建立目录的时候被自动产生的。这个搜索视窗110允许你获得所感兴趣的特定族谱编号，具体如图8所示。这个搜索的结果是图9的模块族谱摘要(MFS)视窗140，它显示了对应蛋白质及其模块的示意图。

b).图10-根据序列搜索：这个视窗120允许你在同源(进化相关的)蛋白质族谱目录中搜索一个蛋白质，具体如图10所示。同源性在从序列数据库中提取信息方面是一个重要概念。这是因为当两个蛋白质是同源关系时，就可以得出关于它们的化学行为和生物作用的结论。确定两个蛋白质是否同源的一个途径就是比较它们的氨基酸序列。在专业领域已经确定了比较两个蛋白质序列，记录近似点，以及使用这个记录来访问由公共祖先而不是随机产生近似点的这个似然的过程。[Gonnet，G.H.，Cohen，M.A.，Benner，S.A.整个蛋白质序列数据库的彻底匹配，科学256，1443-1445(1992)]。你可以输入感兴趣的氨基酸，指定一个最小范围和最大匹配数，修改PAM灵敏度(搜索灵敏度可以被设置为，例如，50PAM来搜索相近同族谱体，也可以设置为150来搜索较疏远的同族谱体，而只有符合指定的最小范围并且等于最大数目的匹配被报道出来)。这个搜索过程对于大型的取样序列来说需要耗费一端时间。你可以利用cancel按钮在任何时候中断搜索。

搜索的结果就是Sequence Search Results(SSR)视窗125，它显示了一个取样序列与相关联族谱之间关系的示意图，具体如图11所示。该视窗显示了为查询选择的取样序列与相关的所有族谱之间的关系。分数是与“记录差异分数”相对应的，是序列之间的联系是根据进化模型而相互联系在一起的可能性还是这种相似性是偶然发生的可能性。

在SSR视窗显示的任何模块上双击都将显示该族谱的模块族谱摘要(MFS)视窗140。带有该摘要的取样序列的排列会接着显示出来。

c).图12-根据关键字搜索：这个视窗130根据原始序列数据库种蛋白质的注释提供了根据关键字搜索蛋白质序列数据库的搜索，具体如图12所示。所提供的关键字包括根据有机体，分类，基因名字以及基因产物描述进行选择。

这个搜索的结果是一个关键字搜索结果(KSR)视窗135，图13，它包括一个数据库序列ID的列表，这些ID都拥有匹配描述中关键字的数据库序列注释。显示画面说明了适合关键字搜索标准的单个蛋白质序列的一个示意图。该示意图被显示为一个表示沿识别的氨基酸排列(AA)在所选择目录种找到的现有模块的框图的现行排列。每个示意框图是根据其响应的Module ID号码表示的并且根据颜色或其他有特色的表示法加以区分。在某些情况下，序列可能会与特殊的关键字而非有效的模块化信息(没有在示意框图中显示)相匹配，这是因为这些序列并不属于包括在当前选择目录中的集合。

在KSR视窗135中显示的任何模块上双击都将显示相关组的模块族谱摘要(MFS)视窗140。

图9的模块族谱摘要(MFS)视窗140显示了一个相关蛋白质的示意图，这里现在不对它们的模块加以详细描述。这个视窗通过提供到其他显示窗口的通路而成为通往本发明的导航能力的大门。这个视窗显示了在作为特殊族谱成员的当前显示目录中的所有序列，其中的族谱包含拥有感兴趣的特殊模块的所有序列。所有模块之间的联系都已经在数据库中预先计算好了。模块是作为族谱成员的一个子序列，其中族谱图形长度是成比例的。未定义的区域没有示意框图。所感兴趣的模块从外观上与其他模块加以区别而它的ID可以从视窗的标题栏上识别。族谱中的序列还可以包含其它模块。序列被排列成簇模块，它们在进化亲疏关系上是最靠近的。

视窗最好被制成带有表示每个序列的有限行的表格。而它的列最好包括序列ID，描述，氨基酸排列和表示为示意框图(空间导向的)线性排列的序列示意图，它表示沿着确定氨基酸排列(AA)在选择目录中找到的现有模块。每个示意框图最好都是由其相应的Module ID号码识别的，并且它是由颜色或者其他区别表示法的形式加以区分的。当前选择模块的示意框图是垂直排列并且从外观上加以区别的，例如利用颜色(红色)。视窗的“工具提示”在指示器被放在特殊表单条目上方时会扩展任何缩短的描述或者在自动定位的窗口提供附加信息。这个视窗提供了一个良好的在不同模块之间确定疏远同族谱关系的方法。共享公共模块的蛋白质经常会在相似的位置拥有其他近似的模块。这种关系可以通过检验多个序列队列和树来确定。

MFS视窗的工具栏允许你从这个点执行很多不同的任务(例如，打印，输出到磁盘，显示多序列队列(MSA)，以及显示系统发育树)。这里将具体讨论所有这些任务。族谱摘要可以从本地计算机直接打印到有效的打印机上。这个族谱的模块化描述可以被输出到文件中。

我们现在转向显示当前族谱的多序列队列(MSA)的图14。选择视窗工具栏上的MSA按钮可以显示图14中MSA视窗150的多序列队列(模块在氨基酸等级上被联系在一起的方法)。视窗在蛋白质序列级别提供具体的进化信息以遵循保存氨基酸模块比较的模式以及变化。MSA最好根据氨基酸的憎水性和亲水性来添以颜色。(例如，红色表示憎水性倾向而蓝色表示亲水性倾向)。系统在MSA视窗中使用的编号方法最好与由MFS视窗和Tree视窗同时实现的编号系统相对应。将鼠标(指示器)移动到一个选定的高亮区域可以显示自动定位视窗中的注释。这些可以是手工的注释，例如来自SwissProt的特征表单条目或者从诸如在PROSITE(或者其他诸如PRINTS)中自动产生的。可以从MSA视窗底部的选项栏选择不同的注释。

对每个模块族谱的序列中图形替换的相互关系进行分析允许做出关于主要结构或功能的约束条件的预测。在更好的情况下，注释所提供的是Vparse，它显示了阻断残基和模式的假定结构。；Score，显示了在队列的每个位置保留的程度。这个值是依赖于序列之间的进化亲疏关系和单个氨基酸的易变性，它是保存地点的有效位的灵敏指示物；PredSI，指示在该位置残基的融解可达性；PreSec，指示预测的次级结构。如果族谱的PAM宽度很不理想或者序列数目很少，那么就不足以为次级结构预测提供足够的信息。如果给定模块与PDB中的任何条目显著地排列在一起，就可以PredSI和PredSec串下方MSA视窗底部看到与该列相对应的次级结构元素的一行。

如前面所描述的那样，多列排列视窗显示了在同族谱中蛋白质之间氨基酸与氨基酸的关系。其中一些首选的特点包括a)色彩：憎水性残基以红色表示，亲水性残基以蓝色表示，两性分子以黑色表示，b)解析：有可能表示阻隔位置的次级结构序列区域，被表示出来，c)PredSI：预测的表面/内部残基被表示出来，d)PredSec：显示了预测的次级结构，e)Experimental Sec：如果已知，显示由实验决定族谱中同族关系的次级结构，f)Annotation：序列特点，诸如可从视窗中“annotations：”列表框中选取的已知功能图形(参见下面)。MSA视窗的功能包括：a)输出序列数据：这个族谱的选择模块序列可以被输出到各种格式的文件中，b)将序列数据复制到剪贴板：当按钮被选择的时候，该族谱的选择模块的序列被复制到剪贴板，c)打印：族谱摘要可以被直接从你的本地计算机打印到任何有效的打印机上，d)注释：MSA中的序列可以为特别的注释(通常是特殊的图形或者特殊数据库注释)而被高亮显示。一个这样的注释集合是“Prosite”数据库。与Prosite注释相对应的序列区域被添以橙色。将鼠标移动到文本区域可以在自动定位的视窗中显示注释的具体信息。从当前窗口可视的完整集合可以通过查看“注释类型”菜单来获得。当前集合的所有注释子集可以有由在注释菜单中的复选框中自定义来获得。

下面将描述序列/模块的选择。你可以选择单个模块的所有序列或者其中一些。序列可以经过鼠标点击在MSA显示窗口中被逐个选择。为了将你的选择结合到前面的选择中去，你可以在选择的同时一直按住<CTRL>键。除了工具栏任务之外，视窗上还有其他的一些特点。举例来说，在ID列上的任意序列上双击可以显示该族谱(包括目录从属关系，描述，以及注释)的蛋白质序列窗口。

我们现在转向显示当前族谱进化树的图15。选择视窗上的Tree按钮可以在图15的Tree视窗160中显示进化树。这指示了单个模块之间的分歧/相似处的图形，它假定模块之间的亲疏关系可以从蛋白质序列的相似处计算出来。明确地讲，树显示了对蛋白质模块进化历史的估计，它是利用族谱的单个成员之间的PAM亲属关系构建起来的。树可以显示为固定的或者不固定的形式；这些表示法之间并没有什么显著的区别，根节点被选择在能够平衡整棵树的位置。

在树的分支上，分支的长的是以PAM单位显示的。这提供了在不同序列的比较中发现的分歧的估计。选择位于视窗底部的“kA/kS”键可以显示在DNA级别的压缩变化率与无声(silent)变化率的比率，也就是导致蛋白质等级变化的突变率比上导致仅仅在DNA登记变化的突变率。

这个比率最好被标准化以便于在读取压缩：未知，这个值为1.0时表示没有选择，的时候所有同义(无声变化)和非同义(压缩变化)的代替是等可能的(例如，一个假基因)。用户可以在光滑的刻度上调节kA/kS的阈值等级。分离的颜色图解可以用来表示高于阈值还是低于阈值。举例来说，如果kA/kS低于阈值(缺省值为1.0)的话，分支被涂上蓝色，而如果kA/kS高于阈值的话，分支就被涂上红色。如果不存在DNA序列的有效信息，那么分支就被涂上黑色。实际上，蛋白质通常都受净化选择的影响，所以这个比值一般都低于阈值。因此，在比值接近或者超过1.0的地方，着眼于快速序列进化(推测起来是新功能)的一段的置信度就会增加。对在很长一段进化时间中发生的适应来说，压缩：未知比率的值将由于随机突变增加了无声变化的数目而降低。可以根据检验整个进化树来确定合适的阈值，该树应该包含已经在长时间里保留净化选择并将这些值与希望位置的快速变化相比较。

图形界面还提供利用视窗的滑动缩放按钮进行得放大和缩小功能。为了了解PAM亲疏关系标签或者叶标识符，缩放功能是很有必要得。该信息还可以通过将光标定位在叶子或者分支上方在自动定位的视窗中了解。单个分支可以通过选择合适的分支和“缩放”键在各自的树上显示出来。“调节”按钮可以将树的缩放成全屏大小。

如前面所提到的那样，Tree视窗通过由族谱单个模块的氨基酸序列比较计算出来的亲疏关系显示了它们之间的进化关系。一些首选的特点包括：a)色彩：蓝色边缘-KaKs(参见下面)低于阈值，红色边缘-KaKs高于阈值，黑色边缘-KaKs不能计算(不存在DNA/不可靠的DNA序列)。阈值是通过更改Tree视窗工具栏上的滑杆来进行选择的，b)固定/不固定：树可以被显示为固定或者不固定的形式，这依赖于用户的意图。而这两者的描述之间的信息内容并没有不同；树的根是出于平衡目的而选择的，而不是作为其他系统发育证据的结果。一些首选的功能包括：a)输出树的描述：树可以以各种形式被输出到文件中，b)打印：树可以被从你的本地计算机直接打印到任何有效的打印机上，c)注释：MSA中的序列可以为特别的注释而被高亮显示(通常是特殊的序列图形或者特殊的数据库注释)。一个这样的注释集合是“Prosite”数据库。与Prosite注释相对应的序列区域被涂上了橙色。在当前视窗中可视的完整注释集合可以通过查看“注释类型”菜单来获得。位于当前集合之中的所有注释子集可以通过利用注释菜单中的复选框定制来获得；d)选择序列/模块：你可以通过单击鼠标来选择树的分支或者叶子。选择一个分支会导致选中所有的下游分支和节点。(根节点被标上一个圆圈)。为了将选择结合到你前面的选择中去，可以在选择的同时一直按住<CTRL>键；e)调节/重新调节树：调节按钮可以被用来将树到整个视窗。按住SHIFT以及鼠标左键可以被用来将视窗放大到所选择的位置，而按住SHIFT和鼠标右键可以将视窗缩小到所选择的位置；f)Ka/Ks：你可以在树上显示KaKs或者PAM亲疏关系。

MFS视窗，树视窗和MSA视窗是链接在一起的，这样有利于在一个视窗上进行选择可以使在其他视窗中的序列高亮显示。你可以选择由单个序列占有的所有模块或者其中一些。模块可以在MFS视窗中利用鼠标单击来选择。所有由蛋白质占有的模块可以通过在左边列选择模块id(#)来被全部选定。为了将你的选择与先前的选择结合到一起，可以在选择的同时一直按下<CTRL>键。

通常情况下选定的对象可以传播到当前族谱的所有显示视窗中，也就是说，选择关系到一个族谱的任何视窗中的序列都会在该族谱-Tree视窗，MSA视窗和MFS视窗的显示中高亮显示这个模块。如果设置了传播校验框，相关选择会由序列传播出去-也就是说，所有拥有任何被选择模块的蛋白质序列都会被高亮显示。这种方式在跨越不同蛋白质族谱追踪其关系的时候是非常有用的。

我们现在将描述到另一个族谱的导航(由当前族谱中序列的从属关系相关联)。在图形表示法的任何模块上双击鼠标都可以显示与该模块相对应的族谱摘要视窗。

本发明的显著特点包括：a)多目录视图，用户可以同时查看多个目录，b)树到树交互性，从当前视窗中进行的有效选择可以传播出去(选择和删除)，c)选择的连通性，其中树的一部分被选择之后将在其他视窗高亮显示相关信息，而这些都将被不断应用到打开的视窗中，d)MSA视窗的Prosite注释，显示注释的工具栏，以及对选择子集的注释/视图的自定义。

附录A[20页]包含了用Java编写的本发明确定的功能的源代码，这些功能包括用来管理和传播选择的IndexSelection.java，用来将族谱数据显示为表单的FamilyFrame.java，用来将包括序列和它们的模块的族谱信息表示出来的FamilyTableModel.java，作为一个类的界面监视索引选择变化的IndexSelectionListener.java，用来呈现族谱序列，即当在模块上单击就选中它而双击它就会打开相应的族谱结构的FamilySequenceRenderer.java。

下面是说明实践本发明的过程的一些例子。这些例子不应该被视为具有限制性的。

实例1-

图16描述了一个根据序列进行搜索的交互式逐级查询定制活动的连续屏幕显示实例。首先向查询框120之中输入或者剪切和粘贴一个序列。用户可以根据需要调整最小范围，最大匹配以及PAM。接着查询就被运行并生成结果Sequence Search Results(SSR)视窗125，用户可以通过在模块上双击进行逐级查询模块，这导致包含所关心模块的MFS视窗140被指定为红色并且与其他模块在位置上排列在一起。

实例2-

图17描述了一个根据关键字进行搜索的交互式逐级查询定制活动的连续屏幕显示的实例。搜索项“isocitrate”被输入(其他搜索项还可以可以包含必要的布尔逻辑)到查询视窗130中。在执行查询之后，就会显示Keyword Search Results(KSR)视窗135，它列出了所有包含查询关键字的序列并带有序列的图形显示以及它们的模块。用户可以从这个视窗中选择关心的模块，使其显示在MFS视窗140中。MFS视窗140显示了生物学数据的二维空间定位，它包括选定族谱每个序列中的模块(表示为方框示意图)的可视位置，其中的族谱是区分显示的并且与序列中的其他模块排列在一起的。

实例3-

图18A描述了一个目录的MFS视窗140。可以从菜单栏中选择附加的目录视图。在本例中，基因组和OP基因组目录都可以被选择查看，具体如图18B所示。这个视图描述了一个带有两个目录的MFS视窗。用户可以通过选择关心的模块从这个视窗开始逐级查询定制活动并在MFS视窗中查看它们。

实例4-

图19描述了进化树视窗160的屏幕显示，它与MFS视窗140和MSA视窗相链接并且将高亮显示的选择项传播出去。将树中的一部分高亮显示将自动把这个高亮显示传播到这个选择序列的其他视窗(MSA和MFS)中。

实例5-

图20描述了说明通过多MFS视窗140进行交互式逐级查询定制活动的屏幕显示。举例来说，以358_1模块MFS视窗作为开始，用户可以选择显示377_1，978_1，以及371_1(同时的)。视窗可以根据需要被关闭或者在屏幕内移动。随后，用户可以继续从结果视窗中选择显示，举例来说，用户可以从978_1 MFS视窗中选择显示1075_1模块，并依此类推。逐级查询可以被逐级地继续下去。当然，从每个MFS视窗140中，可以如在图6的流程图中描述的那样显示图14的MSA视窗150，图15的进化树160，或者数据库查询(这里没有显示)。

应该理解的是，这里所描述的实例和实施方案都是仅仅以说明为目的的，这里将对专业领域的人员提出相关的更正和修改，这些都包括在本应用的精神和范围以及附加权利要求的范围之内。所有的专利，专利申请，临时申请，以及与此相关或在上文列举到的相关资料，再有享有优先权的权利要求，都在与该规格说明书的明确讲授中结合在一起。

  APPENDIX A1999 EraGen Biosciences，Inc.Saliwanchik，Lloyd & Saliwanchik，P.A.2421N.W.41st Street，Suite A-1Gainesville，FL 32606(352)375-8100

package mastercatalog.util；
import java.util.*；
/**

　　The class managing and propagating selections of indices per id. Global

　　propagation is possible through maps of indices to global ids.

　　@author Lukas Knecht
*/
/*

　　$Id：IndexSelection.java，v1.5 1999/08/19 11：25：46 knecht Exp$

　　$Log：IndexSelection.java，v$

　　Revision1.5 1999/08/19 11：25：46 knecht

　　Added hasSelected() and getSubsetName().

　　Revision1.4 1999/07/30 08：43：13 knecht

　　Added global propagation of selections.

　　Revision1.3 1999/07/19 08：30：09 knecht

　　Added multiple toggle.

　　Revision 1.2 1999/04/26 13：13：00 knecht

　　Modifications for V2.0

　　Revision 1.1 1999/02/18 21：42：16 knecht

　　Initial revision

　　*/
public class IndexSelection (
  private static Hashtable selectionTable＝new Hashtable()；
  private static boolean global Propagation；
  private BitSet selected；
  private boolean changed；// true if anything changed since the last propagate()
  private Vector listeners；
  private int[]indexToId；// maps index to ids for global propagation
  /**

　　Create a new empty IndexSelection with a given id.

　　@param id the id uniquely identifying this selection.

　　*/
  protected IndexSelection(int id) {

　　selected＝new BitSet()；changed＝false；listeners＝new Vector()；

　　selectionTable.put(new Integer(id)，this)；
  }
  /**

　　  Obtain the index selection belonging to a given id.This is the only

　　  method to create an IndexSelection.

　　  @param id the id uniquely identifying the selection.If no IndexSelection

　　  with this id exists，it is created.

　　  @return the IndexSelection belonging to the given id.

　　  */
  public static IndexSelection obtainIndexSelection(int id) {

　　  IndexSelection selection＝getIndexSelection(id)；

　　 if(selection＝＝null)selection＝new IndexSelection(id)；

　　 return selection；
  }
  /**

　　 Get index selection belonging to a given id.

　　 @param id the id uniquely identifying the selection.

　　 @return the IndexSelection belonging to the given id or null if no such

　　 IndexSelection exists.

　　 */
   public static IndexSelection getIndexSelection(int id) {

　　 return(IndexSelection)selectionTable.get(new Integer(id))；
  }
  /**

　　 Enable or display global propagation of selections.

　　 @param enabled true if global propagation should be enabled，false otherwise.
				
				<dp n="d31"/>
　　  */
   public static void setGlobalPropagation(boolean enabled)  {

　　 globalPropagation＝enabled；
   }
   /**

　　  Get the status of global propagation of selections.

　　  @return true if enabled，false otherwise.

　　  */
  public static boolean getGlobalPropagation() (return globalPropagation；)
   /**

　　  Set the mapping from indices to global ids for global propagation of

　　  the selection. If global propagation is enabled， copies existing selections.

　　  @param indexToId the mapping. Setting it to null disables global propagation

　　  from this IndexSelection.

　　  */
  public void setIndexToId(int[] indexToId) {

　　  this.indexToId＝indexToId；

　　 if(globalPropagation &amp;&amp; indexToId ！＝null)

　　     for(Enumeration e＝selectionTable.elements()；e.hasMoreRlements()；){

　　       IndexSelection other＝(IndexSelection)e.nextElement()；

　　        if(other！＝this &amp;&amp; other.indexToId！＝null) {

　　           for(int i＝0；i＜indexToId.length；i++)

　　               for(int j＝0；j＜other.indexToId.length；j++)

　　             if(indexToId[i]＝＝other.indexToId[j])

　　                     if(other.isSelected(j)) select(i)；

　　                     else deselect(i)；

　　        }

　　    }
  }
 /**
   Get the mapping from indices to global ids for global propagation of
   the selection.
   @return the mapping.
   */
public int[] getIndexToId(){return indexToId；}
/**

　　Get the current selection.

　　@return the set of currently selected indices.

　　*/
public BitSet getSelected()[return salected；}
/**

　　Add a listener listening to selection changes.

　　@param 1 the listener to be added.

　　*/
public synchronized void addSelectionListener(IndexSelectionListener 1) {

　　if(！listeners.contains(1)) listeners.addElement(1)；
}
/**
   Remove a previously added listener.
   @param 1 the listener to be removed.
   */
public synchronized void removeSelectionListener(IndexSelectionListener 1) {
  listenere.removeElement(1)；
}
/**
   Select the given index and note any change.
   @param index the index to be selected.
   */
public synchronized void select(int index) {
   if(！selected.get(index)) {selected. set(index)；changed＝true；}
}
/**
   Select the given indices and note any change.
   @param indices the indices to be selected.
				
				<dp n="d32"/>
　　 */
  public synchrornized void select(int[] indices) {

　　for(inti＝0；i＜indices.length；i++) select(indices[i])；
  }
   /**

　　 Deselect the given index and note any change.

　　 @param index the index to be deselected.

　　 */
  public synchronized void.deselect(int index){

　　 if(selected.get(index))(selected.clear(index)；changed＝true；}
  }
  /**

　　Deselect the given indices and note any change.

　　@param indices the indices to be deselected.

　　*/
 public synchronized void deselect(int[]indices){

　　for(int i＝0；i＜indices.length；i++)deselect(indices[i])；
 }
  /**

　　Toggle the selection of the given index，optionally allowing multiple

　　selections.

　　@param inddx the index to be toggled.

　　@param multiple allowa for multiple selections：if false and index is being

　　selected，deselects all other indices.

　　*/
public synchronized void toggle(int index，boolean multiple) {

　　if(selected.get(index)) selected.clear(index)；

　　else {

　　   if(！multiple)selected＝new BitSet()；

　　   selected.set(index)；

　　}

　　changed＝true；
 }
/**

　　 Toggle the selection of the given indices，optionally allowing multiple

　　selections.

　　@param indices the indices to be toggled.

　　@param multiple allows for multiple selections：if false and any index is

　　being selected，deselects all other indices.

　　*/
public synchronized void toggle(int[]indices，boolean multiple){
   int i；
   BitSet newSelected＝selected；
   if(！multiple) {

　　  for(i＝0；i＜indices.length &amp;&amp; selected.get(indices[i])；i++)；

　　  if(i＜indices.length) newSelected＝new BitSet()；
   }
   for(i＝0，i＜indices.length；i++)

　　 if(selected.get(indices[i]))newSelected.clear(indices(i))；

　　 else newSelected.set(indices(i))；
   selected＝newSelected；changed＝true；
}
/**
   Get the selection for a given index.
   @param index the index to be queried.
   @return true if index is selected，false otherwise.
   */
public synchronized boolean isSelected(int index) {
   return selected.get(index)；
}
/**
  Check whether there is any selection at all.
  @return true if any index is selected，false otherwise.
   */
public synchronized boolean hasSelected() {
   int i；
				
				<dp n="d33"/>
　　for(i＝0；i＜selected.size() &amp;&amp;！selected.get(i)；i++)；

　　return i＜selected.size()；
/**

　　Propagate the current selection state to the SelectionListeners if it

　　changed since the last propagation.

　　@param source the listener which should not be notified.

　　*/
public synchronized void propagate(IndexSelectionListener source) {

　　if(changed) {

　　   changed＝false；

　　   for(int i＝0；i＜listeners.size()；i++) {

　　      IndexSelectionListener 1＝

　　          (IndexSelectionListener) listeners.elementAt(i)；

　　      if(1！＝source)1.selectionChanged(this)；

　　  }

　　   propagateGlobally()；
  }
}
/**
   If global propagation is enabled， propagate the current selection state
   globally to all other selections.

　　*/
public synchronized void propagateGlobally() {
   if(globalPropagation &amp;&amp; indexToId ！＝null)

　　   for(Enumeration e＝selectionTable.elements()；e.hasMoreElements()；)(

　　      IndexSelection other＝(IndexSelection)e.nextElement() ；

　　      if(other ！＝this &amp;&amp; other.indexToId！＝null) {

  　　         for(int i＝0；i＜indexToId.length；i++)

　　             for(int j＝0；j＜other.indexToId.length；j++)

　　                if(indexToId[i]＝＝other.indexToId[j])

　　                    if(isSelected(i))other.select(j)；

　　                    else other.deselect(j)；

　　         other.propagate(null)；

　　      }

　　   }
/**
   Get a simple standard name for a BitSet.
   @param subset the set.May be null.
   @return a(nonunique)name corresponding to the subset.
   */
public static String getSubsetName(BitSet subset) {
   if(subset＝＝null)return″″；
   int mini＝1，maxi＝0；
   for(int i＝0；i＜subset.size()；i++)

　　  if(subset，get(i)){

　　      if(mini＞maxi)mini＝i；

　　      maxi＝i；

　　}
   return″(″+mini + ′-′+maxi+ ′)′；
   }
}
				
				<dp n="d34"/>
  package mastercatalog.gui；
  import mastercatalog.gui.event.*；
  import mastercatalog.ds.*；
  import mastercatalog.util.*；
  import java.io.*；
  import java.awt.*；
  import java.awt.event.*；
  imort java.util.*；
  imort javax.swing.*；
  imort javax.swing.event.*；
/**

　　The standard frame showing the data about a family as a table.

　　@author Lukas Knecht
 */
 /*

　　$Id：FamilyFrame.java，v1.10 1999/08/19 11：25：45 knecht Exp$

　　$Log：FamilyFrame.java，v$

　　Revision1.10 1999/08/19 11：25：45 knecht

　　Various GUI changes.

　　Revision 1.9 1999/08/10 12：55：11 knecht

　　Change for new busy indicator.

　　Revision1.8 1999/07/30 08：43：13 knecht

　　Various changes and modification.

　　Revision 1.7 1999/07/19 09：44：10 knecht

　　No tree and no MSA give error message.

　　Revision1.6 1999/07/19 08：16：20 knecht

　　Various GUI changes.

　　Revision1.5 1999/04/26 10：13：19 knecht

　　Modifications for V2.0

　　Revision1.4 1999/02/19 10：08：26 knecht

　　Added menus.

　　Revision1.3 1999/02/18 21：45：02 knecht

　　Various big changes and enhancements for V1.0

　　Revision1.2 1998/12/14 22：19：28 sgc

　　Various bug fixes and enhancements，including the export function and MSA ordering

　　Rsvision1.1 1998/10/02 14：15：46 knecht

　　Initial revision
   */
public class FamilyFrame extends MCFrame
implements Exportable，Printable，IndexSelectionListener，CellClickListener {
  private static final int EXPORT_TEXT＝0；
  private static final int EXPORT_STRUCTURED＝1；
  private static final String[]exportFormats＝{″Text″，″Structured″)；
  private static FrameTable openFrames＝new FrameTable()；
  private Family family；
  private BitSet subset；
  private String name；
  private FamilyTableModel model；
  private MCTable table；
  private IndexSelection selection；
  private BitSet oldSelected；
  private int[]memberToSequence；
  private FamilySequence[]extraSequence；
  private JComboBox searches；//the list of available searches
  /**

　　Create a frame showing a family belonging to a certain catalog.

　　@param server the ServerConnection to get the available catalogs from.
				
				<dp n="d35"/>
　　@param Catalog the catalog the family belongs to.

　　@param family the family to be shown.

　　@param subset a BitSet identifying the subset. May be null.
   */
public PamilyFrame(ServerConnection server，Family family，BitSet subset)

　　      throws Exception
{

　　super(server，″″，″FamilyFrame.gif″)；

　　this.family＝family；this.subset＝subset；

　　String subsetName＝IndexSelection.getSubsetName(subset)；

　　name＝family.getId()+″_″+subsetName；openFrames.put(name，this)；

　　Catalog catalog＝server.getCatalogById(family.catId)；

　　setTitle(family.getFullName()+subsetName+″Module Family，″+

　　         catalog.name+″Catalog″)；

　　memberToSequence＝family.getMemberToSequence()；

　　//Listen to changes in the selection

　　selection＝IndexSelection. obtainIndexSelection(family.getId())；

　　selection.set IndexToId(family.getMemberToSequenceId())；

　　selection.addSelectionListener(this)；

　　table＝new MCTable()；

　　JTextField descr＝new JTextField()；

　　descr.setEditable(false)；

　　if(Capabilities.areAllToolTipsSupported())

　　   descr.setToolTipText(″This description has been obtnined automaticnlly″)；

　　add(descr，″North″)；

　　add(new JScrollPane(table)，″Center″)；

　　model＝new FamilyTableModel(catalog，family}；

　　table.setModel(model)；

　　table.setContext(server，catalog)；

　　table.setSelection(selection)；

　　oldSelected＝(BitSet)selection.getSelected().clone()；

　　table.addCellClickListener(this)；

　　addStandardMenuItems(catalog)；

　　toolBar.addSeparator()；

　　final SlowAction msaAction＝new SlowAction(){

　　public void act(){showMSA()；}
  }；

　　MCAbstractAction msa＝

　　  new MCAbstractAction(″MSA″，″MSAFrame.gif″，

　　                     ″Show the annotated multiple sequence alignment″) {

　　  public void actionPerformed(ActionEvent e)(msaAction.run()；}
  }；
  addToToolBar(msa)；addToViewMenu(msa，′M′)；
  final SlowAction treeAction＝new SlowAction() {

　　public void act(){showTree()；}
  }；
  MCAbstractAction tree＝

　　  new MCAbstractAction(″Tree″，″TreeFrame.gif″，

　　                     ″Show the phylogenetic tree″) {

　　  public void actionPerformed(ActionEvent e){treeAction.run()；}
  }；
  addToToolBar(tree)；addToViewMenu(tree，′T′)；
  MCAbetractAction clip＝

　　  new MCAbstractAction(″Clip″，″clip.gif″，

　　                       ″Display a frame contnining only selected scquences.″)

　　 {

　　    public void actionPerformed(ActionEvent e){clipSelected()；}

　　}；
  addToToolBar(clip)；addToViewMenu(clip，′C′)；
  JMenu catMenu＝new JMenu(″Catalogs″)；
  addToMenuBar(catMenu)；
  Catalog[]allCats＝server.getCatalogs()；
  for(int i＝0；i＜allCats.length；i++){

　　  JCheckBoxMenuItem item＝new JCheckBoxMenuTtem(allCats[i].name)；

　　  item.setEnabled(！allCats[i].isEntryCatalog()&amp;&amp;

　　                  allCats[i].getId()！＝famtly.catId)；

　　  item.setState(allCats[i].getId()＝＝family.catId)；
				
				<dp n="d36"/>
　　    item.addActionListener(new ActionListener() {

　　      public void actionPerformed(ActionEvent e}{

　　        toggleCatalog(((JMenuItem)e.getSource()).getText())；

　　       }

　　    ))；

　　   addToCurrentMenu(item)；

　　}

　　catMenu.setEnabled(server.isXNavigationAllowed())；

　　toolBar.addSeparator()；

　　JPanel seqPanel＝new JPanel(new GridLayout(2，1))；

　　seqPanel.setMaximumSize(new Dimension(l50，100))；

　　seqPanel.add(new JLabel(″with：″))；

　　searches＝new JComboBox()；

　　searches.setToolTipText(″Select the sequence to be ddded to MSA or Tree″)；

　　seqPanel.add(searches)；toolBar.add(seqPanel)；

　　toolBar.addSeparator()；addPropagateBoxes(selection)；

　　table.setRowSelectionAllowed(false)；

　　descr.setText(family.descr)；
 }
 /**

　　Show the Tree belonging to this family.

　　*/
private void showTree() {

　　String search＝null；

　　int i＝searches.getSelectedIndex()；

　　if(i＞0)search＝(String)searches.getItemAt(i)；
   TreeFrame frame＝TreeFrame.openFrame(server，family，search，subset)；

　　if(frame！＝null)frame.appendToHistory()；
}
/**
   Show the MSA belonging to this family.

　　*/
private void showMSA() {
   String search＝null；
   int i＝searches.getSelectedIndex()；
   if(i＞0)search＝(String)searches.getItemAt(i)；
   MSAFrame frame＝MSAFrame.openFrame(server，family，search，subset)；
   if(frame！＝null)frame.appendToHistory()；
}
/**
   Open a new frame with the selected modules.
   Does nothing if there are no selected modules.
   */
private void clipSelected(){
   if(selection.hasSelected()) {

　　  FamilyFrame clipFrame＝

　　      FamilyFrame.openFrame(server，family.getId()，selection.getSelected())；

　　   if(clipFrame！＝null)clipFrame.appsndToHistory()；
   }
}
/**
   Toggle a column displaying a given catalog.
   @param name the name of the catalog.
   */
private void toggleCatalog(final String name){
   try{

　　  Catalog cat＝server.getCatalogByName(name)；

　　  if(cat！＝null){

　　      int i＝model.indexOf(cat)；

　　      if(i＞＝0){

　　         model.removeCatalog(cat)；table.removeColumn(i)；

　　      }

　　      else {

　　         FamilySequence[]sequence＝

　　            new FamilySequence[family.sequence.length]；

　　         for(i＝0；i＜sequence.length；i++)

　　            sequence[i]＝
				
				<dp n="d37"/>
　　               server.getFamilySequence(cat.getId()，family.sequence[i].id)；

　　           model .addCatalog(cat，sequence)；

　　           table.addColumn(FamilyTableModel.SBQUENCE_WIDTH)；

　　        }

　　     }

　　 }

　　 catch(Exception e){UserMessages.show(e)；)
  /**

　　 Get the matching search ids for this family.

　　 */
private void getSearches() {

　　 if(searches.getItemCount()！＝0)searches.removeAllItems()；

　　 searches.addItem(″(nonc)″)；

　　String[]names＝server.getSearchNames(family)；

　　 for(int i＝0；i＜names.length；i++) searchea.addItem(names(i))；

　　 aearches.eetEnabled(names.length＞0)；

　　extraSequence＝server.getSearchSequences(family)；

　　 int[]extraIndent＝server.getSearchSequenceIndents(family)；

　　model.setExtraSequences(extraSequence，extraIndent)；
 }
public void dispose() {

　　openFrames.remove(bame)；super.dispose()；
 }
 /**

　　Apply the user preferred properties to this frame.

　　@param withSize apply also the size property.

　　*/
public void applyPropertiea(boolean withSize) {

　　table.applyProperties(withSize)；

　　if(withSize)pack()；
 }
 /**

　　Get all child frames.

　　*/
public MCFrame[] getChildren() {

　　MCFrame[]trees＝TreeFrame.getAllWithPrefix(family.getId()+″_″)；

　　MCFrame[]msas＝MSAFrame.getAllWithPrefix(family.getId()+″_″)；

　　MCFrame[]res＝new MCFrame[trees.length+msas.length]；

　　System.arraycopy(trees，0，res，0，trees.length)；

　　System.arraycopy(msas，0，res，trees.length，msas.length)；

　　return res；
 }
/**
   Write the parameters to create this frame to a serializer.
   @param out the serializer to write to.

　　*/
public void writeParameters(ASCIISerializer out)throws Exception {
   Catalog catalog＝server.getCatalogById(family.catId)；
   out.writeQuoted(catalog.name)；out.write(′，′)；
   out. writeQuoted(family.getFullNams())；
   if(subset！＝null){out.write(′，′)；out.write(subset)；)
/**
   Create a frame to show a given family if it does not already exist，
   make it visible and put it on top of the window stack.
   @param server the ServerConnection to use.
   @param famId the id of the family to be shown.
   @param subset a BitSet defining a subset of modules to be displayed.
   May be null.
   */
public static FamilyFrame openFrame(ServerConnection server，int famId，

　　                                BitSet subset) {
   String subsetName＝IndexSelection.getSubsetName(subset)；
   FamilyFrame frame＝(FamilyFrame)openFnFrms.get(famId+″_″+subsetName)；
   if(frame＝＝null)  {
				
				<dp n="d38"/>
　　   try{

　　       Family family＝server.getFamily(famId)；

　　       if(subset！＝null)

　　          family＝family.cloneSelected(subset)；

　　       frame＝new FamilyFrame(server，family，subset)；

　　    }    

　　   catch(Exception e){UserMessages.show(e)；)

　　}

　　if(frame！＝null) {  

　　   frame.getSearches()；frame.applyProperties(true)；frame.setVisible(true)；

　　   frame.toFront()；

　　return frame；
 /**

　　Create a frame from a command read from a deserializer.

　　The string has the format″catalog′，′family″.

　　@param server the ServerConnection to use.

　　@param in the deserializer to read the command from.

　　*/
public static FamilyFrame openFrame(ServerConnection server，

　　                                ASCIIDeserializer in)

　　throws Exception
 {

　　String name＝in.readString()；

　　Catalog catalog＝server.getCatalogByName(name)；

　　if(catalog＝＝null){

　　   UserMessages.show(null，″Error″，″No snch catalog：″+name)；

　　   return null；

　　}

　　in.checkChar(′.′)；

　　name＝in.readString()；

　　int familyId＝server.getFamilyId(catalog，name)；

　　if(familyId＜0) {

　　   UserMessages.show(null，″Error″，″No sucb family；″+name)；

　　   return null；

　　}
   BitSet subset＝null；
   if(in.ttype＝＝′.′){in.nextToken()；subset＝in.readBitSet()；}
   return openFrame(server，familyId，subset)；
}
/**
   Get the history text corresponding to the command read from a deserializer.
   @param dcserializcr the deserializer to read the command from.
   */
public static String getHistoryText(ASCIIDeserializer in)

　　throws IOException，SyntaxException
{
   StringBuffer text＝new StringBuffer(″Pamily″)；
   String catalog＝in.readString()；in.checkChar(′.′)；
   String family＝in.readString()；
   text.append(family)；
   if(in.ttype＝＝′.′){

　　 in.nextToken()；text.append(″″)；text.append(in.readBitSet().toString())；
   }
   text.append(″in″)；text.append(catalog)；
   return text.toString()；
}
/**
   Dispose all open frames.
   */
public static void disposeAll(){openFrames.disposeAll()；)
/**
   Get all open frames.
   */
public static MCFrame[]getAll()(return openFrames.getAll()；}
/**
				
				<dp n="d39"/>
   Apply the properties to all open frames.
   @param withSize true if the frame size should be set.
   */
public static void applyPropertiesToAll(boolean withSize) {
  openFrames.applyPropertiesToAll(withSize)；
}
/* The Printable implementation：″/
public void print(PrintJob job，Rectangle area) {
   Graphics g＝job.getGraphics()；
   Font ssFont＝Fontbase.getSansSerif(″PLAIN″，10)；
   g.setFont(ssFont)；
   int fontSize＝

　　 server.getProperties().getIntProperty(ClientProperties.MODULE_FONTSIZE)；
   Font moduleFont＝Fontbase.getSansSerif(″PLAIN″，fontSize)；
   FontMetrics fm＝g.getFontMetrics()；
   //compute labels and ranges and the width of the first three columns
   String[]label＝new String[family.sequence.length]；
   String[]range＝new String[family.sequence.length]；
   int dxLabe)＝0；
   int dxId＝0；
   int dxRange＝0；
   for(int i＝0；i＜family.sequence.length；i++) {

　　  Module[]modules＝

　　     family.sequence[i].getFamilyModulesByIndex(family.getId())；

　　  StringBuffer buf＝new StringBuffer()；

　　  for(int j＝0；j＜modules.length；j++) {

　　     if(j＞0)buf.append(″，″)；

　　     buf.append(modules[j].index)；

　　  }

　　  label[i]＝buf.toString()；

　　  buf＝new StringBuffer(″AA″)；

　　  for(int j＝0；j＜modules.length；j++) {

　　     if(j＞0)buf.append(″，″)；

　　     buf.append(modules[j].seqStart+1)；

　　     buf.append(′-′)；

　　     buf. append(modules[j].seqStart+modules[j].seqLength)；

　　  )

　　  range[i]＝buf.toString()；

　　  int w＝fm.stringWidth(label[i])；

　　  if(w＞dxLabel)dxLabel＝w；

　　 w＝fm.stringWidth(family.sequence[i].name)；

　　  if(w＞dxId)dxId＝w；

　　 w＝fm.stringWidth(range[i])；

　　  if(w＞dxRange)dxRange＝w；
  }
  //compute column positions
  int space＝fm.charwidth(′w′)；
  int xId＝area.x+dxLabel+space；
  int xRange＝xId+dxId+space；
  int xSeq＝xRange+dxRange+space；
  int dxSeq＝area.width -xSeq；
  //compute the number of lines
  int chHeight＝fm.getHeight()+fm.getMaxDescent()；
  int lines＝(area.height/chHeight-1)/2-2；//count title
  for(int i0＝0；i0＜family.sequence.length；i0+＝lines) {

　　 int i1＝i0+linee；

　　 if(i1＞family.sequence.length)i1＝family.sequence.length；

　　 //creats a new page if none exists yet and print the title

　　 if(g＝＝null)g＝job.getGraphics()；

　　 g.setFont(Fontbase.getSansSerif(″BOLO″，14))；

　　 g.drawString(getTitle()+″，Seguences″+(i0+1)+″-″+il，

　　              area.x，area.y+chHeight)；

　　 //print the sequences

　　 int y＝area.y+2*chHeight；

　　 for(int i＝i0；i＜i1；i++) {

　　    FamilySequence sequence＝family.sequencs[i]；

　　    y+＝chHeight；

　　    //print label，id and range
				
				<dp n="d40"/>
　　        g.setFont(ssFont)；g.setColor(Color.black)；

　　        DrawingUtilities.

　　           drawRightAdjustedString(g，label[i]，area.x+dxLabel，y)；

　　        g.drawString(sequence.name，xId，y)；

　　        g.drawString(range[i]，xRange，y)；

　　        //print gray bar representing the sequence

　　        g.setColor(Color.gray)；

　　        g.fillRect(xSeq+family.indent[i]*dxSeq/family.maxLength，

　　                   y-4*chHeight/10，

　　                   sequence.length*dxSeq/family.maxLength，

　　                   2*chHeight/10)；

　　        g.setFont(moduleFont)；

　　        for(int j＝0；j＜sequence.module.length；j++)

　　          DrawingUtilities.drawModule

　　               (g，xSeq+(family.indent[i]+sequence.module[j].seqStart)

　　                *dxSeq/family.maxLength，y-9*chHeight/10，

　　                sequence.module[j].seqLength*dxSeq/family.maxLength，

　　                8*chHeight/10，sequence.module[j].famName，

　　                sequence.module[j].famId＝＝family.getId()，false)；

　　    //print the descriptions

　　    y+＝chHeight/2；

　　    for(int i＝i0；i＜i1；i++) {

　　       FamilySequence sequence＝family.sequence[i]；

　　       y+＝chHeight；

　　       //print label，id and description

　　       g. setFont(ssFont)；g.setColor(Color.black)；

　　       DrawingUtilities.

　　          drawRightAdjustedString(g，label[i]，area.x+dxLabel，y)；

　　       g.drawString(sequence.name，xId，y)；

　　       g.drawString(sequence.descr，xRange，y)；

　　    }

　　    //print this page and force allocation of the next page

　　    g.dispose()；g＝null；

　　}
 }
 /* The IndexSelectionListener implementation：*/
 /*

　　A complete update of the entire colrmn is too slow.We therefore only

　　update the changed rows，which means that all selection changes in the

　　table must happen through here to keep oldSelected consistent.

　　*/
public void selectionChanged(IndexSelection selection) {

　　BitSet selected＝selection.getSelected()；

　　for{int i＝1；i＜memberToSequence.length+extraSequence.length；i++)

　　   if(selected.get(i)！＝oldSelected.get(i)) {

　　      int row；

　　      if(i＞＝ memberToSequence.length)

　　          row＝i-memberToSequence.length+family.sequence.length；

　　      else

　　         row＝memberToSequence[i]；

　　      table.tableChanged(new TableModelEvent(model，row，row))；

　　   }
   oldSelected＝(BitSet)selected.clone()；
}
/* The CellClickListener implementation：*/
public void cellClicked(CellClickEvent event) {
   if(event.getClickCount()＝＝2 &amp;&amp; event.getColumn()＝＝1) {

　　   int row＝event.getRow()；

　　  if(row＜family.sequence.legth) {

　　      SequenceFrame frame＝

　　         SequenceFrame.openFrame(server，family.sequence[row].id)；

　　      if(frame！＝null)frame.appendToHistory()；

　　         }

　　   }
}
				
				<dp n="d41"/>
/* The Exportable interface implementation：*/
public String[]getExportFormats(){return exportFormats；)
public void export(Writer out，int format)

　　   throws IOException
{
   switch(format) {
   case EXPORT_TEXT；

　　 out.write(″Family″+family.getFullName()+″\n″)；

　　  for(int i＝0；i＜family.sequence.length；i++) {

　　    FamilySequence seq＝family.sequence[i]；

　　    out.write(″\t″+seq.name+″：″)；

　　     for(int j＝0；j＜seq.module.length；j++) {

　　       Module mod＝seq.module[j]；

　　       out.write(″\t″+mod.famName+

　　                 ″(″+(mod.seqStart+1)+

　　                 ″-″+(mod.seqStart+mod.seqLength)+

　　                 ″)″)；

　　    }

　　    out.write(′\n′)；

　　  }

　　 break；
  case EXPORT_STRUCTURED ：

　　 out.write(family.toString())；

　　 break；

　　  }
   }
}
				
				<dp n="d42"/>
package mastercatalog.gui；
import mastercatalog.ds.*；
import mastercatalog.gui.event.*；
import java.util.*；
import javax.swing.table.*；
/**

　　The table model responsible for repesentation of family information with

　　sequences and their modules.

　　@author Lukas Knecht

　　@version 08-02-1998
*/
/*

　　$Id：FamilyTableModel.java，v1.6 1999/08/19 11：25：45 knecht Exp$

　　$Log：FamilyTableModel.java.v$

　　Revision1.6 1999/08/19 11：25；45 knecht

　　Various GUI changes.

　　Revision1.5 1999/07/30 08；43：13 knecht

　　Various GUI changes and modifications.

　　Revision1.4 1999/07/19 08：16：36 knecht

　　Various GUI changes.

　　Revision1.3 1999/04/26 10：13：19 knecht

　　Modifications for V2.0

　　Revision1.2 1999/02/18 21：45：02 knecht

　　Various big changes and enbancemente for V1.0

　　Revision1.2 1998/12/14 22：19：28 sgc

　　Various bug fixes and enhancements，including the export function and MSA ordering

　　Revision1.1 1998/10/02 14：15：46 knecht

　　Initial revision
   */
public class FamilyTableModel extands MCAbstractTableModel
implants SequenceDisplayable
{
   /**

　　  The preferred width of the sequence columns.

　　  */
   public final static int SEQUENCE_WIDTH＝300；
   private Catalog catalog；//the main catalog to be displayed
   private Family family；//the main family to be displayed
   private String[]labels＝(″＊″，″ID″，″Ddscription″，″species″，″AA range″，

　　                        null}；
   private int[]widths＝[30，100，200，150，80，SEQUENCE_WIDTH)；
   private Vector otherCatalogs＝new Vector()；
   private Vector otherSequences＝new Vector()；
   private Object[][]extraData；
   private int[] extraIndent；
   /**

　　  Construct a new family table model.

　　  @param cat the catalog the family bilongs to.

　　  @param family the family to be displayed.

　　  */
  public FamilyTableModel(Catalog catalog，Family family) {

　　setContext(catalog，family)；
   }
   /**

　　  Set the family to be displayed.

　　  @param cat the catalog the family belongs to.

　　  @param family the family to be displayed.

　　  */
				
				<dp n="d43"/>
  public void setContext(Catalog catalog，Family family) {

　　this.family＝family；this.catalog＝catalog；

　　 //convert the family into the data to be displayed

　　data＝new Object(family.sequence.length][]；

　　labels[5]＝catalog.name+″(the family′s)″；

　　for(int i＝0；i＜data.length；i++)

　　  data[i]＝getRow(family.getId()，family.sequence[i])；

　　otherCatalogs.removeAllElements()；otherSequences.removeAllElements()；
 }
 private Object[]getRow(int famId，FamilySequence sequence) {

　　Module[]modules＝sequence.getFamilyModulesByIndex(famId)；

　　int[]indices＝new int[modules.length]；

　　for(int j＝0；j＜modules.length；j++)indices[j]＝modules[j].index；

　　Object[]row＝new Object[6]；

　　row[0]＝new SelectableString(indices)；

　　row[1]＝sequence.name；

　　row[2]＝sequence.descr；

　　row[3]＝sequence.getSpecies()；

　　StringBuffer buf＝new StringBuffer()；

　　for(int j＝0；j＜modules.length；j++) {

　　  if(j＞0)buf.append(″，″)；

　　   buf.append(modules[j].seqStar+1)；

　　   buf.append(′-′)；

　　   buf.append(modules[j].seqStart+modules[j].seqLength)；

　　}

　　row[4]＝buf.toString()；

　　row[5]＝sequence；

　　return row；
 }
 /**

　　Set extra sequences to be displayed(sequences which do not really belong

　　to the family，but which make some sense when added.＜BR＞

　　This adds sequences only to the main catalog column.

　　@param sequences the extra sequences to be added.

　　@param indent the indent of the extra sequences to be added in the

　　context of the family.

　　*/
public void setExtraSequences(FamilySequence[]sequences，int[]indent) {

　　if(extraData！＝null)

　　   fireTableRoweDeleted(data.length，data.length+extraData.length-1)；

　　extraData＝null；

　　if(sequences！＝null) {

　　   extraData＝new Object[sequences.length][]；extraIndent＝indent；

　　   for(int i＝0；i＜sequences.length；i++)

　　      extraData[i]＝getRow(family.getId()，sequences[i])；

　　   fireTableRowsInserted(data.length，data.length+extraData.length-1)；

　　}
}
/**
   Add a new column displaying another catalog.Adding a catalog which
   is already displayed is a no-op.
   @param cat the catalog to add.
   @param sequence the same sequences as displayed by this model，but with
   modules of cat.
   */
public void addCatalog(Catalog cat，FamilySequence[]sequence) {
   if(indexOf(cat)＜0)  {

　　  otherCatalogs.addElement(cat.name)；otherSequences.addElement(sequence)；
   }
}
/**
   Get the column index of a catalog or-1 if the catalog is not shown.
   @param cat the catalog to check for.
   @return the model column index of the catalog or-1.
   */
public int indexOf(Catalog cat) {
   int i＝otherCatalogs.indexOf(cat.name)；
   if(i＞＝0)i+＝data{0}.length；
				
				<dp n="d44"/>
　　return i；
 }
 /**

　　Remove a column displaying another catalog. Removing a catalog which is

　　not displayed is a no-op.

　　@param cat the catalog to remove.

　　 */
 public void removeCatalog(Catalog cat) {

　　int i＝otherCatalogs.indexOf(cat.name)；

　　if(i＞＝0) {

　　   otherCatalogs.removeElementAt(i)；otherSequences.removeElementAt(i)；

　　}
 }
 /* The AbstractTableModel implementation. */
public String getColumnName(int col) {

　　if(col＜labels.length)return labels[col]；

　　return(String)otherCatalogs.elementAt(col-labels.length)；
 }
 /* The MCAbstractTableModel implementation. */
public String getToolTipTextAt(int row，int col) {

　　FamilySequence seq＝

　　   row＜data.length？family.sequence[row]：

　　    (FamilySequence)extraData[row-data.length][5]；

　　if(col＝＝1)return seq.getKeys(SeqKeyGroup.IDENTIFIER_GROUP)；

　　if(col＝＝2)return seq.descr；

　　if(col＝＝3)return seq.getSpecies()；
   return null；
}
public int[]getColumnWidths()(return widths；)
public int getColumnCount()  {
   return super.getColUMNCount()+otherCatalogs.size()；
}
public int getRowCount() {
   if(extraData＝＝null)return super.getRowCount()；
   else return super.getRowCount()+extraData.lengh；
}
public Object getValu~t(int row， int col) {
   if (row＜data.length) { 

　　   int i＝col-data[row].length；

　　   if(i＜0)return super.getValueAt(row，col)；

　　   return((FamilySequence[])otherSequences，elementAt(i))[row]；
   }
   else{

　　  row-＝data.length；

　　  if(col＜extraData[row].length)return extraData[row][col]；

　　  else return null；
   }
}
public Class getColumnClass(int col){
   Class cls＝null；
   Object value＝getValueAt(0，col)；
   if(value！＝null)cls＝value.getClasa()；
   else{

　　  //Object.class does not work in all VMs

　　  try{cls＝Class.forName(″java. lang.Object″)；}

　　  catch (ClassNotFoundException e){}//ignore
   }
   return cls；
}
/* The SequenceDisplayable implementation. */
				
				<dp n="d45"/>
  public int getFamilyId(){return family.getId()；)
  public int getIndent(int row) {
   if(row＜data.length) return family. indent[row]；
   else return extraIndent[row-data.length]；
  }
  public int getMaxLength()(return family.maxLength；}
  /**

　　 Get the family being displayed.

　　 @return the family.

　　 */
  public Family getFamily()(return family；}
}
				
				<dp n="d46"/>
package mastercatalog.util；
import java.util.*；
/**
   The interface for a class which listens to index selection changes.
   @author Lukas Knecht
   @version 01-17-1999
*/
/*
   $Id：IndexSelectionListener.java，v1.1 1999/02/18 21：42：29knecht Rel$
   $Log：IndexSelectionListener.java，v$
   Revision1.1 1999/02/18 21：42：29 knecht
   Initial revision
   */
public interface IndexSelectionListener {
   /**

　　  Notify a listener that an index selection has changed.

　　  @param selection the IndexSelection which has changed.

　　  */
   public void selectionChanged(IndexSelection selection)；
}
				
				<dp n="d47"/>
package mastercatalog.gui；
impott mastercatalog.ds.*；
import mastercatalog.gui.event.*；
import mastercatalog.util.*；
import java.awt.*；
import java.awt.event.*；
import javax.swing.*；
import javax.swing.table.*；
/**

　　The renderer of a family sequence.Single clicking on a module selects it，

　　double clicking triggers opening of the corresponding family frame.

　　@author Lukas Knecht
*/
/*

　　$Id：FamilySequenceRenderer.java，v1.8 1999/08/19 11：25：45 knecht Exp$

　　$Log：FamilySequenceRenderer.java，v$

　　Revision1.8 1999/08/19 11：25：45 knecht

　　Removed drawModule().

　　Revision1.7 1999/08/10 12：55：11 knecht

　　Change for new busy indicator.

　　Revision1.6 1999/07/30 08：43：13 knecht

　　Various GUI changes and modifications.

　　Revision1.5 1999/07/19 08：16：29 knecht

　　Various GUI changes.

　　Revision1.4 1999/04/26 10：13：19 knecht

　　Modifications for V2.0

　　Revision1.3 1999/02/18 21：45：02 knecht

　　Various big changes and enhancements for V1.0

　　Revision1.2 1998/12/16 16：24：45 knecht

　　Added getFGColor()and getBGColor().

　　Revision1.1 1998/10/02 14：15：46 knecht

　　Initial revision
   */
public class FamilySequenceRenderer extends JComponent
implements TableCellRenderer，ClickableCellRenderer{
  private CellState toDraw，clicked；
  private MCTable clickedTable；
  private int clickedX；
  private Font font；
  private SlowAction openAction；
  private IndexSelection selection；
  class CellState(

　　  int famId，indent，maxLength；

　　  FamilySequence sequence；

　　  Dimension size；

　　  CellState()(size＝new Dimension()；)

　　  CellState(SequenceDisplayable displayable，int row，FamilySequence sequence，

　　            Dimension size){

　　     thie.sequence＝sequence；this.size＝size；

　　     setDisplayable(displayable，row)；

　　  }

　　  void setDisplayable(SequenceDisplayable displayable，int row) {

　　     famId＝displayable.getFamilyId()；

　　     maxLength＝displayable.getMaxLength()；

　　     indent＝displayable.getIndent(row)；
				
				<dp n="d48"/>
　　//scale(0，maxLength)to(0，size.width)

　　int scaleX(int x)(return x *size.width/maxLength；)

　　//scale(0，10)to(0，size.height)

　　int scaleY(int y)(return y*size.height/10；)

　　//find a member by its x coordinate

　　Module findModule(int x) {

　　   int i；

　　   for(i＝0；i＜sequence.module.length &amp;&amp;

　　              (scaleX(indent+sequence.module[i].seqStart)＞x||

　　               scaleX(indent+sequence.module[i].seqStart+

　　                         sequence.module[i].seqLength)＜＝x)；

　　          i++)；

　　   if(i＜sequence.module.length)return sequence.module[i]；

　　   else return null；
   }
 }
/**

　　Construct a new renderer for family sequences.

　　*/
public FamlySequenceRenderer() {
  setBackground(Color.white)；setFontSize(10)；

　　toDraw＝new CellState()；

　　openAction＝new SlowAction() {

　　  public void act() (

　　     Module clickedModule＝clicked. findModule(clickedX)；

　　     if(clickedModule！＝null) {

　　        FamilyFrame frame＝FamilyFrame.openFrame

　　            (clickedTable.getServerConnection()，clickedModule.famId，null)；

　　        if(frame！＝null)frame.appendToHistory()；

　　     }

　　  }
   }；
}
/**
   Set the font size used in rendering the modules.
  .*/
public void setFontSize(int size) {
   font＝Fontbase.getSansSerif(″PLAIN″，size)；
}
/**
   Set the IndexSelection determining the selected modules.
   @param selection the IndexSelection belonging to the family displayed
   by this renderer or null if there are no selected modules.
   */
public void setSelection(IndexSelection selection) {
   this.selection＝selection；
}
public void paint (Graphics g) (
   if(toDraw.sequence！＝null) (

　　  getSize(toDraw.size)；

　　  if(toDraw.sequence.wasModularized)g.setColor(Color.gray)；

　　  else g.setColor(Color.lightGray)；

　　  g.drawRect(toDraw.scaleX(toDraw.indent)，toDraw.scaleY(4)，

　　             toDraw.scaleX(toDraw.sequence.length)，toDraw.scaleY(2))；

　　  g.fillRect(toDraw.scaleX(toDraw.indent)，toDraw.scaleY(4)，

　　             toDraw.scaleX(toDraw.sequence.length)，toDraw.acaleY(2))；

　　  if(font！＝null)g.setFont(font)；

　　  for(int i＝0；i＜toDraw.sequence.module.length；i++) {

　　    Module module＝toDraw.sequence.module[i]；

　　    boolean ofFamily＝toDraw.famId＝＝module.famId；

　　    DrawingUtilities.drawModule

　　      (g，

　　      toDraw.scaleX(to.aw.indent+module.seqStart)，

　　      toDraw.scaleY(1)，
				
				<dp n="d49"/>
　　            toDraw.scaleX(module.seqLength)，

　　            toDraw.scaleY(9)，

　　           module.famName，ofFamily，

　　            ofFamily &amp;&amp; selection！＝null &amp;&amp;

　　            selection.getSelected().get(module.index))；

　　   }

　　   if(！toDraw.sequence.waeModularized) {

　　      String text＝″(not modularized)″；

　　      FontMetrics fm＝g.getFontMatrics()；

　　      iht w＝fm.stringWidth(text)；

　　      int x＝toDraw.scaleX(toDraw.indent)+

　　          (toDraw.scaleX(toDraw.sequence.length)-w)/2；

　　      g.setColor(Color.black)；

　　      g.drawString(text，x，toDraw. scaleY(8))；

　　   }

　　}
}
/* The TableCellRenderer implementation：*/
public Component getTableCellRendererComponent(JTable table，Object value，

　　                                           boolean isSelected，

　　                                           boolean hasFocus，

　　                                           int row，int column} {

　　toDraw.setDisplayable((SequenceDisplayable)table.getModel()，row)；

　　toDraw.sequence＝(FamilySequence)value；

　　return this；
}
/* The ClickableCellRenderer implementation：*/
public void cellClicked(MCTable table，CellClickEvent event，Object value){
   if(value！＝null)

　　   if(event.getClickCount()＝＝1 &amp;&amp; selection！＝null) {

　　      CellState selected＝newCellState((SequenceDisplayable)table.getModel()，

　　                                       event.getRow()，

　　                                       (FamilySequence)value，

　                                       event.getSize())；

　　      Module module＝selected.findModule(event.getX())；

　　      if(module！＝null &amp;&amp;module.famId＝＝selected.famId) {

　　        selection.toggle(module.index，event.isControlDown())；

　　        selection.propagate(null)；

　　      }

　　   }

　　   else if(event.getClickCount()＝＝2) {

　　     clicked＝new CellState((SequenceDisplayable)table.getModel()，

　　                            event.getRow()，

　　                            (FamilySequence)value，event.getSize())；

　　      clickedTable＝table；clickedX＝event.getX()；openAction.run()；

　　   }
}
/* Get position dependent tooltipa：*/
public String getToolTipText(MCTable table，CellClickEvent event，

　　                         Object value) {
   String text＝null；
   if(value！＝null) {

　　  CellState state＝new CellState((SequenceDisplayable)table.getModel()，

　　                                 eyent.getRow()，

　　                                 (FamilySequence)value，event.getSize())；

　　  Module module＝state.findModule(event.getx())；

　　  if(module！＝null) {

　　      text＝″Module″+module.famName；

　　      if(module，famId＝＝state.famId)text＝text+″(this family)″；

　　      else text＝text+″(double click to show its family)″；

　　  }
   }
   return text；
  }
}

Claims (31)

1.一个搜索和显示诸如能够发现的基因序列之间进化关系模式的生物学数据的方法，它由下列步骤组成：

(a)至少选择一个目录，其中目录包含由相关生物学数据的组织体；

(b)使用取样序列搜索目录来获得以图形的形式显示的搜索结果列表，它可以说明取样序列与所有与该取样序列进化相关的模块的关系，其中模块是一个蛋白质序列的区域；

(c)从搜索结果列表中选择一个感兴趣的模块；并且

(d)显示一个由所有所选择的模块的序列集合组成的族谱，其中集合中的每个序列都包括沿着氨基酸排列不同序列模块的相应图形表示。

2.权利要求1中的方法，进一步包含由显示族谱的多序列排列，进化树或者数据库条目的步骤。

3.权利要求1中的方法，其中的图形表示包含一个所有集合中序列的二维空间导向的视图，其中所有序列的模块被表示为方框示意图并且所有序列的模块都是沿着其氨基酸排列顺序排列的。

4.权利要求3中的方法，其中族谱的所有序列的相似模块是与其他相似模块排列在一起的，并且它们是区分显示的。

5.权利要求1中的方法，进一步包含从不同模块的图形表示选择所关心新模块，并显示一个不同族谱的步骤，其中族谱由拥有所关心新选择模块的所有序列集合组成。

6.权利要求5中的方法，其中集合的所有序列都包括一个相应沿着其氨基酸排列序列的不同模块图形表示。

7.权利要求1中的方法，进一步包括添加至少一个目录的步骤，以便于族谱的图形显示对于所有目录包括序列不同模块的相应图形表示。

8.权利要求7中的方法，进一步包括从来自任何目录中不同模块的图形表示中选择关心的新模块的步骤，并对于目录来说显示一个不同的族谱，该族谱是由拥有新选择所关心模决的所有序列集合组成的。

9.权利要求2中的方法，其中在多序列排列中显示了位于同族谱的蛋白质之间氨基酸到氨基酸的关系。

10.权利要求9中的方法，其中憎水的，亲水的，以及两性残基被从外观上加以区别。

11.权利要求9中的方法，其中有可能表示次级结构中断位置的序列区域被从外观上指示出来。

12.权利要求9中的方法，其中预测的外部/内部残基被从外观上指示出来。

13.权利要求9中的方法，其中预测的次级结构被显示出来。

14.权利要求9中的方法，其中由实验确定的族谱同源体的次级结构如果已知的话就被显示出来。

15.权利要求2中的方法，其中的进化树被显示来指示单个模块之间分歧和相似处的模式。

16.权利要求15中的方法，其中的进化树是利用族谱中单个成员之间的PAM亲疏关系构建的。

17.权利要求16中的方法，其中显示了DNA等级的压缩变化率与无声变化率的比率。

18.权利要求17中的方法，其中使用了单独的有色图解来指示高于或者低于用户所选择的比率阈值。

19.权利要求2中的方法，其中族谱序列不同模块的图形表示的显示，多序列排列的显示，以及进化树的显示是相关的，这样使得用户在任一这些显示中进行的选择都会传播到其他显示中去。

20.一个搜索和显示诸如能够被探测的基因序列之间进化关系中模式的生物学数据的方法，它包括下列步骤：

a)选定至少一个目录，其中的目录包括一个相关生物学数据的组织体；

b)通过关键字进行搜索以获得显示为图形形式的搜索结果列表，这些图形显示了匹配关键字描述的单个蛋白质序列，每个蛋白质序列的特殊区域在模块上是可以加以区别的；

c).从搜索结果列表中选择所关心的模块；并且

d).显示一个族谱，包含所有拥有选择模块的序列集合，其中所有集合序列都包括相应的沿着其氨基酸排列不同序列模块的图形表示。

21.一个用来搜索和显示诸如能够被探测的基因序列之间进化关系中模式的生物学数据的计算机系统，它包括：

选择至少一个目录的输入装置，其中的目录包括一个相关生物学数据的组织体；

用来利用取样序列搜索目录以获得搜索结果列表的处理装置，其中的搜索结果列表被显示为图形形式，可以显示取样序列和所有与取样序列进化相关的模块之间的关系，这里的一个模块是指蛋白质序列的一个区域。

用来从搜索结果列表中选择关心模块的输入装置；以及

用来显示包括拥有关心选定模块的所有集合族谱的显示装置，其中集合的所有序列都包括一个沿着其氨基酸排列的不同序列模块相应的图形表示。

22.一个用来搜索和显示诸如可被探测的基因序列之间进化关系的模式的生物学数据的图形用户界面，该图形用户界面包括：

用来选择至少一个目录的第一显示区域，其中的目录包含一个相关生物学数据的组织体；

用来使用取样序列搜索目录的第二显示区域；

提供显示为图形形式搜索结果列表的第三显示区域，它可以说明取样序列与所有和取样序列进化相关的模块的关系，其中模块是蛋白质序列的一个区域，可以从搜索结果中的选择所关心的模块；

用来显示包含所有拥有选择关心模块的序列集合的族谱的第四显示区域，其中集合的每个序列都包括一个沿着其氨基酸排列相应的不同序列模块的图形表示。

23.一个用来显示诸如可被探测的基因序列之间进化关系的模式的生物学数据的图形用户界面，该图形用户界面包括：

一个用来显示包含所有拥有选择关心模块的序列集合的族谱的显示区域，其其中集合的每个序列都包括一个沿着其氨基酸排列相应的不同序列模块的图形表示，并且图形表示包含集合序列的二位空间导向的视图，其中每个序列的模块都被表示为方框示意图，并且其中的每个序列模块都是沿着其氨基酸排列顺序排列的。

24.权利要求23中的图形用户界面，其中族谱的所有序列的相似模块都与其他相似模块排列在一起的，并且从外观上加以区分。

25.一个计算机可读介质，它包含用来在计算机系统的显示设备上显示数据的程序指令，从与计算机系统相关的数据库表单中获得的数据，上述计算机可读介质包括：

用来选择至少一个目录的第一计算机程序代码，其中的目录包含一个相关生物学数据的组织体；

用来利用取样序列搜索目录以获得显示为图形形式的搜索结果列表的第二计算机程序代码，其中的结果列表说明了取样序列与所有与取样序列进化相关模块的关系，其中的模块是蛋白质序列的一个区域；

用来从搜索结果列表中选择感兴趣模块的第三计算机程序代码；以及

用来显示包含所有拥有选择关心模块序列集合的族谱的第四计算机程序代码，其中集合的每个序列都包括一个沿着其氨基酸排列序列的不同模块的相应图形表示。

26.一个生物学信息的计算机处理存储和检索系统，它包括一个在关系数据库中存储数据的数据存储方法，其中的数据库包括许多表单，每个表单都有至少一个属性域与其他表单共有，上述表单包括：

至少一个用来存储数据库中所有有效氨基酸序列的表单；

至少一个用来存储数据库中有效目录的表单：

至少一个用来存储所有族谱的所有注释的表单；

至少一个用来存储所有目录的所有族谱的表单；

至少一个用来存储所有目录的所有模块的表单；

至少一个用来存储所有族谱的所有简档的表单；

至少一个用来存储数据库中所有序列的所有注释的表单；

至少一个用来存储数据库中序列注释的所有类型的表单；

至少一个用来存储数据库中有效序列数据库的表单；以及

至少一个用来存储一个序列的索引键的表单。

27.一个用来存储和检索生物学数据的计算机系统，它包括：

一个用来存储包括多个相关表单的生物学数据的关系数据库，其中每个表单都包括一个与数据库中至少一个表单的属性拥有公共域的属性；以及用来在关系数据库中存储的数据基础上查看基因序列之间进化关系模式的装置。

28.一个权利要求27中的计算机系统，其中的数据库包括许多表单，上述表单包括：

至少一个用来存储数据库中所有有效氨基酸序列的表单；

至少一个用来存储数据库中所有有效目录的表单；

至少一个用来存储所有族谱的所有注释的表单；

至少一个用来存储所有目录的所有族谱的表单；

至少一个用来存储所有目录的所有模块的表单；

至少一个用来存储所有族谱的所有概况的表单；

至少一个用来存储数据库中所有序列的所有注释的表单；

至少一个用来存储数据库中序列注释的所有类型的表单；

至少一个用来存储数据库中所有有效序列数据库的表单；以及

至少一个用来存储一个序列的所有索引键的表单。

29.一个用来存储和检索生物学数据库的计算机系统，它包括：

一个包括许多表单的数据库，其中上述生物学信息被存储成使得表单拥有至少一个公共属性而相关；

在存储在数据库中的数据基础上查看基因序列之间进化关系模式的装置。

30.在显示设备上显示关于多个模块之间亲疏同源关系的图形表示方法，每个特定模块包括一个公共子序列，该方法包括下列步骤：

选择所关心的模块；然后

显示数据库中所有占有上述所关心模块的蛋白质集合，集合中的每个蛋白质都有一个其模块的视图，其中选择的关心模块和其他同源模块在相似位置是可以从外观上区分的。

31.在通过标识数据库中的同源蛋白质序列的族谱来组织的数据库中，为每个族谱构建一个多序列排列，一个进化树，以及在树中节点处的祖先序列，将DNA序列中的未知和压缩突变分配到DNA进化树的每个分支中去，一个用来在显示设备上显示关于众多模块之间亲疏同源关系的图形表示方法，每个特殊的模块都包括一个公共子序列，该方法包括下列步骤：

选择一个感兴趣的模块；和

显示数据库中占有上述感兴趣模块的所有蛋白质集合，集合中的每个蛋白质都拥有一个其模块的图形视图，其中感兴趣的选择模块与其他的同源模块在近似位置上可以从外观上加以区别。

Images