Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
ContactGeometry	39	51	27	0.00%	Show methods
ContactGeometry.contactInterval	103	9	5	0.00%	Show methods

Class ContactGeometry

Class ContactGeometry	Line # 39	Total Statements 51	Complexity 27	TOTAL Coverage 0.00%
ContactGeometry(ContactListI,int)   ContactGeometry(ContactListI,int)	7878	9.09	3.03	0.0 0.00%
intersects(contactInterval,ColumnSelection,HiddenColumns,boolean) : boolean   intersects(contactInterval,ColumnSelection,HiddenColumns,boolean) : boolean	154154	14.014	9.09	0.0 0.00%
mapFor(int,int) : contactInterval   mapFor(int,int) : contactInterval	204204	10.010	5.05	0.0 0.00%
findStep(int) : contactInterval   findStep(int) : contactInterval	232232	3.03	3.03	0.0 0.00%
mapFor(int) : contactInterval   mapFor(int) : contactInterval	251251	4.04	2.02	0.0 0.00%
allSteps() : List<contactInterval>   allSteps() : List<contactInterval>	261261	10.010	4.04	0.0 0.00%
iterateOverContactIntervals(int) : Iterator<contactInterval>   iterateOverContactIntervals(int) : Iterator<contactInterval>	280280	1.01	1.01	0.0 0.00%

 

Class ContactGeometry.contactInterval

Class ContactGeometry.contactInterval	Line # 103	Total Statements 9	Complexity 5	TOTAL Coverage 0.00%
contactInterval(int,int,int,int)   contactInterval(int,int,int,int)	105105	4.04	1.01	0.0 0.00%
equals(Object) : boolean   equals(Object) : boolean	123123	4.04	3.03	0.0 0.00%
toString() : String   toString() : String	135135	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 java.util.Arrays;
24		import java.util.Iterator;
25		import java.util.List;
26
27		import jalview.datamodel.ColumnSelection;
28		import jalview.datamodel.ContactListI;
29		import jalview.datamodel.HiddenColumns;
30		import jalview.renderer.ContactGeometry.contactInterval;
31
32		/**
33		* encapsulate logic for mapping between positions in a ContactList and their
34		* rendered representation in a given number of pixels.
35		*
36		* @author jprocter
37		*
38		*/
		0% Uncovered Elements: 88 (88) Complexity: 27 Complexity Density: 0.53
