Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
ImageMaker	41	94	42	0.00%	Show methods
ImageMaker.TYPE	65	7	4	0.00%	Show methods

Class ImageMaker

Class ImageMaker	Line # 41	Total Statements 94	Complexity 42	TOTAL Coverage 0.00%
ImageMaker(TYPE,int,int,File,String,boolean,BitmapImageSizing)   ImageMaker(TYPE,int,int,File,String,boolean,BitmapImageSizing)	118118	13.013	4.04	0.0 0.00%
getGraphics() : Graphics   getGraphics() : Graphics	140140	1.01	1.01	0.0 0.00%
writeImage() : void   writeImage() : void	150150	18.018	5.05	0.0 0.00%
setupPNG(int,int,BitmapImageSizing) : void   setupPNG(int,int,BitmapImageSizing) : void	185185	12.012	4.04	0.0 0.00%
setupSVG(int,int,boolean) : void   setupSVG(int,int,boolean) : void	216216	4.04	2.02	0.0 0.00%
setupEPS(int,int,String,boolean) : void   setupEPS(int,int,String,boolean) : void	238238	5.05	1.01	0.0 0.00%
getScaleWidthHeight(int,int,float,int,int) : BitmapImageSizing   getScaleWidthHeight(int,int,float,int,int) : BitmapImageSizing	267267	22.022	14.014	0.0 0.00%
getScaleWidthHeight(int,int,BitmapImageSizing) : BitmapImageSizing   getScaleWidthHeight(int,int,BitmapImageSizing) : BitmapImageSizing	319319	1.01	1.01	0.0 0.00%
parseScaleWidthHeightStrings(String,String,String) : BitmapImageSizing   parseScaleWidthHeightStrings(String,String,String) : BitmapImageSizing	336336	18.018	10.010	0.0 0.00%

 

Class ImageMaker.TYPE

Class ImageMaker.TYPE	Line # 65	Total Statements 7	Complexity 4	TOTAL Coverage 0.00%
TYPE(String,String,String,String)   TYPE(String,String,String,String)	8181	4.04	1.01	0.0 0.00%
getName() : String   getName() : String	8989	1.01	1.01	0.0 0.00%
getFileChooser() : JalviewFileChooser   getFileChooser() : JalviewFileChooser	9494	1.01	1.01	0.0 0.00%
getLabel() : String   getLabel() : String	9999	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.util;
22
23		import java.awt.Graphics;
24		import java.awt.Graphics2D;
25		import java.awt.RenderingHints;
26		import java.awt.image.BufferedImage;
27		import java.io.File;
28		import java.io.FileOutputStream;
29		import java.io.IOException;
30
31		import javax.imageio.ImageIO;
32
33		import org.jfree.graphics2d.svg.SVGGraphics2D;
34		import org.jfree.graphics2d.svg.SVGHints;
35		import org.jibble.epsgraphics.EpsGraphics2D;
36
37		import jalview.bin.Console;
38		import jalview.io.JalviewFileChooser;
39		import jalview.util.imagemaker.BitmapImageSizing;
40
		0% Uncovered Elements: 129 (129) Complexity: 42 Complexity Density: 0.45
