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