Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
OverviewRenderer	42	116	32	0.00%	Show methods

Class OverviewRenderer

Class OverviewRenderer	Line # 42	Total Statements 116	Complexity 32	TOTAL Coverage 0.00%
OverviewRenderer(FeatureRenderer,OverviewDimensions,AlignmentI,ResidueShaderI,OverviewResColourFinder)   OverviewRenderer(FeatureRenderer,OverviewDimensions,AlignmentI,ResidueShaderI,OverviewResColourFinder)	7878	8.08	1.01	0.0 0.00%
draw(AlignmentRowsCollectionI,AlignmentColsCollectionI) : BufferedImage   draw(AlignmentRowsCollectionI,AlignmentColsCollectionI) : BufferedImage	104104	38.038	8.08	0.0 0.00%
sendProgressUpdate(int,int,int,int) : int   sendProgressUpdate(int,int,int,int) : int	203203	5.05	2.02	0.0 0.00%
getColumnColourFromSequence(SequenceGroup[],SequenceI,int) : int   getColumnColourFromSequence(SequenceGroup[],SequenceI,int) : int	225225	4.04	3.03	0.0 0.00%
overlayHiddenRegions(AlignmentRowsCollectionI,AlignmentColsCollectionI) : void   overlayHiddenRegions(AlignmentRowsCollectionI,AlignmentColsCollectionI) : void	247247	5.05	3.03	0.0 0.00%
buildHiddenImage(AlignmentRowsCollectionI,AlignmentColsCollectionI,int,int) : BufferedImage   buildHiddenImage(AlignmentRowsCollectionI,AlignmentColsCollectionI,int,int) : BufferedImage	276276	28.028	6.06	0.0 0.00%
drawGraph(Graphics,AlignmentAnnotation,int,AlignmentColsCollectionI) : void   drawGraph(Graphics,AlignmentAnnotation,int,AlignmentColsCollectionI) : void	361361	24.024	6.06	0.0 0.00%
setRedraw(boolean) : void   setRedraw(boolean) : void	424424	2.02	1.01	0.0 0.00%
addPropertyChangeListener(RendererListenerI) : void   addPropertyChangeListener(RendererListenerI) : void	432432	1.01	1.01	0.0 0.00%
removePropertyChangeListener(RendererListenerI) : void   removePropertyChangeListener(RendererListenerI) : void	437437	1.01	1.01	0.0 0.00%

 

Contributing tests

Source view

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.renderer;
22
23		import jalview.api.AlignmentColsCollectionI;
24		import jalview.api.AlignmentRowsCollectionI;
25		import jalview.api.RendererListenerI;
26		import jalview.datamodel.AlignmentAnnotation;
27		import jalview.datamodel.AlignmentI;
28		import jalview.datamodel.Annotation;
29		import jalview.datamodel.SequenceGroup;
30		import jalview.datamodel.SequenceI;
31		import jalview.renderer.seqfeatures.FeatureColourFinder;
32		import jalview.renderer.seqfeatures.FeatureRenderer;
33		import jalview.viewmodel.OverviewDimensions;
34
35		import java.awt.AlphaComposite;
36		import java.awt.Color;
37		import java.awt.Graphics;
38		import java.awt.Graphics2D;
39		import java.awt.image.BufferedImage;
40		import java.beans.PropertyChangeSupport;
41
		0% Uncovered Elements: 166 (166) Complexity: 32 Complexity Density: 0.28