41		public class ImageMaker
42		{
43		public static final String SVG_DESCRIPTION = "Scalable Vector Graphics";
44
45		public static final String SVG_EXTENSION = "svg";
46
47		public static final String EPS_DESCRIPTION = "Encapsulated Postscript";
48
49		public static final String EPS_EXTENSION = "eps";
50
51		public static final String PNG_EXTENSION = "png";
52
53		public static final String PNG_DESCRIPTION = "Portable network graphics";
54
55		EpsGraphics2D pg;
56
57		Graphics graphics;
58
59		FileOutputStream out;
60
61		BufferedImage bi;
62
63		TYPE type;
64
		0% Uncovered Elements: 11 (11) Complexity: 4 Complexity Density: 0.57
65		public enum TYPE
66		{
67		EPS("EPS", MessageManager.getString("label.eps_file"), EPS_EXTENSION,
68		EPS_DESCRIPTION),
69		PNG("PNG", MessageManager.getString("label.png_image"), PNG_EXTENSION,
70		PNG_DESCRIPTION),
71		SVG("SVG", "SVG", SVG_EXTENSION, SVG_DESCRIPTION);
72
73		public final String name;
74
75		public final String label;
76
77		public final String extension;
78
79		public final String description;
80
		0% Uncovered Elements: 4 (4) Complexity: 1 Complexity Density: 0.25
81	0	TYPE(String name, String label, String ext, String desc)...
82		{
83	0	this.name = name;
84	0	this.label = label;
85	0	this.extension = ext;
86	0	this.description = desc;
87		}
88
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
89	0	public String getName()...
90		{
91	0	return name;
92		}
93
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
94	0	public JalviewFileChooser getFileChooser()...
95		{
96	0	return new JalviewFileChooser(extension, description);
97		}
98
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
99	0	public String getLabel()...
100		{
101	0	return label;
102		}
103
104		}
105
106		/**
107		* Constructor configures the graphics context ready for writing to
108		*
109		* @param imageType
110		* @param width
111		* @param height
112		* @param file
113		* @param fileTitle
114		* @param useLineart
115		* @param bitmapscale
116		* @throws IOException
117		*/
		0% Uncovered Elements: 13 (13) Complexity: 4 Complexity Density: 0.31
118	0	public ImageMaker(TYPE imageType, int width, int height, File file,...
119		String fileTitle, boolean useLineart, BitmapImageSizing userBis)
120		throws IOException
121		{
122	0	this.type = imageType;
123
124	0	out = new FileOutputStream(file);
125	0	switch (imageType)
126		{
127	0	case SVG:
128	0	setupSVG(width, height, useLineart);
129	0	break;
130	0	case EPS:
131	0	setupEPS(width, height, fileTitle, useLineart);
132	0	break;
133	0	case PNG:
134	0	setupPNG(width, height, userBis);
135	0	break;
136	0	default:
137		}
138		}
139
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
140	0	public Graphics getGraphics()...
141		{
142	0	return graphics;
143		}
144
145		/**
146		* For SVG or PNG, writes the generated graphics data to the file output
147		* stream. For EPS, flushes the output graphics (which is written to file as
148		* it is generated).
149		*/
		0% Uncovered Elements: 18 (18) Complexity: 5 Complexity Density: 0.28
150	0	public void writeImage()...
151		{
152	0	try
153		{
154	0	switch (type)
155		{
156	0	case EPS:
157	0	pg.flush();
158	0	pg.close();
159	0	break;
160	0	case SVG:
161	0	String svgData = ((SVGGraphics2D) getGraphics()).getSVGDocument();
162	0	out.write(svgData.getBytes());
163	0	out.flush();
164	0	out.close();
165	0	break;
166	0	case PNG:
167	0	ImageIO.write(bi, PNG_EXTENSION, out);
168	0	out.flush();
169	0	out.close();
170	0	break;
171		}
172		} catch (Exception ex)
173		{
174	0	ex.printStackTrace();
175		}
176		}
177
178		/**
179		* Sets up a graphics object for the PNG image to be written on
180		*
181		* @param width
182		* @param height
183		* @param scale
184		*/
		0% Uncovered Elements: 16 (16) Complexity: 4 Complexity Density: 0.33
185	0	protected void setupPNG(int width, int height, BitmapImageSizing userBis)...
186		{
187	0	if (width == 0 || height == 0)
188	0	return;
189
190	0	BitmapImageSizing bis = ImageMaker.getScaleWidthHeight(width, height,
191		userBis);
192	0	float usescale = bis.scale();
193	0	int usewidth = bis.width();
194	0	int useheight = bis.height();
195
196	0	bi = new BufferedImage(usewidth, useheight, BufferedImage.TYPE_INT_RGB);
197	0	graphics = bi.getGraphics();
198	0	Graphics2D ig2 = (Graphics2D) graphics;
199	0	ig2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
200		RenderingHints.VALUE_ANTIALIAS_ON);
201	0	if (usescale > 0.0f)
202		{
203	0	ig2.scale(usescale, usescale);
204		}
205		}
206
207		/**
208		* A helper method to configure the SVG output graphics, with choice of Text
209		* or Lineart character rendering
210		*
211		* @param width
212		* @param height
213		* @param useLineart
214		* true for Lineart character rendering, false for Text
215		*/
		0% Uncovered Elements: 6 (6) Complexity: 2 Complexity Density: 0.5
216	0	protected void setupSVG(int width, int height, boolean useLineart)...
217		{
218	0	SVGGraphics2D g2 = new SVGGraphics2D(width, height);
219	0	if (useLineart)
220		{
221	0	g2.setRenderingHint(SVGHints.KEY_DRAW_STRING_TYPE,
222		SVGHints.VALUE_DRAW_STRING_TYPE_VECTOR);
223		}
224	0	graphics = g2;
225		}
226
227		/**
228		* A helper method that sets up the EPS graphics output with user choice of
229		* Text or Lineart character rendering
230		*
231		* @param width
232		* @param height
233		* @param title
234		* @param useLineart
235		* true for Lineart character rendering, false for Text
236		* @throws IOException
237		*/
		0% Uncovered Elements: 5 (5) Complexity: 1 Complexity Density: 0.2
