1 Clazz.declarePackage ("jalview.analysis");
\r
2 Clazz.load (null, "jalview.analysis.AlignmentSorter", ["jalview.datamodel.SequenceI", "jalview.util.Comparison", "$.MessageManager", "$.QuickSort", "java.lang.Error", "$.Float", "$.StringBuffer", "java.util.ArrayList"], function () {
\r
3 c$ = Clazz.declareType (jalview.analysis, "AlignmentSorter");
\r
4 c$.sortByPID = Clazz.defineMethod (c$, "sortByPID",
\r
5 function (align, s, tosort) {
\r
6 jalview.analysis.AlignmentSorter.sortByPID (align, s, tosort, 0, -1);
\r
7 }, "jalview.datamodel.AlignmentI,jalview.datamodel.SequenceI,~A");
\r
8 c$.sortByPID = Clazz.defineMethod (c$, "sortByPID",
\r
9 function (align, s, tosort, start, end) {
\r
10 var nSeq = align.getHeight ();
\r
11 var scores = Clazz.newFloatArray (nSeq, 0);
\r
12 var seqs = new Array (nSeq);
\r
13 for (var i = 0; i < nSeq; i++) {
\r
14 scores[i] = jalview.util.Comparison.PID (align.getSequenceAt (i).getSequenceAsString (), s.getSequenceAsString ());
\r
15 seqs[i] = align.getSequenceAt (i);
\r
17 jalview.util.QuickSort.sortFloatObject (scores, seqs);
\r
18 jalview.analysis.AlignmentSorter.setReverseOrder (align, seqs);
\r
19 }, "jalview.datamodel.AlignmentI,jalview.datamodel.SequenceI,~A,~N,~N");
\r
20 c$.setReverseOrder = Clazz.defineMethod (c$, "setReverseOrder",
\r
21 ($fz = function (align, seqs) {
\r
22 var nSeq = seqs.length;
\r
24 if ((nSeq % 2) == 0) {
\r
25 len = Clazz.doubleToInt (nSeq / 2);
\r
27 len = Clazz.doubleToInt ((nSeq + 1) / 2);
\r
30 for (var i = 0; i < len; i++) {
\r
31 asq.set (i, seqs[nSeq - i - 1]);
\r
32 asq.set (nSeq - i - 1, seqs[i]);
\r
34 }}, $fz.isPrivate = true, $fz), "jalview.datamodel.AlignmentI,~A");
\r
35 c$.setOrder = Clazz.defineMethod (c$, "setOrder",
\r
36 ($fz = function (align, tmp) {
\r
37 jalview.analysis.AlignmentSorter.setOrder (align, jalview.analysis.AlignmentSorter.vectorSubsetToArray (tmp, align.getSequences ()));
\r
38 }, $fz.isPrivate = true, $fz), "jalview.datamodel.AlignmentI,java.util.List");
\r
39 c$.setOrder = Clazz.defineMethod (c$, "setOrder",
\r
40 function (align, seqs) {
\r
43 var tmp = new java.util.ArrayList ();
\r
44 for (var i = 0; i < seqs.length; i++) {
\r
45 if (algn.contains (seqs[i])) {
\r
49 for (var i = 0; i < tmp.size (); i++) {
\r
50 algn.add (tmp.get (i));
\r
52 }}, "jalview.datamodel.AlignmentI,~A");
\r
53 c$.sortByID = Clazz.defineMethod (c$, "sortByID",
\r
55 var nSeq = align.getHeight ();
\r
56 var ids = new Array (nSeq);
\r
57 var seqs = new Array (nSeq);
\r
58 for (var i = 0; i < nSeq; i++) {
\r
59 ids[i] = align.getSequenceAt (i).getName ();
\r
60 seqs[i] = align.getSequenceAt (i);
\r
62 jalview.util.QuickSort.sort (ids, seqs);
\r
63 if (jalview.analysis.AlignmentSorter.sortIdAscending) {
\r
64 jalview.analysis.AlignmentSorter.setReverseOrder (align, seqs);
\r
66 jalview.analysis.AlignmentSorter.setOrder (align, seqs);
\r
67 }jalview.analysis.AlignmentSorter.sortIdAscending = !jalview.analysis.AlignmentSorter.sortIdAscending;
\r
68 }, "jalview.datamodel.AlignmentI");
\r
69 c$.sortByLength = Clazz.defineMethod (c$, "sortByLength",
\r
71 var nSeq = align.getHeight ();
\r
72 var length = Clazz.newFloatArray (nSeq, 0);
\r
73 var seqs = new Array (nSeq);
\r
74 for (var i = 0; i < nSeq; i++) {
\r
75 seqs[i] = align.getSequenceAt (i);
\r
76 length[i] = (seqs[i].getEnd () - seqs[i].getStart ());
\r
78 jalview.util.QuickSort.sortFloatObject (length, seqs);
\r
79 if (jalview.analysis.AlignmentSorter.sortLengthAscending) {
\r
80 jalview.analysis.AlignmentSorter.setReverseOrder (align, seqs);
\r
82 jalview.analysis.AlignmentSorter.setOrder (align, seqs);
\r
83 }jalview.analysis.AlignmentSorter.sortLengthAscending = !jalview.analysis.AlignmentSorter.sortLengthAscending;
\r
84 }, "jalview.datamodel.AlignmentI");
\r
85 c$.sortByGroup = Clazz.defineMethod (c$, "sortByGroup",
\r
87 var groups = new java.util.ArrayList ();
\r
88 if (groups.hashCode () != jalview.analysis.AlignmentSorter.lastGroupHash) {
\r
89 jalview.analysis.AlignmentSorter.sortGroupAscending = true;
\r
90 jalview.analysis.AlignmentSorter.lastGroupHash = groups.hashCode ();
\r
92 jalview.analysis.AlignmentSorter.sortGroupAscending = !jalview.analysis.AlignmentSorter.sortGroupAscending;
\r
93 }for (var sg, $sg = align.getGroups ().iterator (); $sg.hasNext () && ((sg = $sg.next ()) || true);) {
\r
94 for (var j = 0; j < groups.size (); j++) {
\r
95 var sg2 = groups.get (j);
\r
96 if (sg.getSize () > sg2.getSize ()) {
\r
100 if (!groups.contains (sg)) {
\r
103 var seqs = new java.util.ArrayList ();
\r
104 for (var i = 0; i < groups.size (); i++) {
\r
105 var sg = groups.get (i);
\r
106 var orderedseqs = sg.getSequencesInOrder (align);
\r
107 for (var j = 0; j < orderedseqs.length; j++) {
\r
108 seqs.add (orderedseqs[j]);
\r
111 if (jalview.analysis.AlignmentSorter.sortGroupAscending) {
\r
112 jalview.analysis.AlignmentSorter.setOrder (align, seqs);
\r
114 jalview.analysis.AlignmentSorter.setReverseOrder (align, jalview.analysis.AlignmentSorter.vectorSubsetToArray (seqs, align.getSequences ()));
\r
115 }}, "jalview.datamodel.AlignmentI");
\r
116 c$.vectorSubsetToArray = Clazz.defineMethod (c$, "vectorSubsetToArray",
\r
117 ($fz = function (tmp, mask) {
\r
118 var seqs = new java.util.ArrayList ();
\r
121 var tmask = Clazz.newBooleanArray (mask.size (), false);
\r
122 for (i = 0; i < mask.size (); i++) {
\r
125 for (i = 0; i < tmp.size (); i++) {
\r
126 var sq = tmp.get (i);
\r
127 idx = mask.indexOf (sq);
\r
128 if (idx > -1 && tmask[idx]) {
\r
129 tmask[idx] = false;
\r
132 for (i = 0; i < tmask.length; i++) {
\r
134 seqs.add (mask.get (i));
\r
136 return seqs.toArray ( new Array (seqs.size ()));
\r
137 }, $fz.isPrivate = true, $fz), "java.util.List,java.util.List");
\r
138 c$.sortBy = Clazz.defineMethod (c$, "sortBy",
\r
139 function (align, order) {
\r
140 var tmp = order.getOrder ();
\r
141 if (jalview.analysis.AlignmentSorter.lastOrder === order) {
\r
142 jalview.analysis.AlignmentSorter.sortOrderAscending = !jalview.analysis.AlignmentSorter.sortOrderAscending;
\r
144 jalview.analysis.AlignmentSorter.sortOrderAscending = true;
\r
145 }if (jalview.analysis.AlignmentSorter.sortOrderAscending) {
\r
146 jalview.analysis.AlignmentSorter.setOrder (align, tmp);
\r
148 jalview.analysis.AlignmentSorter.setReverseOrder (align, jalview.analysis.AlignmentSorter.vectorSubsetToArray (tmp, align.getSequences ()));
\r
149 }}, "jalview.datamodel.AlignmentI,jalview.datamodel.AlignmentOrder");
\r
150 c$.getOrderByTree = Clazz.defineMethod (c$, "getOrderByTree",
\r
151 ($fz = function (align, tree) {
\r
152 var nSeq = align.getHeight ();
\r
153 var tmp = new java.util.ArrayList ();
\r
154 tmp = jalview.analysis.AlignmentSorter._sortByTree (tree.getTopNode (), tmp, align.getSequences ());
\r
155 if (tmp.size () != nSeq) {
\r
156 if (tmp.size () != nSeq) {
\r
157 jalview.analysis.AlignmentSorter.addStrays (align, tmp);
\r
158 }if (tmp.size () != nSeq) {
\r
159 System.err.println ("WARNING: tmp.size()=" + tmp.size () + " != nseq=" + nSeq + " in getOrderByTree - tree contains sequences not in alignment");
\r
161 }, $fz.isPrivate = true, $fz), "jalview.datamodel.AlignmentI,jalview.analysis.NJTree");
\r
162 c$.sortByTree = Clazz.defineMethod (c$, "sortByTree",
\r
163 function (align, tree) {
\r
164 var tmp = jalview.analysis.AlignmentSorter.getOrderByTree (align, tree);
\r
165 if (jalview.analysis.AlignmentSorter.lastTree !== tree) {
\r
166 jalview.analysis.AlignmentSorter.sortTreeAscending = true;
\r
167 jalview.analysis.AlignmentSorter.lastTree = tree;
\r
169 jalview.analysis.AlignmentSorter.sortTreeAscending = !jalview.analysis.AlignmentSorter.sortTreeAscending;
\r
170 }if (jalview.analysis.AlignmentSorter.sortTreeAscending) {
\r
171 jalview.analysis.AlignmentSorter.setOrder (align, tmp);
\r
173 jalview.analysis.AlignmentSorter.setReverseOrder (align, jalview.analysis.AlignmentSorter.vectorSubsetToArray (tmp, align.getSequences ()));
\r
174 }}, "jalview.datamodel.AlignmentI,jalview.analysis.NJTree");
\r
175 c$.addStrays = Clazz.defineMethod (c$, "addStrays",
\r
176 ($fz = function (align, tmp) {
\r
177 var nSeq = align.getHeight ();
\r
178 for (var i = 0; i < nSeq; i++) {
\r
179 if (!tmp.contains (align.getSequenceAt (i))) {
\r
180 tmp.add (align.getSequenceAt (i));
\r
182 if (nSeq != tmp.size ()) {
\r
183 System.err.println ("ERROR: Size still not right even after addStrays");
\r
184 }}, $fz.isPrivate = true, $fz), "jalview.datamodel.AlignmentI,java.util.List");
\r
185 c$._sortByTree = Clazz.defineMethod (c$, "_sortByTree",
\r
186 ($fz = function (node, tmp, seqset) {
\r
187 if (node == null) {
\r
189 }var left = node.left ();
\r
190 var right = node.right ();
\r
191 if ((left == null) && (right == null)) {
\r
192 if (!node.isPlaceholder () && (node.element () != null)) {
\r
193 if (Clazz.instanceOf (node.element (), jalview.datamodel.SequenceI)) {
\r
194 if (!tmp.contains (node.element ())) {
\r
195 tmp.add (node.element ());
\r
198 jalview.analysis.AlignmentSorter._sortByTree (left, tmp, seqset);
\r
199 jalview.analysis.AlignmentSorter._sortByTree (right, tmp, seqset);
\r
201 }, $fz.isPrivate = true, $fz), "jalview.datamodel.SequenceNode,java.util.List,java.util.List");
\r
202 c$.recoverOrder = Clazz.defineMethod (c$, "recoverOrder",
\r
203 function (alignment) {
\r
204 var ids = Clazz.newFloatArray (alignment.length, 0);
\r
205 for (var i = 0; i < alignment.length; i++) {
\r
206 ids[i] = ( new Float (alignment[i].getName ().substring (8))).floatValue ();
\r
208 jalview.util.QuickSort.sortFloatObject (ids, alignment);
\r
210 c$.sortByAnnotationScore = Clazz.defineMethod (c$, "sortByAnnotationScore",
\r
211 function (scoreLabel, alignment) {
\r
212 var seqs = alignment.getSequencesArray ();
\r
213 var hasScore = Clazz.newBooleanArray (seqs.length, false);
\r
215 var scores = Clazz.newDoubleArray (seqs.length, 0);
\r
218 for (var i = 0; i < seqs.length; i++) {
\r
219 var scoreAnn = seqs[i].getAnnotation (scoreLabel);
\r
220 if (scoreAnn != null) {
\r
222 hasScore[i] = true;
\r
223 scores[i] = scoreAnn[0].getScore ();
\r
224 if (hasScores == 1) {
\r
225 max = min = scores[i];
\r
227 if (max < scores[i]) {
\r
229 }if (min > scores[i]) {
\r
232 hasScore[i] = false;
\r
234 if (hasScores == 0) {
\r
236 }if (hasScores < seqs.length) {
\r
237 for (var i = 0; i < seqs.length; i++) {
\r
238 if (!hasScore[i]) {
\r
239 scores[i] = (max + i + 1.0);
\r
241 }jalview.util.QuickSort.sortDouble (scores, seqs);
\r
242 if (jalview.analysis.AlignmentSorter.lastSortByScore !== scoreLabel) {
\r
243 jalview.analysis.AlignmentSorter.lastSortByScore = scoreLabel;
\r
244 jalview.analysis.AlignmentSorter.setOrder (alignment, seqs);
\r
246 jalview.analysis.AlignmentSorter.setReverseOrder (alignment, seqs);
\r
247 }}, "~S,jalview.datamodel.AlignmentI");
\r
248 c$.sortByFeature = Clazz.defineMethod (c$, "sortByFeature",
\r
249 function (featureLabel, groupLabel, start, stop, alignment, method) {
\r
250 jalview.analysis.AlignmentSorter.sortByFeature (featureLabel == null ? null : Clazz.newArray (-1, [featureLabel]), groupLabel == null ? null : Clazz.newArray (-1, [groupLabel]), start, stop, alignment, method);
\r
251 }, "~S,~S,~N,~N,jalview.datamodel.AlignmentI,~S");
\r
252 c$.containsIgnoreCase = Clazz.defineMethod (c$, "containsIgnoreCase",
\r
253 ($fz = function (lab, labs) {
\r
254 if (labs == null) {
\r
256 }if (lab == null) {
\r
258 }for (var q = 0; q < labs.length; q++) {
\r
259 if (labs[q] != null && lab.equalsIgnoreCase (labs[q])) {
\r
263 }, $fz.isPrivate = true, $fz), "~S,~A");
\r
264 c$.sortByFeature = Clazz.defineMethod (c$, "sortByFeature",
\r
265 function (featureLabels, groupLabels, start, stop, alignment, method) {
\r
266 if (method !== jalview.analysis.AlignmentSorter.FEATURE_SCORE && method !== jalview.analysis.AlignmentSorter.FEATURE_LABEL && method !== jalview.analysis.AlignmentSorter.FEATURE_DENSITY) {
\r
267 throw new Error (jalview.util.MessageManager.getString ("error.implementation_error_sortbyfeature"));
\r
268 }var ignoreScore = method !== jalview.analysis.AlignmentSorter.FEATURE_SCORE;
\r
269 var scoreLabel = new StringBuffer ();
\r
270 scoreLabel.append (start + stop + method);
\r
271 for (var i = 0; featureLabels != null && i < featureLabels.length; i++) {
\r
272 scoreLabel.append (featureLabels[i] == null ? "null" : featureLabels[i]);
\r
274 for (var i = 0; groupLabels != null && i < groupLabels.length; i++) {
\r
275 scoreLabel.append (groupLabels[i] == null ? "null" : groupLabels[i]);
\r
277 var seqs = alignment.getSequencesArray ();
\r
278 var hasScore = Clazz.newBooleanArray (seqs.length, false);
\r
280 var scores = Clazz.newDoubleArray (seqs.length, 0);
\r
281 var seqScores = Clazz.newIntArray (seqs.length, 0);
\r
282 var feats = new Array (seqs.length);
\r
285 for (var i = 0; i < seqs.length; i++) {
\r
286 var sf = seqs[i].getSequenceFeatures ();
\r
288 sf = new Array (0);
\r
290 var tmp = new Array (sf.length);
\r
291 for (var s = 0; s < tmp.length; s++) {
\r
295 }var sstart = (start == -1) ? start : seqs[i].findPosition (start);
\r
296 var sstop = (stop == -1) ? stop : seqs[i].findPosition (stop);
\r
300 for (var f = 0; f < sf.length; f++) {
\r
301 if ((sf[f].end < sstart || sf[f].begin > sstop) || (featureLabels != null && !jalview.analysis.AlignmentSorter.containsIgnoreCase (sf[f].type, featureLabels)) || (groupLabels != null && (sf[f].getFeatureGroup () != null && !jalview.analysis.AlignmentSorter.containsIgnoreCase (sf[f].getFeatureGroup (), groupLabels)))) {
\r
305 if (!ignoreScore && !Float.isNaN (sf[f].getScore ())) {
\r
306 if (seqScores[i] == 0) {
\r
309 hasScore[i] = true;
\r
310 scores[i] += sf[f].getScore ();
\r
313 feats[i] = fs = new Array (n);
\r
316 for (var f = 0; f < sf.length; f++) {
\r
317 if (sf[f] != null) {
\r
318 (feats[i])[n++] = sf[f];
\r
320 if (method === jalview.analysis.AlignmentSorter.FEATURE_LABEL) {
\r
321 var labs = new Array (fs.length);
\r
322 for (var l = 0; l < labs.length; l++) {
\r
323 labs[l] = (fs[l].getDescription () != null ? fs[l].getDescription () : fs[l].getType ());
\r
325 jalview.util.QuickSort.sort (labs, (feats[i]));
\r
326 }}if (hasScore[i]) {
\r
327 scores[i] /= seqScores[i];
\r
328 if (hasScores == 1) {
\r
329 max = min = scores[i];
\r
331 if (max < scores[i]) {
\r
333 }if (min > scores[i]) {
\r
336 if (method === jalview.analysis.AlignmentSorter.FEATURE_SCORE) {
\r
337 if (hasScores == 0) {
\r
339 }if (hasScores < seqs.length) {
\r
340 for (var i = 0; i < seqs.length; i++) {
\r
341 if (!hasScore[i]) {
\r
342 scores[i] = (max + 1 + i);
\r
344 var nf = (feats[i] == null) ? 0 : (feats[i]).length;
\r
346 }jalview.util.QuickSort.sortDouble (scores, seqs);
\r
347 } else if (method === jalview.analysis.AlignmentSorter.FEATURE_DENSITY) {
\r
348 var fr = 0.9 / (1.0 * seqs.length);
\r
349 for (var i = 0; i < seqs.length; i++) {
\r
351 scores[i] = (0.05 + fr * i) + (nf = ((feats[i] == null) ? 0.0 : 1.0 * (feats[i]).length));
\r
353 jalview.util.QuickSort.sortDouble (scores, seqs);
\r
355 if (method === jalview.analysis.AlignmentSorter.FEATURE_LABEL) {
\r
356 throw new Error (jalview.util.MessageManager.getString ("error.not_yet_implemented"));
\r
357 }}if (jalview.analysis.AlignmentSorter.lastSortByFeatureScore == null || !scoreLabel.toString ().equals (jalview.analysis.AlignmentSorter.lastSortByFeatureScore)) {
\r
358 jalview.analysis.AlignmentSorter.sortByFeatureScoreAscending = true;
\r
360 jalview.analysis.AlignmentSorter.sortByFeatureScoreAscending = !jalview.analysis.AlignmentSorter.sortByFeatureScoreAscending;
\r
361 }if (jalview.analysis.AlignmentSorter.sortByFeatureScoreAscending) {
\r
362 jalview.analysis.AlignmentSorter.setOrder (alignment, seqs);
\r
364 jalview.analysis.AlignmentSorter.setReverseOrder (alignment, seqs);
\r
365 }jalview.analysis.AlignmentSorter.lastSortByFeatureScore = scoreLabel.toString ();
\r
366 }, "~A,~A,~N,~N,jalview.datamodel.AlignmentI,~S");
\r
367 Clazz.defineStatics (c$,
\r
368 "sortIdAscending", true,
\r
369 "lastGroupHash", 0,
\r
370 "sortGroupAscending", true,
\r
372 "sortOrderAscending", true,
\r
374 "sortTreeAscending", true,
\r
375 "lastSortByScore", null,
\r
376 "sortByScoreAscending", true,
\r
377 "lastSortByFeatureScore", null,
\r
378 "sortByFeatureScoreAscending", true,
\r
379 "sortLengthAscending", false,
\r
380 "FEATURE_SCORE", "average_score",
\r
381 "FEATURE_LABEL", "text",
\r
382 "FEATURE_DENSITY", "density");
\r