X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fviewmodel%2Fseqfeatures%2FFeatureRendererModel.java;h=28fceec6b08334bdbf2ed601c999af3f214c06b0;hb=0ebfeaf22a68a4c2760ef6980d68ede56ad40eb3;hp=4ab050d2366e107fa3f0e669fe7c15ce5c7af2d8;hpb=0a461d38627bf41323b8f77e5c6f45b300025494;p=jalview.git diff --git a/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java b/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java index 4ab050d..28fceec 100644 --- a/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java +++ b/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java @@ -26,16 +26,17 @@ 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 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; @@ -45,18 +46,29 @@ 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 featureColours = new ConcurrentHashMap(); + /* + * colour scheme for each feature type + */ + protected Map featureColours = new ConcurrentHashMap<>(); - protected Map featureGroups = new ConcurrentHashMap(); + /* + * visibility flag for each feature group + */ + protected Map featureGroups = new ConcurrentHashMap<>(); + + /* + * filters for each feature type + */ + protected Map featureFilters = new HashMap<>(); protected String[] renderOrder; @@ -100,6 +112,7 @@ public abstract class FeatureRendererModel implements 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()) @@ -117,11 +130,10 @@ public abstract class FeatureRendererModel implements synchronized (fd) { fd.clear(); - java.util.Iterator fdisp = _fr.getFeaturesDisplayed() - .getVisibleFeatures(); - while (fdisp.hasNext()) + for (String type : _fr.getFeaturesDisplayed() + .getVisibleFeatures()) { - fd.setVisible(fdisp.next()); + fd.setVisible(type); } } } @@ -157,7 +169,7 @@ public abstract class FeatureRendererModel implements { av.setFeaturesDisplayed(fdi = new FeaturesDisplayed()); } - List nft = new ArrayList(); + List nft = new ArrayList<>(); for (String featureType : featureTypes) { if (!fdi.isRegistered(featureType)) @@ -193,7 +205,7 @@ public abstract class FeatureRendererModel implements renderOrder = neworder; } - protected Map minmax = new Hashtable(); + protected Map minmax = new Hashtable<>(); public Map getMinMax() { @@ -216,7 +228,8 @@ public abstract class FeatureRendererModel implements 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 { @@ -265,43 +278,33 @@ public abstract class FeatureRendererModel implements } @Override - public List findFeaturesAtRes(SequenceI sequence, int res) + public List findFeaturesAtColumn(SequenceI sequence, int column) { - ArrayList tmp = new ArrayList(); - SequenceFeature[] features = sequence.getSequenceFeatures(); - - if (features != null) + /* + * include features at the position provided their feature type is + * displayed, and feature group is null or marked for display + */ + List result = new ArrayList<>(); + if (!av.areFeaturesDisplayed() || getFeaturesDisplayed() == null) { - 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 visibleFeatures = getFeaturesDisplayed() + .getVisibleFeatures(); + String[] visibleTypes = visibleFeatures + .toArray(new String[visibleFeatures.size()]); + List features = sequence.findFeatures(column, column, + visibleTypes); - // check if start/end are at res, and if not a contact feature, that res - // lies between start and end - if ((features[i].getBegin() == res || features[i].getEnd() == res) - || (!features[i].isContactFeature() - && (features[i].getBegin() < res) && (features[i] - .getEnd() >= res))) - { - tmp.add(features[i]); - } + for (SequenceFeature sf : features) + { + if (!featureGroupNotShown(sf)) + { + result.add(sf); } } - return tmp; + return result; } /** @@ -330,7 +333,7 @@ public abstract class FeatureRendererModel implements } FeaturesDisplayedI featuresDisplayed = av.getFeaturesDisplayed(); - Set oldfeatures = new HashSet(); + Set oldfeatures = new HashSet<>(); if (renderOrder != null) { for (int i = 0; i < renderOrder.length; i++) @@ -343,22 +346,25 @@ public abstract class FeatureRendererModel implements } AlignmentI alignment = av.getAlignment(); - List allfeatures = new ArrayList(); // or HashSet? + List allfeatures = new ArrayList<>(); for (int i = 0; i < alignment.getHeight(); i++) { SequenceI asq = alignment.getSequenceAt(i); for (String group : asq.getFeatures().getFeatureGroups(true)) { - if (group == null) - { - continue; - } - Boolean groupDisplayed = featureGroups.get(group); - if (groupDisplayed == null) + boolean groupDisplayed = true; + if (group != null) { - groupDisplayed = Boolean.valueOf(newMadeVisible); - featureGroups.put(group, groupDisplayed); + if (featureGroups.containsKey(group)) + { + groupDisplayed = featureGroups.get(group); + } + else + { + groupDisplayed = newMadeVisible; + featureGroups.put(group, groupDisplayed); + } } if (groupDisplayed) { @@ -376,10 +382,8 @@ public abstract class FeatureRendererModel implements } } - /* - * 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) @@ -422,7 +426,7 @@ public abstract class FeatureRendererModel implements */ if (minmax == null) { - minmax = new Hashtable(); + minmax = new Hashtable<>(); } synchronized (minmax) { @@ -459,7 +463,7 @@ public abstract class FeatureRendererModel implements */ private void updateRenderOrder(List allFeatures) { - List allfeatures = new ArrayList(allFeatures); + List allfeatures = new ArrayList<>(allFeatures); String[] oldRender = renderOrder; renderOrder = new String[allfeatures.size()]; boolean initOrders = (featureOrder == null); @@ -472,7 +476,8 @@ public abstract class FeatureRendererModel implements { 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])) { @@ -485,7 +490,8 @@ public abstract class FeatureRendererModel implements 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]); } @@ -515,7 +521,8 @@ public abstract class FeatureRendererModel implements 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]); } @@ -565,32 +572,11 @@ public abstract class FeatureRendererModel implements 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); } /** @@ -602,7 +588,8 @@ public abstract class FeatureRendererModel implements */ 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 @@ -637,7 +624,7 @@ public abstract class FeatureRendererModel implements { if (featureOrder == null) { - featureOrder = new Hashtable(); + featureOrder = new Hashtable<>(); } featureOrder.put(type, new Float(position)); return position; @@ -696,7 +683,7 @@ public abstract class FeatureRendererModel implements * note visible feature ordering and colours before update */ List visibleFeatures = getDisplayedFeatureTypes(); - Map visibleColours = new HashMap( + Map visibleColours = new HashMap<>( getFeatureColours()); FeaturesDisplayedI av_featuresdisplayed = null; @@ -708,7 +695,8 @@ public abstract class FeatureRendererModel implements } else { - av.setFeaturesDisplayed(av_featuresdisplayed = new FeaturesDisplayed()); + av.setFeaturesDisplayed( + av_featuresdisplayed = new FeaturesDisplayed()); } } else @@ -820,11 +808,12 @@ public abstract class FeatureRendererModel implements { // 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) { @@ -854,7 +843,7 @@ public abstract class FeatureRendererModel implements { if (featureGroups != null) { - List gp = new ArrayList(); + List gp = new ArrayList<>(); for (String grp : featureGroups.keySet()) { @@ -900,16 +889,15 @@ public abstract class FeatureRendererModel implements @Override public Map getDisplayedFeatureCols() { - Map fcols = new Hashtable(); + Map fcols = new Hashtable<>(); if (getViewport().getFeaturesDisplayed() == null) { return fcols; } - Iterator features = getViewport().getFeaturesDisplayed() + Set features = getViewport().getFeaturesDisplayed() .getVisibleFeatures(); - while (features.hasNext()) + for (String feature : features) { - String feature = features.next(); fcols.put(feature, getFeatureStyle(feature)); } return fcols; @@ -929,7 +917,7 @@ public abstract class FeatureRendererModel implements public List getDisplayedFeatureTypes() { List typ = getRenderOrder(); - List displayed = new ArrayList(); + List displayed = new ArrayList<>(); FeaturesDisplayedI feature_disp = av.getFeaturesDisplayed(); if (feature_disp != null) { @@ -950,26 +938,190 @@ public abstract class FeatureRendererModel implements @Override public List getDisplayedFeatureGroups() { - List _gps = new ArrayList(); - boolean valid = false; + List _gps = new ArrayList<>(); for (String gp : getFeatureGroups()) { if (checkGroupVisibility(gp, false)) { - valid = true; _gps.add(gp); } - if (!valid) + } + 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(); + } + + /** + * {@inheritDoc} + */ + @Override + public List findFeaturesAtResidue(SequenceI sequence, + int resNo) + { + List result = new ArrayList<>(); + 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 visibleFeatures = getFeaturesDisplayed() + .getVisibleFeatures(); + String[] visibleTypes = visibleFeatures + .toArray(new String[visibleFeatures.size()]); + List features = sequence.getFeatures().findFeatures( + resNo, resNo, visibleTypes); + + for (SequenceFeature sf : features) + { + if (!featureGroupNotShown(sf)) { - return null; + result.add(sf); } - else + } + 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 features) + { + if (features.isEmpty()) + { + return; + } + SequenceFeatures.sortFeatures(features, true); + SequenceFeature lastFeature = null; + + Iterator 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())) { - // gps = new String[_gps.size()]; - // _gps.toArray(gps); + it.remove(); } + lastFeature = sf; } - return _gps; + } + + @Override + public Map getFeatureFilters() + { + return new HashMap<>(featureFilters); + } + + @Override + public void setFeatureFilters(Map 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)); } }