src/jalview/datamodel/Alignment.java

   1 /*\r
   2  * Jalview - A Sequence Alignment Editor and Viewer\r
   3  * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
   4  *\r
   5  * This program is free software; you can redistribute it and/or\r
   6  * modify it under the terms of the GNU General Public License\r
   7  * as published by the Free Software Foundation; either version 2\r
   8  * of the License, or (at your option) any later version.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  *\r
  15  * You should have received a copy of the GNU General Public License\r
  16  * along with this program; if not, write to the Free Software\r
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
  18  */\r
  19 package jalview.datamodel;\r
  20 \r
  21 import jalview.analysis.*;\r
  22 \r
  23 import jalview.util.*;\r
  24 \r
  25 import java.util.*;\r
  26 \r
  27 \r
  28 /** Data structure to hold and manipulate a multiple sequence alignment\r
  29  */\r
  30 public class Alignment implements AlignmentI\r
  31 {\r
  32     protected Alignment dataset;\r
  33     protected Vector sequences;\r
  34     protected Vector groups = new Vector();\r
  35     protected Vector superGroup = new Vector();\r
  36     protected char gapCharacter = '-';\r
  37     protected Provenance provenance;\r
  38     protected int type = NUCLEOTIDE;\r
  39     public static final int PROTEIN = 0;\r
  40     public static final int NUCLEOTIDE = 1;\r
  41 \r
  42     /** DOCUMENT ME!! */\r
  43     public AlignmentAnnotation[] annotations;\r
  44 \r
  45     /** Make an alignment from an array of Sequences.\r
  46      *\r
  47      * @param sequences\r
  48      */\r
  49     public Alignment(SequenceI[] seqs)\r
  50     {\r
  51         int i=0;\r
  52 \r
  53         if( jalview.util.Comparison.isNucleotide(seqs))\r
  54           type = NUCLEOTIDE;\r
  55         else\r
  56           type = PROTEIN;\r
  57 \r
  58         sequences = new Vector();\r
  59 \r
  60         for (i = 0; i < seqs.length; i++)\r
  61         {\r
  62             sequences.addElement(seqs[i]);\r
  63         }\r
  64 \r
  65         getWidth();\r
  66     }\r
  67 \r
  68     /**\r
  69      * DOCUMENT ME!\r
  70      *\r
  71      * @return DOCUMENT ME!\r
  72      */\r
  73     public Vector getSequences()\r
  74     {\r
  75         return sequences;\r
  76     }\r
  77 \r
  78     /**\r
  79      * DOCUMENT ME!\r
  80      *\r
  81      * @param i DOCUMENT ME!\r
  82      *\r
  83      * @return DOCUMENT ME!\r
  84      */\r
  85     public SequenceI getSequenceAt(int i)\r
  86     {\r
  87         if (i < sequences.size())\r
  88         {\r
  89             return (SequenceI) sequences.elementAt(i);\r
  90         }\r
  91 \r
  92         return null;\r
  93     }\r
  94 \r
  95     /** Adds a sequence to the alignment.  Recalculates maxLength and size.\r
  96      *\r
  97      * @param snew\r
  98      */\r
  99     public void addSequence(SequenceI snew)\r
 100     {\r
 101         sequences.addElement(snew);\r
 102     }\r
 103 \r
 104     /**\r
 105      * DOCUMENT ME!\r
 106      *\r
 107      * @param seq DOCUMENT ME!\r
 108      */\r
 109     public void addSequence(SequenceI[] seq)\r
 110     {\r
 111         for (int i = 0; i < seq.length; i++)\r
 112         {\r
 113             addSequence(seq[i]);\r
 114         }\r
 115     }\r
 116 \r
 117     /** Adds a sequence to the alignment.  Recalculates maxLength and size.\r
 118      *\r
 119      * @param snew\r
 120      */\r
 121     public void setSequenceAt(int i, SequenceI snew)\r
 122     {\r
 123         SequenceI oldseq = getSequenceAt(i);\r
 124         deleteSequence(oldseq);\r
 125 \r
 126         sequences.setElementAt(snew, i);\r
 127     }\r
 128 \r
 129     /**\r
 130      * DOCUMENT ME!\r
 131      *\r
 132      * @return DOCUMENT ME!\r
 133      */\r
 134     public Vector getGroups()\r
 135     {\r
 136         return groups;\r
 137     }\r
 138 \r
 139     /** Takes out columns consisting entirely of gaps (-,.," ")\r
 140      */\r
 141     public void removeGaps()\r
 142     {\r
 143         SequenceI current;\r
 144         int iSize = getWidth();\r
 145 \r
 146         for (int i = 0; i < iSize; i++)\r
 147         {\r
 148             boolean delete = true;\r
 149 \r
 150             for (int j = 0; j < getHeight(); j++)\r
 151             {\r
 152                 current = getSequenceAt(j);\r
 153 \r
 154                 if (current.getLength() > i)\r
 155                 {\r
 156                     /* MC Should move this to a method somewhere */\r
 157                     if (!jalview.util.Comparison.isGap(current.getCharAt(i)))\r
 158                     {\r
 159                         delete = false;\r
 160                     }\r
 161                 }\r
 162             }\r
 163 \r
 164             if (delete)\r
 165             {\r
 166                 deleteColumns(i, i);\r
 167                 iSize--;\r
 168                 i--;\r
 169             }\r
 170         }\r
 171     }\r
 172 \r
 173     /** Removes a range of columns (start to end inclusive).\r
 174      *\r
 175      * @param start Start column in the alignment\r
 176      * @param end End column in the alignment\r
 177      */\r
 178     public void deleteColumns(int start, int end)\r
 179     {\r
 180         deleteColumns(0, getHeight() - 1, start, end);\r
 181     }\r
 182 \r
 183     /**\r
 184      * DOCUMENT ME!\r
 185      *\r
 186      * @param seq1 DOCUMENT ME!\r
 187      * @param seq2 DOCUMENT ME!\r
 188      * @param start DOCUMENT ME!\r
 189      * @param end DOCUMENT ME!\r
 190      */\r
 191     public void deleteColumns(int seq1, int seq2, int start, int end)\r
 192     {\r
 193         for (int i = 0; i <= (end - start); i++)\r
 194         {\r
 195             for (int j = seq1; j <= seq2; j++)\r
 196             {\r
 197                 getSequenceAt(j).deleteCharAt(start);\r
 198             }\r
 199         }\r
 200     }\r
 201 \r
 202     /**\r
 203      * DOCUMENT ME!\r
 204      *\r
 205      * @param i DOCUMENT ME!\r
 206      */\r
 207     public void trimLeft(int i)\r
 208     {\r
 209         for (int j = 0; j < getHeight(); j++)\r
 210         {\r
 211             SequenceI s = getSequenceAt(j);\r
 212             int newstart = s.findPosition(i);\r
 213 \r
 214             s.setStart(newstart);\r
 215             s.setSequence(s.getSequence().substring(i));\r
 216         }\r
 217     }\r
 218 \r
 219     /**\r
 220      * DOCUMENT ME!\r
 221      *\r
 222      * @param i DOCUMENT ME!\r
 223      */\r
 224     public void trimRight(int i)\r
 225     {\r
 226         for (int j = 0; j < getHeight(); j++)\r
 227         {\r
 228             SequenceI s = getSequenceAt(j);\r
 229             int newend = s.findPosition(i);\r
 230 \r
 231             s.setEnd(newend);\r
 232             s.setSequence(s.getSequence().substring(0, i + 1));\r
 233         }\r
 234     }\r
 235 \r
 236     /**\r
 237      * DOCUMENT ME!\r
 238      *\r
 239      * @param s DOCUMENT ME!\r
 240      */\r
 241     public void deleteSequence(SequenceI s)\r
 242     {\r
 243         for (int i = 0; i < getHeight(); i++)\r
 244         {\r
 245             if (getSequenceAt(i) == s)\r
 246             {\r
 247                 deleteSequence(i);\r
 248             }\r
 249         }\r
 250     }\r
 251 \r
 252     /**\r
 253      * DOCUMENT ME!\r
 254      *\r
 255      * @param i DOCUMENT ME!\r
 256      */\r
 257     public void deleteSequence(int i)\r
 258     {\r
 259         sequences.removeElementAt(i);\r
 260     }\r
 261 \r
 262     /**\r
 263      * DOCUMENT ME!\r
 264      *\r
 265      * @param threshold DOCUMENT ME!\r
 266      * @param sel DOCUMENT ME!\r
 267      *\r
 268      * @return DOCUMENT ME!\r
 269      */\r
 270     public Vector removeRedundancy(float threshold, Vector sel)\r
 271     {\r
 272         Vector del = new Vector();\r
 273 \r
 274         for (int i = 1; i < sel.size(); i++)\r
 275         {\r
 276             for (int j = 0; j < i; j++)\r
 277             {\r
 278                 // Only do the comparison if either have not been deleted\r
 279                 if (!del.contains((SequenceI) sel.elementAt(i)) ||\r
 280                         !del.contains((SequenceI) sel.elementAt(j)))\r
 281                 {\r
 282                     // use PID instead of Comparison (which is really not pleasant)\r
 283                     float pid = Comparison.PID((SequenceI) sel.elementAt(j),\r
 284                             (SequenceI) sel.elementAt(i));\r
 285 \r
 286                     if (pid >= threshold)\r
 287                     {\r
 288                         // Delete the shortest one\r
 289                         if (((SequenceI) sel.elementAt(j)).getSequence().length() > ((SequenceI) sel\r
 290                                                                                          .elementAt(\r
 291                                     i)).getSequence().length())\r
 292                         {\r
 293                             del.addElement(sel.elementAt(i));\r
 294                         }\r
 295                         else\r
 296                         {\r
 297                             del.addElement(sel.elementAt(i));\r
 298                         }\r
 299                     }\r
 300                 }\r
 301             }\r
 302         }\r
 303 \r
 304         // Now delete the sequences\r
 305         for (int i = 0; i < del.size(); i++)\r
 306         {\r
 307             deleteSequence((SequenceI) del.elementAt(i));\r
 308         }\r
 309 \r
 310         return del;\r
 311     }\r
 312 \r
 313     /**    */\r
 314     public SequenceGroup findGroup(int i)\r
 315     {\r
 316         return findGroup(getSequenceAt(i));\r
 317     }\r
 318 \r
 319     /**    */\r
 320     public SequenceGroup findGroup(SequenceI s)\r
 321     {\r
 322         for (int i = 0; i < this.groups.size(); i++)\r
 323         {\r
 324             SequenceGroup sg = (SequenceGroup) groups.elementAt(i);\r
 325 \r
 326             if (sg.sequences.contains(s))\r
 327             {\r
 328                 return sg;\r
 329             }\r
 330         }\r
 331 \r
 332         return null;\r
 333     }\r
 334 \r
 335     /**\r
 336      * DOCUMENT ME!\r
 337      *\r
 338      * @param s DOCUMENT ME!\r
 339      *\r
 340      * @return DOCUMENT ME!\r
 341      */\r
 342     public SequenceGroup[] findAllGroups(SequenceI s)\r
 343     {\r
 344         Vector temp = new Vector();\r
 345 \r
 346         int gSize = groups.size();\r
 347         for (int i = 0; i < gSize; i++)\r
 348         {\r
 349             SequenceGroup sg = (SequenceGroup) groups.elementAt(i);\r
 350             if(sg==null || sg.sequences==null)\r
 351             {\r
 352               this.deleteGroup(sg);\r
 353               gSize--;\r
 354               continue;\r
 355             }\r
 356 \r
 357             if (sg.sequences.contains(s))\r
 358             {\r
 359                 temp.addElement(sg);\r
 360             }\r
 361         }\r
 362 \r
 363         SequenceGroup[] ret = new SequenceGroup[temp.size()];\r
 364 \r
 365         for (int i = 0; i < temp.size(); i++)\r
 366         {\r
 367             ret[i] = (SequenceGroup) temp.elementAt(i);\r
 368         }\r
 369 \r
 370         return ret;\r
 371     }\r
 372 \r
 373     /**\r
 374      * DOCUMENT ME!\r
 375      *\r
 376      * @param sg DOCUMENT ME!\r
 377      */\r
 378     public void addSuperGroup(SuperGroup sg)\r
 379     {\r
 380         superGroup.addElement(sg);\r
 381     }\r
 382 \r
 383     /**\r
 384      * DOCUMENT ME!\r
 385      *\r
 386      * @param sg DOCUMENT ME!\r
 387      */\r
 388     public void removeSuperGroup(SuperGroup sg)\r
 389     {\r
 390         superGroup.removeElement(sg);\r
 391     }\r
 392 \r
 393     /**\r
 394      * DOCUMENT ME!\r
 395      *\r
 396      * @param sg DOCUMENT ME!\r
 397      *\r
 398      * @return DOCUMENT ME!\r
 399      */\r
 400     public SuperGroup getSuperGroup(SequenceGroup sg)\r
 401     {\r
 402         for (int i = 0; i < this.superGroup.size(); i++)\r
 403         {\r
 404             SuperGroup temp = (SuperGroup) superGroup.elementAt(i);\r
 405 \r
 406             if (temp.sequenceGroups.contains(sg))\r
 407             {\r
 408                 return temp;\r
 409             }\r
 410         }\r
 411 \r
 412         return null;\r
 413     }\r
 414 \r
 415     /**    */\r
 416     public void addGroup(SequenceGroup sg)\r
 417     {\r
 418         if (!groups.contains(sg))\r
 419         {\r
 420             groups.addElement(sg);\r
 421         }\r
 422     }\r
 423 \r
 424     /**\r
 425      * DOCUMENT ME!\r
 426      */\r
 427     public void deleteAllGroups()\r
 428     {\r
 429         groups.removeAllElements();\r
 430         superGroup.removeAllElements();\r
 431 \r
 432         int i = 0;\r
 433 \r
 434         while (i < sequences.size())\r
 435         {\r
 436             SequenceI s = getSequenceAt(i);\r
 437             s.setColor(java.awt.Color.white);\r
 438             i++;\r
 439         }\r
 440     }\r
 441 \r
 442     /**    */\r
 443     public void deleteGroup(SequenceGroup g)\r
 444     {\r
 445         if (groups.contains(g))\r
 446         {\r
 447             groups.removeElement(g);\r
 448         }\r
 449     }\r
 450 \r
 451     /**    */\r
 452     public SequenceI findName(String name)\r
 453     {\r
 454         int i = 0;\r
 455 \r
 456         while (i < sequences.size())\r
 457         {\r
 458             if (getSequenceAt(i).getName().equals(name))\r
 459             {\r
 460                 return getSequenceAt(i);\r
 461             }\r
 462 \r
 463             i++;\r
 464         }\r
 465 \r
 466         return null;\r
 467     }\r
 468 \r
 469 \r
 470     /**    */\r
 471     public int findIndex(SequenceI s)\r
 472     {\r
 473         int i = 0;\r
 474 \r
 475         while (i < sequences.size())\r
 476         {\r
 477             if (s == getSequenceAt(i))\r
 478             {\r
 479                 return i;\r
 480             }\r
 481 \r
 482             i++;\r
 483         }\r
 484 \r
 485         return -1;\r
 486     }\r
 487 \r
 488     /**\r
 489      * DOCUMENT ME!\r
 490      *\r
 491      * @return DOCUMENT ME!\r
 492      */\r
 493     public int getHeight()\r
 494     {\r
 495         return sequences.size();\r
 496     }\r
 497 \r
 498     /**\r
 499      * DOCUMENT ME!\r
 500      *\r
 501      * @return DOCUMENT ME!\r
 502      */\r
 503     public int getWidth()\r
 504     {\r
 505         int maxLength = -1;\r
 506 \r
 507         for (int i = 0; i < sequences.size(); i++)\r
 508         {\r
 509             if (getSequenceAt(i).getLength() > maxLength)\r
 510             {\r
 511                 maxLength = getSequenceAt(i).getLength();\r
 512             }\r
 513         }\r
 514 \r
 515         return maxLength;\r
 516     }\r
 517 \r
 518     /**\r
 519      * DOCUMENT ME!\r
 520      *\r
 521      * @return DOCUMENT ME!\r
 522      */\r
 523     public int getMaxIdLength()\r
 524     {\r
 525         int max = 0;\r
 526         int i = 0;\r
 527 \r
 528         while (i < sequences.size())\r
 529         {\r
 530             SequenceI seq = getSequenceAt(i);\r
 531             String tmp = seq.getName() + "/" + seq.getStart() + "-" +\r
 532                 seq.getEnd();\r
 533 \r
 534             if (tmp.length() > max)\r
 535             {\r
 536                 max = tmp.length();\r
 537             }\r
 538 \r
 539             i++;\r
 540         }\r
 541 \r
 542         return max;\r
 543     }\r
 544 \r
 545     /**\r
 546      * DOCUMENT ME!\r
 547      *\r
 548      * @param gc DOCUMENT ME!\r
 549      */\r
 550     public void setGapCharacter(char gc)\r
 551     {\r
 552         gapCharacter = gc;\r
 553 \r
 554         for (int i = 0; i < sequences.size(); i++)\r
 555         {\r
 556             Sequence seq = (Sequence) sequences.elementAt(i);\r
 557             seq.sequence = seq.sequence.replace('.', gc);\r
 558             seq.sequence = seq.sequence.replace('-', gc);\r
 559             seq.sequence = seq.sequence.replace(' ', gc);\r
 560         }\r
 561     }\r
 562 \r
 563     /**\r
 564      * DOCUMENT ME!\r
 565      *\r
 566      * @return DOCUMENT ME!\r
 567      */\r
 568     public char getGapCharacter()\r
 569     {\r
 570         return gapCharacter;\r
 571     }\r
 572 \r
 573     /**\r
 574      * DOCUMENT ME!\r
 575      *\r
 576      * @return DOCUMENT ME!\r
 577      */\r
 578     public Vector getAAFrequency()\r
 579     {\r
 580         return AAFrequency.calculate(sequences, 0, getWidth());\r
 581     }\r
 582 \r
 583     /**\r
 584      * DOCUMENT ME!\r
 585      *\r
 586      * @return DOCUMENT ME!\r
 587      */\r
 588     public boolean isAligned()\r
 589     {\r
 590         int width = getWidth();\r
 591 \r
 592         for (int i = 0; i < sequences.size(); i++)\r
 593         {\r
 594             if (getSequenceAt(i).getLength() != width)\r
 595             {\r
 596                 return false;\r
 597             }\r
 598         }\r
 599 \r
 600         return true;\r
 601     }\r
 602 \r
 603     /**\r
 604      * DOCUMENT ME!\r
 605      *\r
 606      * @param aa DOCUMENT ME!\r
 607      */\r
 608     public void deleteAnnotation(AlignmentAnnotation aa)\r
 609     {\r
 610         int aSize = 1;\r
 611 \r
 612         if (annotations != null)\r
 613         {\r
 614             aSize = annotations.length;\r
 615         }\r
 616 \r
 617         AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize - 1];\r
 618 \r
 619         int tIndex = 0;\r
 620 \r
 621         for (int i = 0; i < aSize; i++)\r
 622         {\r
 623             if (annotations[i] == aa)\r
 624             {\r
 625                 continue;\r
 626             }\r
 627 \r
 628             temp[tIndex] = annotations[i];\r
 629             tIndex++;\r
 630         }\r
 631 \r
 632         annotations = temp;\r
 633     }\r
 634 \r
 635     /**\r
 636      * DOCUMENT ME!\r
 637      *\r
 638      * @param aa DOCUMENT ME!\r
 639      */\r
 640     public void addAnnotation(AlignmentAnnotation aa)\r
 641     {\r
 642         int aSize = 1;\r
 643 \r
 644         if (annotations != null)\r
 645         {\r
 646             aSize = annotations.length + 1;\r
 647         }\r
 648 \r
 649 \r
 650         AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize];\r
 651         int i = 0;\r
 652 \r
 653         if (aSize > 1)\r
 654         {\r
 655             for (i = 0; i < (aSize - 1); i++)\r
 656             {\r
 657                 temp[i] = annotations[i];\r
 658             }\r
 659         }\r
 660 \r
 661         temp[i] = aa;\r
 662 \r
 663         annotations = temp;\r
 664     }\r
 665 \r
 666     /**\r
 667      * DOCUMENT ME!\r
 668      *\r
 669      * @return DOCUMENT ME!\r
 670      */\r
 671     public AlignmentAnnotation[] getAlignmentAnnotation()\r
 672     {\r
 673         return annotations;\r
 674     }\r
 675 \r
 676     public void setNucleotide(boolean b)\r
 677     {\r
 678       if(b)\r
 679         type = NUCLEOTIDE;\r
 680       else\r
 681         type = PROTEIN;\r
 682     }\r
 683 \r
 684     public boolean isNucleotide()\r
 685     {\r
 686       if(type==NUCLEOTIDE)\r
 687         return true;\r
 688       else\r
 689         return false;\r
 690     }\r
 691 \r
 692     public void setDataset(Alignment data)\r
 693     {\r
 694       if(dataset==null && data==null)\r
 695       {\r
 696         // Create a new dataset for this alignment.\r
 697         // Can only be done once, if dataset is not null\r
 698         // This will not be performed\r
 699         Sequence[] seqs = new Sequence[getHeight()];\r
 700         for (int i = 0; i < getHeight(); i++)\r
 701         {\r
 702 \r
 703           seqs[i] = new Sequence(getSequenceAt(i).getName(),\r
 704                                  AlignSeq.extractGaps(\r
 705                                      jalview.util.Comparison.GapChars,\r
 706                                      getSequenceAt(i).getSequence()\r
 707                                  ),\r
 708                                  getSequenceAt(i).getStart(),\r
 709                                  getSequenceAt(i).getEnd());\r
 710 \r
 711           getSequenceAt(i).setDatasetSequence(seqs[i]);\r
 712         }\r
 713 \r
 714         dataset = new Alignment(seqs);\r
 715       }\r
 716       else if(dataset==null && data!=null)\r
 717       {\r
 718         dataset = data;\r
 719       }\r
 720     }\r
 721 \r
 722     public Alignment getDataset()\r
 723     {\r
 724       return dataset;\r
 725     }\r
 726 \r
 727     public void setProvenance(Provenance prov)\r
 728     {\r
 729       provenance = prov;\r
 730     }\r
 731     public Provenance getProvenance()\r
 732     {\r
 733       return provenance;\r
 734     }\r
 735 }\r