42		public class OverviewRenderer
43		{
44		// transparency of hidden cols/seqs overlay
45		private final float TRANSPARENCY = 0.5f;
46
47		public static final String UPDATE = "OverviewUpdate";
48
49		private static final int MAX_PROGRESS = 100;
50
51		private PropertyChangeSupport changeSupport = new PropertyChangeSupport(
52		this);
53
54		private FeatureColourFinder finder;
55
56		// image to render on
57		private BufferedImage miniMe;
58
59		// raw number of pixels to allocate to each column
60		private float pixelsPerCol;
61
62		// raw number of pixels to allocate to each row
63		private float pixelsPerSeq;
64
65		// height in pixels of graph
66		private int graphHeight;
67
68		// flag to indicate whether to halt drawing
69		private volatile boolean redraw = false;
70
71		// reference to alignment, needed to get sequence groups
72		private AlignmentI al;
73
74		private ResidueShaderI shader;
75
76		private OverviewResColourFinder resColFinder;
77
		0% Uncovered Elements: 8 (8) Complexity: 1 Complexity Density: 0.12
78	0	public OverviewRenderer(FeatureRenderer fr, OverviewDimensions od,...
79		AlignmentI alignment, ResidueShaderI resshader,
80		OverviewResColourFinder colFinder)
81		{
82	0	finder = new FeatureColourFinder(fr);
83	0	resColFinder = colFinder;
84
85	0	al = alignment;
86	0	shader = resshader;
87
88	0	pixelsPerCol = od.getPixelsPerCol();
89	0	pixelsPerSeq = od.getPixelsPerSeq();
90	0	graphHeight = od.getGraphHeight();
91	0	miniMe = new BufferedImage(od.getWidth(), od.getHeight(),
92		BufferedImage.TYPE_INT_RGB);
93		}
94
95		/**
96		* Draw alignment rows and columns onto an image
97		*
98		* @param rit
99		* Iterator over rows to be drawn
100		* @param cit
101		* Iterator over columns to be drawn
102		* @return image containing the drawing
103		*/
		0% Uncovered Elements: 52 (52) Complexity: 8 Complexity Density: 0.21
104	0	public BufferedImage draw(AlignmentRowsCollectionI rows,...
105		AlignmentColsCollectionI cols)
106		{
107	0	int rgbcolor = Color.white.getRGB();
108	0	int seqIndex = 0;
109	0	int pixelRow = 0;
110	0	int alignmentHeight = miniMe.getHeight() - graphHeight;
111	0	int totalPixels = miniMe.getWidth() * alignmentHeight;
112
113	0	int lastRowUpdate = 0;
114	0	int lastUpdate = 0;
115	0	changeSupport.firePropertyChange(UPDATE, -1, 0);
116
117	0	for (int alignmentRow : rows)
118		{
119	0	if (redraw)
120		{
121	0	break;
122		}
123
124		// get details of this alignment row
125	0	SequenceI seq = rows.getSequence(alignmentRow);
126
127		// rate limiting step when rendering overview for lots of groups
128	0	SequenceGroup[] allGroups = al.findAllGroups(seq);
129
130		// calculate where this row extends to in pixels
131	0	int endRow = Math.min(Math.round((seqIndex + 1) * pixelsPerSeq) - 1,
132		miniMe.getHeight() - 1);
133
134	0	int colIndex = 0;
135	0	int pixelCol = 0;
136	0	for (int alignmentCol : cols)
137		{
138	0	if (redraw)
139		{
140	0	break;
141		}
142
143		// calculate where this column extends to in pixels
144	0	int endCol = Math.min(Math.round((colIndex + 1) * pixelsPerCol) - 1,
145		miniMe.getWidth() - 1);
146
147		// don't do expensive colour determination if we're not going to use it
148		// NB this is important to avoid performance issues in the overview
149		// panel
150	0	if (pixelCol <= endCol)
151		{
152	0	rgbcolor = getColumnColourFromSequence(allGroups, seq,
153		alignmentCol);
154
155		// fill in the appropriate number of pixels
156	0	for (int row = pixelRow; row <= endRow; ++row)
157		{
158	0	for (int col = pixelCol; col <= endCol; ++col)
159		{
160	0	miniMe.setRGB(col, row, rgbcolor);
161		}
162		}
163
164		// store last update value
165	0	lastUpdate = sendProgressUpdate(
166		(pixelCol + 1) * (endRow - pixelRow), totalPixels,
167		lastRowUpdate, lastUpdate);
168
169	0	pixelCol = endCol + 1;
170		}
171	0	colIndex++;
172		}
173
174	0	if (pixelRow != endRow + 1)
175		{
176		// store row offset and last update value
177	0	lastRowUpdate = sendProgressUpdate(endRow + 1, alignmentHeight, 0,
178		lastUpdate);
179	0	lastUpdate = lastRowUpdate;
180	0	pixelRow = endRow + 1;
181		}
182	0	seqIndex++;
183		}
184
185	0	overlayHiddenRegions(rows, cols);
186		// final update to progress bar if present
187	0	if (redraw)
188		{
189	0	sendProgressUpdate(pixelRow - 1, alignmentHeight, 0, 0);
190		}
191		else
192		{
193	0	sendProgressUpdate(alignmentHeight, miniMe.getHeight(), 0, 0);
194		}
195	0	return miniMe;
196		}
197
198		/*
199		* Calculate progress update value and fire event
200		* @param rowOffset number of rows to offset calculation by
201		* @return new rowOffset - return value only to be used when at end of a row
202		*/
		0% Uncovered Elements: 7 (7) Complexity: 2 Complexity Density: 0.4
203	0	private int sendProgressUpdate(int position, int maximum, int rowOffset,...
204		int lastUpdate)
205		{
206	0	int newUpdate = rowOffset
207		+ Math.round(MAX_PROGRESS * ((float) position / maximum));
208	0	if (newUpdate > lastUpdate)
209		{
210	0	changeSupport.firePropertyChange(UPDATE, rowOffset, newUpdate);
211	0	return newUpdate;
212		}
213	0	return newUpdate;
214		}
215
216		/*
217		* Find the RGB value of the colour of a sequence at a specified column position
218		*
219		* @param seq
220		* sequence to get colour for
221		* @param lastcol
222		* column position to get colour for
223		* @return colour of sequence at this position, as RGB
224		*/
		0% Uncovered Elements: 6 (6) Complexity: 3 Complexity Density: 0.75
225	0	int getColumnColourFromSequence(SequenceGroup[] allGroups, SequenceI seq,...
226		int lastcol)
227		{
228	0	Color color = resColFinder.gapColour;
229
230	0	if ((seq != null) && (seq.getLength() > lastcol))
231		{
232	0	color = resColFinder.getResidueColour(true, shader, allGroups, seq,
233		lastcol, finder);
234		}
235
236	0	return color.getRGB();
237		}
238
239		/**
240		* Overlay the hidden regions on the overview image
241		*
242		* @param rows
243		* collection of rows the overview is built over
244		* @param cols
245		* collection of columns the overview is built over
246		*/
		0% Uncovered Elements: 7 (7) Complexity: 3 Complexity Density: 0.6
247	0	private void overlayHiddenRegions(AlignmentRowsCollectionI rows,...
248		AlignmentColsCollectionI cols)
249		{
250	0	if (cols.hasHidden() || rows.hasHidden())
251		{
252	0	BufferedImage mask = buildHiddenImage(rows, cols, miniMe.getWidth(),
253		miniMe.getHeight());
254
255	0	Graphics2D g = (Graphics2D) miniMe.getGraphics();
256	0	g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
257		TRANSPARENCY));
258	0	g.drawImage(mask, 0, 0, miniMe.getWidth(), miniMe.getHeight(), null);
259		}
260		}
261
262		/**
263		* Build a masking image of hidden columns and rows to be applied on top of
264		* the main overview image.
265		*
266		* @param rows
267		* collection of rows the overview is built over
268		* @param cols
269		* collection of columns the overview is built over
270		* @param width
271		* width of overview in pixels
272		* @param height
273		* height of overview in pixels
274		* @return BufferedImage containing mask of hidden regions
275		*/
		0% Uncovered Elements: 38 (38) Complexity: 6 Complexity Density: 0.21
