import jalview.api.FeaturesDisplayedI;
import jalview.datamodel.AlignedCodonFrame;
import jalview.datamodel.AlignmentI;
+import jalview.datamodel.MappedFeatures;
import jalview.datamodel.Mapping;
import jalview.datamodel.SearchResultMatchI;
import jalview.datamodel.SearchResults;
{
featureOrder = new Hashtable<>();
}
- featureOrder.put(type, new Float(position));
+ featureOrder.put(type, Float.valueOf(position));
return position;
}
}
if (newGroupsVisible)
{
- featureGroups.put(group, new Boolean(true));
+ featureGroups.put(group, Boolean.valueOf(true));
return true;
}
return false;
@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());
}
/**
- * 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. No
- * filtering is done if transparency, or any feature filters, are in force.
+ * 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
*/
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()))
}
/**
- * Answers a (possibly empty) list of features in this alignment at a position
- * (or range) which is mappable from the given sequence residue position in a
- * mapped alignment. Features are returned in render order of feature type (on
- * top last), with order within feature type undefined.
+ * Answers a bean containing a mapping, and a list of features in this
+ * alignment at a position (or range) which is mappable from the given
+ * sequence residue position in a mapped alignment. Features are returned in
+ * render order of feature type (on top last), with order within feature type
+ * undefined. If no features or mapping are found, answers null.
*
* @param sequence
* @param pos
* @return
*/
- public List<SequenceFeature> findComplementFeaturesAtResidue(SequenceI sequence, int pos)
+ public MappedFeatures findComplementFeaturesAtResidue(SequenceI sequence,
+ 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);
* todo: direct lookup of CDS for peptide and vice-versa; for now,
* have to search through an unordered list of mappings for a candidate
*/
+ Mapping mapping = null;
+ SequenceI mapFrom = null;
+
for (AlignedCodonFrame acf : mappings)
{
- Mapping mapping = acf.getMappingForSequence(sequence, true);
+ mapping = acf.getMappingForSequence(sequence, true);
if (mapping == null || mapping.getMap().getFromRatio() == mapping
.getMap().getToRatio())
{
{
int fromRes = match.getStart();
int toRes = match.getEnd();
+ mapFrom = match.getSequence();
List<SequenceFeature> fs = findFeaturesAtResidue(
match.getSequence(), fromRes, toRes);
for (SequenceFeature sf : fs)
}
}
}
+
+ /*
+ * just take the first mapped features we find
+ */
+ if (!found.isEmpty())
+ {
+ break;
+ }
+ }
+ if (found.isEmpty())
+ {
+ return null;
}
+
/*
* sort by renderorder, inefficiently
*/
result.add(sf);
if (result.size() == found.size())
{
- return result;
+ return new MappedFeatures(mapping, mapFrom, pos, residue,
+ result);
}
}
}
}
- return result;
+ return new MappedFeatures(mapping, 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;
}
}