238	0	protected void setupEPS(int width, int height, String title,...
239		boolean useLineart) throws IOException
240		{
241	0	pg = new EpsGraphics2D(title, out, 0, 0, width, height);
242	0	Graphics2D ig2 = pg;
243	0	ig2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
244		RenderingHints.VALUE_ANTIALIAS_ON);
245	0	pg.setAccurateTextMode(useLineart);
246	0	graphics = pg;
247		}
248
249		/**
250		* Takes initial width and height, and suggested float scale, int width, int
251		* height and create a bounding box returned as a BitmapImageSizing object
252		* with consistent scale, width, height fields.
253		*
254		* @param width
255		* The unscaled image width
256		* @param height
257		* The unscaled image height
258		* @param scale
259		* The suggested scaling
260		* @param bitmapwidth
261		* The suggested width
262		* @param bitmapheight
263		* The suggested height
264		* @return BitmapImageSizing A consistent scale,width and height for the final
265		* image
266		*/
		0% Uncovered Elements: 34 (34) Complexity: 14 Complexity Density: 0.64
267	0	public static BitmapImageSizing getScaleWidthHeight(int width, int height,...
268		float scale, int bitmapwidth, int bitmapheight)
269		{
270	0	float usescale = 0.0f;
271	0	int usewidth = width;
272	0	int useheight = height;
273
274	0	if ((width == 0 && bitmapwidth > 0)
275		|| (height == 0 && bitmapheight > 0))
276		{
277		// original image is zero sized! Avoid dividing by zero!
278	0	return BitmapImageSizing.nullBitmapImageSizing();
279		}
280
281		// use the smallest positive scale (i.e. fit in the box)
282	0	if (scale > 0.0f)
283		{
284	0	usescale = scale;
285	0	usewidth = Math.round(scale * width);
286	0	useheight = Math.round(scale * height);
287		}
288	0	if (bitmapwidth > 0)
289		{
290	0	float wscale = (float) bitmapwidth / width;
291	0	if (wscale > 0.0f && (usescale == 0.0f || wscale < usescale))
292		{
293	0	usescale = wscale;
294	0	usewidth = bitmapwidth;
295	0	useheight = Math.round(usescale * height);
296		}
297		}
298	0	if (bitmapheight > 0)
299		{
300	0	float hscale = (float) bitmapheight / height;
301	0	if (hscale > 0.0f && (usescale == 0.0f || hscale < usescale))
302		{
303	0	usescale = hscale;
304	0	usewidth = Math.round(usescale * width);
305	0	useheight = bitmapheight;
306		}
307		}
308	0	return new BitmapImageSizing(usescale, usewidth, useheight, false);
309		}
310
311		/**
312		* Takes suggested scale, width, height as a BitmapImageSizing object and
313		* create a bounding box returned as a BitmapImageSizing object with
314		* consistent scale, width, height fields.
315		*
316		* @param bis
317		* @return BitmapImageSizing
318		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
319	0	public static BitmapImageSizing getScaleWidthHeight(int width, int height,...
320		BitmapImageSizing bis)
321		{
322	0	return ImageMaker.getScaleWidthHeight(width, height, bis.scale(),
323		bis.width(), bis.height());
324		}
325
326		/**
327		* Takes String versions of suggested float scale, int width, int height and
328		* create a bounding box returned as a BitmapImageSizing object with
329		* consistent scale, width, height fields.
330		*
331		* @param scaleS
332		* @param widthS
333		* @param heightS
334		* @return BitmapImageSizing
335		*/
		0% Uncovered Elements: 26 (26) Complexity: 10 Complexity Density: 0.56
336	0	public static BitmapImageSizing parseScaleWidthHeightStrings(...
337		String scaleS, String widthS, String heightS)
338		{
339	0	if (scaleS == null && widthS == null && heightS == null)
340		{
341		// if all items are null (i.e. not provided) we use the dynamic
342		// preferences set BIS
343	0	return BitmapImageSizing.defaultBitmapImageSizing();
344		}
345
346	0	float scale = 0.0f;
347	0	int width = 0;
348	0	int height = 0;
349
350	0	if (scaleS != null)
351		{
352	0	try
353		{
354	0	scale = Float.parseFloat(scaleS);
355		} catch (NumberFormatException e)
356		{
357	0	Console.warn("Did not understand scale '" + scaleS
358		+ "', won't be used.");
359		}
360		}
361	0	if (widthS != null)
362		{
363	0	try
364		{
365	0	width = Integer.parseInt(widthS);
366		} catch (NumberFormatException e)
367		{
368	0	Console.warn("Did not understand width '" + widthS
369		+ "', won't be used.");
370		}
371		}
372	0	if (heightS != null)
373		{
374	0	try
375		{
376	0	height = Integer.parseInt(heightS);
377		} catch (NumberFormatException e)
378		{
379	0	Console.warn("Did not understand height '" + heightS
380		+ "', won't be used.");
381		}
382		}
383
384	0	return new BitmapImageSizing(scale, width, height, false);
385		}
386		}