*/
package jalview.viewmodel.seqfeatures;
-import jalview.api.AlignViewportI;
-import jalview.api.FeatureColourI;
-import jalview.api.FeaturesDisplayedI;
-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 java.awt.Color;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-public abstract class FeatureRendererModel implements
- jalview.api.FeatureRenderer
+import jalview.api.AlignViewportI;
+import jalview.api.FeatureColourI;
+import jalview.api.FeaturesDisplayedI;
+import jalview.datamodel.AlignedCodonFrame;
+import jalview.datamodel.AlignedCodonFrame.SequenceToSequenceMapping;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.MappedFeatures;
+import jalview.datamodel.SearchResultMatchI;
+import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
+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;
+
+public abstract class FeatureRendererModel
+ implements jalview.api.FeatureRenderer
{
+ /*
+ * a data bean to hold one row of feature settings from the gui
+ */
+ public static class FeatureSettingsBean
+ {
+ public final String featureType;
- /**
+ public final FeatureColourI featureColour;
+
+ public final FeatureMatcherSetI filter;
+
+ 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
*/
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, FeatureMatcherSetI> featureFilters = new HashMap<>();
protected String[] renderOrder;
Map<String, Float> featureOrder = null;
- protected PropertyChangeSupport changeSupport = new PropertyChangeSupport(
- this);
-
protected AlignViewportI av;
+ private PropertyChangeSupport changeSupport = new PropertyChangeSupport(
+ this);
+
@Override
public AlignViewportI getViewport()
{
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())
{
av.setFeaturesDisplayed(fdi = new FeaturesDisplayed());
}
- List<String> nft = new ArrayList<String>();
+ List<String> nft = new ArrayList<>();
for (String featureType : featureTypes)
{
if (!fdi.isRegistered(featureType))
renderOrder = neworder;
}
- protected Map<String, float[][]> minmax = new Hashtable<String, float[][]>();
+ protected Map<String, float[][]> minmax = new Hashtable<>();
public Map<String, float[][]> getMinMax()
{
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
{
{
firing = Boolean.TRUE;
findAllFeatures(true); // add all new features as visible
- changeSupport.firePropertyChange("changeSupport", null, null);
+ notifyFeaturesChanged();
firing = Boolean.FALSE;
}
}
}
@Override
+ public void notifyFeaturesChanged()
+ {
+ changeSupport.firePropertyChange("changeSupport", null, null);
+ }
+
+ @Override
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>();
+ List<SequenceFeature> result = new ArrayList<>();
if (!av.areFeaturesDisplayed() || getFeaturesDisplayed() == null)
{
return result;
List<SequenceFeature> features = sequence.findFeatures(column, column,
visibleTypes);
+ /*
+ * include features unless they are hidden (have no colour), based on
+ * feature group visibility, or a filter or colour threshold
+ */
for (SequenceFeature sf : features)
{
- if (!featureGroupNotShown(sf))
+ if (getColour(sf) != null)
{
result.add(sf);
}
}
FeaturesDisplayedI featuresDisplayed = av.getFeaturesDisplayed();
- Set<String> oldfeatures = new HashSet<String>();
+ Set<String> oldfeatures = new HashSet<>();
if (renderOrder != null)
{
for (int i = 0; i < renderOrder.length; i++)
}
AlignmentI alignment = av.getAlignment();
- List<String> allfeatures = new ArrayList<String>();
+ List<String> allfeatures = new ArrayList<>();
for (int i = 0; i < alignment.getHeight(); i++)
{
*/
if (minmax == null)
{
- minmax = new Hashtable<String, float[][]>();
+ minmax = new Hashtable<>();
}
synchronized (minmax)
{
*/
private void updateRenderOrder(List<String> allFeatures)
{
- List<String> allfeatures = new ArrayList<String>(allFeatures);
+ List<String> allfeatures = new ArrayList<>(allFeatures);
String[] oldRender = renderOrder;
renderOrder = new String[allfeatures.size()];
boolean initOrders = (featureOrder == null);
{
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. Returns null for a score feature whose score value lies
- * outside any colour threshold.
- *
- * @param feature
- * @return
- */
+ @Override
public Color getColour(SequenceFeature feature)
{
FeatureColourI fc = getFeatureStyle(feature.getType());
- return fc.getColor(feature);
+ 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
{
if (featureOrder == null)
{
- featureOrder = new Hashtable<String, Float>();
+ featureOrder = new Hashtable<>();
}
- featureOrder.put(type, new Float(position));
+ featureOrder.put(type, Float.valueOf(position));
return position;
}
* 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
*/
List<String> visibleFeatures = getDisplayedFeatureTypes();
- Map<String, FeatureColourI> visibleColours = new HashMap<String, FeatureColourI>(
+ Map<String, FeatureColourI> visibleColours = new HashMap<>(
getFeatureColours());
FeaturesDisplayedI av_featuresdisplayed = null;
}
else
{
- av.setFeaturesDisplayed(av_featuresdisplayed = new FeaturesDisplayed());
+ av.setFeaturesDisplayed(
+ av_featuresdisplayed = new FeaturesDisplayed());
}
}
else
{
for (int i = 0; i < data.length; i++)
{
- String type = data[i][0].toString();
- setColour(type, (FeatureColourI) data[i][1]);
- if (((Boolean) data[i][2]).booleanValue())
+ String type = data[i].featureType;
+ setColour(type, data[i].featureColour);
+ if (data[i].show)
{
av_featuresdisplayed.setVisible(type);
}
{
// 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)
{
}
if (newGroupsVisible)
{
- featureGroups.put(group, new Boolean(true));
+ featureGroups.put(group, Boolean.valueOf(true));
return true;
}
return false;
{
if (featureGroups != null)
{
- List<String> gp = new ArrayList<String>();
+ List<String> gp = new ArrayList<>();
for (String grp : featureGroups.keySet())
{
@Override
public void setGroupVisibility(String group, boolean visible)
{
- featureGroups.put(group, new Boolean(visible));
+ featureGroups.put(group, Boolean.valueOf(visible));
}
@Override
for (String gst : toset)
{
Boolean st = featureGroups.get(gst);
- featureGroups.put(gst, new Boolean(visible));
+ featureGroups.put(gst, Boolean.valueOf(visible));
if (st != null)
{
rdrw = rdrw || (visible != st.booleanValue());
@Override
public Map<String, FeatureColourI> getDisplayedFeatureCols()
{
- Map<String, FeatureColourI> fcols = new Hashtable<String, FeatureColourI>();
+ Map<String, FeatureColourI> fcols = new Hashtable<>();
if (getViewport().getFeaturesDisplayed() == null)
{
return fcols;
public List<String> getDisplayedFeatureTypes()
{
List<String> typ = getRenderOrder();
- List<String> displayed = new ArrayList<String>();
+ List<String> displayed = new ArrayList<>();
FeaturesDisplayedI feature_disp = av.getFeaturesDisplayed();
if (feature_disp != null)
{
@Override
public List<String> getDisplayedFeatureGroups()
{
- List<String> _gps = new ArrayList<String>();
+ List<String> _gps = new ArrayList<>();
for (String gp : getFeatureGroups())
{
if (checkGroupVisibility(gp, false))
* @param sequenceFeature
* @return
*/
- protected boolean featureGroupNotShown(final SequenceFeature sequenceFeature)
+ public boolean featureGroupNotShown(final SequenceFeature sequenceFeature)
{
return featureGroups != null
&& sequenceFeature.featureGroup != null
*/
@Override
public List<SequenceFeature> findFeaturesAtResidue(SequenceI sequence,
- int resNo)
+ int fromResNo, int toResNo)
{
- List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+ List<SequenceFeature> result = new ArrayList<>();
if (!av.areFeaturesDisplayed() || getFeaturesDisplayed() == null)
{
return result;
* displayed, and feature group is null or the empty string
* or marked for display
*/
- Set<String> visibleFeatures = getFeaturesDisplayed()
- .getVisibleFeatures();
+ List<String> visibleFeatures = getDisplayedFeatureTypes();
String[] visibleTypes = visibleFeatures
.toArray(new String[visibleFeatures.size()]);
List<SequenceFeature> features = sequence.getFeatures().findFeatures(
- resNo, resNo, visibleTypes);
+ fromResNo, toResNo, visibleTypes);
for (SequenceFeature sf : features)
{
- if (!featureGroupNotShown(sf))
+ if (!featureGroupNotShown(sf) && getColour(sf) != null)
{
result.add(sf);
}
}
/**
- * Removes from the list of features any that have a feature group that is not
- * displayed, or duplicate the location of a feature of the same type (unless
- * a graduated colour scheme or colour by label is applied). Should be used
- * only for features of the same feature colour (which normally implies the
- * same feature type).
+ * 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
- * @param fc
*/
- public void filterFeaturesForDisplay(List<SequenceFeature> features,
- FeatureColourI fc)
+ 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);
- boolean simpleColour = fc == null || fc.isSimpleColour();
SequenceFeature lastFeature = null;
Iterator<SequenceFeature> it = features.iterator();
* (checking type and isContactFeature as a fail-safe here, although
* currently they are guaranteed to match in this context)
*/
- if (simpleColour)
+ 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, FeatureMatcherSetI> getFeatureFilters()
+ {
+ return featureFilters;
+ }
+
+ @Override
+ public void setFeatureFilters(Map<String, FeatureMatcherSetI> filters)
+ {
+ featureFilters = filters;
+ }
+
+ @Override
+ public FeatureMatcherSetI getFeatureFilter(String featureType)
+ {
+ return featureFilters.get(featureType);
+ }
+
+ @Override
+ public void setFeatureFilter(String featureType, FeatureMatcherSetI 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 group visibility, by filters, or by colour threshold settings. This
+ * method does not take feature visibility into account.
+ *
+ * @param sf
+ * @param fc
+ * @return
+ */
+ public Color getColor(SequenceFeature sf, FeatureColourI fc)
+ {
+ /*
+ * 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)
+ {
+ FeatureMatcherSetI filter = featureFilters.get(sf.getType());
+ return filter == null ? true : filter.matches(sf);
+ }
+
+ @Override
+ public MappedFeatures findComplementFeaturesAtResidue(
+ final SequenceI sequence, final int pos)
+ {
+ SequenceI ds = sequence.getDatasetSequence();
+ if (ds == null)
+ {
+ ds = sequence;
+ }
+ final char residue = ds.getCharAt(pos - ds.getStart());
+
+ List<SequenceFeature> found = new ArrayList<>();
+ List<AlignedCodonFrame> mappings = this.av.getAlignment()
+ .getCodonFrame(sequence);
+
+ /*
+ * fudge: if no mapping found, check the complementary alignment
+ * todo: only store in one place? StructureSelectionManager?
+ */
+ if (mappings.isEmpty())
+ {
+ mappings = this.av.getCodingComplement().getAlignment()
+ .getCodonFrame(sequence);
+ }
+
+ /*
+ * todo: direct lookup of CDS for peptide and vice-versa; for now,
+ * have to search through an unordered list of mappings for a candidate
+ */
+ SequenceToSequenceMapping mapping = null;
+ SequenceI mapFrom = null;
+
+ for (AlignedCodonFrame acf : mappings)
+ {
+ mapping = acf.getCoveringCodonMapping(ds);
+ if (mapping == null)
+ {
+ continue;
+ }
+ SearchResultsI sr = new SearchResults();
+ mapping.markMappedRegion(ds, pos, sr);
+ for (SearchResultMatchI match : sr.getResults())
+ {
+ int fromRes = match.getStart();
+ int toRes = match.getEnd();
+ mapFrom = match.getSequence();
+ List<SequenceFeature> fs = findFeaturesAtResidue(
+ mapFrom, fromRes, toRes);
+ for (SequenceFeature sf : fs)
+ {
+ if (!found.contains(sf))
+ {
+ found.add(sf);
+ }
+ }
+ }
+
+ /*
+ * just take the first mapped features we find
+ */
+ if (!found.isEmpty())
{
- if (lastFeature != null && sf.getBegin() == lastFeature.getBegin()
- && sf.getEnd() == lastFeature.getEnd()
- && sf.isContactFeature() == lastFeature.isContactFeature()
- && sf.getType().equals(lastFeature.getType()))
+ break;
+ }
+ }
+ if (found.isEmpty())
+ {
+ return null;
+ }
+
+ /*
+ * sort by renderorder (inefficiently but ok for small scale);
+ * NB this sorts 'on top' feature to end, for rendering
+ */
+ List<SequenceFeature> result = new ArrayList<>();
+ final int toAdd = found.size();
+ int added = 0;
+ for (String type : renderOrder)
+ {
+ for (SequenceFeature sf : found)
+ {
+ if (type.equals(sf.getType()))
+ {
+ result.add(sf);
+ added++;
+ }
+ if (added == toAdd)
{
- it.remove();
+ break;
}
}
- lastFeature = sf;
}
+
+ return new MappedFeatures(mapping.getMapping(), mapFrom, pos, residue, result);
+ }
+
+ @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;
}
}
git://source.jalview.org / jalview.git / blobdiff