X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fviewmodel%2Fseqfeatures%2FFeatureRendererModel.java;h=4fc143e4a88da2d4c22e8d9eba09b5c24831341c;hb=c6d5255c09855fc1b0d03a085da9988a75cd3898;hp=e4d9d880e8a7bc2422b12ffe49e7b131d94e4a11;hpb=274dcb86a3d7ab44e051325b7bd38c5a138bf087;p=jalview.git

diff --git a/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java b/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java
index e4d9d88..4fc143e 100644
--- a/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java
+++ b/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java
@@ -23,7 +23,13 @@ package jalview.viewmodel.seqfeatures;
 import jalview.api.AlignViewportI;
 import jalview.api.FeatureColourI;
 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;
+import jalview.datamodel.SearchResultsI;
 import jalview.datamodel.SequenceFeature;
 import jalview.datamodel.SequenceI;
 import jalview.datamodel.features.FeatureMatcherSetI;
@@ -320,12 +326,12 @@ public abstract class FeatureRendererModel
             visibleTypes);
 
     /*
-     * include features unless their feature group is not displayed, or
-     * they are hidden (have no colour) based on a filter or colour threshold
+     * 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) && getColour(sf) != null)
+      if (getColour(sf) != null)
       {
         result.add(sf);
       }
@@ -983,7 +989,7 @@ public abstract class FeatureRendererModel
    * @param sequenceFeature
    * @return
    */
-  protected boolean featureGroupNotShown(final SequenceFeature sequenceFeature)
+  public boolean featureGroupNotShown(final SequenceFeature sequenceFeature)
   {
     return featureGroups != null
             && sequenceFeature.featureGroup != null
@@ -998,7 +1004,7 @@ public abstract class FeatureRendererModel
    */
   @Override
   public List<SequenceFeature> findFeaturesAtResidue(SequenceI sequence,
-          int resNo)
+          int fromResNo, int toResNo)
   {
     List<SequenceFeature> result = new ArrayList<>();
     if (!av.areFeaturesDisplayed() || getFeaturesDisplayed() == null)
@@ -1011,12 +1017,11 @@ public abstract class FeatureRendererModel
      * 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)
     {
@@ -1032,16 +1037,24 @@ public abstract class FeatureRendererModel
    * 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.
+   * not check visibility settings for feature type or feature group. 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;
 
@@ -1142,4 +1155,93 @@ public abstract class FeatureRendererModel
     return filter == null ? true : filter.matches(sf);
   }
 
+  /**
+   * 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.
+   * 
+   * @param sequence
+   * @param pos
+   * @return
+   */
+  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 = acf.getMappingForSequence(sequence, true);
+      if (mapping == null || mapping.getMap().getFromRatio() == mapping
+              .getMap().getToRatio())
+      {
+        continue; // we are only looking for 3:1 or 1:3 mappings
+      }
+      SearchResultsI sr = new SearchResults();
+      acf.markMappedRegion(ds, pos, sr);
+      for (SearchResultMatchI match : sr.getResults())
+      {
+        int fromRes = match.getStart();
+        int toRes = match.getEnd();
+        mapFrom = match.getSequence();
+        List<SequenceFeature> fs = findFeaturesAtResidue(
+                match.getSequence(), fromRes, toRes);
+        for (SequenceFeature sf : fs)
+        {
+          if (!found.contains(sf))
+          {
+            found.add(sf);
+          }
+        }
+      }
+
+      /*
+       * just take the first mapped features we find
+       */
+      if (!found.isEmpty())
+      {
+        break;
+      }
+    }
+
+    /*
+     * sort by renderorder, inefficiently
+     */
+    List<SequenceFeature> result = new ArrayList<>();
+    for (String type : renderOrder)
+    {
+      for (SequenceFeature sf : found)
+      {
+        if (type.equals(sf.getType()))
+        {
+          result.add(sf);
+          if (result.size() == found.size())
+          {
+            return new MappedFeatures(mapping, mapFrom, pos, residue,
+                    result);
+          }
+        }
+      }
+    }
+    
+    return new MappedFeatures(mapping, mapFrom, pos, residue, result);
+  }
+
 }