39		public class ContactGeometry
40		{
41
42		final ContactListI contacts;
43
44		/**
45		* how many pixels per contact (1..many)
46		*/
47		final int pixels_step;
48
49		/**
50		* how many contacts per pixel (many > 0)
51		*/
52		final double contacts_per_pixel;
53
54		/**
55		* number of contacts being mapped
56		*/
57		final int contact_height;
58
59		/**
60		* number of pixels to map contact_height to
61		*/
62		final int graphHeight;
63
64		/**
65		* number of contacts for each pixel_step - to last whole contact
66		*/
67		final double contacts_step;
68
69		final int lastStep;
70
71		/**
72		* Bean used to map from a range of contacts to a range of pixels
73		*
74		* @param contacts
75		* @param graphHeight
76		* Number of pixels to map given range of contacts
77		*/
		0% Uncovered Elements: 13 (13) Complexity: 3 Complexity Density: 0.33
78	0	public ContactGeometry(final ContactListI contacts, int graphHeight)...
79		{
80	0	this.contacts = contacts;
81	0	this.graphHeight = graphHeight;
82	0	contact_height = contacts.getContactHeight();
83		// fractional number of contacts covering each pixel
84	0	contacts_per_pixel = (graphHeight <= 1) ? contact_height
85		: ((double) contact_height) / ((double) graphHeight);
86
87	0	if (contacts_per_pixel >= 1)
88		{
89		// many contacts rendered per pixel
90	0	pixels_step = 1;
91		}
92		else
93		{
94		// pixel height for each contact
95	0	pixels_step = (int) Math
96		.ceil(((double) graphHeight) / (double) contact_height);
97		}
98	0	contacts_step = pixels_step * contacts_per_pixel;
99	0	lastStep = (int) Math.min((double) graphHeight,
100		((double) graphHeight) / ((double) pixels_step));
101		}
102
		0% Uncovered Elements: 14 (14) Complexity: 5 Complexity Density: 0.56
103		public class contactInterval
104		{
		0% Uncovered Elements: 4 (4) Complexity: 1 Complexity Density: 0.25
105	0	public contactInterval(int cStart, int cEnd, int pStart, int pEnd)...
106		{
107	0	this.cStart = cStart;
108	0	this.cEnd = cEnd;
109	0	this.pStart = pStart;
110	0	this.pEnd = pEnd;
111		}
112
113		// range on contact list
114		public final int cStart;
115
116		public final int cEnd;
117
118		// range in pixels
119		public final int pStart;
120
121		public final int pEnd;
122
		0% Uncovered Elements: 6 (6) Complexity: 3 Complexity Density: 0.75
123	0	@Override...
124		public boolean equals(Object obj)
125		{
126	0	if (obj == null || !(obj instanceof contactInterval))
127		{
128	0	return false;
129		}
130	0	contactInterval them = (contactInterval) obj;
131	0	return cStart == them.cStart && cEnd == them.cEnd && pEnd == them.pEnd
132		&& pStart == them.pStart;
133		}
134
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
135	0	@Override...
136		public String toString()
137		{
138	0	return "Contacts [" + cStart + "," + cEnd + "] : Pixels [" + pStart
139		+ "," + pEnd + "]";
140		}
141		}
142
143		/**
144		*
145		* @param columnSelection
146		* @param ci
147		* @param visibleOnly
148		* - when true, only test intersection of visible columns given
149		* matrix range
150		* @return true if the range on the matrix specified by ci intersects with
151		* selected columns in the ContactListI's reference frame.
152		*/
153
		0% Uncovered Elements: 24 (24) Complexity: 9 Complexity Density: 0.64
154	0	boolean intersects(contactInterval ci, ColumnSelection columnSelection,...
155		HiddenColumns hiddenColumns, boolean visibleOnly)
156		{
157	0	boolean rowsel = false;
158	0	final int[] mappedRange = contacts.getMappedPositionsFor(ci.cStart,
159		ci.cEnd);
160	0	if (mappedRange == null)
161		{
162	0	return false;
163		}
164	0	for (int p = 0; p < mappedRange.length && !rowsel; p += 2)
165		{
166	0	boolean containsHidden = false;
167	0	if (visibleOnly && hiddenColumns != null
168		&& hiddenColumns.hasHiddenColumns())
169		{
170		// TODO: turn into function on hiddenColumns and create test !!
171	0	Iterator<int[]> viscont = hiddenColumns.getVisContigsIterator(
172		-1 + mappedRange[p], -1 + mappedRange[p + 1], false);
173	0	containsHidden = !viscont.hasNext();
174	0	if (!containsHidden)
175		{
176	0	for (int[] interval = viscont.next(); viscont
177		.hasNext(); rowsel |= columnSelection
178		.intersects(interval[p], interval[p + 1]))
179	0	;
180		}
181		}
182		else
183		{
184	0	rowsel = columnSelection.intersects(-1 + mappedRange[p],
185		-1 + mappedRange[p + 1]);
186		}
187		}
188	0	return rowsel;
189
190		}
191
192		/**
193		* Return mapped cell intersecting pStart \
194		*
195		* FIXME: REDUNDANT METHOD - COULD DELETE FIXME: OR RE-IMPLEMENT AS EFFICIENT
196		* RANGE QUERY
197		*
198		* @param pStart
199		* [0..)
200		* @param pEnd
201		* @return nearest full cell containing pStart - does not set
202		* contactInterval.pEnd or cEnd to equivalent position on pEnd !
203		*/
		0% Uncovered Elements: 18 (18) Complexity: 5 Complexity Density: 0.5
204	0	public contactInterval mapFor(int pStart, int pEnd)...
205		{
206	0	if (pStart < 0)
207		{
208	0	pStart = 0;
209		}
210	0	if (pEnd < pStart)
211		{
212	0	pEnd = pStart;
213		}
214	0	if (pEnd >= graphHeight)
215		{
216	0	pEnd = graphHeight - 1;
217		}
218	0	if (pStart >= graphHeight)
219		{
220	0	pStart = graphHeight - pixels_step;
221		}
222	0	int step = Math.floorDiv(pStart, pixels_step);
223	0	return findStep(step);
224		}
225
226		/**
227		*
228		* @param step
229		* [0..) n steps covering height and contactHeight
230		* @return contactInterval for step, or null if out of bounds
231		*/
		0% Uncovered Elements: 5 (5) Complexity: 3 Complexity Density: 1
232	0	contactInterval findStep(int step)...
233		{
234	0	if (step < 0 || step > lastStep)
235		{
236	0	return null;
237		}
238	0	return new contactInterval((int) Math.floor(contacts_step * step),
239		-1 + (int) Math.min(contact_height,
240		Math.floor(contacts_step * (step + 1))),
241		pixels_step * step,
242		Math.min(graphHeight, (step + 1) * pixels_step) - 1);
243		}
244
245		/**
246		* return the cell containing given pixel
247		*
248		* @param pCentre
249		* @return range for pCEntre
250		*/
		0% Uncovered Elements: 6 (6) Complexity: 2 Complexity Density: 0.5
251	0	public contactInterval mapFor(int pCentre)...
252		{
253	0	if (pCentre >= graphHeight + pixels_step)
254		{
255	0	return null;
256		}
257	0	int step = Math.floorDiv(pCentre, pixels_step);
258	0	return findStep(step);
259		}
260
		0% Uncovered Elements: 14 (14) Complexity: 4 Complexity Density: 0.4
261	0	public List<contactInterval> allSteps()...
262		{
263	0	contactInterval[] array = new contactInterval[lastStep + 1];
264	0	int csum = 0, psum = 0;
265	0	for (int i = 0; i <= lastStep; i++)
266		{
267	0	array[i] = findStep(i);
268	0	csum += 1 + array[i].cEnd - array[i].cStart;
269	0	psum += 1 + array[i].pEnd - array[i].pStart;
270		}
271	0	if (csum != contact_height || psum != graphHeight)
272		{
273	0	System.err.println("csum = " + csum + " not " + contact_height + "\n"
274		+ "psum = " + psum + " not " + graphHeight);
275	0	return null;
276		}
277	0	return Arrays.asList(array);
278		}
279
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
280	0	public Iterator<contactInterval> iterateOverContactIntervals(...
281		int graphHeight)
282		{
283		// NOT YET IMPLEMENTED
284	0	return null;
285		// int cstart = 0, cend;
286		//
287		// for (int ht = y2,
288		// eht = y2 - graphHeight; ht >= eht; ht -= pixels_step)
289		// {
290		// cstart = (int) Math.floor(((double) y2 - ht) * contacts_per_pixel);
291		// cend = (int) Math.min(contact_height,
292		// Math.ceil(cstart + contacts_per_pixel * pixels_step));
293		//
294		// return new Iterator<contactIntervals>() {
295		//
296		// @Override
297		// public boolean hasNext()
298		// {
299		// // TODO Auto-generated method stub
300		// return false;
301		// }
302		//
303		// @Override
304		// public contactIntervals next()
305		// {
306		// // TODO Auto-generated method stub
307		// return null;
308		// }
309		//
310		// }
311		}
312		}