various loadTree bits for loading and saving trees.
[jalview.git] / src / jalview / analysis / AAFrequency.java
1 package jalview.analysis;\r
2 \r
3 import jalview.jbgui.*;\r
4 import jalview.datamodel.*;\r
5 import jalview.io.*;\r
6 import jalview.analysis.*;\r
7 \r
8 import java.awt.*;\r
9 import java.applet.Applet;\r
10 import java.util.*;\r
11 import java.net.*;\r
12 import java.io.*;\r
13 \r
14 public class AAFrequency {\r
15 \r
16     // Takes in a vector of sequences and column start and column end\r
17     // and returns a vector of size (end-start+1). Each element of the\r
18     // vector contains a hashtable with the keys being residues and\r
19     // the values being the count of each residue in that column.\r
20     // This class is used extensively in calculating alignment colourschemes\r
21     // that depend on the amount of conservation in each alignment column.\r
22 \r
23     public static Vector calculate(Vector sequences,int start,int end) {\r
24 \r
25     Vector result = new Vector();\r
26 \r
27     for (int i = start;i <= end; i++)\r
28     {\r
29 \r
30       Hashtable residueHash = new Hashtable();\r
31       int       maxCount    = -1;\r
32       String    maxResidue  = "-";\r
33       int       nongap      = 0;\r
34       for (int j=0; j < sequences.size(); j++)\r
35       {\r
36 \r
37         if (sequences.elementAt(j) instanceof Sequence)\r
38         {\r
39           Sequence s = (Sequence)sequences.elementAt(j);\r
40 \r
41           if (s.getSequence().length() > i)\r
42           {\r
43 \r
44             String res = s.getSequence().substring(i,i+1);\r
45 \r
46             if (!res.equals("-"))\r
47               nongap++;\r
48 \r
49             if (residueHash.containsKey(res))\r
50             {\r
51 \r
52               int count = ((Integer)residueHash.get(res)).intValue() ;\r
53               count++;\r
54 \r
55               if (!res.equals("-") && count >= maxCount)\r
56               {\r
57 \r
58                   if(count>maxCount)\r
59                       maxResidue = res;\r
60                   else if(maxResidue.indexOf(res)==-1)\r
61                       maxResidue += res;\r
62 \r
63                   maxCount = count;\r
64               }\r
65 \r
66               residueHash.put(res,new Integer(count));\r
67             }\r
68             else\r
69               residueHash.put(res,new Integer(1));\r
70 \r
71 \r
72           }\r
73           else\r
74           {\r
75             if (residueHash.containsKey("-"))\r
76             {\r
77               int count = ((Integer)residueHash.get("-")).intValue() ;\r
78               count++;\r
79               residueHash.put("-",new Integer(count));\r
80             }\r
81             else\r
82               residueHash.put("-",new Integer(1));\r
83 \r
84           }\r
85         }\r
86       }\r
87       residueHash.put("maxCount",new Integer(maxCount));\r
88       residueHash.put("maxResidue", maxResidue);\r
89       residueHash.put("size", new Integer(sequences.size()));\r
90       residueHash.put("nongap", new Integer(nongap));\r
91       result.addElement(residueHash);\r
92     }\r
93 \r
94     return result;\r
95   }\r
96 \r
97     public static Vector calculatePID(SequenceI refseq,Vector sequences,int window,int start,int end) {\r
98 \r
99     Vector result = new Vector();\r
100 \r
101     boolean init = true;\r
102 \r
103 \r
104     Vector prev = null;\r
105 \r
106     for (int i = start;i <= end; i++) {\r
107         Vector values = new Vector();\r
108 \r
109         result.addElement(values);\r
110 \r
111         // If start < window/2 then set value to zero.\r
112 \r
113         if (i< window/2 || i >= refseq.getSequence().length()-window/2) {\r
114             for (int j = 0; j < sequences.size(); j++) {\r
115                 values.addElement(new Integer(0));\r
116             }\r
117         } else  if (init == true) {\r
118             init = false;\r
119 \r
120             int winstart = i-window/2;\r
121             int winend   = i+window/2;\r
122 \r
123             if (window%2 != 0) {\r
124               winend++;\r
125             }\r
126 \r
127             for (int j = 0; j < sequences.size(); j++) {\r
128                 values.addElement(new Integer(0));\r
129             }\r
130 \r
131             for (int k = winstart; k <= winend; k++) {\r
132                 String refchar = refseq.getSequence().substring(k,k+1);\r
133 \r
134                 for (int j = 0; j < sequences.size(); j++) {\r
135 \r
136                     if (refchar.equals("-") == false) {\r
137 \r
138                         Sequence s = (Sequence)sequences.elementAt(j);\r
139 \r
140                         if (s.getSequence().length() > k) {\r
141 \r
142                             String res = s.getSequence().substring(k,k+1);\r
143 \r
144                             if (res.equals(refchar)) {\r
145                                 int val = ((Integer)values.elementAt(j)).intValue();\r
146                                 val++;\r
147                                 values.setElementAt(new Integer(val),j);\r
148                             }\r
149                         }\r
150                     }\r
151                 }\r
152             }\r
153             prev = values;\r
154         } else {\r
155             int winstart = i-window/2;\r
156             int winend   = i+window/2;\r
157 \r
158             if (window%2 != 0) {\r
159               winend++;\r
160             }\r
161             // We need to take the previous set of values\r
162             // subtract the pid at winstart-1\r
163             // and add the pid at winend;\r
164 \r
165             String pre_refchar  = refseq.getSequence().substring(winstart-1,winstart);\r
166             String pos_refchar = "-";\r
167 \r
168             if (refseq.getSequence().length() > winend) {\r
169               pos_refchar  = refseq.getSequence().substring(winend,winend+1);\r
170             }\r
171 \r
172             for (int j = 0; j < sequences.size(); j++) {\r
173                 // First copy the pid value from i-1\r
174 \r
175                 int val = ((Integer)prev.elementAt(j)).intValue();\r
176 \r
177                 Sequence s = (Sequence)sequences.elementAt(j);\r
178 \r
179                 String pre_char = s.getSequence().substring(winstart-1,winstart);\r
180 \r
181                 String pos_char = "-";\r
182 \r
183                 if (s.getSequence().length() > winend) {\r
184                   pos_char = s.getSequence().substring(winend,winend+1);\r
185                 }\r
186 \r
187                 // Now substract 1 if the chars at winstart-1 match\r
188 \r
189                 if (pre_refchar.equals("-") == false && pre_char.equals(pre_refchar)) {\r
190                     val--;\r
191                 }\r
192 \r
193                 if (pos_refchar.equals("-") == false && pos_char.equals(pos_refchar)) {\r
194                     val++;\r
195                 }\r
196 \r
197                 values.addElement(new Integer(val));\r
198 \r
199 \r
200             }\r
201             prev = values;\r
202         }\r
203     }\r
204 \r
205     return result;\r
206     }\r
207 \r
208     public static Hashtable findBlocks(Vector seqs, int start, int end,Vector exc) {\r
209 \r
210         // start and end are in real (not relative coords);\r
211 \r
212         // The coords in the hashtable that is returned are in relative coords\r
213         // i.e. start from 0\r
214 \r
215         Hashtable blocks = new Hashtable();\r
216 \r
217         boolean prev = false;\r
218         int     bstart = -1;\r
219 \r
220         for (int i = start; i <= end ; i++) {\r
221             SequenceI seq = (SequenceI)seqs.elementAt(0);\r
222 \r
223             char      c   = seq.getCharAt(i);\r
224 \r
225             boolean found = true;\r
226 \r
227             int j = 1;\r
228 \r
229             while (j < seqs.size() && found == true) {\r
230 \r
231                 SequenceI jseq  = (SequenceI)seqs.elementAt(j);\r
232 \r
233                 if (!exc.contains(jseq)) {\r
234 \r
235                     char cc = jseq.getCharAt(i);\r
236 \r
237                     if ( cc != c) {\r
238                         found = false;\r
239                     }\r
240                 }\r
241                 j++;\r
242             }\r
243 \r
244 \r
245             if (prev == false && found == true) {\r
246                 bstart = i;\r
247             } else if (prev == true && found == false && bstart != -1) {\r
248 \r
249                 int blockstart = bstart-start;\r
250                 int blocklen   = i-bstart;\r
251 \r
252                 //System.out.println("Start len " + blockstart + " " + blocklen);\r
253 \r
254                 for (int jj = blockstart; jj < blockstart + blocklen;jj++) {\r
255                     blocks.put(new Integer(jj),new Integer(blocklen));\r
256                 }\r
257 \r
258                 bstart = -1;\r
259             }\r
260             prev = found;\r
261         }\r
262 \r
263         if (bstart != -1) {\r
264 \r
265             int blockstart = bstart-start;\r
266             int blocklen   = end-bstart;\r
267 \r
268           //  System.out.println("Start len " + blockstart + " " + blocklen);\r
269 \r
270             for (int jj = blockstart; jj < blockstart + blocklen;jj++) {\r
271                 blocks.put(new Integer(blockstart),new Integer(blocklen));\r
272             }\r
273 \r
274         }\r
275         return blocks;\r
276     }\r
277 \r
278 \r
279 \r
280     public static Hashtable findKmerCount(SequenceI seq, int start, int end,int window, int step,Vector kmers) {\r
281 \r
282        int tmpstart = start;\r
283        Hashtable vals = new Hashtable();\r
284 \r
285        while (tmpstart <= end) {\r
286 \r
287            String tmpstr = seq.getSequence().substring(tmpstart-window/2,tmpstart+window/2);\r
288 \r
289            int count = 0;\r
290 \r
291            //System.out.println("Str " + tmpstr);\r
292 \r
293            for (int ii = 0; ii < kmers.size(); ii++) {\r
294                String kmer = ((SequenceI)kmers.elementAt(ii)).getSequence();\r
295 \r
296                int i = -1;\r
297 \r
298                while (tmpstr.indexOf(kmer,i) != -1) {\r
299                i = tmpstr.indexOf(kmer,i);\r
300 \r
301                i++;\r
302                count++;\r
303                }\r
304                ii++;\r
305            }\r
306            vals.put(new Integer(tmpstart),new Integer(count));\r
307            tmpstart += step;\r
308        }\r
309        return vals;\r
310     }\r
311 \r
312     public static Hashtable findBlockStarts(Vector seqs, int start, int end,Vector exc) {\r
313 \r
314         // start and end are in real (not relative coords);\r
315 \r
316         // The coords in the hashtable that is returned are in relative coords\r
317         // i.e. start from 0\r
318 \r
319         Hashtable blocks = new Hashtable();\r
320 \r
321         boolean prev = false;\r
322         int     bstart = -1;\r
323 \r
324         for (int i = start; i <= end ; i++) {\r
325             SequenceI seq = (SequenceI)seqs.elementAt(0);\r
326 \r
327             char      c   = seq.getCharAt(i);\r
328 \r
329             boolean found = true;\r
330 \r
331             int j = 1;\r
332 \r
333             while (j < seqs.size() && found == true) {\r
334 \r
335                 SequenceI jseq  = (SequenceI)seqs.elementAt(j);\r
336 \r
337                 if (!exc.contains(jseq)) {\r
338 \r
339                     char cc = jseq.getCharAt(i);\r
340 \r
341                     if ( cc != c) {\r
342                         found = false;\r
343                     }\r
344                 }\r
345                 j++;\r
346             }\r
347 \r
348 \r
349             if (prev == false && found == true) {\r
350                 bstart = i;\r
351             } else if (prev == true && found == false && bstart != -1) {\r
352 \r
353                 int blockstart = bstart-start;\r
354                 int blocklen   = i-bstart;\r
355 \r
356                 //              System.out.println("Start len " + blockstart + " " + blocklen);\r
357 \r
358                 //for (int jj = blockstart; jj < blockstart + blocklen;jj++) {\r
359                     blocks.put(new Integer(blockstart),new Integer(blocklen));\r
360         //      }\r
361 \r
362                 bstart = -1;\r
363             }\r
364             prev = found;\r
365         }\r
366 \r
367         if (bstart != -1) {\r
368 \r
369             int blockstart = bstart-start;\r
370             int blocklen   = end-bstart;\r
371 \r
372           //  System.out.println("Start len " + blockstart + " " + blocklen);\r
373 \r
374             //for (int jj = blockstart; jj < blockstart + blocklen;jj++) {\r
375                 blocks.put(new Integer(blockstart),new Integer(blocklen));\r
376            // }\r
377 \r
378         }\r
379         return blocks;\r
380     }\r
381 \r
382 }\r
383 \r