Formatted source
[jalview.git] / src / jalview / analysis / AAFrequency.java
index 02569ef..41c6599 100755 (executable)
 * along with this program; if not, write to the Free Software\r
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
 */\r
-\r
 package jalview.analysis;\r
 \r
-import jalview.jbgui.*;\r
+import jalview.analysis.*;\r
+\r
 import jalview.datamodel.*;\r
+\r
 import jalview.io.*;\r
-import jalview.analysis.*;\r
 \r
-import java.awt.*;\r
+import jalview.jbgui.*;\r
+\r
 import java.applet.Applet;\r
-import java.util.*;\r
-import java.net.*;\r
+\r
+import java.awt.*;\r
+\r
 import java.io.*;\r
 \r
-public class AAFrequency {\r
+import java.net.*;\r
 \r
+import java.util.*;\r
+\r
+\r
+public class AAFrequency {\r
     // Takes in a vector of sequences and column start and column end\r
     // and returns a vector of size (end-start+1). Each element of the\r
     // vector contains a hashtable with the keys being residues and\r
     // the values being the count of each residue in that column.\r
     // This class is used extensively in calculating alignment colourschemes\r
     // that depend on the amount of conservation in each alignment column.\r
+    public static Vector calculate(Vector sequences, int start, int end) {\r
+        Vector result = new Vector();\r
+\r
+        for (int i = start; i <= end; i++) {\r
+            Hashtable residueHash = new Hashtable();\r
+            int maxCount = 0;\r
+            String maxResidue = "-";\r
+            int nongap = 0;\r
+\r
+            for (int j = 0; j < sequences.size(); j++) {\r
+                if (sequences.elementAt(j) instanceof Sequence) {\r
+                    Sequence s = (Sequence) sequences.elementAt(j);\r
+\r
+                    if (s.getSequence().length() > i) {\r
+                        String res = s.getSequence().charAt(i) + "";\r
+\r
+                        if (!jalview.util.Comparison.isGap(res.charAt(0))) {\r
+                            nongap++;\r
+                        } else {\r
+                            res = "-"; // we always use this for gaps in the property vectors\r
+                        }\r
+\r
+                        if (residueHash.containsKey(res)) {\r
+                            int count = ((Integer) residueHash.get(res)).intValue();\r
+                            count++;\r
+\r
+                            if (!jalview.util.Comparison.isGap(res.charAt(0)) &&\r
+                                    (count >= maxCount)) {\r
+                                if (count > maxCount) {\r
+                                    maxResidue = res;\r
+                                } else if (maxResidue.indexOf(res) == -1) {\r
+                                    maxResidue += res;\r
+                                }\r
+\r
+                                maxCount = count;\r
+                            }\r
+\r
+                            residueHash.put(res, new Integer(count));\r
+                        } else {\r
+                            residueHash.put(res, new Integer(1));\r
+                        }\r
+                    } else {\r
+                        if (residueHash.containsKey("-")) {\r
+                            int count = ((Integer) residueHash.get("-")).intValue();\r
+                            count++;\r
+                            residueHash.put("-", new Integer(count));\r
+                        } else {\r
+                            residueHash.put("-", new Integer(1));\r
+                        }\r
+                    }\r
+                }\r
+            }\r
 \r
+            residueHash.put("maxCount", new Integer(maxCount));\r
 \r
-    public static Vector calculate(Vector sequences,int start,int end) {\r
-\r
-    Vector result = new Vector();\r
-\r
-    for (int i = start;i <= end; i++)\r
-    {\r
-\r
-      Hashtable residueHash = new Hashtable();\r
-      int       maxCount    = 0;\r
-      String    maxResidue  = "-";\r
-      int       nongap      = 0;\r
-      for (int j=0; j < sequences.size(); j++)\r
-      {\r
-\r
-        if (sequences.elementAt(j) instanceof Sequence)\r
-        {\r
-          Sequence s = (Sequence)sequences.elementAt(j);\r
-\r
-          if (s.getSequence().length() > i)\r
-          {\r
-\r
-            String res = s.getSequence().charAt(i)+"";\r
-\r
-            if (!jalview.util.Comparison.isGap(res.charAt(0)))\r
-              nongap++;\r
-            else\r
-              res = "-"; // we always use this for gaps in the property vectors\r
-\r
-            if (residueHash.containsKey(res))\r
-            {\r
-\r
-              int count = ((Integer)residueHash.get(res)).intValue() ;\r
-              count++;\r
-\r
-             if (!jalview.util.Comparison.isGap(res.charAt(0)) && count >= maxCount)\r
-              {\r
-\r
-                  if(count>maxCount)\r
-                      maxResidue = res;\r
-                  else if(maxResidue.indexOf(res)==-1)\r
-                      maxResidue += res;\r
-\r
-                  maxCount = count;\r
-             }\r
-\r
-              residueHash.put(res,new Integer(count));\r
+            if (maxCount < 0) {\r
+                System.out.println("asasa " + maxCount);\r
             }\r
-            else\r
-              residueHash.put(res,new Integer(1));\r
-\r
-\r
-          }\r
-          else\r
-          {\r
-            if (residueHash.containsKey("-"))\r
-            {\r
-              int count = ((Integer)residueHash.get("-")).intValue() ;\r
-              count++;\r
-              residueHash.put("-",new Integer(count));\r
-            }\r
-            else\r
-              residueHash.put("-",new Integer(1));\r
 \r
-          }\r
+            residueHash.put("maxResidue", maxResidue);\r
+            residueHash.put("size", new Integer(sequences.size()));\r
+            residueHash.put("nongap", new Integer(nongap));\r
+            result.addElement(residueHash);\r
         }\r
-      }\r
-\r
-      residueHash.put("maxCount",new Integer(maxCount));\r
-      if(maxCount<0)\r
-        System.out.println("asasa "+maxCount);\r
-      residueHash.put("maxResidue", maxResidue);\r
-      residueHash.put("size", new Integer(sequences.size()));\r
-      residueHash.put("nongap", new Integer(nongap));\r
-      result.addElement(residueHash);\r
-    }\r
-\r
-    return result;\r
-  }\r
 \r
-    public static Vector calculatePID(SequenceI refseq,Vector sequences,int window,int start,int end) {\r
-\r
-    Vector result = new Vector();\r
-\r
-    boolean init = true;\r
-\r
-\r
-    Vector prev = null;\r
-\r
-    for (int i = start;i <= end; i++) {\r
-       Vector values = new Vector();\r
+        return result;\r
+    }\r
 \r
-       result.addElement(values);\r
+    public static Vector calculatePID(SequenceI refseq, Vector sequences,\r
+        int window, int start, int end) {\r
+        Vector result = new Vector();\r
 \r
-       // If start < window/2 then set value to zero.\r
+        boolean init = true;\r
 \r
-       if (i< window/2 || i >= refseq.getSequence().length()-window/2) {\r
-           for (int j = 0; j < sequences.size(); j++) {\r
-               values.addElement(new Integer(0));\r
-           }\r
-       } else  if (init == true) {\r
-           init = false;\r
+        Vector prev = null;\r
 \r
-           int winstart = i-window/2;\r
-           int winend   = i+window/2;\r
+        for (int i = start; i <= end; i++) {\r
+            Vector values = new Vector();\r
 \r
-            if (window%2 != 0) {\r
-              winend++;\r
-            }\r
+            result.addElement(values);\r
 \r
-           for (int j = 0; j < sequences.size(); j++) {\r
-               values.addElement(new Integer(0));\r
-           }\r
-\r
-           for (int k = winstart; k <= winend; k++) {\r
-               String refchar = refseq.getSequence().substring(k,k+1);\r
-                if (jalview.util.Comparison.isGap(refchar.charAt(0)))\r
-                  refchar="-";\r
-                else {\r
-                  for (int j = 0; j < sequences.size(); j++) {\r
+            // If start < window/2 then set value to zero.\r
+            if ((i < (window / 2)) ||\r
+                    (i >= (refseq.getSequence().length() - (window / 2)))) {\r
+                for (int j = 0; j < sequences.size(); j++) {\r
+                    values.addElement(new Integer(0));\r
+                }\r
+            } else if (init == true) {\r
+                init = false;\r
 \r
-                    Sequence s = (Sequence)sequences.elementAt(j);\r
+                int winstart = i - (window / 2);\r
+                int winend = i + (window / 2);\r
 \r
-                    if (s.getSequence().length() > k) {\r
+                if ((window % 2) != 0) {\r
+                    winend++;\r
+                }\r
 \r
-                      String res = s.getSequence().substring(k,k+1); // no gapchar test needed\r
+                for (int j = 0; j < sequences.size(); j++) {\r
+                    values.addElement(new Integer(0));\r
+                }\r
 \r
-                      if (res.equals(refchar)) {\r
-                        int val = ((Integer)values.elementAt(j)).intValue();\r
-                        val++;\r
-                        values.setElementAt(new Integer(val),j);\r
-                      }\r
+                for (int k = winstart; k <= winend; k++) {\r
+                    String refchar = refseq.getSequence().substring(k, k + 1);\r
+\r
+                    if (jalview.util.Comparison.isGap(refchar.charAt(0))) {\r
+                        refchar = "-";\r
+                    } else {\r
+                        for (int j = 0; j < sequences.size(); j++) {\r
+                            Sequence s = (Sequence) sequences.elementAt(j);\r
+\r
+                            if (s.getSequence().length() > k) {\r
+                                String res = s.getSequence().substring(k, k +\r
+                                        1); // no gapchar test needed\r
+\r
+                                if (res.equals(refchar)) {\r
+                                    int val = ((Integer) values.elementAt(j)).intValue();\r
+                                    val++;\r
+                                    values.setElementAt(new Integer(val), j);\r
+                                }\r
+                            }\r
+                        }\r
                     }\r
-                  }\r
                 }\r
 \r
-              }\r
-\r
-           prev = values;\r
-       } else {\r
-           int winstart = i-window/2;\r
-           int winend   = i+window/2;\r
+                prev = values;\r
+            } else {\r
+                int winstart = i - (window / 2);\r
+                int winend = i + (window / 2);\r
 \r
-            if (window%2 != 0) {\r
-              winend++;\r
-            }\r
-           // We need to take the previous set of values\r
-           // subtract the pid at winstart-1\r
-           // and add the pid at winend;\r
-\r
-           String pre_refchar  = refseq.getSequence().substring(winstart-1,winstart);\r
-            String pos_refchar = "-";\r
-\r
-            if (refseq.getSequence().length() > winend) {\r
-             pos_refchar  = refseq.getSequence().substring(winend,winend+1);\r
-            }\r
-\r
-           for (int j = 0; j < sequences.size(); j++) {\r
-               // First copy the pid value from i-1\r
-\r
-               int val = ((Integer)prev.elementAt(j)).intValue();\r
-\r
-               Sequence s = (Sequence)sequences.elementAt(j);\r
-\r
-               String pre_char = s.getSequence().substring(winstart-1,winstart);\r
-\r
-                String pos_char = "-";\r
-\r
-                if (s.getSequence().length() > winend) {\r
-                 pos_char = s.getSequence().substring(winend,winend+1);\r
+                if ((window % 2) != 0) {\r
+                    winend++;\r
                 }\r
 \r
-               // Now substract 1 if the chars at winstart-1 match\r
-\r
-                if (jalview.util.Comparison.isGap(pre_refchar.charAt(0)) == false\r
-                    && pre_char.equals(pre_refchar)) {\r
-                   val--;\r
-               }\r
-\r
-                if (jalview.util.Comparison.isGap(pos_refchar.charAt(0)) == false\r
-                    && pos_char.equals(pos_refchar)) {\r
-                   val++;\r
-               }\r
-\r
-               values.addElement(new Integer(val));\r
+                // We need to take the previous set of values\r
+                // subtract the pid at winstart-1\r
+                // and add the pid at winend;\r
+                String pre_refchar = refseq.getSequence().substring(winstart -\r
+                        1, winstart);\r
+                String pos_refchar = "-";\r
 \r
+                if (refseq.getSequence().length() > winend) {\r
+                    pos_refchar = refseq.getSequence().substring(winend,\r
+                            winend + 1);\r
+                }\r
 \r
-           }\r
-           prev = values;\r
-       }\r
-    }\r
+                for (int j = 0; j < sequences.size(); j++) {\r
+                    // First copy the pid value from i-1\r
+                    int val = ((Integer) prev.elementAt(j)).intValue();\r
 \r
-    return result;\r
-    }\r
+                    Sequence s = (Sequence) sequences.elementAt(j);\r
 \r
-    public static Hashtable findBlocks(Vector seqs, int start, int end,Vector exc) {\r
+                    String pre_char = s.getSequence().substring(winstart - 1,\r
+                            winstart);\r
 \r
-       // start and end are in real (not relative coords);\r
+                    String pos_char = "-";\r
 \r
-       // The coords in the hashtable that is returned are in relative coords\r
-       // i.e. start from 0\r
+                    if (s.getSequence().length() > winend) {\r
+                        pos_char = s.getSequence().substring(winend, winend +\r
+                                1);\r
+                    }\r
 \r
-       Hashtable blocks = new Hashtable();\r
+                    // Now substract 1 if the chars at winstart-1 match\r
+                    if ((jalview.util.Comparison.isGap(pre_refchar.charAt(0)) == false) &&\r
+                            pre_char.equals(pre_refchar)) {\r
+                        val--;\r
+                    }\r
 \r
-       boolean prev = false;\r
-       int     bstart = -1;\r
+                    if ((jalview.util.Comparison.isGap(pos_refchar.charAt(0)) == false) &&\r
+                            pos_char.equals(pos_refchar)) {\r
+                        val++;\r
+                    }\r
 \r
-       for (int i = start; i <= end ; i++) {\r
-           SequenceI seq = (SequenceI)seqs.elementAt(0);\r
+                    values.addElement(new Integer(val));\r
+                }\r
 \r
-           char      c   = seq.getCharAt(i);\r
+                prev = values;\r
+            }\r
+        }\r
 \r
-           boolean found = true;\r
+        return result;\r
+    }\r
 \r
-           int j = 1;\r
+    public static Hashtable findBlocks(Vector seqs, int start, int end,\r
+        Vector exc) {\r
+        // start and end are in real (not relative coords);\r
+        // The coords in the hashtable that is returned are in relative coords\r
+        // i.e. start from 0\r
+        Hashtable blocks = new Hashtable();\r
 \r
-           while (j < seqs.size() && found == true) {\r
+        boolean prev = false;\r
+        int bstart = -1;\r
 \r
-               SequenceI jseq  = (SequenceI)seqs.elementAt(j);\r
+        for (int i = start; i <= end; i++) {\r
+            SequenceI seq = (SequenceI) seqs.elementAt(0);\r
 \r
-               if (!exc.contains(jseq)) {\r
+            char c = seq.getCharAt(i);\r
 \r
-                   char cc = jseq.getCharAt(i);\r
+            boolean found = true;\r
 \r
-                   if ( cc != c) {\r
-                       found = false;\r
-                   }\r
-               }\r
-               j++;\r
-           }\r
+            int j = 1;\r
 \r
+            while ((j < seqs.size()) && (found == true)) {\r
+                SequenceI jseq = (SequenceI) seqs.elementAt(j);\r
 \r
-           if (prev == false && found == true) {\r
-               bstart = i;\r
-           } else if (prev == true && found == false && bstart != -1) {\r
+                if (!exc.contains(jseq)) {\r
+                    char cc = jseq.getCharAt(i);\r
 \r
-               int blockstart = bstart-start;\r
-               int blocklen   = i-bstart;\r
+                    if (cc != c) {\r
+                        found = false;\r
+                    }\r
+                }\r
 \r
-               //System.out.println("Start len " + blockstart + " " + blocklen);\r
+                j++;\r
+            }\r
 \r
-               for (int jj = blockstart; jj < blockstart + blocklen;jj++) {\r
-                   blocks.put(new Integer(jj),new Integer(blocklen));\r
-               }\r
+            if ((prev == false) && (found == true)) {\r
+                bstart = i;\r
+            } else if ((prev == true) && (found == false) && (bstart != -1)) {\r
+                int blockstart = bstart - start;\r
+                int blocklen = i - bstart;\r
 \r
-               bstart = -1;\r
-           }\r
-           prev = found;\r
-       }\r
+                //System.out.println("Start len " + blockstart + " " + blocklen);\r
+                for (int jj = blockstart; jj < (blockstart + blocklen); jj++) {\r
+                    blocks.put(new Integer(jj), new Integer(blocklen));\r
+                }\r
 \r
-       if (bstart != -1) {\r
+                bstart = -1;\r
+            }\r
 \r
-           int blockstart = bstart-start;\r
-           int blocklen   = end-bstart;\r
+            prev = found;\r
+        }\r
 \r
-         //  System.out.println("Start len " + blockstart + " " + blocklen);\r
+        if (bstart != -1) {\r
+            int blockstart = bstart - start;\r
+            int blocklen = end - bstart;\r
 \r
-           for (int jj = blockstart; jj < blockstart + blocklen;jj++) {\r
-               blocks.put(new Integer(blockstart),new Integer(blocklen));\r
-           }\r
+            //  System.out.println("Start len " + blockstart + " " + blocklen);\r
+            for (int jj = blockstart; jj < (blockstart + blocklen); jj++) {\r
+                blocks.put(new Integer(blockstart), new Integer(blocklen));\r
+            }\r
+        }\r
 \r
-       }\r
-       return blocks;\r
+        return blocks;\r
     }\r
 \r
+    public static Hashtable findKmerCount(SequenceI seq, int start, int end,\r
+        int window, int step, Vector kmers) {\r
+        int tmpstart = start;\r
+        Hashtable vals = new Hashtable();\r
 \r
+        while (tmpstart <= end) {\r
+            String tmpstr = seq.getSequence().substring(tmpstart -\r
+                    (window / 2), tmpstart + (window / 2));\r
 \r
-    public static Hashtable findKmerCount(SequenceI seq, int start, int end,int window, int step,Vector kmers) {\r
-\r
-       int tmpstart = start;\r
-       Hashtable vals = new Hashtable();\r
+            int count = 0;\r
 \r
-       while (tmpstart <= end) {\r
+            //System.out.println("Str " + tmpstr);\r
+            for (int ii = 0; ii < kmers.size(); ii++) {\r
+                String kmer = ((SequenceI) kmers.elementAt(ii)).getSequence();\r
 \r
-           String tmpstr = seq.getSequence().substring(tmpstart-window/2,tmpstart+window/2);\r
+                int i = -1;\r
 \r
-           int count = 0;\r
+                while (tmpstr.indexOf(kmer, i) != -1) {\r
+                    i = tmpstr.indexOf(kmer, i);\r
 \r
-           //System.out.println("Str " + tmpstr);\r
-\r
-          for (int ii = 0; ii < kmers.size(); ii++) {\r
-              String kmer = ((SequenceI)kmers.elementAt(ii)).getSequence();\r
+                    i++;\r
+                    count++;\r
+                }\r
 \r
-              int i = -1;\r
+                ii++;\r
+            }\r
 \r
-              while (tmpstr.indexOf(kmer,i) != -1) {\r
-               i = tmpstr.indexOf(kmer,i);\r
+            vals.put(new Integer(tmpstart), new Integer(count));\r
+            tmpstart += step;\r
+        }\r
 \r
-               i++;\r
-               count++;\r
-              }\r
-              ii++;\r
-          }\r
-           vals.put(new Integer(tmpstart),new Integer(count));\r
-           tmpstart += step;\r
-       }\r
-       return vals;\r
+        return vals;\r
     }\r
 \r
-    public static Hashtable findBlockStarts(Vector seqs, int start, int end,Vector exc) {\r
-\r
-       // start and end are in real (not relative coords);\r
-\r
-       // The coords in the hashtable that is returned are in relative coords\r
-       // i.e. start from 0\r
+    public static Hashtable findBlockStarts(Vector seqs, int start, int end,\r
+        Vector exc) {\r
+        // start and end are in real (not relative coords);\r
+        // The coords in the hashtable that is returned are in relative coords\r
+        // i.e. start from 0\r
+        Hashtable blocks = new Hashtable();\r
 \r
-       Hashtable blocks = new Hashtable();\r
+        boolean prev = false;\r
+        int bstart = -1;\r
 \r
-       boolean prev = false;\r
-       int     bstart = -1;\r
+        for (int i = start; i <= end; i++) {\r
+            SequenceI seq = (SequenceI) seqs.elementAt(0);\r
 \r
-       for (int i = start; i <= end ; i++) {\r
-           SequenceI seq = (SequenceI)seqs.elementAt(0);\r
+            char c = seq.getCharAt(i);\r
 \r
-           char      c   = seq.getCharAt(i);\r
+            boolean found = true;\r
 \r
-           boolean found = true;\r
+            int j = 1;\r
 \r
-           int j = 1;\r
+            while ((j < seqs.size()) && (found == true)) {\r
+                SequenceI jseq = (SequenceI) seqs.elementAt(j);\r
 \r
-           while (j < seqs.size() && found == true) {\r
+                if (!exc.contains(jseq)) {\r
+                    char cc = jseq.getCharAt(i);\r
 \r
-               SequenceI jseq  = (SequenceI)seqs.elementAt(j);\r
-\r
-               if (!exc.contains(jseq)) {\r
-\r
-                   char cc = jseq.getCharAt(i);\r
-\r
-                   if ( cc != c) {\r
-                       found = false;\r
-                   }\r
-               }\r
-               j++;\r
-           }\r
-\r
-\r
-           if (prev == false && found == true) {\r
-               bstart = i;\r
-           } else if (prev == true && found == false && bstart != -1) {\r
+                    if (cc != c) {\r
+                        found = false;\r
+                    }\r
+                }\r
 \r
-               int blockstart = bstart-start;\r
-               int blocklen   = i-bstart;\r
+                j++;\r
+            }\r
 \r
-               //              System.out.println("Start len " + blockstart + " " + blocklen);\r
+            if ((prev == false) && (found == true)) {\r
+                bstart = i;\r
+            } else if ((prev == true) && (found == false) && (bstart != -1)) {\r
+                int blockstart = bstart - start;\r
+                int blocklen = i - bstart;\r
 \r
-               //for (int jj = blockstart; jj < blockstart + blocklen;jj++) {\r
-                   blocks.put(new Integer(blockstart),new Integer(blocklen));\r
-       //      }\r
+                //             System.out.println("Start len " + blockstart + " " + blocklen);\r
+                //for (int jj = blockstart; jj < blockstart + blocklen;jj++) {\r
+                blocks.put(new Integer(blockstart), new Integer(blocklen));\r
 \r
-               bstart = -1;\r
-           }\r
-           prev = found;\r
-       }\r
+                //     }\r
+                bstart = -1;\r
+            }\r
 \r
-       if (bstart != -1) {\r
+            prev = found;\r
+        }\r
 \r
-           int blockstart = bstart-start;\r
-           int blocklen   = end-bstart;\r
+        if (bstart != -1) {\r
+            int blockstart = bstart - start;\r
+            int blocklen = end - bstart;\r
 \r
-         //  System.out.println("Start len " + blockstart + " " + blocklen);\r
+            //  System.out.println("Start len " + blockstart + " " + blocklen);\r
+            //for (int jj = blockstart; jj < blockstart + blocklen;jj++) {\r
+            blocks.put(new Integer(blockstart), new Integer(blocklen));\r
 \r
-           //for (int jj = blockstart; jj < blockstart + blocklen;jj++) {\r
-               blocks.put(new Integer(blockstart),new Integer(blocklen));\r
-          // }\r
+            // }\r
+        }\r
 \r
-       }\r
-       return blocks;\r
+        return blocks;\r
     }\r
-\r
 }\r
-\r