src/jalview/analysis/AlignSeq.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.analysis;\r
  20 \r
  21 import jalview.datamodel.SequenceI;\r
  22 \r
  23 import jalview.schemes.*;\r
  24 \r
  25 import jalview.util.*;\r
  26 \r
  27 import java.awt.*;\r
  28 \r
  29 import java.util.*;\r
  30 \r
  31 \r
  32 /**\r
  33  *\r
  34  *\r
  35  * @author $author$\r
  36  * @version $Revision$\r
  37  */\r
  38 public class AlignSeq\r
  39 {\r
  40     /** DOCUMENT ME!! */\r
  41     public static java.util.Hashtable dnaHash = new java.util.Hashtable();\r
  42 \r
  43     static\r
  44     {\r
  45         dnaHash.put("C", new Integer(0));\r
  46         dnaHash.put("T", new Integer(1));\r
  47         dnaHash.put("A", new Integer(2));\r
  48         dnaHash.put("G", new Integer(3));\r
  49         dnaHash.put("-", new Integer(4));\r
  50     }\r
  51 \r
  52     static String[] dna = { "C", "T", "A", "G", "-" };\r
  53     static String[] pep =\r
  54     {\r
  55         "A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F",\r
  56         "P", "S", "T", "W", "Y", "V", "B", "Z", "X", "-"\r
  57     };\r
  58     int[][] score;\r
  59     int[][] E;\r
  60     int[][] F;\r
  61     int[][] traceback;\r
  62     int[] seq1;\r
  63     int[] seq2;\r
  64     SequenceI s1;\r
  65     SequenceI s2;\r
  66     String s1str;\r
  67     String s2str;\r
  68     int maxi;\r
  69     int maxj;\r
  70     int[] aseq1;\r
  71     int[] aseq2;\r
  72     public String astr1 = "";\r
  73     public String astr2 = "";\r
  74 \r
  75     /** DOCUMENT ME!! */\r
  76     public int seq1start;\r
  77 \r
  78     /** DOCUMENT ME!! */\r
  79     public int seq1end;\r
  80 \r
  81     /** DOCUMENT ME!! */\r
  82     public int seq2start;\r
  83 \r
  84     /** DOCUMENT ME!! */\r
  85     public int seq2end;\r
  86     int count;\r
  87 \r
  88     /** DOCUMENT ME!! */\r
  89     public int maxscore;\r
  90     float pid;\r
  91     int prev = 0;\r
  92     int gapOpen = 120;\r
  93     int gapExtend = 20;\r
  94     int[][] lookup = ResidueProperties.getBLOSUM62();\r
  95     String[] intToStr = pep;\r
  96     int defInt = 23;\r
  97     StringBuffer output = new StringBuffer();\r
  98     String type;\r
  99     Runtime rt;\r
 100 \r
 101 \r
 102     /**\r
 103      * Creates a new AlignSeq object.\r
 104      *\r
 105      * @param s1 DOCUMENT ME!\r
 106      * @param s2 DOCUMENT ME!\r
 107      * @param type DOCUMENT ME!\r
 108      */\r
 109     public AlignSeq(SequenceI s1, SequenceI s2, String type)\r
 110     {\r
 111         rt = Runtime.getRuntime();\r
 112         SeqInit(s1, s2, type);\r
 113     }\r
 114 \r
 115     /**\r
 116      * DOCUMENT ME!\r
 117      *\r
 118      * @return DOCUMENT ME!\r
 119      */\r
 120     public int getMaxScore()\r
 121     {\r
 122         return maxscore;\r
 123     }\r
 124 \r
 125     /**\r
 126      * DOCUMENT ME!\r
 127      *\r
 128      * @return DOCUMENT ME!\r
 129      */\r
 130     public int getSeq2Start()\r
 131     {\r
 132         return seq2start;\r
 133     }\r
 134 \r
 135     /**\r
 136      * DOCUMENT ME!\r
 137      *\r
 138      * @return DOCUMENT ME!\r
 139      */\r
 140     public int getSeq2End()\r
 141     {\r
 142         return seq2end;\r
 143     }\r
 144 \r
 145     /**\r
 146      * DOCUMENT ME!\r
 147      *\r
 148      * @return DOCUMENT ME!\r
 149      */\r
 150     public int getSeq1Start()\r
 151     {\r
 152         return seq1start;\r
 153     }\r
 154 \r
 155     /**\r
 156      * DOCUMENT ME!\r
 157      *\r
 158      * @return DOCUMENT ME!\r
 159      */\r
 160     public int getSeq1End()\r
 161     {\r
 162         return seq1end;\r
 163     }\r
 164 \r
 165     /**\r
 166      * DOCUMENT ME!\r
 167      *\r
 168      * @return DOCUMENT ME!\r
 169      */\r
 170     public String getOutput()\r
 171     {\r
 172         return output.toString();\r
 173     }\r
 174 \r
 175     /**\r
 176      * DOCUMENT ME!\r
 177      *\r
 178      * @return DOCUMENT ME!\r
 179      */\r
 180     public String getAStr1()\r
 181     {\r
 182         return astr1;\r
 183     }\r
 184 \r
 185     /**\r
 186      * DOCUMENT ME!\r
 187      *\r
 188      * @return DOCUMENT ME!\r
 189      */\r
 190     public String getAStr2()\r
 191     {\r
 192         return astr2;\r
 193     }\r
 194 \r
 195     /**\r
 196      * DOCUMENT ME!\r
 197      *\r
 198      * @return DOCUMENT ME!\r
 199      */\r
 200     public int[] getASeq1()\r
 201     {\r
 202         return aseq1;\r
 203     }\r
 204 \r
 205     /**\r
 206      * DOCUMENT ME!\r
 207      *\r
 208      * @return DOCUMENT ME!\r
 209      */\r
 210     public int[] getASeq2()\r
 211     {\r
 212         return aseq2;\r
 213     }\r
 214 \r
 215     /**\r
 216      * DOCUMENT ME!\r
 217      *\r
 218      * @return DOCUMENT ME!\r
 219      */\r
 220     public SequenceI getS1()\r
 221     {\r
 222         return s1;\r
 223     }\r
 224 \r
 225     /**\r
 226      * DOCUMENT ME!\r
 227      *\r
 228      * @return DOCUMENT ME!\r
 229      */\r
 230     public SequenceI getS2()\r
 231     {\r
 232         return s2;\r
 233     }\r
 234 \r
 235     /**\r
 236      * DOCUMENT ME!\r
 237      *\r
 238      * @param s1 DOCUMENT ME!\r
 239      * @param s2 DOCUMENT ME!\r
 240      * @param type DOCUMENT ME!\r
 241      */\r
 242     public void SeqInit(SequenceI s1, SequenceI s2, String type)\r
 243     {\r
 244         s1str = extractGaps(jalview.util.Comparison.GapChars, s1.getSequence());\r
 245         s2str = extractGaps(jalview.util.Comparison.GapChars, s2.getSequence());\r
 246 \r
 247         this.s1 = s1;\r
 248         this.s2 = s2;\r
 249 \r
 250         this.type = type;\r
 251 \r
 252         if (type.equals("pep"))\r
 253         {\r
 254             lookup = ResidueProperties.getBLOSUM62();\r
 255             intToStr = pep;\r
 256             defInt = 23;\r
 257         }\r
 258         else if (type.equals("dna"))\r
 259         {\r
 260             lookup = ResidueProperties.getDNA();\r
 261             intToStr = dna;\r
 262             defInt = 4;\r
 263         }\r
 264         else\r
 265         {\r
 266             output.append("Wrong type = dna or pep only");\r
 267             System.exit(0);\r
 268         }\r
 269 \r
 270         //System.out.println("lookuip " + rt.freeMemory() + " "+  rt.totalMemory());\r
 271         seq1 = new int[s1str.length()];\r
 272 \r
 273         //System.out.println("seq1 " + rt.freeMemory() +" "  + rt.totalMemory());\r
 274         seq2 = new int[s2str.length()];\r
 275 \r
 276         //System.out.println("seq2 " + rt.freeMemory() + " " + rt.totalMemory());\r
 277         score = new int[s1str.length()][s2str.length()];\r
 278 \r
 279         //System.out.println("score " + rt.freeMemory() + " " + rt.totalMemory());\r
 280         E = new int[s1str.length()][s2str.length()];\r
 281 \r
 282         //System.out.println("E " + rt.freeMemory() + " " + rt.totalMemory());\r
 283         F = new int[s1str.length()][s2str.length()];\r
 284         traceback = new int[s1str.length()][s2str.length()];\r
 285 \r
 286         //System.out.println("F " + rt.freeMemory() + " " + rt.totalMemory());\r
 287         seq1 = stringToInt(s1str, type);\r
 288 \r
 289         //System.out.println("seq1 " + rt.freeMemory() + " " + rt.totalMemory());\r
 290         seq2 = stringToInt(s2str, type);\r
 291 \r
 292         //System.out.println("Seq2 " + rt.freeMemory() + " " + rt.totalMemory());\r
 293         //   long tstart = System.currentTimeMillis();\r
 294         //    calcScoreMatrix();\r
 295         //long tend = System.currentTimeMillis();\r
 296         //System.out.println("Time take to calculate score matrix = " + (tend-tstart) + " ms");\r
 297         //   printScoreMatrix(score);\r
 298         //System.out.println();\r
 299         //printScoreMatrix(traceback);\r
 300         //System.out.println();\r
 301         //  printScoreMatrix(E);\r
 302         //System.out.println();\r
 303         ///printScoreMatrix(F);\r
 304         //System.out.println();\r
 305         // tstart = System.currentTimeMillis();\r
 306         //traceAlignment();\r
 307         //tend = System.currentTimeMillis();\r
 308         //System.out.println("Time take to traceback alignment = " + (tend-tstart) + " ms");\r
 309     }\r
 310 \r
 311     /**\r
 312      * DOCUMENT ME!\r
 313      */\r
 314     public void traceAlignment()\r
 315     {\r
 316         // Find the maximum score along the rhs or bottom row\r
 317         int max = -9999;\r
 318 \r
 319         for (int i = 0; i < seq1.length; i++)\r
 320         {\r
 321             if (score[i][seq2.length - 1] > max)\r
 322             {\r
 323                 max = score[i][seq2.length - 1];\r
 324                 maxi = i;\r
 325                 maxj = seq2.length - 1;\r
 326             }\r
 327         }\r
 328 \r
 329         for (int j = 0; j < seq2.length; j++)\r
 330         {\r
 331             if (score[seq1.length - 1][j] > max)\r
 332             {\r
 333                 max = score[seq1.length - 1][j];\r
 334                 maxi = seq1.length - 1;\r
 335                 maxj = j;\r
 336             }\r
 337         }\r
 338 \r
 339         //  System.out.println(maxi + " " + maxj + " " + score[maxi][maxj]);\r
 340         int i = maxi;\r
 341         int j = maxj;\r
 342         int trace;\r
 343         maxscore = score[i][j] / 10;\r
 344 \r
 345         seq1end = maxi + 1;\r
 346         seq2end = maxj + 1;\r
 347 \r
 348         aseq1 = new int[seq1.length + seq2.length];\r
 349         aseq2 = new int[seq1.length + seq2.length];\r
 350 \r
 351         count = (seq1.length + seq2.length) - 1;\r
 352 \r
 353         while ((i > 0) && (j > 0))\r
 354         {\r
 355             if ((aseq1[count] != defInt) && (i >= 0))\r
 356             {\r
 357                 aseq1[count] = seq1[i];\r
 358                 astr1 = intToStr[seq1[i]] + astr1;\r
 359             }\r
 360 \r
 361             if ((aseq2[count] != defInt) && (j > 0))\r
 362             {\r
 363                 aseq2[count] = seq2[j];\r
 364                 astr2 = intToStr[seq2[j]] + astr2;\r
 365             }\r
 366 \r
 367             trace = findTrace(i, j);\r
 368 \r
 369             if (trace == 0)\r
 370             {\r
 371                 i--;\r
 372                 j--;\r
 373             }\r
 374             else if (trace == 1)\r
 375             {\r
 376                 j--;\r
 377                 aseq1[count] = defInt;\r
 378                 astr1 = "-" + astr1.substring(1);\r
 379             }\r
 380             else if (trace == -1)\r
 381             {\r
 382                 i--;\r
 383                 aseq2[count] = defInt;\r
 384                 astr2 = "-" + astr2.substring(1);\r
 385             }\r
 386 \r
 387             count--;\r
 388         }\r
 389 \r
 390         seq1start = i + 1;\r
 391         seq2start = j + 1;\r
 392 \r
 393         if (aseq1[count] != defInt)\r
 394         {\r
 395             aseq1[count] = seq1[i];\r
 396             astr1 = intToStr[seq1[i]] + astr1;\r
 397         }\r
 398 \r
 399         if (aseq2[count] != defInt)\r
 400         {\r
 401             aseq2[count] = seq2[j];\r
 402             astr2 = intToStr[seq2[j]] + astr2;\r
 403         }\r
 404     }\r
 405 \r
 406     public int [] getExactMapping()\r
 407     {\r
 408         // Print out the matching chars\r
 409         int size = s2.getLength()+1;\r
 410         int [] mapping = new int[size];\r
 411         for(int i=0; i<size; i++)\r
 412           mapping[i] = -1;\r
 413 \r
 414         int pdbpos = s2.getStart() + seq2start-3;\r
 415         int alignpos = s1.getStart() + seq1start-3;\r
 416 \r
 417 System.out.println(pdbpos+" "+alignpos);\r
 418         for(int i=0; i<astr1.length(); i++)\r
 419         {\r
 420             if (astr1.charAt(i) != '-')\r
 421             {\r
 422               alignpos++;\r
 423             }\r
 424 \r
 425             if (astr2.charAt(i) != '-')\r
 426             {\r
 427               pdbpos++;\r
 428             }\r
 429 \r
 430             if (astr1.charAt(i) == astr2.charAt(i))\r
 431             {\r
 432               mapping[pdbpos] = alignpos;\r
 433             }\r
 434         }\r
 435 System.out.println(s1.getStart()+" "+s2.getStart()+" "+seq1start+" "+seq2start+"\n"+\r
 436                            s1.getSequence()+"\n"+s2.getSequence()+"\n"+astr1+"\n"+astr2);\r
 437 \r
 438         for(int i=0; i<mapping.length; i++)\r
 439         {\r
 440           if(mapping[i]!=-1)\r
 441             System.out.println(i+" "+s2.getCharAt(i) + " " + mapping[i] + " " +\r
 442                                s1.findIndex(mapping[i]+1)+" "+\r
 443                                s1.getCharAt(s1.findIndex(mapping[i])));\r
 444           else\r
 445             System.out.println(i+" "+"XX"+s2.getCharAt(i));\r
 446         }\r
 447 \r
 448         return mapping;\r
 449     }\r
 450 \r
 451     /**\r
 452      * DOCUMENT ME!\r
 453      */\r
 454     public void printAlignment(java.io.PrintStream os)\r
 455     {\r
 456         // Find the biggest id length for formatting purposes\r
 457         int maxid = s1.getName().length();\r
 458 \r
 459         if (s2.getName().length() > maxid)\r
 460         {\r
 461             maxid = s2.getName().length();\r
 462         }\r
 463 \r
 464         int len = 72 - maxid - 1;\r
 465         int nochunks = ((aseq1.length - count) / len) + 1;\r
 466         pid = 0;\r
 467 \r
 468         output.append("Score = " + score[maxi][maxj] + "\n");\r
 469         output.append("Length of alignment = " + (aseq1.length - count) + "\n");\r
 470         output.append("Sequence ");\r
 471         output.append(new Format("%" + maxid + "s").form(s1.getName()));\r
 472         output.append(" :  " + seq1start + " - " + seq1end + " (Sequence length = " +\r
 473             s1str.length() + ")\n");\r
 474         output .append("Sequence ");\r
 475         output.append(new Format("%" + maxid + "s").form(s2.getName()));\r
 476         output .append(" :  " + seq2start + " - " + seq2end + " (Sequence length = " +\r
 477             s2str.length() + ")\n\n");\r
 478 \r
 479         for (int j = 0; j < nochunks; j++)\r
 480         {\r
 481             // Print the first aligned sequence\r
 482             output.append(new Format("%" + (maxid) + "s").form(s1.getName()) + " ");\r
 483 \r
 484             for (int i = 0; i < len; i++)\r
 485             {\r
 486                 if ((count + i + (j * len)) < aseq1.length)\r
 487                 {\r
 488                     output.append(new Format("%s").form(intToStr[aseq1[count + i +\r
 489                             (j * len)]]));\r
 490                 }\r
 491             }\r
 492 \r
 493             output.append("\n");\r
 494             output.append(new Format("%" + (maxid) + "s").form(" ") + " ");\r
 495 \r
 496             // Print out the matching chars\r
 497             for (int i = 0; i < len; i++)\r
 498             {\r
 499                 if ((count + i + (j * len)) < aseq1.length)\r
 500                 {\r
 501                     if (intToStr[aseq1[count + i + (j * len)]].equals(\r
 502                                 intToStr[aseq2[count + i + (j * len)]]) &&\r
 503                             !intToStr[aseq1[count + i + (j * len)]].equals("-"))\r
 504                     {\r
 505                         pid++;\r
 506                         output.append("|");\r
 507                     }\r
 508                     else if (type.equals("pep"))\r
 509                     {\r
 510                         if (ResidueProperties.getPAM250(\r
 511                                     intToStr[aseq1[count + i + (j * len)]],\r
 512                                     intToStr[aseq2[count + i + (j * len)]]) > 0)\r
 513                         {\r
 514                             output.append(".");\r
 515                         }\r
 516                         else\r
 517                         {\r
 518                             output.append(" ");\r
 519                         }\r
 520                     }\r
 521                     else\r
 522                     {\r
 523                         output.append(" ");\r
 524                     }\r
 525                 }\r
 526             }\r
 527 \r
 528             // Now print the second aligned sequence\r
 529             output = output.append("\n");\r
 530             output = output.append(new Format("%" + (maxid) + "s").form(s2.getName()) + " ");\r
 531 \r
 532             for (int i = 0; i < len; i++)\r
 533             {\r
 534                 if ((count + i + (j * len)) < aseq1.length)\r
 535                 {\r
 536                     output .append(new Format("%s").form(intToStr[aseq2[count + i +\r
 537                             (j * len)]]));\r
 538                 }\r
 539             }\r
 540 \r
 541             output = output .append("\n\n");\r
 542         }\r
 543 \r
 544         pid = pid / (float) (aseq1.length - count) * 100;\r
 545         output = output.append(new Format("Percentage ID = %2.2f\n\n").form(pid));\r
 546 \r
 547         try{\r
 548           os.println(output.toString());\r
 549         }catch(Exception ex){}\r
 550     }\r
 551 \r
 552     /**\r
 553      * DOCUMENT ME!\r
 554      *\r
 555      * @param mat DOCUMENT ME!\r
 556      */\r
 557     public void printScoreMatrix(int[][] mat)\r
 558     {\r
 559         int n = seq1.length;\r
 560         int m = seq2.length;\r
 561 \r
 562         for (int i = 0; i < n; i++)\r
 563         {\r
 564             // Print the top sequence\r
 565             if (i == 0)\r
 566             {\r
 567                 Format.print(System.out, "%8s", s2str.substring(0, 1));\r
 568 \r
 569                 for (int jj = 1; jj < m; jj++)\r
 570                 {\r
 571                     Format.print(System.out, "%5s", s2str.substring(jj, jj + 1));\r
 572                 }\r
 573 \r
 574                 System.out.println();\r
 575             }\r
 576 \r
 577             for (int j = 0; j < m; j++)\r
 578             {\r
 579                 if (j == 0)\r
 580                 {\r
 581                     Format.print(System.out, "%3s", s1str.substring(i, i + 1));\r
 582                 }\r
 583 \r
 584                 Format.print(System.out, "%3d ", mat[i][j] / 10);\r
 585             }\r
 586 \r
 587             System.out.println();\r
 588         }\r
 589     }\r
 590 \r
 591     /**\r
 592      * DOCUMENT ME!\r
 593      *\r
 594      * @param i DOCUMENT ME!\r
 595      * @param j DOCUMENT ME!\r
 596      *\r
 597      * @return DOCUMENT ME!\r
 598      */\r
 599     public int findTrace(int i, int j)\r
 600     {\r
 601         int t = 0;\r
 602         int max = score[i - 1][j - 1] + (lookup[seq1[i]][seq2[j]] * 10);\r
 603 \r
 604         if (F[i][j] > max)\r
 605         {\r
 606             max = F[i][j];\r
 607             t = -1;\r
 608         }\r
 609         else if (F[i][j] == max)\r
 610         {\r
 611             if (prev == -1)\r
 612             {\r
 613                 max = F[i][j];\r
 614                 t = -1;\r
 615             }\r
 616         }\r
 617 \r
 618         if (E[i][j] >= max)\r
 619         {\r
 620             max = E[i][j];\r
 621             t = 1;\r
 622         }\r
 623         else if (E[i][j] == max)\r
 624         {\r
 625             if (prev == 1)\r
 626             {\r
 627                 max = E[i][j];\r
 628                 t = 1;\r
 629             }\r
 630         }\r
 631 \r
 632         prev = t;\r
 633 \r
 634         return t;\r
 635     }\r
 636 \r
 637     /**\r
 638      * DOCUMENT ME!\r
 639      */\r
 640     public void calcScoreMatrix()\r
 641     {\r
 642         int n = seq1.length;\r
 643         int m = seq2.length;\r
 644 \r
 645         // top left hand element\r
 646         score[0][0] = lookup[seq1[0]][seq2[0]] * 10;\r
 647         E[0][0] = -gapExtend;\r
 648         F[0][0] = 0;\r
 649 \r
 650         // Calculate the top row first\r
 651         for (int j = 1; j < m; j++)\r
 652         {\r
 653             // What should these values be? 0 maybe\r
 654             E[0][j] = max(score[0][j - 1] - gapOpen, E[0][j - 1] - gapExtend);\r
 655             F[0][j] = -gapExtend;\r
 656 \r
 657             score[0][j] = max(lookup[seq1[0]][seq2[j]] * 10, -gapOpen,\r
 658                     -gapExtend);\r
 659 \r
 660             traceback[0][j] = 1;\r
 661         }\r
 662 \r
 663         // Now do the left hand column\r
 664         for (int i = 1; i < n; i++)\r
 665         {\r
 666             E[i][0] = -gapOpen;\r
 667             F[i][0] = max(score[i - 1][0] - gapOpen, F[i - 1][0] - gapExtend);\r
 668 \r
 669             score[i][0] = max(lookup[seq1[i]][seq2[0]] * 10, E[i][0], F[i][0]);\r
 670             traceback[i][0] = -1;\r
 671         }\r
 672 \r
 673         // Now do all the other rows\r
 674         for (int i = 1; i < n; i++)\r
 675         {\r
 676             for (int j = 1; j < m; j++)\r
 677             {\r
 678                 E[i][j] = max(score[i][j - 1] - gapOpen, E[i][j - 1] -\r
 679                         gapExtend);\r
 680                 F[i][j] = max(score[i - 1][j] - gapOpen, F[i - 1][j] -\r
 681                         gapExtend);\r
 682 \r
 683                 score[i][j] = max(score[i - 1][j - 1] +\r
 684                         (lookup[seq1[i]][seq2[j]] * 10), E[i][j], F[i][j]);\r
 685                 traceback[i][j] = findTrace(i, j);\r
 686             }\r
 687         }\r
 688     }\r
 689 \r
 690 \r
 691 \r
 692     /**\r
 693      * DOCUMENT ME!\r
 694      *\r
 695      * @param gapChar DOCUMENT ME!\r
 696      * @param seq DOCUMENT ME!\r
 697      *\r
 698      * @return DOCUMENT ME!\r
 699      */\r
 700     public static String extractGaps(String gapChar, String seq)\r
 701     {\r
 702         StringTokenizer str = new StringTokenizer(seq, gapChar);\r
 703         StringBuffer newString = new StringBuffer();\r
 704 \r
 705         while (str.hasMoreTokens())\r
 706         {\r
 707             newString.append( str.nextToken() );\r
 708         }\r
 709 \r
 710         return newString.toString();\r
 711     }\r
 712 \r
 713     /**\r
 714      * DOCUMENT ME!\r
 715      *\r
 716      * @param i1 DOCUMENT ME!\r
 717      * @param i2 DOCUMENT ME!\r
 718      * @param i3 DOCUMENT ME!\r
 719      *\r
 720      * @return DOCUMENT ME!\r
 721      */\r
 722     public int max(int i1, int i2, int i3)\r
 723     {\r
 724         int max = i1;\r
 725 \r
 726         if (i2 > i1)\r
 727         {\r
 728             max = i2;\r
 729         }\r
 730 \r
 731         if (i3 > max)\r
 732         {\r
 733             max = i3;\r
 734         }\r
 735 \r
 736         return max;\r
 737     }\r
 738 \r
 739     /**\r
 740      * DOCUMENT ME!\r
 741      *\r
 742      * @param i1 DOCUMENT ME!\r
 743      * @param i2 DOCUMENT ME!\r
 744      *\r
 745      * @return DOCUMENT ME!\r
 746      */\r
 747     public int max(int i1, int i2)\r
 748     {\r
 749         int max = i1;\r
 750 \r
 751         if (i2 > i1)\r
 752         {\r
 753             max = i2;\r
 754         }\r
 755 \r
 756         return max;\r
 757     }\r
 758 \r
 759     /**\r
 760      * DOCUMENT ME!\r
 761      *\r
 762      * @param s DOCUMENT ME!\r
 763      * @param type DOCUMENT ME!\r
 764      *\r
 765      * @return DOCUMENT ME!\r
 766      */\r
 767     public int[] stringToInt(String s, String type)\r
 768     {\r
 769         int[] seq1 = new int[s.length()];\r
 770 \r
 771         for (int i = 0; i < s.length(); i++)\r
 772         {\r
 773             String ss = s.substring(i, i + 1).toUpperCase();\r
 774 \r
 775             try\r
 776             {\r
 777                 if (type.equals("pep"))\r
 778                 {\r
 779                     seq1[i] = ((Integer) ResidueProperties.aaHash.get(ss)).intValue();\r
 780                 }\r
 781                 else if (type.equals("dna"))\r
 782                 {\r
 783                     seq1[i] = ((Integer) dnaHash.get(ss)).intValue();\r
 784                 }\r
 785 \r
 786                 if (seq1[i] > 23)\r
 787                 {\r
 788                     seq1[i] = 23;\r
 789                 }\r
 790             }\r
 791             catch (Exception e)\r
 792             {\r
 793                 if (type.equals("dna"))\r
 794                 {\r
 795                     seq1[i] = 4;\r
 796                 }\r
 797                 else\r
 798                 {\r
 799                     seq1[i] = 23;\r
 800                 }\r
 801             }\r
 802         }\r
 803 \r
 804         return seq1;\r
 805     }\r
 806 \r
 807     /**\r
 808      * DOCUMENT ME!\r
 809      *\r
 810      * @param g DOCUMENT ME!\r
 811      * @param mat DOCUMENT ME!\r
 812      * @param n DOCUMENT ME!\r
 813      * @param m DOCUMENT ME!\r
 814      * @param psize DOCUMENT ME!\r
 815      */\r
 816     public static void displayMatrix(Graphics g, int[][] mat, int n, int m,\r
 817         int psize)\r
 818     {\r
 819         int max = -1000;\r
 820         int min = 1000;\r
 821 \r
 822         for (int i = 0; i < n; i++)\r
 823         {\r
 824             for (int j = 0; j < m; j++)\r
 825             {\r
 826                 if (mat[i][j] >= max)\r
 827                 {\r
 828                     max = mat[i][j];\r
 829                 }\r
 830 \r
 831                 if (mat[i][j] <= min)\r
 832                 {\r
 833                     min = mat[i][j];\r
 834                 }\r
 835             }\r
 836         }\r
 837 \r
 838         System.out.println(max + " " + min);\r
 839 \r
 840         for (int i = 0; i < n; i++)\r
 841         {\r
 842             for (int j = 0; j < m; j++)\r
 843             {\r
 844                 int x = psize * i;\r
 845                 int y = psize * j;\r
 846 \r
 847                 //      System.out.println(mat[i][j]);\r
 848                 float score = (float) (mat[i][j] - min) / (float) (max - min);\r
 849                 g.setColor(new Color(score, 0, 0));\r
 850                 g.fillRect(x, y, psize, psize);\r
 851 \r
 852                 //      System.out.println(x + " " + y + " " + score);\r
 853             }\r
 854         }\r
 855     }\r
 856 }\r