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