Merge remote-tracking branch 'origin/tasks/JAL-3035_remove_dasobert_dependency' into...
[jalview.git] / src / jalview / analysis / AlignmentAnnotationUtils.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.analysis;
22
23 import jalview.datamodel.AlignmentAnnotation;
24 import jalview.datamodel.SequenceI;
25 import jalview.renderer.AnnotationRenderer;
26
27 import java.util.ArrayList;
28 import java.util.Arrays;
29 import java.util.BitSet;
30 import java.util.Collections;
31 import java.util.HashMap;
32 import java.util.List;
33 import java.util.Map;
34
35 public class AlignmentAnnotationUtils
36 {
37
38   /**
39    * Helper method to populate lists of annotation types for the Show/Hide
40    * Annotations menus. If sequenceGroup is not null, this is restricted to
41    * annotations which are associated with sequences in the selection group.
42    * <p/>
43    * If an annotation row is currently visible, its type (label) is added (once
44    * only per type), to the shownTypes list. If it is currently hidden, it is
45    * added to the hiddenTypesList.
46    * <p/>
47    * For rows that belong to a line graph group, so are always rendered
48    * together:
49    * <ul>
50    * <li>Treat all rows in the group as visible, if at least one of them is</li>
51    * <li>Build a list of all the annotation types that belong to the group</li>
52    * </ul>
53    * 
54    * @param shownTypes
55    *          a map, keyed by calcId (annotation source), whose entries are the
56    *          lists of annotation types found for the calcId; each annotation
57    *          type in turn may be a list (in the case of grouped annotations)
58    * @param hiddenTypes
59    *          a map, similar to shownTypes, but for hidden annotation types
60    * @param annotations
61    *          the annotations on the alignment to scan
62    * @param forSequences
63    *          the sequences to restrict search to
64    */
65   public static void getShownHiddenTypes(
66           Map<String, List<List<String>>> shownTypes,
67           Map<String, List<List<String>>> hiddenTypes,
68           List<AlignmentAnnotation> annotations,
69           List<SequenceI> forSequences)
70   {
71     BitSet visibleGraphGroups = AlignmentAnnotationUtils
72             .getVisibleLineGraphGroups(annotations);
73
74     /*
75      * Build a lookup, by calcId (annotation source), of all annotation types in
76      * each graph group.
77      */
78     Map<String, Map<Integer, List<String>>> groupLabels = new HashMap<String, Map<Integer, List<String>>>();
79
80     // trackers for which calcId!label combinations we have dealt with
81     List<String> addedToShown = new ArrayList<String>();
82     List<String> addedToHidden = new ArrayList<String>();
83
84     for (AlignmentAnnotation aa : annotations)
85     {
86       /*
87        * Ignore non-positional annotations, can't render these against an
88        * alignment
89        */
90       if (aa.annotations == null)
91       {
92         continue;
93       }
94       if (forSequences != null && (aa.sequenceRef != null
95               && forSequences.contains(aa.sequenceRef)))
96       {
97         String calcId = aa.getCalcId();
98
99         /*
100          * Build a 'composite label' for types in line graph groups.
101          */
102         final List<String> labelAsList = new ArrayList<String>();
103         final String displayLabel = aa.label;
104         labelAsList.add(displayLabel);
105         if (aa.graph == AlignmentAnnotation.LINE_GRAPH
106                 && aa.graphGroup > -1)
107         {
108           if (!groupLabels.containsKey(calcId))
109           {
110             groupLabels.put(calcId, new HashMap<Integer, List<String>>());
111           }
112           Map<Integer, List<String>> groupLabelsForCalcId = groupLabels
113                   .get(calcId);
114           if (groupLabelsForCalcId.containsKey(aa.graphGroup))
115           {
116             if (!groupLabelsForCalcId.get(aa.graphGroup)
117                     .contains(displayLabel))
118             {
119               groupLabelsForCalcId.get(aa.graphGroup).add(displayLabel);
120             }
121           }
122           else
123           {
124             groupLabelsForCalcId.put(aa.graphGroup, labelAsList);
125           }
126         }
127         else
128         /*
129          * 'Simple case' - not a grouped annotation type - list of one label
130          * only
131          */
132         {
133           String rememberAs = calcId + "!" + displayLabel;
134           if (aa.visible && !addedToShown.contains(rememberAs))
135           {
136             if (!shownTypes.containsKey(calcId))
137             {
138               shownTypes.put(calcId, new ArrayList<List<String>>());
139             }
140             shownTypes.get(calcId).add(labelAsList);
141             addedToShown.add(rememberAs);
142           }
143           else
144           {
145             if (!aa.visible && !addedToHidden.contains(rememberAs))
146             {
147               if (!hiddenTypes.containsKey(calcId))
148               {
149                 hiddenTypes.put(calcId, new ArrayList<List<String>>());
150               }
151               hiddenTypes.get(calcId).add(labelAsList);
152               addedToHidden.add(rememberAs);
153             }
154           }
155         }
156       }
157     }
158     /*
159      * Finally add the 'composite group labels' to the appropriate lists,
160      * depending on whether the group is identified as visible or hidden. Don't
161      * add the same label more than once (there may be many graph groups that
162      * generate it).
163      */
164     for (String calcId : groupLabels.keySet())
165     {
166       for (int group : groupLabels.get(calcId).keySet())
167       {
168         final List<String> groupLabel = groupLabels.get(calcId).get(group);
169         // don't want to duplicate 'same types in different order'
170         Collections.sort(groupLabel);
171         if (visibleGraphGroups.get(group))
172         {
173           if (!shownTypes.containsKey(calcId))
174           {
175             shownTypes.put(calcId, new ArrayList<List<String>>());
176           }
177           if (!shownTypes.get(calcId).contains(groupLabel))
178           {
179             shownTypes.get(calcId).add(groupLabel);
180           }
181         }
182         else
183         {
184           if (!hiddenTypes.containsKey(calcId))
185           {
186             hiddenTypes.put(calcId, new ArrayList<List<String>>());
187           }
188           if (!hiddenTypes.get(calcId).contains(groupLabel))
189           {
190             hiddenTypes.get(calcId).add(groupLabel);
191           }
192         }
193       }
194     }
195   }
196
197   /**
198    * Returns a BitSet (possibly empty) of those graphGroups for line graph
199    * annotations, which have at least one member annotation row marked visible.
200    * <p/>
201    * Only one row in each visible group is marked visible, but when it is drawn,
202    * so are all the other rows in the same group.
203    * <p/>
204    * This lookup set allows us to check whether rows apparently marked not
205    * visible are in fact shown.
206    * 
207    * @see AnnotationRenderer#drawComponent
208    * @param annotations
209    * @return
210    */
211   public static BitSet getVisibleLineGraphGroups(
212           List<AlignmentAnnotation> annotations)
213   {
214     BitSet result = new BitSet();
215     for (AlignmentAnnotation ann : annotations)
216     {
217       if (ann.graph == AlignmentAnnotation.LINE_GRAPH && ann.visible)
218       {
219         int gg = ann.graphGroup;
220         if (gg > -1)
221         {
222           result.set(gg);
223         }
224       }
225     }
226     return result;
227   }
228
229   /**
230    * Converts an array of AlignmentAnnotation into a List of
231    * AlignmentAnnotation. A null array is converted to an empty list.
232    * 
233    * @param anns
234    * @return
235    */
236   public static List<AlignmentAnnotation> asList(AlignmentAnnotation[] anns)
237   {
238     // TODO use AlignmentAnnotationI instead when it exists
239     return (anns == null ? Collections.<AlignmentAnnotation> emptyList()
240             : Arrays.asList(anns));
241   }
242 }