X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FConservation.java;h=cbc4dcae3130c89b40ccf47d77dfd7e488cd2194;hb=57738a1f3c19b1c3a00bd3ac5108f8cd0af32f99;hp=81277478b4a729167a51476271257bf58c46eef4;hpb=b7c6fbe6d47b510f7ac845eb5c29e971ffb41cfb;p=jalview.git diff --git a/src/jalview/analysis/Conservation.java b/src/jalview/analysis/Conservation.java index 8127747..cbc4dca 100755 --- a/src/jalview/analysis/Conservation.java +++ b/src/jalview/analysis/Conservation.java @@ -20,71 +20,106 @@ */ package jalview.analysis; +import java.util.Locale; + +import jalview.analysis.scoremodels.ScoreMatrix; +import jalview.analysis.scoremodels.ScoreModels; import jalview.datamodel.AlignmentAnnotation; import jalview.datamodel.Annotation; +import jalview.datamodel.ResidueCount; +import jalview.datamodel.ResidueCount.SymbolCounts; import jalview.datamodel.Sequence; import jalview.datamodel.SequenceI; -import jalview.ext.android.SparseIntArray; import jalview.schemes.ResidueProperties; +import jalview.util.Comparison; +import jalview.util.Format; import java.awt.Color; import java.util.List; import java.util.Map; +import java.util.Map.Entry; +import java.util.SortedMap; import java.util.TreeMap; import java.util.Vector; /** * Calculates conservation values for a given set of sequences - * - * @author $author$ - * @version $Revision$ */ public class Conservation { + /* + * need to have a minimum of 3% of sequences with a residue + * for it to be included in the conservation calculation + */ + private static final int THRESHOLD_PERCENT = 3; + + private static final int TOUPPERCASE = 'a' - 'A'; + + private static final int GAP_INDEX = -1; + + private static final Format FORMAT_3DP = new Format("%2.5f"); + SequenceI[] sequences; int start; int end; - Vector seqNums; // vector of int vectors where first is sequence - // checksum + /* + * a list whose i'th element is an array whose first entry is the checksum + * of the i'th sequence, followed by residues encoded to score matrix index + */ + Vector seqNums; int maxLength = 0; // used by quality calcs boolean seqNumsChanged = false; // updated after any change via calcSeqNum; + /* + * a map per column with {property, conservation} where conservation value is + * 1 (property is conserved), 0 (absence of property is conserved) or -1 + * (property is not conserved i.e. column has residues with and without it) + */ Map[] total; - boolean canonicaliseAa = true; // if true then conservation calculation will - - // map all symbols to canonical aa numbering - // rather than consider conservation of that - // symbol + /* + * if true then conservation calculation will map all symbols to canonical aa + * numbering rather than consider conservation of that symbol + */ + boolean canonicaliseAa = true; - /** Stores calculated quality values */ private Vector quality; - /** Stores maximum and minimum values of quality values */ - private double[] qualityRange = new double[2]; + private double qualityMinimum; + + private double qualityMaximum; private Sequence consSequence; + /* + * percentage of residues in a column to qualify for counting conservation + */ private int threshold; private String name = ""; + /* + * an array, for each column, of counts of symbols (by score matrix index) + */ private int[][] cons2; + /* + * gap counts for each column + */ + private int[] cons2GapCounts; + private String[] consSymbs; /** - * Creates a new Conservation object. + * Constructor using default threshold of 3% * * @param name * Name of conservation - * @param threshold - * to count the residues in residueHash(). commonly used value is 3 * @param sequences * sequences to be used in calculation * @param start @@ -92,8 +127,29 @@ public class Conservation * @param end * end residue position */ - public Conservation(String name, int threshold, - List sequences, int start, int end) + public Conservation(String name, List sequences, int start, + int end) + { + this(name, THRESHOLD_PERCENT, sequences, start, end); + } + + /** + * Constructor + * + * @param name + * Name of conservation + * @param threshold + * percentage of sequences at or below which property conservation is + * ignored + * @param sequences + * sequences to be used in calculation + * @param start + * start column position + * @param end + * end column position + */ + public Conservation(String name, int threshold, List sequences, + int start, int end) { this.name = name; this.threshold = threshold; @@ -126,27 +182,29 @@ public class Conservation } /** - * Translate sequence i into a numerical representation and store it in the - * i'th position of the seqNums array. + * Translate sequence i into score matrix indices and store it in the i'th + * position of the seqNums array. * * @param i + * @param sm */ - private void calcSeqNum(int i) + private void calcSeqNum(int i, ScoreMatrix sm) { - String sq = null; // for dumb jbuilder not-inited exception warning - int[] sqnum = null; - int sSize = sequences.length; if ((i > -1) && (i < sSize)) { - sq = sequences[i].getSequenceAsString(); + String sq = sequences[i].getSequenceAsString(); if (seqNums.size() <= i) { seqNums.addElement(new int[sq.length() + 1]); } + /* + * the first entry in the array is the sequence's hashcode, + * following entries are matrix indices of sequence characters + */ if (sq.hashCode() != seqNums.elementAt(i)[0]) { int j; @@ -159,14 +217,26 @@ public class Conservation maxLength = len; } - sqnum = new int[len + 1]; // better to always make a new array - + int[] sqnum = new int[len + 1]; // better to always make a new array - // sequence can change its length sqnum[0] = sq.hashCode(); for (j = 1; j <= len; j++) { - sqnum[j] = jalview.schemes.ResidueProperties.aaIndex[sq - .charAt(j - 1)]; + // sqnum[j] = ResidueProperties.aaIndex[sq.charAt(j - 1)]; + char residue = sq.charAt(j - 1); + if (Comparison.isGap(residue)) + { + sqnum[j] = GAP_INDEX; + } + else + { + sqnum[j] = sm.getMatrixIndex(residue); + if (sqnum[j] == -1) + { + sqnum[j] = GAP_INDEX; + } + } } seqNums.setElementAt(sqnum, i); @@ -179,8 +249,8 @@ public class Conservation else { // JBPNote INFO level debug - System.err - .println("ERROR: calcSeqNum called with out of range sequence index for Alignment\n"); + System.err.println( + "ERROR: calcSeqNum called with out of range sequence index for Alignment\n"); } } @@ -189,154 +259,188 @@ public class Conservation */ public void calculate() { - int jSize = sequences.length; - // int[] values; // Replaces residueHash - SparseIntArray values = new SparseIntArray(); + int height = sequences.length; total = new Map[maxLength]; - for (int i = start; i <= end; i++) + for (int column = start; column <= end; column++) { - // values = new int[255]; - values.clear(); + ResidueCount values = countResidues(column); - for (int j = 0; j < jSize; j++) + /* + * percentage count at or below which we ignore residues + */ + int thresh = (threshold * height) / 100; + + /* + * check observed residues in column and record whether each + * physico-chemical property is conserved (+1), absence conserved (0), + * or not conserved (-1) + * Using TreeMap means properties are displayed in alphabetical order + */ + SortedMap resultHash = new TreeMap<>(); + SymbolCounts symbolCounts = values.getSymbolCounts(); + char[] symbols = symbolCounts.symbols; + int[] counts = symbolCounts.values; + for (int j = 0; j < symbols.length; j++) { - if (sequences[j].getLength() > i) + char c = symbols[j]; + if (counts[j] > thresh) { - char c = sequences[j].getCharAt(i); + recordConservation(resultHash, String.valueOf(c)); + } + } + if (values.getGapCount() > thresh) + { + recordConservation(resultHash, "-"); + } - if (canonicaliseAa) - { // lookup the base aa code symbol - c = (char) ResidueProperties.aaIndex[sequences[j].getCharAt(i)]; - if (c > 20) - { - c = '-'; - } - else - { - // recover canonical aa symbol - c = ResidueProperties.aa[c].charAt(0); - } - } - else - { - // original behaviour - operate on ascii symbols directly - // No need to check if its a '-' - if (c == '.' || c == ' ') - { - c = '-'; - } + if (total.length > 0) + { + total[column - start] = resultHash; + } + } + } - c = toUpperCase(c); - } - // values[c]++; - values.add(c, 1); + /** + * Updates the conservation results for an observed residue + * + * @param resultMap + * a map of {property, conservation} where conservation value is +1 + * (all residues have the property), 0 (no residue has the property) + * or -1 (some do, some don't) + * @param res + */ + protected static void recordConservation(Map resultMap, + String res) + { + res = res.toUpperCase(Locale.ROOT); + for (Entry> property : ResidueProperties.propHash + .entrySet()) + { + String propertyName = property.getKey(); + Integer residuePropertyValue = property.getValue().get(res); + + if (!resultMap.containsKey(propertyName)) + { + /* + * first time we've seen this residue - note whether it has this property + */ + if (residuePropertyValue != null) + { + resultMap.put(propertyName, residuePropertyValue); } else { - // values['-']++; - values.add('-', 1); + /* + * unrecognised residue - use default value for property + */ + resultMap.put(propertyName, property.getValue().get("-")); } } - - // What is the count threshold to count the residues in residueHash() - int thresh = (threshold * jSize) / 100; - - // loop over all the found residues - // Hashtable resultHash = new Hashtable(); - Map resultHash = new TreeMap(); - // for (char v = '-'; v < 'Z'; v++) - for (int key = 0; key < values.size(); key++) + else { - char v = (char) values.keyAt(key); - // if (values[v] > thresh) - if (values.valueAt(key) > thresh) + Integer currentResult = resultMap.get(propertyName); + if (currentResult.intValue() != -1 + && !currentResult.equals(residuePropertyValue)) { - String res = String.valueOf(v); + /* + * property is unconserved - residues seen both with and without it + */ + resultMap.put(propertyName, Integer.valueOf(-1)); + } + } + } + } - // Now loop over the properties - for (String type : ResidueProperties.propHash.keySet()) - { - Map ht = ResidueProperties.propHash.get(type); + /** + * Counts residues (upper-cased) and gaps in the given column + * + * @param column + * @return + */ + protected ResidueCount countResidues(int column) + { + ResidueCount values = new ResidueCount(false); - // Have we ticked this before? - if (!resultHash.containsKey(type)) - { - if (ht.containsKey(res)) - { - resultHash.put(type, ht.get(res)); - } - else - { - resultHash.put(type, ht.get("-")); - } - } - else if (!resultHash.get(type).equals(ht.get(res))) - { - resultHash.put(type, new Integer(-1)); - } - } + for (int row = 0; row < sequences.length; row++) + { + if (sequences[row].getLength() > column) + { + char c = sequences[row].getCharAt(column); + if (canonicaliseAa) + { + int index = ResidueProperties.aaIndex[c]; + c = index > 20 ? '-' : ResidueProperties.aa[index].charAt(0); + } + else + { + c = toUpperCase(c); + } + if (Comparison.isGap(c)) + { + values.addGap(); + } + else + { + values.add(c); } } - - if (total.length > 0) + else { - total[i - start] = resultHash; + values.addGap(); } } + return values; } - /***************************************************************************** - * count conservation for the j'th column of the alignment + /** + * Counts conservation and gaps for a column of the alignment * - * @return { gap count, conserved residue count} + * @return { 1 if fully conserved, else 0, gap count } */ - public int[] countConsNGaps(int j) + public int[] countConservationAndGaps(int column) { - int count = 0; - int cons = 0; - int nres = 0; - int[] r = new int[2]; - char f = '$'; - int i, iSize = sequences.length; - char c; + int gapCount = 0; + boolean fullyConserved = true; + int iSize = sequences.length; - for (i = 0; i < iSize; i++) + if (iSize == 0) + { + return new int[] { 0, 0 }; + } + + char lastRes = '0'; + for (int i = 0; i < iSize; i++) { - if (j >= sequences[i].getLength()) + if (column >= sequences[i].getLength()) { - count++; + gapCount++; continue; } - c = sequences[i].getCharAt(j); // gaps do not have upper/lower case + char c = sequences[i].getCharAt(column); // gaps do not have upper/lower + // case - if (jalview.util.Comparison.isGap((c))) + if (Comparison.isGap((c))) { - count++; + gapCount++; } else { c = toUpperCase(c); - nres++; - - if (nres == 1) + if (lastRes == '0') { - f = c; - cons++; + lastRes = c; } - else if (f == c) + if (c != lastRes) { - cons++; + fullyConserved = false; } } } - r[0] = (nres == cons) ? 1 : 0; - r[1] = count; - + int[] r = new int[] { fullyConserved ? 1 : 0, gapCount }; return r; } @@ -351,7 +455,7 @@ public class Conservation { if ('a' <= c && c <= 'z') { - c -= (32); // 32 = 'a' - 'A' + c -= TOUPPERCASE; } return c; } @@ -359,14 +463,17 @@ public class Conservation /** * Calculates the conservation sequence * - * @param consflag - * if true, positive conservation; false calculates negative - * conservation - * @param percentageGaps - * commonly used value is 25 + * @param positiveOnly + * if true, calculate positive conservation; else calculate both + * positive and negative conservation + * @param maxPercentageGaps + * the percentage of gaps in a column, at or above which no + * conservation is asserted */ - public void verdict(boolean consflag, float percentageGaps) + public void verdict(boolean positiveOnly, float maxPercentageGaps) { + // TODO call this at the end of calculate(), should not be a public method + StringBuilder consString = new StringBuilder(end); // NOTE THIS SHOULD CHECK IF THE CONSEQUENCE ALREADY @@ -379,56 +486,43 @@ public class Conservation consSymbs = new String[end - start + 1]; for (int i = start; i <= end; i++) { - int[] gapcons = countConsNGaps(i); + int[] gapcons = countConservationAndGaps(i); + boolean fullyConserved = gapcons[0] == 1; int totGaps = gapcons[1]; - float pgaps = ((float) totGaps * 100) / sequences.length; - StringBuilder positives = new StringBuilder(64); - StringBuilder negatives = new StringBuilder(32); - // consSymbs[i - start] = ""; + float pgaps = (totGaps * 100f) / sequences.length; - if (percentageGaps > pgaps) + if (maxPercentageGaps > pgaps) { Map resultHash = total[i - start]; - // Now find the verdict int count = 0; + StringBuilder positives = new StringBuilder(64); + StringBuilder negatives = new StringBuilder(32); for (String type : resultHash.keySet()) { int result = resultHash.get(type).intValue(); - // Do we want to count +ve conservation or +ve and -ve cons.? - if (consflag) + if (result == -1) { - if (result == 1) - { - // consSymbs[i - start] = type + " " + consSymbs[i - start]; - positives.append(positives.length() == 0 ? "" : " "); - positives.append(type); - count++; - } + /* + * not conserved (present or absent) + */ + continue; } - else + count++; + if (result == 1) { - if (result != -1) - { - if (result == 0) - { - /* - * add negatively conserved properties on the end - */ - // consSymbs[i - start] = consSymbs[i - start] + " !" + type; - negatives.append(negatives.length() == 0 ? "" : " "); - negatives.append("!").append(type); - } - else - { - /* - * put positively conserved properties on the front - */ - // consSymbs[i - start] = type + " " + consSymbs[i - start]; - positives.append(positives.length() == 0 ? "" : " "); - positives.append(type); - } - count++; - } + /* + * positively conserved property (all residues have it) + */ + positives.append(positives.length() == 0 ? "" : " "); + positives.append(type); + } + if (result == 0 && !positiveOnly) + { + /* + * absense of property is conserved (all residues lack it) + */ + negatives.append(negatives.length() == 0 ? "" : " "); + negatives.append("!").append(type); } } if (negatives.length() > 0) @@ -443,7 +537,7 @@ public class Conservation } else { - consString.append((gapcons[0] == 1) ? "*" : "+"); + consString.append(fullyConserved ? "*" : "+"); } } else @@ -460,7 +554,7 @@ public class Conservation * * @return Conservation sequence */ - public Sequence getConsSequence() + public SequenceI getConsSequence() { return consSequence; } @@ -468,137 +562,134 @@ public class Conservation // From Alignment.java in jalview118 public void findQuality() { - findQuality(0, maxLength - 1); + findQuality(0, maxLength - 1, ScoreModels.getInstance().getBlosum62()); } /** * DOCUMENT ME! + * + * @param sm */ - private void percentIdentity2() + private void percentIdentity(ScoreMatrix sm) { - seqNums = new Vector(); - // calcSeqNum(s); + seqNums = new Vector<>(); int i = 0, iSize = sequences.length; // Do we need to calculate this again? for (i = 0; i < iSize; i++) { - calcSeqNum(i); + calcSeqNum(i, sm); } if ((cons2 == null) || seqNumsChanged) { + // FIXME remove magic number 24 without changing calc + // sm.getSize() returns 25 so doesn't quite do it... cons2 = new int[maxLength][24]; + cons2GapCounts = new int[maxLength]; - // Initialize the array - for (int j = 0; j < 24; j++) - { - for (i = 0; i < maxLength; i++) - { - cons2[i][j] = 0; - } - } - - int[] sqnum; int j = 0; while (j < sequences.length) { - sqnum = seqNums.elementAt(j); + int[] sqnum = seqNums.elementAt(j); for (i = 1; i < sqnum.length; i++) { - cons2[i - 1][sqnum[i]]++; + int index = sqnum[i]; + if (index == GAP_INDEX) + { + cons2GapCounts[i - 1]++; + } + else + { + cons2[i - 1][index]++; + } } + // TODO should this start from sqnum.length? for (i = sqnum.length - 1; i < maxLength; i++) { - cons2[i][23]++; // gap count + cons2GapCounts[i]++; } - j++; } - - // unnecessary ? - - /* - * for (int i=start; i <= end; i++) { int max = -1000; int maxi = -1; int - * maxj = -1; - * - * for (int j=0;j<24;j++) { if (cons2[i][j] > max) { max = cons2[i][j]; - * maxi = i; maxj = j; } } } - */ } } /** - * Calculates the quality of the set of sequences + * Calculates the quality of the set of sequences over the given inclusive + * column range, using the specified substitution score matrix * - * @param startRes - * Start residue - * @param endRes - * End residue + * @param startCol + * @param endCol + * @param scoreMatrix */ - public void findQuality(int startRes, int endRes) + protected void findQuality(int startCol, int endCol, + ScoreMatrix scoreMatrix) { - quality = new Vector(); + quality = new Vector<>(); - double max = -10000; - int[][] BLOSUM62 = ResidueProperties.getBLOSUM62(); + double max = -Double.MAX_VALUE; + float[][] scores = scoreMatrix.getMatrix(); - // Loop over columns // JBPNote Profiling info - // long ts = System.currentTimeMillis(); - // long te = System.currentTimeMillis(); - percentIdentity2(); + percentIdentity(scoreMatrix); int size = seqNums.size(); int[] lengths = new int[size]; - double tot, bigtot, sr, tmp; - double[] x, xx; - int l, j, i, ii, i2, k, seqNum; - for (l = 0; l < size; l++) + for (int l = 0; l < size; l++) { lengths[l] = seqNums.elementAt(l).length - 1; } - for (j = startRes; j <= endRes; j++) + final int symbolCount = scoreMatrix.getSize(); + + for (int j = startCol; j <= endCol; j++) { - bigtot = 0; + double bigtot = 0; // First Xr = depends on column only - x = new double[24]; + double[] x = new double[symbolCount]; - for (ii = 0; ii < 24; ii++) + for (int ii = 0; ii < symbolCount; ii++) { x[ii] = 0; - for (i2 = 0; i2 < 24; i2++) + /* + * todo JAL-728 currently assuming last symbol in matrix is * for gap + * (which we ignore as counted separately); true for BLOSUM62 but may + * not be once alternative matrices are supported + */ + for (int i2 = 0; i2 < symbolCount - 1; i2++) { - x[ii] += (((double) cons2[j][i2] * BLOSUM62[ii][i2]) + 4); + x[ii] += (((double) cons2[j][i2] * scores[ii][i2]) + 4D); } + x[ii] += 4D + cons2GapCounts[j] * scoreMatrix.getMinimumScore(); x[ii] /= size; } // Now calculate D for each position and sum - for (k = 0; k < size; k++) + for (int k = 0; k < size; k++) { - tot = 0; - xx = new double[24]; - 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++) - { - sr = 0; + double tot = 0; + double[] xx = new double[symbolCount]; + // sequence character index, or implied gap if sequence too short + int seqNum = (j < lengths[k]) ? seqNums.elementAt(k)[j + 1] + : GAP_INDEX; - sr = (double) BLOSUM62[i][seqNum] + 4; + for (int i = 0; i < symbolCount - 1; i++) + { + double sr = 4D; + if (seqNum == GAP_INDEX) + { + sr += scoreMatrix.getMinimumScore(); + } + else + { + sr += scores[i][seqNum]; + } - // Calculate X with another loop over residues - // System.out.println("Xi " + i + " " + x[i] + " " + sr); xx[i] = x[i] - sr; tot += (xx[i] * xx[i]); @@ -607,27 +698,21 @@ public class Conservation bigtot += Math.sqrt(tot); } - // This is the quality for one column - if (max < bigtot) - { - max = bigtot; - } + max = Math.max(max, bigtot); - // bigtot = bigtot * (size-cons2[j][23])/size; - quality.addElement(new Double(bigtot)); - - // Need to normalize by gaps + quality.addElement(Double.valueOf(bigtot)); } - double newmax = -10000; + double newmax = -Double.MAX_VALUE; - for (j = startRes; j <= endRes; j++) + for (int j = startCol; j <= endCol; j++) { - tmp = quality.elementAt(j).doubleValue(); - tmp = ((max - tmp) * (size - cons2[j][23])) / size; + double tmp = quality.elementAt(j).doubleValue(); + // tmp = ((max - tmp) * (size - cons2[j][23])) / size; + tmp = ((max - tmp) * (size - cons2GapCounts[j])) / size; // System.out.println(tmp+ " " + j); - quality.setElementAt(new Double(tmp), j); + quality.setElementAt(Double.valueOf(tmp), j); if (tmp > newmax) { @@ -635,15 +720,14 @@ public class Conservation } } - // System.out.println("Quality " + s); - qualityRange[0] = 0D; - qualityRange[1] = newmax; + qualityMinimum = 0D; + qualityMaximum = 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. + * this method will reallocate the given annotation row if it is different to + * the calculated width, otherwise will leave its length unchanged. * * @param conservation * conservation annotation row @@ -657,51 +741,46 @@ public class 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 + SequenceI cons = getConsSequence(); + + /* + * colour scale for Conservation and Quality; + */ + float minR = 0.3f; + float minG = 0.0f; + float minB = 0f; + float maxR = 1.0f - minR; + float maxG = 0.9f - minG; + float maxB = 0f - minB; 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.length != alWidth) { conservation.annotations = new Annotation[alWidth]; } if (quality2 != null) { - quality2.graphMax = (float) qualityRange[1]; + quality2.graphMax = (float) qualityMaximum; if (quality2.annotations != null - && quality2.annotations.length < alWidth) + && quality2.annotations.length != alWidth) { quality2.annotations = new Annotation[alWidth]; } - qmin = (float) qualityRange[0]; - qmax = (float) qualityRange[1]; + qmin = (float) qualityMinimum; + qmax = (float) qualityMaximum; } for (int i = istart; i < alWidth; i++) { float value = 0; - c = sequence[i]; + char c = cons.getCharAt(i); if (Character.isDigit(c)) { @@ -721,11 +800,11 @@ public class Conservation float vprop = value - min; vprop /= max; int consp = i - start; - String conssym = (value > 0 && consp > -1 && consp < consSymbs.length) ? consSymbs[consp] - : ""; + 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))); + conssym, ' ', value, new Color(minR + (maxR * vprop), + minG + (maxG * vprop), minB + (maxB * vprop))); } // Quality calc @@ -734,10 +813,10 @@ public class Conservation 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))); + String description = FORMAT_3DP.form(value); + quality2.annotations[i] = new Annotation(" ", description, ' ', + value, new Color(minR + (maxR * vprop), + minG + (maxG * vprop), minB + (maxB * vprop))); } } } @@ -747,29 +826,27 @@ public class Conservation * * @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 + * @param positiveOnly + * calculate positive (true) or positive and negative (false) + * conservation + * @param maxPercentGaps * 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) + List seqs, int start, int end, boolean positiveOnly, + int maxPercentGaps, boolean calcQuality) { - Conservation cons = new Conservation(name, threshold, seqs, start, end); + Conservation cons = new Conservation(name, seqs, start, end); cons.calculate(); - cons.verdict(posOrNeg, consPercGaps); + cons.verdict(positiveOnly, maxPercentGaps); if (calcQuality) { @@ -778,4 +855,25 @@ public class Conservation return cons; } + + /** + * Returns the computed tooltip (annotation description) for a given column. + * The tip is empty if the conservation score is zero, otherwise holds the + * conserved properties (and, optionally, properties whose absence is + * conserved). + * + * @param column + * @return + */ + String getTooltip(int column) + { + SequenceI cons = getConsSequence(); + char val = column < cons.getLength() ? cons.getCharAt(column) : '-'; + boolean hasConservation = val != '-' && val != '0'; + int consp = column - start; + String tip = (hasConservation && consp > -1 && consp < consSymbs.length) + ? consSymbs[consp] + : ""; + return tip; + } }