276	0	private BufferedImage buildHiddenImage(AlignmentRowsCollectionI rows,...
277		AlignmentColsCollectionI cols, int width, int height)
278		{
279		// new masking image
280	0	BufferedImage hiddenImage = new BufferedImage(width, height,
281		BufferedImage.TYPE_INT_ARGB);
282
283	0	int colIndex = 0;
284	0	int pixelCol = 0;
285
286	0	Color hidden = resColFinder.getHiddenColour();
287
288	0	Graphics2D g2d = (Graphics2D) hiddenImage.getGraphics();
289
290		// set background to transparent
291		// g2d.setComposite(AlphaComposite.Clear);
292		// g2d.fillRect(0, 0, width, height);
293
294		// set next colour to opaque
295	0	g2d.setComposite(AlphaComposite.Src);
296
297	0	for (int alignmentCol : cols)
298		{
299	0	if (redraw)
300		{
301	0	break;
302		}
303
304		// calculate where this column extends to in pixels
305	0	int endCol = Math.min(Math.round((colIndex + 1) * pixelsPerCol) - 1,
306		hiddenImage.getWidth() - 1);
307
308	0	if (pixelCol <= endCol)
309		{
310		// determine the colour based on the sequence and column position
311	0	if (cols.isHidden(alignmentCol))
312		{
313	0	g2d.setColor(hidden);
314	0	g2d.fillRect(pixelCol, 0, endCol - pixelCol + 1, height);
315		}
316
317	0	pixelCol = endCol + 1;
318		}
319	0	colIndex++;
320
321		}
322
323	0	int seqIndex = 0;
324	0	int pixelRow = 0;
325	0	for (int alignmentRow : rows)
326		{
327	0	if (redraw)
328		{
329	0	break;
330		}
331
332		// calculate where this row extends to in pixels
333	0	int endRow = Math.min(Math.round((seqIndex + 1) * pixelsPerSeq) - 1,
334		miniMe.getHeight() - 1);
335
336		// get details of this alignment row
337	0	if (rows.isHidden(alignmentRow))
338		{
339	0	g2d.setColor(hidden);
340	0	g2d.fillRect(0, pixelRow, width, endRow - pixelRow + 1);
341		}
342	0	pixelRow = endRow + 1;
343	0	seqIndex++;
344		}
345
346	0	return hiddenImage;
347		}
348
349		/**
350		* Draw the alignment annotation in the overview panel
351		*
352		* @param g
353		* the graphics object to draw on
354		* @param anno
355		* alignment annotation information
356		* @param y
357		* y-position for the annotation graph
358		* @param cols
359		* the collection of columns used in the overview panel
360		*/
		0% Uncovered Elements: 34 (34) Complexity: 6 Complexity Density: 0.25
