import jalview.datamodel.AlignmentI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
+import jalview.datamodel.features.SequenceFeatures;
import jalview.renderer.seqfeatures.FeatureRenderer;
import jalview.schemes.FeatureColour;
import jalview.util.ColorUtils;
+import jalview.util.matcher.KeyedMatcherSetI;
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;
import java.util.concurrent.ConcurrentHashMap;
-public abstract class FeatureRendererModel implements
- jalview.api.FeatureRenderer
+public abstract class FeatureRendererModel
+ implements jalview.api.FeatureRenderer
{
- /**
+ /*
* global transparency for feature
*/
protected float transparency = 1.0f;
- protected Map<String, FeatureColourI> featureColours = new ConcurrentHashMap<String, FeatureColourI>();
+ /*
+ * colour scheme for each feature type
+ */
+ protected Map<String, FeatureColourI> featureColours = new ConcurrentHashMap<>();
- protected Map<String, Boolean> featureGroups = new ConcurrentHashMap<String, Boolean>();
+ /*
+ * visibility flag for each feature group
+ */
+ protected Map<String, Boolean> featureGroups = new ConcurrentHashMap<>();
+
+ /*
+ * filters for each feature type
+ */
+ protected Map<String, KeyedMatcherSetI> featureFilters = new HashMap<>();
protected String[] renderOrder;
this.renderOrder = frs.renderOrder;
this.featureGroups = frs.featureGroups;
this.featureColours = frs.featureColours;
+ this.featureFilters = frs.featureFilters;
this.transparency = frs.transparency;
this.featureOrder = frs.featureOrder;
if (av != null && av != fr.getViewport())
if (r[0] != 0 || mm[0] < 0.0)
{
r[0] = 1;
- r[1] = (byte) ((int) 128.0 + 127.0 * (sequenceFeature.score / mm[1]));
+ r[1] = (byte) ((int) 128.0
+ + 127.0 * (sequenceFeature.score / mm[1]));
}
else
{
}
@Override
- public List<SequenceFeature> findFeaturesAtRes(SequenceI sequence, int res)
+ public List<SequenceFeature> findFeaturesAtColumn(SequenceI sequence, int column)
{
+ /*
+ * include features at the position provided their feature type is
+ * displayed, and feature group is null or marked for display
+ */
List<SequenceFeature> result = new ArrayList<SequenceFeature>();
- if (!av.areFeaturesDisplayed())
+ if (!av.areFeaturesDisplayed() || getFeaturesDisplayed() == null)
{
return result;
}
.getVisibleFeatures();
String[] visibleTypes = visibleFeatures
.toArray(new String[visibleFeatures.size()]);
-
- /*
- * 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);
+ List<SequenceFeature> features = sequence.findFeatures(column, column,
+ visibleTypes);
for (SequenceFeature sf : features)
{
}
}
}
- // <<<<<<< HEAD
- //
- // =======
- // if (minmax == null)
- // {
- // minmax = new Hashtable<String, float[][]>();
- // }
- //
- // Set<String> oldGroups = new HashSet<String>(featureGroups.keySet());
- // >>>>>>> refs/heads/develop
+
AlignmentI alignment = av.getAlignment();
- List<String> allfeatures = new ArrayList<String>(); // or HashSet?
+ List<String> allfeatures = new ArrayList<String>();
for (int i = 0; i < alignment.getHeight(); i++)
{
SequenceI asq = alignment.getSequenceAt(i);
for (String group : asq.getFeatures().getFeatureGroups(true))
{
- // <<<<<<< HEAD
- /*
- * features in null group are always displayed; other groups
- * keep their current visibility; new groups as 'newMadeVisible'
- */
boolean groupDisplayed = true;
if (group != null)
- // =======
- // continue;
- // }
- //
- // int index = 0;
- // while (index < features.length)
- // {
- // String fgrp = features[index].getFeatureGroup();
- // oldGroups.remove(fgrp);
- // if (!featuresDisplayed.isRegistered(features[index].getType()))
- // >>>>>>> refs/heads/develop
{
- // <<<<<<< HEAD
if (featureGroups.containsKey(group))
- // =======
- // if (fgrp != null)
- // >>>>>>> refs/heads/develop
{
groupDisplayed = featureGroups.get(group);
}
}
}
- /*
- //<<<<<<< HEAD
- * mark any new feature types as visible
- */
- Collections.sort(allfeatures, String.CASE_INSENSITIVE_ORDER);
+ // uncomment to add new features in alphebetical order (but JAL-2575)
+ // Collections.sort(allfeatures, String.CASE_INSENSITIVE_ORDER);
if (newMadeVisible)
{
for (String type : allfeatures)
setOrder(type, 0);
}
}
- // =======
- // * oldGroups now consists of groups that no longer
- // * have any feature in them - remove these
- // */
- // for (String grp : oldGroups)
- // {
- // featureGroups.remove(grp);
- // >>>>>>> refs/heads/develop
}
updateRenderOrder(allfeatures);
{
if (initOrders)
{
- setOrder(oldRender[j], (1 - (1 + (float) j) / oldRender.length));
+ setOrder(oldRender[j],
+ (1 - (1 + (float) j) / oldRender.length));
}
if (allfeatures.contains(oldRender[j]))
{
if (mmrange != null)
{
FeatureColourI fc = featureColours.get(oldRender[j]);
- if (fc != null && !fc.isSimpleColour() && fc.isAutoScaled())
+ if (fc != null && !fc.isSimpleColour() && fc.isAutoScaled()
+ && !fc.isColourByAttribute())
{
fc.updateBounds(mmrange[0][0], mmrange[0][1]);
}
if (mmrange != null)
{
FeatureColourI fc = featureColours.get(newf[i]);
- if (fc != null && !fc.isSimpleColour() && fc.isAutoScaled())
+ if (fc != null && !fc.isSimpleColour() && fc.isAutoScaled()
+ && !fc.isColourByAttribute())
{
fc.updateBounds(mmrange[0][0], mmrange[0][1]);
}
return fc;
}
- /**
- * 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
- */
+ @Override
public Color getColour(SequenceFeature feature)
{
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)
- {
- FeatureColourI fc = getFeatureStyle(sequenceFeature.type);
- return fc.isColored(sequenceFeature);
+ return getColor(feature, fc);
}
/**
*/
protected boolean showFeatureOfType(String type)
{
- return type == null ? false : av.getFeaturesDisplayed().isVisible(type);
+ return type == null ? false : (av.getFeaturesDisplayed() == null ? true
+ : av.getFeaturesDisplayed().isVisible(type));
}
@Override
}
else
{
- av.setFeaturesDisplayed(av_featuresdisplayed = new FeaturesDisplayed());
+ av.setFeaturesDisplayed(
+ av_featuresdisplayed = new FeaturesDisplayed());
}
}
else
{
// conflict between applet and desktop - featureGroups returns the map in
// the desktop featureRenderer
- return (featureGroups == null) ? Arrays.asList(new String[0]) : Arrays
- .asList(featureGroups.keySet().toArray(new String[0]));
+ return (featureGroups == null) ? Arrays.asList(new String[0])
+ : Arrays.asList(featureGroups.keySet().toArray(new String[0]));
}
- public boolean checkGroupVisibility(String group, boolean newGroupsVisible)
+ public boolean checkGroupVisibility(String group,
+ boolean newGroupsVisible)
{
if (featureGroups == null)
{
public List<String> getDisplayedFeatureGroups()
{
List<String> _gps = new ArrayList<String>();
- boolean valid = false;
for (String gp : getFeatureGroups())
{
if (checkGroupVisibility(gp, false))
{
- valid = true;
_gps.add(gp);
}
- if (!valid)
- {
- return null;
- }
- else
- {
- // gps = new String[_gps.size()];
- // _gps.toArray(gps);
- }
}
return _gps;
}
.booleanValue();
}
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public List<SequenceFeature> findFeaturesAtResidue(SequenceI sequence,
+ int resNo)
+ {
+ List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+ if (!av.areFeaturesDisplayed() || getFeaturesDisplayed() == null)
+ {
+ return result;
+ }
+
+ /*
+ * include features at the position provided their feature type is
+ * displayed, and feature group is null or the empty string
+ * or marked for display
+ */
+ Set<String> visibleFeatures = getFeaturesDisplayed()
+ .getVisibleFeatures();
+ String[] visibleTypes = visibleFeatures
+ .toArray(new String[visibleFeatures.size()]);
+ List<SequenceFeature> features = sequence.getFeatures().findFeatures(
+ resNo, resNo, visibleTypes);
+
+ for (SequenceFeature sf : features)
+ {
+ if (!featureGroupNotShown(sf))
+ {
+ result.add(sf);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Removes from the list of features any that duplicate the location of a
+ * feature of the same type. Should be used only for features of the same,
+ * simple, feature colour (which normally implies the same feature type). Does
+ * not check visibility settings for feature type or feature group.
+ *
+ * @param features
+ */
+ public void filterFeaturesForDisplay(List<SequenceFeature> features)
+ {
+ if (features.isEmpty())
+ {
+ return;
+ }
+ SequenceFeatures.sortFeatures(features, true);
+ SequenceFeature lastFeature = null;
+
+ Iterator<SequenceFeature> it = features.iterator();
+ while (it.hasNext())
+ {
+ SequenceFeature sf = it.next();
+
+ /*
+ * a feature is redundant for rendering purposes if it has the
+ * same extent as another (so would just redraw the same colour);
+ * (checking type and isContactFeature as a fail-safe here, although
+ * currently they are guaranteed to match in this context)
+ */
+ if (lastFeature != null && sf.getBegin() == lastFeature.getBegin()
+ && sf.getEnd() == lastFeature.getEnd()
+ && sf.isContactFeature() == lastFeature.isContactFeature()
+ && sf.getType().equals(lastFeature.getType()))
+ {
+ it.remove();
+ }
+ lastFeature = sf;
+ }
+ }
+
+ @Override
+ public Map<String, KeyedMatcherSetI> getFeatureFilters()
+ {
+ return new HashMap<>(featureFilters);
+ }
+
+ @Override
+ public void setFeatureFilters(Map<String, KeyedMatcherSetI> filters)
+ {
+ featureFilters = filters;
+ }
+
+ @Override
+ public KeyedMatcherSetI getFeatureFilter(String featureType)
+ {
+ return featureFilters.get(featureType);
+ }
+
+ @Override
+ public void setFeatureFilter(String featureType, KeyedMatcherSetI filter)
+ {
+ if (filter == null || filter.isEmpty())
+ {
+ featureFilters.remove(featureType);
+ }
+ else
+ {
+ featureFilters.put(featureType, filter);
+ }
+ }
+
+ /**
+ * Answers the colour for the feature, or null if the feature is excluded by
+ * feature type or group visibility, by filters, or by colour threshold
+ * settings
+ *
+ * @param sf
+ * @param fc
+ * @return
+ */
+ public Color getColor(SequenceFeature sf, FeatureColourI fc)
+ {
+ /*
+ * is the feature type displayed?
+ */
+ if (!showFeatureOfType(sf.getType()))
+ {
+ return null;
+ }
+
+ /*
+ * is the feature group displayed?
+ */
+ if (featureGroupNotShown(sf))
+ {
+ return null;
+ }
+
+ /*
+ * does the feature pass filters?
+ */
+ if (!featureMatchesFilters(sf))
+ {
+ return null;
+ }
+
+ return fc.getColor(sf);
+ }
+
+ /**
+ * Answers true if there no are filters defined for the feature type, or this
+ * feature matches the filters. Answers false if the feature fails to match
+ * filters.
+ *
+ * @param sf
+ * @return
+ */
+ protected boolean featureMatchesFilters(SequenceFeature sf)
+ {
+ KeyedMatcherSetI filter = featureFilters.get(sf.getType());
+ return filter == null ? true : filter.matches(key -> sf
+ .getValueAsString(key));
+ }
+
}