X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FConservation.java;h=75dec63ac63c6930428fba667e573786f5c38a36;hb=refs%2Fheads%2Freleases%2FRelease_2_10_0_Branch;hp=1f7913bf8c497095ea48dfccb27ba5990f5495da;hpb=2de8acfae59aced665e4c37ad0f7dcc2ed68818e;p=jalview.git diff --git a/src/jalview/analysis/Conservation.java b/src/jalview/analysis/Conservation.java index 1f7913b..75dec63 100755 --- a/src/jalview/analysis/Conservation.java +++ b/src/jalview/analysis/Conservation.java @@ -1,26 +1,36 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1) - * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. + * This file is part of Jalview. * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.analysis; -import java.util.*; +import jalview.datamodel.AlignmentAnnotation; +import jalview.datamodel.Annotation; +import jalview.datamodel.Sequence; +import jalview.datamodel.SequenceI; +import jalview.schemes.ResidueProperties; -import jalview.datamodel.*; +import java.awt.Color; +import java.util.Hashtable; +import java.util.List; +import java.util.Map; +import java.util.Vector; /** * Calculates conservation values for a given set of sequences @@ -36,13 +46,14 @@ public class Conservation int end; - Vector seqNums; // vector of int vectors where first is sequence checksum + Vector seqNums; // vector of int vectors where first is sequence + // checksum int maxLength = 0; // used by quality calcs boolean seqNumsChanged = false; // updated after any change via calcSeqNum; - Hashtable[] total; + Map[] total; boolean canonicaliseAa = true; // if true then conservation calculation will @@ -51,46 +62,39 @@ public class Conservation // symbol /** Stores calculated quality values */ - public Vector quality; + private Vector quality; /** Stores maximum and minimum values of quality values */ - public Double[] qualityRange = new Double[2]; - - String consString = ""; + private double[] qualityRange = new double[2]; - Sequence consSequence; + private Sequence consSequence; - Hashtable propHash; + private int threshold; - int threshold; + private String name = ""; - String name = ""; + private int[][] cons2; - int[][] cons2; + private String[] consSymbs; /** * Creates a new Conservation object. * * @param name - * Name of conservation - * @param propHash - * hash of properties for each symbol + * Name of conservation * @param threshold - * to count the residues in residueHash(). commonly used value - * is 3 + * to count the residues in residueHash(). commonly used value is 3 * @param sequences - * sequences to be used in calculation + * sequences to be used in calculation * @param start - * start residue position + * start residue position * @param end - * end residue position + * end residue position */ - public Conservation(String name, Hashtable propHash, int threshold, - Vector sequences, int start, int end) + public Conservation(String name, int threshold, + List sequences, int start, int end) { - this.name = name; - this.propHash = propHash; this.threshold = threshold; this.start = start; this.end = end; @@ -101,14 +105,22 @@ public class Conservation int s, sSize = sequences.size(); SequenceI[] sarray = new SequenceI[sSize]; this.sequences = sarray; - - for (s = 0; s < sSize; s++) + try { - sarray[s] = (SequenceI) sequences.elementAt(s); - if (sarray[s].getLength() > maxLength) + for (s = 0; s < sSize; s++) { - maxLength = sarray[s].getLength(); + sarray[s] = sequences.get(s); + if (sarray[s].getLength() > maxLength) + { + maxLength = sarray[s].getLength(); + } } + } catch (ArrayIndexOutOfBoundsException ex) + { + // bail - another thread has modified the sequence array, so the current + // calculation is probably invalid. + this.sequences = new SequenceI[0]; + maxLength = 0; } } @@ -134,7 +146,7 @@ public class Conservation seqNums.addElement(new int[sq.length() + 1]); } - if (sq.hashCode() != ((int[]) seqNums.elementAt(i))[0]) + if (sq.hashCode() != seqNums.elementAt(i)[0]) { int j; int len; @@ -176,12 +188,9 @@ public class Conservation */ public void calculate() { - Hashtable resultHash, ht; int thresh, j, jSize = sequences.length; int[] values; // Replaces residueHash - String type, res = null; char c; - Enumeration enumeration2; total = new Hashtable[maxLength]; @@ -197,8 +206,7 @@ public class Conservation if (canonicaliseAa) { // lookup the base aa code symbol - c = (char) jalview.schemes.ResidueProperties.aaIndex[sequences[j] - .getCharAt(i)]; + c = (char) ResidueProperties.aaIndex[sequences[j].getCharAt(i)]; if (c > 20) { c = '-'; @@ -206,7 +214,7 @@ public class Conservation else { // recover canonical aa symbol - c = jalview.schemes.ResidueProperties.aa[c].charAt(0); + c = ResidueProperties.aa[c].charAt(0); } } else @@ -218,10 +226,7 @@ public class Conservation c = '-'; } - if (!canonicaliseAa && 'a' <= c && c <= 'z') - { - c -= (32); // 32 = 'a' - 'A' - } + c = toUpperCase(c); } values[c]++; } @@ -235,21 +240,18 @@ public class Conservation thresh = (threshold * (jSize)) / 100; // loop over all the found residues - resultHash = new Hashtable(); + Hashtable resultHash = new Hashtable(); for (char v = '-'; v < 'Z'; v++) { if (values[v] > thresh) { - res = String.valueOf(v); + String res = String.valueOf(v); // Now loop over the properties - enumeration2 = propHash.keys(); - - while (enumeration2.hasMoreElements()) + for (String type : ResidueProperties.propHash.keySet()) { - type = (String) enumeration2.nextElement(); - ht = (Hashtable) propHash.get(type); + Map ht = ResidueProperties.propHash.get(type); // Have we ticked this before? if (!resultHash.containsKey(type)) @@ -263,8 +265,7 @@ public class Conservation resultHash.put(type, ht.get("-")); } } - else if (((Integer) resultHash.get(type)).equals((Integer) ht - .get(res)) == false) + else if (!resultHash.get(type).equals(ht.get(res))) { resultHash.put(type, new Integer(-1)); } @@ -272,7 +273,10 @@ public class Conservation } } - total[i - start] = resultHash; + if (total.length > 0) + { + total[i - start] = resultHash; + } } } @@ -307,6 +311,7 @@ public class Conservation } else { + c = toUpperCase(c); nres++; if (nres == 1) @@ -328,24 +333,33 @@ public class Conservation } /** + * Returns the upper-cased character if between 'a' and 'z', else the + * unchanged value + * + * @param c + * @return + */ + char toUpperCase(char c) + { + if ('a' <= c && c <= 'z') + { + c -= (32); // 32 = 'a' - 'A' + } + return c; + } + + /** * Calculates the conservation sequence * * @param consflag - * if true, poitiveve conservation; false calculates negative - * conservation + * if true, positive conservation; false calculates negative + * conservation * @param percentageGaps - * commonly used value is 25 + * commonly used value is 25 */ public void verdict(boolean consflag, float percentageGaps) { StringBuffer consString = new StringBuffer(); - String type; - Integer result; - int[] gapcons; - int totGaps, count; - float pgaps; - Hashtable resultHash; - Enumeration enumeration; // NOTE THIS SHOULD CHECK IF THE CONSEQUENCE ALREADY // EXISTS AND NOT OVERWRITE WITH '-', BUT THIS CASE @@ -354,38 +368,43 @@ public class Conservation { consString.append('-'); } - + consSymbs = new String[end - start + 1]; for (int i = start; i <= end; i++) { - gapcons = countConsNGaps(i); - totGaps = gapcons[1]; - pgaps = ((float) totGaps * 100) / (float) sequences.length; + int[] gapcons = countConsNGaps(i); + int totGaps = gapcons[1]; + float pgaps = ((float) totGaps * 100) / sequences.length; + consSymbs[i - start] = new String(); if (percentageGaps > pgaps) { - resultHash = total[i - start]; - + Map resultHash = total[i - start]; // Now find the verdict - count = 0; - enumeration = resultHash.keys(); - - while (enumeration.hasMoreElements()) + int count = 0; + for (String type : resultHash.keySet()) { - type = (String) enumeration.nextElement(); - result = (Integer) resultHash.get(type); - + int result = resultHash.get(type).intValue(); // Do we want to count +ve conservation or +ve and -ve cons.? if (consflag) { - if (result.intValue() == 1) + if (result == 1) { + consSymbs[i - start] = type + " " + consSymbs[i - start]; count++; } } else { - if (result.intValue() != -1) + if (result != -1) { + if (result == 0) + { + consSymbs[i - start] = consSymbs[i - start] + " !" + type; + } + else + { + consSymbs[i - start] = type + " " + consSymbs[i - start]; + } count++; } } @@ -430,7 +449,7 @@ public class Conservation */ private void percentIdentity2() { - seqNums = new Vector(); + seqNums = new Vector(); // calcSeqNum(s); int i = 0, iSize = sequences.length; // Do we need to calculate this again? @@ -457,7 +476,7 @@ public class Conservation while (j < sequences.length) { - sqnum = (int[]) seqNums.elementAt(j); + sqnum = seqNums.elementAt(j); for (i = 1; i < sqnum.length; i++) { @@ -487,17 +506,17 @@ public class Conservation /** * Calculates the quality of the set of sequences * - * @param start - * Start residue - * @param end - * End residue + * @param startRes + * Start residue + * @param endRes + * End residue */ - public void findQuality(int start, int end) + public void findQuality(int startRes, int endRes) { - quality = new Vector(); + quality = new Vector(); double max = -10000; - int[][] BLOSUM62 = jalview.schemes.ResidueProperties.getBLOSUM62(); + int[][] BLOSUM62 = ResidueProperties.getBLOSUM62(); // Loop over columns // JBPNote Profiling info // long ts = System.currentTimeMillis(); @@ -512,10 +531,10 @@ public class Conservation for (l = 0; l < size; l++) { - lengths[l] = ((int[]) seqNums.elementAt(l)).length - 1; + lengths[l] = seqNums.elementAt(l).length - 1; } - for (j = start; j <= end; j++) + for (j = startRes; j <= endRes; j++) { bigtot = 0; @@ -539,8 +558,10 @@ public class Conservation { tot = 0; xx = new double[24]; - seqNum = (j < lengths[k]) ? ((int[]) seqNums.elementAt(k))[j + 1] - : 23; // Sequence, or gap at the end + seqNum = (j < lengths[k]) ? seqNums.elementAt(k)[j + 1] : 23; // Sequence, + // or gap + // at the + // end // This is a loop over r for (i = 0; i < 23; i++) @@ -573,9 +594,9 @@ public class Conservation double newmax = -10000; - for (j = start; j <= end; j++) + for (j = startRes; j <= endRes; j++) { - tmp = ((Double) quality.elementAt(j)).doubleValue(); + tmp = quality.elementAt(j).doubleValue(); tmp = ((max - tmp) * (size - cons2[j][23])) / size; // System.out.println(tmp+ " " + j); @@ -588,7 +609,146 @@ public class Conservation } // System.out.println("Quality " + s); - qualityRange[0] = new Double(0); - qualityRange[1] = new Double(newmax); + qualityRange[0] = 0D; + qualityRange[1] = newmax; + } + + /** + * Complete the given consensus and quuality annotation rows. Note: currently + * this method will enlarge the given annotation row if it is too small, + * otherwise will leave its length unchanged. + * + * @param conservation + * conservation annotation row + * @param quality2 + * (optional - may be null) + * @param istart + * first column for conservation + * @param alWidth + * extent of conservation + */ + public void completeAnnotations(AlignmentAnnotation conservation, + AlignmentAnnotation quality2, int istart, int alWidth) + { + char[] sequence = getConsSequence().getSequence(); + float minR; + float minG; + float minB; + float maxR; + float maxG; + float maxB; + minR = 0.3f; + minG = 0.0f; + minB = 0f; + maxR = 1.0f - minR; + maxG = 0.9f - minG; + maxB = 0f - minB; // scalable range for colouring both Conservation and + // Quality + + float min = 0f; + float max = 11f; + float qmin = 0f; + float qmax = 0f; + + char c; + + if (conservation != null && conservation.annotations != null + && conservation.annotations.length < alWidth) + { + conservation.annotations = new Annotation[alWidth]; + } + + if (quality2 != null) + { + quality2.graphMax = (float) qualityRange[1]; + if (quality2.annotations != null + && quality2.annotations.length < alWidth) + { + quality2.annotations = new Annotation[alWidth]; + } + qmin = (float) qualityRange[0]; + qmax = (float) qualityRange[1]; + } + + for (int i = istart; i < alWidth; i++) + { + float value = 0; + + c = sequence[i]; + + if (Character.isDigit(c)) + { + value = c - '0'; + } + else if (c == '*') + { + value = 11; + } + else if (c == '+') + { + value = 10; + } + + if (conservation != null) + { + float vprop = value - min; + vprop /= max; + int consp = i - start; + String conssym = (value > 0 && consp > -1 && consp < consSymbs.length) ? consSymbs[consp] + : ""; + conservation.annotations[i] = new Annotation(String.valueOf(c), + conssym, ' ', value, new Color(minR + (maxR * vprop), minG + + (maxG * vprop), minB + (maxB * vprop))); + } + + // Quality calc + if (quality2 != null) + { + value = quality.elementAt(i).floatValue(); + float vprop = value - qmin; + vprop /= qmax; + quality2.annotations[i] = new Annotation(" ", + String.valueOf(value), ' ', value, new Color(minR + + (maxR * vprop), minG + (maxG * vprop), minB + + (maxB * vprop))); + } + } + } + + /** + * construct and call the calculation methods on a new Conservation object + * + * @param name + * - name of conservation + * @param threshold + * - minimum number of conserved residues needed to indicate + * conservation (typically 3) + * @param seqs + * @param start + * first column in calculation window + * @param end + * last column in calculation window + * @param posOrNeg + * positive (true) or negative (false) conservation + * @param consPercGaps + * percentage of gaps tolerated in column + * @param calcQuality + * flag indicating if alignment quality should be calculated + * @return Conservation object ready for use in visualization + */ + public static Conservation calculateConservation(String name, + int threshold, List seqs, int start, int end, + boolean posOrNeg, int consPercGaps, boolean calcQuality) + { + Conservation cons = new Conservation(name, threshold, seqs, start, end); + cons.calculate(); + cons.verdict(posOrNeg, consPercGaps); + + if (calcQuality) + { + cons.findQuality(); + } + + return cons; } }