import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.renderer.seqfeatures.FeatureRenderer;
-import jalview.schemes.GraduatedColor;
-import jalview.viewmodel.AlignmentViewport;
+import jalview.schemes.FeatureColour;
+import jalview.util.ColorUtils;
import java.awt.Color;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.Hashtable;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
*/
protected float transparency = 1.0f;
- protected Map<String, Object> featureColours = new ConcurrentHashMap<String, Object>();
+ protected Map<String, FeatureColourI> featureColours = new ConcurrentHashMap<String, FeatureColourI>();
protected Map<String, Boolean> featureGroups = new ConcurrentHashMap<String, Boolean>();
- protected Object currentColour;
-
- /*
- * feature types in ordering of rendering, where last means on top
- */
protected String[] renderOrder;
+ Map<String, Float> featureOrder = null;
+
protected PropertyChangeSupport changeSupport = new PropertyChangeSupport(
this);
- protected AlignmentViewport av;
-
- /*
- * map holds per feature type, {{min, max}, {min, max}} feature score
- * values for positional and non-positional features respectively
- */
- private Map<String, float[][]> minmax = new Hashtable<String, float[][]>();
+ protected AlignViewportI av;
@Override
public AlignViewportI getViewport()
synchronized (fd)
{
fd.clear();
- java.util.Iterator<String> fdisp = _fr.getFeaturesDisplayed()
- .getVisibleFeatures();
- while (fdisp.hasNext())
+ for (String type : _fr.getFeaturesDisplayed()
+ .getVisibleFeatures())
{
- fd.setVisible(fdisp.next());
+ fd.setVisible(type);
}
}
}
renderOrder = neworder;
}
+ protected Map<String, float[][]> minmax = new Hashtable<String, float[][]>();
+
public Map<String, float[][]> getMinMax()
{
return minmax;
@Override
public List<SequenceFeature> findFeaturesAtRes(SequenceI sequence, int res)
{
- ArrayList<SequenceFeature> tmp = new ArrayList<SequenceFeature>();
- SequenceFeature[] features = sequence.getSequenceFeatures();
-
- if (features != null)
+ List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+ if (!av.areFeaturesDisplayed())
{
- for (int i = 0; i < features.length; i++)
- {
- if (!av.areFeaturesDisplayed()
- || !av.getFeaturesDisplayed().isVisible(
- features[i].getType()))
- {
- continue;
- }
+ return result;
+ }
- if (features[i].featureGroup != null
- && featureGroups != null
- && featureGroups.containsKey(features[i].featureGroup)
- && !featureGroups.get(features[i].featureGroup)
- .booleanValue())
- {
- continue;
- }
+ Set<String> visibleFeatures = getFeaturesDisplayed()
+ .getVisibleFeatures();
+ String[] visibleTypes = visibleFeatures
+ .toArray(new String[visibleFeatures.size()]);
- if ((features[i].getBegin() <= res)
- && (features[i].getEnd() >= res))
- {
- tmp.add(features[i]);
- }
+ /*
+ * include features at the position provided their feature type is
+ * displayed, and feature group is null or marked for display
+ */
+ List<SequenceFeature> features = sequence.getFeatures().findFeatures(
+ res, res, visibleTypes);
+
+ for (SequenceFeature sf : features)
+ {
+ if (!featureGroupNotShown(sf))
+ {
+ result.add(sf);
}
}
- return tmp;
+ return result;
}
/**
* Searches alignment for all features and updates colours
*
* @param newMadeVisible
- * if true newly added feature types will be rendered immediatly
+ * if true newly added feature types will be rendered immediately
* TODO: check to see if this method should actually be proxied so
* repaint events can be propagated by the renderer code
*/
}
FeaturesDisplayedI featuresDisplayed = av.getFeaturesDisplayed();
- ArrayList<String> allfeatures = new ArrayList<String>();
- ArrayList<String> oldfeatures = new ArrayList<String>();
+ Set<String> oldfeatures = new HashSet<String>();
if (renderOrder != null)
{
for (int i = 0; i < renderOrder.length; i++)
}
}
}
- if (minmax == null)
- {
- minmax = new Hashtable<String, float[][]>();
- }
+
AlignmentI alignment = av.getAlignment();
+ List<String> allfeatures = new ArrayList<String>(); // or HashSet?
+
for (int i = 0; i < alignment.getHeight(); i++)
{
SequenceI asq = alignment.getSequenceAt(i);
- SequenceFeature[] features = asq.getSequenceFeatures();
-
- if (features == null)
- {
- continue;
- }
-
- int index = 0;
- while (index < features.length)
+ for (String group : asq.getFeatures().getFeatureGroups(true))
{
- if (!featuresDisplayed.isRegistered(features[index].getType()))
+ /*
+ * features in null group are always displayed; other groups
+ * keep their current visibility; new groups as 'newMadeVisible'
+ */
+ boolean groupDisplayed = true;
+ if (group != null)
{
- String fgrp = features[index].getFeatureGroup();
- if (fgrp != null)
+ if (featureGroups.containsKey(group))
{
- Boolean groupDisplayed = featureGroups.get(fgrp);
- if (groupDisplayed == null)
- {
- groupDisplayed = Boolean.valueOf(newMadeVisible);
- featureGroups.put(fgrp, groupDisplayed);
- }
- if (!groupDisplayed.booleanValue())
- {
- index++;
- continue;
- }
+ groupDisplayed = featureGroups.get(group);
}
- if (!(features[index].begin == 0 && features[index].end == 0))
+ else
{
- // If beginning and end are 0, the feature is for the whole sequence
- // and we don't want to render the feature in the normal way
-
- if (newMadeVisible
- && !oldfeatures.contains(features[index].getType()))
- {
- // this is a new feature type on the alignment. Mark it for
- // display.
- featuresDisplayed.setVisible(features[index].getType());
- setOrder(features[index].getType(), 0);
- }
+ groupDisplayed = newMadeVisible;
+ featureGroups.put(group, groupDisplayed);
}
}
- if (!allfeatures.contains(features[index].getType()))
+ if (groupDisplayed)
{
- allfeatures.add(features[index].getType());
- }
- if (!Float.isNaN(features[index].score))
- {
- int nonpos = features[index].getBegin() >= 1 ? 0 : 1;
- float[][] mm = minmax.get(features[index].getType());
- if (mm == null)
- {
- mm = new float[][] { null, null };
- minmax.put(features[index].getType(), mm);
- }
- if (mm[nonpos] == null)
- {
- mm[nonpos] = new float[] { features[index].score,
- features[index].score };
-
- }
- else
+ Set<String> types = asq.getFeatures().getFeatureTypesForGroups(
+ true, group);
+ for (String type : types)
{
- if (mm[nonpos][0] > features[index].score)
- {
- mm[nonpos][0] = features[index].score;
- }
- if (mm[nonpos][1] < features[index].score)
+ if (!allfeatures.contains(type)) // or use HashSet and no test?
{
- mm[nonpos][1] = features[index].score;
+ allfeatures.add(type);
}
+ updateMinMax(asq, type, true); // todo: for all features?
}
}
- index++;
}
}
+
+ /*
+ * mark any new feature types as visible
+ */
+ Collections.sort(allfeatures, String.CASE_INSENSITIVE_ORDER);
+ if (newMadeVisible)
+ {
+ for (String type : allfeatures)
+ {
+ if (!oldfeatures.contains(type))
+ {
+ featuresDisplayed.setVisible(type);
+ setOrder(type, 0);
+ }
+ }
+ }
+
updateRenderOrder(allfeatures);
findingFeatures = false;
}
+ /**
+ * Updates the global (alignment) min and max values for a feature type from
+ * the score for a sequence, if the score is not NaN. Values are stored
+ * separately for positional and non-positional features.
+ *
+ * @param seq
+ * @param featureType
+ * @param positional
+ */
+ protected void updateMinMax(SequenceI seq, String featureType,
+ boolean positional)
+ {
+ float min = seq.getFeatures().getMinimumScore(featureType, positional);
+ if (Float.isNaN(min))
+ {
+ return;
+ }
+
+ float max = seq.getFeatures().getMaximumScore(featureType, positional);
+
+ /*
+ * stored values are
+ * { {positionalMin, positionalMax}, {nonPositionalMin, nonPositionalMax} }
+ */
+ if (minmax == null)
+ {
+ minmax = new Hashtable<String, float[][]>();
+ }
+ synchronized (minmax)
+ {
+ float[][] mm = minmax.get(featureType);
+ int index = positional ? 0 : 1;
+ if (mm == null)
+ {
+ mm = new float[][] { null, null };
+ minmax.put(featureType, mm);
+ }
+ if (mm[index] == null)
+ {
+ mm[index] = new float[] { min, max };
+ }
+ else
+ {
+ mm[index][0] = Math.min(mm[index][0], min);
+ mm[index][1] = Math.max(mm[index][1], max);
+ }
+ }
+ }
protected Boolean firing = Boolean.FALSE;
/**
List<String> allfeatures = new ArrayList<String>(allFeatures);
String[] oldRender = renderOrder;
renderOrder = new String[allfeatures.size()];
- Object mmrange, fc = null;
boolean initOrders = (featureOrder == null);
int opos = 0;
if (oldRender != null && oldRender.length > 0)
allfeatures.remove(oldRender[j]);
if (minmax != null)
{
- mmrange = minmax.get(oldRender[j]);
+ float[][] mmrange = minmax.get(oldRender[j]);
if (mmrange != null)
{
- fc = featureColours.get(oldRender[j]);
- if (fc != null && fc instanceof GraduatedColor
- && ((GraduatedColor) fc).isAutoScale())
+ FeatureColourI fc = featureColours.get(oldRender[j]);
+ if (fc != null && !fc.isSimpleColour() && fc.isAutoScaled())
{
- ((GraduatedColor) fc).updateBounds(
- ((float[][]) mmrange)[0][0],
- ((float[][]) mmrange)[0][1]);
+ fc.updateBounds(mmrange[0][0], mmrange[0][1]);
}
}
}
if (minmax != null)
{
// update from new features minmax if necessary
- mmrange = minmax.get(newf[i]);
+ float[][] mmrange = minmax.get(newf[i]);
if (mmrange != null)
{
- fc = featureColours.get(newf[i]);
- if (fc != null && fc instanceof GraduatedColor
- && ((GraduatedColor) fc).isAutoScale())
+ FeatureColourI fc = featureColours.get(newf[i]);
+ if (fc != null && !fc.isSimpleColour() && fc.isAutoScaled())
{
- ((GraduatedColor) fc).updateBounds(((float[][]) mmrange)[0][0],
- ((float[][]) mmrange)[0][1]);
+ fc.updateBounds(mmrange[0][0], mmrange[0][1]);
}
}
}
setOrder(newf[i], i / (float) denom);
}
// set order from newly found feature from persisted ordering.
- sortOrder[i] = 2 - ((Float) featureOrder.get(newf[i])).floatValue();
+ sortOrder[i] = 2 - featureOrder.get(newf[i]).floatValue();
if (i < iSize)
{
// only sort if we need to
/**
* get a feature style object for the given type string. Creates a
- * java.awt.Color for a featureType with no existing colourscheme. TODO:
- * replace return type with object implementing standard abstract colour/style
- * interface
+ * java.awt.Color for a featureType with no existing colourscheme.
*
* @param featureType
- * @return java.awt.Color or GraduatedColor
+ * @return
*/
@Override
- public Object getFeatureStyle(String featureType)
+ public FeatureColourI getFeatureStyle(String featureType)
{
- Object fc = featureColours.get(featureType);
+ FeatureColourI fc = featureColours.get(featureType);
if (fc == null)
{
- jalview.schemes.UserColourScheme ucs = new jalview.schemes.UserColourScheme();
- Color col = ucs.createColourFromName(featureType);
- featureColours.put(featureType, fc = col);
+ Color col = ColorUtils.createColourFromName(featureType);
+ fc = new FeatureColour(col);
+ featureColours.put(featureType, fc);
}
return fc;
}
/**
- * calculate the render colour for a specific feature using current feature
- * settings.
+ * Returns the configured colour for a particular feature instance. This
+ * includes calculation of 'colour by label', or of a graduated score colour,
+ * if applicable. It does not take into account feature visibility or colour
+ * transparency.
*
* @param feature
- * @return render colour for the given feature
+ * @return
*/
public Color getColour(SequenceFeature feature)
{
- Object fc = getFeatureStyle(feature.getType());
- if (fc instanceof Color)
- {
- return (Color) fc;
- }
- else
- {
- if (fc instanceof GraduatedColor)
- {
- return ((GraduatedColor) fc).findColor(feature);
- }
- }
- throw new Error("Implementation Error: Unrecognised render object "
- + fc.getClass() + " for features of type " + feature.getType());
+ FeatureColourI fc = getFeatureStyle(feature.getType());
+ return fc.getColor(feature);
}
+ /**
+ * Answers true unless the feature has a graduated colour scheme and the
+ * feature value lies outside the current threshold for display
+ *
+ * @param sequenceFeature
+ * @return
+ */
protected boolean showFeature(SequenceFeature sequenceFeature)
{
- Object fc = getFeatureStyle(sequenceFeature.type);
- if (fc instanceof GraduatedColor)
- {
- return ((GraduatedColor) fc).isColored(sequenceFeature);
- }
- else
- {
- return true;
- }
+ FeatureColourI fc = getFeatureStyle(sequenceFeature.type);
+ return fc.isColored(sequenceFeature);
}
+ /**
+ * Answers true if the feature type is currently selected to be displayed,
+ * else false
+ *
+ * @param type
+ * @return
+ */
protected boolean showFeatureOfType(String type)
{
- return av.getFeaturesDisplayed().isVisible(type);
+ return type == null ? false : av.getFeaturesDisplayed().isVisible(type);
}
@Override
- public void setColour(String featureType, Object col)
+ public void setColour(String featureType, FeatureColourI col)
{
- // overwrite
- // Color _col = (col instanceof Color) ? ((Color) col) : (col instanceof
- // GraduatedColor) ? ((GraduatedColor) col).getMaxColor() : null;
- // Object c = featureColours.get(featureType);
- // if (c == null || c instanceof Color || (c instanceof GraduatedColor &&
- // !((GraduatedColor)c).getMaxColor().equals(_col)))
- if (col instanceof FeatureColourI)
- {
- if (((FeatureColourI) col).isGraduatedColour())
- {
- col = new GraduatedColor((FeatureColourI) col);
- }
- else
- {
- col = ((FeatureColourI) col).getColour();
- }
- }
- featureColours.put(featureType, col);
+ featureColours.put(featureType, col);
}
+ @Override
public void setTransparency(float value)
{
transparency = value;
}
+ @Override
public float getTransparency()
{
return transparency;
}
- Map featureOrder = null;
-
/**
* analogous to colour - store a normalized ordering for all feature types in
* this rendering context.
{
if (featureOrder == null)
{
- featureOrder = new Hashtable();
+ featureOrder = new Hashtable<String, Float>();
}
featureOrder.put(type, new Float(position));
return position;
{
if (featureOrder.containsKey(type))
{
- return ((Float) featureOrder.get(type)).floatValue();
+ return featureOrder.get(type).floatValue();
}
}
return -1;
}
@Override
- public Map<String, Object> getFeatureColours()
+ public Map<String, FeatureColourI> getFeatureColours()
{
return featureColours;
}
}
/**
- * Sets the priority order for features
+ * Sets the priority order for features, with the highest priority (displayed
+ * on top) at the start of the data array
*
* @param data
* { String(Type), Colour(Type), Boolean(Displayed) }
* note visible feature ordering and colours before update
*/
List<String> visibleFeatures = getDisplayedFeatureTypes();
- Map<String, Object> visibleColours = new HashMap<String, Object>(
+ Map<String, FeatureColourI> visibleColours = new HashMap<String, FeatureColourI>(
getFeatureColours());
FeaturesDisplayedI av_featuresdisplayed = null;
for (int i = 0; i < data.length; i++)
{
String type = data[i][0].toString();
- setColour(type, data[i][1]); // todo : typesafety - feature color
- // interface object
+ setColour(type, (FeatureColourI) data[i][1]);
if (((Boolean) data[i][2]).booleanValue())
{
av_featuresdisplayed.setVisible(type);
* @return list of groups
*/
@Override
- public List getGroups(boolean visible)
+ public List<String> getGroups(boolean visible)
{
if (featureGroups != null)
{
- ArrayList gp = new ArrayList();
+ List<String> gp = new ArrayList<String>();
- for (Object grp : featureGroups.keySet())
+ for (String grp : featureGroups.keySet())
{
Boolean state = featureGroups.get(grp);
if (state.booleanValue() == visible)
}
@Override
- public Hashtable getDisplayedFeatureCols()
+ public Map<String, FeatureColourI> getDisplayedFeatureCols()
{
- Hashtable fcols = new Hashtable();
+ Map<String, FeatureColourI> fcols = new Hashtable<String, FeatureColourI>();
if (getViewport().getFeaturesDisplayed() == null)
{
return fcols;
}
- Iterator<String> en = getViewport().getFeaturesDisplayed()
+ Set<String> features = getViewport().getFeaturesDisplayed()
.getVisibleFeatures();
- while (en.hasNext())
+ for (String feature : features)
{
- String col = en.next();
- fcols.put(col, featureColours.get(col));
+ fcols.put(feature, getFeatureStyle(feature));
}
return fcols;
}
return _gps;
}
+ /**
+ * Answers true if the feature belongs to a feature group which is not
+ * currently displayed, else false
+ *
+ * @param sequenceFeature
+ * @return
+ */
+ protected boolean featureGroupNotShown(final SequenceFeature sequenceFeature)
+ {
+ return featureGroups != null
+ && sequenceFeature.featureGroup != null
+ && sequenceFeature.featureGroup.length() != 0
+ && featureGroups.containsKey(sequenceFeature.featureGroup)
+ && !featureGroups.get(sequenceFeature.featureGroup)
+ .booleanValue();
+ }
+
}