X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAAFrequency.java;h=b1505d6827ce8401af83960a821cc6d4b3a1a5ea;hb=57738a1f3c19b1c3a00bd3ac5108f8cd0af32f99;hp=8025882c83d6e8c743669fd04b099aea578ae9bf;hpb=ab43013b7e357b84b4abade0dba949668dfb2a0e;p=jalview.git diff --git a/src/jalview/analysis/AAFrequency.java b/src/jalview/analysis/AAFrequency.java index 8025882..b1505d6 100755 --- a/src/jalview/analysis/AAFrequency.java +++ b/src/jalview/analysis/AAFrequency.java @@ -1,6 +1,6 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2b1) - * Copyright (C) 2014 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * @@ -20,10 +20,27 @@ */ package jalview.analysis; -import java.util.*; - +import jalview.datamodel.AlignedCodonFrame; +import jalview.datamodel.AlignmentAnnotation; +import jalview.datamodel.AlignmentI; +import jalview.datamodel.Annotation; +import jalview.datamodel.Profile; +import jalview.datamodel.ProfileI; +import jalview.datamodel.Profiles; +import jalview.datamodel.ProfilesI; +import jalview.datamodel.ResidueCount; +import jalview.datamodel.ResidueCount.SymbolCounts; +import jalview.datamodel.SequenceI; +import jalview.ext.android.SparseIntArray; +import jalview.util.Comparison; import jalview.util.Format; -import jalview.datamodel.*; +import jalview.util.MappingUtils; +import jalview.util.QuickSort; + +import java.awt.Color; +import java.util.Arrays; +import java.util.Hashtable; +import java.util.List; /** * Takes in a vector or array of sequences and column start and column end and @@ -36,25 +53,28 @@ import jalview.datamodel.*; */ public class AAFrequency { - // No need to store 1000s of strings which are not - // visible to the user. - public static final String MAXCOUNT = "C"; - - public static final String MAXRESIDUE = "R"; - - public static final String PID_GAPS = "G"; + public static final String PROFILE = "P"; - public static final String PID_NOGAPS = "N"; + /* + * Quick look-up of String value of char 'A' to 'Z' + */ + private static final String[] CHARS = new String['Z' - 'A' + 1]; - public static final String PROFILE = "P"; + static + { + for (char c = 'A'; c <= 'Z'; c++) + { + CHARS[c - 'A'] = String.valueOf(c); + } + } - public static final Hashtable[] calculate(List list, - int start, int end) + public static final ProfilesI calculate(List list, int start, + int end) { return calculate(list, start, end, false); } - public static final Hashtable[] calculate(List sequences, + public static final ProfilesI calculate(List sequences, int start, int end, boolean profile) { SequenceI[] seqs = new SequenceI[sequences.size()]; @@ -64,321 +84,668 @@ public class AAFrequency for (int i = 0; i < sequences.size(); i++) { seqs[i] = sequences.get(i); - if (seqs[i].getLength() > width) + int length = seqs[i].getLength(); + if (length > width) { - width = seqs[i].getLength(); + width = length; } } - Hashtable[] reply = new Hashtable[width]; - if (end >= width) { end = width; } - calculate(seqs, start, end, reply, profile); + ProfilesI reply = calculate(seqs, width, start, end, profile); return reply; } } - public static final void calculate(SequenceI[] sequences, int start, - int end, Hashtable[] result) - { - calculate(sequences, start, end, result, false); - } - - public static final void calculate(SequenceI[] sequences, int start, - int end, Hashtable[] result, boolean profile) + /** + * Calculate the consensus symbol(s) for each column in the given range. + * + * @param sequences + * @param width + * the full width of the alignment + * @param start + * start column (inclusive, base zero) + * @param end + * end column (exclusive) + * @param saveFullProfile + * if true, store all symbol counts + */ + public static final ProfilesI calculate(final SequenceI[] sequences, + int width, int start, int end, boolean saveFullProfile) { - Hashtable residueHash; - int maxCount, nongap, i, j, v, jSize = sequences.length; - String maxResidue; - char c = '-'; - float percentage; - - int[] values = new int[255]; + // long now = System.currentTimeMillis(); + int seqCount = sequences.length; + boolean nucleotide = false; + int nucleotideCount = 0; + int peptideCount = 0; - char[] seq; + ProfileI[] result = new ProfileI[width]; - for (i = start; i < end; i++) + for (int column = start; column < end; column++) { - residueHash = new Hashtable(); - maxCount = 0; - maxResidue = ""; - nongap = 0; - values = new int[255]; + /* + * Apply a heuristic to detect nucleotide data (which can + * be counted in more compact arrays); here we test for + * more than 90% nucleotide; recheck every 10 columns in case + * of misleading data e.g. highly conserved Alanine in peptide! + * Mistakenly guessing nucleotide has a small performance cost, + * as it will result in counting in sparse arrays. + * Mistakenly guessing peptide has a small space cost, + * as it will use a larger than necessary array to hold counts. + */ + if (nucleotideCount > 100 && column % 10 == 0) + { + nucleotide = (9 * peptideCount < nucleotideCount); + } + ResidueCount residueCounts = new ResidueCount(nucleotide); - for (j = 0; j < jSize; j++) + for (int row = 0; row < seqCount; row++) { - if (sequences[j] == null) + if (sequences[row] == null) { - System.err - .println("WARNING: Consensus skipping null sequence - possible race condition."); + System.err.println( + "WARNING: Consensus skipping null sequence - possible race condition."); continue; } - seq = sequences[j].getSequence(); - if (seq.length > i) + if (sequences[row].getLength() > column) { - c = seq[i]; - - if (c == '.' || c == ' ') - { - c = '-'; - } - - if (c == '-') + char c = sequences[row].getCharAt(column); + residueCounts.add(c); + if (Comparison.isNucleotide(c)) { - values['-']++; - continue; + nucleotideCount++; } - else if ('a' <= c && c <= 'z') + else if (!Comparison.isGap(c)) { - c -= 32; // ('a' - 'A'); + peptideCount++; } - - nongap++; - values[c]++; - } else { - values['-']++; + /* + * count a gap if the sequence doesn't reach this column + */ + residueCounts.addGap(); } } - if (jSize == 1) + + int maxCount = residueCounts.getModalCount(); + String maxResidue = residueCounts.getResiduesForCount(maxCount); + int gapCount = residueCounts.getGapCount(); + ProfileI profile = new Profile(seqCount, gapCount, maxCount, + maxResidue); + + if (saveFullProfile) { - maxResidue = String.valueOf(c); - maxCount = 1; + profile.setCounts(residueCounts); } - else - { - for (v = 'A'; v < 'Z'; v++) - { - if (values[v] < 2 || values[v] < maxCount) - { - continue; - } - if (values[v] > maxCount) - { - maxResidue = String.valueOf((char) v); - } - else if (values[v] == maxCount) - { - maxResidue += String.valueOf((char) v); - } - maxCount = values[v]; - } + result[column] = profile; + } + return new Profiles(result); + // long elapsed = System.currentTimeMillis() - now; + // System.out.println(elapsed); + } + + /** + * Make an estimate of the profile size we are going to compute i.e. how many + * different characters may be present in it. Overestimating has a cost of + * using more memory than necessary. Underestimating has a cost of needing to + * extend the SparseIntArray holding the profile counts. + * + * @param profileSizes + * counts of sizes of profiles so far encountered + * @return + */ + static int estimateProfileSize(SparseIntArray profileSizes) + { + if (profileSizes.size() == 0) + { + return 4; + } + + /* + * could do a statistical heuristic here e.g. 75%ile + * for now just return the largest value + */ + return profileSizes.keyAt(profileSizes.size() - 1); + } + + /** + * Derive the consensus annotations to be added to the alignment for display. + * This does not recompute the raw data, but may be called on a change in + * display options, such as 'ignore gaps', which may in turn result in a + * change in the derived values. + * + * @param consensus + * the annotation row to add annotations to + * @param profiles + * the source consensus data + * @param startCol + * start column (inclusive) + * @param endCol + * end column (exclusive) + * @param ignoreGaps + * if true, normalise residue percentages ignoring gaps + * @param showSequenceLogo + * if true include all consensus symbols, else just show modal + * residue + * @param nseq + * number of sequences + */ + public static void completeConsensus(AlignmentAnnotation consensus, + ProfilesI profiles, int startCol, int endCol, boolean ignoreGaps, + boolean showSequenceLogo, long nseq) + { + // long now = System.currentTimeMillis(); + if (consensus == null || consensus.annotations == null + || consensus.annotations.length < endCol) + { + /* + * called with a bad alignment annotation row + * wait for it to be initialised properly + */ + return; + } + + for (int i = startCol; i < endCol; i++) + { + ProfileI profile = profiles.get(i); + if (profile == null) + { + /* + * happens if sequences calculated over were + * shorter than alignment width + */ + consensus.annotations[i] = null; + return; } - if (maxResidue.length() == 0) + + final int dp = getPercentageDp(nseq); + + float value = profile.getPercentageIdentity(ignoreGaps); + + String description = getTooltip(profile, value, showSequenceLogo, + ignoreGaps, dp); + + String modalResidue = profile.getModalResidue(); + if ("".equals(modalResidue)) { - maxResidue = "-"; + modalResidue = "-"; } - if (profile) + else if (modalResidue.length() > 1) { - residueHash.put(PROFILE, new int[][] - { values, new int[] - { jSize, nongap } }); + modalResidue = "+"; } - residueHash.put(MAXCOUNT, new Integer(maxCount)); - residueHash.put(MAXRESIDUE, maxResidue); - - percentage = ((float) maxCount * 100) / jSize; - residueHash.put(PID_GAPS, new Float(percentage)); + consensus.annotations[i] = new Annotation(modalResidue, description, + ' ', value); + } + // long elapsed = System.currentTimeMillis() - now; + // System.out.println(-elapsed); + } - if (nongap > 0) + /** + * Derive the gap count annotation row. + * + * @param gaprow + * the annotation row to add annotations to + * @param profiles + * the source consensus data + * @param startCol + * start column (inclusive) + * @param endCol + * end column (exclusive) + */ + public static void completeGapAnnot(AlignmentAnnotation gaprow, + ProfilesI profiles, int startCol, int endCol, long nseq) + { + if (gaprow == null || gaprow.annotations == null + || gaprow.annotations.length < endCol) + { + /* + * called with a bad alignment annotation row + * wait for it to be initialised properly + */ + return; + } + // always set ranges again + gaprow.graphMax = nseq; + gaprow.graphMin = 0; + double scale = 0.8 / nseq; + for (int i = startCol; i < endCol; i++) + { + ProfileI profile = profiles.get(i); + if (profile == null) { - // calculate for non-gapped too - percentage = ((float) maxCount * 100) / nongap; + /* + * happens if sequences calculated over were + * shorter than alignment width + */ + gaprow.annotations[i] = null; + return; } - residueHash.put(PID_NOGAPS, new Float(percentage)); - result[i] = residueHash; + final int gapped = profile.getNonGapped(); + + String description = "" + gapped; + + gaprow.annotations[i] = new Annotation("", description, '\0', gapped, + jalview.util.ColorUtils.bleachColour(Color.DARK_GRAY, + (float) scale * gapped)); } } /** - * Compute all or part of the annotation row from the given consensus - * hashtable + * Returns a tooltip showing either + *
    + *
  • the full profile (percentages of all residues present), if + * showSequenceLogo is true, or
    • + *
  • just the modal (most common) residue(s), if showSequenceLogo is + * false
    • + *
+ * Percentages are as a fraction of all sequence, or only ungapped sequences + * if ignoreGaps is true. * - * @param consensus - * - pre-allocated annotation row - * @param hconsensus - * @param iStart - * @param width - * @param ignoreGapsInConsensusCalculation - * @param includeAllConsSymbols - * @param nseq + * @param profile + * @param pid + * @param showSequenceLogo + * @param ignoreGaps + * @param dp + * the number of decimal places to format percentages to + * @return */ - public static void completeConsensus(AlignmentAnnotation consensus, - Hashtable[] hconsensus, int iStart, int width, - boolean ignoreGapsInConsensusCalculation, - boolean includeAllConsSymbols, long nseq) + static String getTooltip(ProfileI profile, float pid, + boolean showSequenceLogo, boolean ignoreGaps, int dp) { - completeConsensus(consensus, hconsensus, iStart, width, - ignoreGapsInConsensusCalculation, includeAllConsSymbols, null, - nseq); // new - // char[] - // { 'A', 'C', 'G', 'T', 'U' }); - } + ResidueCount counts = profile.getCounts(); - public static void completeConsensus(AlignmentAnnotation consensus, - Hashtable[] hconsensus, int iStart, int width, - boolean ignoreGapsInConsensusCalculation, - boolean includeAllConsSymbols, char[] alphabet, long nseq) - { - float tval, value; - if (consensus == null || consensus.annotations == null - || consensus.annotations.length < width) + String description = null; + if (counts != null && showSequenceLogo) { - // called with a bad alignment annotation row - wait for it to be - // initialised properly - return; + int normaliseBy = ignoreGaps ? profile.getNonGapped() + : profile.getHeight(); + description = counts.getTooltip(normaliseBy, dp); } - String fmtstr = "%3.1f"; - int precision = 0; - while (nseq >= 10) + else { - precision++; - nseq /= 10; + StringBuilder sb = new StringBuilder(64); + String maxRes = profile.getModalResidue(); + if (maxRes.length() > 1) + { + sb.append("[").append(maxRes).append("]"); + } + else + { + sb.append(maxRes); + } + if (maxRes.length() > 0) + { + sb.append(" "); + Format.appendPercentage(sb, pid, dp); + sb.append("%"); + } + description = sb.toString(); } - final Format fmt; - if (precision > 1) + return description; + } + + /** + * Returns the sorted profile for the given consensus data. The returned array + * contains + * + * 
+   *    [profileType, numberOfValues, totalPercent, charValue1, percentage1, charValue2, percentage2, ...]
+   * in descending order of percentage value
+   *
+ * + * @param profile + * the data object from which to extract and sort values + * @param ignoreGaps + * if true, only non-gapped values are included in percentage + * calculations + * @return + */ + public static int[] extractProfile(ProfileI profile, boolean ignoreGaps) + { + ResidueCount counts = profile.getCounts(); + if (counts == null) + { + return null; + } + + SymbolCounts symbolCounts = counts.getSymbolCounts(); + char[] symbols = symbolCounts.symbols; + int[] values = symbolCounts.values; + QuickSort.sort(values, symbols); + int totalPercentage = 0; + final int divisor = ignoreGaps ? profile.getNonGapped() + : profile.getHeight(); + + /* + * traverse the arrays in reverse order (highest counts first) + */ + int[] result = new int[3 + 2 * symbols.length]; + int nextArrayPos = 3; + int nonZeroCount = 0; + + for (int i = symbols.length - 1; i >= 0; i--) { - // if (precision>2) + int theChar = symbols[i]; + int charCount = values[i]; + final int percentage = (charCount * 100) / divisor; + if (percentage == 0) { - fmtstr = "%" + (2 + precision) + "." + (precision) + "f"; + /* + * this count (and any remaining) round down to 0% - discard + */ + break; } - fmt = new Format(fmtstr); + nonZeroCount++; + result[nextArrayPos++] = theChar; + result[nextArrayPos++] = percentage; + totalPercentage += percentage; } - else + + /* + * truncate array if any zero values were discarded + */ + if (nonZeroCount < symbols.length) + { + int[] tmp = new int[3 + 2 * nonZeroCount]; + System.arraycopy(result, 0, tmp, 0, tmp.length); + result = tmp; + } + + /* + * fill in 'header' values + */ + result[0] = AlignmentAnnotation.SEQUENCE_PROFILE; + result[1] = nonZeroCount; + result[2] = totalPercentage; + + return result; + } + + /** + * Extract a sorted extract of cDNA codon profile data. The returned array + * contains + * + * 
+   *    [profileType, numberOfValues, totalPercentage, charValue1, percentage1, charValue2, percentage2, ...]
+   * in descending order of percentage value, where the character values encode codon triplets
+   *
+ * + * @param hashtable + * @return + */ + public static int[] extractCdnaProfile( + Hashtable hashtable, boolean ignoreGaps) + { + // this holds #seqs, #ungapped, and then codon count, indexed by encoded + // codon triplet + int[] codonCounts = (int[]) hashtable.get(PROFILE); + int[] sortedCounts = new int[codonCounts.length - 2]; + System.arraycopy(codonCounts, 2, sortedCounts, 0, + codonCounts.length - 2); + + int[] result = new int[3 + 2 * sortedCounts.length]; + // first value is just the type of profile data + result[0] = AlignmentAnnotation.CDNA_PROFILE; + + char[] codons = new char[sortedCounts.length]; + for (int i = 0; i < codons.length; i++) { - fmt = null; + codons[i] = (char) i; } - for (int i = iStart; i < width; i++) + QuickSort.sort(sortedCounts, codons); + int totalPercentage = 0; + int distinctValuesCount = 0; + int j = 3; + int divisor = ignoreGaps ? codonCounts[1] : codonCounts[0]; + for (int i = codons.length - 1; i >= 0; i--) { - Hashtable hci; - if (i >= hconsensus.length || ((hci = hconsensus[i]) == null)) + final int codonCount = sortedCounts[i]; + if (codonCount == 0) { - // happens if sequences calculated over were shorter than alignment - // width - consensus.annotations[i] = null; - continue; + break; // nothing else of interest here } - value = 0; - Float fv; - if (ignoreGapsInConsensusCalculation) + final int percentage = codonCount * 100 / divisor; + if (percentage == 0) { - fv = (Float) hci.get(AAFrequency.PID_NOGAPS); + /* + * this (and any remaining) values rounded down to 0 - discard + */ + break; } - else + distinctValuesCount++; + result[j++] = codons[i]; + result[j++] = percentage; + totalPercentage += percentage; + } + result[2] = totalPercentage; + + /* + * Just return the non-zero values + */ + // todo next value is redundant if we limit the array to non-zero counts + result[1] = distinctValuesCount; + return Arrays.copyOfRange(result, 0, j); + } + + /** + * Compute a consensus for the cDNA coding for a protein alignment. + * + * @param alignment + * the protein alignment (which should hold mappings to cDNA + * sequences) + * @param hconsensus + * the consensus data stores to be populated (one per column) + */ + public static void calculateCdna(AlignmentI alignment, + Hashtable[] hconsensus) + { + final char gapCharacter = alignment.getGapCharacter(); + List mappings = alignment.getCodonFrames(); + if (mappings == null || mappings.isEmpty()) + { + return; + } + + int cols = alignment.getWidth(); + for (int col = 0; col < cols; col++) + { + // todo would prefer a Java bean for consensus data + Hashtable columnHash = new Hashtable<>(); + // #seqs, #ungapped seqs, counts indexed by (codon encoded + 1) + int[] codonCounts = new int[66]; + codonCounts[0] = alignment.getSequences().size(); + int ungappedCount = 0; + for (SequenceI seq : alignment.getSequences()) { - fv = (Float) hci.get(AAFrequency.PID_GAPS); + if (seq.getCharAt(col) == gapCharacter) + { + continue; + } + List codons = MappingUtils.findCodonsFor(seq, col, + mappings); + for (char[] codon : codons) + { + int codonEncoded = CodingUtils.encodeCodon(codon); + if (codonEncoded >= 0) + { + codonCounts[codonEncoded + 2]++; + ungappedCount++; + break; + } + } } - if (fv == null) + codonCounts[1] = ungappedCount; + // todo: sort values here, save counts and codons? + columnHash.put(PROFILE, codonCounts); + hconsensus[col] = columnHash; + } + } + + /** + * Derive displayable cDNA consensus annotation from computed consensus data. + * + * @param consensusAnnotation + * the annotation row to be populated for display + * @param consensusData + * the computed consensus data + * @param showProfileLogo + * if true show all symbols present at each position, else only the + * modal value + * @param nseqs + * the number of sequences in the alignment + */ + public static void completeCdnaConsensus( + AlignmentAnnotation consensusAnnotation, + Hashtable[] consensusData, + boolean showProfileLogo, int nseqs) + { + if (consensusAnnotation == null + || consensusAnnotation.annotations == null + || consensusAnnotation.annotations.length < consensusData.length) + { + // called with a bad alignment annotation row - wait for it to be + // initialised properly + return; + } + + // ensure codon triplet scales with font size + consensusAnnotation.scaleColLabel = true; + for (int col = 0; col < consensusData.length; col++) + { + Hashtable hci = consensusData[col]; + if (hci == null) { - consensus.annotations[i] = null; - // data has changed below us .. give up and + // gapped protein column? continue; } - value = fv.floatValue(); - String maxRes = hci.get(AAFrequency.MAXRESIDUE).toString(); - String mouseOver = hci.get(AAFrequency.MAXRESIDUE) + " "; - if (maxRes.length() > 1) + // array holds #seqs, #ungapped, then codon counts indexed by codon + final int[] codonCounts = (int[]) hci.get(PROFILE); + int totalCount = 0; + + /* + * First pass - get total count and find the highest + */ + final char[] codons = new char[codonCounts.length - 2]; + for (int j = 2; j < codonCounts.length; j++) { - mouseOver = "[" + maxRes + "] "; - maxRes = "+"; + final int codonCount = codonCounts[j]; + codons[j - 2] = (char) (j - 2); + totalCount += codonCount; } - int[][] profile = (int[][]) hci.get(AAFrequency.PROFILE); - if (profile != null && includeAllConsSymbols) + + /* + * Sort array of encoded codons by count ascending - so the modal value + * goes to the end; start by copying the count (dropping the first value) + */ + int[] sortedCodonCounts = new int[codonCounts.length - 2]; + System.arraycopy(codonCounts, 2, sortedCodonCounts, 0, + codonCounts.length - 2); + QuickSort.sort(sortedCodonCounts, codons); + + int modalCodonEncoded = codons[codons.length - 1]; + int modalCodonCount = sortedCodonCounts[codons.length - 1]; + String modalCodon = String + .valueOf(CodingUtils.decodeCodon(modalCodonEncoded)); + if (sortedCodonCounts.length > 1 && sortedCodonCounts[codons.length + - 2] == sortedCodonCounts[codons.length - 1]) { - mouseOver = ""; - if (alphabet != null) + /* + * two or more codons share the modal count + */ + modalCodon = "+"; + } + float pid = sortedCodonCounts[sortedCodonCounts.length - 1] * 100 + / (float) totalCount; + + /* + * todo ? Replace consensus hashtable with sorted arrays of codons and + * counts (non-zero only). Include total count in count array [0]. + */ + + /* + * Scan sorted array backwards for most frequent values first. Show + * repeated values compactly. + */ + StringBuilder mouseOver = new StringBuilder(32); + StringBuilder samePercent = new StringBuilder(); + String percent = null; + String lastPercent = null; + int percentDecPl = getPercentageDp(nseqs); + + for (int j = codons.length - 1; j >= 0; j--) + { + int codonCount = sortedCodonCounts[j]; + if (codonCount == 0) { - for (int c = 0; c < alphabet.length; c++) + /* + * remaining codons are 0% - ignore, but finish off the last one if + * necessary + */ + if (samePercent.length() > 0) { - tval = profile[0][alphabet[c]] * 100f - / profile[1][ignoreGapsInConsensusCalculation ? 1 : 0]; - mouseOver += ((c == 0) ? "" : "; ") + alphabet[c] + " " - + ((fmt != null) ? fmt.form(tval) : ((int) tval)) + "%"; + mouseOver.append(samePercent).append(": ").append(percent) + .append("% "); } + break; } - else + int codonEncoded = codons[j]; + final int pct = codonCount * 100 / totalCount; + String codon = String + .valueOf(CodingUtils.decodeCodon(codonEncoded)); + StringBuilder sb = new StringBuilder(); + Format.appendPercentage(sb, pct, percentDecPl); + percent = sb.toString(); + if (showProfileLogo || codonCount == modalCodonCount) { - Object[] ca = new Object[profile[0].length]; - float[] vl = new float[profile[0].length]; - for (int c = 0; c < ca.length; c++) + if (percent.equals(lastPercent) && j > 0) { - ca[c] = new char[] - { (char) c }; - vl[c] = profile[0][c]; + samePercent.append(samePercent.length() == 0 ? "" : ", "); + samePercent.append(codon); } - ; - jalview.util.QuickSort.sort(vl, ca); - for (int p = 0, c = ca.length - 1; profile[0][((char[]) ca[c])[0]] > 0; c--) + else { - if (((char[]) ca[c])[0] != '-') + if (samePercent.length() > 0) { - tval = profile[0][((char[]) ca[c])[0]] - * 100f - / profile[1][ignoreGapsInConsensusCalculation ? 1 : 0]; - mouseOver += ((p == 0) ? "" : "; ") + ((char[]) ca[c])[0] - + " " - + ((fmt != null) ? fmt.form(tval) : ((int) tval)) - + "%"; - p++; - + mouseOver.append(samePercent).append(": ").append(lastPercent) + .append("% "); } + samePercent.setLength(0); + samePercent.append(codon); } - + lastPercent = percent; } } - else - { - mouseOver += ((fmt != null) ? fmt.form(value) : ((int) value)) - + "%"; - } - consensus.annotations[i] = new Annotation(maxRes, mouseOver, ' ', - value); + + consensusAnnotation.annotations[col] = new Annotation(modalCodon, + mouseOver.toString(), ' ', pid); } } /** - * get the sorted profile for the given position of the consensus + * Returns the number of decimal places to show for profile percentages. For + * less than 100 sequences, returns zero (the integer percentage value will be + * displayed). For 100-999 sequences, returns 1, for 1000-9999 returns 2, etc. * - * @param hconsensus + * @param nseq * @return */ - public static int[] extractProfile(Hashtable hconsensus, - boolean ignoreGapsInConsensusCalculation) + protected static int getPercentageDp(long nseq) { - int[] rtnval = new int[64]; - int[][] profile = (int[][]) hconsensus.get(AAFrequency.PROFILE); - if (profile == null) - return null; - Object[] ca = new Object[profile[0].length]; - float[] vl = new float[profile[0].length]; - for (int c = 0; c < ca.length; c++) - { - ca[c] = new char[] - { (char) c }; - vl[c] = profile[0][c]; - } - ; - jalview.util.QuickSort.sort(vl, ca); - rtnval[0] = 2; - rtnval[1] = 0; - for (int c = ca.length - 1; profile[0][((char[]) ca[c])[0]] > 0; c--) + int scale = 0; + while (nseq >= 100) { - if (((char[]) ca[c])[0] != '-') - { - rtnval[rtnval[0]++] = ((char[]) ca[c])[0]; - rtnval[rtnval[0]] = (int) (profile[0][((char[]) ca[c])[0]] * 100f / profile[1][ignoreGapsInConsensusCalculation ? 1 - : 0]); - rtnval[1] += rtnval[rtnval[0]++]; - } + scale++; + nseq /= 10; } - return rtnval; + return scale; } }