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     String astr1 = "";\r
  73     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();\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 = seq2start-2;\r
 415         int alignpos = seq1start-2;\r
 416 \r
 417 \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 \r
 436        /* for(int i=0; i<mapping.length; i++)\r
 437         {\r
 438           if(mapping[i]!=-1)\r
 439             System.out.println(i+" "+s2.getCharAt(i) + " " + mapping[i] + " " +\r
 440                                s1.findIndex(mapping[i])+" "+\r
 441                                s1.getCharAt(s1.findIndex(mapping[i])-1));\r
 442           else\r
 443             System.out.println(i+" "+"XX"+s2.getCharAt(i));\r
 444         }*/\r
 445 \r
 446         return mapping;\r
 447     }\r
 448 \r
 449     /**\r
 450      * DOCUMENT ME!\r
 451      */\r
 452     public void printAlignment(java.io.PrintStream os)\r
 453     {\r
 454         // Find the biggest id length for formatting purposes\r
 455         int maxid = s1.getName().length();\r
 456 \r
 457         if (s2.getName().length() > maxid)\r
 458         {\r
 459             maxid = s2.getName().length();\r
 460         }\r
 461 \r
 462         int len = 72 - maxid - 1;\r
 463         int nochunks = ((aseq1.length - count) / len) + 1;\r
 464         pid = 0;\r
 465 \r
 466         output.append("Score = " + score[maxi][maxj] + "\n");\r
 467         output.append("Length of alignment = " + (aseq1.length - count) + "\n");\r
 468         output.append("Sequence ");\r
 469         output.append(new Format("%" + maxid + "s").form(s1.getName()));\r
 470         output.append(" :  " + seq1start + " - " + seq1end + " (Sequence length = " +\r
 471             s1str.length() + ")\n");\r
 472         output .append("Sequence ");\r
 473         output.append(new Format("%" + maxid + "s").form(s2.getName()));\r
 474         output .append(" :  " + seq2start + " - " + seq2end + " (Sequence length = " +\r
 475             s2str.length() + ")\n\n");\r
 476 \r
 477         for (int j = 0; j < nochunks; j++)\r
 478         {\r
 479             // Print the first aligned sequence\r
 480             output.append(new Format("%" + (maxid) + "s").form(s1.getName()) + " ");\r
 481 \r
 482             for (int i = 0; i < len; i++)\r
 483             {\r
 484                 if ((count + i + (j * len)) < aseq1.length)\r
 485                 {\r
 486                     output.append(new Format("%s").form(intToStr[aseq1[count + i +\r
 487                             (j * len)]]));\r
 488                 }\r
 489             }\r
 490 \r
 491             output.append("\n");\r
 492             output.append(new Format("%" + (maxid) + "s").form(" ") + " ");\r
 493 \r
 494             // Print out the matching chars\r
 495             for (int i = 0; i < len; i++)\r
 496             {\r
 497                 if ((count + i + (j * len)) < aseq1.length)\r
 498                 {\r
 499                     if (intToStr[aseq1[count + i + (j * len)]].equals(\r
 500                                 intToStr[aseq2[count + i + (j * len)]]) &&\r
 501                             !intToStr[aseq1[count + i + (j * len)]].equals("-"))\r
 502                     {\r
 503                         pid++;\r
 504                         output.append("|");\r
 505                     }\r
 506                     else if (type.equals("pep"))\r
 507                     {\r
 508                         if (ResidueProperties.getPAM250(\r
 509                                     intToStr[aseq1[count + i + (j * len)]],\r
 510                                     intToStr[aseq2[count + i + (j * len)]]) > 0)\r
 511                         {\r
 512                             output.append(".");\r
 513                         }\r
 514                         else\r
 515                         {\r
 516                             output.append(" ");\r
 517                         }\r
 518                     }\r
 519                     else\r
 520                     {\r
 521                         output.append(" ");\r
 522                     }\r
 523                 }\r
 524             }\r
 525 \r
 526             // Now print the second aligned sequence\r
 527             output = output.append("\n");\r
 528             output = output.append(new Format("%" + (maxid) + "s").form(s2.getName()) + " ");\r
 529 \r
 530             for (int i = 0; i < len; i++)\r
 531             {\r
 532                 if ((count + i + (j * len)) < aseq1.length)\r
 533                 {\r
 534                     output .append(new Format("%s").form(intToStr[aseq2[count + i +\r
 535                             (j * len)]]));\r
 536                 }\r
 537             }\r
 538 \r
 539             output = output .append("\n\n");\r
 540         }\r
 541 \r
 542         pid = pid / (float) (aseq1.length - count) * 100;\r
 543         output = output.append(new Format("Percentage ID = %2.2f\n\n").form(pid));\r
 544 \r
 545         try{\r
 546           os.println(output.toString());\r
 547         }catch(Exception ex){}\r
 548     }\r
 549 \r
 550     /**\r
 551      * DOCUMENT ME!\r
 552      *\r
 553      * @param mat DOCUMENT ME!\r
 554      */\r
 555     public void printScoreMatrix(int[][] mat)\r
 556     {\r
 557         int n = seq1.length;\r
 558         int m = seq2.length;\r
 559 \r
 560         for (int i = 0; i < n; i++)\r
 561         {\r
 562             // Print the top sequence\r
 563             if (i == 0)\r
 564             {\r
 565                 Format.print(System.out, "%8s", s2str.substring(0, 1));\r
 566 \r
 567                 for (int jj = 1; jj < m; jj++)\r
 568                 {\r
 569                     Format.print(System.out, "%5s", s2str.substring(jj, jj + 1));\r
 570                 }\r
 571 \r
 572                 System.out.println();\r
 573             }\r
 574 \r
 575             for (int j = 0; j < m; j++)\r
 576             {\r
 577                 if (j == 0)\r
 578                 {\r
 579                     Format.print(System.out, "%3s", s1str.substring(i, i + 1));\r
 580                 }\r
 581 \r
 582                 Format.print(System.out, "%3d ", mat[i][j] / 10);\r
 583             }\r
 584 \r
 585             System.out.println();\r
 586         }\r
 587     }\r
 588 \r
 589     /**\r
 590      * DOCUMENT ME!\r
 591      *\r
 592      * @param i DOCUMENT ME!\r
 593      * @param j DOCUMENT ME!\r
 594      *\r
 595      * @return DOCUMENT ME!\r
 596      */\r
 597     public int findTrace(int i, int j)\r
 598     {\r
 599         int t = 0;\r
 600         int max = score[i - 1][j - 1] + (lookup[seq1[i]][seq2[j]] * 10);\r
 601 \r
 602         if (F[i][j] > max)\r
 603         {\r
 604             max = F[i][j];\r
 605             t = -1;\r
 606         }\r
 607         else if (F[i][j] == max)\r
 608         {\r
 609             if (prev == -1)\r
 610             {\r
 611                 max = F[i][j];\r
 612                 t = -1;\r
 613             }\r
 614         }\r
 615 \r
 616         if (E[i][j] >= max)\r
 617         {\r
 618             max = E[i][j];\r
 619             t = 1;\r
 620         }\r
 621         else if (E[i][j] == max)\r
 622         {\r
 623             if (prev == 1)\r
 624             {\r
 625                 max = E[i][j];\r
 626                 t = 1;\r
 627             }\r
 628         }\r
 629 \r
 630         prev = t;\r
 631 \r
 632         return t;\r
 633     }\r
 634 \r
 635     /**\r
 636      * DOCUMENT ME!\r
 637      */\r
 638     public void calcScoreMatrix()\r
 639     {\r
 640         int n = seq1.length;\r
 641         int m = seq2.length;\r
 642 \r
 643         // top left hand element\r
 644         score[0][0] = lookup[seq1[0]][seq2[0]] * 10;\r
 645         E[0][0] = -gapExtend;\r
 646         F[0][0] = 0;\r
 647 \r
 648         // Calculate the top row first\r
 649         for (int j = 1; j < m; j++)\r
 650         {\r
 651             // What should these values be? 0 maybe\r
 652             E[0][j] = max(score[0][j - 1] - gapOpen, E[0][j - 1] - gapExtend);\r
 653             F[0][j] = -gapExtend;\r
 654 \r
 655             score[0][j] = max(lookup[seq1[0]][seq2[j]] * 10, -gapOpen,\r
 656                     -gapExtend);\r
 657 \r
 658             traceback[0][j] = 1;\r
 659         }\r
 660 \r
 661         // Now do the left hand column\r
 662         for (int i = 1; i < n; i++)\r
 663         {\r
 664             E[i][0] = -gapOpen;\r
 665             F[i][0] = max(score[i - 1][0] - gapOpen, F[i - 1][0] - gapExtend);\r
 666 \r
 667             score[i][0] = max(lookup[seq1[i]][seq2[0]] * 10, E[i][0], F[i][0]);\r
 668             traceback[i][0] = -1;\r
 669         }\r
 670 \r
 671         // Now do all the other rows\r
 672         for (int i = 1; i < n; i++)\r
 673         {\r
 674             for (int j = 1; j < m; j++)\r
 675             {\r
 676                 E[i][j] = max(score[i][j - 1] - gapOpen, E[i][j - 1] -\r
 677                         gapExtend);\r
 678                 F[i][j] = max(score[i - 1][j] - gapOpen, F[i - 1][j] -\r
 679                         gapExtend);\r
 680 \r
 681                 score[i][j] = max(score[i - 1][j - 1] +\r
 682                         (lookup[seq1[i]][seq2[j]] * 10), E[i][j], F[i][j]);\r
 683                 traceback[i][j] = findTrace(i, j);\r
 684             }\r
 685         }\r
 686     }\r
 687 \r
 688 \r
 689 \r
 690     /**\r
 691      * DOCUMENT ME!\r
 692      *\r
 693      * @param gapChar DOCUMENT ME!\r
 694      * @param seq DOCUMENT ME!\r
 695      *\r
 696      * @return DOCUMENT ME!\r
 697      */\r
 698     public static String extractGaps(String gapChar, String seq)\r
 699     {\r
 700         StringTokenizer str = new StringTokenizer(seq, gapChar);\r
 701         StringBuffer newString = new StringBuffer();\r
 702 \r
 703         while (str.hasMoreTokens())\r
 704         {\r
 705             newString.append( str.nextToken() );\r
 706         }\r
 707 \r
 708         return newString.toString();\r
 709     }\r
 710 \r
 711     /**\r
 712      * DOCUMENT ME!\r
 713      *\r
 714      * @param i1 DOCUMENT ME!\r
 715      * @param i2 DOCUMENT ME!\r
 716      * @param i3 DOCUMENT ME!\r
 717      *\r
 718      * @return DOCUMENT ME!\r
 719      */\r
 720     public int max(int i1, int i2, int i3)\r
 721     {\r
 722         int max = i1;\r
 723 \r
 724         if (i2 > i1)\r
 725         {\r
 726             max = i2;\r
 727         }\r
 728 \r
 729         if (i3 > max)\r
 730         {\r
 731             max = i3;\r
 732         }\r
 733 \r
 734         return max;\r
 735     }\r
 736 \r
 737     /**\r
 738      * DOCUMENT ME!\r
 739      *\r
 740      * @param i1 DOCUMENT ME!\r
 741      * @param i2 DOCUMENT ME!\r
 742      *\r
 743      * @return DOCUMENT ME!\r
 744      */\r
 745     public int max(int i1, int i2)\r
 746     {\r
 747         int max = i1;\r
 748 \r
 749         if (i2 > i1)\r
 750         {\r
 751             max = i2;\r
 752         }\r
 753 \r
 754         return max;\r
 755     }\r
 756 \r
 757     /**\r
 758      * DOCUMENT ME!\r
 759      *\r
 760      * @param s DOCUMENT ME!\r
 761      * @param type DOCUMENT ME!\r
 762      *\r
 763      * @return DOCUMENT ME!\r
 764      */\r
 765     public int[] stringToInt(String s, String type)\r
 766     {\r
 767         int[] seq1 = new int[s.length()];\r
 768 \r
 769         for (int i = 0; i < s.length(); i++)\r
 770         {\r
 771             String ss = s.substring(i, i + 1).toUpperCase();\r
 772 \r
 773             try\r
 774             {\r
 775                 if (type.equals("pep"))\r
 776                 {\r
 777                     seq1[i] = ((Integer) ResidueProperties.aaHash.get(ss)).intValue();\r
 778                 }\r
 779                 else if (type.equals("dna"))\r
 780                 {\r
 781                     seq1[i] = ((Integer) dnaHash.get(ss)).intValue();\r
 782                 }\r
 783 \r
 784                 if (seq1[i] > 23)\r
 785                 {\r
 786                     seq1[i] = 23;\r
 787                 }\r
 788             }\r
 789             catch (Exception e)\r
 790             {\r
 791                 if (type.equals("dna"))\r
 792                 {\r
 793                     seq1[i] = 4;\r
 794                 }\r
 795                 else\r
 796                 {\r
 797                     seq1[i] = 23;\r
 798                 }\r
 799             }\r
 800         }\r
 801 \r
 802         return seq1;\r
 803     }\r
 804 \r
 805     /**\r
 806      * DOCUMENT ME!\r
 807      *\r
 808      * @param g DOCUMENT ME!\r
 809      * @param mat DOCUMENT ME!\r
 810      * @param n DOCUMENT ME!\r
 811      * @param m DOCUMENT ME!\r
 812      * @param psize DOCUMENT ME!\r
 813      */\r
 814     public static void displayMatrix(Graphics g, int[][] mat, int n, int m,\r
 815         int psize)\r
 816     {\r
 817         int max = -1000;\r
 818         int min = 1000;\r
 819 \r
 820         for (int i = 0; i < n; i++)\r
 821         {\r
 822             for (int j = 0; j < m; j++)\r
 823             {\r
 824                 if (mat[i][j] >= max)\r
 825                 {\r
 826                     max = mat[i][j];\r
 827                 }\r
 828 \r
 829                 if (mat[i][j] <= min)\r
 830                 {\r
 831                     min = mat[i][j];\r
 832                 }\r
 833             }\r
 834         }\r
 835 \r
 836         System.out.println(max + " " + min);\r
 837 \r
 838         for (int i = 0; i < n; i++)\r
 839         {\r
 840             for (int j = 0; j < m; j++)\r
 841             {\r
 842                 int x = psize * i;\r
 843                 int y = psize * j;\r
 844 \r
 845                 //      System.out.println(mat[i][j]);\r
 846                 float score = (float) (mat[i][j] - min) / (float) (max - min);\r
 847                 g.setColor(new Color(score, 0, 0));\r
 848                 g.fillRect(x, y, psize, psize);\r
 849 \r
 850                 //      System.out.println(x + " " + y + " " + score);\r
 851             }\r
 852         }\r
 853     }\r
 854 }\r