import jalview.datamodel.AlignmentI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
+import jalview.datamodel.features.FeatureMatcherSetI;
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.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
implements jalview.api.FeatureRenderer
{
/*
- * column indices of fields in Feature Settings table
- * todo: transfer valuers as data beans instead of Object[][]
+ * a data bean to hold one row of feature settings from the gui
*/
- public static final int TYPE_COLUMN = 0;
+ public static class FeatureSettingsBean
+ {
+ public final String featureType;
- public static final int COLOUR_COLUMN = 1;
+ public final FeatureColourI featureColour;
- public static final int FILTER_COLUMN = 2;
+ public final FeatureMatcherSetI filter;
- public static final int SHOW_COLUMN = 3;
+ public final Boolean show;
+
+ public FeatureSettingsBean(String type, FeatureColourI colour,
+ FeatureMatcherSetI theFilter, Boolean isShown)
+ {
+ featureType = type;
+ featureColour = colour;
+ filter = theFilter;
+ show = isShown;
+ }
+ }
/*
* global transparency for feature
/*
* filters for each feature type
*/
- protected Map<String, KeyedMatcherSetI> featureFilters = new HashMap<>();
+ protected Map<String, FeatureMatcherSetI> featureFilters = new HashMap<>();
protected String[] renderOrder;
* @param type
* @return
*/
- protected boolean showFeatureOfType(String type)
+ public boolean showFeatureOfType(String type)
{
return type == null ? false : (av.getFeaturesDisplayed() == null ? true
: av.getFeaturesDisplayed().isVisible(type));
* Replace current ordering with new ordering
*
* @param data
- * { String(Type), Colour(Type), Boolean(Displayed) }
+ * an array of { Type, Colour, Filter, Boolean }
* @return true if any visible features have been reordered, else false
*/
- public boolean setFeaturePriority(Object[][] data)
+ public boolean setFeaturePriority(FeatureSettingsBean[] data)
{
return setFeaturePriority(data, true);
}
/**
- * Sets the priority order for features, with the highest priority (displayed
- * on top) at the start of the data array
+ * 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) }
+ * an array of { Type, Colour, Filter, Boolean }
* @param visibleNew
* when true current featureDisplay list will be cleared
- * @return true if any visible features have been reordered or recoloured,
- * else false (i.e. no need to repaint)
+ * @return true if any visible features have been reordered or recoloured, else
+ * false (i.e. no need to repaint)
*/
- public boolean setFeaturePriority(Object[][] data, boolean visibleNew)
+ public boolean setFeaturePriority(FeatureSettingsBean[] data,
+ boolean visibleNew)
{
/*
* note visible feature ordering and colours before update
{
for (int i = 0; i < data.length; i++)
{
- String type = data[i][TYPE_COLUMN].toString();
- setColour(type, (FeatureColourI) data[i][COLOUR_COLUMN]);
- if (((Boolean) data[i][SHOW_COLUMN]).booleanValue())
+ String type = data[i].featureType;
+ setColour(type, data[i].featureColour);
+ if (data[i].show)
{
av_featuresdisplayed.setVisible(type);
}
*/
protected boolean featureGroupNotShown(final SequenceFeature sequenceFeature)
{
+ Boolean b;
return featureGroups != null
&& sequenceFeature.featureGroup != null
- && sequenceFeature.featureGroup.length() != 0
- && featureGroups.containsKey(sequenceFeature.featureGroup)
- && !featureGroups.get(sequenceFeature.featureGroup)
- .booleanValue();
+ && sequenceFeature.featureGroup.length() > 0
+ && (b = featureGroups.get(sequenceFeature.featureGroup)) != null
+ && !b.booleanValue();
}
/**
}
/**
- * 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.
+ * Removes from the list of features any whose group is not shown, or that are
+ * visible and duplicate the location of a visible feature of the same type.
+ * Should be used only for features of the same, simple, feature colour (which
+ * normally implies the same feature type). No filtering is done if
+ * transparency, or any feature filters, are in force.
*
* @param features
*/
public void filterFeaturesForDisplay(List<SequenceFeature> features)
{
- if (features.isEmpty())
+ /*
+ * don't remove 'redundant' features if
+ * - transparency is applied (feature count affects depth of feature colour)
+ * - filters are applied (not all features may be displayable)
+ */
+ if (features.isEmpty() || transparency != 1f
+ || !featureFilters.isEmpty())
{
return;
}
+
SequenceFeatures.sortFeatures(features, true);
SequenceFeature lastFeature = null;
while (it.hasNext())
{
SequenceFeature sf = it.next();
+ if (featureGroupNotShown(sf))
+ {
+ it.remove();
+ continue;
+ }
/*
* a feature is redundant for rendering purposes if it has the
* (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()
+ if (lastFeature != null
+ && sf.getBegin() == lastFeature.getBegin()
&& sf.getEnd() == lastFeature.getEnd()
&& sf.isContactFeature() == lastFeature.isContactFeature()
&& sf.getType().equals(lastFeature.getType()))
}
@Override
- public Map<String, KeyedMatcherSetI> getFeatureFilters()
+ public Map<String, FeatureMatcherSetI> getFeatureFilters()
{
- return new HashMap<>(featureFilters);
+ return featureFilters;
}
@Override
- public void setFeatureFilters(Map<String, KeyedMatcherSetI> filters)
+ public void setFeatureFilters(Map<String, FeatureMatcherSetI> filters)
{
featureFilters = filters;
}
@Override
- public KeyedMatcherSetI getFeatureFilter(String featureType)
+ public FeatureMatcherSetI getFeatureFilter(String featureType)
{
return featureFilters.get(featureType);
}
@Override
- public void setFeatureFilter(String featureType, KeyedMatcherSetI filter)
+ public void setFeatureFilter(String featureType, FeatureMatcherSetI filter)
{
if (filter == null || filter.isEmpty())
{
/**
* 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
+ * feature group visibility, by filters, or by colour threshold settings. This
+ * method does not take feature visibility into account.
*
* @param sf
* @param fc
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))
*/
protected boolean featureMatchesFilters(SequenceFeature sf)
{
- KeyedMatcherSetI filter = featureFilters.get(sf.getType());
- // TODO temporary fudge for Score and Label
- return filter == null ? true
- : filter.matches(
- key -> "Label".equals(key[0]) ? sf.getDescription()
- : ("Score".equals(key[0])
- ? String.valueOf(sf.getScore())
- : sf.getValueAsString(key)));
+ FeatureMatcherSetI filter = featureFilters.get(sf.getType());
+ return filter == null ? true : filter.matches(sf);
+ }
+
+ /**
+ * Answers true unless the specified group is set to hidden. Defaults to true
+ * if group visibility is not set.
+ *
+ * @param group
+ * @return
+ */
+ public boolean isGroupVisible(String group)
+ {
+ if (!featureGroups.containsKey(group))
+ {
+ return true;
+ }
+ return featureGroups.get(group);
+ }
+
+ /**
+ * Orders features in render precedence (last in order is last to render, so
+ * displayed on top of other features)
+ *
+ * @param order
+ */
+ public void orderFeatures(Comparator<String> order)
+ {
+ Arrays.sort(renderOrder, order);
}
+ @Override
+ public boolean isVisible(SequenceFeature feature)
+ {
+ if (feature == null)
+ {
+ return false;
+ }
+ if (getFeaturesDisplayed() == null
+ || !getFeaturesDisplayed().isVisible(feature.getType()))
+ {
+ return false;
+ }
+ if (featureGroupNotShown(feature))
+ {
+ return false;
+ }
+ FeatureColourI fc = featureColours.get(feature.getType());
+ if (fc != null && fc.isOutwithThreshold(feature))
+ {
+ return false;
+ }
+ if (!featureMatchesFilters(feature))
+ {
+ return false;
+ }
+ return true;
+ }
}