1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
|
|
19 |
|
|
20 |
|
|
21 |
|
package jalview.schemes; |
22 |
|
|
23 |
|
import jalview.api.FeatureColourI; |
24 |
|
import jalview.datamodel.SequenceFeature; |
25 |
|
import jalview.datamodel.features.FeatureMatcher; |
26 |
|
import jalview.util.ColorUtils; |
27 |
|
import jalview.util.Format; |
28 |
|
import jalview.util.MessageManager; |
29 |
|
|
30 |
|
import java.awt.Color; |
31 |
|
import java.util.StringTokenizer; |
32 |
|
|
33 |
|
|
34 |
|
|
35 |
|
|
36 |
|
|
37 |
|
|
38 |
|
|
39 |
|
|
40 |
|
|
41 |
|
|
42 |
|
|
43 |
|
|
44 |
|
|
45 |
|
|
46 |
|
|
47 |
|
|
48 |
|
|
49 |
|
|
50 |
|
|
51 |
|
|
|
|
| 88.7% |
Uncovered Elements: 52 (462) |
Complexity: 119 |
Complexity Density: 0.43 |
|
52 |
|
public class FeatureColour implements FeatureColourI |
53 |
|
{ |
54 |
|
private static final String I18N_LABEL = MessageManager |
55 |
|
.getString("label.label"); |
56 |
|
|
57 |
|
private static final String I18N_SCORE = MessageManager |
58 |
|
.getString("label.score"); |
59 |
|
|
60 |
|
private static final String ABSOLUTE = "abso"; |
61 |
|
|
62 |
|
private static final String ABOVE = "above"; |
63 |
|
|
64 |
|
private static final String BELOW = "below"; |
65 |
|
|
66 |
|
|
67 |
|
|
68 |
|
|
69 |
|
private static final String LABEL = "label"; |
70 |
|
|
71 |
|
private static final String SCORE = "score"; |
72 |
|
|
73 |
|
private static final String ATTRIBUTE = "attribute"; |
74 |
|
|
75 |
|
private static final String NO_VALUE_MIN = "noValueMin"; |
76 |
|
|
77 |
|
private static final String NO_VALUE_MAX = "noValueMax"; |
78 |
|
|
79 |
|
private static final String NO_VALUE_NONE = "noValueNone"; |
80 |
|
|
81 |
|
static final Color DEFAULT_NO_COLOUR = null; |
82 |
|
|
83 |
|
private static final String BAR = "|"; |
84 |
|
|
85 |
|
final private Color colour; |
86 |
|
|
87 |
|
final private Color minColour; |
88 |
|
|
89 |
|
final private Color maxColour; |
90 |
|
|
91 |
|
|
92 |
|
|
93 |
|
|
94 |
|
|
95 |
|
final private Color noColour; |
96 |
|
|
97 |
|
|
98 |
|
|
99 |
|
|
100 |
|
|
101 |
|
private boolean graduatedColour; |
102 |
|
|
103 |
|
|
104 |
|
|
105 |
|
|
106 |
|
|
107 |
|
private boolean colourByLabel; |
108 |
|
|
109 |
|
|
110 |
|
|
111 |
|
|
112 |
|
|
113 |
|
private String[] attributeName; |
114 |
|
|
115 |
|
private float threshold; |
116 |
|
|
117 |
|
private float base; |
118 |
|
|
119 |
|
private float range; |
120 |
|
|
121 |
|
private boolean belowThreshold; |
122 |
|
|
123 |
|
private boolean aboveThreshold; |
124 |
|
|
125 |
|
private boolean isHighToLow; |
126 |
|
|
127 |
|
private boolean autoScaled; |
128 |
|
|
129 |
|
final private float minRed; |
130 |
|
|
131 |
|
final private float minGreen; |
132 |
|
|
133 |
|
final private float minBlue; |
134 |
|
|
135 |
|
final private float deltaRed; |
136 |
|
|
137 |
|
final private float deltaGreen; |
138 |
|
|
139 |
|
final private float deltaBlue; |
140 |
|
|
141 |
|
|
142 |
|
|
143 |
|
|
144 |
|
|
145 |
|
|
146 |
|
|
147 |
|
|
148 |
|
|
149 |
|
|
150 |
|
|
151 |
|
|
152 |
|
|
153 |
|
|
154 |
|
|
155 |
|
|
156 |
|
|
157 |
|
|
158 |
|
|
159 |
|
|
160 |
|
|
161 |
|
|
162 |
|
|
163 |
|
|
164 |
|
|
165 |
|
|
166 |
|
|
167 |
|
|
168 |
|
|
169 |
|
|
170 |
|
@param |
171 |
|
@return |
172 |
|
@throws |
173 |
|
|
174 |
|
|
|
|
| 77.6% |
Uncovered Elements: 41 (183) |
Complexity: 42 |
Complexity Density: 0.38 |
|
175 |
46 |
public static FeatureColourI parseJalviewFeatureColour(String descriptor)... |
176 |
|
{ |
177 |
46 |
StringTokenizer gcol = new StringTokenizer(descriptor, BAR, true); |
178 |
46 |
float min = Float.MIN_VALUE; |
179 |
46 |
float max = Float.MAX_VALUE; |
180 |
46 |
boolean byLabel = false; |
181 |
46 |
boolean byAttribute = false; |
182 |
46 |
String attName = null; |
183 |
46 |
String mincol = null; |
184 |
46 |
String maxcol = null; |
185 |
|
|
186 |
|
|
187 |
|
|
188 |
|
|
189 |
|
|
190 |
46 |
String nextToken = gcol.nextToken(); |
191 |
46 |
if (nextToken == BAR) |
192 |
|
{ |
193 |
0 |
throw new IllegalArgumentException( |
194 |
|
"Expected either 'label' or a colour specification in the line: " |
195 |
|
+ descriptor); |
196 |
|
} |
197 |
46 |
if (nextToken.toLowerCase().startsWith(LABEL)) |
198 |
|
{ |
199 |
2 |
byLabel = true; |
200 |
|
|
201 |
2 |
mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null); |
202 |
2 |
mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null); |
203 |
|
} |
204 |
44 |
else if (nextToken.toLowerCase().startsWith(SCORE)) |
205 |
|
{ |
206 |
1 |
mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null); |
207 |
1 |
mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null); |
208 |
|
} |
209 |
43 |
else if (nextToken.toLowerCase().startsWith(ATTRIBUTE)) |
210 |
|
{ |
211 |
4 |
byAttribute = true; |
212 |
4 |
attName = (gcol.hasMoreTokens() ? gcol.nextToken() : null); |
213 |
4 |
attName = (gcol.hasMoreTokens() ? gcol.nextToken() : null); |
214 |
4 |
mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null); |
215 |
4 |
mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null); |
216 |
|
} |
217 |
|
else |
218 |
|
{ |
219 |
39 |
mincol = nextToken; |
220 |
|
} |
221 |
|
|
222 |
|
|
223 |
|
|
224 |
|
|
225 |
|
|
226 |
46 |
if (!gcol.hasMoreTokens()) |
227 |
|
{ |
228 |
35 |
if (byLabel || byAttribute) |
229 |
|
{ |
230 |
2 |
FeatureColourI fc = new FeatureColour(); |
231 |
2 |
fc.setColourByLabel(true); |
232 |
2 |
if (byAttribute) |
233 |
|
{ |
234 |
1 |
fc.setAttributeName( |
235 |
|
FeatureMatcher.fromAttributeDisplayName(attName)); |
236 |
|
} |
237 |
2 |
return fc; |
238 |
|
} |
239 |
|
|
240 |
33 |
Color colour = ColorUtils.parseColourString(descriptor); |
241 |
33 |
if (colour == null) |
242 |
|
{ |
243 |
1 |
throw new IllegalArgumentException( |
244 |
|
"Invalid colour descriptor: " + descriptor); |
245 |
|
} |
246 |
32 |
return new FeatureColour(colour); |
247 |
|
} |
248 |
|
|
249 |
|
|
250 |
|
|
251 |
|
|
252 |
|
|
253 |
|
|
254 |
|
|
255 |
|
|
256 |
|
|
257 |
|
|
258 |
11 |
boolean autoScaled = true; |
259 |
11 |
String tok = null, minval, maxval; |
260 |
11 |
String noValueColour = NO_VALUE_MIN; |
261 |
|
|
262 |
11 |
if (mincol != null) |
263 |
|
{ |
264 |
|
|
265 |
11 |
if (mincol.equals(BAR)) |
266 |
|
{ |
267 |
2 |
mincol = null; |
268 |
|
} |
269 |
|
else |
270 |
|
{ |
271 |
9 |
gcol.nextToken(); |
272 |
|
} |
273 |
11 |
maxcol = gcol.nextToken(); |
274 |
11 |
if (maxcol.equals(BAR)) |
275 |
|
{ |
276 |
2 |
maxcol = null; |
277 |
|
} |
278 |
|
else |
279 |
|
{ |
280 |
9 |
gcol.nextToken(); |
281 |
|
} |
282 |
11 |
tok = gcol.nextToken(); |
283 |
|
|
284 |
|
|
285 |
|
|
286 |
|
|
287 |
|
|
288 |
11 |
if (tok.equalsIgnoreCase(NO_VALUE_MIN)) |
289 |
|
{ |
290 |
0 |
tok = gcol.nextToken(); |
291 |
0 |
tok = gcol.nextToken(); |
292 |
|
} |
293 |
11 |
else if (tok.equalsIgnoreCase(NO_VALUE_MAX)) |
294 |
|
{ |
295 |
0 |
noValueColour = NO_VALUE_MAX; |
296 |
0 |
tok = gcol.nextToken(); |
297 |
0 |
tok = gcol.nextToken(); |
298 |
|
} |
299 |
11 |
else if (tok.equalsIgnoreCase(NO_VALUE_NONE)) |
300 |
|
{ |
301 |
0 |
noValueColour = NO_VALUE_NONE; |
302 |
0 |
tok = gcol.nextToken(); |
303 |
0 |
tok = gcol.nextToken(); |
304 |
|
} |
305 |
|
|
306 |
11 |
gcol.nextToken(); |
307 |
11 |
if (tok.toLowerCase().startsWith(ABSOLUTE)) |
308 |
|
{ |
309 |
2 |
minval = gcol.nextToken(); |
310 |
2 |
gcol.nextToken(); |
311 |
2 |
autoScaled = false; |
312 |
|
} |
313 |
|
else |
314 |
|
{ |
315 |
9 |
minval = tok; |
316 |
|
} |
317 |
11 |
maxval = gcol.nextToken(); |
318 |
11 |
if (gcol.hasMoreTokens()) |
319 |
|
{ |
320 |
8 |
gcol.nextToken(); |
321 |
|
} |
322 |
11 |
try |
323 |
|
{ |
324 |
11 |
if (minval.length() > 0) |
325 |
|
{ |
326 |
11 |
min = new Float(minval).floatValue(); |
327 |
|
} |
328 |
|
} catch (Exception e) |
329 |
|
{ |
330 |
0 |
throw new IllegalArgumentException( |
331 |
|
"Couldn't parse the minimum value for graduated colour (" |
332 |
|
+ descriptor + ")"); |
333 |
|
} |
334 |
11 |
try |
335 |
|
{ |
336 |
11 |
if (maxval.length() > 0) |
337 |
|
{ |
338 |
11 |
max = new Float(maxval).floatValue(); |
339 |
|
} |
340 |
|
} catch (Exception e) |
341 |
|
{ |
342 |
0 |
throw new IllegalArgumentException( |
343 |
|
"Couldn't parse the maximum value for graduated colour (" |
344 |
|
+ descriptor + ")"); |
345 |
|
} |
346 |
|
} |
347 |
|
else |
348 |
|
{ |
349 |
|
|
350 |
|
|
351 |
|
|
352 |
|
|
353 |
0 |
mincol = "white"; |
354 |
0 |
maxcol = "black"; |
355 |
0 |
byLabel = true; |
356 |
|
} |
357 |
|
|
358 |
|
|
359 |
|
|
360 |
|
|
361 |
11 |
FeatureColour featureColour; |
362 |
11 |
try |
363 |
|
{ |
364 |
11 |
Color minColour = ColorUtils.parseColourString(mincol); |
365 |
11 |
Color maxColour = ColorUtils.parseColourString(maxcol); |
366 |
11 |
Color noColour = noValueColour.equals(NO_VALUE_MAX) ? maxColour |
367 |
11 |
: (noValueColour.equals(NO_VALUE_NONE) ? null : minColour); |
368 |
11 |
featureColour = new FeatureColour(minColour, maxColour, noColour, min, |
369 |
|
max); |
370 |
11 |
featureColour.setColourByLabel(minColour == null); |
371 |
11 |
featureColour.setAutoScaled(autoScaled); |
372 |
11 |
if (byAttribute) |
373 |
|
{ |
374 |
3 |
featureColour.setAttributeName( |
375 |
|
FeatureMatcher.fromAttributeDisplayName(attName)); |
376 |
|
} |
377 |
|
|
378 |
11 |
String ttype = null, tval = null; |
379 |
11 |
if (gcol.hasMoreTokens()) |
380 |
|
{ |
381 |
|
|
382 |
8 |
ttype = gcol.nextToken(); |
383 |
8 |
if (ttype.toLowerCase().startsWith(BELOW)) |
384 |
|
{ |
385 |
4 |
featureColour.setBelowThreshold(true); |
386 |
|
} |
387 |
4 |
else if (ttype.toLowerCase().startsWith(ABOVE)) |
388 |
|
{ |
389 |
4 |
featureColour.setAboveThreshold(true); |
390 |
|
} |
391 |
|
else |
392 |
|
{ |
393 |
0 |
if (!ttype.toLowerCase().startsWith("no")) |
394 |
|
{ |
395 |
0 |
System.err.println( |
396 |
|
"Ignoring unrecognised threshold type : " + ttype); |
397 |
|
} |
398 |
|
} |
399 |
|
} |
400 |
11 |
if (featureColour.hasThreshold()) |
401 |
|
{ |
402 |
8 |
try |
403 |
|
{ |
404 |
8 |
gcol.nextToken(); |
405 |
8 |
tval = gcol.nextToken(); |
406 |
8 |
featureColour.setThreshold(new Float(tval).floatValue()); |
407 |
|
} catch (Exception e) |
408 |
|
{ |
409 |
0 |
System.err.println("Couldn't parse threshold value as a float: (" |
410 |
|
+ tval + ")"); |
411 |
|
} |
412 |
|
} |
413 |
11 |
if (gcol.hasMoreTokens()) |
414 |
|
{ |
415 |
0 |
System.err.println( |
416 |
|
"Ignoring additional tokens in parameters in graduated colour specification\n"); |
417 |
0 |
while (gcol.hasMoreTokens()) |
418 |
|
{ |
419 |
0 |
System.err.println(BAR + gcol.nextToken()); |
420 |
|
} |
421 |
0 |
System.err.println("\n"); |
422 |
|
} |
423 |
11 |
return featureColour; |
424 |
|
} catch (Exception e) |
425 |
|
{ |
426 |
0 |
throw new IllegalArgumentException(e.getMessage()); |
427 |
|
} |
428 |
|
} |
429 |
|
|
430 |
|
|
431 |
|
|
432 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
433 |
19 |
public FeatureColour()... |
434 |
|
{ |
435 |
19 |
this((Color) null); |
436 |
|
} |
437 |
|
|
438 |
|
|
439 |
|
|
440 |
|
|
441 |
|
@param |
442 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (10) |
Complexity: 1 |
Complexity Density: 0.1 |
|
443 |
1347 |
public FeatureColour(Color c)... |
444 |
|
{ |
445 |
1347 |
minColour = Color.WHITE; |
446 |
1347 |
maxColour = Color.BLACK; |
447 |
1347 |
noColour = DEFAULT_NO_COLOUR; |
448 |
1347 |
minRed = 0f; |
449 |
1347 |
minGreen = 0f; |
450 |
1347 |
minBlue = 0f; |
451 |
1347 |
deltaRed = 0f; |
452 |
1347 |
deltaGreen = 0f; |
453 |
1347 |
deltaBlue = 0f; |
454 |
1347 |
colour = c; |
455 |
|
} |
456 |
|
|
457 |
|
|
458 |
|
|
459 |
|
|
460 |
|
|
461 |
|
@param |
462 |
|
@param |
463 |
|
@param |
464 |
|
@param |
465 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
466 |
19 |
public FeatureColour(Color low, Color high, float min, float max)... |
467 |
|
{ |
468 |
19 |
this(low, high, low, min, max); |
469 |
|
} |
470 |
|
|
471 |
|
|
472 |
|
|
473 |
|
|
474 |
|
@param |
475 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (20) |
Complexity: 1 |
Complexity Density: 0.05 |
|
476 |
11 |
public FeatureColour(FeatureColour fc)... |
477 |
|
{ |
478 |
11 |
graduatedColour = fc.graduatedColour; |
479 |
11 |
colour = fc.colour; |
480 |
11 |
minColour = fc.minColour; |
481 |
11 |
maxColour = fc.maxColour; |
482 |
11 |
noColour = fc.noColour; |
483 |
11 |
minRed = fc.minRed; |
484 |
11 |
minGreen = fc.minGreen; |
485 |
11 |
minBlue = fc.minBlue; |
486 |
11 |
deltaRed = fc.deltaRed; |
487 |
11 |
deltaGreen = fc.deltaGreen; |
488 |
11 |
deltaBlue = fc.deltaBlue; |
489 |
11 |
base = fc.base; |
490 |
11 |
range = fc.range; |
491 |
11 |
isHighToLow = fc.isHighToLow; |
492 |
11 |
attributeName = fc.attributeName; |
493 |
11 |
setAboveThreshold(fc.isAboveThreshold()); |
494 |
11 |
setBelowThreshold(fc.isBelowThreshold()); |
495 |
11 |
setThreshold(fc.getThreshold()); |
496 |
11 |
setAutoScaled(fc.isAutoScaled()); |
497 |
11 |
setColourByLabel(fc.isColourByLabel()); |
498 |
|
} |
499 |
|
|
500 |
|
|
501 |
|
|
502 |
|
|
503 |
|
@param |
504 |
|
@param |
505 |
|
@param |
506 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
507 |
5 |
public FeatureColour(FeatureColour fc, float min, float max)... |
508 |
|
{ |
509 |
5 |
this(fc); |
510 |
5 |
updateBounds(min, max); |
511 |
|
} |
512 |
|
|
513 |
|
|
514 |
|
|
515 |
|
|
516 |
|
@param |
517 |
|
@param |
518 |
|
@param |
519 |
|
@param |
520 |
|
@param |
521 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (28) |
Complexity: 4 |
Complexity Density: 0.18 |
|
522 |
47 |
public FeatureColour(Color low, Color high, Color noValueColour,... |
523 |
|
float min, float max) |
524 |
|
{ |
525 |
47 |
if (low == null) |
526 |
|
{ |
527 |
2 |
low = Color.white; |
528 |
|
} |
529 |
47 |
if (high == null) |
530 |
|
{ |
531 |
2 |
high = Color.black; |
532 |
|
} |
533 |
47 |
graduatedColour = true; |
534 |
47 |
colour = null; |
535 |
47 |
minColour = low; |
536 |
47 |
maxColour = high; |
537 |
47 |
noColour = noValueColour; |
538 |
47 |
threshold = Float.NaN; |
539 |
47 |
isHighToLow = min >= max; |
540 |
47 |
minRed = low.getRed() / 255f; |
541 |
47 |
minGreen = low.getGreen() / 255f; |
542 |
47 |
minBlue = low.getBlue() / 255f; |
543 |
47 |
deltaRed = (high.getRed() / 255f) - minRed; |
544 |
47 |
deltaGreen = (high.getGreen() / 255f) - minGreen; |
545 |
47 |
deltaBlue = (high.getBlue() / 255f) - minBlue; |
546 |
47 |
if (isHighToLow) |
547 |
|
{ |
548 |
6 |
base = max; |
549 |
6 |
range = min - max; |
550 |
|
} |
551 |
|
else |
552 |
|
{ |
553 |
41 |
base = min; |
554 |
41 |
range = max - min; |
555 |
|
} |
556 |
|
} |
557 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
558 |
33922 |
@Override... |
559 |
|
public boolean isGraduatedColour() |
560 |
|
{ |
561 |
33922 |
return graduatedColour; |
562 |
|
} |
563 |
|
|
564 |
|
|
565 |
|
|
566 |
|
|
567 |
|
|
|
|
| 60% |
Uncovered Elements: 2 (5) |
Complexity: 2 |
Complexity Density: 0.67 |
|
568 |
27 |
void setGraduatedColour(boolean b)... |
569 |
|
{ |
570 |
27 |
graduatedColour = b; |
571 |
27 |
if (b) |
572 |
|
{ |
573 |
0 |
setColourByLabel(false); |
574 |
|
} |
575 |
|
} |
576 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
577 |
26234 |
@Override... |
578 |
|
public Color getColour() |
579 |
|
{ |
580 |
26234 |
return colour; |
581 |
|
} |
582 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
583 |
26 |
@Override... |
584 |
|
public Color getMinColour() |
585 |
|
{ |
586 |
26 |
return minColour; |
587 |
|
} |
588 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
589 |
30 |
@Override... |
590 |
|
public Color getMaxColour() |
591 |
|
{ |
592 |
30 |
return maxColour; |
593 |
|
} |
594 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
595 |
11 |
@Override... |
596 |
|
public Color getNoColour() |
597 |
|
{ |
598 |
11 |
return noColour; |
599 |
|
} |
600 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
601 |
33977 |
@Override... |
602 |
|
public boolean isColourByLabel() |
603 |
|
{ |
604 |
33977 |
return colourByLabel; |
605 |
|
} |
606 |
|
|
607 |
|
|
608 |
|
|
609 |
|
|
610 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (5) |
Complexity: 2 |
Complexity Density: 0.67 |
|
611 |
47 |
@Override... |
612 |
|
public void setColourByLabel(boolean b) |
613 |
|
{ |
614 |
47 |
colourByLabel = b; |
615 |
47 |
if (b) |
616 |
|
{ |
617 |
27 |
setGraduatedColour(false); |
618 |
|
} |
619 |
|
} |
620 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
621 |
100 |
@Override... |
622 |
|
public boolean isBelowThreshold() |
623 |
|
{ |
624 |
100 |
return belowThreshold; |
625 |
|
} |
626 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (5) |
Complexity: 2 |
Complexity Density: 0.67 |
|
627 |
58 |
@Override... |
628 |
|
public void setBelowThreshold(boolean b) |
629 |
|
{ |
630 |
58 |
belowThreshold = b; |
631 |
58 |
if (b) |
632 |
|
{ |
633 |
18 |
setAboveThreshold(false); |
634 |
|
} |
635 |
|
} |
636 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
637 |
136 |
@Override... |
638 |
|
public boolean isAboveThreshold() |
639 |
|
{ |
640 |
136 |
return aboveThreshold; |
641 |
|
} |
642 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (5) |
Complexity: 2 |
Complexity Density: 0.67 |
|
643 |
57 |
@Override... |
644 |
|
public void setAboveThreshold(boolean b) |
645 |
|
{ |
646 |
57 |
aboveThreshold = b; |
647 |
57 |
if (b) |
648 |
|
{ |
649 |
29 |
setBelowThreshold(false); |
650 |
|
} |
651 |
|
} |
652 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
653 |
50 |
@Override... |
654 |
|
public float getThreshold() |
655 |
|
{ |
656 |
50 |
return threshold; |
657 |
|
} |
658 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
659 |
52 |
@Override... |
660 |
|
public void setThreshold(float f) |
661 |
|
{ |
662 |
52 |
threshold = f; |
663 |
|
} |
664 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
665 |
48 |
@Override... |
666 |
|
public boolean isAutoScaled() |
667 |
|
{ |
668 |
48 |
return autoScaled; |
669 |
|
} |
670 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
671 |
44 |
@Override... |
672 |
|
public void setAutoScaled(boolean b) |
673 |
|
{ |
674 |
44 |
this.autoScaled = b; |
675 |
|
} |
676 |
|
|
677 |
|
|
678 |
|
@inheritDoc |
679 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (9) |
Complexity: 2 |
Complexity Density: 0.29 |
|
680 |
5 |
@Override... |
681 |
|
public void updateBounds(float min, float max) |
682 |
|
{ |
683 |
5 |
if (max < min) |
684 |
|
{ |
685 |
1 |
base = max; |
686 |
1 |
range = min - max; |
687 |
1 |
isHighToLow = true; |
688 |
|
} |
689 |
|
else |
690 |
|
{ |
691 |
4 |
base = min; |
692 |
4 |
range = max - min; |
693 |
4 |
isHighToLow = false; |
694 |
|
} |
695 |
|
} |
696 |
|
|
697 |
|
|
698 |
|
|
699 |
|
|
700 |
|
|
701 |
|
|
702 |
|
|
703 |
|
@param |
704 |
|
@return |
705 |
|
|
|
|
| 84.3% |
Uncovered Elements: 8 (51) |
Complexity: 16 |
Complexity Density: 0.59 |
|
706 |
26059 |
@Override... |
707 |
|
public Color getColor(SequenceFeature feature) |
708 |
|
{ |
709 |
26059 |
if (isColourByLabel()) |
710 |
|
{ |
711 |
3 |
String label = attributeName == null ? feature.getDescription() |
712 |
|
: feature.getValueAsString(attributeName); |
713 |
3 |
return label == null ? noColour : ColorUtils |
714 |
|
.createColourFromName(label); |
715 |
|
} |
716 |
|
|
717 |
26056 |
if (!isGraduatedColour()) |
718 |
|
{ |
719 |
26011 |
return getColour(); |
720 |
|
} |
721 |
|
|
722 |
|
|
723 |
|
|
724 |
|
|
725 |
|
|
726 |
|
|
727 |
45 |
float scr = feature.getScore(); |
728 |
45 |
if (attributeName != null) |
729 |
|
{ |
730 |
13 |
try |
731 |
|
{ |
732 |
13 |
String attVal = feature.getValueAsString(attributeName); |
733 |
13 |
scr = Float.valueOf(attVal); |
734 |
|
} catch (Throwable e) |
735 |
|
{ |
736 |
5 |
scr = Float.NaN; |
737 |
|
} |
738 |
|
} |
739 |
45 |
if (Float.isNaN(scr)) |
740 |
|
{ |
741 |
10 |
return noColour; |
742 |
|
} |
743 |
|
|
744 |
35 |
if (isAboveThreshold() && scr <= threshold) |
745 |
|
{ |
746 |
10 |
return null; |
747 |
|
} |
748 |
|
|
749 |
25 |
if (isBelowThreshold() && scr >= threshold) |
750 |
|
{ |
751 |
5 |
return null; |
752 |
|
} |
753 |
20 |
if (range == 0.0) |
754 |
|
{ |
755 |
0 |
return getMaxColour(); |
756 |
|
} |
757 |
20 |
float scl = (scr - base) / range; |
758 |
20 |
if (isHighToLow) |
759 |
|
{ |
760 |
0 |
scl = -scl; |
761 |
|
} |
762 |
20 |
if (scl < 0f) |
763 |
|
{ |
764 |
0 |
scl = 0f; |
765 |
|
} |
766 |
20 |
if (scl > 1f) |
767 |
|
{ |
768 |
0 |
scl = 1f; |
769 |
|
} |
770 |
20 |
return new Color(minRed + scl * deltaRed, minGreen + scl * deltaGreen, |
771 |
|
minBlue + scl * deltaBlue); |
772 |
|
} |
773 |
|
|
774 |
|
|
775 |
|
|
776 |
|
|
777 |
|
@return |
778 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 2 |
Complexity Density: 2 |
|
779 |
36 |
@Override... |
780 |
|
public float getMax() |
781 |
|
{ |
782 |
|
|
783 |
36 |
return (isHighToLow) ? base : (base + range); |
784 |
|
} |
785 |
|
|
786 |
|
|
787 |
|
|
788 |
|
|
789 |
|
@return |
790 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 2 |
Complexity Density: 2 |
|
791 |
36 |
@Override... |
792 |
|
public float getMin() |
793 |
|
{ |
794 |
|
|
795 |
36 |
return (isHighToLow) ? (base + range) : base; |
796 |
|
} |
797 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
798 |
7844 |
@Override... |
799 |
|
public boolean isSimpleColour() |
800 |
|
{ |
801 |
7844 |
return (!isColourByLabel() && !isGraduatedColour()); |
802 |
|
} |
803 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
804 |
40 |
@Override... |
805 |
|
public boolean hasThreshold() |
806 |
|
{ |
807 |
40 |
return isAboveThreshold() || isBelowThreshold(); |
808 |
|
} |
809 |
|
|
|
|
| 98% |
Uncovered Elements: 1 (51) |
Complexity: 13 |
Complexity Density: 0.45 |
|
810 |
19 |
@Override... |
811 |
|
public String toJalviewFormat(String featureType) |
812 |
|
{ |
813 |
19 |
String colourString = null; |
814 |
19 |
if (isSimpleColour()) |
815 |
|
{ |
816 |
4 |
colourString = Format.getHexString(getColour()); |
817 |
|
} |
818 |
|
else |
819 |
|
{ |
820 |
15 |
StringBuilder sb = new StringBuilder(32); |
821 |
15 |
if (isColourByAttribute()) |
822 |
|
{ |
823 |
3 |
sb.append(ATTRIBUTE).append(BAR); |
824 |
3 |
sb.append( |
825 |
|
FeatureMatcher.toAttributeDisplayName(getAttributeName())); |
826 |
|
} |
827 |
12 |
else if (isColourByLabel()) |
828 |
|
{ |
829 |
4 |
sb.append(LABEL); |
830 |
|
} |
831 |
|
else |
832 |
|
{ |
833 |
8 |
sb.append(SCORE); |
834 |
|
} |
835 |
15 |
if (isGraduatedColour()) |
836 |
|
{ |
837 |
9 |
sb.append(BAR).append(Format.getHexString(getMinColour())) |
838 |
|
.append(BAR); |
839 |
9 |
sb.append(Format.getHexString(getMaxColour())).append(BAR); |
840 |
9 |
String noValue = minColour.equals(noColour) ? NO_VALUE_MIN |
841 |
5 |
: (maxColour.equals(noColour) ? NO_VALUE_MAX |
842 |
|
: NO_VALUE_NONE); |
843 |
9 |
sb.append(noValue).append(BAR); |
844 |
9 |
if (!isAutoScaled()) |
845 |
|
{ |
846 |
5 |
sb.append(ABSOLUTE).append(BAR); |
847 |
|
} |
848 |
|
} |
849 |
|
else |
850 |
|
{ |
851 |
|
|
852 |
|
|
853 |
|
|
854 |
|
|
855 |
6 |
if (hasThreshold()) |
856 |
|
{ |
857 |
3 |
sb.append(BAR).append(BAR).append(BAR); |
858 |
|
} |
859 |
|
} |
860 |
15 |
if (hasThreshold() || isGraduatedColour()) |
861 |
|
{ |
862 |
12 |
sb.append(getMin()).append(BAR); |
863 |
12 |
sb.append(getMax()).append(BAR); |
864 |
12 |
if (isBelowThreshold()) |
865 |
|
{ |
866 |
5 |
sb.append(BELOW).append(BAR).append(getThreshold()); |
867 |
|
} |
868 |
7 |
else if (isAboveThreshold()) |
869 |
|
{ |
870 |
3 |
sb.append(ABOVE).append(BAR).append(getThreshold()); |
871 |
|
} |
872 |
|
else |
873 |
|
{ |
874 |
4 |
sb.append("none"); |
875 |
|
} |
876 |
|
} |
877 |
15 |
colourString = sb.toString(); |
878 |
|
} |
879 |
19 |
return String.format("%s\t%s", featureType, colourString); |
880 |
|
} |
881 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
882 |
48 |
@Override... |
883 |
|
public boolean isColourByAttribute() |
884 |
|
{ |
885 |
48 |
return attributeName != null; |
886 |
|
} |
887 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
888 |
54 |
@Override... |
889 |
|
public String[] getAttributeName() |
890 |
|
{ |
891 |
54 |
return attributeName; |
892 |
|
} |
893 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
894 |
31 |
@Override... |
895 |
|
public void setAttributeName(String... name) |
896 |
|
{ |
897 |
31 |
attributeName = name; |
898 |
|
} |
899 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (29) |
Complexity: 8 |
Complexity Density: 0.47 |
|
900 |
17 |
@Override... |
901 |
|
public String getDescription() |
902 |
|
{ |
903 |
17 |
if (isSimpleColour()) |
904 |
|
{ |
905 |
1 |
return "r=" + colour.getRed() + ",g=" + colour.getGreen() + ",b=" |
906 |
|
+ colour.getBlue(); |
907 |
|
} |
908 |
16 |
StringBuilder tt = new StringBuilder(); |
909 |
16 |
String by = null; |
910 |
|
|
911 |
16 |
if (getAttributeName() != null) |
912 |
|
{ |
913 |
4 |
by = FeatureMatcher.toAttributeDisplayName(getAttributeName()); |
914 |
|
} |
915 |
12 |
else if (isColourByLabel()) |
916 |
|
{ |
917 |
5 |
by = I18N_LABEL; |
918 |
|
} |
919 |
|
else |
920 |
|
{ |
921 |
7 |
by = I18N_SCORE; |
922 |
|
} |
923 |
16 |
tt.append(MessageManager.formatMessage("action.by_title_param", by)); |
924 |
|
|
925 |
|
|
926 |
|
|
927 |
|
|
928 |
16 |
if (isAboveThreshold() || isBelowThreshold()) |
929 |
|
{ |
930 |
10 |
tt.append(" ("); |
931 |
10 |
if (isColourByLabel()) |
932 |
|
{ |
933 |
|
|
934 |
|
|
935 |
|
|
936 |
|
|
937 |
3 |
tt.append(I18N_SCORE).append(" "); |
938 |
|
} |
939 |
10 |
tt.append(isAboveThreshold() ? "> " : "< "); |
940 |
10 |
tt.append(getThreshold()).append(")"); |
941 |
|
} |
942 |
|
|
943 |
16 |
return tt.toString(); |
944 |
|
} |
945 |
|
|
946 |
|
} |