JAL-2788 possible adjustments to sequence accesses
[jalview.git] / src / jalview / workers / ColumnCounterSetWorker.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.workers;
22
23 import jalview.api.AlignViewportI;
24 import jalview.api.AlignmentViewPanel;
25 import jalview.datamodel.AlignmentAnnotation;
26 import jalview.datamodel.AlignmentI;
27 import jalview.datamodel.Annotation;
28 import jalview.datamodel.SequenceFeature;
29 import jalview.datamodel.SequenceI;
30 import jalview.renderer.seqfeatures.FeatureRenderer;
31 import jalview.util.ColorUtils;
32 import jalview.util.Comparison;
33
34 import java.awt.Color;
35 import java.util.ArrayList;
36 import java.util.List;
37
38 /**
39  * A class to compute alignment annotations with column counts for a set of
40  * properties of interest on positions in an alignment. <br>
41  * This is designed to be extensible, by supplying to the constructor an object
42  * that computes a vector of counts for each residue position, based on the
43  * residue and and sequence features at that position.
44  * 
45  */
46 class ColumnCounterSetWorker extends AlignCalcWorker
47 {
48   FeatureSetCounterI counter;
49
50   /**
51    * Constructor registers the annotation for the given alignment frame
52    * 
53    * @param af
54    * @param counter
55    */
56   public ColumnCounterSetWorker(AlignViewportI viewport,
57           AlignmentViewPanel panel, FeatureSetCounterI counter)
58   {
59     super(viewport, panel);
60     ourAnnots = new ArrayList<>();
61     this.counter = counter;
62     calcMan.registerWorker(this);
63   }
64
65   /**
66    * method called under control of AlignCalcManager to recompute the annotation
67    * when the alignment changes
68    */
69   @Override
70   public void run()
71   {
72     boolean annotationAdded = false;
73     try
74     {
75       calcMan.notifyStart(this);
76
77       while (!calcMan.notifyWorking(this))
78       {
79         try
80         {
81           Thread.sleep(200);
82         } catch (InterruptedException ex)
83         {
84           ex.printStackTrace();
85         }
86       }
87       if (alignViewport.isClosed())
88       {
89         abortAndDestroy();
90         return;
91       }
92
93       if (alignViewport.getAlignment() != null)
94       {
95         try
96         {
97           annotationAdded = computeAnnotations();
98         } catch (IndexOutOfBoundsException x)
99         {
100           // probable race condition. just finish and return without any fuss.
101           return;
102         }
103       }
104     } catch (OutOfMemoryError error)
105     {
106       ap.raiseOOMWarning("calculating feature counts", error);
107       calcMan.disableWorker(this);
108     } finally
109     {
110       calcMan.workerComplete(this);
111     }
112
113     if (ap != null)
114     {
115       if (annotationAdded)
116       {
117         ap.adjustAnnotationHeight();
118       }
119       ap.paintAlignment(true, true);
120     }
121
122   }
123
124   /**
125    * Scan each column of the alignment to calculate a count by feature type. Set
126    * the count as the value of the alignment annotation for that feature type.
127    * 
128    * @return
129    */
130   boolean computeAnnotations()
131   {
132     FeatureRenderer fr = new FeatureRenderer(alignViewport);
133     // TODO use the commented out code once JAL-2075 is fixed
134     // to get adequate performance on genomic length sequence
135     AlignmentI alignment = alignViewport.getAlignment();
136     // AlignmentView alignmentView = alignViewport.getAlignmentView(false);
137     // AlignmentI alignment = alignmentView.getVisibleAlignment(' ');
138
139     int rows = counter.getNames().length;
140
141     int width = alignment.getWidth();
142     int height = alignment.getHeight();
143     int[][] counts = new int[width][rows];
144     int max[] = new int[rows];
145     for (int crow = 0; crow < rows; crow++)
146     {
147       max[crow] = 0;
148     }
149
150     int[] minC = counter.getMinColour();
151     int[] maxC = counter.getMaxColour();
152     Color minColour = new Color(minC[0], minC[1], minC[2]);
153     Color maxColour = new Color(maxC[0], maxC[1], maxC[2]);
154
155     for (int col = 0; col < width; col++)
156     {
157       int[] count = counts[col];
158       for (int crow = 0; crow < rows; crow++)
159       {
160         count[crow] = 0;
161       }
162       for (int row = 0; row < height; row++)
163       {
164         int[] colcount = countFeaturesAt(alignment, col, row, fr);
165         if (colcount != null)
166         {
167           for (int crow = 0; crow < rows; crow++)
168           {
169             count[crow] += colcount[crow];
170           }
171         }
172       }
173       counts[col] = count;
174       for (int crow = 0; crow < rows; crow++)
175       {
176         max[crow] = Math.max(count[crow], max[crow]);
177       }
178     }
179
180     boolean annotationAdded = false;
181
182     for (int anrow = 0; anrow < rows; anrow++)
183     {
184       Annotation[] anns = new Annotation[width];
185       long rmax = 0;
186       /*
187        * add counts as annotations. zeros are needed since select-by-annotation ignores empty annotation positions
188        */
189       for (int i = 0; i < counts.length; i++)
190       {
191         int count = counts[i][anrow];
192
193         Color color = ColorUtils.getGraduatedColour(count, 0, minColour,
194                 max[anrow], maxColour);
195         String str = String.valueOf(count);
196         anns[i] = new Annotation(str, str, '0', count, color);
197         rmax = Math.max(count, rmax);
198       }
199
200       /*
201        * construct or update the annotation
202        */
203       String description = counter.getDescriptions()[anrow];
204       if (!alignment.findAnnotation(description).iterator().hasNext())
205       {
206         annotationAdded = true;
207       }
208       AlignmentAnnotation ann = alignment.findOrCreateAnnotation(
209               counter.getNames()[anrow], description, false, null, null);
210       ann.description = description;
211       ann.showAllColLabels = true;
212       ann.scaleColLabel = true;
213       ann.graph = AlignmentAnnotation.BAR_GRAPH;
214       ann.annotations = anns;
215       ann.graphMin = 0f; // minimum always zero count
216       ann.graphMax = rmax; // maximum count from loop over feature columns
217       ann.validateRangeAndDisplay();
218       if (!ourAnnots.contains(ann))
219       {
220         ourAnnots.add(ann);
221       }
222     }
223     return annotationAdded;
224   }
225
226   /**
227    * Returns a count of any feature types present at the specified position of
228    * the alignment
229    * 
230    * @param alignment
231    * @param col
232    *          (0..)
233    * @param row
234    * @param fr
235    */
236   int[] countFeaturesAt(AlignmentI alignment, int col, int row,
237           FeatureRenderer fr)
238   {
239     SequenceI seq = alignment.getSequenceAt(row);
240     if (seq == null)
241     {
242       return null;
243     }
244     if (col >= seq.getLength())
245     {
246       return null;// sequence doesn't extend this far
247     }
248     char res = seq.getCharAt(col);
249     if (Comparison.isGap(res))
250     {
251       return null;
252     }
253
254     /*
255      * compute a count for any displayed features at residue
256      */
257     // see JAL-2075
258     List<SequenceFeature> features = fr.findFeaturesAtColumn(seq, col + 1);
259     int[] count = this.counter.count(String.valueOf(res), features);
260     return count;
261   }
262
263   /**
264    * Method called when the user changes display options that may affect how the
265    * annotation is rendered, but do not change its values. Currently no such
266    * options affect user-defined annotation, so this method does nothing.
267    */
268   @Override
269   public void updateAnnotation()
270   {
271     // do nothing
272   }
273
274   /**
275    * Answers true to indicate that if this worker's annotation is deleted from
276    * the display, the worker should also be removed. This prevents it running
277    * and recreating the annotation when the alignment changes.
278    */
279   @Override
280   public boolean isDeletable()
281   {
282     return true;
283   }
284 }