/*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
- * 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.
*
*/
package jalview.analysis;
-import java.awt.Color;
-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
int end;
- Vector seqNums; // vector of int vectors where first is sequence checksum
+ Vector<int[]> 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<String, Integer>[] total;
boolean canonicaliseAa = true; // if true then conservation calculation will
// symbol
/** Stores calculated quality values */
- public Vector quality;
+ private Vector<Double> 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 = "";
-
- int[][] cons2;
+ private int[][] cons2;
private String[] consSymbs;
*
* @param name
* Name of conservation
- * @param propHash
- * hash of properties for each symbol
* @param threshold
* to count the residues in residueHash(). commonly used value is 3
* @param sequences
* @param end
* end residue position
*/
- public Conservation(String name, Hashtable propHash, int threshold,
+ public Conservation(String name, int threshold,
List<SequenceI> sequences, int start, int end)
{
this.name = name;
- this.propHash = propHash;
this.threshold = threshold;
this.start = start;
this.end = end;
{
for (s = 0; s < sSize; s++)
{
- sarray[s] = (SequenceI) sequences.get(s);
+ sarray[s] = sequences.get(s);
if (sarray[s].getLength() > maxLength)
{
maxLength = sarray[s].getLength();
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;
*/
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];
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 = '-';
else
{
// recover canonical aa symbol
- c = jalview.schemes.ResidueProperties.aa[c].charAt(0);
+ c = ResidueProperties.aa[c].charAt(0);
}
}
else
c = '-';
}
- if (!canonicaliseAa && 'a' <= c && c <= 'z')
- {
- c -= (32); // 32 = 'a' - 'A'
- }
+ c = toUpperCase(c);
}
values[c]++;
}
thresh = (threshold * (jSize)) / 100;
// loop over all the found residues
- resultHash = new Hashtable();
+ Hashtable<String, Integer> resultHash = new Hashtable<String, Integer>();
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<String, Integer> ht = ResidueProperties.propHash.get(type);
// Have we ticked this before?
if (!resultHash.containsKey(type))
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));
}
}
else
{
+ c = toUpperCase(c);
nres++;
if (nres == 1)
}
/**
+ * 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
+ * if true, positive conservation; false calculates negative
* conservation
* @param percentageGaps
* 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
{
consString.append('-');
}
- consSymbs = new String[end-start+1];
+ 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;
- consSymbs[i-start]=new String();
-
+ 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<String, Integer> 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];
+ consSymbs[i - start] = type + " " + consSymbs[i - start];
count++;
}
}
else
{
- if (result.intValue() != -1)
+ if (result != -1)
{
- {
- if (result.intValue()==0) {
- consSymbs[i-start] = consSymbs[i-start]+ " !"+type;
- } else {
- consSymbs[i-start] = type+" "+consSymbs[i-start];
- }
+ if (result == 0)
+ {
+ consSymbs[i - start] = consSymbs[i - start] + " !" + type;
+ }
+ else
+ {
+ consSymbs[i - start] = type + " " + consSymbs[i - start];
}
-
count++;
}
}
*/
private void percentIdentity2()
{
- seqNums = new Vector();
+ seqNums = new Vector<int[]>();
// calcSeqNum(s);
int i = 0, iSize = sequences.length;
// Do we need to calculate this again?
while (j < sequences.length)
{
- sqnum = (int[]) seqNums.elementAt(j);
+ sqnum = seqNums.elementAt(j);
for (i = 1; i < sqnum.length; i++)
{
/**
* Calculates the quality of the set of sequences
*
- * @param start
+ * @param startRes
* Start residue
- * @param end
+ * @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>();
double max = -10000;
- int[][] BLOSUM62 = jalview.schemes.ResidueProperties.getBLOSUM62();
+ int[][] BLOSUM62 = ResidueProperties.getBLOSUM62();
// Loop over columns // JBPNote Profiling info
// long ts = System.currentTimeMillis();
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;
{
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++)
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);
}
// 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
+ * 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.
*
char c;
- if (conservation.annotations != null
+ if (conservation != null && conservation.annotations != null
&& conservation.annotations.length < alWidth)
{
conservation.annotations = new Annotation[alWidth];
if (quality2 != null)
{
- quality2.graphMax = qualityRange[1].floatValue();
+ quality2.graphMax = (float) qualityRange[1];
if (quality2.annotations != null
&& quality2.annotations.length < alWidth)
{
quality2.annotations = new Annotation[alWidth];
}
- qmin = qualityRange[0].floatValue();
- qmax = qualityRange[1].floatValue();
+ qmin = (float) qualityRange[0];
+ qmax = (float) qualityRange[1];
}
- for (int i = 0; i < alWidth; i++)
+ for (int i = istart; i < alWidth; i++)
{
float value = 0;
if (Character.isDigit(c))
{
- value = (int) (c - '0');
+ value = c - '0';
}
else if (c == '*')
{
value = 10;
}
- float vprop = value - min;
- vprop /= max;
- conservation.annotations[i] = new Annotation(String.valueOf(c),
- consSymbs[i-start], ' ', value, new Color(minR
- + (maxR * vprop), minG + (maxG * vprop), minB
- + (maxB * vprop)));
+ 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 = ((Double) quality.elementAt(i)).floatValue();
- vprop = value - qmin;
+ value = quality.elementAt(i).floatValue();
+ float vprop = value - qmin;
vprop /= qmax;
quality2.annotations[i] = new Annotation(" ",
String.valueOf(value), ' ', value, new Color(minR
*
* @param name
* - name of conservation
- * @param consHash
- * - hash table of properties for each amino acid (normally
- * ResidueProperties.propHash)
* @param threshold
* - minimum number of conserved residues needed to indicate
* conservation (typically 3)
* @return Conservation object ready for use in visualization
*/
public static Conservation calculateConservation(String name,
- Hashtable consHash, int threshold, List<SequenceI> seqs,
- int start, int end, boolean posOrNeg, int consPercGaps,
- boolean calcQuality)
- {
- Conservation cons = new Conservation(name, consHash, threshold, seqs,
- start, end);
- return calculateConservation(cons, posOrNeg, consPercGaps, calcQuality);
- }
-
- /**
- * @param b
- * 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(Conservation cons,
- boolean b, int consPercGaps, boolean calcQuality)
+ int threshold, List<SequenceI> seqs, int start, int end,
+ boolean posOrNeg, int consPercGaps, boolean calcQuality)
{
+ Conservation cons = new Conservation(name, threshold, seqs, start, end);
cons.calculate();
- cons.verdict(b, consPercGaps);
+ cons.verdict(posOrNeg, consPercGaps);
if (calcQuality)
{
git://source.jalview.org / jalview.git / blobdiff