361	0	public void drawGraph(Graphics g, AlignmentAnnotation anno, int y,...
362		AlignmentColsCollectionI cols)
363		{
364	0	Annotation[] annotations = anno.annotations;
365	0	g.setColor(Color.white);
366	0	g.fillRect(0, 0, miniMe.getWidth(), y);
367
368	0	int height;
369	0	int colIndex = 0;
370	0	int pixelCol = 0;
371	0	for (int alignmentCol : cols)
372		{
373	0	if (redraw)
374		{
375	0	changeSupport.firePropertyChange(UPDATE, MAX_PROGRESS - 1, 0);
376	0	break;
377		}
378
379	0	if (alignmentCol >= annotations.length)
380		{
381	0	break; // no more annotations to draw here
382		}
383		else
384		{
385	0	int endCol = Math.min(Math.round((colIndex + 1) * pixelsPerCol) - 1,
386		miniMe.getWidth() - 1);
387
388	0	if (annotations[alignmentCol] != null)
389		{
390	0	if (annotations[alignmentCol].colour == null)
391		{
392	0	g.setColor(Color.black);
393		}
394		else
395		{
396	0	g.setColor(annotations[alignmentCol].colour);
397		}
398
399	0	height = (int) ((annotations[alignmentCol].value / anno.graphMax)
400		* y);
401	0	if (height > y)
402		{
403	0	height = y;
404		}
405
406	0	g.fillRect(pixelCol, y - height, endCol - pixelCol + 1, height);
407		}
408
409	0	pixelCol = endCol + 1;
410	0	colIndex++;
411		}
412		}
413	0	changeSupport.firePropertyChange(UPDATE, MAX_PROGRESS - 1,
414		MAX_PROGRESS);
415		}
416
417		/**
418		* Allows redraw flag to be set
419		*
420		* @param b
421		* value to set redraw to: true = redraw is occurring, false = no
422		* redraw
423		*/
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
424	0	public void setRedraw(boolean b)...
425		{
426	0	synchronized (this)
427		{
428	0	redraw = b;
429		}
430		}
431
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
432	0	public void addPropertyChangeListener(RendererListenerI listener)...
433		{
434	0	changeSupport.addPropertyChangeListener(listener);
435		}
436
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
437	0	public void removePropertyChangeListener(RendererListenerI listener)...
438		{
439	0	changeSupport.removePropertyChangeListener(listener);
440		}
441		}