1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
|
|
19 |
|
|
20 |
|
|
21 |
|
package jalview.project; |
22 |
|
|
23 |
|
import static jalview.math.RotatableMatrix.Axis.X; |
24 |
|
import static jalview.math.RotatableMatrix.Axis.Y; |
25 |
|
import static jalview.math.RotatableMatrix.Axis.Z; |
26 |
|
|
27 |
|
import java.awt.Color; |
28 |
|
import java.awt.Font; |
29 |
|
import java.awt.Rectangle; |
30 |
|
import java.io.BufferedReader; |
31 |
|
import java.io.ByteArrayInputStream; |
32 |
|
import java.io.File; |
33 |
|
import java.io.FileInputStream; |
34 |
|
import java.io.FileOutputStream; |
35 |
|
import java.io.IOException; |
36 |
|
import java.io.InputStream; |
37 |
|
import java.io.InputStreamReader; |
38 |
|
import java.io.OutputStream; |
39 |
|
import java.io.OutputStreamWriter; |
40 |
|
import java.io.PrintWriter; |
41 |
|
import java.lang.reflect.InvocationTargetException; |
42 |
|
import java.math.BigInteger; |
43 |
|
import java.net.MalformedURLException; |
44 |
|
import java.net.URL; |
45 |
|
import java.util.ArrayList; |
46 |
|
import java.util.Arrays; |
47 |
|
import java.util.BitSet; |
48 |
|
import java.util.Collections; |
49 |
|
import java.util.Enumeration; |
50 |
|
import java.util.GregorianCalendar; |
51 |
|
import java.util.HashMap; |
52 |
|
import java.util.HashSet; |
53 |
|
import java.util.Hashtable; |
54 |
|
import java.util.IdentityHashMap; |
55 |
|
import java.util.Iterator; |
56 |
|
import java.util.LinkedHashMap; |
57 |
|
import java.util.List; |
58 |
|
import java.util.Locale; |
59 |
|
import java.util.Map; |
60 |
|
import java.util.Map.Entry; |
61 |
|
import java.util.Set; |
62 |
|
import java.util.Vector; |
63 |
|
import java.util.jar.JarEntry; |
64 |
|
import java.util.jar.JarInputStream; |
65 |
|
import java.util.jar.JarOutputStream; |
66 |
|
|
67 |
|
import javax.swing.JInternalFrame; |
68 |
|
import javax.swing.SwingUtilities; |
69 |
|
import javax.xml.bind.JAXBContext; |
70 |
|
import javax.xml.bind.JAXBElement; |
71 |
|
import javax.xml.bind.Marshaller; |
72 |
|
import javax.xml.datatype.DatatypeConfigurationException; |
73 |
|
import javax.xml.datatype.DatatypeFactory; |
74 |
|
import javax.xml.datatype.XMLGregorianCalendar; |
75 |
|
import javax.xml.stream.XMLInputFactory; |
76 |
|
import javax.xml.stream.XMLStreamReader; |
77 |
|
|
78 |
|
import jalview.analysis.Conservation; |
79 |
|
import jalview.analysis.PCA; |
80 |
|
import jalview.analysis.PaSiMap; |
81 |
|
import jalview.analysis.scoremodels.ScoreModels; |
82 |
|
import jalview.analysis.scoremodels.SimilarityParams; |
83 |
|
import jalview.api.FeatureColourI; |
84 |
|
import jalview.api.ViewStyleI; |
85 |
|
import jalview.api.analysis.ScoreModelI; |
86 |
|
import jalview.api.analysis.SimilarityParamsI; |
87 |
|
import jalview.api.structures.JalviewStructureDisplayI; |
88 |
|
import jalview.bin.Cache; |
89 |
|
import jalview.bin.Console; |
90 |
|
import jalview.bin.Jalview; |
91 |
|
import jalview.datamodel.AlignedCodonFrame; |
92 |
|
import jalview.datamodel.Alignment; |
93 |
|
import jalview.datamodel.AlignmentAnnotation; |
94 |
|
import jalview.datamodel.AlignmentI; |
95 |
|
import jalview.datamodel.ContactMatrix; |
96 |
|
import jalview.datamodel.ContactMatrixI; |
97 |
|
import jalview.datamodel.DBRefEntry; |
98 |
|
import jalview.datamodel.FloatContactMatrix; |
99 |
|
import jalview.datamodel.GeneLocus; |
100 |
|
import jalview.datamodel.GraphLine; |
101 |
|
import jalview.datamodel.GroupSet; |
102 |
|
import jalview.datamodel.PDBEntry; |
103 |
|
import jalview.datamodel.Point; |
104 |
|
import jalview.datamodel.RnaViewerModel; |
105 |
|
import jalview.datamodel.SequenceFeature; |
106 |
|
import jalview.datamodel.SequenceGroup; |
107 |
|
import jalview.datamodel.SequenceI; |
108 |
|
import jalview.datamodel.StructureViewerModel; |
109 |
|
import jalview.datamodel.StructureViewerModel.StructureData; |
110 |
|
import jalview.datamodel.features.FeatureMatcher; |
111 |
|
import jalview.datamodel.features.FeatureMatcherI; |
112 |
|
import jalview.datamodel.features.FeatureMatcherSet; |
113 |
|
import jalview.datamodel.features.FeatureMatcherSetI; |
114 |
|
import jalview.ext.varna.RnaModel; |
115 |
|
import jalview.gui.AlignFrame; |
116 |
|
import jalview.gui.AlignViewport; |
117 |
|
import jalview.gui.AlignmentPanel; |
118 |
|
import jalview.gui.AppVarna; |
119 |
|
import jalview.gui.Desktop; |
120 |
|
import jalview.gui.JvOptionPane; |
121 |
|
import jalview.gui.OOMWarning; |
122 |
|
import jalview.gui.OverviewPanel; |
123 |
|
import jalview.gui.PCAPanel; |
124 |
|
import jalview.gui.PaSiMapPanel; |
125 |
|
import jalview.gui.PaintRefresher; |
126 |
|
import jalview.gui.SplitFrame; |
127 |
|
import jalview.gui.StructureViewer; |
128 |
|
import jalview.gui.StructureViewer.ViewerType; |
129 |
|
import jalview.gui.StructureViewerBase; |
130 |
|
import jalview.gui.TreePanel; |
131 |
|
import jalview.io.BackupFiles; |
132 |
|
import jalview.io.DataSourceType; |
133 |
|
import jalview.io.FileFormat; |
134 |
|
import jalview.io.NewickFile; |
135 |
|
import jalview.math.Matrix; |
136 |
|
import jalview.math.MatrixI; |
137 |
|
import jalview.renderer.ResidueShaderI; |
138 |
|
import jalview.schemes.AnnotationColourGradient; |
139 |
|
import jalview.schemes.ColourSchemeI; |
140 |
|
import jalview.schemes.ColourSchemeProperty; |
141 |
|
import jalview.schemes.FeatureColour; |
142 |
|
import jalview.schemes.ResidueProperties; |
143 |
|
import jalview.schemes.UserColourScheme; |
144 |
|
import jalview.structure.StructureSelectionManager; |
145 |
|
import jalview.structures.models.AAStructureBindingModel; |
146 |
|
import jalview.util.Format; |
147 |
|
import jalview.util.HttpUtils; |
148 |
|
import jalview.util.MessageManager; |
149 |
|
import jalview.util.Platform; |
150 |
|
import jalview.util.StringUtils; |
151 |
|
import jalview.util.jarInputStreamProvider; |
152 |
|
import jalview.util.matcher.Condition; |
153 |
|
import jalview.viewmodel.AlignmentViewport; |
154 |
|
import jalview.viewmodel.PCAModel; |
155 |
|
import jalview.viewmodel.PaSiMapModel; |
156 |
|
import jalview.viewmodel.ViewportRanges; |
157 |
|
import jalview.viewmodel.seqfeatures.FeatureRendererModel; |
158 |
|
import jalview.viewmodel.seqfeatures.FeatureRendererSettings; |
159 |
|
import jalview.viewmodel.seqfeatures.FeaturesDisplayed; |
160 |
|
import jalview.ws.datamodel.MappableContactMatrixI; |
161 |
|
import jalview.ws.datamodel.alphafold.PAEContactMatrix; |
162 |
|
import jalview.ws.jws2.Jws2Discoverer; |
163 |
|
import jalview.ws.jws2.dm.AAConSettings; |
164 |
|
import jalview.ws.jws2.jabaws2.Jws2Instance; |
165 |
|
import jalview.ws.params.ArgumentI; |
166 |
|
import jalview.ws.params.AutoCalcSetting; |
167 |
|
import jalview.ws.params.WsParamSetI; |
168 |
|
import jalview.xml.binding.jalview.AlcodonFrame; |
169 |
|
import jalview.xml.binding.jalview.AlcodonFrame.AlcodMap; |
170 |
|
import jalview.xml.binding.jalview.Annotation; |
171 |
|
import jalview.xml.binding.jalview.Annotation.ThresholdLine; |
172 |
|
import jalview.xml.binding.jalview.AnnotationColourScheme; |
173 |
|
import jalview.xml.binding.jalview.AnnotationElement; |
174 |
|
import jalview.xml.binding.jalview.DoubleMatrix; |
175 |
|
import jalview.xml.binding.jalview.DoubleVector; |
176 |
|
import jalview.xml.binding.jalview.Feature; |
177 |
|
import jalview.xml.binding.jalview.Feature.OtherData; |
178 |
|
import jalview.xml.binding.jalview.FeatureMatcherSet.CompoundMatcher; |
179 |
|
import jalview.xml.binding.jalview.FilterBy; |
180 |
|
import jalview.xml.binding.jalview.JalviewModel; |
181 |
|
import jalview.xml.binding.jalview.JalviewModel.FeatureSettings; |
182 |
|
import jalview.xml.binding.jalview.JalviewModel.FeatureSettings.Group; |
183 |
|
import jalview.xml.binding.jalview.JalviewModel.FeatureSettings.Setting; |
184 |
|
import jalview.xml.binding.jalview.JalviewModel.JGroup; |
185 |
|
import jalview.xml.binding.jalview.JalviewModel.JSeq; |
186 |
|
import jalview.xml.binding.jalview.JalviewModel.JSeq.Pdbids; |
187 |
|
import jalview.xml.binding.jalview.JalviewModel.JSeq.Pdbids.StructureState; |
188 |
|
import jalview.xml.binding.jalview.JalviewModel.JSeq.RnaViewer; |
189 |
|
import jalview.xml.binding.jalview.JalviewModel.JSeq.RnaViewer.SecondaryStructure; |
190 |
|
import jalview.xml.binding.jalview.JalviewModel.PcaViewer; |
191 |
|
import jalview.xml.binding.jalview.JalviewModel.PcaViewer.Axis; |
192 |
|
import jalview.xml.binding.jalview.JalviewModel.PcaViewer.SeqPointMax; |
193 |
|
import jalview.xml.binding.jalview.JalviewModel.PcaViewer.SeqPointMin; |
194 |
|
import jalview.xml.binding.jalview.JalviewModel.PcaViewer.SequencePoint; |
195 |
|
import jalview.xml.binding.jalview.JalviewModel.Tree; |
196 |
|
import jalview.xml.binding.jalview.JalviewModel.UserColours; |
197 |
|
import jalview.xml.binding.jalview.JalviewModel.Viewport; |
198 |
|
import jalview.xml.binding.jalview.JalviewModel.Viewport.CalcIdParam; |
199 |
|
import jalview.xml.binding.jalview.JalviewModel.Viewport.HiddenColumns; |
200 |
|
import jalview.xml.binding.jalview.JalviewModel.Viewport.Overview; |
201 |
|
import jalview.xml.binding.jalview.JalviewUserColours; |
202 |
|
import jalview.xml.binding.jalview.JalviewUserColours.Colour; |
203 |
|
import jalview.xml.binding.jalview.MapListType; |
204 |
|
import jalview.xml.binding.jalview.MapListType.MapListFrom; |
205 |
|
import jalview.xml.binding.jalview.MapListType.MapListTo; |
206 |
|
import jalview.xml.binding.jalview.MapOnAMatrixType; |
207 |
|
import jalview.xml.binding.jalview.Mapping; |
208 |
|
import jalview.xml.binding.jalview.MatrixType; |
209 |
|
import jalview.xml.binding.jalview.NoValueColour; |
210 |
|
import jalview.xml.binding.jalview.ObjectFactory; |
211 |
|
import jalview.xml.binding.jalview.PcaDataType; |
212 |
|
import jalview.xml.binding.jalview.Pdbentry.Property; |
213 |
|
import jalview.xml.binding.jalview.Sequence; |
214 |
|
import jalview.xml.binding.jalview.Sequence.DBRef; |
215 |
|
import jalview.xml.binding.jalview.SequenceSet; |
216 |
|
import jalview.xml.binding.jalview.SequenceSet.SequenceSetProperties; |
217 |
|
import jalview.xml.binding.jalview.ThresholdType; |
218 |
|
import jalview.xml.binding.jalview.VAMSAS; |
219 |
|
|
220 |
|
|
221 |
|
|
222 |
|
|
223 |
|
|
224 |
|
|
225 |
|
|
226 |
|
|
227 |
|
@author |
228 |
|
@version |
229 |
|
|
|
|
| 74.6% |
Uncovered Elements: 989 (3,887) |
Complexity: 817 |
Complexity Density: 0.31 |
|
230 |
|
public class Jalview2XML |
231 |
|
{ |
232 |
|
|
233 |
|
|
234 |
|
|
235 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
236 |
4 |
static... |
237 |
|
{ |
238 |
4 |
Platform.addJ2SBinaryType(".jvp?"); |
239 |
|
} |
240 |
|
|
241 |
|
private static final String VIEWER_PREFIX = "viewer_"; |
242 |
|
|
243 |
|
private static final String RNA_PREFIX = "rna_"; |
244 |
|
|
245 |
|
private static final String UTF_8 = "UTF-8"; |
246 |
|
|
247 |
|
|
248 |
|
|
249 |
|
|
250 |
|
private static boolean stateSavedUpToDate = false; |
251 |
|
|
252 |
|
|
253 |
|
|
254 |
|
|
255 |
|
|
256 |
|
private static final String UNIQSEQSETID = "uniqueSeqSetId."; |
257 |
|
|
258 |
|
|
259 |
|
private int counter = 0; |
260 |
|
|
261 |
|
|
262 |
|
|
263 |
|
|
264 |
|
|
265 |
|
IdentityHashMap<SequenceI, String> seqsToIds = null; |
266 |
|
|
267 |
|
|
268 |
|
|
269 |
|
|
270 |
|
|
271 |
|
|
272 |
|
Map<String, SequenceI> seqRefIds = null; |
273 |
|
|
274 |
|
Map<String, SequenceI> incompleteSeqs = null; |
275 |
|
|
276 |
|
List<forwardRef> frefedSequence = null; |
277 |
|
|
278 |
|
boolean raiseGUI = true; |
279 |
|
|
280 |
|
|
281 |
|
|
282 |
|
|
283 |
|
|
284 |
|
private Map<Viewport, AlignFrame> splitFrameCandidates = new HashMap<>(); |
285 |
|
|
286 |
|
|
287 |
|
|
288 |
|
|
289 |
|
|
290 |
|
private Map<RnaModel, String> rnaSessions = new HashMap<>(); |
291 |
|
|
292 |
|
|
293 |
|
|
294 |
|
|
295 |
|
private Map<ContactMatrixI, String> contactMatrices = new HashMap<>(); |
296 |
|
|
297 |
|
private Map<String, ContactMatrixI> contactMatrixRefs = new HashMap<>(); |
298 |
|
|
299 |
|
private List<jalview.xml.binding.jalview.MatrixType> xmlMatrices = new ArrayList<>(); |
300 |
|
|
301 |
|
|
302 |
|
|
303 |
|
|
304 |
|
|
305 |
|
|
306 |
|
@param |
307 |
|
@return |
308 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 2 |
Complexity Density: 2 |
|
309 |
3930 |
public static boolean safeBoolean(Boolean b)... |
310 |
|
{ |
311 |
3930 |
return b == null ? false : b.booleanValue(); |
312 |
|
} |
313 |
|
|
314 |
|
|
315 |
|
|
316 |
|
|
317 |
|
|
318 |
|
|
319 |
|
@param |
320 |
|
@return |
321 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 2 |
Complexity Density: 2 |
|
322 |
273832 |
public static int safeInt(Integer i)... |
323 |
|
{ |
324 |
273832 |
return i == null ? 0 : i.intValue(); |
325 |
|
} |
326 |
|
|
327 |
|
|
328 |
|
|
329 |
|
|
330 |
|
|
331 |
|
|
332 |
|
@param |
333 |
|
@return |
334 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 2 |
Complexity Density: 2 |
|
335 |
405037 |
public static float safeFloat(Float f)... |
336 |
|
{ |
337 |
405037 |
return f == null ? 0f : f.floatValue(); |
338 |
|
} |
339 |
|
|
340 |
|
|
341 |
|
|
342 |
|
|
343 |
|
@param |
344 |
|
@return |
345 |
|
|
|
|
| 83.3% |
Uncovered Elements: 2 (12) |
Complexity: 3 |
Complexity Density: 0.38 |
|
346 |
1488 |
String seqHash(SequenceI sq)... |
347 |
|
{ |
348 |
1488 |
if (seqsToIds == null) |
349 |
|
{ |
350 |
0 |
initSeqRefs(); |
351 |
|
} |
352 |
1488 |
if (seqsToIds.containsKey(sq)) |
353 |
|
{ |
354 |
670 |
return seqsToIds.get(sq); |
355 |
|
} |
356 |
|
else |
357 |
|
{ |
358 |
|
|
359 |
818 |
String key = "sq" + (seqsToIds.size() + 1); |
360 |
818 |
key = makeHashCode(sq, key); |
361 |
|
|
362 |
818 |
seqsToIds.put(sq, key); |
363 |
818 |
return key; |
364 |
|
} |
365 |
|
} |
366 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (16) |
Complexity: 5 |
Complexity Density: 0.62 |
|
367 |
114 |
void initSeqRefs()... |
368 |
|
{ |
369 |
114 |
if (seqsToIds == null) |
370 |
|
{ |
371 |
64 |
seqsToIds = new IdentityHashMap<>(); |
372 |
|
} |
373 |
114 |
if (seqRefIds == null) |
374 |
|
{ |
375 |
64 |
seqRefIds = new HashMap<>(); |
376 |
|
} |
377 |
114 |
if (incompleteSeqs == null) |
378 |
|
{ |
379 |
64 |
incompleteSeqs = new HashMap<>(); |
380 |
|
} |
381 |
114 |
if (frefedSequence == null) |
382 |
|
{ |
383 |
64 |
frefedSequence = new ArrayList<>(); |
384 |
|
} |
385 |
|
} |
386 |
|
|
|
|
| - |
Uncovered Elements: 0 (0) |
Complexity: 1 |
Complexity Density: - |
|
387 |
20 |
public Jalview2XML()... |
388 |
|
{ |
389 |
|
} |
390 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
391 |
44 |
public Jalview2XML(boolean raiseGUI)... |
392 |
|
{ |
393 |
44 |
this.raiseGUI = raiseGUI; |
394 |
|
} |
395 |
|
|
396 |
|
|
397 |
|
|
398 |
|
|
399 |
|
|
400 |
|
@author |
401 |
|
|
402 |
|
|
|
|
| 42.9% |
Uncovered Elements: 4 (7) |
Complexity: 3 |
Complexity Density: 0.75 |
|
403 |
|
abstract class forwardRef |
404 |
|
{ |
405 |
|
String sref; |
406 |
|
|
407 |
|
String type; |
408 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
409 |
3 |
public forwardRef(String _sref, String type)... |
410 |
|
{ |
411 |
3 |
sref = _sref; |
412 |
3 |
this.type = type; |
413 |
|
} |
414 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
415 |
0 |
public String getSref()... |
416 |
|
{ |
417 |
0 |
return sref; |
418 |
|
} |
419 |
|
|
420 |
|
public abstract boolean isResolvable(); |
421 |
|
|
422 |
|
|
423 |
|
@return |
424 |
|
|
425 |
|
abstract boolean resolve(); |
426 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
427 |
0 |
@Override... |
428 |
|
public String toString() |
429 |
|
{ |
430 |
0 |
return type + " reference to " + sref; |
431 |
|
} |
432 |
|
} |
433 |
|
|
434 |
|
|
435 |
|
|
436 |
|
|
437 |
|
@author |
438 |
|
|
|
|
| 0% |
Uncovered Elements: 16 (16) |
Complexity: 6 |
Complexity Density: 0.75 |
|
439 |
|
abstract class SeqFref extends forwardRef |
440 |
|
{ |
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
441 |
0 |
public SeqFref(String _sref, String type)... |
442 |
|
{ |
443 |
0 |
super(_sref, type); |
444 |
|
} |
445 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
446 |
0 |
public SequenceI getSrefSeq()... |
447 |
|
{ |
448 |
0 |
return seqRefIds.get(sref); |
449 |
|
} |
450 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
451 |
0 |
public boolean isResolvable()... |
452 |
|
{ |
453 |
0 |
return seqRefIds.get(sref) != null; |
454 |
|
} |
455 |
|
|
|
|
| 0% |
Uncovered Elements: 9 (9) |
Complexity: 3 |
Complexity Density: 0.6 |
|
456 |
0 |
public SequenceI getSrefDatasetSeq()... |
457 |
|
{ |
458 |
0 |
SequenceI sq = seqRefIds.get(sref); |
459 |
0 |
if (sq != null) |
460 |
|
{ |
461 |
0 |
while (sq.getDatasetSequence() != null) |
462 |
|
{ |
463 |
0 |
sq = sq.getDatasetSequence(); |
464 |
|
} |
465 |
|
} |
466 |
0 |
return sq; |
467 |
|
} |
468 |
|
} |
469 |
|
|
470 |
|
|
471 |
|
|
472 |
|
|
473 |
|
@param |
474 |
|
@param |
475 |
|
@return |
476 |
|
|
|
|
| 0% |
Uncovered Elements: 2 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
477 |
0 |
public SeqFref newMappingRef(final String sref,... |
478 |
|
final jalview.datamodel.Mapping _jmap) |
479 |
|
{ |
480 |
0 |
SeqFref fref = new SeqFref(sref, "Mapping") |
481 |
|
{ |
482 |
|
public jalview.datamodel.Mapping jmap = _jmap; |
483 |
|
|
|
|
| 0% |
Uncovered Elements: 7 (7) |
Complexity: 2 |
Complexity Density: 0.4 |
|
484 |
0 |
@Override... |
485 |
|
boolean resolve() |
486 |
|
{ |
487 |
0 |
SequenceI seq = getSrefDatasetSeq(); |
488 |
0 |
if (seq == null) |
489 |
|
{ |
490 |
0 |
return false; |
491 |
|
} |
492 |
0 |
jmap.setTo(seq); |
493 |
0 |
return true; |
494 |
|
} |
495 |
|
}; |
496 |
0 |
return fref; |
497 |
|
} |
498 |
|
|
|
|
| 0% |
Uncovered Elements: 2 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
499 |
0 |
public SeqFref newAlcodMapRef(final String sref,... |
500 |
|
final AlignedCodonFrame _cf, |
501 |
|
final jalview.datamodel.Mapping _jmap) |
502 |
|
{ |
503 |
|
|
504 |
0 |
SeqFref fref = new SeqFref(sref, "Codon Frame") |
505 |
|
{ |
506 |
|
AlignedCodonFrame cf = _cf; |
507 |
|
|
508 |
|
public jalview.datamodel.Mapping mp = _jmap; |
509 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
510 |
0 |
@Override... |
511 |
|
public boolean isResolvable() |
512 |
|
{ |
513 |
0 |
return super.isResolvable() && mp.getTo() != null; |
514 |
|
} |
515 |
|
|
|
|
| 0% |
Uncovered Elements: 7 (7) |
Complexity: 2 |
Complexity Density: 0.4 |
|
516 |
0 |
@Override... |
517 |
|
boolean resolve() |
518 |
|
{ |
519 |
0 |
SequenceI seq = getSrefDatasetSeq(); |
520 |
0 |
if (seq == null) |
521 |
|
{ |
522 |
0 |
return false; |
523 |
|
} |
524 |
0 |
cf.addMap(seq, mp.getTo(), mp.getMap()); |
525 |
0 |
return true; |
526 |
|
} |
527 |
|
}; |
528 |
0 |
return fref; |
529 |
|
} |
530 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
531 |
3 |
public forwardRef newMatrixFref(final String matRef,... |
532 |
|
final jalview.util.MapList mapping, final AlignmentAnnotation jaa) |
533 |
|
{ |
534 |
3 |
forwardRef fref = new forwardRef(matRef, |
535 |
|
"Matrix Reference for sequence and annotation") |
536 |
|
{ |
537 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (4) |
Complexity: 1 |
Complexity Density: 0.25 |
|
538 |
3 |
@Override... |
539 |
|
boolean resolve() |
540 |
|
{ |
541 |
3 |
ContactMatrixI cm = contactMatrixRefs.get(matRef); |
542 |
3 |
PAEContactMatrix newpae = new PAEContactMatrix(jaa.sequenceRef, |
543 |
|
mapping, cm); |
544 |
|
|
545 |
3 |
jaa.sequenceRef.addContactListFor(jaa, newpae); |
546 |
3 |
return true; |
547 |
|
} |
548 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
549 |
3 |
@Override... |
550 |
|
public boolean isResolvable() |
551 |
|
{ |
552 |
3 |
return (contactMatrixRefs.get(matRef) != null); |
553 |
|
} |
554 |
|
}; |
555 |
3 |
return fref; |
556 |
|
} |
557 |
|
|
|
|
| 50% |
Uncovered Elements: 19 (38) |
Complexity: 10 |
Complexity Density: 0.42 |
|
558 |
29 |
public void resolveFrefedSequences()... |
559 |
|
{ |
560 |
29 |
Iterator<forwardRef> nextFref = frefedSequence.iterator(); |
561 |
29 |
int toresolve = frefedSequence.size(); |
562 |
29 |
int unresolved = 0, failedtoresolve = 0; |
563 |
32 |
while (nextFref.hasNext()) |
564 |
|
{ |
565 |
3 |
forwardRef ref = nextFref.next(); |
566 |
3 |
if (ref.isResolvable()) |
567 |
|
{ |
568 |
3 |
try |
569 |
|
{ |
570 |
3 |
if (ref.resolve()) |
571 |
|
{ |
572 |
3 |
nextFref.remove(); |
573 |
|
} |
574 |
|
else |
575 |
|
{ |
576 |
0 |
failedtoresolve++; |
577 |
|
} |
578 |
|
} catch (Exception x) |
579 |
|
{ |
580 |
0 |
jalview.bin.Console.errPrintln( |
581 |
|
"IMPLEMENTATION ERROR: Failed to resolve forward reference for sequence " |
582 |
|
+ ref.getSref()); |
583 |
0 |
x.printStackTrace(); |
584 |
0 |
failedtoresolve++; |
585 |
|
} |
586 |
|
} |
587 |
|
else |
588 |
|
{ |
589 |
0 |
unresolved++; |
590 |
|
} |
591 |
|
} |
592 |
29 |
if (unresolved > 0) |
593 |
|
{ |
594 |
0 |
jalview.bin.Console.errPrintln("Jalview Project Import: There were " |
595 |
|
+ unresolved |
596 |
|
+ " forward references left unresolved on the stack."); |
597 |
|
} |
598 |
29 |
if (failedtoresolve > 0) |
599 |
|
{ |
600 |
0 |
jalview.bin.Console.errPrintln("SERIOUS! " + failedtoresolve |
601 |
|
+ " resolvable forward references failed to resolve."); |
602 |
|
} |
603 |
29 |
if (incompleteSeqs != null && incompleteSeqs.size() > 0) |
604 |
|
{ |
605 |
0 |
jalview.bin.Console.errPrintln( |
606 |
|
"Jalview Project Import: There are " + incompleteSeqs.size() |
607 |
|
+ " sequences which may have incomplete metadata."); |
608 |
0 |
if (incompleteSeqs.size() < 10) |
609 |
|
{ |
610 |
0 |
for (SequenceI s : incompleteSeqs.values()) |
611 |
|
{ |
612 |
0 |
jalview.bin.Console.errPrintln(s.toString()); |
613 |
|
} |
614 |
|
} |
615 |
|
else |
616 |
|
{ |
617 |
0 |
jalview.bin.Console.errPrintln( |
618 |
|
"Too many to report. Skipping output of incomplete sequences."); |
619 |
|
} |
620 |
|
} |
621 |
|
} |
622 |
|
|
623 |
|
|
624 |
|
|
625 |
|
|
626 |
|
|
627 |
|
Map<String, AlignViewport> viewportsAdded = new HashMap<>(); |
628 |
|
|
629 |
|
Map<String, AlignmentAnnotation> annotationIds = new HashMap<>(); |
630 |
|
|
631 |
|
String uniqueSetSuffix = ""; |
632 |
|
|
633 |
|
|
634 |
|
|
635 |
|
|
636 |
|
List<String> pdbfiles = null; |
637 |
|
|
638 |
|
|
|
|
| 57.9% |
Uncovered Elements: 8 (19) |
Complexity: 5 |
Complexity Density: 0.33 |
|
639 |
16 |
public void saveState(File statefile)... |
640 |
|
{ |
641 |
16 |
FileOutputStream fos = null; |
642 |
|
|
643 |
16 |
try |
644 |
|
{ |
645 |
|
|
646 |
16 |
fos = new FileOutputStream(statefile); |
647 |
|
|
648 |
16 |
JarOutputStream jout = new JarOutputStream(fos); |
649 |
16 |
saveState(jout); |
650 |
16 |
fos.close(); |
651 |
|
|
652 |
|
} catch (Exception e) |
653 |
|
{ |
654 |
0 |
Console.error("Couln't write Jalview state to " + statefile, e); |
655 |
|
|
656 |
|
|
657 |
0 |
if (errorMessage == null) |
658 |
|
{ |
659 |
0 |
errorMessage = "Did't write Jalview Archive to output file '" |
660 |
|
+ statefile + "' - See console error log for details"; |
661 |
|
} |
662 |
|
else |
663 |
|
{ |
664 |
0 |
errorMessage += "(Didn't write Jalview Archive to output file '" |
665 |
|
+ statefile + ")"; |
666 |
|
} |
667 |
0 |
e.printStackTrace(); |
668 |
|
} finally |
669 |
|
{ |
670 |
16 |
if (fos != null) |
671 |
|
{ |
672 |
16 |
try |
673 |
|
{ |
674 |
16 |
fos.close(); |
675 |
|
} catch (IOException e) |
676 |
|
{ |
677 |
|
|
678 |
|
} |
679 |
|
} |
680 |
|
} |
681 |
16 |
reportErrors(); |
682 |
|
} |
683 |
|
|
684 |
|
|
685 |
|
|
686 |
|
|
687 |
|
@param |
688 |
|
|
|
|
| 85% |
Uncovered Elements: 3 (20) |
Complexity: 5 |
Complexity Density: 0.36 |
|
689 |
16 |
public void saveState(JarOutputStream jout)... |
690 |
|
{ |
691 |
16 |
AlignFrame[] frames = Desktop.getDesktopAlignFrames(); |
692 |
|
|
693 |
16 |
setStateSavedUpToDate(true); |
694 |
|
|
695 |
16 |
if (Cache.getDefault("DEBUG_DELAY_SAVE", false)) |
696 |
|
{ |
697 |
2 |
int n = debugDelaySave; |
698 |
2 |
int i = 0; |
699 |
15 |
while (i < n) |
700 |
|
{ |
701 |
13 |
Console.debug("***** debugging save sleep " + i + "/" + n); |
702 |
13 |
try |
703 |
|
{ |
704 |
13 |
Thread.sleep(1000); |
705 |
|
} catch (InterruptedException e) |
706 |
|
{ |
707 |
|
|
708 |
0 |
e.printStackTrace(); |
709 |
|
} |
710 |
13 |
i++; |
711 |
|
} |
712 |
|
} |
713 |
|
|
714 |
16 |
if (frames == null) |
715 |
|
{ |
716 |
0 |
return; |
717 |
|
} |
718 |
16 |
saveAllFrames(Arrays.asList(frames), jout); |
719 |
|
} |
720 |
|
|
721 |
|
|
722 |
|
|
723 |
|
|
724 |
|
@param |
725 |
|
|
726 |
|
|
727 |
|
@param |
728 |
|
|
729 |
|
|
|
|
| 88.1% |
Uncovered Elements: 5 (42) |
Complexity: 11 |
Complexity Density: 0.39 |
|
730 |
24 |
private void saveAllFrames(List<AlignFrame> frames, JarOutputStream jout)... |
731 |
|
{ |
732 |
24 |
Hashtable<String, AlignFrame> dsses = new Hashtable<>(); |
733 |
|
|
734 |
|
|
735 |
|
|
736 |
|
|
737 |
|
|
738 |
24 |
rnaSessions.clear(); |
739 |
24 |
splitFrameCandidates.clear(); |
740 |
|
|
741 |
24 |
try |
742 |
|
{ |
743 |
|
|
744 |
|
|
745 |
|
|
746 |
|
|
747 |
24 |
List<String> shortNames = new ArrayList<>(); |
748 |
24 |
List<String> viewIds = new ArrayList<>(); |
749 |
|
|
750 |
|
|
751 |
51 |
for (int i = frames.size() - 1; i > -1; i--) |
752 |
|
{ |
753 |
28 |
AlignFrame af = frames.get(i); |
754 |
|
|
755 |
28 |
if (skipList != null && skipList |
756 |
|
.containsKey(af.getViewport().getSequenceSetId())) |
757 |
|
{ |
758 |
0 |
continue; |
759 |
|
} |
760 |
|
|
761 |
28 |
String shortName = makeFilename(af, shortNames); |
762 |
|
|
763 |
28 |
int apSize = af.getAlignPanels().size(); |
764 |
|
|
765 |
64 |
for (int ap = 0; ap < apSize; ap++) |
766 |
|
{ |
767 |
37 |
AlignmentPanel apanel = (AlignmentPanel) af.getAlignPanels() |
768 |
|
.get(ap); |
769 |
37 |
String fileName = apSize == 1 ? shortName : ap + shortName; |
770 |
37 |
if (!fileName.endsWith(".xml")) |
771 |
|
{ |
772 |
0 |
fileName = fileName + ".xml"; |
773 |
|
} |
774 |
|
|
775 |
37 |
saveState(apanel, fileName, jout, viewIds); |
776 |
|
|
777 |
36 |
String dssid = getDatasetIdRef( |
778 |
|
af.getViewport().getAlignment().getDataset()); |
779 |
36 |
if (!dsses.containsKey(dssid)) |
780 |
|
{ |
781 |
27 |
dsses.put(dssid, af); |
782 |
|
} |
783 |
|
} |
784 |
|
} |
785 |
|
|
786 |
23 |
writeDatasetFor(dsses, "" + jout.hashCode() + " " + uniqueSetSuffix, |
787 |
|
jout); |
788 |
|
|
789 |
23 |
try |
790 |
|
{ |
791 |
23 |
jout.flush(); |
792 |
|
} catch (Exception foo) |
793 |
|
{ |
794 |
|
} |
795 |
23 |
jout.close(); |
796 |
|
} catch (Exception ex) |
797 |
|
{ |
798 |
|
|
799 |
|
|
800 |
1 |
if (errorMessage == null) |
801 |
|
{ |
802 |
1 |
errorMessage = "Couldn't write Jalview Archive - see error output for details"; |
803 |
|
} |
804 |
1 |
ex.printStackTrace(); |
805 |
|
} |
806 |
|
} |
807 |
|
|
808 |
|
|
809 |
|
|
810 |
|
|
811 |
|
|
812 |
|
|
813 |
|
@param |
814 |
|
@param |
815 |
|
@return |
816 |
|
|
|
|
| 95.2% |
Uncovered Elements: 1 (21) |
Complexity: 5 |
Complexity Density: 0.38 |
|
817 |
28 |
protected String makeFilename(AlignFrame af, List<String> namesUsed)... |
818 |
|
{ |
819 |
28 |
String shortName = af.getTitle(); |
820 |
|
|
821 |
28 |
if (shortName.indexOf(File.separatorChar) > -1) |
822 |
|
{ |
823 |
12 |
shortName = shortName |
824 |
|
.substring(shortName.lastIndexOf(File.separatorChar) + 1); |
825 |
|
} |
826 |
|
|
827 |
28 |
int count = 1; |
828 |
|
|
829 |
38 |
while (namesUsed.contains(shortName)) |
830 |
|
{ |
831 |
10 |
if (shortName.endsWith("_" + (count - 1))) |
832 |
|
{ |
833 |
6 |
shortName = shortName.substring(0, shortName.lastIndexOf("_")); |
834 |
|
} |
835 |
|
|
836 |
10 |
shortName = shortName.concat("_" + count); |
837 |
10 |
count++; |
838 |
|
} |
839 |
|
|
840 |
28 |
namesUsed.add(shortName); |
841 |
|
|
842 |
28 |
if (!shortName.endsWith(".xml")) |
843 |
|
{ |
844 |
28 |
shortName = shortName + ".xml"; |
845 |
|
} |
846 |
28 |
return shortName; |
847 |
|
} |
848 |
|
|
849 |
|
|
|
|
| 61.9% |
Uncovered Elements: 16 (42) |
Complexity: 10 |
Complexity Density: 0.33 |
|
850 |
8 |
public boolean saveAlignment(AlignFrame af, String jarFile,... |
851 |
|
String fileName) |
852 |
|
{ |
853 |
8 |
try |
854 |
|
{ |
855 |
|
|
856 |
8 |
boolean doBackup = BackupFiles.getEnabled(); |
857 |
8 |
BackupFiles backupfiles = doBackup ? new BackupFiles(jarFile) : null; |
858 |
8 |
FileOutputStream fos = new FileOutputStream( |
859 |
8 |
doBackup ? backupfiles.getTempFilePath() : jarFile); |
860 |
|
|
861 |
8 |
if (Cache.getDefault("DEBUG_DELAY_SAVE", false)) |
862 |
|
{ |
863 |
0 |
int n = debugDelaySave; |
864 |
0 |
int i = 0; |
865 |
0 |
while (i < n) |
866 |
|
{ |
867 |
0 |
Console.debug("***** debugging save sleep " + i + "/" + n); |
868 |
0 |
try |
869 |
|
{ |
870 |
0 |
Thread.sleep(1000); |
871 |
|
} catch (InterruptedException e) |
872 |
|
{ |
873 |
|
|
874 |
0 |
e.printStackTrace(); |
875 |
|
} |
876 |
0 |
i++; |
877 |
|
} |
878 |
|
} |
879 |
|
|
880 |
8 |
JarOutputStream jout = new JarOutputStream(fos); |
881 |
8 |
List<AlignFrame> frames = new ArrayList<>(); |
882 |
|
|
883 |
|
|
884 |
8 |
if (af.getViewport().getCodingComplement() != null) |
885 |
|
{ |
886 |
0 |
frames = ((SplitFrame) af.getSplitViewContainer()).getAlignFrames(); |
887 |
|
} |
888 |
|
else |
889 |
|
{ |
890 |
8 |
frames.add(af); |
891 |
|
} |
892 |
8 |
saveAllFrames(frames, jout); |
893 |
8 |
try |
894 |
|
{ |
895 |
8 |
jout.flush(); |
896 |
|
} catch (Exception foo) |
897 |
|
{ |
898 |
|
} |
899 |
8 |
jout.close(); |
900 |
8 |
boolean success = true; |
901 |
|
|
902 |
8 |
if (doBackup) |
903 |
|
{ |
904 |
6 |
backupfiles.setWriteSuccess(success); |
905 |
6 |
success = backupfiles.rollBackupsAndRenameTempFile(); |
906 |
|
} |
907 |
|
|
908 |
8 |
return success; |
909 |
|
} catch (Exception ex) |
910 |
|
{ |
911 |
0 |
errorMessage = "Couldn't Write alignment view to Jalview Archive - see error output for details"; |
912 |
0 |
ex.printStackTrace(); |
913 |
0 |
return false; |
914 |
|
} |
915 |
|
} |
916 |
|
|
|
|
| 87.5% |
Uncovered Elements: 1 (8) |
Complexity: 2 |
Complexity Density: 0.33 |
|
917 |
23 |
private void writeDatasetFor(Hashtable<String, AlignFrame> dsses,... |
918 |
|
String fileName, JarOutputStream jout) |
919 |
|
{ |
920 |
|
|
921 |
23 |
for (String dssids : dsses.keySet()) |
922 |
|
{ |
923 |
27 |
AlignFrame _af = dsses.get(dssids); |
924 |
27 |
String jfileName = fileName + " Dataset for " + _af.getTitle(); |
925 |
27 |
if (!jfileName.endsWith(".xml")) |
926 |
|
{ |
927 |
27 |
jfileName = jfileName + ".xml"; |
928 |
|
} |
929 |
27 |
saveState(_af.alignPanel, jfileName, true, jout, null); |
930 |
|
} |
931 |
|
} |
932 |
|
|
933 |
|
|
934 |
|
|
935 |
|
|
936 |
|
|
937 |
|
@param |
938 |
|
|
939 |
|
@param |
940 |
|
|
941 |
|
@param |
942 |
|
|
943 |
|
@param |
944 |
|
@param |
945 |
|
|
946 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
947 |
47 |
public JalviewModel saveState(AlignmentPanel ap, String fileName,... |
948 |
|
JarOutputStream jout, List<String> viewIds) |
949 |
|
{ |
950 |
47 |
return saveState(ap, fileName, false, jout, viewIds); |
951 |
|
} |
952 |
|
|
953 |
|
|
954 |
|
|
955 |
|
|
956 |
|
|
957 |
|
@param |
958 |
|
|
959 |
|
@param |
960 |
|
|
961 |
|
@param |
962 |
|
|
963 |
|
|
964 |
|
@param |
965 |
|
|
966 |
|
@param |
967 |
|
|
968 |
|
|
|
|
| 88.1% |
Uncovered Elements: 73 (613) |
Complexity: 106 |
Complexity Density: 0.25 |
|
969 |
74 |
public JalviewModel saveState(AlignmentPanel ap, String fileName,... |
970 |
|
boolean storeDS, JarOutputStream jout, List<String> viewIds) |
971 |
|
{ |
972 |
74 |
if (viewIds == null) |
973 |
|
{ |
974 |
37 |
viewIds = new ArrayList<>(); |
975 |
|
} |
976 |
|
|
977 |
74 |
initSeqRefs(); |
978 |
|
|
979 |
74 |
List<UserColourScheme> userColours = new ArrayList<>(); |
980 |
|
|
981 |
74 |
AlignViewport av = ap.av; |
982 |
74 |
ViewportRanges vpRanges = av.getRanges(); |
983 |
|
|
984 |
73 |
final ObjectFactory objectFactory = new ObjectFactory(); |
985 |
73 |
JalviewModel object = objectFactory.createJalviewModel(); |
986 |
73 |
object.setVamsasModel(new VAMSAS()); |
987 |
|
|
988 |
|
|
989 |
73 |
try |
990 |
|
{ |
991 |
73 |
GregorianCalendar c = new GregorianCalendar(); |
992 |
73 |
DatatypeFactory datatypeFactory = DatatypeFactory.newInstance(); |
993 |
73 |
XMLGregorianCalendar now = datatypeFactory.newXMLGregorianCalendar(c); |
994 |
73 |
object.setCreationDate(now); |
995 |
|
} catch (DatatypeConfigurationException e) |
996 |
|
{ |
997 |
0 |
jalview.bin.Console.errPrintln("error writing date: " + e.toString()); |
998 |
|
} |
999 |
73 |
object.setVersion(Cache.getDefault("VERSION", "Development Build")); |
1000 |
|
|
1001 |
|
|
1002 |
|
|
1003 |
|
|
1004 |
|
|
1005 |
73 |
jalview.datamodel.AlignmentI rjal = av.getAlignment(), jal = rjal; |
1006 |
|
|
1007 |
73 |
if (av.hasHiddenRows()) |
1008 |
|
{ |
1009 |
19 |
rjal = jal.getHiddenSequences().getFullAlignment(); |
1010 |
|
} |
1011 |
|
|
1012 |
73 |
SequenceSet vamsasSet = new SequenceSet(); |
1013 |
73 |
Sequence vamsasSeq; |
1014 |
|
|
1015 |
|
|
1016 |
73 |
vamsasSet.setGapChar(jal.getGapCharacter() + ""); |
1017 |
|
|
1018 |
73 |
if (jal.getDataset() != null) |
1019 |
|
{ |
1020 |
|
|
1021 |
73 |
vamsasSet.setDatasetId(getDatasetIdRef(jal.getDataset())); |
1022 |
73 |
if (storeDS) |
1023 |
|
{ |
1024 |
|
|
1025 |
27 |
jal = jal.getDataset(); |
1026 |
27 |
rjal = jal; |
1027 |
|
} |
1028 |
|
} |
1029 |
73 |
if (jal.getProperties() != null) |
1030 |
|
{ |
1031 |
1 |
Enumeration en = jal.getProperties().keys(); |
1032 |
22 |
while (en.hasMoreElements()) |
1033 |
|
{ |
1034 |
21 |
String key = en.nextElement().toString(); |
1035 |
21 |
SequenceSetProperties ssp = new SequenceSetProperties(); |
1036 |
21 |
ssp.setKey(key); |
1037 |
21 |
ssp.setValue(jal.getProperties().get(key).toString()); |
1038 |
|
|
1039 |
21 |
vamsasSet.getSequenceSetProperties().add(ssp); |
1040 |
|
} |
1041 |
|
} |
1042 |
|
|
1043 |
73 |
JSeq jseq; |
1044 |
73 |
Set<String> calcIdSet = new HashSet<>(); |
1045 |
|
|
1046 |
73 |
HashMap<String, Sequence> vamsasSetIds = new HashMap<>(); |
1047 |
|
|
1048 |
73 |
for (final SequenceI jds : rjal.getSequences()) |
1049 |
|
{ |
1050 |
949 |
final SequenceI jdatasq = jds.getDatasetSequence() == null ? jds |
1051 |
|
: jds.getDatasetSequence(); |
1052 |
949 |
String id = seqHash(jds); |
1053 |
949 |
if (vamsasSetIds.get(id) == null) |
1054 |
|
{ |
1055 |
949 |
if (seqRefIds.get(id) != null && !storeDS) |
1056 |
|
{ |
1057 |
|
|
1058 |
|
|
1059 |
|
|
1060 |
|
|
1061 |
|
|
1062 |
|
|
1063 |
|
|
1064 |
|
|
1065 |
|
|
1066 |
|
|
1067 |
|
|
1068 |
|
|
1069 |
|
|
1070 |
|
|
1071 |
|
|
1072 |
|
} |
1073 |
|
else |
1074 |
|
{ |
1075 |
760 |
vamsasSeq = createVamsasSequence(id, jds); |
1076 |
|
|
1077 |
760 |
vamsasSet.getSequence().add(vamsasSeq); |
1078 |
760 |
vamsasSetIds.put(id, vamsasSeq); |
1079 |
760 |
seqRefIds.put(id, jds); |
1080 |
|
} |
1081 |
|
} |
1082 |
949 |
jseq = new JSeq(); |
1083 |
949 |
jseq.setStart(jds.getStart()); |
1084 |
949 |
jseq.setEnd(jds.getEnd()); |
1085 |
949 |
jseq.setColour(av.getSequenceColour(jds).getRGB()); |
1086 |
|
|
1087 |
949 |
jseq.setId(id); |
1088 |
949 |
if (!storeDS) |
1089 |
|
{ |
1090 |
|
|
1091 |
598 |
if (av.hasHiddenRows()) |
1092 |
|
{ |
1093 |
|
|
1094 |
190 |
jseq.setHidden( |
1095 |
|
av.getAlignment().getHiddenSequences().isHidden(jds)); |
1096 |
|
|
1097 |
190 |
if (av.isHiddenRepSequence(jds)) |
1098 |
|
{ |
1099 |
2 |
jalview.datamodel.SequenceI[] reps = av |
1100 |
|
.getRepresentedSequences(jds).getSequencesInOrder(rjal); |
1101 |
|
|
1102 |
6 |
for (int h = 0; h < reps.length; h++) |
1103 |
|
{ |
1104 |
4 |
if (reps[h] != jds) |
1105 |
|
{ |
1106 |
|
|
1107 |
2 |
jseq.getHiddenSequences().add(rjal.findIndex(reps[h])); |
1108 |
|
} |
1109 |
|
} |
1110 |
|
} |
1111 |
|
} |
1112 |
|
|
1113 |
598 |
if (jal.hasSeqrep()) |
1114 |
|
{ |
1115 |
80 |
jseq.setViewreference(jds == jal.getSeqrep()); |
1116 |
|
} |
1117 |
|
} |
1118 |
|
|
1119 |
|
|
1120 |
|
|
1121 |
949 |
List<SequenceFeature> sfs = jds.getSequenceFeatures(); |
1122 |
949 |
for (SequenceFeature sf : sfs) |
1123 |
|
{ |
1124 |
|
|
1125 |
10860 |
Feature features = new Feature(); |
1126 |
|
|
1127 |
10860 |
features.setBegin(sf.getBegin()); |
1128 |
10860 |
features.setEnd(sf.getEnd()); |
1129 |
10860 |
features.setDescription(sf.getDescription()); |
1130 |
10860 |
features.setType(sf.getType()); |
1131 |
10860 |
features.setFeatureGroup(sf.getFeatureGroup()); |
1132 |
10860 |
features.setScore(sf.getScore()); |
1133 |
10860 |
if (sf.links != null) |
1134 |
|
{ |
1135 |
5344 |
for (int l = 0; l < sf.links.size(); l++) |
1136 |
|
{ |
1137 |
2672 |
OtherData keyValue = new OtherData(); |
1138 |
2672 |
keyValue.setKey("LINK_" + l); |
1139 |
2672 |
keyValue.setValue(sf.links.elementAt(l).toString()); |
1140 |
|
|
1141 |
2672 |
features.getOtherData().add(keyValue); |
1142 |
|
} |
1143 |
|
} |
1144 |
10860 |
if (sf.otherDetails != null) |
1145 |
|
{ |
1146 |
|
|
1147 |
|
|
1148 |
|
|
1149 |
|
|
1150 |
3108 |
for (Entry<String, Object> entry : sf.otherDetails.entrySet()) |
1151 |
|
{ |
1152 |
3128 |
String key = entry.getKey(); |
1153 |
3128 |
Object value = entry.getValue(); |
1154 |
3128 |
if (value instanceof Map<?, ?>) |
1155 |
|
{ |
1156 |
20 |
for (Entry<String, Object> subAttribute : ((Map<String, Object>) value) |
1157 |
|
.entrySet()) |
1158 |
|
{ |
1159 |
20 |
OtherData otherData = new OtherData(); |
1160 |
20 |
otherData.setKey(key); |
1161 |
20 |
otherData.setKey2(subAttribute.getKey()); |
1162 |
20 |
otherData.setValue(subAttribute.getValue().toString()); |
1163 |
|
|
1164 |
20 |
features.getOtherData().add(otherData); |
1165 |
|
} |
1166 |
|
} |
1167 |
|
else |
1168 |
|
{ |
1169 |
3108 |
OtherData otherData = new OtherData(); |
1170 |
3108 |
otherData.setKey(key); |
1171 |
3108 |
otherData.setValue(value.toString()); |
1172 |
|
|
1173 |
3108 |
features.getOtherData().add(otherData); |
1174 |
|
} |
1175 |
|
} |
1176 |
|
} |
1177 |
|
|
1178 |
|
|
1179 |
10860 |
jseq.getFeatures().add(features); |
1180 |
|
} |
1181 |
|
|
1182 |
949 |
if (jdatasq.getAllPDBEntries() != null) |
1183 |
|
{ |
1184 |
949 |
Enumeration<PDBEntry> en = jdatasq.getAllPDBEntries().elements(); |
1185 |
1011 |
while (en.hasMoreElements()) |
1186 |
|
{ |
1187 |
62 |
Pdbids pdb = new Pdbids(); |
1188 |
62 |
jalview.datamodel.PDBEntry entry = en.nextElement(); |
1189 |
|
|
1190 |
62 |
String pdbId = entry.getId(); |
1191 |
62 |
pdb.setId(pdbId); |
1192 |
62 |
pdb.setType(entry.getType()); |
1193 |
|
|
1194 |
|
|
1195 |
|
|
1196 |
|
|
1197 |
|
|
1198 |
|
|
1199 |
|
|
1200 |
62 |
List<JalviewStructureDisplayI> viewFrames = new ArrayList<>(); |
1201 |
62 |
if (Desktop.desktop != null) |
1202 |
|
{ |
1203 |
62 |
JInternalFrame[] jifs = Desktop.desktop.getAllFrames(); |
1204 |
62 |
if (jifs != null) |
1205 |
|
{ |
1206 |
62 |
for (JInternalFrame jif : jifs) |
1207 |
|
{ |
1208 |
382 |
if (jif instanceof JalviewStructureDisplayI) |
1209 |
|
{ |
1210 |
48 |
viewFrames.add((JalviewStructureDisplayI) jif); |
1211 |
|
} |
1212 |
|
} |
1213 |
|
} |
1214 |
|
} |
1215 |
0 |
else if (Jalview.isHeadlessMode() |
1216 |
|
&& Jalview.getInstance().getCommands() != null) |
1217 |
|
{ |
1218 |
0 |
viewFrames.addAll( |
1219 |
|
StructureViewerBase.getAllStructureViewerBases()); |
1220 |
|
} |
1221 |
|
|
1222 |
62 |
String matchedFile = null; |
1223 |
62 |
for (JalviewStructureDisplayI viewFrame : viewFrames) |
1224 |
|
{ |
1225 |
48 |
matchedFile = saveStructureViewer(ap, jds, pdb, entry, viewIds, |
1226 |
|
matchedFile, viewFrame); |
1227 |
|
|
1228 |
|
|
1229 |
|
|
1230 |
|
|
1231 |
48 |
String viewId = viewFrame.getViewId(); |
1232 |
48 |
String viewerType = viewFrame.getViewerType().toString(); |
1233 |
48 |
if (!storeDS && !viewIds.contains(viewId)) |
1234 |
|
{ |
1235 |
2 |
viewIds.add(viewId); |
1236 |
2 |
File viewerState = viewFrame.saveSession(); |
1237 |
2 |
if (viewerState != null) |
1238 |
|
{ |
1239 |
2 |
copyFileToJar(jout, viewerState.getPath(), |
1240 |
|
getViewerJarEntryName(viewId), viewerType); |
1241 |
|
} |
1242 |
|
else |
1243 |
|
{ |
1244 |
0 |
Console.error( |
1245 |
|
"Failed to save viewer state for " + viewerType); |
1246 |
|
} |
1247 |
|
} |
1248 |
|
} |
1249 |
|
|
1250 |
62 |
if (matchedFile != null || entry.getFile() != null) |
1251 |
|
{ |
1252 |
46 |
if (entry.getFile() != null) |
1253 |
|
{ |
1254 |
|
|
1255 |
46 |
matchedFile = entry.getFile(); |
1256 |
|
} |
1257 |
46 |
pdb.setFile(matchedFile); |
1258 |
46 |
if (pdbfiles == null) |
1259 |
|
{ |
1260 |
4 |
pdbfiles = new ArrayList<>(); |
1261 |
|
} |
1262 |
|
|
1263 |
46 |
if (!pdbfiles.contains(pdbId)) |
1264 |
|
{ |
1265 |
4 |
pdbfiles.add(pdbId); |
1266 |
4 |
copyFileToJar(jout, matchedFile, pdbId, pdbId); |
1267 |
|
} |
1268 |
|
} |
1269 |
|
|
1270 |
62 |
Enumeration<String> props = entry.getProperties(); |
1271 |
62 |
if (props.hasMoreElements()) |
1272 |
|
{ |
1273 |
|
|
1274 |
92 |
while (props.hasMoreElements()) |
1275 |
|
{ |
1276 |
46 |
Property prop = new Property(); |
1277 |
46 |
String key = props.nextElement(); |
1278 |
46 |
prop.setName(key); |
1279 |
46 |
prop.setValue(entry.getProperty(key).toString()); |
1280 |
|
|
1281 |
46 |
pdb.getProperty().add(prop); |
1282 |
|
} |
1283 |
|
|
1284 |
|
} |
1285 |
|
|
1286 |
|
|
1287 |
62 |
jseq.getPdbids().add(pdb); |
1288 |
|
} |
1289 |
|
} |
1290 |
|
|
1291 |
949 |
saveRnaViewers(jout, jseq, jds, viewIds, ap, storeDS); |
1292 |
|
|
1293 |
|
|
1294 |
949 |
object.getJSeq().add(jseq); |
1295 |
|
} |
1296 |
|
|
1297 |
73 |
if (!storeDS && av.hasHiddenRows()) |
1298 |
|
{ |
1299 |
12 |
jal = av.getAlignment(); |
1300 |
|
} |
1301 |
|
|
1302 |
|
|
1303 |
73 |
if (storeDS && jal.getCodonFrames() != null) |
1304 |
|
{ |
1305 |
27 |
List<AlignedCodonFrame> jac = jal.getCodonFrames(); |
1306 |
27 |
for (AlignedCodonFrame acf : jac) |
1307 |
|
{ |
1308 |
0 |
AlcodonFrame alc = new AlcodonFrame(); |
1309 |
0 |
if (acf.getProtMappings() != null |
1310 |
|
&& acf.getProtMappings().length > 0) |
1311 |
|
{ |
1312 |
0 |
boolean hasMap = false; |
1313 |
0 |
SequenceI[] dnas = acf.getdnaSeqs(); |
1314 |
0 |
jalview.datamodel.Mapping[] pmaps = acf.getProtMappings(); |
1315 |
0 |
for (int m = 0; m < pmaps.length; m++) |
1316 |
|
{ |
1317 |
0 |
AlcodMap alcmap = new AlcodMap(); |
1318 |
0 |
alcmap.setDnasq(seqHash(dnas[m])); |
1319 |
0 |
alcmap.setMapping( |
1320 |
|
createVamsasMapping(pmaps[m], dnas[m], null, false)); |
1321 |
|
|
1322 |
0 |
alc.getAlcodMap().add(alcmap); |
1323 |
0 |
hasMap = true; |
1324 |
|
} |
1325 |
0 |
if (hasMap) |
1326 |
|
{ |
1327 |
|
|
1328 |
0 |
vamsasSet.getAlcodonFrame().add(alc); |
1329 |
|
} |
1330 |
|
} |
1331 |
|
|
1332 |
|
|
1333 |
|
|
1334 |
|
|
1335 |
|
|
1336 |
|
|
1337 |
|
|
1338 |
|
|
1339 |
|
|
1340 |
|
|
1341 |
|
|
1342 |
|
|
1343 |
|
|
1344 |
|
|
1345 |
|
|
1346 |
|
|
1347 |
|
|
1348 |
|
|
1349 |
|
|
1350 |
|
|
1351 |
|
|
1352 |
|
|
1353 |
|
|
1354 |
|
|
1355 |
|
|
1356 |
|
|
1357 |
|
|
1358 |
|
|
1359 |
|
|
1360 |
|
|
1361 |
|
|
1362 |
|
} |
1363 |
|
} |
1364 |
|
|
1365 |
|
|
1366 |
|
|
1367 |
73 |
if (!storeDS && av.getCurrentTree() != null) |
1368 |
|
{ |
1369 |
|
|
1370 |
|
|
1371 |
4 |
if (Desktop.desktop != null) |
1372 |
|
{ |
1373 |
4 |
JInternalFrame[] frames = Desktop.desktop.getAllFrames(); |
1374 |
|
|
1375 |
25 |
for (int t = 0; t < frames.length; t++) |
1376 |
|
{ |
1377 |
21 |
if (frames[t] instanceof TreePanel) |
1378 |
|
{ |
1379 |
4 |
TreePanel tp = (TreePanel) frames[t]; |
1380 |
|
|
1381 |
4 |
if (tp.getTreeCanvas().getViewport().getAlignment() == jal) |
1382 |
|
{ |
1383 |
4 |
JalviewModel.Tree tree = new JalviewModel.Tree(); |
1384 |
4 |
tree.setTitle(tp.getTitle()); |
1385 |
4 |
tree.setCurrentTree((av.getCurrentTree() == tp.getTree())); |
1386 |
4 |
tree.setNewick(tp.getTree().print()); |
1387 |
4 |
tree.setThreshold(tp.getTreeCanvas().getThreshold()); |
1388 |
|
|
1389 |
4 |
tree.setFitToWindow(tp.fitToWindow.getState()); |
1390 |
4 |
tree.setFontName(tp.getTreeFont().getName()); |
1391 |
4 |
tree.setFontSize(tp.getTreeFont().getSize()); |
1392 |
4 |
tree.setFontStyle(tp.getTreeFont().getStyle()); |
1393 |
4 |
tree.setMarkUnlinked(tp.placeholdersMenu.getState()); |
1394 |
|
|
1395 |
4 |
tree.setShowBootstrap(tp.bootstrapMenu.getState()); |
1396 |
4 |
tree.setShowDistances(tp.distanceMenu.getState()); |
1397 |
|
|
1398 |
4 |
tree.setHeight(tp.getHeight()); |
1399 |
4 |
tree.setWidth(tp.getWidth()); |
1400 |
4 |
tree.setXpos(tp.getX()); |
1401 |
4 |
tree.setYpos(tp.getY()); |
1402 |
4 |
tree.setId(makeHashCode(tp, null)); |
1403 |
4 |
tree.setLinkToAllViews( |
1404 |
|
tp.getTreeCanvas().isApplyToAllViews()); |
1405 |
|
|
1406 |
|
|
1407 |
4 |
if (tp.isColumnWise()) |
1408 |
|
{ |
1409 |
0 |
tree.setColumnWise(true); |
1410 |
0 |
String annId = tp.getAssocAnnotation().annotationId; |
1411 |
0 |
tree.setColumnReference(annId); |
1412 |
|
} |
1413 |
|
|
1414 |
4 |
object.getTree().add(tree); |
1415 |
|
} |
1416 |
|
} |
1417 |
|
} |
1418 |
|
} |
1419 |
|
} |
1420 |
|
|
1421 |
|
|
1422 |
|
|
1423 |
|
|
1424 |
73 |
if (!storeDS && Desktop.desktop != null) |
1425 |
|
{ |
1426 |
44 |
for (JInternalFrame frame : Desktop.desktop.getAllFrames()) |
1427 |
|
{ |
1428 |
140 |
if (frame instanceof PCAPanel) |
1429 |
|
{ |
1430 |
5 |
PCAPanel panel = (PCAPanel) frame; |
1431 |
5 |
if (panel.getAlignViewport().getAlignment() == jal) |
1432 |
|
{ |
1433 |
1 |
savePCA(panel, object); |
1434 |
|
} |
1435 |
|
} |
1436 |
140 |
if (frame instanceof PaSiMapPanel) |
1437 |
|
{ |
1438 |
0 |
PaSiMapPanel panel = (PaSiMapPanel) frame; |
1439 |
0 |
if (panel.getAlignViewport().getAlignment() == jal) |
1440 |
|
{ |
1441 |
0 |
savePaSiMap(panel, object); |
1442 |
|
} |
1443 |
|
} |
1444 |
|
} |
1445 |
|
} |
1446 |
|
|
1447 |
|
|
1448 |
|
|
1449 |
|
|
1450 |
|
|
1451 |
73 |
IdentityHashMap<SequenceGroup, String> groupRefs = new IdentityHashMap<>(); |
1452 |
73 |
if (storeDS) |
1453 |
|
{ |
1454 |
27 |
for (SequenceI sq : jal.getSequences()) |
1455 |
|
{ |
1456 |
|
|
1457 |
351 |
AlignmentAnnotation[] aa = sq.getAnnotation(); |
1458 |
351 |
if (aa != null && aa.length > 0) |
1459 |
|
{ |
1460 |
82 |
storeAlignmentAnnotation(aa, groupRefs, av, calcIdSet, storeDS, |
1461 |
|
vamsasSet); |
1462 |
|
} |
1463 |
|
} |
1464 |
|
} |
1465 |
|
else |
1466 |
|
{ |
1467 |
46 |
if (jal.getAlignmentAnnotation() != null) |
1468 |
|
{ |
1469 |
|
|
1470 |
46 |
AlignmentAnnotation[] aa = jal.getAlignmentAnnotation(); |
1471 |
46 |
storeAlignmentAnnotation(aa, groupRefs, av, calcIdSet, storeDS, |
1472 |
|
vamsasSet); |
1473 |
|
} |
1474 |
|
} |
1475 |
|
|
1476 |
73 |
if (jal.getGroups() != null) |
1477 |
|
{ |
1478 |
73 |
JGroup[] groups = new JGroup[jal.getGroups().size()]; |
1479 |
73 |
int i = -1; |
1480 |
73 |
for (jalview.datamodel.SequenceGroup sg : jal.getGroups()) |
1481 |
|
{ |
1482 |
15 |
JGroup jGroup = new JGroup(); |
1483 |
15 |
groups[++i] = jGroup; |
1484 |
|
|
1485 |
15 |
jGroup.setStart(sg.getStartRes()); |
1486 |
15 |
jGroup.setEnd(sg.getEndRes()); |
1487 |
15 |
jGroup.setName(sg.getName()); |
1488 |
15 |
if (groupRefs.containsKey(sg)) |
1489 |
|
{ |
1490 |
|
|
1491 |
6 |
jGroup.setId(groupRefs.get(sg)); |
1492 |
|
} |
1493 |
15 |
ColourSchemeI colourScheme = sg.getColourScheme(); |
1494 |
15 |
if (colourScheme != null) |
1495 |
|
{ |
1496 |
9 |
ResidueShaderI groupColourScheme = sg.getGroupColourScheme(); |
1497 |
9 |
if (groupColourScheme.conservationApplied()) |
1498 |
|
{ |
1499 |
2 |
jGroup.setConsThreshold(groupColourScheme.getConservationInc()); |
1500 |
|
|
1501 |
2 |
if (colourScheme instanceof jalview.schemes.UserColourScheme) |
1502 |
|
{ |
1503 |
0 |
jGroup.setColour(setUserColourScheme(colourScheme, |
1504 |
|
userColours, object)); |
1505 |
|
} |
1506 |
|
else |
1507 |
|
{ |
1508 |
2 |
jGroup.setColour(colourScheme.getSchemeName()); |
1509 |
|
} |
1510 |
|
} |
1511 |
7 |
else if (colourScheme instanceof jalview.schemes.AnnotationColourGradient) |
1512 |
|
{ |
1513 |
1 |
jGroup.setColour("AnnotationColourGradient"); |
1514 |
1 |
jGroup.setAnnotationColours(constructAnnotationColours( |
1515 |
|
(jalview.schemes.AnnotationColourGradient) colourScheme, |
1516 |
|
userColours, object)); |
1517 |
|
} |
1518 |
6 |
else if (colourScheme instanceof jalview.schemes.UserColourScheme) |
1519 |
|
{ |
1520 |
0 |
jGroup.setColour( |
1521 |
|
setUserColourScheme(colourScheme, userColours, object)); |
1522 |
|
} |
1523 |
|
else |
1524 |
|
{ |
1525 |
6 |
jGroup.setColour(colourScheme.getSchemeName()); |
1526 |
|
} |
1527 |
|
|
1528 |
9 |
jGroup.setPidThreshold(groupColourScheme.getThreshold()); |
1529 |
|
} |
1530 |
|
|
1531 |
15 |
jGroup.setOutlineColour(sg.getOutlineColour().getRGB()); |
1532 |
15 |
jGroup.setDisplayBoxes(sg.getDisplayBoxes()); |
1533 |
15 |
jGroup.setDisplayText(sg.getDisplayText()); |
1534 |
15 |
jGroup.setColourText(sg.getColourText()); |
1535 |
15 |
jGroup.setTextCol1(sg.textColour.getRGB()); |
1536 |
15 |
jGroup.setTextCol2(sg.textColour2.getRGB()); |
1537 |
15 |
jGroup.setTextColThreshold(sg.thresholdTextColour); |
1538 |
15 |
jGroup.setShowUnconserved(sg.getShowNonconserved()); |
1539 |
15 |
jGroup.setIgnoreGapsinConsensus(sg.getIgnoreGapsConsensus()); |
1540 |
15 |
jGroup.setShowConsensusHistogram(sg.isShowConsensusHistogram()); |
1541 |
15 |
jGroup.setShowSequenceLogo(sg.isShowSequenceLogo()); |
1542 |
15 |
jGroup.setNormaliseSequenceLogo(sg.isNormaliseSequenceLogo()); |
1543 |
15 |
for (SequenceI seq : sg.getSequences()) |
1544 |
|
{ |
1545 |
|
|
1546 |
114 |
jGroup.getSeq().add(seqHash(seq)); |
1547 |
|
} |
1548 |
|
} |
1549 |
|
|
1550 |
|
|
1551 |
73 |
Object group; |
1552 |
73 |
for (JGroup grp : groups) |
1553 |
|
{ |
1554 |
15 |
object.getJGroup().add(grp); |
1555 |
|
} |
1556 |
|
} |
1557 |
73 |
if (!storeDS) |
1558 |
|
{ |
1559 |
|
|
1560 |
46 |
Viewport view = new Viewport(); |
1561 |
46 |
view.setTitle(ap.alignFrame.getTitle()); |
1562 |
46 |
view.setSequenceSetId( |
1563 |
|
makeHashCode(av.getSequenceSetId(), av.getSequenceSetId())); |
1564 |
46 |
view.setId(av.getViewId()); |
1565 |
46 |
if (av.getCodingComplement() != null) |
1566 |
|
{ |
1567 |
0 |
view.setComplementId(av.getCodingComplement().getViewId()); |
1568 |
|
} |
1569 |
46 |
view.setViewName(av.getViewName()); |
1570 |
46 |
view.setGatheredViews(av.isGatherViewsHere()); |
1571 |
|
|
1572 |
46 |
Rectangle size = ap.av.getExplodedGeometry(); |
1573 |
46 |
Rectangle position = size; |
1574 |
46 |
if (size == null) |
1575 |
|
{ |
1576 |
36 |
size = ap.alignFrame.getBounds(); |
1577 |
36 |
if (av.getCodingComplement() != null) |
1578 |
|
{ |
1579 |
0 |
position = ((SplitFrame) ap.alignFrame.getSplitViewContainer()) |
1580 |
|
.getBounds(); |
1581 |
|
} |
1582 |
|
else |
1583 |
|
{ |
1584 |
36 |
position = size; |
1585 |
|
} |
1586 |
|
} |
1587 |
46 |
view.setXpos(position.x); |
1588 |
46 |
view.setYpos(position.y); |
1589 |
|
|
1590 |
46 |
view.setWidth(size.width); |
1591 |
46 |
view.setHeight(size.height); |
1592 |
|
|
1593 |
46 |
view.setStartRes(vpRanges.getStartRes()); |
1594 |
46 |
view.setStartSeq(vpRanges.getStartSeq()); |
1595 |
|
|
1596 |
46 |
OverviewPanel ov = ap.getOverviewPanel(); |
1597 |
46 |
if (ov != null) |
1598 |
|
{ |
1599 |
14 |
Overview overview = new Overview(); |
1600 |
14 |
overview.setTitle(ov.getTitle()); |
1601 |
14 |
Rectangle bounds = ov.getFrameBounds(); |
1602 |
14 |
overview.setXpos(bounds.x); |
1603 |
14 |
overview.setYpos(bounds.y); |
1604 |
14 |
overview.setWidth(bounds.width); |
1605 |
14 |
overview.setHeight(bounds.height); |
1606 |
14 |
overview.setShowHidden(ov.isShowHiddenRegions()); |
1607 |
14 |
overview.setGapColour(ov.getCanvas().getGapColour().getRGB()); |
1608 |
14 |
overview.setResidueColour( |
1609 |
|
ov.getCanvas().getResidueColour().getRGB()); |
1610 |
14 |
overview.setHiddenColour(ov.getCanvas().getHiddenColour().getRGB()); |
1611 |
14 |
view.setOverview(overview); |
1612 |
|
} |
1613 |
46 |
if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme) |
1614 |
|
{ |
1615 |
0 |
view.setBgColour(setUserColourScheme(av.getGlobalColourScheme(), |
1616 |
|
userColours, object)); |
1617 |
|
} |
1618 |
46 |
else if (av |
1619 |
|
.getGlobalColourScheme() instanceof jalview.schemes.AnnotationColourGradient) |
1620 |
|
{ |
1621 |
2 |
AnnotationColourScheme ac = constructAnnotationColours( |
1622 |
|
(jalview.schemes.AnnotationColourGradient) av |
1623 |
|
.getGlobalColourScheme(), |
1624 |
|
userColours, object); |
1625 |
|
|
1626 |
2 |
view.setAnnotationColours(ac); |
1627 |
2 |
view.setBgColour("AnnotationColourGradient"); |
1628 |
|
} |
1629 |
|
else |
1630 |
|
{ |
1631 |
44 |
view.setBgColour(ColourSchemeProperty |
1632 |
|
.getColourName(av.getGlobalColourScheme())); |
1633 |
|
} |
1634 |
|
|
1635 |
46 |
ResidueShaderI vcs = av.getResidueShading(); |
1636 |
46 |
ColourSchemeI cs = av.getGlobalColourScheme(); |
1637 |
|
|
1638 |
46 |
if (cs != null) |
1639 |
|
{ |
1640 |
8 |
if (vcs.conservationApplied()) |
1641 |
|
{ |
1642 |
2 |
view.setConsThreshold(vcs.getConservationInc()); |
1643 |
2 |
if (cs instanceof jalview.schemes.UserColourScheme) |
1644 |
|
{ |
1645 |
0 |
view.setBgColour(setUserColourScheme(cs, userColours, object)); |
1646 |
|
} |
1647 |
|
} |
1648 |
8 |
view.setPidThreshold(vcs.getThreshold()); |
1649 |
|
} |
1650 |
|
|
1651 |
46 |
view.setConservationSelected(av.getConservationSelected()); |
1652 |
46 |
view.setPidSelected(av.getAbovePIDThreshold()); |
1653 |
46 |
view.setCharHeight(av.getCharHeight()); |
1654 |
46 |
view.setCharWidth(av.getCharWidth()); |
1655 |
46 |
final Font font = av.getFont(); |
1656 |
46 |
view.setFontName(font.getName()); |
1657 |
46 |
view.setFontSize(font.getSize()); |
1658 |
46 |
view.setFontStyle(font.getStyle()); |
1659 |
46 |
view.setScaleProteinAsCdna(av.getViewStyle().isScaleProteinAsCdna()); |
1660 |
46 |
view.setRenderGaps(av.isRenderGaps()); |
1661 |
46 |
view.setShowAnnotation(av.isShowAnnotation()); |
1662 |
46 |
view.setShowBoxes(av.getShowBoxes()); |
1663 |
46 |
view.setShowColourText(av.getColourText()); |
1664 |
46 |
view.setShowFullId(av.getShowJVSuffix()); |
1665 |
46 |
view.setRightAlignIds(av.isRightAlignIds()); |
1666 |
46 |
view.setIdWidth(av.getIdWidth()); |
1667 |
46 |
view.setIdWidthManuallyAdjusted( |
1668 |
|
ap.getIdPanel().getIdCanvas().isManuallyAdjusted()); |
1669 |
|
|
1670 |
46 |
view.setShowSequenceFeatures(av.isShowSequenceFeatures()); |
1671 |
46 |
view.setShowText(av.getShowText()); |
1672 |
46 |
view.setShowUnconserved(av.getShowUnconserved()); |
1673 |
46 |
view.setWrapAlignment(av.getWrapAlignment()); |
1674 |
46 |
view.setTextCol1(av.getTextColour().getRGB()); |
1675 |
46 |
view.setTextCol2(av.getTextColour2().getRGB()); |
1676 |
46 |
view.setTextColThreshold(av.getThresholdTextColour()); |
1677 |
46 |
view.setShowConsensusHistogram(av.isShowConsensusHistogram()); |
1678 |
46 |
view.setShowSequenceLogo(av.isShowSequenceLogo()); |
1679 |
46 |
view.setNormaliseSequenceLogo(av.isNormaliseSequenceLogo()); |
1680 |
46 |
view.setShowGroupConsensus(av.isShowGroupConsensus()); |
1681 |
46 |
view.setShowGroupConservation(av.isShowGroupConservation()); |
1682 |
46 |
view.setShowNPfeatureTooltip(av.isShowNPFeats()); |
1683 |
46 |
view.setShowDbRefTooltip(av.isShowDBRefs()); |
1684 |
46 |
view.setFollowHighlight(av.isFollowHighlight()); |
1685 |
46 |
view.setFollowSelection(av.followSelection); |
1686 |
46 |
view.setIgnoreGapsinConsensus(av.isIgnoreGapsConsensus()); |
1687 |
46 |
view.setShowComplementFeatures(av.isShowComplementFeatures()); |
1688 |
46 |
view.setShowComplementFeaturesOnTop( |
1689 |
|
av.isShowComplementFeaturesOnTop()); |
1690 |
46 |
if (av.getFeaturesDisplayed() != null) |
1691 |
|
{ |
1692 |
11 |
FeatureSettings fs = new FeatureSettings(); |
1693 |
|
|
1694 |
11 |
FeatureRendererModel fr = ap.getSeqPanel().seqCanvas |
1695 |
|
.getFeatureRenderer(); |
1696 |
11 |
String[] renderOrder = fr.getRenderOrder().toArray(new String[0]); |
1697 |
|
|
1698 |
11 |
Vector<String> settingsAdded = new Vector<>(); |
1699 |
11 |
if (renderOrder != null) |
1700 |
|
{ |
1701 |
11 |
for (String featureType : renderOrder) |
1702 |
|
{ |
1703 |
191 |
FeatureSettings.Setting setting = new FeatureSettings.Setting(); |
1704 |
191 |
setting.setType(featureType); |
1705 |
|
|
1706 |
|
|
1707 |
|
|
1708 |
|
|
1709 |
191 |
FeatureMatcherSetI filter = fr.getFeatureFilter(featureType); |
1710 |
191 |
if (filter != null) |
1711 |
|
{ |
1712 |
3 |
Iterator<FeatureMatcherI> filters = filter.getMatchers() |
1713 |
|
.iterator(); |
1714 |
3 |
FeatureMatcherI firstFilter = filters.next(); |
1715 |
3 |
setting.setMatcherSet(Jalview2XML.marshalFilter(firstFilter, |
1716 |
|
filters, filter.isAnded())); |
1717 |
|
} |
1718 |
|
|
1719 |
|
|
1720 |
|
|
1721 |
|
|
1722 |
191 |
FeatureColourI fcol = fr.getFeatureStyle(featureType); |
1723 |
191 |
if (!fcol.isSimpleColour()) |
1724 |
|
{ |
1725 |
4 |
setting.setColour(fcol.getMaxColour().getRGB()); |
1726 |
4 |
setting.setMincolour(fcol.getMinColour().getRGB()); |
1727 |
4 |
setting.setMin(fcol.getMin()); |
1728 |
4 |
setting.setMax(fcol.getMax()); |
1729 |
4 |
setting.setColourByLabel(fcol.isColourByLabel()); |
1730 |
4 |
if (fcol.isColourByAttribute()) |
1731 |
|
{ |
1732 |
2 |
String[] attName = fcol.getAttributeName(); |
1733 |
2 |
setting.getAttributeName().add(attName[0]); |
1734 |
2 |
if (attName.length > 1) |
1735 |
|
{ |
1736 |
1 |
setting.getAttributeName().add(attName[1]); |
1737 |
|
} |
1738 |
|
} |
1739 |
4 |
setting.setAutoScale(fcol.isAutoScaled()); |
1740 |
4 |
setting.setThreshold(fcol.getThreshold()); |
1741 |
4 |
Color noColour = fcol.getNoColour(); |
1742 |
4 |
if (noColour == null) |
1743 |
|
{ |
1744 |
4 |
setting.setNoValueColour(NoValueColour.NONE); |
1745 |
|
} |
1746 |
0 |
else if (noColour.equals(fcol.getMaxColour())) |
1747 |
|
{ |
1748 |
0 |
setting.setNoValueColour(NoValueColour.MAX); |
1749 |
|
} |
1750 |
|
else |
1751 |
|
{ |
1752 |
0 |
setting.setNoValueColour(NoValueColour.MIN); |
1753 |
|
} |
1754 |
|
|
1755 |
4 |
setting.setThreshstate(fcol.isAboveThreshold() ? 1 |
1756 |
3 |
: (fcol.isBelowThreshold() ? 0 : -1)); |
1757 |
|
} |
1758 |
|
else |
1759 |
|
{ |
1760 |
187 |
setting.setColour(fcol.getColour().getRGB()); |
1761 |
|
} |
1762 |
|
|
1763 |
191 |
setting.setDisplay( |
1764 |
|
av.getFeaturesDisplayed().isVisible(featureType)); |
1765 |
191 |
float rorder = fr.getOrder(featureType); |
1766 |
191 |
if (rorder > -1) |
1767 |
|
{ |
1768 |
191 |
setting.setOrder(rorder); |
1769 |
|
} |
1770 |
|
|
1771 |
191 |
fs.getSetting().add(setting); |
1772 |
191 |
settingsAdded.addElement(featureType); |
1773 |
|
} |
1774 |
|
} |
1775 |
|
|
1776 |
|
|
1777 |
11 |
Iterator<String> en = fr.getFeatureGroups().iterator(); |
1778 |
11 |
Vector<String> groupsAdded = new Vector<>(); |
1779 |
44 |
while (en.hasNext()) |
1780 |
|
{ |
1781 |
33 |
String grp = en.next(); |
1782 |
33 |
if (groupsAdded.contains(grp)) |
1783 |
|
{ |
1784 |
0 |
continue; |
1785 |
|
} |
1786 |
33 |
Group g = new Group(); |
1787 |
33 |
g.setName(grp); |
1788 |
33 |
g.setDisplay(((Boolean) fr.checkGroupVisibility(grp, false)) |
1789 |
|
.booleanValue()); |
1790 |
|
|
1791 |
33 |
fs.getGroup().add(g); |
1792 |
33 |
groupsAdded.addElement(grp); |
1793 |
|
} |
1794 |
|
|
1795 |
11 |
object.setFeatureSettings(fs); |
1796 |
|
} |
1797 |
|
|
1798 |
46 |
if (av.hasHiddenColumns()) |
1799 |
|
{ |
1800 |
4 |
jalview.datamodel.HiddenColumns hidden = av.getAlignment() |
1801 |
|
.getHiddenColumns(); |
1802 |
4 |
if (hidden == null) |
1803 |
|
{ |
1804 |
0 |
Console.warn( |
1805 |
|
"REPORT BUG: avoided null columnselection bug (DMAM reported). Please contact Jim about this."); |
1806 |
|
} |
1807 |
|
else |
1808 |
|
{ |
1809 |
4 |
Iterator<int[]> hiddenRegions = hidden.iterator(); |
1810 |
10 |
while (hiddenRegions.hasNext()) |
1811 |
|
{ |
1812 |
6 |
int[] region = hiddenRegions.next(); |
1813 |
6 |
HiddenColumns hc = new HiddenColumns(); |
1814 |
6 |
hc.setStart(region[0]); |
1815 |
6 |
hc.setEnd(region[1]); |
1816 |
|
|
1817 |
6 |
view.getHiddenColumns().add(hc); |
1818 |
|
} |
1819 |
|
} |
1820 |
|
} |
1821 |
46 |
if (calcIdSet.size() > 0) |
1822 |
|
{ |
1823 |
46 |
for (String calcId : calcIdSet) |
1824 |
|
{ |
1825 |
55 |
if (calcId.trim().length() > 0) |
1826 |
|
{ |
1827 |
9 |
CalcIdParam cidp = createCalcIdParam(calcId, av); |
1828 |
|
|
1829 |
9 |
if (cidp != null) |
1830 |
|
{ |
1831 |
|
|
1832 |
0 |
view.getCalcIdParam().add(cidp); |
1833 |
|
} |
1834 |
|
} |
1835 |
|
} |
1836 |
|
} |
1837 |
|
|
1838 |
|
|
1839 |
46 |
object.getViewport().add(view); |
1840 |
|
} |
1841 |
|
|
1842 |
73 |
if (storeDS) |
1843 |
|
{ |
1844 |
|
|
1845 |
27 |
if (xmlMatrices != null && xmlMatrices.size() > 0) |
1846 |
|
{ |
1847 |
2 |
Console.debug( |
1848 |
|
"Adding " + xmlMatrices.size() + " matrices to dataset."); |
1849 |
2 |
vamsasSet.getMatrix().addAll(xmlMatrices); |
1850 |
2 |
xmlMatrices.clear(); |
1851 |
|
} |
1852 |
|
} |
1853 |
|
|
1854 |
|
|
1855 |
|
|
1856 |
73 |
object.getVamsasModel().getSequenceSet().add(vamsasSet); |
1857 |
|
|
1858 |
73 |
if (jout != null && fileName != null) |
1859 |
|
{ |
1860 |
|
|
1861 |
|
|
1862 |
|
|
1863 |
63 |
try |
1864 |
|
{ |
1865 |
63 |
fileName = fileName.replace('\\', '/'); |
1866 |
63 |
jalview.bin.Console.outPrintln("Writing jar entry " + fileName); |
1867 |
63 |
JarEntry entry = new JarEntry(fileName); |
1868 |
63 |
jout.putNextEntry(entry); |
1869 |
59 |
PrintWriter pout = new PrintWriter( |
1870 |
|
new OutputStreamWriter(jout, UTF_8)); |
1871 |
59 |
JAXBContext jaxbContext = JAXBContext |
1872 |
|
.newInstance(JalviewModel.class); |
1873 |
59 |
Marshaller jaxbMarshaller = jaxbContext.createMarshaller(); |
1874 |
|
|
1875 |
|
|
1876 |
|
|
1877 |
59 |
jaxbMarshaller.marshal( |
1878 |
|
new ObjectFactory().createJalviewModel(object), pout); |
1879 |
|
|
1880 |
|
|
1881 |
|
|
1882 |
59 |
pout.flush(); |
1883 |
59 |
jout.closeEntry(); |
1884 |
|
} catch (Exception ex) |
1885 |
|
{ |
1886 |
|
|
1887 |
4 |
jalview.bin.Console.errPrintln("Error writing Jalview project"); |
1888 |
4 |
ex.printStackTrace(); |
1889 |
|
} |
1890 |
|
} |
1891 |
73 |
return object; |
1892 |
|
} |
1893 |
|
|
1894 |
|
|
1895 |
|
|
1896 |
|
|
1897 |
|
|
|
|
| 98.3% |
Uncovered Elements: 1 (60) |
Complexity: 2 |
Complexity Density: 0.03 |
|
1898 |
1 |
protected void savePCA(PCAPanel panel, JalviewModel object)... |
1899 |
|
{ |
1900 |
1 |
try |
1901 |
|
{ |
1902 |
1 |
PcaViewer viewer = new PcaViewer(); |
1903 |
1 |
viewer.setHeight(panel.getHeight()); |
1904 |
1 |
viewer.setWidth(panel.getWidth()); |
1905 |
1 |
viewer.setXpos(panel.getX()); |
1906 |
1 |
viewer.setYpos(panel.getY()); |
1907 |
1 |
viewer.setTitle(panel.getTitle()); |
1908 |
1 |
PCAModel pcaModel = panel.getPcaModel(); |
1909 |
1 |
viewer.setScoreModelName(pcaModel.getScoreModelName()); |
1910 |
1 |
viewer.setXDim(panel.getSelectedDimensionIndex(X)); |
1911 |
1 |
viewer.setYDim(panel.getSelectedDimensionIndex(Y)); |
1912 |
1 |
viewer.setZDim(panel.getSelectedDimensionIndex(Z)); |
1913 |
1 |
viewer.setBgColour( |
1914 |
|
panel.getRotatableCanvas().getBackgroundColour().getRGB()); |
1915 |
1 |
viewer.setScaleFactor(panel.getRotatableCanvas().getScaleFactor()); |
1916 |
1 |
float[] spMin = panel.getRotatableCanvas().getSeqMin(); |
1917 |
1 |
SeqPointMin spmin = new SeqPointMin(); |
1918 |
1 |
spmin.setXPos(spMin[0]); |
1919 |
1 |
spmin.setYPos(spMin[1]); |
1920 |
1 |
spmin.setZPos(spMin[2]); |
1921 |
1 |
viewer.setSeqPointMin(spmin); |
1922 |
1 |
float[] spMax = panel.getRotatableCanvas().getSeqMax(); |
1923 |
1 |
SeqPointMax spmax = new SeqPointMax(); |
1924 |
1 |
spmax.setXPos(spMax[0]); |
1925 |
1 |
spmax.setYPos(spMax[1]); |
1926 |
1 |
spmax.setZPos(spMax[2]); |
1927 |
1 |
viewer.setSeqPointMax(spmax); |
1928 |
1 |
viewer.setShowLabels(panel.getRotatableCanvas().isShowLabels()); |
1929 |
1 |
viewer.setLinkToAllViews( |
1930 |
|
panel.getRotatableCanvas().isApplyToAllViews()); |
1931 |
1 |
SimilarityParamsI sp = pcaModel.getSimilarityParameters(); |
1932 |
1 |
viewer.setIncludeGaps(sp.includeGaps()); |
1933 |
1 |
viewer.setMatchGaps(sp.matchGaps()); |
1934 |
1 |
viewer.setIncludeGappedColumns(sp.includeGappedColumns()); |
1935 |
1 |
viewer.setDenominateByShortestLength(sp.denominateByShortestLength()); |
1936 |
|
|
1937 |
|
|
1938 |
|
|
1939 |
|
|
1940 |
1 |
for (jalview.datamodel.SequencePoint spt : pcaModel |
1941 |
|
.getSequencePoints()) |
1942 |
|
{ |
1943 |
15 |
SequencePoint point = new SequencePoint(); |
1944 |
15 |
point.setSequenceRef(seqHash(spt.getSequence())); |
1945 |
15 |
point.setXPos(spt.coord.x); |
1946 |
15 |
point.setYPos(spt.coord.y); |
1947 |
15 |
point.setZPos(spt.coord.z); |
1948 |
15 |
viewer.getSequencePoint().add(point); |
1949 |
|
} |
1950 |
|
|
1951 |
|
|
1952 |
|
|
1953 |
|
|
1954 |
1 |
for (Point p : panel.getRotatableCanvas().getAxisEndPoints()) |
1955 |
|
{ |
1956 |
|
|
1957 |
3 |
Axis axis = new Axis(); |
1958 |
3 |
axis.setXPos(p.x); |
1959 |
3 |
axis.setYPos(p.y); |
1960 |
3 |
axis.setZPos(p.z); |
1961 |
3 |
viewer.getAxis().add(axis); |
1962 |
|
} |
1963 |
|
|
1964 |
|
|
1965 |
|
|
1966 |
|
|
1967 |
|
|
1968 |
1 |
PcaDataType data = new PcaDataType(); |
1969 |
1 |
viewer.setPcaData(data); |
1970 |
1 |
PCA pca = pcaModel.getPcaData(); |
1971 |
|
|
1972 |
1 |
DoubleMatrix pm = new DoubleMatrix(); |
1973 |
1 |
saveDoubleMatrix(pca.getPairwiseScores(), pm); |
1974 |
1 |
data.setPairwiseMatrix(pm); |
1975 |
|
|
1976 |
1 |
DoubleMatrix tm = new DoubleMatrix(); |
1977 |
1 |
saveDoubleMatrix(pca.getTridiagonal(), tm); |
1978 |
1 |
data.setTridiagonalMatrix(tm); |
1979 |
|
|
1980 |
1 |
DoubleMatrix eigenMatrix = new DoubleMatrix(); |
1981 |
1 |
data.setEigenMatrix(eigenMatrix); |
1982 |
1 |
saveDoubleMatrix(pca.getEigenmatrix(), eigenMatrix); |
1983 |
|
|
1984 |
1 |
object.getPcaViewer().add(viewer); |
1985 |
|
} catch (Throwable t) |
1986 |
|
{ |
1987 |
0 |
Console.error("Error saving PCA: " + t.getMessage()); |
1988 |
|
} |
1989 |
|
} |
1990 |
|
|
1991 |
|
|
1992 |
|
|
1993 |
|
|
1994 |
|
|
1995 |
|
|
|
|
| 0% |
Uncovered Elements: 52 (52) |
Complexity: 2 |
Complexity Density: 0.04 |
|
1996 |
0 |
protected void savePaSiMap(PaSiMapPanel panel, JalviewModel object)... |
1997 |
|
{ |
1998 |
|
|
1999 |
|
|
2000 |
0 |
try |
2001 |
|
{ |
2002 |
0 |
PcaViewer viewer = new PcaViewer(); |
2003 |
0 |
viewer.setHeight(panel.getHeight()); |
2004 |
0 |
viewer.setWidth(panel.getWidth()); |
2005 |
0 |
viewer.setXpos(panel.getX()); |
2006 |
0 |
viewer.setYpos(panel.getY()); |
2007 |
0 |
viewer.setTitle(panel.getTitle()); |
2008 |
0 |
PaSiMapModel pasimapModel = panel.getPasimapModel(); |
2009 |
0 |
viewer.setScoreModelName(pasimapModel.getScoreModelName()); |
2010 |
0 |
viewer.setXDim(panel.getSelectedDimensionIndex(X)); |
2011 |
0 |
viewer.setYDim(panel.getSelectedDimensionIndex(Y)); |
2012 |
0 |
viewer.setZDim(panel.getSelectedDimensionIndex(Z)); |
2013 |
0 |
viewer.setBgColour( |
2014 |
|
panel.getRotatableCanvas().getBackgroundColour().getRGB()); |
2015 |
0 |
viewer.setScaleFactor(panel.getRotatableCanvas().getScaleFactor()); |
2016 |
0 |
float[] spMin = panel.getRotatableCanvas().getSeqMin(); |
2017 |
0 |
SeqPointMin spmin = new SeqPointMin(); |
2018 |
0 |
spmin.setXPos(spMin[0]); |
2019 |
0 |
spmin.setYPos(spMin[1]); |
2020 |
0 |
spmin.setZPos(spMin[2]); |
2021 |
0 |
viewer.setSeqPointMin(spmin); |
2022 |
0 |
float[] spMax = panel.getRotatableCanvas().getSeqMax(); |
2023 |
0 |
SeqPointMax spmax = new SeqPointMax(); |
2024 |
0 |
spmax.setXPos(spMax[0]); |
2025 |
0 |
spmax.setYPos(spMax[1]); |
2026 |
0 |
spmax.setZPos(spMax[2]); |
2027 |
0 |
viewer.setSeqPointMax(spmax); |
2028 |
0 |
viewer.setShowLabels(panel.getRotatableCanvas().isShowLabels()); |
2029 |
0 |
viewer.setLinkToAllViews( |
2030 |
|
panel.getRotatableCanvas().isApplyToAllViews()); |
2031 |
|
|
2032 |
|
|
2033 |
|
|
2034 |
|
|
2035 |
|
|
2036 |
|
|
2037 |
|
|
2038 |
|
|
2039 |
|
|
2040 |
|
|
2041 |
|
|
2042 |
|
|
2043 |
0 |
for (jalview.datamodel.SequencePoint spt : pasimapModel |
2044 |
|
.getSequencePoints()) |
2045 |
|
{ |
2046 |
0 |
SequencePoint point = new SequencePoint(); |
2047 |
0 |
point.setSequenceRef(seqHash(spt.getSequence())); |
2048 |
0 |
point.setXPos(spt.coord.x); |
2049 |
0 |
point.setYPos(spt.coord.y); |
2050 |
0 |
point.setZPos(spt.coord.z); |
2051 |
0 |
viewer.getSequencePoint().add(point); |
2052 |
|
} |
2053 |
|
|
2054 |
|
|
2055 |
|
|
2056 |
|
|
2057 |
0 |
for (Point p : panel.getRotatableCanvas().getAxisEndPoints()) |
2058 |
|
{ |
2059 |
|
|
2060 |
0 |
Axis axis = new Axis(); |
2061 |
0 |
axis.setXPos(p.x); |
2062 |
0 |
axis.setYPos(p.y); |
2063 |
0 |
axis.setZPos(p.z); |
2064 |
0 |
viewer.getAxis().add(axis); |
2065 |
|
} |
2066 |
|
|
2067 |
|
|
2068 |
|
|
2069 |
|
|
2070 |
|
|
2071 |
0 |
PcaDataType data = new PcaDataType(); |
2072 |
0 |
viewer.setPcaData(data); |
2073 |
0 |
PaSiMap pasimap = pasimapModel.getPasimapData(); |
2074 |
|
|
2075 |
0 |
DoubleMatrix pm = new DoubleMatrix(); |
2076 |
0 |
saveDoubleMatrix(pasimap.getPairwiseScores(), pm); |
2077 |
0 |
data.setPairwiseMatrix(pm); |
2078 |
|
|
2079 |
0 |
DoubleMatrix eigenMatrix = new DoubleMatrix(); |
2080 |
0 |
data.setEigenMatrix(eigenMatrix); |
2081 |
0 |
saveDoubleMatrix(pasimap.getEigenmatrix(), eigenMatrix); |
2082 |
|
|
2083 |
0 |
object.getPcaViewer().add(viewer); |
2084 |
|
} catch (Throwable t) |
2085 |
|
{ |
2086 |
0 |
Console.error("Error saving PaSiMap: " + t.getMessage()); |
2087 |
|
} |
2088 |
|
} |
2089 |
|
|
2090 |
|
|
2091 |
|
|
2092 |
|
|
2093 |
|
|
2094 |
|
@param |
2095 |
|
@param |
2096 |
|
@see |
2097 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (25) |
Complexity: 5 |
Complexity Density: 0.29 |
|
2098 |
3 |
protected void saveDoubleMatrix(MatrixI m, DoubleMatrix xmlMatrix)... |
2099 |
|
{ |
2100 |
3 |
xmlMatrix.setRows(m.height()); |
2101 |
3 |
xmlMatrix.setColumns(m.width()); |
2102 |
48 |
for (int i = 0; i < m.height(); i++) |
2103 |
|
{ |
2104 |
45 |
DoubleVector row = new DoubleVector(); |
2105 |
720 |
for (int j = 0; j < m.width(); j++) |
2106 |
|
{ |
2107 |
675 |
row.getV().add(m.getValue(i, j)); |
2108 |
|
} |
2109 |
45 |
xmlMatrix.getRow().add(row); |
2110 |
|
} |
2111 |
3 |
if (m.getD() != null) |
2112 |
|
{ |
2113 |
2 |
DoubleVector dVector = new DoubleVector(); |
2114 |
2 |
for (double d : m.getD()) |
2115 |
|
{ |
2116 |
30 |
dVector.getV().add(d); |
2117 |
|
} |
2118 |
2 |
xmlMatrix.setD(dVector); |
2119 |
|
} |
2120 |
3 |
if (m.getE() != null) |
2121 |
|
{ |
2122 |
2 |
DoubleVector eVector = new DoubleVector(); |
2123 |
2 |
for (double e : m.getE()) |
2124 |
|
{ |
2125 |
30 |
eVector.getV().add(e); |
2126 |
|
} |
2127 |
2 |
xmlMatrix.setE(eVector); |
2128 |
|
} |
2129 |
|
} |
2130 |
|
|
2131 |
|
|
2132 |
|
|
2133 |
|
|
2134 |
|
|
2135 |
|
@param |
2136 |
|
@return |
2137 |
|
@see |
2138 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (30) |
Complexity: 4 |
Complexity Density: 0.17 |
|
2139 |
3 |
protected MatrixI loadDoubleMatrix(DoubleMatrix mData)... |
2140 |
|
{ |
2141 |
3 |
int rows = mData.getRows(); |
2142 |
3 |
double[][] vals = new double[rows][]; |
2143 |
|
|
2144 |
48 |
for (int i = 0; i < rows; i++) |
2145 |
|
{ |
2146 |
45 |
List<Double> dVector = mData.getRow().get(i).getV(); |
2147 |
45 |
vals[i] = new double[dVector.size()]; |
2148 |
45 |
int dvi = 0; |
2149 |
45 |
for (Double d : dVector) |
2150 |
|
{ |
2151 |
675 |
vals[i][dvi++] = d; |
2152 |
|
} |
2153 |
|
} |
2154 |
|
|
2155 |
3 |
MatrixI m = new Matrix(vals); |
2156 |
|
|
2157 |
3 |
if (mData.getD() != null) |
2158 |
|
{ |
2159 |
2 |
List<Double> dVector = mData.getD().getV(); |
2160 |
2 |
double[] vec = new double[dVector.size()]; |
2161 |
2 |
int dvi = 0; |
2162 |
2 |
for (Double d : dVector) |
2163 |
|
{ |
2164 |
30 |
vec[dvi++] = d; |
2165 |
|
} |
2166 |
2 |
m.setD(vec); |
2167 |
|
} |
2168 |
3 |
if (mData.getE() != null) |
2169 |
|
{ |
2170 |
2 |
List<Double> dVector = mData.getE().getV(); |
2171 |
2 |
double[] vec = new double[dVector.size()]; |
2172 |
2 |
int dvi = 0; |
2173 |
2 |
for (Double d : dVector) |
2174 |
|
{ |
2175 |
30 |
vec[dvi++] = d; |
2176 |
|
} |
2177 |
2 |
m.setE(vec); |
2178 |
|
} |
2179 |
|
|
2180 |
3 |
return m; |
2181 |
|
} |
2182 |
|
|
2183 |
|
|
2184 |
|
|
2185 |
|
|
2186 |
|
|
2187 |
|
|
2188 |
|
|
2189 |
|
|
2190 |
|
|
2191 |
|
|
2192 |
|
|
2193 |
|
|
2194 |
|
|
2195 |
|
|
2196 |
|
|
2197 |
|
|
2198 |
|
|
2199 |
|
|
2200 |
|
@param |
2201 |
|
@param |
2202 |
|
@param |
2203 |
|
@param |
2204 |
|
@param |
2205 |
|
@param |
2206 |
|
|
|
|
| 22.2% |
Uncovered Elements: 35 (45) |
Complexity: 8 |
Complexity Density: 0.24 |
|
2207 |
949 |
protected void saveRnaViewers(JarOutputStream jout, JSeq jseq,... |
2208 |
|
final SequenceI jds, List<String> viewIds, AlignmentPanel ap, |
2209 |
|
boolean storeDataset) |
2210 |
|
{ |
2211 |
949 |
if (Desktop.desktop == null) |
2212 |
|
{ |
2213 |
60 |
return; |
2214 |
|
} |
2215 |
889 |
JInternalFrame[] frames = Desktop.desktop.getAllFrames(); |
2216 |
4259 |
for (int f = frames.length - 1; f > -1; f--) |
2217 |
|
{ |
2218 |
3370 |
if (frames[f] instanceof AppVarna) |
2219 |
|
{ |
2220 |
0 |
AppVarna varna = (AppVarna) frames[f]; |
2221 |
|
|
2222 |
|
|
2223 |
|
|
2224 |
|
|
2225 |
0 |
if (varna.isListeningFor(jds) && ap == varna.getAlignmentPanel()) |
2226 |
|
{ |
2227 |
0 |
String viewId = varna.getViewId(); |
2228 |
0 |
RnaViewer rna = new RnaViewer(); |
2229 |
0 |
rna.setViewId(viewId); |
2230 |
0 |
rna.setTitle(varna.getTitle()); |
2231 |
0 |
rna.setXpos(varna.getX()); |
2232 |
0 |
rna.setYpos(varna.getY()); |
2233 |
0 |
rna.setWidth(varna.getWidth()); |
2234 |
0 |
rna.setHeight(varna.getHeight()); |
2235 |
0 |
rna.setDividerLocation(varna.getDividerLocation()); |
2236 |
0 |
rna.setSelectedRna(varna.getSelectedIndex()); |
2237 |
|
|
2238 |
0 |
jseq.getRnaViewer().add(rna); |
2239 |
|
|
2240 |
|
|
2241 |
|
|
2242 |
|
|
2243 |
|
|
2244 |
|
|
2245 |
|
|
2246 |
|
|
2247 |
|
|
2248 |
|
|
2249 |
|
|
2250 |
|
|
2251 |
0 |
for (RnaModel model : varna.getModels()) |
2252 |
|
{ |
2253 |
0 |
if (model.seq == jds) |
2254 |
|
{ |
2255 |
|
|
2256 |
|
|
2257 |
|
|
2258 |
|
|
2259 |
0 |
String jarEntryName = rnaSessions.get(model); |
2260 |
0 |
if (jarEntryName == null) |
2261 |
|
{ |
2262 |
|
|
2263 |
0 |
String varnaStateFile = varna.getStateInfo(model.rna); |
2264 |
0 |
jarEntryName = RNA_PREFIX + viewId + "_" + nextCounter(); |
2265 |
0 |
copyFileToJar(jout, varnaStateFile, jarEntryName, "Varna"); |
2266 |
0 |
rnaSessions.put(model, jarEntryName); |
2267 |
|
} |
2268 |
0 |
SecondaryStructure ss = new SecondaryStructure(); |
2269 |
0 |
String annotationId = varna.getAnnotation(jds).annotationId; |
2270 |
0 |
ss.setAnnotationId(annotationId); |
2271 |
0 |
ss.setViewerState(jarEntryName); |
2272 |
0 |
ss.setGapped(model.gapped); |
2273 |
0 |
ss.setTitle(model.title); |
2274 |
|
|
2275 |
0 |
rna.getSecondaryStructure().add(ss); |
2276 |
|
} |
2277 |
|
} |
2278 |
|
} |
2279 |
|
} |
2280 |
|
} |
2281 |
|
} |
2282 |
|
|
2283 |
|
|
2284 |
|
|
2285 |
|
|
2286 |
|
@param |
2287 |
|
@param |
2288 |
|
@param |
2289 |
|
@param |
2290 |
|
|
2291 |
|
|
|
|
| 81.8% |
Uncovered Elements: 2 (11) |
Complexity: 6 |
Complexity Density: 0.67 |
|
2292 |
6 |
protected void copyFileToJar(JarOutputStream jout, String infilePath,... |
2293 |
|
String jarEntryName, String msg) |
2294 |
|
{ |
2295 |
6 |
try (InputStream is = new FileInputStream(infilePath)) |
2296 |
|
{ |
2297 |
6 |
File file = new File(infilePath); |
2298 |
6 |
if (file.exists() && jout != null) |
2299 |
|
{ |
2300 |
6 |
jalview.bin.Console.outPrintln( |
2301 |
|
"Writing jar entry " + jarEntryName + " (" + msg + ")"); |
2302 |
6 |
jout.putNextEntry(new JarEntry(jarEntryName)); |
2303 |
6 |
copyAll(is, jout); |
2304 |
6 |
jout.closeEntry(); |
2305 |
|
|
2306 |
|
|
2307 |
|
|
2308 |
|
|
2309 |
|
} |
2310 |
|
} catch (Exception ex) |
2311 |
|
{ |
2312 |
0 |
ex.printStackTrace(); |
2313 |
|
} |
2314 |
|
} |
2315 |
|
|
2316 |
|
|
2317 |
|
|
2318 |
|
|
2319 |
|
@param |
2320 |
|
@param |
2321 |
|
@throws |
2322 |
|
|
|
|
| 66.7% |
Uncovered Elements: 2 (6) |
Complexity: 2 |
Complexity Density: 0.5 |
|
2323 |
23 |
protected void copyAll(InputStream in, OutputStream out)... |
2324 |
|
throws IOException |
2325 |
|
{ |
2326 |
23 |
byte[] buffer = new byte[4096]; |
2327 |
23 |
int bytesRead = 0; |
2328 |
? |
while ((bytesRead = in.read(buffer)) != -1) |
2329 |
|
{ |
2330 |
820 |
out.write(buffer, 0, bytesRead); |
2331 |
|
} |
2332 |
|
} |
2333 |
|
|
2334 |
|
|
2335 |
|
|
2336 |
|
|
2337 |
|
@param |
2338 |
|
@param |
2339 |
|
@param |
2340 |
|
|
2341 |
|
@param |
2342 |
|
@param |
2343 |
|
@param |
2344 |
|
@param |
2345 |
|
@return |
2346 |
|
|
|
|
| 86.8% |
Uncovered Elements: 5 (38) |
Complexity: 9 |
Complexity Density: 0.35 |
|
2347 |
48 |
protected String saveStructureViewer(AlignmentPanel ap, SequenceI jds,... |
2348 |
|
Pdbids pdb, PDBEntry entry, List<String> viewIds, |
2349 |
|
String matchedFile, JalviewStructureDisplayI viewFrame) |
2350 |
|
{ |
2351 |
48 |
final AAStructureBindingModel bindingModel = viewFrame.getBinding(); |
2352 |
|
|
2353 |
|
|
2354 |
|
|
2355 |
|
|
2356 |
|
|
2357 |
96 |
for (int peid = 0; peid < bindingModel.getPdbCount(); peid++) |
2358 |
|
{ |
2359 |
48 |
final PDBEntry pdbentry = bindingModel.getPdbEntry(peid); |
2360 |
48 |
final String pdbId = pdbentry.getId(); |
2361 |
48 |
if (!pdbId.equals(entry.getId()) && !(entry.getId().length() > 4 |
2362 |
|
&& entry.getId().toLowerCase(Locale.ROOT) |
2363 |
|
.startsWith(pdbId.toLowerCase(Locale.ROOT)))) |
2364 |
|
{ |
2365 |
|
|
2366 |
|
|
2367 |
|
|
2368 |
16 |
continue; |
2369 |
|
} |
2370 |
32 |
if (matchedFile == null) |
2371 |
|
{ |
2372 |
32 |
matchedFile = pdbentry.getFile(); |
2373 |
|
} |
2374 |
0 |
else if (!matchedFile.equals(pdbentry.getFile())) |
2375 |
|
{ |
2376 |
0 |
Console.warn( |
2377 |
|
"Probably lost some PDB-Sequence mappings for this structure file (which apparently has same PDB Entry code): " |
2378 |
|
+ pdbentry.getFile()); |
2379 |
|
} |
2380 |
|
|
2381 |
|
|
2382 |
|
|
2383 |
|
|
2384 |
|
|
2385 |
|
|
2386 |
96 |
for (int smap = 0; smap < viewFrame.getBinding() |
2387 |
|
.getSequence()[peid].length; smap++) |
2388 |
|
{ |
2389 |
|
|
2390 |
64 |
if (jds == viewFrame.getBinding().getSequence()[peid][smap]) |
2391 |
|
{ |
2392 |
20 |
StructureState state = new StructureState(); |
2393 |
20 |
state.setVisible(true); |
2394 |
20 |
state.setXpos(viewFrame.getY()); |
2395 |
20 |
state.setYpos(viewFrame.getY()); |
2396 |
20 |
state.setWidth(viewFrame.getWidth()); |
2397 |
20 |
state.setHeight(viewFrame.getHeight()); |
2398 |
20 |
final String viewId = viewFrame.getViewId(); |
2399 |
20 |
state.setViewId(viewId); |
2400 |
20 |
state.setAlignwithAlignPanel(viewFrame.isUsedforaligment(ap)); |
2401 |
20 |
state.setColourwithAlignPanel(viewFrame.isUsedForColourBy(ap)); |
2402 |
20 |
state.setColourByJmol(viewFrame.isColouredByViewer()); |
2403 |
20 |
state.setType(viewFrame.getViewerType().toString()); |
2404 |
|
|
2405 |
20 |
pdb.getStructureState().add(state); |
2406 |
|
} |
2407 |
|
} |
2408 |
|
} |
2409 |
48 |
return matchedFile; |
2410 |
|
} |
2411 |
|
|
2412 |
|
|
2413 |
|
|
2414 |
|
|
2415 |
|
|
2416 |
|
@param |
2417 |
|
@param |
2418 |
|
@param |
2419 |
|
@return |
2420 |
|
|
|
|
| 85.7% |
Uncovered Elements: 2 (14) |
Complexity: 2 |
Complexity Density: 0.17 |
|
2421 |
3 |
private AnnotationColourScheme constructAnnotationColours(... |
2422 |
|
AnnotationColourGradient acg, List<UserColourScheme> userColours, |
2423 |
|
JalviewModel jm) |
2424 |
|
{ |
2425 |
3 |
AnnotationColourScheme ac = new AnnotationColourScheme(); |
2426 |
3 |
ac.setAboveThreshold(acg.getAboveThreshold()); |
2427 |
3 |
ac.setThreshold(acg.getAnnotationThreshold()); |
2428 |
|
|
2429 |
3 |
ac.setAnnotation(acg.getAnnotation().annotationId); |
2430 |
3 |
if (acg.getBaseColour() instanceof UserColourScheme) |
2431 |
|
{ |
2432 |
0 |
ac.setColourScheme( |
2433 |
|
setUserColourScheme(acg.getBaseColour(), userColours, jm)); |
2434 |
|
} |
2435 |
|
else |
2436 |
|
{ |
2437 |
3 |
ac.setColourScheme( |
2438 |
|
ColourSchemeProperty.getColourName(acg.getBaseColour())); |
2439 |
|
} |
2440 |
|
|
2441 |
3 |
ac.setMaxColour(acg.getMaxColour().getRGB()); |
2442 |
3 |
ac.setMinColour(acg.getMinColour().getRGB()); |
2443 |
3 |
ac.setPerSequence(acg.isSeqAssociated()); |
2444 |
3 |
ac.setPredefinedColours(acg.isPredefinedColours()); |
2445 |
3 |
return ac; |
2446 |
|
} |
2447 |
|
|
|
|
| 89.3% |
Uncovered Elements: 13 (122) |
Complexity: 32 |
Complexity Density: 0.43 |
|
2448 |
128 |
private void storeAlignmentAnnotation(AlignmentAnnotation[] aa,... |
2449 |
|
IdentityHashMap<SequenceGroup, String> groupRefs, |
2450 |
|
AlignmentViewport av, Set<String> calcIdSet, boolean storeDS, |
2451 |
|
SequenceSet vamsasSet) |
2452 |
|
{ |
2453 |
|
|
2454 |
569 |
for (int i = 0; i < aa.length; i++) |
2455 |
|
{ |
2456 |
441 |
Annotation an = new Annotation(); |
2457 |
|
|
2458 |
441 |
AlignmentAnnotation annotation = aa[i]; |
2459 |
441 |
if (annotation.annotationId != null) |
2460 |
|
{ |
2461 |
441 |
annotationIds.put(annotation.annotationId, annotation); |
2462 |
|
} |
2463 |
|
|
2464 |
441 |
an.setId(annotation.annotationId); |
2465 |
|
|
2466 |
441 |
an.setVisible(annotation.visible); |
2467 |
|
|
2468 |
441 |
an.setDescription(annotation.description); |
2469 |
|
|
2470 |
441 |
if (annotation.sequenceRef != null) |
2471 |
|
{ |
2472 |
|
|
2473 |
229 |
an.setSequenceRef(seqsToIds.get(annotation.sequenceRef)); |
2474 |
|
} |
2475 |
441 |
if (annotation.groupRef != null) |
2476 |
|
{ |
2477 |
6 |
String groupIdr = groupRefs.get(annotation.groupRef); |
2478 |
6 |
if (groupIdr == null) |
2479 |
|
{ |
2480 |
|
|
2481 |
6 |
groupRefs.put(annotation.groupRef, |
2482 |
|
groupIdr = ("" + System.currentTimeMillis() |
2483 |
|
+ annotation.groupRef.getName() |
2484 |
|
+ groupRefs.size())); |
2485 |
|
} |
2486 |
6 |
an.setGroupRef(groupIdr.toString()); |
2487 |
|
} |
2488 |
|
|
2489 |
|
|
2490 |
441 |
an.setGraphHeight(annotation.graphHeight); |
2491 |
441 |
an.setCentreColLabels(annotation.centreColLabels); |
2492 |
441 |
an.setScaleColLabels(annotation.scaleColLabel); |
2493 |
441 |
an.setShowAllColLabels(annotation.showAllColLabels); |
2494 |
441 |
an.setBelowAlignment(annotation.belowAlignment); |
2495 |
|
|
2496 |
441 |
if (annotation.graph > 0) |
2497 |
|
{ |
2498 |
277 |
an.setGraph(true); |
2499 |
277 |
an.setGraphType(annotation.graph); |
2500 |
277 |
an.setGraphGroup(annotation.graphGroup); |
2501 |
277 |
if (annotation.getThreshold() != null) |
2502 |
|
{ |
2503 |
30 |
ThresholdLine line = new ThresholdLine(); |
2504 |
30 |
line.setLabel(annotation.getThreshold().label); |
2505 |
30 |
line.setValue(annotation.getThreshold().value); |
2506 |
30 |
line.setColour(annotation.getThreshold().colour.getRGB()); |
2507 |
30 |
an.setThresholdLine(line); |
2508 |
|
} |
2509 |
277 |
if (annotation.graph == AlignmentAnnotation.CONTACT_MAP) |
2510 |
|
{ |
2511 |
9 |
if (annotation.sequenceRef.getContactMaps() != null) |
2512 |
|
{ |
2513 |
9 |
ContactMatrixI cm = annotation.sequenceRef |
2514 |
|
.getContactMatrixFor(annotation); |
2515 |
9 |
if (cm != null) |
2516 |
|
{ |
2517 |
9 |
storeMatrixFor(vamsasSet, an, annotation, cm); |
2518 |
|
} |
2519 |
|
} |
2520 |
|
} |
2521 |
|
} |
2522 |
|
else |
2523 |
|
{ |
2524 |
164 |
an.setGraph(false); |
2525 |
|
} |
2526 |
|
|
2527 |
441 |
an.setLabel(annotation.label); |
2528 |
|
|
2529 |
441 |
if (annotation == av.getAlignmentQualityAnnot() |
2530 |
|
|| annotation == av.getAlignmentConservationAnnotation() |
2531 |
|
|| annotation == av.getAlignmentConsensusAnnotation() |
2532 |
|
|| annotation.autoCalculated) |
2533 |
|
{ |
2534 |
|
|
2535 |
187 |
an.setAutoCalculated(annotation.autoCalculated); |
2536 |
|
} |
2537 |
441 |
if (annotation.hasScore()) |
2538 |
|
{ |
2539 |
139 |
an.setScore(annotation.getScore()); |
2540 |
|
} |
2541 |
|
|
2542 |
441 |
if (annotation.getCalcId() != null) |
2543 |
|
{ |
2544 |
417 |
calcIdSet.add(annotation.getCalcId()); |
2545 |
417 |
an.setCalcId(annotation.getCalcId()); |
2546 |
|
} |
2547 |
441 |
if (annotation.hasProperties()) |
2548 |
|
{ |
2549 |
0 |
for (String pr : annotation.getProperties()) |
2550 |
|
{ |
2551 |
0 |
jalview.xml.binding.jalview.Property prop = new jalview.xml.binding.jalview.Property(); |
2552 |
0 |
prop.setName(pr); |
2553 |
0 |
prop.setValue(annotation.getProperty(pr)); |
2554 |
0 |
an.getProperty().add(prop); |
2555 |
|
} |
2556 |
|
} |
2557 |
|
|
2558 |
441 |
AnnotationElement ae; |
2559 |
441 |
if (annotation.annotations != null) |
2560 |
|
{ |
2561 |
441 |
an.setScoreOnly(false); |
2562 |
53547 |
for (int a = 0; a < annotation.annotations.length; a++) |
2563 |
|
{ |
2564 |
53106 |
if ((annotation == null) || (annotation.annotations[a] == null)) |
2565 |
|
{ |
2566 |
8653 |
continue; |
2567 |
|
} |
2568 |
|
|
2569 |
44453 |
ae = new AnnotationElement(); |
2570 |
44453 |
if (annotation.annotations[a].description != null) |
2571 |
|
{ |
2572 |
39965 |
ae.setDescription(annotation.annotations[a].description); |
2573 |
|
} |
2574 |
44453 |
if (annotation.annotations[a].displayCharacter != null) |
2575 |
|
{ |
2576 |
40287 |
ae.setDisplayCharacter( |
2577 |
|
annotation.annotations[a].displayCharacter); |
2578 |
|
} |
2579 |
|
|
2580 |
44453 |
if (!Float.isNaN(annotation.annotations[a].value)) |
2581 |
|
{ |
2582 |
42749 |
ae.setValue(annotation.annotations[a].value); |
2583 |
|
} |
2584 |
|
|
2585 |
44453 |
ae.setPosition(a); |
2586 |
44453 |
if (annotation.annotations[a].secondaryStructure > ' ') |
2587 |
|
{ |
2588 |
6548 |
ae.setSecondaryStructure( |
2589 |
|
annotation.annotations[a].secondaryStructure + ""); |
2590 |
|
} |
2591 |
|
|
2592 |
44453 |
if (annotation.annotations[a].colour != null |
2593 |
|
&& annotation.annotations[a].colour != java.awt.Color.black) |
2594 |
|
{ |
2595 |
23753 |
ae.setColour(annotation.annotations[a].colour.getRGB()); |
2596 |
|
} |
2597 |
|
|
2598 |
|
|
2599 |
44453 |
an.getAnnotationElement().add(ae); |
2600 |
44453 |
if (annotation.autoCalculated) |
2601 |
|
{ |
2602 |
|
|
2603 |
|
|
2604 |
|
|
2605 |
23057 |
continue; |
2606 |
|
} |
2607 |
|
} |
2608 |
|
} |
2609 |
|
else |
2610 |
|
{ |
2611 |
0 |
an.setScoreOnly(true); |
2612 |
|
} |
2613 |
441 |
if (!storeDS || (storeDS && !annotation.autoCalculated)) |
2614 |
|
{ |
2615 |
|
|
2616 |
|
|
2617 |
|
|
2618 |
441 |
vamsasSet.getAnnotation().add(an); |
2619 |
|
} |
2620 |
|
} |
2621 |
|
|
2622 |
|
} |
2623 |
|
|
|
|
| 91.1% |
Uncovered Elements: 5 (56) |
Complexity: 7 |
Complexity Density: 0.16 |
|
2624 |
9 |
private void storeMatrixFor(SequenceSet root, Annotation an,... |
2625 |
|
AlignmentAnnotation annotation, ContactMatrixI cm) |
2626 |
|
{ |
2627 |
9 |
String cmId = contactMatrices.get(cm); |
2628 |
9 |
MatrixType xmlmat = null; |
2629 |
|
|
2630 |
|
|
2631 |
9 |
if (cmId == null) |
2632 |
|
{ |
2633 |
3 |
xmlmat = new MatrixType(); |
2634 |
3 |
xmlmat.setType(cm.getType()); |
2635 |
3 |
xmlmat.setRows(BigInteger.valueOf(cm.getWidth())); |
2636 |
3 |
xmlmat.setCols(BigInteger.valueOf(cm.getHeight())); |
2637 |
|
|
2638 |
|
|
2639 |
3 |
xmlmat.setElements(ContactMatrix.contactToFloatString(cm)); |
2640 |
3 |
if (cm.hasGroups()) |
2641 |
|
{ |
2642 |
3 |
for (BitSet gp : cm.getGroups()) |
2643 |
|
{ |
2644 |
9 |
xmlmat.getGroups().add(stringifyBitset(gp)); |
2645 |
|
} |
2646 |
|
} |
2647 |
3 |
if (cm.hasTree()) |
2648 |
|
{ |
2649 |
|
|
2650 |
3 |
xmlmat.getNewick().add(cm.getNewick()); |
2651 |
3 |
xmlmat.setTreeMethod(cm.getTreeMethod()); |
2652 |
|
} |
2653 |
3 |
if (cm.hasCutHeight()) |
2654 |
|
{ |
2655 |
3 |
xmlmat.setCutHeight(cm.getCutHeight()); |
2656 |
|
} |
2657 |
3 |
xmlmat.setId(cmId = "m" + contactMatrices.size() |
2658 |
|
+ System.currentTimeMillis()); |
2659 |
3 |
Console.trace("Matrix data stored :" + cmId); |
2660 |
3 |
contactMatrices.put(cm, cmId); |
2661 |
3 |
contactMatrixRefs.put(cmId, cm); |
2662 |
3 |
xmlMatrices.add(xmlmat); |
2663 |
|
} |
2664 |
|
else |
2665 |
|
{ |
2666 |
6 |
Console.trace("Existing Matrix stored :" + cmId); |
2667 |
|
} |
2668 |
|
|
2669 |
|
|
2670 |
|
|
2671 |
9 |
MapOnAMatrixType xmlmatmapping = new MapOnAMatrixType(); |
2672 |
9 |
xmlmatmapping.setMatrix(cmId); |
2673 |
|
|
2674 |
|
|
2675 |
|
|
2676 |
9 |
if (cm instanceof MappableContactMatrixI) |
2677 |
|
{ |
2678 |
9 |
jalview.util.MapList mlst = ((MappableContactMatrixI) cm) |
2679 |
|
.getMapFor(annotation.sequenceRef); |
2680 |
9 |
if (mlst != null) |
2681 |
|
{ |
2682 |
9 |
MapListType mp = new MapListType(); |
2683 |
9 |
List<int[]> r = mlst.getFromRanges(); |
2684 |
9 |
for (int[] range : r) |
2685 |
|
{ |
2686 |
9 |
MapListFrom mfrom = new MapListFrom(); |
2687 |
9 |
mfrom.setStart(range[0]); |
2688 |
9 |
mfrom.setEnd(range[1]); |
2689 |
|
|
2690 |
9 |
mp.getMapListFrom().add(mfrom); |
2691 |
|
} |
2692 |
9 |
r = mlst.getToRanges(); |
2693 |
9 |
for (int[] range : r) |
2694 |
|
{ |
2695 |
9 |
MapListTo mto = new MapListTo(); |
2696 |
9 |
mto.setStart(range[0]); |
2697 |
9 |
mto.setEnd(range[1]); |
2698 |
|
|
2699 |
9 |
mp.getMapListTo().add(mto); |
2700 |
|
} |
2701 |
9 |
mp.setMapFromUnit(BigInteger.valueOf(mlst.getFromRatio())); |
2702 |
9 |
mp.setMapToUnit(BigInteger.valueOf(mlst.getToRatio())); |
2703 |
9 |
xmlmatmapping.setMapping(mp); |
2704 |
|
} |
2705 |
|
} |
2706 |
|
|
2707 |
9 |
an.getContactmatrix().add(xmlmatmapping); |
2708 |
|
} |
2709 |
|
|
|
|
| 75% |
Uncovered Elements: 2 (8) |
Complexity: 2 |
Complexity Density: 0.33 |
|
2710 |
9 |
private String stringifyBitset(BitSet gp)... |
2711 |
|
{ |
2712 |
9 |
StringBuilder sb = new StringBuilder(); |
2713 |
9 |
for (long val : gp.toLongArray()) |
2714 |
|
{ |
2715 |
9 |
if (sb.length() > 0) |
2716 |
|
{ |
2717 |
0 |
sb.append(","); |
2718 |
|
} |
2719 |
9 |
sb.append(val); |
2720 |
|
} |
2721 |
9 |
return sb.toString(); |
2722 |
|
} |
2723 |
|
|
|
|
| 71.4% |
Uncovered Elements: 4 (14) |
Complexity: 5 |
Complexity Density: 0.5 |
|
2724 |
6 |
private BitSet deStringifyBitset(String stringified)... |
2725 |
|
{ |
2726 |
6 |
if ("".equals(stringified) || stringified == null) |
2727 |
|
{ |
2728 |
0 |
return new BitSet(); |
2729 |
|
} |
2730 |
6 |
String[] longvals = stringified.split(","); |
2731 |
6 |
long[] newlongvals = new long[longvals.length]; |
2732 |
12 |
for (int lv = 0; lv < longvals.length; lv++) |
2733 |
|
{ |
2734 |
6 |
try |
2735 |
|
{ |
2736 |
6 |
newlongvals[lv] = Long.valueOf(longvals[lv]); |
2737 |
|
} catch (Exception x) |
2738 |
|
{ |
2739 |
0 |
errorMessage += "Couldn't destringify bitset from: '" + stringified |
2740 |
|
+ "'"; |
2741 |
0 |
newlongvals[lv] = 0; |
2742 |
|
} |
2743 |
|
} |
2744 |
6 |
return BitSet.valueOf(newlongvals); |
2745 |
|
|
2746 |
|
} |
2747 |
|
|
|
|
| 18.2% |
Uncovered Elements: 18 (22) |
Complexity: 3 |
Complexity Density: 0.17 |
|
2748 |
9 |
private CalcIdParam createCalcIdParam(String calcId, AlignViewport av)... |
2749 |
|
{ |
2750 |
9 |
AutoCalcSetting settings = av.getCalcIdSettingsFor(calcId); |
2751 |
9 |
if (settings != null) |
2752 |
|
{ |
2753 |
0 |
CalcIdParam vCalcIdParam = new CalcIdParam(); |
2754 |
0 |
vCalcIdParam.setCalcId(calcId); |
2755 |
|
|
2756 |
0 |
vCalcIdParam.getServiceURL().add(settings.getServiceURI()); |
2757 |
|
|
2758 |
|
|
2759 |
0 |
for (String url : settings.getServiceURLs()) |
2760 |
|
{ |
2761 |
|
|
2762 |
0 |
vCalcIdParam.getServiceURL().add(url); |
2763 |
|
} |
2764 |
0 |
vCalcIdParam.setVersion("1.0"); |
2765 |
0 |
if (settings.getPreset() != null) |
2766 |
|
{ |
2767 |
0 |
WsParamSetI setting = settings.getPreset(); |
2768 |
0 |
vCalcIdParam.setName(setting.getName()); |
2769 |
0 |
vCalcIdParam.setDescription(setting.getDescription()); |
2770 |
|
} |
2771 |
|
else |
2772 |
|
{ |
2773 |
0 |
vCalcIdParam.setName(""); |
2774 |
0 |
vCalcIdParam.setDescription("Last used parameters"); |
2775 |
|
} |
2776 |
|
|
2777 |
|
|
2778 |
|
|
2779 |
0 |
vCalcIdParam.setParameters( |
2780 |
|
settings.getWsParamFile().replace("\n", "|\\n|")); |
2781 |
0 |
vCalcIdParam.setAutoUpdate(settings.isAutoUpdate()); |
2782 |
|
|
2783 |
|
|
2784 |
0 |
return vCalcIdParam; |
2785 |
|
} |
2786 |
9 |
return null; |
2787 |
|
} |
2788 |
|
|
|
|
| 0% |
Uncovered Elements: 29 (29) |
Complexity: 6 |
Complexity Density: 0.29 |
|
2789 |
0 |
private boolean recoverCalcIdParam(CalcIdParam calcIdParam,... |
2790 |
|
AlignViewport av) |
2791 |
|
{ |
2792 |
0 |
if (calcIdParam.getVersion().equals("1.0")) |
2793 |
|
{ |
2794 |
0 |
final String[] calcIds = calcIdParam.getServiceURL() |
2795 |
|
.toArray(new String[0]); |
2796 |
0 |
Jws2Instance service = Jws2Discoverer.getDiscoverer() |
2797 |
|
.getPreferredServiceFor(calcIds); |
2798 |
0 |
if (service != null) |
2799 |
|
{ |
2800 |
0 |
WsParamSetI parmSet = null; |
2801 |
0 |
try |
2802 |
|
{ |
2803 |
0 |
parmSet = service.getParamStore().parseServiceParameterFile( |
2804 |
|
calcIdParam.getName(), calcIdParam.getDescription(), |
2805 |
|
calcIds, |
2806 |
|
calcIdParam.getParameters().replace("|\\n|", "\n")); |
2807 |
|
} catch (IOException x) |
2808 |
|
{ |
2809 |
0 |
Console.warn("Couldn't parse parameter data for " |
2810 |
|
+ calcIdParam.getCalcId(), x); |
2811 |
0 |
return false; |
2812 |
|
} |
2813 |
0 |
List<ArgumentI> argList = null; |
2814 |
0 |
if (calcIdParam.getName().length() > 0) |
2815 |
|
{ |
2816 |
0 |
parmSet = service.getParamStore() |
2817 |
|
.getPreset(calcIdParam.getName()); |
2818 |
0 |
if (parmSet != null) |
2819 |
|
{ |
2820 |
|
|
2821 |
|
|
2822 |
|
} |
2823 |
|
} |
2824 |
|
else |
2825 |
|
{ |
2826 |
0 |
argList = parmSet.getArguments(); |
2827 |
0 |
parmSet = null; |
2828 |
|
} |
2829 |
0 |
AAConSettings settings = new AAConSettings( |
2830 |
|
calcIdParam.isAutoUpdate(), service, parmSet, argList); |
2831 |
0 |
av.setCalcIdSettingsFor(calcIdParam.getCalcId(), settings, |
2832 |
|
calcIdParam.isNeedsUpdate()); |
2833 |
0 |
return true; |
2834 |
|
} |
2835 |
|
else |
2836 |
|
{ |
2837 |
0 |
Console.warn( |
2838 |
|
"Cannot resolve a service for the parameters used in this project. Try configuring a JABAWS server."); |
2839 |
0 |
return false; |
2840 |
|
} |
2841 |
|
} |
2842 |
0 |
throw new Error(MessageManager.formatMessage( |
2843 |
|
"error.unsupported_version_calcIdparam", new Object[] |
2844 |
|
{ calcIdParam.toString() })); |
2845 |
|
} |
2846 |
|
|
2847 |
|
|
2848 |
|
|
2849 |
|
|
2850 |
|
|
2851 |
|
|
2852 |
|
|
2853 |
|
IdentityHashMap jv2vobj = null; |
2854 |
|
|
2855 |
|
|
2856 |
|
|
2857 |
|
|
2858 |
|
|
2859 |
|
@param |
2860 |
|
|
2861 |
|
@return |
2862 |
|
|
|
|
| 16.7% |
Uncovered Elements: 15 (18) |
Complexity: 6 |
Complexity Density: 0.6 |
|
2863 |
977 |
private String makeHashCode(Object jvobj, String altCode)... |
2864 |
|
{ |
2865 |
977 |
if (jv2vobj != null) |
2866 |
|
{ |
2867 |
0 |
Object id = jv2vobj.get(jvobj); |
2868 |
0 |
if (id != null) |
2869 |
|
{ |
2870 |
0 |
return id.toString(); |
2871 |
|
} |
2872 |
|
|
2873 |
0 |
if (jvids2vobj != null && jvobj instanceof String) |
2874 |
|
{ |
2875 |
0 |
id = jvids2vobj.get(jvobj); |
2876 |
|
} |
2877 |
0 |
if (id != null) |
2878 |
|
{ |
2879 |
0 |
return id.toString(); |
2880 |
|
} |
2881 |
|
|
2882 |
0 |
Console.warn( |
2883 |
|
"Cannot find ID for object in external mapping : " + jvobj); |
2884 |
|
} |
2885 |
977 |
return altCode; |
2886 |
|
} |
2887 |
|
|
2888 |
|
|
2889 |
|
|
2890 |
|
|
2891 |
|
@param |
2892 |
|
|
2893 |
|
@return |
2894 |
|
|
|
|
| 60% |
Uncovered Elements: 2 (5) |
Complexity: 3 |
Complexity Density: 1 |
|
2895 |
12 |
private Object retrieveExistingObj(String idcode)... |
2896 |
|
{ |
2897 |
12 |
if (idcode != null && vobj2jv != null) |
2898 |
|
{ |
2899 |
0 |
return vobj2jv.get(idcode); |
2900 |
|
} |
2901 |
12 |
return null; |
2902 |
|
} |
2903 |
|
|
2904 |
|
|
2905 |
|
|
2906 |
|
|
2907 |
|
|
2908 |
|
private Hashtable vobj2jv; |
2909 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
2910 |
760 |
private Sequence createVamsasSequence(String id, SequenceI jds)... |
2911 |
|
{ |
2912 |
760 |
return createVamsasSequence(true, id, jds, null); |
2913 |
|
} |
2914 |
|
|
|
|
| 97.4% |
Uncovered Elements: 1 (39) |
Complexity: 7 |
Complexity Density: 0.26 |
|
2915 |
760 |
private Sequence createVamsasSequence(boolean recurse, String id,... |
2916 |
|
SequenceI jds, SequenceI parentseq) |
2917 |
|
{ |
2918 |
760 |
Sequence vamsasSeq = new Sequence(); |
2919 |
760 |
vamsasSeq.setId(id); |
2920 |
760 |
vamsasSeq.setName(jds.getName()); |
2921 |
760 |
vamsasSeq.setSequence(jds.getSequenceAsString()); |
2922 |
760 |
vamsasSeq.setDescription(jds.getDescription()); |
2923 |
760 |
List<DBRefEntry> dbrefs = null; |
2924 |
760 |
if (jds.getDatasetSequence() != null) |
2925 |
|
{ |
2926 |
409 |
vamsasSeq.setDsseqid(seqHash(jds.getDatasetSequence())); |
2927 |
|
} |
2928 |
|
else |
2929 |
|
{ |
2930 |
|
|
2931 |
|
|
2932 |
351 |
vamsasSeq.setDsseqid(id); |
2933 |
351 |
dbrefs = jds.getDBRefs(); |
2934 |
351 |
if (parentseq == null) |
2935 |
|
{ |
2936 |
351 |
parentseq = jds; |
2937 |
|
} |
2938 |
|
} |
2939 |
|
|
2940 |
|
|
2941 |
|
|
2942 |
|
|
2943 |
760 |
if (dbrefs != null) |
2944 |
|
{ |
2945 |
393 |
for (int d = 0, nd = dbrefs.size(); d < nd; d++) |
2946 |
|
{ |
2947 |
234 |
DBRef dbref = new DBRef(); |
2948 |
234 |
DBRefEntry ref = dbrefs.get(d); |
2949 |
234 |
dbref.setSource(ref.getSource()); |
2950 |
234 |
dbref.setVersion(ref.getVersion()); |
2951 |
234 |
dbref.setAccessionId(ref.getAccessionId()); |
2952 |
234 |
dbref.setCanonical(ref.isCanonical()); |
2953 |
234 |
if (ref instanceof GeneLocus) |
2954 |
|
{ |
2955 |
1 |
dbref.setLocus(true); |
2956 |
|
} |
2957 |
234 |
if (ref.hasMap()) |
2958 |
|
{ |
2959 |
2 |
Mapping mp = createVamsasMapping(ref.getMap(), parentseq, jds, |
2960 |
|
recurse); |
2961 |
2 |
dbref.setMapping(mp); |
2962 |
|
} |
2963 |
234 |
vamsasSeq.getDBRef().add(dbref); |
2964 |
|
} |
2965 |
|
} |
2966 |
760 |
return vamsasSeq; |
2967 |
|
} |
2968 |
|
|
|
|
| 84.2% |
Uncovered Elements: 6 (38) |
Complexity: 6 |
Complexity Density: 0.2 |
|
2969 |
2 |
private Mapping createVamsasMapping(jalview.datamodel.Mapping jmp,... |
2970 |
|
SequenceI parentseq, SequenceI jds, boolean recurse) |
2971 |
|
{ |
2972 |
2 |
Mapping mp = null; |
2973 |
2 |
if (jmp.getMap() != null) |
2974 |
|
{ |
2975 |
2 |
mp = new Mapping(); |
2976 |
|
|
2977 |
2 |
jalview.util.MapList mlst = jmp.getMap(); |
2978 |
2 |
List<int[]> r = mlst.getFromRanges(); |
2979 |
2 |
for (int[] range : r) |
2980 |
|
{ |
2981 |
2 |
MapListFrom mfrom = new MapListFrom(); |
2982 |
2 |
mfrom.setStart(range[0]); |
2983 |
2 |
mfrom.setEnd(range[1]); |
2984 |
|
|
2985 |
2 |
mp.getMapListFrom().add(mfrom); |
2986 |
|
} |
2987 |
2 |
r = mlst.getToRanges(); |
2988 |
2 |
for (int[] range : r) |
2989 |
|
{ |
2990 |
2 |
MapListTo mto = new MapListTo(); |
2991 |
2 |
mto.setStart(range[0]); |
2992 |
2 |
mto.setEnd(range[1]); |
2993 |
|
|
2994 |
2 |
mp.getMapListTo().add(mto); |
2995 |
|
} |
2996 |
2 |
mp.setMapFromUnit(BigInteger.valueOf(mlst.getFromRatio())); |
2997 |
2 |
mp.setMapToUnit(BigInteger.valueOf(mlst.getToRatio())); |
2998 |
2 |
if (jmp.getTo() != null) |
2999 |
|
{ |
3000 |
|
|
3001 |
|
|
3002 |
|
|
3003 |
|
|
3004 |
1 |
String jmpid = ""; |
3005 |
1 |
SequenceI ps = null; |
3006 |
1 |
if (parentseq != jmp.getTo() |
3007 |
|
&& parentseq.getDatasetSequence() != jmp.getTo()) |
3008 |
|
{ |
3009 |
|
|
3010 |
1 |
jmpid = seqHash(ps = jmp.getTo()); |
3011 |
|
} |
3012 |
|
else |
3013 |
|
{ |
3014 |
0 |
jmpid = seqHash(ps = parentseq); |
3015 |
|
} |
3016 |
|
|
3017 |
1 |
mp.setDseqFor(jmpid); |
3018 |
1 |
if (!seqRefIds.containsKey(jmpid)) |
3019 |
|
{ |
3020 |
0 |
Console.debug("creatign new DseqFor ID"); |
3021 |
0 |
seqRefIds.put(jmpid, ps); |
3022 |
|
} |
3023 |
|
else |
3024 |
|
{ |
3025 |
1 |
Console.debug("reusing DseqFor ID"); |
3026 |
|
} |
3027 |
|
|
3028 |
|
|
3029 |
|
} |
3030 |
|
} |
3031 |
2 |
return mp; |
3032 |
|
} |
3033 |
|
|
|
|
| 0% |
Uncovered Elements: 37 (37) |
Complexity: 6 |
Complexity Density: 0.22 |
|
3034 |
0 |
String setUserColourScheme(jalview.schemes.ColourSchemeI cs,... |
3035 |
|
List<UserColourScheme> userColours, JalviewModel jm) |
3036 |
|
{ |
3037 |
0 |
String id = null; |
3038 |
0 |
jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme) cs; |
3039 |
0 |
boolean newucs = false; |
3040 |
0 |
if (!userColours.contains(ucs)) |
3041 |
|
{ |
3042 |
0 |
userColours.add(ucs); |
3043 |
0 |
newucs = true; |
3044 |
|
} |
3045 |
0 |
id = "ucs" + userColours.indexOf(ucs); |
3046 |
0 |
if (newucs) |
3047 |
|
{ |
3048 |
|
|
3049 |
0 |
java.awt.Color[] colours = ucs.getColours(); |
3050 |
0 |
UserColours uc = new UserColours(); |
3051 |
|
|
3052 |
0 |
JalviewUserColours jbucs = new JalviewUserColours(); |
3053 |
|
|
3054 |
0 |
for (int i = 0; i < colours.length; i++) |
3055 |
|
{ |
3056 |
0 |
Colour col = new Colour(); |
3057 |
0 |
col.setName(ResidueProperties.aa[i]); |
3058 |
0 |
col.setRGB(jalview.util.Format.getHexString(colours[i])); |
3059 |
|
|
3060 |
0 |
jbucs.getColour().add(col); |
3061 |
|
} |
3062 |
0 |
if (ucs.getLowerCaseColours() != null) |
3063 |
|
{ |
3064 |
0 |
colours = ucs.getLowerCaseColours(); |
3065 |
0 |
for (int i = 0; i < colours.length; i++) |
3066 |
|
{ |
3067 |
0 |
Colour col = new Colour(); |
3068 |
0 |
col.setName(ResidueProperties.aa[i].toLowerCase(Locale.ROOT)); |
3069 |
0 |
col.setRGB(jalview.util.Format.getHexString(colours[i])); |
3070 |
|
|
3071 |
0 |
jbucs.getColour().add(col); |
3072 |
|
} |
3073 |
|
} |
3074 |
|
|
3075 |
0 |
uc.setId(id); |
3076 |
0 |
uc.setUserColourScheme(jbucs); |
3077 |
|
|
3078 |
0 |
jm.getUserColours().add(uc); |
3079 |
|
} |
3080 |
|
|
3081 |
0 |
return id; |
3082 |
|
} |
3083 |
|
|
|
|
| 0% |
Uncovered Elements: 24 (24) |
Complexity: 5 |
Complexity Density: 0.31 |
|
3084 |
0 |
jalview.schemes.UserColourScheme getUserColourScheme(JalviewModel jm,... |
3085 |
|
String id) |
3086 |
|
{ |
3087 |
0 |
List<UserColours> uc = jm.getUserColours(); |
3088 |
0 |
UserColours colours = null; |
3089 |
|
|
3090 |
|
|
3091 |
|
|
3092 |
|
|
3093 |
|
|
3094 |
|
|
3095 |
|
|
3096 |
|
|
3097 |
|
|
3098 |
|
|
3099 |
0 |
for (UserColours c : uc) |
3100 |
|
{ |
3101 |
0 |
if (c.getId().equals(id)) |
3102 |
|
{ |
3103 |
0 |
colours = c; |
3104 |
0 |
break; |
3105 |
|
} |
3106 |
|
} |
3107 |
|
|
3108 |
0 |
java.awt.Color[] newColours = new java.awt.Color[24]; |
3109 |
|
|
3110 |
0 |
for (int i = 0; i < 24; i++) |
3111 |
|
{ |
3112 |
0 |
newColours[i] = new java.awt.Color(Integer.parseInt( |
3113 |
|
|
3114 |
|
colours.getUserColourScheme().getColour().get(i).getRGB(), |
3115 |
|
16)); |
3116 |
|
} |
3117 |
|
|
3118 |
0 |
jalview.schemes.UserColourScheme ucs = new jalview.schemes.UserColourScheme( |
3119 |
|
newColours); |
3120 |
|
|
3121 |
0 |
if (colours.getUserColourScheme().getColour().size() > 24) |
3122 |
|
{ |
3123 |
0 |
newColours = new java.awt.Color[23]; |
3124 |
0 |
for (int i = 0; i < 23; i++) |
3125 |
|
{ |
3126 |
0 |
newColours[i] = new java.awt.Color( |
3127 |
|
Integer.parseInt(colours.getUserColourScheme().getColour() |
3128 |
|
.get(i + 24).getRGB(), 16)); |
3129 |
|
} |
3130 |
0 |
ucs.setLowerCaseColours(newColours); |
3131 |
|
} |
3132 |
|
|
3133 |
0 |
return ucs; |
3134 |
|
} |
3135 |
|
|
3136 |
|
|
3137 |
|
|
3138 |
|
|
3139 |
|
String errorMessage = null; |
3140 |
|
|
3141 |
|
|
3142 |
|
|
3143 |
|
|
3144 |
|
|
3145 |
|
public boolean attemptversion1parse = false; |
3146 |
|
|
3147 |
|
|
3148 |
|
|
3149 |
|
|
3150 |
|
@param |
3151 |
|
|
3152 |
|
|
|
|
| 73.3% |
Uncovered Elements: 4 (15) |
Complexity: 4 |
Complexity Density: 0.31 |
|
3153 |
30 |
public AlignFrame loadJalviewAlign(final Object file)... |
3154 |
|
{ |
3155 |
|
|
3156 |
30 |
jalview.gui.AlignFrame af = null; |
3157 |
|
|
3158 |
30 |
try |
3159 |
|
{ |
3160 |
|
|
3161 |
30 |
newStructureViewers = new Vector<>(); |
3162 |
|
|
3163 |
|
|
3164 |
|
|
3165 |
|
|
3166 |
|
|
3167 |
30 |
jarInputStreamProvider jprovider = createjarInputStreamProvider(file); |
3168 |
30 |
af = loadJalviewAlign(jprovider); |
3169 |
30 |
if (af != null) |
3170 |
|
{ |
3171 |
30 |
af.setMenusForViewport(); |
3172 |
|
} |
3173 |
|
} catch (MalformedURLException e) |
3174 |
|
{ |
3175 |
0 |
errorMessage = "Invalid URL format for '" + file + "'"; |
3176 |
0 |
reportErrors(); |
3177 |
|
} finally |
3178 |
|
{ |
3179 |
30 |
try |
3180 |
|
{ |
3181 |
30 |
SwingUtilities.invokeAndWait(new Runnable() |
3182 |
|
{ |
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
3183 |
30 |
@Override... |
3184 |
|
public void run() |
3185 |
|
{ |
3186 |
30 |
setLoadingFinishedForNewStructureViewers(); |
3187 |
|
} |
3188 |
|
}); |
3189 |
|
} catch (Exception x) |
3190 |
|
{ |
3191 |
0 |
jalview.bin.Console |
3192 |
|
.errPrintln("Error loading alignment: " + x.getMessage()); |
3193 |
|
} |
3194 |
|
} |
3195 |
30 |
return af; |
3196 |
|
} |
3197 |
|
|
|
|
| 71.4% |
Uncovered Elements: 6 (21) |
Complexity: 5 |
Complexity Density: 0.33 |
|
3198 |
30 |
@SuppressWarnings("unused")... |
3199 |
|
private jarInputStreamProvider createjarInputStreamProvider( |
3200 |
|
final Object ofile) throws MalformedURLException |
3201 |
|
{ |
3202 |
|
|
3203 |
|
|
3204 |
30 |
try |
3205 |
|
{ |
3206 |
30 |
String file = (ofile instanceof File |
3207 |
|
? ((File) ofile).getCanonicalPath() |
3208 |
|
: ofile.toString()); |
3209 |
30 |
byte[] bytes = Platform.isJS() ? Platform.getFileBytes((File) ofile) |
3210 |
|
: null; |
3211 |
30 |
URL url = null; |
3212 |
30 |
errorMessage = null; |
3213 |
30 |
uniqueSetSuffix = null; |
3214 |
30 |
seqRefIds = null; |
3215 |
30 |
viewportsAdded.clear(); |
3216 |
30 |
frefedSequence = null; |
3217 |
|
|
3218 |
30 |
if (HttpUtils.startsWithHttpOrHttps(file)) |
3219 |
|
{ |
3220 |
0 |
url = new URL(file); |
3221 |
|
} |
3222 |
30 |
final URL _url = url; |
3223 |
30 |
return new jarInputStreamProvider() |
3224 |
|
{ |
3225 |
|
|
|
|
| 55.6% |
Uncovered Elements: 4 (9) |
Complexity: 3 |
Complexity Density: 0.6 |
|
3226 |
152 |
@Override... |
3227 |
|
public JarInputStream getJarInputStream() throws IOException |
3228 |
|
{ |
3229 |
152 |
if (bytes != null) |
3230 |
|
{ |
3231 |
|
|
3232 |
|
|
3233 |
|
|
3234 |
0 |
return new JarInputStream(new ByteArrayInputStream(bytes)); |
3235 |
|
} |
3236 |
152 |
if (_url != null) |
3237 |
|
{ |
3238 |
|
|
3239 |
|
|
3240 |
|
|
3241 |
0 |
return new JarInputStream(HttpUtils.openStream(_url)); |
3242 |
|
} |
3243 |
|
else |
3244 |
|
{ |
3245 |
|
|
3246 |
|
|
3247 |
|
|
3248 |
152 |
return new JarInputStream(new FileInputStream(file)); |
3249 |
|
} |
3250 |
|
} |
3251 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
3252 |
30 |
@Override... |
3253 |
|
public String getFilename() |
3254 |
|
{ |
3255 |
30 |
return file; |
3256 |
|
} |
3257 |
|
}; |
3258 |
|
} catch (IOException e) |
3259 |
|
{ |
3260 |
0 |
e.printStackTrace(); |
3261 |
0 |
return null; |
3262 |
|
} |
3263 |
|
} |
3264 |
|
|
3265 |
|
|
3266 |
|
|
3267 |
|
|
3268 |
|
|
3269 |
|
|
3270 |
|
|
3271 |
|
@param |
3272 |
|
@return |
3273 |
|
|
|
|
| 82.7% |
Uncovered Elements: 17 (98) |
Complexity: 21 |
Complexity Density: 0.31 |
|
3274 |
30 |
public AlignFrame loadJalviewAlign(final jarInputStreamProvider jprovider)... |
3275 |
|
{ |
3276 |
30 |
errorMessage = null; |
3277 |
30 |
if (uniqueSetSuffix == null) |
3278 |
|
{ |
3279 |
30 |
uniqueSetSuffix = System.currentTimeMillis() % 100000 + ""; |
3280 |
|
} |
3281 |
30 |
if (seqRefIds == null) |
3282 |
|
{ |
3283 |
30 |
initSeqRefs(); |
3284 |
|
} |
3285 |
30 |
AlignFrame af = null, _af = null; |
3286 |
30 |
List<AlignFrame> toRepaint = new ArrayList<AlignFrame>(); |
3287 |
30 |
IdentityHashMap<AlignmentI, AlignmentI> importedDatasets = new IdentityHashMap<>(); |
3288 |
30 |
Map<String, AlignFrame> gatherToThisFrame = new HashMap<>(); |
3289 |
30 |
final String file = jprovider.getFilename(); |
3290 |
30 |
try |
3291 |
|
{ |
3292 |
30 |
JarInputStream jin = null; |
3293 |
30 |
JarEntry jarentry = null; |
3294 |
30 |
int entryCount = 1; |
3295 |
|
|
3296 |
30 |
do |
3297 |
|
{ |
3298 |
140 |
jin = jprovider.getJarInputStream(); |
3299 |
606 |
for (int i = 0; i < entryCount; i++) |
3300 |
|
{ |
3301 |
466 |
jarentry = jin.getNextJarEntry(); |
3302 |
|
} |
3303 |
|
|
3304 |
140 |
if (jarentry != null && jarentry.getName().endsWith(".xml")) |
3305 |
|
{ |
3306 |
99 |
JAXBContext jc = JAXBContext |
3307 |
|
.newInstance("jalview.xml.binding.jalview"); |
3308 |
99 |
XMLStreamReader streamReader = XMLInputFactory.newInstance() |
3309 |
|
.createXMLStreamReader(jin); |
3310 |
99 |
javax.xml.bind.Unmarshaller um = jc.createUnmarshaller(); |
3311 |
99 |
JAXBElement<JalviewModel> jbe = um.unmarshal(streamReader, |
3312 |
|
JalviewModel.class); |
3313 |
99 |
JalviewModel object = jbe.getValue(); |
3314 |
|
|
3315 |
99 |
if (true) |
3316 |
|
{ |
3317 |
99 |
_af = loadFromObject(object, file, true, jprovider); |
3318 |
98 |
if (_af != null && object.getViewport().size() > 0) |
3319 |
|
|
3320 |
|
{ |
3321 |
74 |
toRepaint.add(_af); |
3322 |
74 |
if (af == null) |
3323 |
|
{ |
3324 |
|
|
3325 |
30 |
af = _af; |
3326 |
|
} |
3327 |
74 |
if (_af.getViewport().isGatherViewsHere()) |
3328 |
|
{ |
3329 |
|
|
3330 |
|
|
3331 |
14 |
af = _af; |
3332 |
14 |
gatherToThisFrame.put(_af.getViewport().getSequenceSetId(), |
3333 |
|
_af); |
3334 |
|
} |
3335 |
|
|
3336 |
74 |
importedDatasets.put( |
3337 |
|
af.getViewport().getAlignment().getDataset(), |
3338 |
|
af.getViewport().getAlignment().getDataset()); |
3339 |
|
} |
3340 |
|
} |
3341 |
98 |
entryCount++; |
3342 |
|
} |
3343 |
41 |
else if (jarentry != null) |
3344 |
|
{ |
3345 |
|
|
3346 |
12 |
entryCount++; |
3347 |
|
} |
3348 |
139 |
} while (jarentry != null); |
3349 |
29 |
jin.close(); |
3350 |
29 |
resolveFrefedSequences(); |
3351 |
29 |
for (AlignFrame alignFrame : toRepaint) |
3352 |
|
{ |
3353 |
70 |
alignFrame.repaint(); |
3354 |
|
} |
3355 |
|
} catch (IOException ex) |
3356 |
|
{ |
3357 |
0 |
ex.printStackTrace(); |
3358 |
0 |
errorMessage = "Couldn't locate Jalview XML file : " + file; |
3359 |
0 |
jalview.bin.Console.errPrintln( |
3360 |
|
"Exception whilst loading jalview XML file : " + ex + "\n"); |
3361 |
|
} catch (Exception ex) |
3362 |
|
{ |
3363 |
1 |
jalview.bin.Console |
3364 |
|
.errPrintln("Parsing as Jalview Version 2 file failed."); |
3365 |
1 |
ex.printStackTrace(System.err); |
3366 |
1 |
if (attemptversion1parse) |
3367 |
|
{ |
3368 |
|
|
3369 |
|
} |
3370 |
1 |
if (Desktop.instance != null) |
3371 |
|
{ |
3372 |
1 |
Desktop.instance.stopLoading(); |
3373 |
|
} |
3374 |
1 |
if (af != null) |
3375 |
|
{ |
3376 |
1 |
jalview.bin.Console.outPrintln("Successfully loaded archive file"); |
3377 |
1 |
return af; |
3378 |
|
} |
3379 |
0 |
ex.printStackTrace(); |
3380 |
|
|
3381 |
0 |
jalview.bin.Console.errPrintln( |
3382 |
|
"Exception whilst loading jalview XML file : " + ex + "\n"); |
3383 |
|
} catch (OutOfMemoryError e) |
3384 |
|
{ |
3385 |
|
|
3386 |
0 |
errorMessage = "Out of memory loading jalview XML file"; |
3387 |
0 |
jalview.bin.Console |
3388 |
|
.errPrintln("Out of memory whilst loading jalview XML file"); |
3389 |
0 |
e.printStackTrace(); |
3390 |
|
} |
3391 |
|
|
3392 |
|
|
3393 |
|
|
3394 |
|
|
3395 |
|
|
3396 |
|
|
3397 |
|
|
3398 |
|
|
3399 |
29 |
for (AlignFrame fr : gatherToThisFrame.values()) |
3400 |
|
{ |
3401 |
13 |
Desktop.instance.gatherViews(fr); |
3402 |
|
} |
3403 |
|
|
3404 |
29 |
restoreSplitFrames(); |
3405 |
29 |
for (AlignmentI ds : importedDatasets.keySet()) |
3406 |
|
{ |
3407 |
29 |
if (ds.getCodonFrames() != null) |
3408 |
|
{ |
3409 |
29 |
StructureSelectionManager |
3410 |
|
.getStructureSelectionManager(Desktop.instance) |
3411 |
|
.registerMappings(ds.getCodonFrames()); |
3412 |
|
} |
3413 |
|
} |
3414 |
29 |
if (errorMessage != null) |
3415 |
|
{ |
3416 |
0 |
reportErrors(); |
3417 |
|
} |
3418 |
|
|
3419 |
29 |
if (Desktop.instance != null) |
3420 |
|
{ |
3421 |
29 |
Desktop.instance.stopLoading(); |
3422 |
|
} |
3423 |
|
|
3424 |
29 |
return af; |
3425 |
|
} |
3426 |
|
|
3427 |
|
|
3428 |
|
|
3429 |
|
|
3430 |
|
|
3431 |
|
|
|
|
| 20% |
Uncovered Elements: 32 (40) |
Complexity: 7 |
Complexity Density: 0.23 |
|
3432 |
29 |
protected void restoreSplitFrames()... |
3433 |
|
{ |
3434 |
29 |
List<SplitFrame> gatherTo = new ArrayList<>(); |
3435 |
29 |
List<AlignFrame> addedToSplitFrames = new ArrayList<>(); |
3436 |
29 |
Map<String, AlignFrame> dna = new HashMap<>(); |
3437 |
|
|
3438 |
|
|
3439 |
|
|
3440 |
|
|
3441 |
29 |
for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates |
3442 |
|
.entrySet()) |
3443 |
|
{ |
3444 |
0 |
AlignFrame af = candidate.getValue(); |
3445 |
0 |
if (af.getViewport().getAlignment().isNucleotide()) |
3446 |
|
{ |
3447 |
0 |
dna.put(candidate.getKey().getId(), af); |
3448 |
|
} |
3449 |
|
} |
3450 |
|
|
3451 |
|
|
3452 |
|
|
3453 |
|
|
3454 |
29 |
for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates |
3455 |
|
.entrySet()) |
3456 |
|
{ |
3457 |
0 |
AlignFrame af = candidate.getValue(); |
3458 |
0 |
if (!af.getViewport().getAlignment().isNucleotide()) |
3459 |
|
{ |
3460 |
0 |
String complementId = candidate.getKey().getComplementId(); |
3461 |
|
|
3462 |
0 |
if (complementId != null && dna.containsKey(complementId)) |
3463 |
|
{ |
3464 |
0 |
final AlignFrame dnaFrame = dna.get(complementId); |
3465 |
0 |
SplitFrame sf = createSplitFrame(dnaFrame, af); |
3466 |
0 |
addedToSplitFrames.add(dnaFrame); |
3467 |
0 |
addedToSplitFrames.add(af); |
3468 |
0 |
dnaFrame.setMenusForViewport(); |
3469 |
0 |
af.setMenusForViewport(); |
3470 |
0 |
if (af.getViewport().isGatherViewsHere()) |
3471 |
|
{ |
3472 |
0 |
gatherTo.add(sf); |
3473 |
|
} |
3474 |
|
} |
3475 |
|
} |
3476 |
|
} |
3477 |
|
|
3478 |
|
|
3479 |
|
|
3480 |
|
|
3481 |
|
|
3482 |
29 |
for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates |
3483 |
|
.entrySet()) |
3484 |
|
{ |
3485 |
0 |
AlignFrame af = candidate.getValue(); |
3486 |
0 |
if (!addedToSplitFrames.contains(af)) |
3487 |
|
{ |
3488 |
0 |
Viewport view = candidate.getKey(); |
3489 |
0 |
Desktop.addInternalFrame(af, view.getTitle(), |
3490 |
|
safeInt(view.getWidth()), safeInt(view.getHeight())); |
3491 |
0 |
af.setMenusForViewport(); |
3492 |
0 |
jalview.bin.Console.errPrintln("Failed to restore view " |
3493 |
|
+ view.getTitle() + " to split frame"); |
3494 |
|
} |
3495 |
|
} |
3496 |
|
|
3497 |
|
|
3498 |
|
|
3499 |
|
|
3500 |
29 |
for (SplitFrame sf : gatherTo) |
3501 |
|
{ |
3502 |
0 |
Desktop.instance.gatherViews(sf); |
3503 |
|
} |
3504 |
|
|
3505 |
29 |
splitFrameCandidates.clear(); |
3506 |
|
} |
3507 |
|
|
3508 |
|
|
3509 |
|
|
3510 |
|
|
3511 |
|
@param |
3512 |
|
@param |
3513 |
|
@return |
3514 |
|
|
|
|
| 0% |
Uncovered Elements: 8 (8) |
Complexity: 1 |
Complexity Density: 0.12 |
|
3515 |
0 |
protected SplitFrame createSplitFrame(AlignFrame dnaFrame,... |
3516 |
|
AlignFrame proteinFrame) |
3517 |
|
{ |
3518 |
0 |
SplitFrame splitFrame = new SplitFrame(dnaFrame, proteinFrame); |
3519 |
0 |
String title = MessageManager.getString("label.linked_view_title"); |
3520 |
0 |
int width = (int) dnaFrame.getBounds().getWidth(); |
3521 |
0 |
int height = (int) (dnaFrame.getBounds().getHeight() |
3522 |
|
+ proteinFrame.getBounds().getHeight() + 50); |
3523 |
|
|
3524 |
|
|
3525 |
|
|
3526 |
|
|
3527 |
0 |
splitFrame.setLocation(dnaFrame.getX(), dnaFrame.getY()); |
3528 |
0 |
Desktop.addInternalFrame(splitFrame, title, width, height); |
3529 |
|
|
3530 |
|
|
3531 |
|
|
3532 |
|
|
3533 |
|
|
3534 |
0 |
proteinFrame.getViewport().alignmentChanged(proteinFrame.alignPanel); |
3535 |
|
|
3536 |
0 |
return splitFrame; |
3537 |
|
} |
3538 |
|
|
3539 |
|
|
3540 |
|
|
3541 |
|
|
3542 |
|
|
3543 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
3544 |
16 |
protected void reportErrors()... |
3545 |
|
{ |
3546 |
16 |
reportErrors(false); |
3547 |
|
} |
3548 |
|
|
|
|
| 80% |
Uncovered Elements: 2 (10) |
Complexity: 3 |
Complexity Density: 0.5 |
|
3549 |
16 |
protected void reportErrors(final boolean saving)... |
3550 |
|
{ |
3551 |
16 |
if (errorMessage != null) |
3552 |
|
{ |
3553 |
1 |
final String finalErrorMessage = errorMessage; |
3554 |
1 |
if (raiseGUI) |
3555 |
|
{ |
3556 |
1 |
javax.swing.SwingUtilities.invokeLater(new Runnable() |
3557 |
|
{ |
|
|
| 66.7% |
Uncovered Elements: 1 (3) |
Complexity: 2 |
Complexity Density: 2 |
|
3558 |
1 |
@Override... |
3559 |
|
public void run() |
3560 |
|
{ |
3561 |
1 |
JvOptionPane.showInternalMessageDialog(Desktop.desktop, |
3562 |
|
finalErrorMessage, |
3563 |
1 |
"Error " + (saving ? "saving" : "loading") |
3564 |
|
+ " Jalview file", |
3565 |
|
JvOptionPane.WARNING_MESSAGE); |
3566 |
|
} |
3567 |
|
}); |
3568 |
|
} |
3569 |
|
else |
3570 |
|
{ |
3571 |
0 |
jalview.bin.Console.errPrintln( |
3572 |
|
"Problem loading Jalview file: " + errorMessage); |
3573 |
|
} |
3574 |
|
} |
3575 |
16 |
errorMessage = null; |
3576 |
|
} |
3577 |
|
|
3578 |
|
Map<String, String> alreadyLoadedPDB = new HashMap<>(); |
3579 |
|
|
3580 |
|
|
3581 |
|
|
3582 |
|
|
3583 |
|
|
3584 |
|
|
3585 |
|
private final boolean updateLocalViews = false; |
3586 |
|
|
3587 |
|
|
3588 |
|
|
3589 |
|
|
3590 |
|
|
3591 |
|
|
3592 |
|
|
3593 |
|
@param |
3594 |
|
@param |
3595 |
|
@return |
3596 |
|
|
|
|
| 90% |
Uncovered Elements: 1 (10) |
Complexity: 3 |
Complexity Density: 0.5 |
|
3597 |
192 |
String loadPDBFile(jarInputStreamProvider jprovider, String pdbId,... |
3598 |
|
String origFile) |
3599 |
|
{ |
3600 |
192 |
if (alreadyLoadedPDB.containsKey(pdbId)) |
3601 |
|
{ |
3602 |
182 |
return alreadyLoadedPDB.get(pdbId).toString(); |
3603 |
|
} |
3604 |
|
|
3605 |
10 |
String tempFile = copyJarEntry(jprovider, pdbId, "jalview_pdb", |
3606 |
|
origFile); |
3607 |
10 |
if (tempFile != null) |
3608 |
|
{ |
3609 |
10 |
alreadyLoadedPDB.put(pdbId, tempFile); |
3610 |
|
} |
3611 |
10 |
return tempFile; |
3612 |
|
} |
3613 |
|
|
3614 |
|
|
3615 |
|
|
3616 |
|
|
3617 |
|
|
3618 |
|
@param |
3619 |
|
@param |
3620 |
|
@param |
3621 |
|
|
3622 |
|
|
3623 |
|
@param |
3624 |
|
|
3625 |
|
|
3626 |
|
@return |
3627 |
|
|
|
|
| 76.7% |
Uncovered Elements: 7 (30) |
Complexity: 12 |
Complexity Density: 0.55 |
|
3628 |
10 |
protected String copyJarEntry(jarInputStreamProvider jprovider,... |
3629 |
|
String jarEntryName, String prefix, String suffixModel) |
3630 |
|
{ |
3631 |
10 |
String suffix = ".tmp"; |
3632 |
10 |
if (suffixModel == null) |
3633 |
|
{ |
3634 |
0 |
suffixModel = jarEntryName; |
3635 |
|
} |
3636 |
10 |
int sfpos = suffixModel.lastIndexOf("."); |
3637 |
10 |
if (sfpos > -1 && sfpos < (suffixModel.length() - 1)) |
3638 |
|
{ |
3639 |
10 |
suffix = "." + suffixModel.substring(sfpos + 1); |
3640 |
|
} |
3641 |
|
|
3642 |
10 |
try (JarInputStream jin = jprovider.getJarInputStream()) |
3643 |
|
{ |
3644 |
10 |
JarEntry entry = null; |
3645 |
10 |
do |
3646 |
|
{ |
3647 |
12 |
entry = jin.getNextJarEntry(); |
3648 |
12 |
} while (entry != null && !entry.getName().equals(jarEntryName)); |
3649 |
|
|
3650 |
10 |
if (entry != null) |
3651 |
|
{ |
3652 |
|
|
3653 |
10 |
File outFile = File.createTempFile(prefix, suffix); |
3654 |
10 |
outFile.deleteOnExit(); |
3655 |
10 |
try (OutputStream os = new FileOutputStream(outFile)) |
3656 |
|
{ |
3657 |
10 |
copyAll(jin, os); |
3658 |
|
} |
3659 |
10 |
String t = outFile.getAbsolutePath(); |
3660 |
10 |
return t; |
3661 |
|
} |
3662 |
|
else |
3663 |
|
{ |
3664 |
0 |
Console.warn( |
3665 |
|
"Couldn't find entry in Jalview Jar for " + jarEntryName); |
3666 |
|
} |
3667 |
|
} catch (Exception ex) |
3668 |
|
{ |
3669 |
0 |
ex.printStackTrace(); |
3670 |
|
} |
3671 |
|
|
3672 |
0 |
return null; |
3673 |
|
} |
3674 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0.5 |
|
3675 |
|
private class JvAnnotRow |
3676 |
|
{ |
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
3677 |
609 |
public JvAnnotRow(int i, AlignmentAnnotation jaa)... |
3678 |
|
{ |
3679 |
609 |
order = i; |
3680 |
609 |
template = jaa; |
3681 |
|
} |
3682 |
|
|
3683 |
|
|
3684 |
|
|
3685 |
|
|
3686 |
|
public jalview.datamodel.AlignmentAnnotation template; |
3687 |
|
|
3688 |
|
|
3689 |
|
|
3690 |
|
|
3691 |
|
public int order; |
3692 |
|
} |
3693 |
|
|
3694 |
|
|
3695 |
|
|
3696 |
|
|
3697 |
|
@param |
3698 |
|
|
3699 |
|
@param |
3700 |
|
|
3701 |
|
@param |
3702 |
|
|
3703 |
|
@param |
3704 |
|
|
3705 |
|
@return |
3706 |
|
|
|
|
| 84.1% |
Uncovered Elements: 79 (497) |
Complexity: 118 |
Complexity Density: 0.39 |
|
3707 |
109 |
AlignFrame loadFromObject(JalviewModel jalviewModel, String file,... |
3708 |
|
boolean loadTreesAndStructures, jarInputStreamProvider jprovider) |
3709 |
|
{ |
3710 |
109 |
SequenceSet vamsasSet = jalviewModel.getVamsasModel().getSequenceSet() |
3711 |
|
.get(0); |
3712 |
109 |
List<Sequence> vamsasSeqs = vamsasSet.getSequence(); |
3713 |
|
|
3714 |
|
|
3715 |
|
|
3716 |
|
|
3717 |
|
|
3718 |
109 |
Viewport view = (jalviewModel.getViewport().size() > 0) |
3719 |
|
? jalviewModel.getViewport().get(0) |
3720 |
|
: null; |
3721 |
|
|
3722 |
|
|
3723 |
|
|
3724 |
|
|
3725 |
|
|
3726 |
|
|
3727 |
|
|
3728 |
|
|
3729 |
|
|
3730 |
|
|
3731 |
|
|
3732 |
|
|
3733 |
|
|
3734 |
|
|
3735 |
109 |
String uniqueSeqSetId = null; |
3736 |
109 |
String viewId = null; |
3737 |
109 |
if (view != null) |
3738 |
|
{ |
3739 |
85 |
uniqueSeqSetId = view.getSequenceSetId() + uniqueSetSuffix; |
3740 |
85 |
viewId = (view.getId() == null ? null |
3741 |
|
: view.getId() + uniqueSetSuffix); |
3742 |
|
} |
3743 |
|
|
3744 |
|
|
3745 |
|
|
3746 |
|
|
3747 |
109 |
if (vamsasSet.getMatrix() != null && vamsasSet.getMatrix().size() > 0) |
3748 |
|
{ |
3749 |
2 |
importMatrixData(vamsasSet.getMatrix()); |
3750 |
|
} |
3751 |
|
|
3752 |
|
|
3753 |
|
|
3754 |
|
|
3755 |
109 |
List<SequenceI> hiddenSeqs = null; |
3756 |
|
|
3757 |
109 |
List<SequenceI> tmpseqs = new ArrayList<>(); |
3758 |
|
|
3759 |
109 |
boolean multipleView = false; |
3760 |
109 |
SequenceI referenceseqForView = null; |
3761 |
|
|
3762 |
109 |
List<JSeq> jseqs = jalviewModel.getJSeq(); |
3763 |
109 |
int vi = 0; |
3764 |
1613 |
for (int i = 0; i < jseqs.size(); i++) |
3765 |
|
{ |
3766 |
1504 |
JSeq jseq = jseqs.get(i); |
3767 |
1504 |
String seqId = jseq.getId(); |
3768 |
|
|
3769 |
1504 |
SequenceI tmpSeq = seqRefIds.get(seqId); |
3770 |
1504 |
if (tmpSeq != null) |
3771 |
|
{ |
3772 |
1072 |
if (!incompleteSeqs.containsKey(seqId)) |
3773 |
|
{ |
3774 |
|
|
3775 |
1072 |
if (tmpSeq.getStart() != jseq.getStart() |
3776 |
|
|| tmpSeq.getEnd() != jseq.getEnd()) |
3777 |
|
{ |
3778 |
0 |
jalview.bin.Console.errPrintln(String.format( |
3779 |
|
"Warning JAL-2154 regression: updating start/end for sequence %s from %d/%d to %d/%d", |
3780 |
|
tmpSeq.getName(), tmpSeq.getStart(), tmpSeq.getEnd(), |
3781 |
|
jseq.getStart(), jseq.getEnd())); |
3782 |
|
} |
3783 |
|
} |
3784 |
|
else |
3785 |
|
{ |
3786 |
0 |
incompleteSeqs.remove(seqId); |
3787 |
|
} |
3788 |
1072 |
if (vamsasSeqs.size() > vi |
3789 |
|
&& vamsasSeqs.get(vi).getId().equals(seqId)) |
3790 |
|
{ |
3791 |
|
|
3792 |
|
|
3793 |
423 |
tmpSeq.setName(vamsasSeqs.get(vi).getName()); |
3794 |
423 |
tmpSeq.setDescription(vamsasSeqs.get(vi).getDescription()); |
3795 |
423 |
tmpSeq.setSequence(vamsasSeqs.get(vi).getSequence()); |
3796 |
423 |
vi++; |
3797 |
|
} |
3798 |
|
else |
3799 |
|
{ |
3800 |
|
|
3801 |
649 |
multipleView = true; |
3802 |
|
} |
3803 |
1072 |
tmpSeq.setStart(jseq.getStart()); |
3804 |
1072 |
tmpSeq.setEnd(jseq.getEnd()); |
3805 |
1072 |
tmpseqs.add(tmpSeq); |
3806 |
|
} |
3807 |
|
else |
3808 |
|
{ |
3809 |
432 |
Sequence vamsasSeq = vamsasSeqs.get(vi); |
3810 |
432 |
tmpSeq = new jalview.datamodel.Sequence(vamsasSeq.getName(), |
3811 |
|
vamsasSeq.getSequence()); |
3812 |
432 |
tmpSeq.setDescription(vamsasSeq.getDescription()); |
3813 |
432 |
tmpSeq.setStart(jseq.getStart()); |
3814 |
432 |
tmpSeq.setEnd(jseq.getEnd()); |
3815 |
432 |
tmpSeq.setVamsasId(uniqueSetSuffix + seqId); |
3816 |
432 |
seqRefIds.put(vamsasSeq.getId(), tmpSeq); |
3817 |
432 |
tmpseqs.add(tmpSeq); |
3818 |
432 |
vi++; |
3819 |
|
} |
3820 |
|
|
3821 |
1504 |
if (safeBoolean(jseq.isViewreference())) |
3822 |
|
{ |
3823 |
5 |
referenceseqForView = tmpseqs.get(tmpseqs.size() - 1); |
3824 |
|
} |
3825 |
|
|
3826 |
1504 |
if (jseq.isHidden() != null && jseq.isHidden().booleanValue()) |
3827 |
|
{ |
3828 |
186 |
if (hiddenSeqs == null) |
3829 |
|
{ |
3830 |
42 |
hiddenSeqs = new ArrayList<>(); |
3831 |
|
} |
3832 |
|
|
3833 |
186 |
hiddenSeqs.add(tmpSeq); |
3834 |
|
} |
3835 |
|
} |
3836 |
|
|
3837 |
|
|
3838 |
|
|
3839 |
|
|
3840 |
109 |
SequenceI[] orderedSeqs = tmpseqs |
3841 |
|
.toArray(new SequenceI[tmpseqs.size()]); |
3842 |
|
|
3843 |
109 |
AlignmentI al = null; |
3844 |
|
|
3845 |
|
|
3846 |
109 |
if (vamsasSet.getDatasetId() == null || vamsasSet.getDatasetId() == "") |
3847 |
|
{ |
3848 |
|
|
3849 |
|
|
3850 |
30 |
al = new Alignment(orderedSeqs); |
3851 |
30 |
al.setDataset(null); |
3852 |
|
} |
3853 |
|
else |
3854 |
|
{ |
3855 |
79 |
boolean isdsal = jalviewModel.getViewport().isEmpty(); |
3856 |
79 |
if (isdsal) |
3857 |
|
{ |
3858 |
|
|
3859 |
|
|
3860 |
24 |
al = getDatasetFor(vamsasSet.getDatasetId()); |
3861 |
|
} |
3862 |
79 |
if (al == null) |
3863 |
|
{ |
3864 |
|
|
3865 |
55 |
al = new Alignment(orderedSeqs); |
3866 |
|
} |
3867 |
79 |
if (isdsal) |
3868 |
|
{ |
3869 |
24 |
addDatasetRef(vamsasSet.getDatasetId(), al); |
3870 |
|
} |
3871 |
|
|
3872 |
|
|
3873 |
|
|
3874 |
79 |
recoverDatasetFor(vamsasSet, al, isdsal, uniqueSeqSetId); |
3875 |
|
} |
3876 |
|
|
3877 |
109 |
if (referenceseqForView != null) |
3878 |
|
{ |
3879 |
5 |
al.setSeqrep(referenceseqForView); |
3880 |
|
} |
3881 |
|
|
3882 |
130 |
for (int i = 0; i < vamsasSet.getSequenceSetProperties().size(); i++) |
3883 |
|
{ |
3884 |
21 |
SequenceSetProperties ssp = vamsasSet.getSequenceSetProperties() |
3885 |
|
.get(i); |
3886 |
21 |
al.setProperty(ssp.getKey(), ssp.getValue()); |
3887 |
|
} |
3888 |
|
|
3889 |
|
|
3890 |
|
|
3891 |
109 |
Hashtable pdbloaded = new Hashtable(); |
3892 |
109 |
if (!multipleView) |
3893 |
|
{ |
3894 |
|
|
3895 |
|
|
3896 |
|
|
3897 |
|
|
3898 |
|
|
3899 |
|
|
3900 |
|
|
3901 |
|
|
3902 |
921 |
for (int i = 0; i < vamsasSeqs.size(); i++) |
3903 |
|
{ |
3904 |
855 |
JSeq jseq = jseqs.get(i); |
3905 |
855 |
if (jseq.getFeatures().size() > 0) |
3906 |
|
{ |
3907 |
215 |
List<Feature> features = jseq.getFeatures(); |
3908 |
135641 |
for (int f = 0; f < features.size(); f++) |
3909 |
|
{ |
3910 |
135426 |
Feature feat = features.get(f); |
3911 |
135426 |
SequenceFeature sf = new SequenceFeature(feat.getType(), |
3912 |
|
feat.getDescription(), feat.getBegin(), feat.getEnd(), |
3913 |
|
safeFloat(feat.getScore()), feat.getFeatureGroup()); |
3914 |
135426 |
sf.setStatus(feat.getStatus()); |
3915 |
|
|
3916 |
|
|
3917 |
|
|
3918 |
|
|
3919 |
135426 |
Map<String, Map<String, String>> mapAttributes = new HashMap<>(); |
3920 |
652710 |
for (int od = 0; od < feat.getOtherData().size(); od++) |
3921 |
|
{ |
3922 |
517284 |
OtherData keyValue = feat.getOtherData().get(od); |
3923 |
517284 |
String attributeName = keyValue.getKey(); |
3924 |
517284 |
String attributeValue = keyValue.getValue(); |
3925 |
517284 |
if (attributeName.startsWith("LINK")) |
3926 |
|
{ |
3927 |
6558 |
sf.addLink(attributeValue); |
3928 |
|
} |
3929 |
|
else |
3930 |
|
{ |
3931 |
510726 |
String subAttribute = keyValue.getKey2(); |
3932 |
510726 |
if (subAttribute == null) |
3933 |
|
{ |
3934 |
|
|
3935 |
510706 |
sf.setValue(attributeName, attributeValue); |
3936 |
|
} |
3937 |
|
else |
3938 |
|
{ |
3939 |
|
|
3940 |
20 |
if (!mapAttributes.containsKey(attributeName)) |
3941 |
|
{ |
3942 |
20 |
mapAttributes.put(attributeName, new HashMap<>()); |
3943 |
|
} |
3944 |
20 |
mapAttributes.get(attributeName).put(subAttribute, |
3945 |
|
attributeValue); |
3946 |
|
} |
3947 |
|
} |
3948 |
|
} |
3949 |
135426 |
for (Entry<String, Map<String, String>> mapAttribute : mapAttributes |
3950 |
|
.entrySet()) |
3951 |
|
{ |
3952 |
20 |
sf.setValue(mapAttribute.getKey(), mapAttribute.getValue()); |
3953 |
|
} |
3954 |
|
|
3955 |
|
|
3956 |
135426 |
al.getSequenceAt(i).addSequenceFeature(sf); |
3957 |
|
} |
3958 |
|
} |
3959 |
855 |
if (vamsasSeqs.get(i).getDBRef().size() > 0) |
3960 |
|
{ |
3961 |
|
|
3962 |
207 |
addDBRefs( |
3963 |
207 |
al.getSequenceAt(i).getDatasetSequence() == null |
3964 |
|
? al.getSequenceAt(i) |
3965 |
|
: al.getSequenceAt(i).getDatasetSequence(), |
3966 |
|
vamsasSeqs.get(i)); |
3967 |
|
} |
3968 |
855 |
if (jseq.getPdbids().size() > 0) |
3969 |
|
{ |
3970 |
44 |
List<Pdbids> ids = jseq.getPdbids(); |
3971 |
295 |
for (int p = 0; p < ids.size(); p++) |
3972 |
|
{ |
3973 |
251 |
Pdbids pdbid = ids.get(p); |
3974 |
251 |
jalview.datamodel.PDBEntry entry = new jalview.datamodel.PDBEntry(); |
3975 |
251 |
entry.setId(pdbid.getId()); |
3976 |
251 |
if (pdbid.getType() != null) |
3977 |
|
{ |
3978 |
35 |
if (PDBEntry.Type.getType(pdbid.getType()) != null) |
3979 |
|
{ |
3980 |
35 |
entry.setType(PDBEntry.Type.getType(pdbid.getType())); |
3981 |
|
} |
3982 |
|
else |
3983 |
|
{ |
3984 |
0 |
entry.setType(PDBEntry.Type.FILE); |
3985 |
|
} |
3986 |
|
} |
3987 |
|
|
3988 |
251 |
if (pdbid.getFile() != null && jprovider != null) |
3989 |
|
{ |
3990 |
32 |
if (!pdbloaded.containsKey(pdbid.getFile())) |
3991 |
|
{ |
3992 |
32 |
entry.setFile(loadPDBFile(jprovider, pdbid.getId(), |
3993 |
|
pdbid.getFile())); |
3994 |
|
} |
3995 |
|
else |
3996 |
|
{ |
3997 |
0 |
entry.setFile(pdbloaded.get(pdbid.getId()).toString()); |
3998 |
|
} |
3999 |
|
} |
4000 |
|
|
4001 |
|
|
4002 |
|
|
4003 |
|
|
4004 |
|
|
4005 |
|
|
4006 |
|
|
4007 |
|
|
4008 |
|
|
4009 |
|
|
4010 |
|
|
4011 |
|
|
4012 |
251 |
for (Property prop : pdbid.getProperty()) |
4013 |
|
{ |
4014 |
20 |
entry.setProperty(prop.getName(), prop.getValue()); |
4015 |
|
} |
4016 |
251 |
StructureSelectionManager |
4017 |
|
.getStructureSelectionManager(Desktop.instance) |
4018 |
|
.registerPDBEntry(entry); |
4019 |
|
|
4020 |
251 |
if (al.getSequenceAt(i).getDatasetSequence() != null) |
4021 |
|
{ |
4022 |
101 |
al.getSequenceAt(i).getDatasetSequence().addPDBId(entry); |
4023 |
|
} |
4024 |
|
else |
4025 |
|
{ |
4026 |
150 |
al.getSequenceAt(i).addPDBId(entry); |
4027 |
|
} |
4028 |
|
} |
4029 |
|
} |
4030 |
|
} |
4031 |
|
} |
4032 |
|
|
4033 |
|
|
4034 |
|
|
4035 |
|
|
4036 |
109 |
if (vamsasSet.getAlcodonFrame().size() > 0) |
4037 |
|
{ |
4038 |
|
|
4039 |
|
|
4040 |
0 |
List<AlcodonFrame> alc = vamsasSet.getAlcodonFrame(); |
4041 |
0 |
for (int i = 0; i < alc.size(); i++) |
4042 |
|
{ |
4043 |
0 |
AlignedCodonFrame cf = new AlignedCodonFrame(); |
4044 |
0 |
if (alc.get(i).getAlcodMap().size() > 0) |
4045 |
|
{ |
4046 |
0 |
List<AlcodMap> maps = alc.get(i).getAlcodMap(); |
4047 |
0 |
for (int m = 0; m < maps.size(); m++) |
4048 |
|
{ |
4049 |
0 |
AlcodMap map = maps.get(m); |
4050 |
0 |
SequenceI dnaseq = seqRefIds.get(map.getDnasq()); |
4051 |
|
|
4052 |
0 |
jalview.datamodel.Mapping mapping = null; |
4053 |
|
|
4054 |
0 |
if (map.getMapping() != null) |
4055 |
|
{ |
4056 |
0 |
mapping = addMapping(map.getMapping()); |
4057 |
0 |
if (dnaseq != null && mapping.getTo() != null) |
4058 |
|
{ |
4059 |
0 |
cf.addMap(dnaseq, mapping.getTo(), mapping.getMap()); |
4060 |
|
} |
4061 |
|
else |
4062 |
|
{ |
4063 |
|
|
4064 |
0 |
frefedSequence |
4065 |
|
.add(newAlcodMapRef(map.getDnasq(), cf, mapping)); |
4066 |
|
} |
4067 |
|
} |
4068 |
|
} |
4069 |
0 |
al.addCodonFrame(cf); |
4070 |
|
} |
4071 |
|
} |
4072 |
|
} |
4073 |
|
|
4074 |
|
|
4075 |
|
|
4076 |
109 |
List<JvAnnotRow> autoAlan = new ArrayList<>(); |
4077 |
|
|
4078 |
|
|
4079 |
|
|
4080 |
|
|
4081 |
109 |
Map<String, List<AlignmentAnnotation>> groupAnnotRefs = new Hashtable<>(); |
4082 |
|
|
4083 |
109 |
if (vamsasSet.getAnnotation().size() > 0) |
4084 |
|
{ |
4085 |
91 |
List<Annotation> an = vamsasSet.getAnnotation(); |
4086 |
|
|
4087 |
681 |
for (int i = 0; i < an.size(); i++) |
4088 |
|
{ |
4089 |
590 |
Annotation annotation = an.get(i); |
4090 |
|
|
4091 |
|
|
4092 |
|
|
4093 |
|
|
4094 |
590 |
boolean autoForView = false; |
4095 |
590 |
if (annotation.getLabel().equals("Quality") |
4096 |
|
|| annotation.getLabel().equals("Conservation") |
4097 |
|
|| annotation.getLabel().equals("Consensus")) |
4098 |
|
{ |
4099 |
|
|
4100 |
231 |
autoForView = true; |
4101 |
|
|
4102 |
|
|
4103 |
|
|
4104 |
|
|
4105 |
|
|
4106 |
|
} |
4107 |
590 |
if (autoForView || annotation.isAutoCalculated()) |
4108 |
|
{ |
4109 |
|
|
4110 |
|
|
4111 |
298 |
annotation.setId(null); |
4112 |
|
} |
4113 |
|
|
4114 |
|
|
4115 |
590 |
String annotationId = annotation.getId(); |
4116 |
590 |
if (annotationId != null && annotationIds.containsKey(annotationId)) |
4117 |
|
{ |
4118 |
6 |
AlignmentAnnotation jda = annotationIds.get(annotationId); |
4119 |
|
|
4120 |
|
|
4121 |
6 |
if (annotation.isVisible() != null) |
4122 |
|
{ |
4123 |
6 |
jda.visible = annotation.isVisible(); |
4124 |
|
} |
4125 |
|
|
4126 |
6 |
al.addAnnotation(jda); |
4127 |
|
|
4128 |
6 |
continue; |
4129 |
|
} |
4130 |
|
|
4131 |
584 |
List<AnnotationElement> ae = annotation.getAnnotationElement(); |
4132 |
584 |
jalview.datamodel.Annotation[] anot = null; |
4133 |
584 |
java.awt.Color firstColour = null; |
4134 |
584 |
int anpos; |
4135 |
584 |
if (!annotation.isScoreOnly()) |
4136 |
|
{ |
4137 |
584 |
anot = new jalview.datamodel.Annotation[al.getWidth()]; |
4138 |
270135 |
for (int aa = 0; aa < ae.size() && aa < anot.length; aa++) |
4139 |
|
{ |
4140 |
269551 |
AnnotationElement annElement = ae.get(aa); |
4141 |
269551 |
anpos = annElement.getPosition(); |
4142 |
|
|
4143 |
269551 |
if (anpos >= anot.length) |
4144 |
|
{ |
4145 |
0 |
continue; |
4146 |
|
} |
4147 |
|
|
4148 |
269551 |
float value = safeFloat(annElement.getValue()); |
4149 |
269551 |
anot[anpos] = new jalview.datamodel.Annotation( |
4150 |
|
annElement.getDisplayCharacter(), |
4151 |
|
annElement.getDescription(), |
4152 |
269551 |
(annElement.getSecondaryStructure() == null |
4153 |
|
|| annElement.getSecondaryStructure() |
4154 |
|
.length() == 0) |
4155 |
|
? ' ' |
4156 |
|
: annElement |
4157 |
|
.getSecondaryStructure() |
4158 |
|
.charAt(0), |
4159 |
|
value); |
4160 |
269551 |
anot[anpos].colour = new Color(safeInt(annElement.getColour())); |
4161 |
269551 |
if (firstColour == null) |
4162 |
|
{ |
4163 |
573 |
firstColour = anot[anpos].colour; |
4164 |
|
} |
4165 |
|
} |
4166 |
|
} |
4167 |
584 |
jalview.datamodel.AlignmentAnnotation jaa = null; |
4168 |
|
|
4169 |
584 |
if (annotation.isGraph()) |
4170 |
|
{ |
4171 |
402 |
float llim = 0, hlim = 0; |
4172 |
|
|
4173 |
|
|
4174 |
|
|
4175 |
402 |
jaa = new jalview.datamodel.AlignmentAnnotation( |
4176 |
|
annotation.getLabel(), annotation.getDescription(), anot, |
4177 |
|
llim, hlim, safeInt(annotation.getGraphType())); |
4178 |
|
|
4179 |
402 |
jaa.graphGroup = safeInt(annotation.getGraphGroup()); |
4180 |
402 |
jaa._linecolour = firstColour; |
4181 |
402 |
if (annotation.getThresholdLine() != null) |
4182 |
|
{ |
4183 |
30 |
jaa.setThreshold(new jalview.datamodel.GraphLine( |
4184 |
|
safeFloat(annotation.getThresholdLine().getValue()), |
4185 |
|
annotation.getThresholdLine().getLabel(), |
4186 |
|
new java.awt.Color(safeInt( |
4187 |
|
annotation.getThresholdLine().getColour())))); |
4188 |
|
} |
4189 |
402 |
if (autoForView || annotation.isAutoCalculated()) |
4190 |
|
{ |
4191 |
|
|
4192 |
|
|
4193 |
298 |
jaa.hasText = true; |
4194 |
|
} |
4195 |
|
} |
4196 |
|
else |
4197 |
|
{ |
4198 |
182 |
jaa = new jalview.datamodel.AlignmentAnnotation( |
4199 |
|
annotation.getLabel(), annotation.getDescription(), anot); |
4200 |
182 |
jaa._linecolour = firstColour; |
4201 |
|
} |
4202 |
|
|
4203 |
584 |
if (annotation.getId() != null) |
4204 |
|
{ |
4205 |
286 |
annotationIds.put(annotation.getId(), jaa); |
4206 |
286 |
jaa.annotationId = annotation.getId(); |
4207 |
|
} |
4208 |
|
|
4209 |
584 |
String sequenceRef = annotation.getSequenceRef(); |
4210 |
584 |
if (sequenceRef != null) |
4211 |
|
{ |
4212 |
|
|
4213 |
203 |
SequenceI sequence = seqRefIds.get(sequenceRef); |
4214 |
203 |
if (sequence == null) |
4215 |
|
{ |
4216 |
|
|
4217 |
0 |
sequence = al.findName(sequenceRef); |
4218 |
|
} |
4219 |
203 |
if (sequence != null) |
4220 |
|
{ |
4221 |
203 |
jaa.createSequenceMapping(sequence, 1, true); |
4222 |
203 |
sequence.addAlignmentAnnotation(jaa); |
4223 |
|
} |
4224 |
|
} |
4225 |
|
|
4226 |
584 |
if (annotation.getGroupRef() != null |
4227 |
|
&& annotation.getGroupRef().length() > 0) |
4228 |
|
{ |
4229 |
24 |
List<jalview.datamodel.AlignmentAnnotation> aal = groupAnnotRefs |
4230 |
|
.get(annotation.getGroupRef()); |
4231 |
24 |
if (aal == null) |
4232 |
|
{ |
4233 |
24 |
aal = new ArrayList<>(); |
4234 |
24 |
groupAnnotRefs.put(annotation.getGroupRef(), aal); |
4235 |
|
} |
4236 |
24 |
aal.add(jaa); |
4237 |
|
} |
4238 |
|
|
4239 |
584 |
if (annotation.getScore() != null) |
4240 |
|
{ |
4241 |
139 |
jaa.setScore(annotation.getScore().doubleValue()); |
4242 |
|
} |
4243 |
584 |
if (annotation.isVisible() != null) |
4244 |
|
{ |
4245 |
584 |
jaa.visible = annotation.isVisible().booleanValue(); |
4246 |
|
} |
4247 |
|
|
4248 |
584 |
if (annotation.isCentreColLabels() != null) |
4249 |
|
{ |
4250 |
584 |
jaa.centreColLabels = annotation.isCentreColLabels() |
4251 |
|
.booleanValue(); |
4252 |
|
} |
4253 |
|
|
4254 |
584 |
if (annotation.isScaleColLabels() != null) |
4255 |
|
{ |
4256 |
584 |
jaa.scaleColLabel = annotation.isScaleColLabels().booleanValue(); |
4257 |
|
} |
4258 |
584 |
if (annotation.isAutoCalculated()) |
4259 |
|
{ |
4260 |
|
|
4261 |
|
|
4262 |
298 |
jaa.autoCalculated = true; |
4263 |
|
|
4264 |
|
} |
4265 |
584 |
if (annotation.getGraphHeight() != null) |
4266 |
|
{ |
4267 |
584 |
jaa.graphHeight = annotation.getGraphHeight().intValue(); |
4268 |
|
} |
4269 |
584 |
jaa.belowAlignment = annotation.isBelowAlignment(); |
4270 |
584 |
jaa.setCalcId(annotation.getCalcId()); |
4271 |
584 |
if (annotation.getProperty().size() > 0) |
4272 |
|
{ |
4273 |
0 |
for (jalview.xml.binding.jalview.Property prop : annotation |
4274 |
|
.getProperty()) |
4275 |
|
{ |
4276 |
0 |
jaa.setProperty(prop.getName(), prop.getValue()); |
4277 |
|
} |
4278 |
|
} |
4279 |
584 |
if (jaa.graph == AlignmentAnnotation.CONTACT_MAP) |
4280 |
|
{ |
4281 |
3 |
if (annotation.getContactmatrix() != null |
4282 |
|
&& annotation.getContactmatrix().size() > 0) |
4283 |
|
{ |
4284 |
3 |
for (MapOnAMatrixType xmlmat : annotation.getContactmatrix()) |
4285 |
|
{ |
4286 |
3 |
restoreMatrixFor(jaa.sequenceRef, jaa, xmlmat); |
4287 |
|
} |
4288 |
|
} |
4289 |
|
} |
4290 |
|
|
4291 |
584 |
if (jaa.autoCalculated) |
4292 |
|
{ |
4293 |
298 |
autoAlan.add(new JvAnnotRow(i, jaa)); |
4294 |
|
} |
4295 |
|
else |
4296 |
|
|
4297 |
|
{ |
4298 |
|
|
4299 |
|
|
4300 |
286 |
al.addAnnotation(jaa); |
4301 |
|
} |
4302 |
|
} |
4303 |
|
} |
4304 |
|
|
4305 |
|
|
4306 |
|
|
4307 |
109 |
if (jalviewModel.getJGroup().size() > 0) |
4308 |
|
{ |
4309 |
31 |
List<JGroup> groups = jalviewModel.getJGroup(); |
4310 |
31 |
boolean addAnnotSchemeGroup = false; |
4311 |
78 |
for (int i = 0; i < groups.size(); i++) |
4312 |
|
{ |
4313 |
47 |
JGroup jGroup = groups.get(i); |
4314 |
47 |
ColourSchemeI cs = null; |
4315 |
47 |
if (jGroup.getColour() != null) |
4316 |
|
{ |
4317 |
23 |
if (jGroup.getColour().startsWith("ucs")) |
4318 |
|
{ |
4319 |
0 |
cs = getUserColourScheme(jalviewModel, jGroup.getColour()); |
4320 |
|
} |
4321 |
23 |
else if (jGroup.getColour().equals("AnnotationColourGradient") |
4322 |
|
&& jGroup.getAnnotationColours() != null) |
4323 |
|
{ |
4324 |
1 |
addAnnotSchemeGroup = true; |
4325 |
|
} |
4326 |
|
else |
4327 |
|
{ |
4328 |
22 |
cs = ColourSchemeProperty.getColourScheme(null, al, |
4329 |
|
jGroup.getColour()); |
4330 |
|
} |
4331 |
|
} |
4332 |
47 |
int pidThreshold = safeInt(jGroup.getPidThreshold()); |
4333 |
|
|
4334 |
47 |
Vector<SequenceI> seqs = new Vector<>(); |
4335 |
|
|
4336 |
431 |
for (int s = 0; s < jGroup.getSeq().size(); s++) |
4337 |
|
{ |
4338 |
384 |
String seqId = jGroup.getSeq().get(s); |
4339 |
384 |
SequenceI ts = seqRefIds.get(seqId); |
4340 |
|
|
4341 |
384 |
if (ts != null) |
4342 |
|
{ |
4343 |
384 |
seqs.addElement(ts); |
4344 |
|
} |
4345 |
|
} |
4346 |
|
|
4347 |
47 |
if (seqs.size() < 1) |
4348 |
|
{ |
4349 |
0 |
continue; |
4350 |
|
} |
4351 |
|
|
4352 |
47 |
SequenceGroup sg = new SequenceGroup(seqs, jGroup.getName(), cs, |
4353 |
|
safeBoolean(jGroup.isDisplayBoxes()), |
4354 |
|
safeBoolean(jGroup.isDisplayText()), |
4355 |
|
safeBoolean(jGroup.isColourText()), |
4356 |
|
safeInt(jGroup.getStart()), safeInt(jGroup.getEnd())); |
4357 |
47 |
sg.getGroupColourScheme().setThreshold(pidThreshold, true); |
4358 |
47 |
sg.getGroupColourScheme() |
4359 |
|
.setConservationInc(safeInt(jGroup.getConsThreshold())); |
4360 |
47 |
sg.setOutlineColour(new Color(safeInt(jGroup.getOutlineColour()))); |
4361 |
|
|
4362 |
47 |
sg.textColour = new Color(safeInt(jGroup.getTextCol1())); |
4363 |
47 |
sg.textColour2 = new Color(safeInt(jGroup.getTextCol2())); |
4364 |
47 |
sg.setShowNonconserved(safeBoolean(jGroup.isShowUnconserved())); |
4365 |
47 |
sg.thresholdTextColour = safeInt(jGroup.getTextColThreshold()); |
4366 |
|
|
4367 |
47 |
sg.setShowConsensusHistogram(jGroup.isShowConsensusHistogram()); |
4368 |
47 |
sg.setshowSequenceLogo(jGroup.isShowSequenceLogo()); |
4369 |
47 |
sg.setNormaliseSequenceLogo(jGroup.isNormaliseSequenceLogo()); |
4370 |
47 |
sg.setIgnoreGapsConsensus(jGroup.isIgnoreGapsinConsensus()); |
4371 |
47 |
if (jGroup.getConsThreshold() != null |
4372 |
|
&& jGroup.getConsThreshold().intValue() != 0) |
4373 |
|
{ |
4374 |
2 |
Conservation c = new Conservation("All", sg.getSequences(null), 0, |
4375 |
|
sg.getWidth() - 1); |
4376 |
2 |
c.calculate(); |
4377 |
2 |
c.verdict(false, 25); |
4378 |
2 |
sg.cs.setConservation(c); |
4379 |
|
} |
4380 |
|
|
4381 |
47 |
if (jGroup.getId() != null && groupAnnotRefs.size() > 0) |
4382 |
|
{ |
4383 |
|
|
4384 |
24 |
List<AlignmentAnnotation> jaal = groupAnnotRefs |
4385 |
|
.get(jGroup.getId()); |
4386 |
24 |
if (jaal != null) |
4387 |
|
{ |
4388 |
24 |
for (AlignmentAnnotation jaa : jaal) |
4389 |
|
{ |
4390 |
24 |
jaa.groupRef = sg; |
4391 |
24 |
if (jaa.autoCalculated) |
4392 |
|
{ |
4393 |
|
|
4394 |
|
|
4395 |
24 |
if (jaa.label.startsWith("Consensus for ")) |
4396 |
|
{ |
4397 |
24 |
sg.setConsensus(jaa); |
4398 |
|
} |
4399 |
|
|
4400 |
|
|
4401 |
24 |
if (jaa.label.startsWith("Conservation for ")) |
4402 |
|
{ |
4403 |
0 |
sg.setConservationRow(jaa); |
4404 |
|
} |
4405 |
|
} |
4406 |
|
} |
4407 |
|
} |
4408 |
|
} |
4409 |
47 |
al.addGroup(sg); |
4410 |
47 |
if (addAnnotSchemeGroup) |
4411 |
|
{ |
4412 |
|
|
4413 |
1 |
sg.setColourScheme( |
4414 |
|
constructAnnotationColour(jGroup.getAnnotationColours(), |
4415 |
|
null, al, jalviewModel, false)); |
4416 |
|
} |
4417 |
|
} |
4418 |
|
} |
4419 |
109 |
if (view == null) |
4420 |
|
{ |
4421 |
|
|
4422 |
24 |
return null; |
4423 |
|
} |
4424 |
|
|
4425 |
|
|
4426 |
|
|
4427 |
85 |
AlignFrame af = null; |
4428 |
85 |
AlignViewport av = null; |
4429 |
|
|
4430 |
85 |
if (multipleView && viewportsAdded.size() == 0) |
4431 |
|
{ |
4432 |
|
|
4433 |
|
|
4434 |
|
|
4435 |
|
|
4436 |
|
|
4437 |
|
|
4438 |
|
|
4439 |
0 |
jalview.bin.Console.errPrintln( |
4440 |
|
"About to recover a viewport for existing alignment: Sequence set ID is " |
4441 |
|
+ uniqueSeqSetId); |
4442 |
0 |
Object seqsetobj = retrieveExistingObj(uniqueSeqSetId); |
4443 |
0 |
if (seqsetobj != null) |
4444 |
|
{ |
4445 |
0 |
if (seqsetobj instanceof String) |
4446 |
|
{ |
4447 |
0 |
uniqueSeqSetId = (String) seqsetobj; |
4448 |
0 |
jalview.bin.Console.errPrintln( |
4449 |
|
"Recovered extant sequence set ID mapping for ID : New Sequence set ID is " |
4450 |
|
+ uniqueSeqSetId); |
4451 |
|
} |
4452 |
|
else |
4453 |
|
{ |
4454 |
0 |
jalview.bin.Console.errPrintln( |
4455 |
|
"Warning : Collision between sequence set ID string and existing jalview object mapping."); |
4456 |
|
} |
4457 |
|
|
4458 |
|
} |
4459 |
|
} |
4460 |
|
|
4461 |
|
|
4462 |
|
|
4463 |
|
|
4464 |
85 |
boolean doGroupAnnColour = Jalview2XML.isVersionStringLaterThan("2.8.1", |
4465 |
|
jalviewModel.getVersion()); |
4466 |
|
|
4467 |
85 |
AlignmentPanel ap = null; |
4468 |
85 |
boolean isnewview = true; |
4469 |
85 |
if (viewId != null) |
4470 |
|
{ |
4471 |
|
|
4472 |
75 |
jalview.gui.AlignmentPanel views[] = Desktop |
4473 |
|
.getAlignmentPanels(uniqueSeqSetId); |
4474 |
75 |
if (views != null && views.length > 0) |
4475 |
|
{ |
4476 |
139 |
for (int v = 0; v < views.length; v++) |
4477 |
|
{ |
4478 |
96 |
if (views[v].av.getViewId().equalsIgnoreCase(viewId)) |
4479 |
|
{ |
4480 |
|
|
4481 |
0 |
af = views[v].alignFrame; |
4482 |
0 |
av = views[v].av; |
4483 |
0 |
ap = views[v]; |
4484 |
|
|
4485 |
|
|
4486 |
0 |
isnewview = false; |
4487 |
|
} |
4488 |
|
} |
4489 |
|
} |
4490 |
|
} |
4491 |
|
|
4492 |
85 |
if (isnewview) |
4493 |
|
{ |
4494 |
85 |
af = loadViewport(file, jseqs, hiddenSeqs, al, jalviewModel, view, |
4495 |
|
uniqueSeqSetId, viewId, autoAlan); |
4496 |
85 |
av = af.getViewport(); |
4497 |
85 |
ap = af.alignPanel; |
4498 |
|
} |
4499 |
|
|
4500 |
|
|
4501 |
|
|
4502 |
|
|
4503 |
|
|
4504 |
|
|
4505 |
85 |
if (loadTreesAndStructures) |
4506 |
|
{ |
4507 |
75 |
loadTrees(jalviewModel, view, af, av, ap); |
4508 |
75 |
loadPCAViewers(jalviewModel, ap); |
4509 |
75 |
loadPaSiMapViewers(jalviewModel, ap); |
4510 |
75 |
loadPDBStructures(jprovider, jseqs, af, ap); |
4511 |
75 |
loadRnaViewers(jprovider, jseqs, ap); |
4512 |
75 |
loadOverview(view, jalviewModel.getVersion(), af); |
4513 |
|
} |
4514 |
|
|
4515 |
84 |
return af; |
4516 |
|
} |
4517 |
|
|
|
|
| 67.6% |
Uncovered Elements: 11 (34) |
Complexity: 7 |
Complexity Density: 0.32 |
|
4518 |
2 |
private void importMatrixData(List<MatrixType> xmlmatrices)... |
4519 |
|
{ |
4520 |
2 |
for (MatrixType xmlmat : xmlmatrices) |
4521 |
|
{ |
4522 |
2 |
if (!PAEContactMatrix.PAEMATRIX.equals(xmlmat.getType())) |
4523 |
|
{ |
4524 |
0 |
Console.error("Ignoring matrix '" + xmlmat.getId() + "' of type '" |
4525 |
|
+ xmlmat.getType()); |
4526 |
0 |
continue; |
4527 |
|
} |
4528 |
|
|
4529 |
2 |
if (!xmlmat.getRows().equals(xmlmat.getCols())) |
4530 |
|
{ |
4531 |
0 |
Console.error("Can't handle non square matrices"); |
4532 |
0 |
continue; |
4533 |
|
} |
4534 |
|
|
4535 |
2 |
float[][] elements = ContactMatrix.fromFloatStringToContacts( |
4536 |
|
xmlmat.getElements(), xmlmat.getCols().intValue(), |
4537 |
|
xmlmat.getRows().intValue()); |
4538 |
|
|
4539 |
2 |
List<BitSet> newgroups = new ArrayList<BitSet>(); |
4540 |
2 |
if (xmlmat.getGroups().size() > 0) |
4541 |
|
{ |
4542 |
2 |
for (String sgroup : xmlmat.getGroups()) |
4543 |
|
{ |
4544 |
6 |
newgroups.add(deStringifyBitset(sgroup)); |
4545 |
|
} |
4546 |
|
} |
4547 |
2 |
String nwk = xmlmat.getNewick().size() > 0 ? xmlmat.getNewick().get(0) |
4548 |
|
: null; |
4549 |
2 |
if (xmlmat.getNewick().size() > 1) |
4550 |
|
{ |
4551 |
0 |
Console.log |
4552 |
|
.info("Ignoring additional clusterings for contact matrix"); |
4553 |
|
} |
4554 |
2 |
String treeMethod = xmlmat.getTreeMethod(); |
4555 |
2 |
double thresh = xmlmat.getCutHeight() != null ? xmlmat.getCutHeight() |
4556 |
|
: 0; |
4557 |
2 |
GroupSet grpset = new GroupSet(); |
4558 |
2 |
grpset.restoreGroups(newgroups, treeMethod, nwk, thresh); |
4559 |
|
|
4560 |
2 |
FloatContactMatrix newcm = new FloatContactMatrix(elements, grpset); |
4561 |
2 |
contactMatrixRefs.put(xmlmat.getId(), newcm); |
4562 |
2 |
Console.trace("Restored base contact matrix " + xmlmat.getId()); |
4563 |
|
} |
4564 |
|
} |
4565 |
|
|
|
|
| 86.7% |
Uncovered Elements: 4 (30) |
Complexity: 5 |
Complexity Density: 0.23 |
|
4566 |
3 |
private void restoreMatrixFor(SequenceI sequenceRef,... |
4567 |
|
AlignmentAnnotation jaa, MapOnAMatrixType xmlmatmapping) |
4568 |
|
{ |
4569 |
|
|
4570 |
3 |
jalview.util.MapList mapping = null; |
4571 |
3 |
if (xmlmatmapping.getMapping() != null) |
4572 |
|
{ |
4573 |
3 |
MapListType m = xmlmatmapping.getMapping(); |
4574 |
|
|
4575 |
3 |
int fr[] = new int[m.getMapListFrom().size() * 2]; |
4576 |
3 |
Iterator<MapListFrom> from = m.getMapListFrom().iterator(); |
4577 |
6 |
for (int _i = 0; from.hasNext(); _i += 2) |
4578 |
|
{ |
4579 |
3 |
MapListFrom mf = from.next(); |
4580 |
3 |
fr[_i] = mf.getStart(); |
4581 |
3 |
fr[_i + 1] = mf.getEnd(); |
4582 |
|
} |
4583 |
3 |
int fto[] = new int[m.getMapListTo().size() * 2]; |
4584 |
3 |
Iterator<MapListTo> to = m.getMapListTo().iterator(); |
4585 |
6 |
for (int _i = 0; to.hasNext(); _i += 2) |
4586 |
|
{ |
4587 |
3 |
MapListTo mf = to.next(); |
4588 |
3 |
fto[_i] = mf.getStart(); |
4589 |
3 |
fto[_i + 1] = mf.getEnd(); |
4590 |
|
} |
4591 |
|
|
4592 |
3 |
mapping = new jalview.util.MapList(fr, fto, |
4593 |
|
m.getMapFromUnit().intValue(), m.getMapToUnit().intValue()); |
4594 |
|
} |
4595 |
|
|
4596 |
|
|
4597 |
3 |
ContactMatrixI cm = contactMatrixRefs.get(xmlmatmapping.getMatrix()); |
4598 |
3 |
if (cm == null) |
4599 |
|
{ |
4600 |
3 |
frefedSequence |
4601 |
|
.add(newMatrixFref(xmlmatmapping.getMatrix(), mapping, jaa)); |
4602 |
|
} |
4603 |
|
else |
4604 |
|
{ |
4605 |
|
|
4606 |
0 |
PAEContactMatrix newpae = new PAEContactMatrix(jaa.sequenceRef, |
4607 |
|
mapping, cm); |
4608 |
|
|
4609 |
0 |
jaa.sequenceRef.addContactListFor(jaa, newpae); |
4610 |
|
} |
4611 |
|
|
4612 |
3 |
return; |
4613 |
|
} |
4614 |
|
|
4615 |
|
|
4616 |
|
|
4617 |
|
|
4618 |
|
|
4619 |
|
@param |
4620 |
|
@param |
4621 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (16) |
Complexity: 4 |
Complexity Density: 0.33 |
|
4622 |
75 |
protected void loadOverview(Viewport view, String version, AlignFrame af)... |
4623 |
|
{ |
4624 |
75 |
if (!isVersionStringLaterThan("2.11.3", version) |
4625 |
|
&& view.getOverview() == null) |
4626 |
|
{ |
4627 |
43 |
return; |
4628 |
|
} |
4629 |
|
|
4630 |
|
|
4631 |
|
|
4632 |
|
|
4633 |
|
|
4634 |
32 |
af.alignPanel.closeOverviewPanel(); |
4635 |
|
|
4636 |
31 |
Overview overview = view.getOverview(); |
4637 |
31 |
if (overview != null) |
4638 |
|
{ |
4639 |
10 |
OverviewPanel overviewPanel = af |
4640 |
|
.openOverviewPanel(overview.isShowHidden()); |
4641 |
10 |
overviewPanel.setTitle(overview.getTitle()); |
4642 |
10 |
overviewPanel.setFrameBounds(overview.getXpos(), overview.getYpos(), |
4643 |
|
overview.getWidth(), overview.getHeight()); |
4644 |
10 |
Color gap = new Color(overview.getGapColour()); |
4645 |
10 |
Color residue = new Color(overview.getResidueColour()); |
4646 |
10 |
Color hidden = new Color(overview.getHiddenColour()); |
4647 |
10 |
overviewPanel.getCanvas().setColours(gap, residue, hidden); |
4648 |
|
} |
4649 |
|
} |
4650 |
|
|
4651 |
|
|
4652 |
|
|
4653 |
|
|
4654 |
|
|
4655 |
|
|
4656 |
|
|
4657 |
|
|
4658 |
|
|
4659 |
|
|
4660 |
|
@param |
4661 |
|
@param |
4662 |
|
@param |
4663 |
|
|
|
|
| 15.8% |
Uncovered Elements: 16 (19) |
Complexity: 3 |
Complexity Density: 0.2 |
|
4664 |
75 |
private void loadRnaViewers(jarInputStreamProvider jprovider,... |
4665 |
|
List<JSeq> jseqs, AlignmentPanel ap) |
4666 |
|
{ |
4667 |
|
|
4668 |
|
|
4669 |
|
|
4670 |
|
|
4671 |
75 |
for (JSeq jseq : jseqs) |
4672 |
|
{ |
4673 |
1070 |
for (int i = 0; i < jseq.getRnaViewer().size(); i++) |
4674 |
|
{ |
4675 |
0 |
RnaViewer viewer = jseq.getRnaViewer().get(i); |
4676 |
0 |
AppVarna appVarna = findOrCreateVarnaViewer(viewer, uniqueSetSuffix, |
4677 |
|
ap); |
4678 |
|
|
4679 |
0 |
for (int j = 0; j < viewer.getSecondaryStructure().size(); j++) |
4680 |
|
{ |
4681 |
0 |
SecondaryStructure ss = viewer.getSecondaryStructure().get(j); |
4682 |
0 |
SequenceI seq = seqRefIds.get(jseq.getId()); |
4683 |
0 |
AlignmentAnnotation ann = this.annotationIds |
4684 |
|
.get(ss.getAnnotationId()); |
4685 |
|
|
4686 |
|
|
4687 |
|
|
4688 |
|
|
4689 |
|
|
4690 |
0 |
boolean gapped = safeBoolean(ss.isGapped()); |
4691 |
0 |
String rnaTitle = ss.getTitle(); |
4692 |
0 |
String sessionState = ss.getViewerState(); |
4693 |
0 |
String tempStateFile = copyJarEntry(jprovider, sessionState, |
4694 |
|
"varna", null); |
4695 |
0 |
RnaModel rna = new RnaModel(rnaTitle, ann, seq, null, gapped); |
4696 |
0 |
appVarna.addModelSession(rna, rnaTitle, tempStateFile); |
4697 |
|
} |
4698 |
0 |
appVarna.setInitialSelection(safeInt(viewer.getSelectedRna())); |
4699 |
|
} |
4700 |
|
} |
4701 |
|
} |
4702 |
|
|
4703 |
|
|
4704 |
|
|
4705 |
|
|
4706 |
|
|
4707 |
|
@param |
4708 |
|
@param |
4709 |
|
@param |
4710 |
|
@return |
4711 |
|
|
|
|
| 0% |
Uncovered Elements: 13 (13) |
Complexity: 3 |
Complexity Density: 0.33 |
|
4712 |
0 |
protected AppVarna findOrCreateVarnaViewer(RnaViewer viewer,... |
4713 |
|
String viewIdSuffix, AlignmentPanel ap) |
4714 |
|
{ |
4715 |
|
|
4716 |
|
|
4717 |
|
|
4718 |
|
|
4719 |
0 |
String postLoadId = viewer.getViewId() + viewIdSuffix; |
4720 |
0 |
for (JInternalFrame frame : getAllFrames()) |
4721 |
|
{ |
4722 |
0 |
if (frame instanceof AppVarna) |
4723 |
|
{ |
4724 |
0 |
AppVarna varna = (AppVarna) frame; |
4725 |
0 |
if (postLoadId.equals(varna.getViewId())) |
4726 |
|
{ |
4727 |
|
|
4728 |
|
|
4729 |
|
|
4730 |
0 |
return varna; |
4731 |
|
} |
4732 |
|
} |
4733 |
|
} |
4734 |
|
|
4735 |
|
|
4736 |
|
|
4737 |
|
|
4738 |
0 |
RnaViewerModel model = new RnaViewerModel(postLoadId, viewer.getTitle(), |
4739 |
|
safeInt(viewer.getXpos()), safeInt(viewer.getYpos()), |
4740 |
|
safeInt(viewer.getWidth()), safeInt(viewer.getHeight()), |
4741 |
|
safeInt(viewer.getDividerLocation())); |
4742 |
0 |
AppVarna varna = new AppVarna(model, ap); |
4743 |
|
|
4744 |
0 |
return varna; |
4745 |
|
} |
4746 |
|
|
4747 |
|
|
4748 |
|
|
4749 |
|
|
4750 |
|
@param |
4751 |
|
@param |
4752 |
|
@param |
4753 |
|
@param |
4754 |
|
@param |
4755 |
|
|
|
|
| 57.1% |
Uncovered Elements: 21 (49) |
Complexity: 10 |
Complexity Density: 0.3 |
|
4756 |
75 |
protected void loadTrees(JalviewModel jm, Viewport view, AlignFrame af,... |
4757 |
|
AlignViewport av, AlignmentPanel ap) |
4758 |
|
{ |
4759 |
|
|
4760 |
75 |
try |
4761 |
|
{ |
4762 |
87 |
for (int t = 0; t < jm.getTree().size(); t++) |
4763 |
|
{ |
4764 |
|
|
4765 |
12 |
Tree tree = jm.getTree().get(t); |
4766 |
|
|
4767 |
12 |
TreePanel tp = (TreePanel) retrieveExistingObj(tree.getId()); |
4768 |
12 |
if (tp == null) |
4769 |
|
{ |
4770 |
12 |
if (tree.isColumnWise()) |
4771 |
|
{ |
4772 |
0 |
AlignmentAnnotation aa = annotationIds |
4773 |
|
.get(tree.getColumnReference()); |
4774 |
0 |
if (aa == null) |
4775 |
|
{ |
4776 |
0 |
Console.warn( |
4777 |
|
"Null alignment annotation when restoring columnwise tree"); |
4778 |
|
} |
4779 |
0 |
tp = af.showColumnWiseTree(new NewickFile(tree.getNewick()), aa, |
4780 |
|
tree.getTitle(), safeInt(tree.getWidth()), |
4781 |
|
safeInt(tree.getHeight()), safeInt(tree.getXpos()), |
4782 |
|
safeInt(tree.getYpos())); |
4783 |
|
|
4784 |
|
} |
4785 |
|
else |
4786 |
|
{ |
4787 |
12 |
tp = af.showNewickTree(new NewickFile(tree.getNewick()), |
4788 |
|
tree.getTitle(), safeInt(tree.getWidth()), |
4789 |
|
safeInt(tree.getHeight()), safeInt(tree.getXpos()), |
4790 |
|
safeInt(tree.getYpos())); |
4791 |
|
} |
4792 |
12 |
if (tree.getId() != null) |
4793 |
|
{ |
4794 |
|
|
4795 |
|
} |
4796 |
|
} |
4797 |
|
else |
4798 |
|
{ |
4799 |
|
|
4800 |
|
|
4801 |
|
|
4802 |
0 |
tp.setTitle(tree.getTitle()); |
4803 |
0 |
tp.setBounds(new Rectangle(safeInt(tree.getXpos()), |
4804 |
|
safeInt(tree.getYpos()), safeInt(tree.getWidth()), |
4805 |
|
safeInt(tree.getHeight()))); |
4806 |
0 |
tp.setViewport(av); |
4807 |
|
|
4808 |
0 |
tp.getTreeCanvas().setViewport(av); |
4809 |
0 |
tp.getTreeCanvas().setAssociatedPanel(ap); |
4810 |
|
} |
4811 |
12 |
tp.getTreeCanvas().setApplyToAllViews(tree.isLinkToAllViews()); |
4812 |
12 |
if (tp == null) |
4813 |
|
{ |
4814 |
0 |
Console.warn( |
4815 |
|
"There was a problem recovering stored Newick tree: \n" |
4816 |
|
+ tree.getNewick()); |
4817 |
0 |
continue; |
4818 |
|
} |
4819 |
|
|
4820 |
12 |
tp.fitToWindow.setState(safeBoolean(tree.isFitToWindow())); |
4821 |
12 |
tp.fitToWindow_actionPerformed(null); |
4822 |
|
|
4823 |
12 |
if (tree.getFontName() != null) |
4824 |
|
{ |
4825 |
12 |
tp.setTreeFont( |
4826 |
|
new Font(tree.getFontName(), safeInt(tree.getFontStyle()), |
4827 |
|
safeInt(tree.getFontSize()))); |
4828 |
|
} |
4829 |
|
else |
4830 |
|
{ |
4831 |
0 |
tp.setTreeFont( |
4832 |
|
new Font(view.getFontName(), safeInt(view.getFontStyle()), |
4833 |
|
safeInt(view.getFontSize()))); |
4834 |
|
} |
4835 |
|
|
4836 |
12 |
tp.showPlaceholders(safeBoolean(tree.isMarkUnlinked())); |
4837 |
12 |
tp.showBootstrap(safeBoolean(tree.isShowBootstrap())); |
4838 |
12 |
tp.showDistances(safeBoolean(tree.isShowDistances())); |
4839 |
|
|
4840 |
12 |
tp.getTreeCanvas().setThreshold(safeFloat(tree.getThreshold())); |
4841 |
|
|
4842 |
12 |
if (safeBoolean(tree.isCurrentTree())) |
4843 |
|
{ |
4844 |
12 |
af.getViewport().setCurrentTree(tp.getTree()); |
4845 |
|
} |
4846 |
|
} |
4847 |
|
|
4848 |
|
} catch (Exception ex) |
4849 |
|
{ |
4850 |
0 |
ex.printStackTrace(); |
4851 |
|
} |
4852 |
|
} |
4853 |
|
|
4854 |
|
|
4855 |
|
|
4856 |
|
|
4857 |
|
@param |
4858 |
|
@param |
4859 |
|
@param |
4860 |
|
@param |
4861 |
|
|
|
|
| 89.2% |
Uncovered Elements: 8 (74) |
Complexity: 14 |
Complexity Density: 0.28 |
|
4862 |
75 |
protected void loadPDBStructures(jarInputStreamProvider jprovider,... |
4863 |
|
List<JSeq> jseqs, AlignFrame af, AlignmentPanel ap) |
4864 |
|
{ |
4865 |
|
|
4866 |
|
|
4867 |
|
|
4868 |
|
|
4869 |
75 |
Map<String, StructureViewerModel> structureViewers = new LinkedHashMap<>(); |
4870 |
|
|
4871 |
1145 |
for (int i = 0; i < jseqs.size(); i++) |
4872 |
|
{ |
4873 |
1070 |
JSeq jseq = jseqs.get(i); |
4874 |
1070 |
if (jseq.getPdbids().size() > 0) |
4875 |
|
{ |
4876 |
128 |
List<Pdbids> ids = jseq.getPdbids(); |
4877 |
325 |
for (int p = 0; p < ids.size(); p++) |
4878 |
|
{ |
4879 |
197 |
Pdbids pdbid = ids.get(p); |
4880 |
197 |
final int structureStateCount = pdbid.getStructureState().size(); |
4881 |
277 |
for (int s = 0; s < structureStateCount; s++) |
4882 |
|
{ |
4883 |
|
|
4884 |
80 |
final StructureState structureState = pdbid.getStructureState() |
4885 |
|
.get(s); |
4886 |
80 |
String sviewid = (structureState.getViewId() == null) ? null |
4887 |
|
: structureState.getViewId() + uniqueSetSuffix; |
4888 |
80 |
jalview.datamodel.PDBEntry jpdb = new jalview.datamodel.PDBEntry(); |
4889 |
|
|
4890 |
|
|
4891 |
|
|
4892 |
80 |
jpdb.setFile( |
4893 |
|
loadPDBFile(jprovider, pdbid.getId(), pdbid.getFile())); |
4894 |
80 |
jpdb.setId(pdbid.getId()); |
4895 |
|
|
4896 |
80 |
int x = safeInt(structureState.getXpos()); |
4897 |
80 |
int y = safeInt(structureState.getYpos()); |
4898 |
80 |
int width = safeInt(structureState.getWidth()); |
4899 |
80 |
int height = safeInt(structureState.getHeight()); |
4900 |
|
|
4901 |
|
|
4902 |
|
|
4903 |
|
|
4904 |
80 |
String pdbFile = loadPDBFile(jprovider, pdbid.getId(), |
4905 |
|
pdbid.getFile()); |
4906 |
80 |
jalview.datamodel.SequenceI seq = seqRefIds |
4907 |
|
.get(jseq.getId() + ""); |
4908 |
80 |
if (sviewid == null) |
4909 |
|
{ |
4910 |
0 |
sviewid = "_jalview_pre2_4_" + x + "," + y + "," + width + "," |
4911 |
|
+ height; |
4912 |
|
} |
4913 |
80 |
if (!structureViewers.containsKey(sviewid)) |
4914 |
|
{ |
4915 |
40 |
String viewerType = structureState.getType(); |
4916 |
40 |
if (viewerType == null) |
4917 |
|
{ |
4918 |
30 |
viewerType = ViewerType.JMOL.toString(); |
4919 |
|
} |
4920 |
40 |
structureViewers.put(sviewid, |
4921 |
|
new StructureViewerModel(x, y, width, height, false, |
4922 |
|
false, true, structureState.getViewId(), |
4923 |
|
viewerType)); |
4924 |
|
|
4925 |
|
|
4926 |
|
|
4927 |
|
} |
4928 |
|
|
4929 |
|
|
4930 |
|
|
4931 |
|
|
4932 |
|
|
4933 |
80 |
StructureViewerModel jmoldat = structureViewers.get(sviewid); |
4934 |
80 |
jmoldat.setAlignWithPanel(jmoldat.isAlignWithPanel() |
4935 |
|
|| structureState.isAlignwithAlignPanel()); |
4936 |
|
|
4937 |
|
|
4938 |
|
|
4939 |
|
|
4940 |
|
|
4941 |
80 |
boolean colourWithAlignPanel = jmoldat.isColourWithAlignPanel(); |
4942 |
80 |
colourWithAlignPanel |= structureState.isColourwithAlignPanel(); |
4943 |
80 |
jmoldat.setColourWithAlignPanel(colourWithAlignPanel); |
4944 |
|
|
4945 |
|
|
4946 |
|
|
4947 |
|
|
4948 |
|
|
4949 |
80 |
boolean colourByViewer = jmoldat.isColourByViewer(); |
4950 |
80 |
colourByViewer &= structureState.isColourByJmol(); |
4951 |
80 |
jmoldat.setColourByViewer(colourByViewer); |
4952 |
|
|
4953 |
80 |
if (jmoldat.getStateData().length() < structureState.getValue() |
4954 |
|
.length()) |
4955 |
|
{ |
4956 |
30 |
jmoldat.setStateData(structureState.getValue()); |
4957 |
|
} |
4958 |
80 |
if (pdbid.getFile() != null) |
4959 |
|
{ |
4960 |
80 |
File mapkey = new File(pdbid.getFile()); |
4961 |
80 |
StructureData seqstrmaps = jmoldat.getFileData().get(mapkey); |
4962 |
80 |
if (seqstrmaps == null) |
4963 |
|
{ |
4964 |
40 |
jmoldat.getFileData().put(mapkey, |
4965 |
|
seqstrmaps = jmoldat.new StructureData(pdbFile, |
4966 |
|
pdbid.getId())); |
4967 |
|
} |
4968 |
80 |
if (!seqstrmaps.getSeqList().contains(seq)) |
4969 |
|
{ |
4970 |
80 |
seqstrmaps.getSeqList().add(seq); |
4971 |
|
|
4972 |
|
} |
4973 |
|
} |
4974 |
|
else |
4975 |
|
{ |
4976 |
0 |
errorMessage = ("The Jmol views in this project were imported\nfrom an older version of Jalview.\nPlease review the sequence colour associations\nin the Colour by section of the Jmol View menu.\n\nIn the case of problems, see note at\nhttp://issues.jalview.org/browse/JAL-747"); |
4977 |
0 |
Console.warn(errorMessage); |
4978 |
|
} |
4979 |
|
} |
4980 |
|
} |
4981 |
|
} |
4982 |
|
} |
4983 |
|
|
4984 |
75 |
for (Entry<String, StructureViewerModel> entry : structureViewers |
4985 |
|
.entrySet()) |
4986 |
|
{ |
4987 |
40 |
try |
4988 |
|
{ |
4989 |
40 |
createOrLinkStructureViewer(entry, af, ap, jprovider); |
4990 |
|
} catch (Exception e) |
4991 |
|
{ |
4992 |
0 |
jalview.bin.Console.errPrintln( |
4993 |
|
"Error loading structure viewer: " + e.getMessage()); |
4994 |
|
|
4995 |
|
} |
4996 |
|
} |
4997 |
|
} |
4998 |
|
|
4999 |
|
|
5000 |
|
|
5001 |
|
@param |
5002 |
|
@param |
5003 |
|
@param |
5004 |
|
@param |
5005 |
|
|
|
|
| 91.7% |
Uncovered Elements: 1 (12) |
Complexity: 3 |
Complexity Density: 0.3 |
|
5006 |
40 |
protected void createOrLinkStructureViewer(... |
5007 |
|
Entry<String, StructureViewerModel> viewerData, AlignFrame af, |
5008 |
|
AlignmentPanel ap, jarInputStreamProvider jprovider) |
5009 |
|
{ |
5010 |
40 |
final StructureViewerModel stateData = viewerData.getValue(); |
5011 |
|
|
5012 |
|
|
5013 |
|
|
5014 |
|
|
5015 |
|
|
5016 |
40 |
StructureViewerBase comp = findMatchingViewer(viewerData); |
5017 |
|
|
5018 |
40 |
if (comp != null) |
5019 |
|
{ |
5020 |
33 |
linkStructureViewer(ap, comp, stateData); |
5021 |
33 |
return; |
5022 |
|
} |
5023 |
|
|
5024 |
7 |
String type = stateData.getType(); |
5025 |
7 |
try |
5026 |
|
{ |
5027 |
7 |
ViewerType viewerType = ViewerType.valueOf(type); |
5028 |
7 |
createStructureViewer(viewerType, viewerData, af, jprovider); |
5029 |
|
} catch (IllegalArgumentException | NullPointerException e) |
5030 |
|
{ |
5031 |
|
|
5032 |
0 |
Console.error("Invalid structure viewer type: " + type); |
5033 |
|
} |
5034 |
|
} |
5035 |
|
|
5036 |
|
|
5037 |
|
|
5038 |
|
|
5039 |
|
|
5040 |
|
@param |
5041 |
|
@return |
5042 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
5043 |
4 |
protected String getViewerJarEntryName(String viewId)... |
5044 |
|
{ |
5045 |
4 |
return VIEWER_PREFIX + viewId; |
5046 |
|
} |
5047 |
|
|
5048 |
|
|
5049 |
|
|
5050 |
|
|
5051 |
|
|
5052 |
|
|
5053 |
|
@param |
5054 |
|
@return |
5055 |
|
|
|
|
| 94.4% |
Uncovered Elements: 1 (18) |
Complexity: 8 |
Complexity Density: 0.67 |
|
5056 |
40 |
protected StructureViewerBase findMatchingViewer(... |
5057 |
|
Entry<String, StructureViewerModel> viewerData) |
5058 |
|
{ |
5059 |
40 |
final String sviewid = viewerData.getKey(); |
5060 |
40 |
final StructureViewerModel svattrib = viewerData.getValue(); |
5061 |
40 |
StructureViewerBase comp = null; |
5062 |
40 |
JInternalFrame[] frames = getAllFrames(); |
5063 |
40 |
for (JInternalFrame frame : frames) |
5064 |
|
{ |
5065 |
231 |
if (frame instanceof StructureViewerBase) |
5066 |
|
{ |
5067 |
|
|
5068 |
|
|
5069 |
|
|
5070 |
33 |
if (sviewid != null && ((StructureViewerBase) frame).getViewId() |
5071 |
|
.equals(sviewid)) |
5072 |
|
{ |
5073 |
28 |
comp = (StructureViewerBase) frame; |
5074 |
28 |
break; |
5075 |
|
} |
5076 |
|
|
5077 |
|
|
5078 |
|
|
5079 |
5 |
else if (frame.getX() == svattrib.getX() |
5080 |
|
&& frame.getY() == svattrib.getY() |
5081 |
|
&& frame.getHeight() == svattrib.getHeight() |
5082 |
|
&& frame.getWidth() == svattrib.getWidth()) |
5083 |
|
{ |
5084 |
5 |
comp = (StructureViewerBase) frame; |
5085 |
|
|
5086 |
|
} |
5087 |
|
} |
5088 |
|
} |
5089 |
40 |
return comp; |
5090 |
|
} |
5091 |
|
|
5092 |
|
|
5093 |
|
|
5094 |
|
|
5095 |
|
@param |
5096 |
|
@param |
5097 |
|
@param |
5098 |
|
@param |
5099 |
|
@param |
5100 |
|
@param |
5101 |
|
|
|
|
| 90.9% |
Uncovered Elements: 2 (22) |
Complexity: 3 |
Complexity Density: 0.17 |
|
5102 |
33 |
protected void linkStructureViewer(AlignmentPanel ap,... |
5103 |
|
StructureViewerBase viewer, StructureViewerModel stateData) |
5104 |
|
{ |
5105 |
|
|
5106 |
|
|
5107 |
|
|
5108 |
33 |
final boolean useinViewerSuperpos = stateData.isAlignWithPanel(); |
5109 |
33 |
final boolean usetoColourbyseq = stateData.isColourWithAlignPanel(); |
5110 |
33 |
final boolean viewerColouring = stateData.isColourByViewer(); |
5111 |
33 |
Map<File, StructureData> oldFiles = stateData.getFileData(); |
5112 |
|
|
5113 |
|
|
5114 |
|
|
5115 |
|
|
5116 |
33 |
final AAStructureBindingModel binding = viewer.getBinding(); |
5117 |
33 |
for (File id : oldFiles.keySet()) |
5118 |
|
{ |
5119 |
|
|
5120 |
|
|
5121 |
33 |
StructureData filedat = oldFiles.get(id); |
5122 |
33 |
String pdbFile = filedat.getFilePath(); |
5123 |
33 |
SequenceI[] seq = filedat.getSeqList().toArray(new SequenceI[0]); |
5124 |
33 |
binding.getSsm().setMapping(seq, null, pdbFile, DataSourceType.FILE, |
5125 |
|
null); |
5126 |
33 |
binding.addSequenceForStructFile(pdbFile, seq); |
5127 |
|
} |
5128 |
|
|
5129 |
33 |
viewer.addAlignmentPanel(ap); |
5130 |
33 |
if (useinViewerSuperpos) |
5131 |
|
{ |
5132 |
0 |
viewer.useAlignmentPanelForSuperposition(ap); |
5133 |
|
} |
5134 |
|
else |
5135 |
|
{ |
5136 |
33 |
viewer.excludeAlignmentPanelForSuperposition(ap); |
5137 |
|
} |
5138 |
33 |
if (usetoColourbyseq) |
5139 |
|
{ |
5140 |
8 |
viewer.useAlignmentPanelForColourbyseq(ap, !viewerColouring); |
5141 |
|
} |
5142 |
|
else |
5143 |
|
{ |
5144 |
25 |
viewer.excludeAlignmentPanelForColourbyseq(ap); |
5145 |
|
} |
5146 |
|
} |
5147 |
|
|
5148 |
|
|
5149 |
|
|
5150 |
|
|
5151 |
|
@return |
5152 |
|
|
|
|
| 66.7% |
Uncovered Elements: 3 (9) |
Complexity: 4 |
Complexity Density: 0.57 |
|
5153 |
40 |
protected JInternalFrame[] getAllFrames()... |
5154 |
|
{ |
5155 |
40 |
JInternalFrame[] frames = null; |
5156 |
|
|
5157 |
40 |
do |
5158 |
|
{ |
5159 |
40 |
try |
5160 |
|
{ |
5161 |
40 |
frames = Desktop.desktop.getAllFrames(); |
5162 |
|
} catch (ArrayIndexOutOfBoundsException e) |
5163 |
|
{ |
5164 |
|
|
5165 |
0 |
try |
5166 |
|
{ |
5167 |
0 |
Thread.sleep(10); |
5168 |
|
} catch (InterruptedException f) |
5169 |
|
{ |
5170 |
|
} |
5171 |
|
} |
5172 |
40 |
} while (frames == null); |
5173 |
40 |
return frames; |
5174 |
|
} |
5175 |
|
|
5176 |
|
|
5177 |
|
|
5178 |
|
|
5179 |
|
|
5180 |
|
|
5181 |
|
|
5182 |
|
@param |
5183 |
|
|
5184 |
|
@param |
5185 |
|
|
5186 |
|
@return |
5187 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 7 |
Complexity Density: 1.75 |
|
5188 |
234 |
public static boolean isVersionStringLaterThan(String supported,... |
5189 |
|
String version) |
5190 |
|
{ |
5191 |
234 |
if (supported == null || version == null |
5192 |
|
|| version.equalsIgnoreCase("DEVELOPMENT BUILD") |
5193 |
|
|| version.equalsIgnoreCase("Test") |
5194 |
|
|| version.equalsIgnoreCase("AUTOMATED BUILD")) |
5195 |
|
{ |
5196 |
86 |
jalview.bin.Console.errPrintln("Assuming project file with " |
5197 |
86 |
+ (version == null ? "null" : version) |
5198 |
|
+ " is compatible with Jalview version " + supported); |
5199 |
86 |
return true; |
5200 |
|
} |
5201 |
|
else |
5202 |
|
{ |
5203 |
148 |
return StringUtils.compareVersions(version, supported, "b") >= 0; |
5204 |
|
} |
5205 |
|
} |
5206 |
|
|
5207 |
|
Vector<JalviewStructureDisplayI> newStructureViewers = null; |
5208 |
|
|
|
|
| 80% |
Uncovered Elements: 1 (5) |
Complexity: 2 |
Complexity Density: 0.67 |
|
5209 |
7 |
protected void addNewStructureViewer(JalviewStructureDisplayI sview)... |
5210 |
|
{ |
5211 |
7 |
if (newStructureViewers != null) |
5212 |
|
{ |
5213 |
7 |
sview.getBinding().setFinishedLoadingFromArchive(false); |
5214 |
7 |
newStructureViewers.add(sview); |
5215 |
|
} |
5216 |
|
} |
5217 |
|
|
|
|
| 85.7% |
Uncovered Elements: 1 (7) |
Complexity: 2 |
Complexity Density: 0.4 |
|
5218 |
30 |
protected void setLoadingFinishedForNewStructureViewers()... |
5219 |
|
{ |
5220 |
30 |
if (newStructureViewers != null) |
5221 |
|
{ |
5222 |
30 |
for (JalviewStructureDisplayI sview : newStructureViewers) |
5223 |
|
{ |
5224 |
7 |
sview.getBinding().setFinishedLoadingFromArchive(true); |
5225 |
|
} |
5226 |
30 |
newStructureViewers.clear(); |
5227 |
30 |
newStructureViewers = null; |
5228 |
|
} |
5229 |
|
} |
5230 |
|
|
|
|
| 89.5% |
Uncovered Elements: 27 (257) |
Complexity: 42 |
Complexity Density: 0.24 |
|
5231 |
85 |
AlignFrame loadViewport(String file, List<JSeq> JSEQ,... |
5232 |
|
List<SequenceI> hiddenSeqs, AlignmentI al, JalviewModel jm, |
5233 |
|
Viewport view, String uniqueSeqSetId, String viewId, |
5234 |
|
List<JvAnnotRow> autoAlan) |
5235 |
|
{ |
5236 |
85 |
AlignFrame af = null; |
5237 |
85 |
af = new AlignFrame(al, safeInt(view.getWidth()), |
5238 |
|
safeInt(view.getHeight()), uniqueSeqSetId, viewId) |
5239 |
|
|
5240 |
|
|
5241 |
|
|
5242 |
|
|
5243 |
|
|
5244 |
|
|
5245 |
|
|
5246 |
|
|
5247 |
|
|
5248 |
|
|
5249 |
|
; |
5250 |
|
|
5251 |
85 |
af.setFileName(file, FileFormat.Jalview); |
5252 |
|
|
5253 |
85 |
final AlignViewport viewport = af.getViewport(); |
5254 |
1277 |
for (int i = 0; i < JSEQ.size(); i++) |
5255 |
|
{ |
5256 |
1192 |
int colour = safeInt(JSEQ.get(i).getColour()); |
5257 |
1192 |
viewport.setSequenceColour(viewport.getAlignment().getSequenceAt(i), |
5258 |
|
new Color(colour)); |
5259 |
|
} |
5260 |
|
|
5261 |
85 |
if (al.hasSeqrep()) |
5262 |
|
{ |
5263 |
5 |
viewport.setColourByReferenceSeq(true); |
5264 |
5 |
viewport.setDisplayReferenceSeq(true); |
5265 |
|
} |
5266 |
|
|
5267 |
85 |
viewport.setGatherViewsHere(safeBoolean(view.isGatheredViews())); |
5268 |
|
|
5269 |
85 |
if (view.getSequenceSetId() != null) |
5270 |
|
{ |
5271 |
85 |
AlignmentViewport av = viewportsAdded.get(uniqueSeqSetId); |
5272 |
|
|
5273 |
85 |
viewport.setSequenceSetId(uniqueSeqSetId); |
5274 |
85 |
if (av != null) |
5275 |
|
{ |
5276 |
|
|
5277 |
43 |
viewport.setHistoryList(av.getHistoryList()); |
5278 |
43 |
viewport.setRedoList(av.getRedoList()); |
5279 |
|
} |
5280 |
|
else |
5281 |
|
{ |
5282 |
42 |
viewportsAdded.put(uniqueSeqSetId, viewport); |
5283 |
|
} |
5284 |
|
|
5285 |
|
|
5286 |
85 |
PaintRefresher.Register(af.alignPanel, uniqueSeqSetId); |
5287 |
|
} |
5288 |
|
|
5289 |
85 |
if (hiddenSeqs != null) |
5290 |
|
{ |
5291 |
712 |
for (int s = 0; s < JSEQ.size(); s++) |
5292 |
|
{ |
5293 |
670 |
SequenceGroup hidden = new SequenceGroup(); |
5294 |
670 |
boolean isRepresentative = false; |
5295 |
672 |
for (int r = 0; r < JSEQ.get(s).getHiddenSequences().size(); r++) |
5296 |
|
{ |
5297 |
2 |
isRepresentative = true; |
5298 |
2 |
SequenceI sequenceToHide = al |
5299 |
|
.getSequenceAt(JSEQ.get(s).getHiddenSequences().get(r)); |
5300 |
2 |
hidden.addSequence(sequenceToHide, false); |
5301 |
|
|
5302 |
2 |
hiddenSeqs.remove(sequenceToHide); |
5303 |
|
} |
5304 |
670 |
if (isRepresentative) |
5305 |
|
{ |
5306 |
2 |
SequenceI representativeSequence = al.getSequenceAt(s); |
5307 |
2 |
hidden.addSequence(representativeSequence, false); |
5308 |
2 |
viewport.hideRepSequences(representativeSequence, hidden); |
5309 |
|
} |
5310 |
|
} |
5311 |
|
|
5312 |
42 |
SequenceI[] hseqs = hiddenSeqs |
5313 |
|
.toArray(new SequenceI[hiddenSeqs.size()]); |
5314 |
42 |
viewport.hideSequence(hseqs); |
5315 |
|
|
5316 |
|
} |
5317 |
|
|
5318 |
|
|
5319 |
85 |
viewport.setShowAnnotation(safeBoolean(view.isShowAnnotation())); |
5320 |
85 |
viewport.setAbovePIDThreshold(safeBoolean(view.isPidSelected())); |
5321 |
85 |
final int pidThreshold = safeInt(view.getPidThreshold()); |
5322 |
85 |
viewport.setThreshold(pidThreshold); |
5323 |
|
|
5324 |
85 |
viewport.setColourText(safeBoolean(view.isShowColourText())); |
5325 |
|
|
5326 |
85 |
viewport.setConservationSelected( |
5327 |
|
safeBoolean(view.isConservationSelected())); |
5328 |
85 |
viewport.setIncrement(safeInt(view.getConsThreshold())); |
5329 |
85 |
viewport.setShowJVSuffix(safeBoolean(view.isShowFullId())); |
5330 |
85 |
viewport.setRightAlignIds(safeBoolean(view.isRightAlignIds())); |
5331 |
85 |
viewport.setFont( |
5332 |
|
new Font(view.getFontName(), safeInt(view.getFontStyle()), |
5333 |
|
safeInt(view.getFontSize())), |
5334 |
85 |
(view.getCharWidth() != null) ? false : true); |
5335 |
85 |
if (view.getCharWidth() != null) |
5336 |
|
{ |
5337 |
42 |
viewport.setCharWidth(view.getCharWidth()); |
5338 |
42 |
viewport.setCharHeight(view.getCharHeight()); |
5339 |
|
} |
5340 |
85 |
ViewStyleI vs = viewport.getViewStyle(); |
5341 |
85 |
vs.setScaleProteinAsCdna(view.isScaleProteinAsCdna()); |
5342 |
85 |
viewport.setViewStyle(vs); |
5343 |
|
|
5344 |
|
|
5345 |
85 |
viewport.setRenderGaps(safeBoolean(view.isRenderGaps())); |
5346 |
85 |
viewport.setWrapAlignment(safeBoolean(view.isWrapAlignment())); |
5347 |
85 |
viewport.setShowAnnotation(safeBoolean(view.isShowAnnotation())); |
5348 |
|
|
5349 |
85 |
viewport.setShowBoxes(safeBoolean(view.isShowBoxes())); |
5350 |
|
|
5351 |
85 |
viewport.setShowText(safeBoolean(view.isShowText())); |
5352 |
|
|
5353 |
85 |
viewport.setTextColour(new Color(safeInt(view.getTextCol1()))); |
5354 |
85 |
viewport.setTextColour2(new Color(safeInt(view.getTextCol2()))); |
5355 |
85 |
viewport.setThresholdTextColour(safeInt(view.getTextColThreshold())); |
5356 |
85 |
viewport.setShowUnconserved(view.isShowUnconserved()); |
5357 |
85 |
viewport.getRanges().setStartRes(safeInt(view.getStartRes())); |
5358 |
|
|
5359 |
85 |
if (view.getViewName() != null) |
5360 |
|
{ |
5361 |
59 |
viewport.setViewName(view.getViewName()); |
5362 |
59 |
af.setInitialTabVisible(); |
5363 |
|
} |
5364 |
85 |
af.setBounds(safeInt(view.getXpos()), safeInt(view.getYpos()), |
5365 |
|
safeInt(view.getWidth()), safeInt(view.getHeight())); |
5366 |
|
|
5367 |
85 |
af.alignPanel.fontChanged(); |
5368 |
|
|
5369 |
85 |
if (view.getIdWidth() == null) |
5370 |
|
{ |
5371 |
43 |
if (!isVersionStringLaterThan("2.11.3", jm.getVersion())) |
5372 |
|
{ |
5373 |
|
|
5374 |
|
|
5375 |
43 |
viewport.setIdWidth(af.alignPanel.getLegacyIdWidth()); |
5376 |
43 |
af.alignPanel.getIdPanel().getIdCanvas().setManuallyAdjusted(true); |
5377 |
|
} |
5378 |
|
} |
5379 |
|
else |
5380 |
|
{ |
5381 |
42 |
viewport.setIdWidth(view.getIdWidth()); |
5382 |
42 |
af.alignPanel.getIdPanel().getIdCanvas() |
5383 |
|
.setManuallyAdjusted(view.isIdWidthManuallyAdjusted()); |
5384 |
|
} |
5385 |
|
|
5386 |
|
|
5387 |
85 |
af.alignPanel.updateLayout(); |
5388 |
85 |
ColourSchemeI cs = null; |
5389 |
|
|
5390 |
85 |
if (view.getBgColour() != null) |
5391 |
|
{ |
5392 |
85 |
if (view.getBgColour().startsWith("ucs")) |
5393 |
|
{ |
5394 |
0 |
cs = getUserColourScheme(jm, view.getBgColour()); |
5395 |
|
} |
5396 |
85 |
else if (view.getBgColour().startsWith("Annotation")) |
5397 |
|
{ |
5398 |
2 |
AnnotationColourScheme viewAnnColour = view.getAnnotationColours(); |
5399 |
2 |
cs = constructAnnotationColour(viewAnnColour, af, al, jm, true); |
5400 |
|
|
5401 |
|
|
5402 |
|
|
5403 |
|
} |
5404 |
|
else |
5405 |
|
{ |
5406 |
83 |
cs = ColourSchemeProperty.getColourScheme(af.getViewport(), al, |
5407 |
|
view.getBgColour()); |
5408 |
|
} |
5409 |
|
} |
5410 |
|
|
5411 |
|
|
5412 |
|
|
5413 |
|
|
5414 |
|
|
5415 |
85 |
viewport.setColourAppliesToAllGroups(false); |
5416 |
85 |
viewport.setGlobalColourScheme(cs); |
5417 |
85 |
viewport.getResidueShading().setThreshold(pidThreshold, |
5418 |
|
view.isIgnoreGapsinConsensus()); |
5419 |
85 |
viewport.getResidueShading() |
5420 |
|
.setConsensus(viewport.getSequenceConsensusHash()); |
5421 |
85 |
viewport.getResidueShading() |
5422 |
|
.setSsConsensus(viewport.getSequenceSSConsensusHash()); |
5423 |
85 |
if (safeBoolean(view.isConservationSelected()) && cs != null) |
5424 |
|
{ |
5425 |
2 |
viewport.getResidueShading() |
5426 |
|
.setConservationInc(safeInt(view.getConsThreshold())); |
5427 |
|
} |
5428 |
85 |
af.changeColour(cs); |
5429 |
85 |
viewport.setColourAppliesToAllGroups(true); |
5430 |
|
|
5431 |
85 |
viewport.setShowSequenceFeatures( |
5432 |
|
safeBoolean(view.isShowSequenceFeatures())); |
5433 |
|
|
5434 |
85 |
viewport.setCentreColumnLabels(view.isCentreColumnLabels()); |
5435 |
85 |
viewport.setIgnoreGapsConsensus(view.isIgnoreGapsinConsensus(), null); |
5436 |
85 |
viewport.setFollowHighlight(view.isFollowHighlight()); |
5437 |
85 |
viewport.followSelection = view.isFollowSelection(); |
5438 |
85 |
viewport.setShowConsensusHistogram(view.isShowConsensusHistogram()); |
5439 |
85 |
viewport.setShowSequenceLogo(view.isShowSequenceLogo()); |
5440 |
85 |
viewport.setNormaliseSequenceLogo(view.isNormaliseSequenceLogo()); |
5441 |
85 |
viewport.setShowDBRefs(safeBoolean(view.isShowDbRefTooltip())); |
5442 |
85 |
viewport.setShowNPFeats(safeBoolean(view.isShowNPfeatureTooltip())); |
5443 |
85 |
viewport.setShowGroupConsensus(view.isShowGroupConsensus()); |
5444 |
85 |
viewport.setShowGroupConservation(view.isShowGroupConservation()); |
5445 |
85 |
viewport.setShowComplementFeatures(view.isShowComplementFeatures()); |
5446 |
85 |
viewport.setShowComplementFeaturesOnTop( |
5447 |
|
view.isShowComplementFeaturesOnTop()); |
5448 |
|
|
5449 |
|
|
5450 |
85 |
if (jm.getFeatureSettings() != null) |
5451 |
|
{ |
5452 |
36 |
FeatureRendererModel fr = af.alignPanel.getSeqPanel().seqCanvas |
5453 |
|
.getFeatureRenderer(); |
5454 |
36 |
FeaturesDisplayed fdi; |
5455 |
36 |
viewport.setFeaturesDisplayed(fdi = new FeaturesDisplayed()); |
5456 |
36 |
String[] renderOrder = new String[jm.getFeatureSettings().getSetting() |
5457 |
|
.size()]; |
5458 |
36 |
Map<String, FeatureColourI> featureColours = new Hashtable<>(); |
5459 |
36 |
Map<String, Float> featureOrder = new Hashtable<>(); |
5460 |
|
|
5461 |
848 |
for (int fs = 0; fs < jm.getFeatureSettings().getSetting() |
5462 |
|
.size(); fs++) |
5463 |
|
{ |
5464 |
812 |
Setting setting = jm.getFeatureSettings().getSetting().get(fs); |
5465 |
812 |
String featureType = setting.getType(); |
5466 |
|
|
5467 |
|
|
5468 |
|
|
5469 |
|
|
5470 |
812 |
jalview.xml.binding.jalview.FeatureMatcherSet filters = setting |
5471 |
|
.getMatcherSet(); |
5472 |
812 |
if (filters != null) |
5473 |
|
{ |
5474 |
3 |
FeatureMatcherSetI filter = Jalview2XML.parseFilter(featureType, |
5475 |
|
filters); |
5476 |
3 |
if (!filter.isEmpty()) |
5477 |
|
{ |
5478 |
3 |
fr.setFeatureFilter(featureType, filter); |
5479 |
|
} |
5480 |
|
} |
5481 |
|
|
5482 |
|
|
5483 |
|
|
5484 |
|
|
5485 |
812 |
Color maxColour = new Color(setting.getColour()); |
5486 |
812 |
if (setting.getMincolour() != null) |
5487 |
|
{ |
5488 |
|
|
5489 |
|
|
5490 |
|
|
5491 |
|
|
5492 |
5 |
Color minColour = new Color(setting.getMincolour().intValue()); |
5493 |
5 |
Color noValueColour = minColour; |
5494 |
5 |
NoValueColour noColour = setting.getNoValueColour(); |
5495 |
5 |
if (noColour == NoValueColour.NONE) |
5496 |
|
{ |
5497 |
5 |
noValueColour = null; |
5498 |
|
} |
5499 |
0 |
else if (noColour == NoValueColour.MAX) |
5500 |
|
{ |
5501 |
0 |
noValueColour = maxColour; |
5502 |
|
} |
5503 |
5 |
float min = safeFloat(safeFloat(setting.getMin())); |
5504 |
5 |
float max = setting.getMax() == null ? 1f |
5505 |
|
: setting.getMax().floatValue(); |
5506 |
5 |
FeatureColourI gc = new FeatureColour(maxColour, minColour, |
5507 |
|
maxColour, noValueColour, min, max); |
5508 |
5 |
if (setting.getAttributeName().size() > 0) |
5509 |
|
{ |
5510 |
2 |
gc.setAttributeName(setting.getAttributeName().toArray( |
5511 |
|
new String[setting.getAttributeName().size()])); |
5512 |
|
} |
5513 |
5 |
if (setting.getThreshold() != null) |
5514 |
|
{ |
5515 |
5 |
gc.setThreshold(setting.getThreshold().floatValue()); |
5516 |
5 |
int threshstate = safeInt(setting.getThreshstate()); |
5517 |
|
|
5518 |
5 |
if (threshstate == 0) |
5519 |
|
{ |
5520 |
1 |
gc.setBelowThreshold(true); |
5521 |
|
} |
5522 |
4 |
else if (threshstate == 1) |
5523 |
|
{ |
5524 |
1 |
gc.setAboveThreshold(true); |
5525 |
|
} |
5526 |
|
} |
5527 |
5 |
gc.setAutoScaled(true); |
5528 |
5 |
if (setting.isAutoScale() != null) |
5529 |
|
{ |
5530 |
5 |
gc.setAutoScaled(setting.isAutoScale()); |
5531 |
|
} |
5532 |
5 |
if (setting.isColourByLabel() != null) |
5533 |
|
{ |
5534 |
5 |
gc.setColourByLabel(setting.isColourByLabel()); |
5535 |
|
} |
5536 |
|
|
5537 |
5 |
featureColours.put(featureType, gc); |
5538 |
|
} |
5539 |
|
else |
5540 |
|
{ |
5541 |
807 |
featureColours.put(featureType, new FeatureColour(maxColour)); |
5542 |
|
} |
5543 |
812 |
renderOrder[fs] = featureType; |
5544 |
812 |
if (setting.getOrder() != null) |
5545 |
|
{ |
5546 |
812 |
featureOrder.put(featureType, setting.getOrder().floatValue()); |
5547 |
|
} |
5548 |
|
else |
5549 |
|
{ |
5550 |
0 |
featureOrder.put(featureType, Float.valueOf( |
5551 |
|
fs / jm.getFeatureSettings().getSetting().size())); |
5552 |
|
} |
5553 |
812 |
if (safeBoolean(setting.isDisplay())) |
5554 |
|
{ |
5555 |
237 |
fdi.setVisible(featureType); |
5556 |
|
} |
5557 |
|
} |
5558 |
36 |
Map<String, Boolean> fgtable = new Hashtable<>(); |
5559 |
163 |
for (int gs = 0; gs < jm.getFeatureSettings().getGroup().size(); gs++) |
5560 |
|
{ |
5561 |
127 |
Group grp = jm.getFeatureSettings().getGroup().get(gs); |
5562 |
127 |
fgtable.put(grp.getName(), Boolean.valueOf(grp.isDisplay())); |
5563 |
|
} |
5564 |
|
|
5565 |
|
|
5566 |
|
|
5567 |
36 |
FeatureRendererSettings frs = new FeatureRendererSettings(renderOrder, |
5568 |
|
fgtable, featureColours, 1.0f, featureOrder); |
5569 |
36 |
fr.transferSettings(frs); |
5570 |
|
} |
5571 |
|
|
5572 |
85 |
if (view.getHiddenColumns().size() > 0) |
5573 |
|
{ |
5574 |
76 |
for (int c = 0; c < view.getHiddenColumns().size(); c++) |
5575 |
|
{ |
5576 |
54 |
final HiddenColumns hc = view.getHiddenColumns().get(c); |
5577 |
54 |
viewport.hideColumns(safeInt(hc.getStart()), |
5578 |
|
safeInt(hc.getEnd()) ); |
5579 |
|
} |
5580 |
|
} |
5581 |
85 |
if (view.getCalcIdParam() != null) |
5582 |
|
{ |
5583 |
85 |
for (CalcIdParam calcIdParam : view.getCalcIdParam()) |
5584 |
|
{ |
5585 |
0 |
if (calcIdParam != null) |
5586 |
|
{ |
5587 |
0 |
if (recoverCalcIdParam(calcIdParam, viewport)) |
5588 |
|
{ |
5589 |
|
} |
5590 |
|
else |
5591 |
|
{ |
5592 |
0 |
Console.warn("Couldn't recover parameters for " |
5593 |
|
+ calcIdParam.getCalcId()); |
5594 |
|
} |
5595 |
|
} |
5596 |
|
} |
5597 |
|
} |
5598 |
85 |
af.setMenusFromViewport(viewport); |
5599 |
85 |
af.setTitle(view.getTitle()); |
5600 |
|
|
5601 |
|
|
5602 |
|
|
5603 |
|
|
5604 |
|
|
5605 |
|
|
5606 |
85 |
String complementaryViewId = view.getComplementId(); |
5607 |
85 |
if (complementaryViewId == null) |
5608 |
|
{ |
5609 |
85 |
Desktop.addInternalFrame(af, view.getTitle(), |
5610 |
|
safeInt(view.getWidth()), safeInt(view.getHeight())); |
5611 |
|
|
5612 |
85 |
af.alignPanel.updateAnnotation(false, true); |
5613 |
85 |
reorderAutoannotation(af, al, autoAlan); |
5614 |
85 |
af.alignPanel.alignmentChanged(); |
5615 |
|
} |
5616 |
|
else |
5617 |
|
{ |
5618 |
0 |
splitFrameCandidates.put(view, af); |
5619 |
|
} |
5620 |
|
|
5621 |
85 |
return af; |
5622 |
|
} |
5623 |
|
|
5624 |
|
|
5625 |
|
|
5626 |
|
|
5627 |
|
@param |
5628 |
|
@param |
5629 |
|
@param |
5630 |
|
@param |
5631 |
|
@param |
5632 |
|
@return |
5633 |
|
|
|
|
| 47.7% |
Uncovered Elements: 34 (65) |
Complexity: 19 |
Complexity Density: 0.49 |
|
5634 |
3 |
private ColourSchemeI constructAnnotationColour(... |
5635 |
|
AnnotationColourScheme viewAnnColour, AlignFrame af, |
5636 |
|
AlignmentI al, JalviewModel model, boolean checkGroupAnnColour) |
5637 |
|
{ |
5638 |
3 |
boolean propagateAnnColour = false; |
5639 |
3 |
AlignmentI annAlignment = af != null ? af.getViewport().getAlignment() |
5640 |
|
: al; |
5641 |
3 |
if (checkGroupAnnColour && al.getGroups() != null |
5642 |
|
&& al.getGroups().size() > 0) |
5643 |
|
{ |
5644 |
|
|
5645 |
|
|
5646 |
1 |
propagateAnnColour = true; |
5647 |
1 |
for (SequenceGroup sg : al.getGroups()) |
5648 |
|
{ |
5649 |
1 |
if (sg.getColourScheme() instanceof AnnotationColourGradient) |
5650 |
|
{ |
5651 |
1 |
propagateAnnColour = false; |
5652 |
|
} |
5653 |
|
} |
5654 |
|
} |
5655 |
|
|
5656 |
|
|
5657 |
|
|
5658 |
|
|
5659 |
3 |
String annotationId = viewAnnColour.getAnnotation(); |
5660 |
3 |
AlignmentAnnotation matchedAnnotation = annotationIds.get(annotationId); |
5661 |
|
|
5662 |
|
|
5663 |
|
|
5664 |
|
|
5665 |
3 |
if (matchedAnnotation == null |
5666 |
|
&& annAlignment.getAlignmentAnnotation() != null) |
5667 |
|
{ |
5668 |
0 |
for (int i = 0; i < annAlignment.getAlignmentAnnotation().length; i++) |
5669 |
|
{ |
5670 |
0 |
if (annotationId |
5671 |
|
.equals(annAlignment.getAlignmentAnnotation()[i].label)) |
5672 |
|
{ |
5673 |
0 |
matchedAnnotation = annAlignment.getAlignmentAnnotation()[i]; |
5674 |
0 |
break; |
5675 |
|
} |
5676 |
|
} |
5677 |
|
} |
5678 |
3 |
if (matchedAnnotation == null) |
5679 |
|
{ |
5680 |
0 |
jalview.bin.Console |
5681 |
|
.errPrintln("Failed to match annotation colour scheme for " |
5682 |
|
+ annotationId); |
5683 |
0 |
return null; |
5684 |
|
} |
5685 |
|
|
5686 |
|
|
5687 |
3 |
if (safeInt(viewAnnColour.getAboveThreshold()) != 0 |
5688 |
|
&& matchedAnnotation.getThreshold() == null) |
5689 |
|
{ |
5690 |
0 |
matchedAnnotation.setThreshold( |
5691 |
|
new GraphLine(safeFloat(viewAnnColour.getThreshold()), |
5692 |
|
"Threshold", Color.black)); |
5693 |
|
} |
5694 |
|
|
5695 |
3 |
AnnotationColourGradient cs = null; |
5696 |
3 |
if (viewAnnColour.getColourScheme().equals("None")) |
5697 |
|
{ |
5698 |
3 |
cs = new AnnotationColourGradient(matchedAnnotation, |
5699 |
|
new Color(safeInt(viewAnnColour.getMinColour())), |
5700 |
|
new Color(safeInt(viewAnnColour.getMaxColour())), |
5701 |
|
safeInt(viewAnnColour.getAboveThreshold())); |
5702 |
|
} |
5703 |
0 |
else if (viewAnnColour.getColourScheme().startsWith("ucs")) |
5704 |
|
{ |
5705 |
0 |
cs = new AnnotationColourGradient(matchedAnnotation, |
5706 |
|
getUserColourScheme(model, viewAnnColour.getColourScheme()), |
5707 |
|
safeInt(viewAnnColour.getAboveThreshold())); |
5708 |
|
} |
5709 |
|
else |
5710 |
|
{ |
5711 |
0 |
cs = new AnnotationColourGradient(matchedAnnotation, |
5712 |
|
ColourSchemeProperty.getColourScheme(af.getViewport(), al, |
5713 |
|
viewAnnColour.getColourScheme()), |
5714 |
|
safeInt(viewAnnColour.getAboveThreshold())); |
5715 |
|
} |
5716 |
|
|
5717 |
3 |
boolean perSequenceOnly = safeBoolean(viewAnnColour.isPerSequence()); |
5718 |
3 |
boolean useOriginalColours = safeBoolean( |
5719 |
|
viewAnnColour.isPredefinedColours()); |
5720 |
3 |
cs.setSeqAssociated(perSequenceOnly); |
5721 |
3 |
cs.setPredefinedColours(useOriginalColours); |
5722 |
|
|
5723 |
3 |
if (propagateAnnColour && al.getGroups() != null) |
5724 |
|
{ |
5725 |
|
|
5726 |
0 |
for (int g = 0; g < al.getGroups().size(); g++) |
5727 |
|
{ |
5728 |
0 |
SequenceGroup sg = al.getGroups().get(g); |
5729 |
0 |
if (sg.getGroupColourScheme() == null) |
5730 |
|
{ |
5731 |
0 |
continue; |
5732 |
|
} |
5733 |
|
|
5734 |
0 |
AnnotationColourGradient groupScheme = new AnnotationColourGradient( |
5735 |
|
matchedAnnotation, sg.getColourScheme(), |
5736 |
|
safeInt(viewAnnColour.getAboveThreshold())); |
5737 |
0 |
sg.setColourScheme(groupScheme); |
5738 |
0 |
groupScheme.setSeqAssociated(perSequenceOnly); |
5739 |
0 |
groupScheme.setPredefinedColours(useOriginalColours); |
5740 |
|
} |
5741 |
|
} |
5742 |
3 |
return cs; |
5743 |
|
} |
5744 |
|
|
|
|
| 92.1% |
Uncovered Elements: 5 (63) |
Complexity: 13 |
Complexity Density: 0.3 |
|
5745 |
85 |
private void reorderAutoannotation(AlignFrame af, AlignmentI al,... |
5746 |
|
List<JvAnnotRow> autoAlan) |
5747 |
|
{ |
5748 |
|
|
5749 |
|
|
5750 |
85 |
if (al.getAlignmentAnnotation() != null) |
5751 |
|
{ |
5752 |
|
|
5753 |
|
|
5754 |
|
|
5755 |
85 |
String[] magicNames = new String[] { "Consensus", "Quality", |
5756 |
|
"Conservation" }; |
5757 |
85 |
JvAnnotRow nullAnnot = new JvAnnotRow(-1, null); |
5758 |
85 |
Hashtable<String, JvAnnotRow> visan = new Hashtable<>(); |
5759 |
85 |
for (String nm : magicNames) |
5760 |
|
{ |
5761 |
255 |
visan.put(nm, nullAnnot); |
5762 |
|
} |
5763 |
85 |
for (JvAnnotRow auan : autoAlan) |
5764 |
|
{ |
5765 |
298 |
visan.put(auan.template.label |
5766 |
298 |
+ (auan.template.getCalcId() == null ? "" |
5767 |
|
: "\t" + auan.template.getCalcId()), |
5768 |
|
auan); |
5769 |
|
} |
5770 |
85 |
int hSize = al.getAlignmentAnnotation().length; |
5771 |
85 |
List<JvAnnotRow> reorder = new ArrayList<>(); |
5772 |
|
|
5773 |
|
|
5774 |
|
|
5775 |
85 |
List<String> remains = new ArrayList<>(visan.keySet()); |
5776 |
655 |
for (int h = 0; h < hSize; h++) |
5777 |
|
{ |
5778 |
570 |
jalview.datamodel.AlignmentAnnotation jalan = al |
5779 |
|
.getAlignmentAnnotation()[h]; |
5780 |
570 |
if (jalan.autoCalculated) |
5781 |
|
{ |
5782 |
359 |
String k; |
5783 |
359 |
JvAnnotRow valan = visan.get(k = jalan.label); |
5784 |
359 |
if (jalan.getCalcId() != null) |
5785 |
|
{ |
5786 |
335 |
valan = visan.get(k = jalan.label + "\t" + jalan.getCalcId()); |
5787 |
|
} |
5788 |
|
|
5789 |
359 |
if (valan != null) |
5790 |
|
{ |
5791 |
|
|
5792 |
226 |
al.deleteAnnotation(jalan, false); |
5793 |
226 |
remains.remove(k); |
5794 |
226 |
hSize--; |
5795 |
226 |
h--; |
5796 |
226 |
if (valan != nullAnnot) |
5797 |
|
{ |
5798 |
226 |
if (jalan != valan.template) |
5799 |
|
{ |
5800 |
|
|
5801 |
|
|
5802 |
|
|
5803 |
202 |
if (valan.template.graphHeight >= 0) |
5804 |
|
|
5805 |
|
{ |
5806 |
202 |
jalan.graphHeight = valan.template.graphHeight; |
5807 |
|
} |
5808 |
202 |
jalan.visible = valan.template.visible; |
5809 |
|
} |
5810 |
226 |
reorder.add(new JvAnnotRow(valan.order, jalan)); |
5811 |
|
} |
5812 |
|
} |
5813 |
|
} |
5814 |
|
} |
5815 |
|
|
5816 |
|
|
5817 |
85 |
for (String other : remains) |
5818 |
|
{ |
5819 |
255 |
JvAnnotRow othera = visan.get(other); |
5820 |
255 |
if (othera != nullAnnot && othera.template.getCalcId() != null |
5821 |
|
&& othera.template.getCalcId().length() > 0) |
5822 |
|
{ |
5823 |
0 |
reorder.add(othera); |
5824 |
|
} |
5825 |
|
} |
5826 |
|
|
5827 |
85 |
int s = 0, srt[] = new int[reorder.size()]; |
5828 |
85 |
JvAnnotRow[] rws = new JvAnnotRow[reorder.size()]; |
5829 |
85 |
for (JvAnnotRow jvar : reorder) |
5830 |
|
{ |
5831 |
226 |
rws[s] = jvar; |
5832 |
226 |
srt[s++] = jvar.order; |
5833 |
|
} |
5834 |
85 |
reorder.clear(); |
5835 |
85 |
jalview.util.QuickSort.sort(srt, rws); |
5836 |
|
|
5837 |
85 |
for (JvAnnotRow jvar : rws) |
5838 |
|
{ |
5839 |
226 |
al.addAnnotation(jvar.template, jvar.order); |
5840 |
|
} |
5841 |
85 |
af.alignPanel.adjustAnnotationHeight(); |
5842 |
|
} |
5843 |
|
} |
5844 |
|
|
5845 |
|
Hashtable skipList = null; |
5846 |
|
|
5847 |
|
|
5848 |
|
|
5849 |
|
|
5850 |
|
@param |
5851 |
|
@return |
5852 |
|
|
5853 |
|
|
5854 |
|
|
5855 |
|
|
5856 |
|
|
5857 |
|
|
5858 |
|
|
5859 |
|
|
5860 |
|
|
5861 |
|
@param |
5862 |
|
@return |
5863 |
|
|
|
|
| 0% |
Uncovered Elements: 11 (11) |
Complexity: 3 |
Complexity Density: 0.43 |
|
5864 |
0 |
private boolean skipViewport(JalviewModel object)... |
5865 |
|
{ |
5866 |
0 |
if (skipList == null) |
5867 |
|
{ |
5868 |
0 |
return false; |
5869 |
|
} |
5870 |
0 |
String id = object.getViewport().get(0).getSequenceSetId(); |
5871 |
0 |
if (skipList.containsKey(id)) |
5872 |
|
{ |
5873 |
0 |
Console.debug("Skipping seuqence set id " + id); |
5874 |
0 |
return true; |
5875 |
|
} |
5876 |
0 |
return false; |
5877 |
|
} |
5878 |
|
|
|
|
| 0% |
Uncovered Elements: 5 (5) |
Complexity: 2 |
Complexity Density: 0.67 |
|
5879 |
0 |
public void addToSkipList(AlignFrame af)... |
5880 |
|
{ |
5881 |
0 |
if (skipList == null) |
5882 |
|
{ |
5883 |
0 |
skipList = new Hashtable(); |
5884 |
|
} |
5885 |
0 |
skipList.put(af.getViewport().getSequenceSetId(), af); |
5886 |
|
} |
5887 |
|
|
|
|
| 0% |
Uncovered Elements: 5 (5) |
Complexity: 2 |
Complexity Density: 0.67 |
|
5888 |
0 |
public void clearSkipList()... |
5889 |
|
{ |
5890 |
0 |
if (skipList != null) |
5891 |
|
{ |
5892 |
0 |
skipList.clear(); |
5893 |
0 |
skipList = null; |
5894 |
|
} |
5895 |
|
} |
5896 |
|
|
|
|
| 88.7% |
Uncovered Elements: 6 (53) |
Complexity: 13 |
Complexity Density: 0.39 |
|
5897 |
79 |
private void recoverDatasetFor(SequenceSet vamsasSet, AlignmentI al,... |
5898 |
|
boolean ignoreUnrefed, String uniqueSeqSetId) |
5899 |
|
{ |
5900 |
79 |
jalview.datamodel.AlignmentI ds = getDatasetFor( |
5901 |
|
vamsasSet.getDatasetId()); |
5902 |
79 |
AlignmentI xtant_ds = ds; |
5903 |
79 |
if (xtant_ds == null) |
5904 |
|
{ |
5905 |
|
|
5906 |
|
|
5907 |
|
|
5908 |
|
|
5909 |
38 |
xtant_ds = checkIfHasDataset(vamsasSet.getSequence()); |
5910 |
38 |
if (xtant_ds != null) |
5911 |
|
{ |
5912 |
2 |
ds = xtant_ds; |
5913 |
2 |
addDatasetRef(vamsasSet.getDatasetId(), ds); |
5914 |
|
} |
5915 |
|
} |
5916 |
79 |
Vector<SequenceI> dseqs = null; |
5917 |
79 |
if (!ignoreUnrefed) |
5918 |
|
{ |
5919 |
|
|
5920 |
55 |
AlignmentI seqSetDS = getDatasetFor(UNIQSEQSETID + uniqueSeqSetId); |
5921 |
55 |
if (seqSetDS != null) |
5922 |
|
{ |
5923 |
19 |
if (ds != null && ds != seqSetDS) |
5924 |
|
{ |
5925 |
0 |
Console.warn( |
5926 |
|
"JAL-3171 regression: Overwriting a dataset reference for an alignment" |
5927 |
|
+ " - CDS/Protein crossreference data may be lost"); |
5928 |
0 |
if (xtant_ds != null) |
5929 |
|
{ |
5930 |
|
|
5931 |
|
|
5932 |
|
|
5933 |
0 |
Console.warn( |
5934 |
|
"JAL-3171 SERIOUS! TOTAL CONFUSION - please consider contacting the Jalview Development team so they can investigate why your project caused this message to be displayed."); |
5935 |
|
} |
5936 |
|
} |
5937 |
19 |
ds = seqSetDS; |
5938 |
19 |
addDatasetRef(vamsasSet.getDatasetId(), ds); |
5939 |
|
} |
5940 |
|
} |
5941 |
79 |
if (ds == null) |
5942 |
|
{ |
5943 |
|
|
5944 |
24 |
AlignmentI xtantDS = checkIfHasDataset(vamsasSet.getSequence()); |
5945 |
|
|
5946 |
24 |
dseqs = new Vector<>(); |
5947 |
|
} |
5948 |
838 |
for (int i = 0, iSize = vamsasSet.getSequence().size(); i < iSize; i++) |
5949 |
|
{ |
5950 |
759 |
Sequence vamsasSeq = vamsasSet.getSequence().get(i); |
5951 |
759 |
ensureJalviewDatasetSequence(vamsasSeq, ds, dseqs, ignoreUnrefed, i); |
5952 |
|
} |
5953 |
|
|
5954 |
79 |
if (ds == null) |
5955 |
|
{ |
5956 |
24 |
SequenceI[] dsseqs = new SequenceI[dseqs.size()]; |
5957 |
24 |
dseqs.copyInto(dsseqs); |
5958 |
24 |
ds = new jalview.datamodel.Alignment(dsseqs); |
5959 |
24 |
Console.debug("Created new dataset " + vamsasSet.getDatasetId() |
5960 |
|
+ " for alignment " + System.identityHashCode(al)); |
5961 |
24 |
addDatasetRef(vamsasSet.getDatasetId(), ds); |
5962 |
|
} |
5963 |
|
|
5964 |
79 |
if (al.getDataset() == null && !ignoreUnrefed) |
5965 |
|
{ |
5966 |
55 |
al.setDataset(ds); |
5967 |
|
|
5968 |
55 |
addDatasetRef(UNIQSEQSETID + uniqueSeqSetId, ds); |
5969 |
|
} |
5970 |
79 |
updateSeqDatasetBinding(vamsasSet.getSequence(), ds); |
5971 |
|
} |
5972 |
|
|
5973 |
|
|
5974 |
|
|
5975 |
|
|
5976 |
|
HashMap<String, AlignmentI> seqToDataset = new HashMap<>(); |
5977 |
|
|
5978 |
|
|
5979 |
|
@return |
5980 |
|
|
5981 |
|
@param |
5982 |
|
|
5983 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 2 |
Complexity Density: 0.4 |
|
5984 |
62 |
AlignmentI checkIfHasDataset(List<Sequence> list)... |
5985 |
|
{ |
5986 |
62 |
for (Sequence restoredSeq : list) |
5987 |
|
{ |
5988 |
608 |
AlignmentI datasetFor = seqToDataset.get(restoredSeq.getDsseqid()); |
5989 |
608 |
if (datasetFor != null) |
5990 |
|
{ |
5991 |
2 |
return datasetFor; |
5992 |
|
} |
5993 |
|
} |
5994 |
60 |
return null; |
5995 |
|
} |
5996 |
|
|
5997 |
|
|
5998 |
|
|
5999 |
|
|
6000 |
|
|
6001 |
|
@param |
6002 |
|
|
6003 |
|
@param |
6004 |
|
|
|
|
| 66.7% |
Uncovered Elements: 2 (6) |
Complexity: 3 |
Complexity Density: 0.75 |
|
6005 |
79 |
void updateSeqDatasetBinding(List<Sequence> list, AlignmentI ds)... |
6006 |
|
{ |
6007 |
79 |
for (Sequence restoredSeq : list) |
6008 |
|
{ |
6009 |
759 |
AlignmentI prevDS = seqToDataset.put(restoredSeq.getDsseqid(), ds); |
6010 |
759 |
if (prevDS != null && prevDS != ds) |
6011 |
|
{ |
6012 |
0 |
Console.warn("Dataset sequence appears in many datasets: " |
6013 |
|
+ restoredSeq.getDsseqid()); |
6014 |
|
|
6015 |
|
} |
6016 |
|
} |
6017 |
|
} |
6018 |
|
|
6019 |
|
|
6020 |
|
|
6021 |
|
@param |
6022 |
|
|
6023 |
|
@param |
6024 |
|
|
6025 |
|
@param |
6026 |
|
|
6027 |
|
@param |
6028 |
|
|
6029 |
|
|
6030 |
|
@param |
6031 |
|
|
6032 |
|
|
6033 |
|
|
|
|
| 75.3% |
Uncovered Elements: 21 (85) |
Complexity: 25 |
Complexity Density: 0.53 |
|
6034 |
759 |
private void ensureJalviewDatasetSequence(Sequence vamsasSeq,... |
6035 |
|
AlignmentI ds, Vector<SequenceI> dseqs, boolean ignoreUnrefed, |
6036 |
|
int vseqpos) |
6037 |
|
{ |
6038 |
|
|
6039 |
|
|
6040 |
759 |
SequenceI sq = seqRefIds.get(vamsasSeq.getId()); |
6041 |
759 |
boolean reorder = false; |
6042 |
759 |
SequenceI dsq = null; |
6043 |
759 |
if (sq != null && sq.getDatasetSequence() != null) |
6044 |
|
{ |
6045 |
122 |
dsq = sq.getDatasetSequence(); |
6046 |
|
} |
6047 |
|
else |
6048 |
|
{ |
6049 |
637 |
reorder = true; |
6050 |
|
} |
6051 |
759 |
if (sq == null && ignoreUnrefed) |
6052 |
|
{ |
6053 |
0 |
return; |
6054 |
|
} |
6055 |
759 |
String sqid = vamsasSeq.getDsseqid(); |
6056 |
759 |
if (dsq == null) |
6057 |
|
{ |
6058 |
|
|
6059 |
637 |
if (sqid != null) |
6060 |
|
{ |
6061 |
637 |
dsq = seqRefIds.get(sqid); |
6062 |
|
} |
6063 |
|
|
6064 |
637 |
if (dsq == null) |
6065 |
|
{ |
6066 |
|
|
6067 |
309 |
dsq = sq.createDatasetSequence(); |
6068 |
309 |
if (sqid == null) |
6069 |
|
{ |
6070 |
|
|
6071 |
0 |
sqid = seqHash(dsq); |
6072 |
|
} |
6073 |
309 |
dsq.setVamsasId(uniqueSetSuffix + sqid); |
6074 |
309 |
seqRefIds.put(sqid, dsq); |
6075 |
309 |
if (ds == null) |
6076 |
|
{ |
6077 |
302 |
if (dseqs != null) |
6078 |
|
{ |
6079 |
302 |
dseqs.addElement(dsq); |
6080 |
|
} |
6081 |
|
} |
6082 |
|
else |
6083 |
|
{ |
6084 |
7 |
ds.addSequence(dsq); |
6085 |
|
} |
6086 |
|
} |
6087 |
|
else |
6088 |
|
{ |
6089 |
328 |
if (sq != dsq) |
6090 |
|
{ |
6091 |
16 |
sq.setDatasetSequence(dsq); |
6092 |
|
|
6093 |
16 |
if (ds == null) |
6094 |
|
{ |
6095 |
0 |
if (dseqs != null) |
6096 |
|
{ |
6097 |
0 |
if (!dseqs.contains(dsq)) |
6098 |
|
{ |
6099 |
0 |
dseqs.add(dsq); |
6100 |
|
} |
6101 |
|
} |
6102 |
|
else |
6103 |
|
{ |
6104 |
0 |
if (ds.findIndex(dsq) < 0) |
6105 |
|
{ |
6106 |
0 |
ds.addSequence(dsq); |
6107 |
|
} |
6108 |
|
} |
6109 |
|
} |
6110 |
|
} |
6111 |
|
} |
6112 |
|
} |
6113 |
|
|
6114 |
|
|
6115 |
|
|
6116 |
|
|
6117 |
|
|
6118 |
|
|
6119 |
759 |
if (sq != dsq) |
6120 |
|
{ |
6121 |
|
|
6122 |
447 |
String newres = jalview.analysis.AlignSeq.extractGaps( |
6123 |
|
jalview.util.Comparison.GapChars, sq.getSequenceAsString()); |
6124 |
447 |
if (!newres.equalsIgnoreCase(dsq.getSequenceAsString()) |
6125 |
|
&& newres.length() > dsq.getLength()) |
6126 |
|
{ |
6127 |
|
|
6128 |
8 |
synchronized (dsq) |
6129 |
|
{ |
6130 |
|
|
6131 |
|
|
6132 |
|
|
6133 |
|
|
6134 |
|
|
6135 |
|
|
6136 |
8 |
dsq.setSequence(newres); |
6137 |
|
} |
6138 |
|
|
6139 |
|
|
6140 |
8 |
jalview.bin.Console.errPrintln( |
6141 |
|
"DEBUG Notice: Merged dataset sequence (if you see this often, post at http://issues.jalview.org/browse/JAL-1474)"); |
6142 |
|
|
6143 |
|
|
6144 |
|
} |
6145 |
|
} |
6146 |
|
else |
6147 |
|
{ |
6148 |
|
|
6149 |
|
|
6150 |
312 |
if (ds != null && dseqs == null) |
6151 |
|
{ |
6152 |
312 |
int opos = ds.findIndex(dsq); |
6153 |
312 |
SequenceI tseq = null; |
6154 |
312 |
if (opos != -1 && vseqpos != opos) |
6155 |
|
{ |
6156 |
|
|
6157 |
39 |
ds.deleteSequence(dsq); |
6158 |
|
} |
6159 |
312 |
if (vseqpos < ds.getHeight()) |
6160 |
|
{ |
6161 |
312 |
if (vseqpos != opos) |
6162 |
|
{ |
6163 |
|
|
6164 |
50 |
tseq = ds.getSequenceAt(vseqpos); |
6165 |
50 |
ds.replaceSequenceAt(vseqpos, dsq); |
6166 |
50 |
ds.addSequence(tseq); |
6167 |
|
} |
6168 |
|
} |
6169 |
|
else |
6170 |
|
{ |
6171 |
0 |
ds.addSequence(dsq); |
6172 |
|
} |
6173 |
|
} |
6174 |
|
} |
6175 |
|
} |
6176 |
|
|
6177 |
|
|
6178 |
|
|
6179 |
|
|
6180 |
|
|
6181 |
|
Hashtable<String, AlignmentI> datasetIds = null; |
6182 |
|
|
6183 |
|
IdentityHashMap<AlignmentI, String> dataset2Ids = null; |
6184 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (10) |
Complexity: 3 |
Complexity Density: 0.5 |
|
6185 |
158 |
private AlignmentI getDatasetFor(String datasetId)... |
6186 |
|
{ |
6187 |
158 |
if (datasetIds == null) |
6188 |
|
{ |
6189 |
24 |
datasetIds = new Hashtable<>(); |
6190 |
24 |
return null; |
6191 |
|
} |
6192 |
134 |
if (datasetIds.containsKey(datasetId)) |
6193 |
|
{ |
6194 |
84 |
return datasetIds.get(datasetId); |
6195 |
|
} |
6196 |
50 |
return null; |
6197 |
|
} |
6198 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (5) |
Complexity: 2 |
Complexity Density: 0.67 |
|
6199 |
134 |
private void addDatasetRef(String datasetId, AlignmentI dataset)... |
6200 |
|
{ |
6201 |
134 |
if (datasetIds == null) |
6202 |
|
{ |
6203 |
10 |
datasetIds = new Hashtable<>(); |
6204 |
|
} |
6205 |
134 |
datasetIds.put(datasetId, dataset); |
6206 |
|
} |
6207 |
|
|
6208 |
|
|
6209 |
|
|
6210 |
|
|
6211 |
|
@param |
6212 |
|
@return |
6213 |
|
|
|
|
| 84.2% |
Uncovered Elements: 3 (19) |
Complexity: 5 |
Complexity Density: 0.45 |
|
6214 |
109 |
private String getDatasetIdRef(AlignmentI dataset)... |
6215 |
|
{ |
6216 |
109 |
if (dataset.getDataset() != null) |
6217 |
|
{ |
6218 |
0 |
Console.warn( |
6219 |
|
"Serious issue! Dataset Object passed to getDatasetIdRef is not a Jalview DATASET alignment..."); |
6220 |
|
} |
6221 |
109 |
String datasetId = makeHashCode(dataset, null); |
6222 |
109 |
if (datasetId == null) |
6223 |
|
{ |
6224 |
|
|
6225 |
109 |
if (dataset2Ids == null) |
6226 |
|
{ |
6227 |
33 |
dataset2Ids = new IdentityHashMap<>(); |
6228 |
|
} |
6229 |
|
else |
6230 |
|
{ |
6231 |
76 |
datasetId = dataset2Ids.get(dataset); |
6232 |
|
} |
6233 |
109 |
if (datasetId == null) |
6234 |
|
{ |
6235 |
41 |
datasetId = "ds" + dataset2Ids.size() + 1; |
6236 |
41 |
dataset2Ids.put(dataset, datasetId); |
6237 |
|
} |
6238 |
|
} |
6239 |
109 |
return datasetId; |
6240 |
|
} |
6241 |
|
|
6242 |
|
|
6243 |
|
|
6244 |
|
|
6245 |
|
|
6246 |
|
@param |
6247 |
|
@param |
6248 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (16) |
Complexity: 4 |
Complexity Density: 0.4 |
|
6249 |
207 |
private void addDBRefs(SequenceI datasetSequence, Sequence sequence)... |
6250 |
|
{ |
6251 |
1281 |
for (int d = 0; d < sequence.getDBRef().size(); d++) |
6252 |
|
{ |
6253 |
1074 |
DBRef dr = sequence.getDBRef().get(d); |
6254 |
1074 |
DBRefEntry entry; |
6255 |
1074 |
if (dr.isLocus()) |
6256 |
|
{ |
6257 |
23 |
entry = new GeneLocus(dr.getSource(), dr.getVersion(), |
6258 |
|
dr.getAccessionId()); |
6259 |
|
} |
6260 |
|
else |
6261 |
|
{ |
6262 |
1051 |
entry = new DBRefEntry(dr.getSource(), dr.getVersion(), |
6263 |
|
dr.getAccessionId()); |
6264 |
|
} |
6265 |
1074 |
if (dr.getMapping() != null) |
6266 |
|
{ |
6267 |
46 |
entry.setMap(addMapping(dr.getMapping())); |
6268 |
|
} |
6269 |
1074 |
entry.setCanonical(dr.isCanonical()); |
6270 |
1074 |
datasetSequence.addDBRef(entry); |
6271 |
|
} |
6272 |
|
} |
6273 |
|
|
|
|
| 53.8% |
Uncovered Elements: 24 (52) |
Complexity: 9 |
Complexity Density: 0.24 |
|
6274 |
46 |
private jalview.datamodel.Mapping addMapping(Mapping m)... |
6275 |
|
{ |
6276 |
46 |
SequenceI dsto = null; |
6277 |
|
|
6278 |
46 |
int fr[] = new int[m.getMapListFrom().size() * 2]; |
6279 |
46 |
Iterator<MapListFrom> from = m.getMapListFrom().iterator(); |
6280 |
92 |
for (int _i = 0; from.hasNext(); _i += 2) |
6281 |
|
{ |
6282 |
46 |
MapListFrom mf = from.next(); |
6283 |
46 |
fr[_i] = mf.getStart(); |
6284 |
46 |
fr[_i + 1] = mf.getEnd(); |
6285 |
|
} |
6286 |
46 |
int fto[] = new int[m.getMapListTo().size() * 2]; |
6287 |
46 |
Iterator<MapListTo> to = m.getMapListTo().iterator(); |
6288 |
313 |
for (int _i = 0; to.hasNext(); _i += 2) |
6289 |
|
{ |
6290 |
267 |
MapListTo mf = to.next(); |
6291 |
267 |
fto[_i] = mf.getStart(); |
6292 |
267 |
fto[_i + 1] = mf.getEnd(); |
6293 |
|
} |
6294 |
46 |
jalview.datamodel.Mapping jmap = new jalview.datamodel.Mapping(dsto, fr, |
6295 |
|
fto, m.getMapFromUnit().intValue(), |
6296 |
|
m.getMapToUnit().intValue()); |
6297 |
|
|
6298 |
|
|
6299 |
|
|
6300 |
|
|
6301 |
46 |
if (m.getDseqFor() != null) |
6302 |
|
{ |
6303 |
23 |
String dsfor = m.getDseqFor(); |
6304 |
23 |
if (seqRefIds.containsKey(dsfor)) |
6305 |
|
{ |
6306 |
|
|
6307 |
|
|
6308 |
|
|
6309 |
23 |
jmap.setTo(seqRefIds.get(dsfor)); |
6310 |
|
} |
6311 |
|
else |
6312 |
|
{ |
6313 |
0 |
frefedSequence.add(newMappingRef(dsfor, jmap)); |
6314 |
|
} |
6315 |
|
} |
6316 |
23 |
else if (m.getSequence() != null) |
6317 |
|
{ |
6318 |
|
|
6319 |
|
|
6320 |
|
|
6321 |
0 |
Sequence ms = m.getSequence(); |
6322 |
0 |
SequenceI djs = null; |
6323 |
0 |
String sqid = ms.getDsseqid(); |
6324 |
0 |
if (sqid != null && sqid.length() > 0) |
6325 |
|
{ |
6326 |
|
|
6327 |
|
|
6328 |
|
|
6329 |
0 |
djs = seqRefIds.get(sqid); |
6330 |
|
} |
6331 |
|
else |
6332 |
|
{ |
6333 |
0 |
jalview.bin.Console.errPrintln( |
6334 |
|
"Warning - making up dataset sequence id for DbRef sequence map reference"); |
6335 |
0 |
sqid = ((Object) ms).toString(); |
6336 |
|
|
6337 |
|
|
6338 |
|
} |
6339 |
|
|
6340 |
0 |
if (djs == null) |
6341 |
|
{ |
6342 |
|
|
6343 |
|
|
6344 |
|
|
6345 |
0 |
djs = new jalview.datamodel.Sequence(ms.getName(), |
6346 |
|
ms.getSequence()); |
6347 |
0 |
djs.setStart(jmap.getMap().getToLowest()); |
6348 |
0 |
djs.setEnd(jmap.getMap().getToHighest()); |
6349 |
0 |
djs.setVamsasId(uniqueSetSuffix + sqid); |
6350 |
0 |
jmap.setTo(djs); |
6351 |
0 |
incompleteSeqs.put(sqid, djs); |
6352 |
0 |
seqRefIds.put(sqid, djs); |
6353 |
|
|
6354 |
|
} |
6355 |
0 |
Console.debug("about to recurse on addDBRefs."); |
6356 |
0 |
addDBRefs(djs, ms); |
6357 |
|
|
6358 |
|
} |
6359 |
|
|
6360 |
46 |
return jmap; |
6361 |
|
} |
6362 |
|
|
6363 |
|
|
6364 |
|
|
6365 |
|
|
6366 |
|
|
6367 |
|
@param |
6368 |
|
@return |
6369 |
|
|
|
|
| 85.7% |
Uncovered Elements: 2 (14) |
Complexity: 2 |
Complexity Density: 0.17 |
|
6370 |
10 |
public AlignmentPanel copyAlignPanel(AlignmentPanel ap)... |
6371 |
|
{ |
6372 |
10 |
initSeqRefs(); |
6373 |
10 |
JalviewModel jm = saveState(ap, null, null, null); |
6374 |
|
|
6375 |
10 |
addDatasetRef( |
6376 |
|
jm.getVamsasModel().getSequenceSet().get(0).getDatasetId(), |
6377 |
|
ap.getAlignment().getDataset()); |
6378 |
|
|
6379 |
10 |
uniqueSetSuffix = ""; |
6380 |
|
|
6381 |
10 |
jm.getViewport().get(0).setId(null); |
6382 |
|
|
6383 |
|
|
6384 |
10 |
if (this.frefedSequence == null) |
6385 |
|
{ |
6386 |
0 |
frefedSequence = new Vector<>(); |
6387 |
|
} |
6388 |
|
|
6389 |
10 |
viewportsAdded.clear(); |
6390 |
|
|
6391 |
10 |
AlignFrame af = loadFromObject(jm, null, false, null); |
6392 |
10 |
af.getAlignPanels().clear(); |
6393 |
10 |
af.closeMenuItem_actionPerformed(true); |
6394 |
|
|
6395 |
|
|
6396 |
|
|
6397 |
|
|
6398 |
|
|
6399 |
|
|
6400 |
|
|
6401 |
|
|
6402 |
|
|
6403 |
10 |
return af.alignPanel; |
6404 |
|
} |
6405 |
|
|
6406 |
|
private Hashtable jvids2vobj; |
6407 |
|
|
6408 |
|
|
6409 |
|
|
6410 |
|
|
6411 |
|
|
6412 |
|
|
6413 |
|
|
6414 |
|
|
6415 |
|
@param |
6416 |
|
|
6417 |
|
@param |
6418 |
|
|
6419 |
|
|
6420 |
|
|
6421 |
|
|
|
|
| 0% |
Uncovered Elements: 53 (53) |
Complexity: 12 |
Complexity Density: 0.39 |
|
6422 |
0 |
public void setObjectMappingTables(Hashtable vobj2jv,... |
6423 |
|
IdentityHashMap jv2vobj) |
6424 |
|
{ |
6425 |
0 |
this.jv2vobj = jv2vobj; |
6426 |
0 |
this.vobj2jv = vobj2jv; |
6427 |
0 |
Iterator ds = jv2vobj.keySet().iterator(); |
6428 |
0 |
String id; |
6429 |
0 |
while (ds.hasNext()) |
6430 |
|
{ |
6431 |
0 |
Object jvobj = ds.next(); |
6432 |
0 |
id = jv2vobj.get(jvobj).toString(); |
6433 |
0 |
if (jvobj instanceof jalview.datamodel.Alignment) |
6434 |
|
{ |
6435 |
0 |
if (((jalview.datamodel.Alignment) jvobj).getDataset() == null) |
6436 |
|
{ |
6437 |
0 |
addDatasetRef(id, (jalview.datamodel.Alignment) jvobj); |
6438 |
|
} |
6439 |
|
} |
6440 |
0 |
else if (jvobj instanceof jalview.datamodel.Sequence) |
6441 |
|
{ |
6442 |
|
|
6443 |
0 |
if (seqRefIds == null) |
6444 |
|
{ |
6445 |
0 |
seqRefIds = new HashMap<>(); |
6446 |
|
} |
6447 |
0 |
if (seqsToIds == null) |
6448 |
|
{ |
6449 |
0 |
seqsToIds = new IdentityHashMap<>(); |
6450 |
|
} |
6451 |
0 |
seqRefIds.put(jv2vobj.get(jvobj).toString(), (SequenceI) jvobj); |
6452 |
0 |
seqsToIds.put((SequenceI) jvobj, id); |
6453 |
|
} |
6454 |
0 |
else if (jvobj instanceof jalview.datamodel.AlignmentAnnotation) |
6455 |
|
{ |
6456 |
0 |
String anid; |
6457 |
0 |
AlignmentAnnotation jvann = (AlignmentAnnotation) jvobj; |
6458 |
0 |
annotationIds.put(anid = jv2vobj.get(jvobj).toString(), jvann); |
6459 |
0 |
if (jvann.annotationId == null) |
6460 |
|
{ |
6461 |
0 |
jvann.annotationId = anid; |
6462 |
|
} |
6463 |
0 |
if (!jvann.annotationId.equals(anid)) |
6464 |
|
{ |
6465 |
|
|
6466 |
0 |
Console.warn("Overriding Annotation ID for " + anid |
6467 |
|
+ " from different id : " + jvann.annotationId); |
6468 |
0 |
jvann.annotationId = anid; |
6469 |
|
} |
6470 |
|
} |
6471 |
0 |
else if (jvobj instanceof String) |
6472 |
|
{ |
6473 |
0 |
if (jvids2vobj == null) |
6474 |
|
{ |
6475 |
0 |
jvids2vobj = new Hashtable(); |
6476 |
0 |
jvids2vobj.put(jvobj, jv2vobj.get(jvobj).toString()); |
6477 |
|
} |
6478 |
|
} |
6479 |
|
else |
6480 |
|
{ |
6481 |
0 |
Console.debug("Ignoring " + jvobj.getClass() + " (ID = " + id); |
6482 |
|
} |
6483 |
|
} |
6484 |
|
} |
6485 |
|
|
6486 |
|
|
6487 |
|
|
6488 |
|
|
6489 |
|
|
6490 |
|
|
6491 |
|
@param |
6492 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
6493 |
0 |
public void setUniqueSetSuffix(String string)... |
6494 |
|
{ |
6495 |
0 |
uniqueSetSuffix = string; |
6496 |
|
|
6497 |
|
} |
6498 |
|
|
6499 |
|
|
6500 |
|
|
6501 |
|
|
6502 |
|
|
6503 |
|
@param |
6504 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
6505 |
0 |
public void setSkipList(Hashtable skipList2)... |
6506 |
|
{ |
6507 |
0 |
skipList = skipList2; |
6508 |
|
} |
6509 |
|
|
6510 |
|
|
6511 |
|
|
6512 |
|
|
6513 |
|
|
6514 |
|
@param |
6515 |
|
@param |
6516 |
|
@return |
6517 |
|
|
|
|
| 75% |
Uncovered Elements: 7 (28) |
Complexity: 8 |
Complexity Density: 0.4 |
|
6518 |
2 |
protected String readJarEntry(jarInputStreamProvider jprovider,... |
6519 |
|
String jarEntryName) |
6520 |
|
{ |
6521 |
2 |
String result = null; |
6522 |
2 |
BufferedReader in = null; |
6523 |
|
|
6524 |
2 |
try |
6525 |
|
{ |
6526 |
|
|
6527 |
|
|
6528 |
|
|
6529 |
|
|
6530 |
2 |
JarInputStream jin = jprovider.getJarInputStream(); |
6531 |
2 |
JarEntry entry = null; |
6532 |
2 |
do |
6533 |
|
{ |
6534 |
2 |
entry = jin.getNextJarEntry(); |
6535 |
2 |
} while (entry != null && !entry.getName().equals(jarEntryName)); |
6536 |
|
|
6537 |
2 |
if (entry != null) |
6538 |
|
{ |
6539 |
2 |
StringBuilder out = new StringBuilder(256); |
6540 |
2 |
in = new BufferedReader(new InputStreamReader(jin, UTF_8)); |
6541 |
2 |
String data; |
6542 |
|
|
6543 |
? |
while ((data = in.readLine()) != null) |
6544 |
|
{ |
6545 |
684 |
out.append(data); |
6546 |
|
} |
6547 |
2 |
result = out.toString(); |
6548 |
|
} |
6549 |
|
else |
6550 |
|
{ |
6551 |
0 |
Console.warn( |
6552 |
|
"Couldn't find entry in Jalview Jar for " + jarEntryName); |
6553 |
|
} |
6554 |
|
} catch (Exception ex) |
6555 |
|
{ |
6556 |
0 |
ex.printStackTrace(); |
6557 |
|
} finally |
6558 |
|
{ |
6559 |
2 |
if (in != null) |
6560 |
|
{ |
6561 |
2 |
try |
6562 |
|
{ |
6563 |
2 |
in.close(); |
6564 |
|
} catch (IOException e) |
6565 |
|
{ |
6566 |
|
|
6567 |
|
} |
6568 |
|
} |
6569 |
|
} |
6570 |
|
|
6571 |
2 |
return result; |
6572 |
|
} |
6573 |
|
|
6574 |
|
|
6575 |
|
|
6576 |
|
|
6577 |
|
@return |
6578 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
6579 |
0 |
private synchronized int nextCounter()... |
6580 |
|
{ |
6581 |
0 |
return counter++; |
6582 |
|
} |
6583 |
|
|
6584 |
|
|
6585 |
|
|
6586 |
|
|
6587 |
|
@param |
6588 |
|
@param |
6589 |
|
|
|
|
| 91.5% |
Uncovered Elements: 5 (59) |
Complexity: 5 |
Complexity Density: 0.09 |
|
6590 |
75 |
protected void loadPCAViewers(JalviewModel model, AlignmentPanel ap)... |
6591 |
|
{ |
6592 |
75 |
try |
6593 |
|
{ |
6594 |
75 |
List<PcaViewer> pcaviewers = model.getPcaViewer(); |
6595 |
75 |
for (PcaViewer viewer : pcaviewers) |
6596 |
|
{ |
6597 |
1 |
if (isPasimap(viewer)) |
6598 |
|
{ |
6599 |
0 |
continue; |
6600 |
|
} |
6601 |
1 |
String modelName = viewer.getScoreModelName(); |
6602 |
1 |
SimilarityParamsI params = new SimilarityParams( |
6603 |
|
viewer.isIncludeGappedColumns(), viewer.isMatchGaps(), |
6604 |
|
viewer.isIncludeGaps(), |
6605 |
|
viewer.isDenominateByShortestLength()); |
6606 |
|
|
6607 |
|
|
6608 |
|
|
6609 |
|
|
6610 |
1 |
PCAPanel panel = new PCAPanel(ap, modelName, params); |
6611 |
|
|
6612 |
1 |
panel.setTitle(viewer.getTitle()); |
6613 |
1 |
panel.setBounds(new Rectangle(viewer.getXpos(), viewer.getYpos(), |
6614 |
|
viewer.getWidth(), viewer.getHeight())); |
6615 |
|
|
6616 |
1 |
boolean showLabels = viewer.isShowLabels(); |
6617 |
1 |
panel.setShowLabels(showLabels); |
6618 |
1 |
panel.getRotatableCanvas().setShowLabels(showLabels); |
6619 |
1 |
panel.getRotatableCanvas() |
6620 |
|
.setBgColour(new Color(viewer.getBgColour())); |
6621 |
1 |
panel.getRotatableCanvas() |
6622 |
|
.setApplyToAllViews(viewer.isLinkToAllViews()); |
6623 |
|
|
6624 |
|
|
6625 |
|
|
6626 |
|
|
6627 |
1 |
ScoreModelI scoreModel = ScoreModels.getInstance() |
6628 |
|
.getScoreModel(modelName, ap); |
6629 |
1 |
PCA pca = new PCA(null, scoreModel, params); |
6630 |
1 |
PcaDataType pcaData = viewer.getPcaData(); |
6631 |
|
|
6632 |
1 |
MatrixI pairwise = loadDoubleMatrix(pcaData.getPairwiseMatrix()); |
6633 |
1 |
pca.setPairwiseScores(pairwise); |
6634 |
|
|
6635 |
1 |
MatrixI triDiag = loadDoubleMatrix(pcaData.getTridiagonalMatrix()); |
6636 |
1 |
pca.setTridiagonal(triDiag); |
6637 |
|
|
6638 |
1 |
MatrixI result = loadDoubleMatrix(pcaData.getEigenMatrix()); |
6639 |
1 |
pca.setEigenmatrix(result); |
6640 |
|
|
6641 |
1 |
panel.getPcaModel().setPCA(pca); |
6642 |
|
|
6643 |
|
|
6644 |
|
|
6645 |
|
|
6646 |
1 |
panel.setInputData(null); |
6647 |
|
|
6648 |
|
|
6649 |
|
|
6650 |
|
|
6651 |
1 |
List<jalview.datamodel.SequencePoint> seqPoints = new ArrayList<>(); |
6652 |
1 |
for (SequencePoint sp : viewer.getSequencePoint()) |
6653 |
|
{ |
6654 |
15 |
String seqId = sp.getSequenceRef(); |
6655 |
15 |
SequenceI seq = seqRefIds.get(seqId); |
6656 |
15 |
if (seq == null) |
6657 |
|
{ |
6658 |
0 |
throw new IllegalStateException( |
6659 |
|
"Unmatched seqref for PCA: " + seqId); |
6660 |
|
} |
6661 |
15 |
Point pt = new Point(sp.getXPos(), sp.getYPos(), sp.getZPos()); |
6662 |
15 |
jalview.datamodel.SequencePoint seqPoint = new jalview.datamodel.SequencePoint( |
6663 |
|
seq, pt); |
6664 |
15 |
seqPoints.add(seqPoint); |
6665 |
|
} |
6666 |
1 |
panel.getRotatableCanvas().setPoints(seqPoints, seqPoints.size()); |
6667 |
|
|
6668 |
|
|
6669 |
|
|
6670 |
|
|
6671 |
1 |
panel.getRotatableCanvas().setScaleFactor(viewer.getScaleFactor()); |
6672 |
1 |
SeqPointMin spMin = viewer.getSeqPointMin(); |
6673 |
1 |
float[] min = new float[] { spMin.getXPos(), spMin.getYPos(), |
6674 |
|
spMin.getZPos() }; |
6675 |
1 |
SeqPointMax spMax = viewer.getSeqPointMax(); |
6676 |
1 |
float[] max = new float[] { spMax.getXPos(), spMax.getYPos(), |
6677 |
|
spMax.getZPos() }; |
6678 |
1 |
panel.getRotatableCanvas().setSeqMinMax(min, max); |
6679 |
|
|
6680 |
|
|
6681 |
1 |
panel.getPcaModel().setSequencePoints(seqPoints); |
6682 |
|
|
6683 |
1 |
panel.setSelectedDimensionIndex(viewer.getXDim(), X); |
6684 |
1 |
panel.setSelectedDimensionIndex(viewer.getYDim(), Y); |
6685 |
1 |
panel.setSelectedDimensionIndex(viewer.getZDim(), Z); |
6686 |
|
|
6687 |
|
|
6688 |
1 |
panel.setTop(seqPoints.size() - 1); |
6689 |
1 |
panel.getPcaModel().setTop(seqPoints.size() - 1); |
6690 |
|
|
6691 |
|
|
6692 |
|
|
6693 |
|
|
6694 |
4 |
for (int i = 0; i < 3; i++) |
6695 |
|
{ |
6696 |
3 |
Axis axis = viewer.getAxis().get(i); |
6697 |
3 |
panel.getRotatableCanvas().getAxisEndPoints()[i] = new Point( |
6698 |
|
axis.getXPos(), axis.getYPos(), axis.getZPos()); |
6699 |
|
} |
6700 |
|
|
6701 |
1 |
Desktop.addInternalFrame(panel, MessageManager.formatMessage( |
6702 |
|
"label.calc_title", "PCA", modelName), 475, 450); |
6703 |
|
} |
6704 |
|
} catch (Exception ex) |
6705 |
|
{ |
6706 |
0 |
Console.error("Error loading PCA: " + ex.toString()); |
6707 |
|
} |
6708 |
|
} |
6709 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
6710 |
2 |
private boolean isPasimap(PcaViewer viewer)... |
6711 |
|
{ |
6712 |
2 |
return viewer.getTitle().toLowerCase(Locale.ROOT).startsWith("pasimap"); |
6713 |
|
} |
6714 |
|
|
6715 |
|
|
6716 |
|
|
6717 |
|
|
6718 |
|
@param |
6719 |
|
@param |
6720 |
|
|
|
|
| 10.7% |
Uncovered Elements: 50 (56) |
Complexity: 5 |
Complexity Density: 0.1 |
|
6721 |
75 |
protected void loadPaSiMapViewers(JalviewModel model, AlignmentPanel ap)... |
6722 |
|
{ |
6723 |
75 |
try |
6724 |
|
{ |
6725 |
75 |
List<PcaViewer> pcaviewers = model.getPcaViewer(); |
6726 |
75 |
for (PcaViewer viewer : pcaviewers) |
6727 |
|
{ |
6728 |
1 |
if (!isPasimap(viewer)) |
6729 |
|
{ |
6730 |
1 |
continue; |
6731 |
|
} |
6732 |
0 |
String modelName = viewer.getScoreModelName(); |
6733 |
|
|
6734 |
|
|
6735 |
|
|
6736 |
|
|
6737 |
|
|
6738 |
|
|
6739 |
|
|
6740 |
|
|
6741 |
|
|
6742 |
|
|
6743 |
0 |
PaSiMapPanel panel = new PaSiMapPanel(ap, modelName); |
6744 |
|
|
6745 |
0 |
panel.setTitle(viewer.getTitle()); |
6746 |
0 |
panel.setBounds(new Rectangle(viewer.getXpos(), viewer.getYpos(), |
6747 |
|
viewer.getWidth(), viewer.getHeight())); |
6748 |
|
|
6749 |
0 |
boolean showLabels = viewer.isShowLabels(); |
6750 |
0 |
panel.setShowLabels(showLabels); |
6751 |
0 |
panel.getRotatableCanvas().setShowLabels(showLabels); |
6752 |
0 |
panel.getRotatableCanvas() |
6753 |
|
.setBgColour(new Color(viewer.getBgColour())); |
6754 |
0 |
panel.getRotatableCanvas() |
6755 |
|
.setApplyToAllViews(viewer.isLinkToAllViews()); |
6756 |
|
|
6757 |
|
|
6758 |
|
|
6759 |
|
|
6760 |
0 |
ScoreModelI scoreModel = ScoreModels.getInstance() |
6761 |
|
.getScoreModel(modelName, ap); |
6762 |
0 |
PaSiMap pasimap = new PaSiMap(null, scoreModel, null); |
6763 |
0 |
PcaDataType pasimapData = viewer.getPcaData(); |
6764 |
|
|
6765 |
0 |
MatrixI pairwise = loadDoubleMatrix( |
6766 |
|
pasimapData.getPairwiseMatrix()); |
6767 |
0 |
pasimap.setPairwiseScores(pairwise); |
6768 |
|
|
6769 |
0 |
MatrixI result = loadDoubleMatrix(pasimapData.getEigenMatrix()); |
6770 |
0 |
pasimap.setEigenmatrix(result); |
6771 |
|
|
6772 |
0 |
panel.getPasimapModel().setPaSiMap(pasimap); |
6773 |
|
|
6774 |
|
|
6775 |
|
|
6776 |
|
|
6777 |
0 |
panel.setInputData(null); |
6778 |
|
|
6779 |
|
|
6780 |
|
|
6781 |
|
|
6782 |
0 |
List<jalview.datamodel.SequencePoint> seqPoints = new ArrayList<>(); |
6783 |
0 |
for (SequencePoint sp : viewer.getSequencePoint()) |
6784 |
|
{ |
6785 |
0 |
String seqId = sp.getSequenceRef(); |
6786 |
0 |
SequenceI seq = seqRefIds.get(seqId); |
6787 |
0 |
if (seq == null) |
6788 |
|
{ |
6789 |
0 |
throw new IllegalStateException( |
6790 |
|
"Unmatched seqref for PaSiMap: " + seqId); |
6791 |
|
} |
6792 |
0 |
Point pt = new Point(sp.getXPos(), sp.getYPos(), sp.getZPos()); |
6793 |
0 |
jalview.datamodel.SequencePoint seqPoint = new jalview.datamodel.SequencePoint( |
6794 |
|
seq, pt); |
6795 |
0 |
seqPoints.add(seqPoint); |
6796 |
|
} |
6797 |
0 |
panel.getRotatableCanvas().setPoints(seqPoints, seqPoints.size()); |
6798 |
|
|
6799 |
|
|
6800 |
|
|
6801 |
|
|
6802 |
0 |
panel.getRotatableCanvas().setScaleFactor(viewer.getScaleFactor()); |
6803 |
0 |
SeqPointMin spMin = viewer.getSeqPointMin(); |
6804 |
0 |
float[] min = new float[] { spMin.getXPos(), spMin.getYPos(), |
6805 |
|
spMin.getZPos() }; |
6806 |
0 |
SeqPointMax spMax = viewer.getSeqPointMax(); |
6807 |
0 |
float[] max = new float[] { spMax.getXPos(), spMax.getYPos(), |
6808 |
|
spMax.getZPos() }; |
6809 |
0 |
panel.getRotatableCanvas().setSeqMinMax(min, max); |
6810 |
|
|
6811 |
|
|
6812 |
0 |
panel.getPasimapModel().setSequencePoints(seqPoints); |
6813 |
|
|
6814 |
0 |
panel.setSelectedDimensionIndex(viewer.getXDim(), X); |
6815 |
0 |
panel.setSelectedDimensionIndex(viewer.getYDim(), Y); |
6816 |
0 |
panel.setSelectedDimensionIndex(viewer.getZDim(), Z); |
6817 |
|
|
6818 |
|
|
6819 |
0 |
panel.setTop(seqPoints.size() - 1); |
6820 |
0 |
panel.getPasimapModel().setTop(seqPoints.size() - 1); |
6821 |
|
|
6822 |
|
|
6823 |
|
|
6824 |
|
|
6825 |
0 |
for (int i = 0; i < 3; i++) |
6826 |
|
{ |
6827 |
0 |
Axis axis = viewer.getAxis().get(i); |
6828 |
0 |
panel.getRotatableCanvas().getAxisEndPoints()[i] = new Point( |
6829 |
|
axis.getXPos(), axis.getYPos(), axis.getZPos()); |
6830 |
|
} |
6831 |
|
|
6832 |
0 |
Desktop.addInternalFrame(panel, MessageManager.formatMessage( |
6833 |
|
"label.calc_title", "PaSiMap", modelName), 475, 450); |
6834 |
|
} |
6835 |
|
} catch (Exception ex) |
6836 |
|
{ |
6837 |
0 |
Console.error("Error loading PaSiMap: " + ex.toString()); |
6838 |
|
} |
6839 |
|
} |
6840 |
|
|
6841 |
|
|
6842 |
|
|
6843 |
|
|
6844 |
|
@param |
6845 |
|
@param |
6846 |
|
@param |
6847 |
|
@param |
6848 |
|
|
|
|
| 69.2% |
Uncovered Elements: 4 (13) |
Complexity: 3 |
Complexity Density: 0.27 |
|
6849 |
7 |
protected void createStructureViewer(ViewerType viewerType,... |
6850 |
|
final Entry<String, StructureViewerModel> viewerData, |
6851 |
|
AlignFrame af, jarInputStreamProvider jprovider) |
6852 |
|
{ |
6853 |
7 |
final StructureViewerModel viewerModel = viewerData.getValue(); |
6854 |
7 |
String sessionFilePath = null; |
6855 |
|
|
6856 |
7 |
if (viewerType == ViewerType.JMOL) |
6857 |
|
{ |
6858 |
7 |
sessionFilePath = rewriteJmolSession(viewerModel, jprovider); |
6859 |
|
} |
6860 |
|
else |
6861 |
|
{ |
6862 |
0 |
String viewerJarEntryName = getViewerJarEntryName( |
6863 |
|
viewerModel.getViewId()); |
6864 |
0 |
sessionFilePath = copyJarEntry(jprovider, viewerJarEntryName, |
6865 |
|
"viewerSession", ".tmp"); |
6866 |
|
} |
6867 |
7 |
final String sessionPath = sessionFilePath; |
6868 |
7 |
final String sviewid = viewerData.getKey(); |
6869 |
7 |
try |
6870 |
|
{ |
6871 |
7 |
SwingUtilities.invokeAndWait(new Runnable() |
6872 |
|
{ |
|
|
| 36.4% |
Uncovered Elements: 7 (11) |
Complexity: 4 |
Complexity Density: 0.44 |
|
6873 |
7 |
@Override... |
6874 |
|
public void run() |
6875 |
|
{ |
6876 |
7 |
JalviewStructureDisplayI sview = null; |
6877 |
7 |
try |
6878 |
|
{ |
6879 |
7 |
sview = StructureViewer.createView(viewerType, af.alignPanel, |
6880 |
|
viewerModel, sessionPath, sviewid); |
6881 |
7 |
addNewStructureViewer(sview); |
6882 |
|
} catch (OutOfMemoryError ex) |
6883 |
|
{ |
6884 |
0 |
new OOMWarning("Restoring structure view for " + viewerType, |
6885 |
|
(OutOfMemoryError) ex.getCause()); |
6886 |
0 |
if (sview != null && sview.isVisible()) |
6887 |
|
{ |
6888 |
0 |
sview.closeViewer(false); |
6889 |
0 |
sview.setVisible(false); |
6890 |
0 |
sview.dispose(); |
6891 |
|
} |
6892 |
|
} |
6893 |
|
} |
6894 |
|
}); |
6895 |
|
} catch (InvocationTargetException | InterruptedException ex) |
6896 |
|
{ |
6897 |
0 |
Console.warn("Unexpected error when opening " + viewerType |
6898 |
|
+ " structure viewer", ex); |
6899 |
|
} |
6900 |
|
} |
6901 |
|
|
6902 |
|
|
6903 |
|
|
6904 |
|
|
6905 |
|
|
6906 |
|
|
6907 |
|
@param |
6908 |
|
@param |
6909 |
|
@return |
6910 |
|
|
|
|
| 53.8% |
Uncovered Elements: 30 (65) |
Complexity: 14 |
Complexity Density: 0.3 |
|
6911 |
7 |
private String rewriteJmolSession(StructureViewerModel svattrib,... |
6912 |
|
jarInputStreamProvider jprovider) |
6913 |
|
{ |
6914 |
7 |
String state = svattrib.getStateData(); |
6915 |
7 |
if (state == null || state.isEmpty()) |
6916 |
|
{ |
6917 |
2 |
String jarEntryName = getViewerJarEntryName(svattrib.getViewId()); |
6918 |
2 |
state = readJarEntry(jprovider, jarEntryName); |
6919 |
|
} |
6920 |
|
|
6921 |
|
|
6922 |
|
|
6923 |
7 |
StringBuilder rewritten = new StringBuilder(state.length()); |
6924 |
7 |
int cp = 0, ncp, ecp; |
6925 |
7 |
Map<File, StructureData> oldFiles = svattrib.getFileData(); |
6926 |
? |
while ((ncp = state.indexOf("load ", cp)) > -1) |
6927 |
|
{ |
6928 |
7 |
do |
6929 |
|
{ |
6930 |
|
|
6931 |
7 |
rewritten.append(state.substring(cp, |
6932 |
|
ncp = (state.indexOf("\"", ncp + 1) + 1))); |
6933 |
7 |
String oldfilenam = state.substring(ncp, |
6934 |
|
ecp = state.indexOf("\"", ncp)); |
6935 |
|
|
6936 |
|
|
6937 |
|
|
6938 |
7 |
StructureData filedat = oldFiles.get(new File(oldfilenam)); |
6939 |
7 |
if (filedat == null) |
6940 |
|
{ |
6941 |
0 |
String reformatedOldFilename = oldfilenam.replaceAll("/", "\\\\"); |
6942 |
0 |
filedat = oldFiles.get(new File(reformatedOldFilename)); |
6943 |
|
} |
6944 |
7 |
rewritten.append(Platform.escapeBackslashes(filedat.getFilePath())); |
6945 |
7 |
rewritten.append("\""); |
6946 |
7 |
cp = ecp + 1; |
6947 |
|
|
6948 |
? |
} while ((ncp = state.indexOf("/*file*/", cp)) > -1); |
6949 |
|
} |
6950 |
7 |
if (cp > 0) |
6951 |
|
{ |
6952 |
|
|
6953 |
7 |
rewritten.append(state.substring(cp)); |
6954 |
|
} |
6955 |
|
else |
6956 |
|
{ |
6957 |
0 |
System.err.print("Ignoring incomplete Jmol state for PDB ids: "); |
6958 |
0 |
rewritten = new StringBuilder(state); |
6959 |
0 |
rewritten.append("; load append "); |
6960 |
0 |
for (File id : oldFiles.keySet()) |
6961 |
|
{ |
6962 |
|
|
6963 |
0 |
StructureData filedat = oldFiles.get(id); |
6964 |
0 |
rewritten.append(" \"").append(filedat.getFilePath()).append("\""); |
6965 |
|
} |
6966 |
0 |
rewritten.append(";"); |
6967 |
|
} |
6968 |
|
|
6969 |
7 |
if (rewritten.length() == 0) |
6970 |
|
{ |
6971 |
0 |
return null; |
6972 |
|
} |
6973 |
7 |
final String history = "history = "; |
6974 |
7 |
int historyIndex = rewritten.indexOf(history); |
6975 |
7 |
if (historyIndex > -1) |
6976 |
|
{ |
6977 |
|
|
6978 |
|
|
6979 |
|
|
6980 |
0 |
historyIndex += history.length(); |
6981 |
0 |
String val = rewritten.substring(historyIndex, historyIndex + 5); |
6982 |
0 |
if (val.startsWith("true")) |
6983 |
|
{ |
6984 |
0 |
rewritten.replace(historyIndex, historyIndex + 4, "1"); |
6985 |
|
} |
6986 |
0 |
else if (val.startsWith("false")) |
6987 |
|
{ |
6988 |
0 |
rewritten.replace(historyIndex, historyIndex + 5, "0"); |
6989 |
|
} |
6990 |
|
} |
6991 |
|
|
6992 |
7 |
try |
6993 |
|
{ |
6994 |
7 |
File tmp = File.createTempFile("viewerSession", ".tmp"); |
6995 |
7 |
try (OutputStream os = new FileOutputStream(tmp)) |
6996 |
|
{ |
6997 |
7 |
InputStream is = new ByteArrayInputStream( |
6998 |
|
rewritten.toString().getBytes()); |
6999 |
7 |
copyAll(is, os); |
7000 |
7 |
return tmp.getAbsolutePath(); |
7001 |
|
} |
7002 |
|
} catch (IOException e) |
7003 |
|
{ |
7004 |
0 |
Console.error("Error restoring Jmol session: " + e.toString()); |
7005 |
|
} |
7006 |
0 |
return null; |
7007 |
|
} |
7008 |
|
|
7009 |
|
|
7010 |
|
|
7011 |
|
|
7012 |
|
@param |
7013 |
|
@param |
7014 |
|
@return |
7015 |
|
|
|
|
| 84.2% |
Uncovered Elements: 6 (38) |
Complexity: 8 |
Complexity Density: 0.33 |
|
7016 |
5 |
public static Colour marshalColour(String featureType,... |
7017 |
|
FeatureColourI fcol) |
7018 |
|
{ |
7019 |
5 |
Colour col = new Colour(); |
7020 |
5 |
if (fcol.isSimpleColour()) |
7021 |
|
{ |
7022 |
1 |
col.setRGB(Format.getHexString(fcol.getColour())); |
7023 |
|
} |
7024 |
|
else |
7025 |
|
{ |
7026 |
4 |
col.setRGB(Format.getHexString(fcol.getMaxColour())); |
7027 |
4 |
col.setMin(fcol.getMin()); |
7028 |
4 |
col.setMax(fcol.getMax()); |
7029 |
4 |
col.setMinRGB(jalview.util.Format.getHexString(fcol.getMinColour())); |
7030 |
4 |
col.setAutoScale(fcol.isAutoScaled()); |
7031 |
4 |
col.setThreshold(fcol.getThreshold()); |
7032 |
4 |
col.setColourByLabel(fcol.isColourByLabel()); |
7033 |
4 |
col.setThreshType(fcol.isAboveThreshold() ? ThresholdType.ABOVE |
7034 |
3 |
: (fcol.isBelowThreshold() ? ThresholdType.BELOW |
7035 |
|
: ThresholdType.NONE)); |
7036 |
4 |
if (fcol.isColourByAttribute()) |
7037 |
|
{ |
7038 |
2 |
final String[] attName = fcol.getAttributeName(); |
7039 |
2 |
col.getAttributeName().add(attName[0]); |
7040 |
2 |
if (attName.length > 1) |
7041 |
|
{ |
7042 |
1 |
col.getAttributeName().add(attName[1]); |
7043 |
|
} |
7044 |
|
} |
7045 |
4 |
Color noColour = fcol.getNoColour(); |
7046 |
4 |
if (noColour == null) |
7047 |
|
{ |
7048 |
4 |
col.setNoValueColour(NoValueColour.NONE); |
7049 |
|
} |
7050 |
0 |
else if (noColour == fcol.getMaxColour()) |
7051 |
|
{ |
7052 |
0 |
col.setNoValueColour(NoValueColour.MAX); |
7053 |
|
} |
7054 |
|
else |
7055 |
|
{ |
7056 |
0 |
col.setNoValueColour(NoValueColour.MIN); |
7057 |
|
} |
7058 |
|
} |
7059 |
5 |
col.setName(featureType); |
7060 |
5 |
return col; |
7061 |
|
} |
7062 |
|
|
7063 |
|
|
7064 |
|
|
7065 |
|
|
7066 |
|
@param |
7067 |
|
|
7068 |
|
@param |
7069 |
|
|
7070 |
|
@param |
7071 |
|
|
7072 |
|
|
|
|
| 97.1% |
Uncovered Elements: 1 (35) |
Complexity: 6 |
Complexity Density: 0.24 |
|
7073 |
14 |
public static jalview.xml.binding.jalview.FeatureMatcherSet marshalFilter(... |
7074 |
|
FeatureMatcherI firstMatcher, Iterator<FeatureMatcherI> filters, |
7075 |
|
boolean and) |
7076 |
|
{ |
7077 |
14 |
jalview.xml.binding.jalview.FeatureMatcherSet result = new jalview.xml.binding.jalview.FeatureMatcherSet(); |
7078 |
|
|
7079 |
14 |
if (filters.hasNext()) |
7080 |
|
{ |
7081 |
|
|
7082 |
|
|
7083 |
|
|
7084 |
4 |
CompoundMatcher compound = new CompoundMatcher(); |
7085 |
4 |
compound.setAnd(and); |
7086 |
4 |
jalview.xml.binding.jalview.FeatureMatcherSet matcher1 = marshalFilter( |
7087 |
|
firstMatcher, Collections.emptyIterator(), and); |
7088 |
|
|
7089 |
4 |
compound.getMatcherSet().add(matcher1); |
7090 |
4 |
FeatureMatcherI nextMatcher = filters.next(); |
7091 |
4 |
jalview.xml.binding.jalview.FeatureMatcherSet matcher2 = marshalFilter( |
7092 |
|
nextMatcher, filters, and); |
7093 |
|
|
7094 |
4 |
compound.getMatcherSet().add(matcher2); |
7095 |
4 |
result.setCompoundMatcher(compound); |
7096 |
|
} |
7097 |
|
else |
7098 |
|
{ |
7099 |
|
|
7100 |
|
|
7101 |
|
|
7102 |
|
|
7103 |
10 |
jalview.xml.binding.jalview.FeatureMatcher matcherModel = new jalview.xml.binding.jalview.FeatureMatcher(); |
7104 |
10 |
matcherModel.setCondition( |
7105 |
|
firstMatcher.getMatcher().getCondition().getStableName()); |
7106 |
10 |
matcherModel.setValue(firstMatcher.getMatcher().getPattern()); |
7107 |
10 |
if (firstMatcher.isByAttribute()) |
7108 |
|
{ |
7109 |
4 |
matcherModel.setBy(FilterBy.BY_ATTRIBUTE); |
7110 |
|
|
7111 |
4 |
String[] attName = firstMatcher.getAttribute(); |
7112 |
4 |
matcherModel.getAttributeName().add(attName[0]); |
7113 |
4 |
if (attName.length > 1) |
7114 |
|
{ |
7115 |
2 |
matcherModel.getAttributeName().add(attName[1]); |
7116 |
|
} |
7117 |
|
} |
7118 |
6 |
else if (firstMatcher.isByLabel()) |
7119 |
|
{ |
7120 |
2 |
matcherModel.setBy(FilterBy.BY_LABEL); |
7121 |
|
} |
7122 |
4 |
else if (firstMatcher.isByScore()) |
7123 |
|
{ |
7124 |
4 |
matcherModel.setBy(FilterBy.BY_SCORE); |
7125 |
|
} |
7126 |
10 |
result.setMatchCondition(matcherModel); |
7127 |
|
} |
7128 |
|
|
7129 |
14 |
return result; |
7130 |
|
} |
7131 |
|
|
7132 |
|
|
7133 |
|
|
7134 |
|
|
7135 |
|
@param |
7136 |
|
@param |
7137 |
|
@return |
7138 |
|
|
|
|
| 80% |
Uncovered Elements: 1 (5) |
Complexity: 2 |
Complexity Density: 0.4 |
|
7139 |
6 |
public static FeatureMatcherSetI parseFilter(String featureType,... |
7140 |
|
jalview.xml.binding.jalview.FeatureMatcherSet matcherSetModel) |
7141 |
|
{ |
7142 |
6 |
FeatureMatcherSetI result = new FeatureMatcherSet(); |
7143 |
6 |
try |
7144 |
|
{ |
7145 |
6 |
parseFilterConditions(result, matcherSetModel, true); |
7146 |
|
} catch (IllegalStateException e) |
7147 |
|
{ |
7148 |
|
|
7149 |
0 |
jalview.bin.Console.errPrintln( |
7150 |
|
String.format("Error reading filter conditions for '%s': %s", |
7151 |
|
featureType, e.getMessage())); |
7152 |
|
|
7153 |
|
} |
7154 |
|
|
7155 |
6 |
return result; |
7156 |
|
} |
7157 |
|
|
7158 |
|
|
7159 |
|
|
7160 |
|
|
7161 |
|
|
7162 |
|
@param |
7163 |
|
@param |
7164 |
|
@param |
7165 |
|
|
7166 |
|
@throws |
7167 |
|
|
7168 |
|
|
|
|
| 91.4% |
Uncovered Elements: 3 (35) |
Complexity: 7 |
Complexity Density: 0.3 |
|
7169 |
14 |
protected static void parseFilterConditions(FeatureMatcherSetI matcherSet,... |
7170 |
|
jalview.xml.binding.jalview.FeatureMatcherSet matcherSetModel, |
7171 |
|
boolean and) |
7172 |
|
{ |
7173 |
14 |
jalview.xml.binding.jalview.FeatureMatcher mc = matcherSetModel |
7174 |
|
.getMatchCondition(); |
7175 |
14 |
if (mc != null) |
7176 |
|
{ |
7177 |
|
|
7178 |
|
|
7179 |
|
|
7180 |
10 |
FilterBy filterBy = mc.getBy(); |
7181 |
10 |
Condition cond = Condition.fromString(mc.getCondition()); |
7182 |
10 |
String pattern = mc.getValue(); |
7183 |
10 |
FeatureMatcherI matchCondition = null; |
7184 |
10 |
if (filterBy == FilterBy.BY_LABEL) |
7185 |
|
{ |
7186 |
2 |
matchCondition = FeatureMatcher.byLabel(cond, pattern); |
7187 |
|
} |
7188 |
8 |
else if (filterBy == FilterBy.BY_SCORE) |
7189 |
|
{ |
7190 |
4 |
matchCondition = FeatureMatcher.byScore(cond, pattern); |
7191 |
|
|
7192 |
|
} |
7193 |
4 |
else if (filterBy == FilterBy.BY_ATTRIBUTE) |
7194 |
|
{ |
7195 |
4 |
final List<String> attributeName = mc.getAttributeName(); |
7196 |
4 |
String[] attNames = attributeName |
7197 |
|
.toArray(new String[attributeName.size()]); |
7198 |
4 |
matchCondition = FeatureMatcher.byAttribute(cond, pattern, |
7199 |
|
attNames); |
7200 |
|
} |
7201 |
|
|
7202 |
|
|
7203 |
|
|
7204 |
|
|
7205 |
|
|
7206 |
10 |
if (and) |
7207 |
|
{ |
7208 |
6 |
matcherSet.and(matchCondition); |
7209 |
|
} |
7210 |
|
else |
7211 |
|
{ |
7212 |
4 |
matcherSet.or(matchCondition); |
7213 |
|
} |
7214 |
|
} |
7215 |
|
else |
7216 |
|
{ |
7217 |
|
|
7218 |
|
|
7219 |
|
|
7220 |
4 |
List<jalview.xml.binding.jalview.FeatureMatcherSet> matchers = matcherSetModel |
7221 |
|
.getCompoundMatcher().getMatcherSet(); |
7222 |
4 |
boolean anded = matcherSetModel.getCompoundMatcher().isAnd(); |
7223 |
4 |
if (matchers.size() == 2) |
7224 |
|
{ |
7225 |
4 |
parseFilterConditions(matcherSet, matchers.get(0), anded); |
7226 |
4 |
parseFilterConditions(matcherSet, matchers.get(1), anded); |
7227 |
|
} |
7228 |
|
else |
7229 |
|
{ |
7230 |
0 |
jalview.bin.Console |
7231 |
|
.errPrintln("Malformed compound filter condition"); |
7232 |
|
} |
7233 |
|
} |
7234 |
|
} |
7235 |
|
|
7236 |
|
|
7237 |
|
|
7238 |
|
|
7239 |
|
@param |
7240 |
|
@return |
7241 |
|
|
|
|
| 84.3% |
Uncovered Elements: 8 (51) |
Complexity: 12 |
Complexity Density: 0.36 |
|
7242 |
5 |
public static FeatureColourI parseColour(Colour colourModel)... |
7243 |
|
{ |
7244 |
5 |
FeatureColourI colour = null; |
7245 |
|
|
7246 |
5 |
if (colourModel.getMax() != null) |
7247 |
|
{ |
7248 |
4 |
Color mincol = null; |
7249 |
4 |
Color maxcol = null; |
7250 |
4 |
Color noValueColour = null; |
7251 |
|
|
7252 |
4 |
try |
7253 |
|
{ |
7254 |
4 |
mincol = new Color(Integer.parseInt(colourModel.getMinRGB(), 16)); |
7255 |
4 |
maxcol = new Color(Integer.parseInt(colourModel.getRGB(), 16)); |
7256 |
|
} catch (Exception e) |
7257 |
|
{ |
7258 |
0 |
Console.warn("Couldn't parse out graduated feature color.", e); |
7259 |
|
} |
7260 |
|
|
7261 |
4 |
NoValueColour noCol = colourModel.getNoValueColour(); |
7262 |
4 |
if (noCol == NoValueColour.MIN) |
7263 |
|
{ |
7264 |
0 |
noValueColour = mincol; |
7265 |
|
} |
7266 |
4 |
else if (noCol == NoValueColour.MAX) |
7267 |
|
{ |
7268 |
0 |
noValueColour = maxcol; |
7269 |
|
} |
7270 |
|
|
7271 |
4 |
colour = new FeatureColour(maxcol, mincol, maxcol, noValueColour, |
7272 |
|
safeFloat(colourModel.getMin()), |
7273 |
|
safeFloat(colourModel.getMax())); |
7274 |
4 |
final List<String> attributeName = colourModel.getAttributeName(); |
7275 |
4 |
String[] attributes = attributeName |
7276 |
|
.toArray(new String[attributeName.size()]); |
7277 |
4 |
if (attributes != null && attributes.length > 0) |
7278 |
|
{ |
7279 |
2 |
colour.setAttributeName(attributes); |
7280 |
|
} |
7281 |
4 |
if (colourModel.isAutoScale() != null) |
7282 |
|
{ |
7283 |
4 |
colour.setAutoScaled(colourModel.isAutoScale().booleanValue()); |
7284 |
|
} |
7285 |
4 |
if (colourModel.isColourByLabel() != null) |
7286 |
|
{ |
7287 |
4 |
colour.setColourByLabel( |
7288 |
|
colourModel.isColourByLabel().booleanValue()); |
7289 |
|
} |
7290 |
4 |
if (colourModel.getThreshold() != null) |
7291 |
|
{ |
7292 |
4 |
colour.setThreshold(colourModel.getThreshold().floatValue()); |
7293 |
|
} |
7294 |
4 |
ThresholdType ttyp = colourModel.getThreshType(); |
7295 |
4 |
if (ttyp == ThresholdType.ABOVE) |
7296 |
|
{ |
7297 |
1 |
colour.setAboveThreshold(true); |
7298 |
|
} |
7299 |
3 |
else if (ttyp == ThresholdType.BELOW) |
7300 |
|
{ |
7301 |
1 |
colour.setBelowThreshold(true); |
7302 |
|
} |
7303 |
|
} |
7304 |
|
else |
7305 |
|
{ |
7306 |
1 |
Color color = new Color(Integer.parseInt(colourModel.getRGB(), 16)); |
7307 |
1 |
colour = new FeatureColour(color); |
7308 |
|
} |
7309 |
|
|
7310 |
5 |
return colour; |
7311 |
|
} |
7312 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
7313 |
21 |
public static void setStateSavedUpToDate(boolean s)... |
7314 |
|
{ |
7315 |
21 |
Console.debug("Setting overall stateSavedUpToDate to " + s); |
7316 |
21 |
stateSavedUpToDate = s; |
7317 |
|
} |
7318 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
7319 |
6 |
public static boolean stateSavedUpToDate()... |
7320 |
|
{ |
7321 |
6 |
Console.debug("Returning overall stateSavedUpToDate value: " |
7322 |
|
+ stateSavedUpToDate); |
7323 |
6 |
return stateSavedUpToDate; |
7324 |
|
} |
7325 |
|
|
|
|
| 85% |
Uncovered Elements: 3 (20) |
Complexity: 6 |
Complexity Density: 0.6 |
|
7326 |
6 |
public static boolean allSavedUpToDate()... |
7327 |
|
{ |
7328 |
6 |
if (stateSavedUpToDate()) |
7329 |
2 |
return true; |
7330 |
|
|
7331 |
4 |
AlignFrame[] frames = Desktop.getDesktopAlignFrames(); |
7332 |
4 |
if (frames != null) |
7333 |
|
{ |
7334 |
7 |
for (int i = 0; i < frames.length; i++) |
7335 |
|
{ |
7336 |
4 |
if (frames[i] == null) |
7337 |
0 |
continue; |
7338 |
4 |
if (!frames[i].getViewport().savedUpToDate()) |
7339 |
1 |
return false; |
7340 |
|
} |
7341 |
|
} |
7342 |
3 |
return true; |
7343 |
|
} |
7344 |
|
|
7345 |
|
|
7346 |
|
private static int debugDelaySave = 20; |
7347 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
7348 |
12 |
public static void setDebugDelaySave(int n)... |
7349 |
|
{ |
7350 |
12 |
debugDelaySave = n; |
7351 |
|
} |
7352 |
|
} |