elementAt instead of get for 1.1 compatibility
[jalview.git] / 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