2 * Jalview - A Sequence Alignment Editor and Viewer (Version 2.6)
\r
3 * Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
\r
5 * This file is part of Jalview.
\r
7 * Jalview is free software: you can redistribute it and/or
\r
8 * modify it under the terms of the GNU General Public License
\r
9 * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
\r
11 * Jalview is distributed in the hope that it will be useful, but
\r
12 * WITHOUT ANY WARRANTY; without even the implied warranty
\r
13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
\r
14 * PURPOSE. See the GNU General Public License for more details.
\r
16 * You should have received a copy of the GNU General Public License along with Jalview. If not, see <http://www.gnu.org/licenses/>.
\r
18 package jalview.datamodel;
\r
20 import jalview.util.ShiftList;
\r
22 import java.io.PrintStream;
\r
23 import java.util.Enumeration;
\r
24 import java.util.Vector;
\r
27 * Transient object compactly representing a 'view' of an alignment - with
\r
28 * discontinuities marked. Extended in Jalview 2.7 to optionally record sequence
\r
29 * groups and specific selected regions on the alignment.
\r
31 public class AlignmentView
\r
33 private SeqCigar[] sequences = null;
\r
35 private int[] contigs = null;
\r
37 private int width = 0;
\r
39 private int firstCol = 0;
\r
42 * one or more ScGroup objects, which are referenced by each seqCigar's group
\r
45 private Vector scGroups;
\r
48 * Group defined over SeqCigars. Unlike AlignmentI associated groups, each
\r
49 * SequenceGroup hold just the essential properties for the group, but no
\r
50 * references to the sequences involved. SeqCigars hold references to the
\r
51 * seuqenceGroup entities themselves.
\r
53 private class ScGroup
\r
57 public SequenceGroup sg;
\r
61 seqs = new Vector();
\r
66 * vector of selected seqCigars. This vector is also referenced by each
\r
67 * seqCigar contained in it.
\r
69 private Vector selected;
\r
72 * Construct an alignmentView from a live jalview alignment view. Note -
\r
73 * hidden rows will be excluded from alignmentView
\r
76 * - alignment as referenced by an AlignViewport
\r
77 * @param columnSelection
\r
80 * @param hasHiddenColumns
\r
81 * - mark the hidden columns in columnSelection as hidden in the view
\r
82 * @param selectedRegionOnly
\r
83 * - when set, only include the selected region in the view,
\r
84 * otherwise just mark the selected region on the constructed view.
\r
85 * @param recordGroups
\r
86 * - when set, any groups on the given alignment will be marked on
\r
89 public AlignmentView(AlignmentI alignment,
\r
90 ColumnSelection columnSelection, SequenceGroup selection,
\r
91 boolean hasHiddenColumns, boolean selectedRegionOnly,
\r
92 boolean recordGroups)
\r
94 // refactored from AlignViewport.getAlignmentView(selectedOnly);
\r
95 this(new jalview.datamodel.CigarArray(alignment,
\r
96 (hasHiddenColumns ? columnSelection : null),
\r
97 (selectedRegionOnly ? selection : null)),
\r
98 (selectedRegionOnly && selection != null) ? selection
\r
99 .getStartRes() : 0);
\r
100 // walk down SeqCigar array and Alignment Array - optionally restricted by
\r
101 // selected region.
\r
102 // test group membership for each sequence in each group, store membership
\r
103 // and record non-empty groups in group list.
\r
104 // record / sub-select selected region on the alignment view
\r
105 SequenceI[] selseqs;
\r
106 if (selection != null)
\r
108 Vector sel = selection.getSequences(null);
\r
109 this.selected = new Vector();
\r
110 selseqs = selection.getSequencesInOrder(alignment, false);
\r
114 selseqs = alignment.getSequencesArray();
\r
117 // get the alignment's group list and make a copy
\r
118 Vector grps = new Vector();
\r
119 Vector gg = alignment.getGroups();
\r
120 Enumeration gge = gg.elements();
\r
121 while (gge.hasMoreElements())
\r
123 grps.addElement(gge.nextElement());
\r
125 ScGroup[] sgrps = null;
\r
126 boolean addedgps[] = null;
\r
130 if (selection != null && selectedRegionOnly)
\r
132 // trim annotation to the region being stored.
\r
133 // strip out any groups that do not actually intersect with the
\r
134 // visible and selected region
\r
135 int ssel = selection.getStartRes(), esel = selection.getEndRes();
\r
136 Vector isg = new Vector();
\r
137 Enumeration en = grps.elements();
\r
138 while (en.hasMoreElements())
\r
140 sg = (SequenceGroup) en.nextElement();
\r
142 if (!(sg.getStartRes() > esel || sg.getEndRes() < ssel))
\r
144 // adjust bounds of new group, if necessary.
\r
145 if (sg.getStartRes() < ssel)
\r
147 sg.setStartRes(ssel);
\r
149 if (sg.getEndRes() > esel)
\r
151 sg.setEndRes(esel);
\r
153 isg.addElement(sg);
\r
159 sgrps = new ScGroup[grps.size()];
\r
160 addedgps = new boolean[grps.size()];
\r
161 for (int g = 0; g < sgrps.length; g++)
\r
163 sg = (SequenceGroup) grps.elementAt(g);
\r
164 sgrps[g] = new ScGroup();
\r
165 sgrps[g].sg = new SequenceGroup(sg);
\r
166 addedgps[g] = false;
\r
167 grps.setElementAt(sg.getSequences(null), g);
\r
169 // grps now contains vectors (should be sets) for each group, so we can
\r
170 // track when we've done with the group
\r
173 for (int i = 0; i < selseqs.length; i++)
\r
175 if (selseqs[i] != null)
\r
177 if (selection != null && !selectedRegionOnly)
\r
179 sequences[csi].setGroupMembership(selected);
\r
180 selected.addElement(sequences[csi]);
\r
184 for (int sg = 0; sg < sgrps.length; sg++)
\r
186 if (((Vector) grps.elementAt(sg)).contains(selseqs[i]))
\r
188 sequences[csi].setGroupMembership(sgrps[sg]);
\r
189 sgrps[sg].sg.deleteSequence(selseqs[i], false);
\r
190 sgrps[sg].seqs.addElement(sequences[csi]);
\r
193 if (scGroups == null)
\r
195 scGroups = new Vector();
\r
197 addedgps[sg] = true;
\r
198 scGroups.addElement(sgrps[sg]);
\r
206 // finally, delete the remaining sequences (if any) not selected
\r
207 for (int sg = 0; sg < sgrps.length; sg++)
\r
209 SequenceI[] sqs = sgrps[sg].sg.getSequencesAsArray(null);
\r
210 for (int si = 0; si < sqs.length; si++)
\r
212 sgrps[sg].sg.deleteSequence(sqs[si], false);
\r
219 * construct an alignmentView from a SeqCigarArray. Errors are thrown if the
\r
220 * seqcigararray.isSeqCigarArray() flag is not set.
\r
222 public AlignmentView(CigarArray seqcigararray)
\r
224 if (!seqcigararray.isSeqCigarArray())
\r
227 "Implementation Error - can only make an alignment view from a CigarArray of sequences.");
\r
229 // contigs = seqcigararray.applyDeletions();
\r
230 contigs = seqcigararray.getDeletedRegions();
\r
231 sequences = seqcigararray.getSeqCigarArray();
\r
232 width = seqcigararray.getWidth(); // visible width
\r
236 * Create an alignmentView where the first column corresponds with the
\r
237 * 'firstcol' column of some reference alignment
\r
242 public AlignmentView(CigarArray sdata, int firstcol)
\r
245 firstCol = firstcol;
\r
248 public void setSequences(SeqCigar[] sequences)
\r
250 this.sequences = sequences;
\r
253 public void setContigs(int[] contigs)
\r
255 this.contigs = contigs;
\r
258 public SeqCigar[] getSequences()
\r
264 * @see CigarArray.getDeletedRegions
\r
265 * @return int[] { vis_start, sym_start, length }
\r
267 public int[] getContigs()
\r
273 * get the full alignment and a columnselection object marking the hidden
\r
276 * @param gapCharacter
\r
278 * @return Object[] { SequenceI[], ColumnSelection}
\r
280 public Object[] getAlignmentAndColumnSelection(char gapCharacter)
\r
282 ColumnSelection colsel = new ColumnSelection();
\r
284 return new Object[]
\r
286 SeqCigar.createAlignmentSequences(sequences, gapCharacter, colsel,
\r
287 contigs), colsel };
\r
291 * return the visible alignment corresponding to this view. Sequences in this
\r
292 * alignment are edited versions of the parent sequences - where hidden
\r
293 * regions have been removed. NOTE: the sequence data in this alignment is not
\r
299 public AlignmentI getVisibleAlignment(char c)
\r
301 SequenceI[] aln = getVisibleSeqs(c);
\r
303 AlignmentI vcal = new Alignment(aln);
\r
304 addPrunedGroupsInOrder(vcal, -1, -1, true);
\r
309 * add groups from view to the given alignment
\r
313 * -1 or 0 to width-1
\r
315 * -1 or gstart to width-1
\r
316 * @param viscontigs
\r
317 * - true if vcal is alignment of the visible regions of the view
\r
318 * (e.g. as returned from getVisibleAlignment)
\r
320 private void addPrunedGroupsInOrder(AlignmentI vcal, int gstart,
\r
321 int gend, boolean viscontigs)
\r
324 if (gstart > -1 && gstart <= gend)
\r
329 SequenceI[] aln = vcal.getSequencesArray();
\r
332 * prune any groups to the visible coordinates of the alignment.
\r
335 int nvg = (scGroups != null) ? scGroups.size() : 0;
\r
338 SequenceGroup[] nsg = new SequenceGroup[nvg];
\r
339 for (int g = 0; g < nvg; g++)
\r
341 SequenceGroup sg = ((ScGroup) scGroups.elementAt(g)).sg;
\r
344 if (sg.getStartRes() > gend || sg.getEndRes() < gstart)
\r
351 // may need to shift/trim start and end ?
\r
352 if (r && !viscontigs)
\r
354 if (nsg[g].getStartRes() < gstart)
\r
356 nsg[g].setStartRes(0);
\r
360 nsg[g].setStartRes(nsg[g].getStartRes() - gstart);
\r
361 nsg[g].setEndRes(nsg[g].getEndRes() - gstart);
\r
363 if (nsg[g].getEndRes() > gend)
\r
365 nsg[g].setEndRes(gend);
\r
369 // clone group properties
\r
370 nsg[g] = new SequenceGroup(sg);
\r
374 // prune groups to cover just the visible positions between
\r
376 if (contigs != null)
\r
379 ShiftList prune = new ShiftList();
\r
382 // adjust for start of alignment within visible window.
\r
383 prune.addShift(gstart, -gstart); //
\r
385 for (int h = 0; h < contigs.length; h += 3)
\r
388 prune.addShift(p + contigs[h + 1], contigs[h + 2]
\r
391 p = contigs[h + 1] + contigs[h + 2];
\r
393 for (int g = 0; g < nsg.length; g++)
\r
395 if (nsg[g] != null)
\r
397 int s = nsg[g].getStartRes(), t = nsg[g].getEndRes();
\r
410 s = prune.shift(s);
\r
411 t = prune.shift(t);
\r
412 nsg[g].setStartRes(s);
\r
413 nsg[g].setEndRes(t);
\r
419 for (int nsq = 0; nsq < aln.length; nsq++)
\r
421 for (int g = 0; g < nvg; g++)
\r
424 && sequences[nsq].isMemberOf(scGroups.elementAt(g)))
\r
426 nsg[g].addSequence(aln[nsq], false);
\r
430 for (int g = 0; g < nvg; g++)
\r
432 if (nsg[g] != null && nsg[g].getSize() > 0)
\r
434 vcal.addGroup(nsg[g]);
\r
444 * generate sequence array corresponding to the visible parts of the
\r
450 private SequenceI[] getVisibleSeqs(char c)
\r
452 SequenceI[] aln = new SequenceI[sequences.length];
\r
453 for (int i = 0, j = sequences.length; i < j; i++)
\r
455 aln[i] = sequences[i].getSeq('-');
\r
457 // Remove hidden regions from sequence objects.
\r
458 String seqs[] = getSequenceStrings('-');
\r
459 for (int i = 0, j = aln.length; i < j; i++)
\r
461 aln[i].setSequence(seqs[i]);
\r
467 * creates new alignment objects for all contiguous visible segments
\r
472 * @param regionOfInterest
\r
473 * specify which sequences to include (or null to include all
\r
475 * @return AlignmentI[] - all alignments where each sequence is a subsequence
\r
476 * constructed from visible contig regions of view
\r
478 public AlignmentI[] getVisibleContigAlignments(char c)
\r
481 int[] vcontigs = getVisibleContigs();
\r
482 SequenceI[][] contigviews = getVisibleContigs(c);
\r
483 AlignmentI[] vcals = new AlignmentI[contigviews.length];
\r
484 for (nvc = 0; nvc < contigviews.length; nvc++)
\r
486 vcals[nvc] = new Alignment(contigviews[nvc]);
\r
487 if (scGroups!=null && scGroups.size()>0)
\r
489 addPrunedGroupsInOrder(vcals[nvc], vcontigs[nvc*2],vcontigs[nvc*2+1], true);
\r
497 * get an array of visible sequence strings for a view on an alignment using
\r
498 * the given gap character
\r
504 public String[] getSequenceStrings(char c)
\r
506 String[] seqs = new String[sequences.length];
\r
507 for (int n = 0; n < sequences.length; n++)
\r
509 String fullseq = sequences[n].getSequenceString(c);
\r
510 if (contigs != null)
\r
514 for (int h = 0; h < contigs.length; h += 3)
\r
516 seqs[n] += fullseq.substring(p, contigs[h + 1]);
\r
517 p = contigs[h + 1] + contigs[h + 2];
\r
519 seqs[n] += fullseq.substring(p);
\r
531 * @return visible number of columns in alignment view
\r
533 public int getWidth()
\r
538 protected void setWidth(int width)
\r
540 this.width = width;
\r
544 * get the contiguous subalignments in an alignment view.
\r
546 * @param gapCharacter
\r
548 * @return SequenceI[][]
\r
550 public SequenceI[][] getVisibleContigs(char gapCharacter)
\r
552 SequenceI[][] smsa;
\r
554 if (sequences == null || width <= 0)
\r
558 if (contigs != null && contigs.length > 0)
\r
562 int fwidth = width;
\r
563 for (int contig = 0; contig < contigs.length; contig += 3)
\r
565 if ((contigs[contig + 1] - start) > 0)
\r
569 fwidth += contigs[contig + 2]; // end up with full region width
\r
570 // (including hidden regions)
\r
571 start = contigs[contig + 1] + contigs[contig + 2];
\r
573 if (start < fwidth)
\r
577 smsa = new SequenceI[njobs][];
\r
580 for (int contig = 0; contig < contigs.length; contig += 3)
\r
582 if (contigs[contig + 1] - start > 0)
\r
584 SequenceI mseq[] = new SequenceI[sequences.length];
\r
585 for (int s = 0; s < mseq.length; s++)
\r
587 mseq[s] = sequences[s].getSeq(gapCharacter).getSubSequence(
\r
588 start, contigs[contig + 1]);
\r
593 start = contigs[contig + 1] + contigs[contig + 2];
\r
595 if (start < fwidth)
\r
597 SequenceI mseq[] = new SequenceI[sequences.length];
\r
598 for (int s = 0; s < mseq.length; s++)
\r
600 mseq[s] = sequences[s].getSeq(gapCharacter).getSubSequence(start,
\r
609 smsa = new SequenceI[1][];
\r
610 smsa[0] = new SequenceI[sequences.length];
\r
611 for (int s = 0; s < sequences.length; s++)
\r
613 smsa[0][s] = sequences[s].getSeq(gapCharacter);
\r
620 * return full msa and hidden regions with visible blocks replaced with new
\r
626 * AlignmentOrder[] corresponding to each SequenceI[] block.
\r
629 public Object[] getUpdatedView(SequenceI[][] nvismsa,
\r
630 AlignmentOrder[] orders, char gapCharacter)
\r
632 if (sequences == null || width <= 0)
\r
634 throw new Error("empty view cannot be updated.");
\r
636 if (nvismsa == null)
\r
639 "nvismsa==null. use getAlignmentAndColumnSelection() instead.");
\r
641 if (contigs != null && contigs.length > 0)
\r
643 SequenceI[] alignment = new SequenceI[sequences.length];
\r
644 ColumnSelection columnselection = new ColumnSelection();
\r
645 if (contigs != null && contigs.length > 0)
\r
649 int owidth = width;
\r
651 for (int contig = 0; contig < contigs.length; contig += 3)
\r
653 owidth += contigs[contig + 2]; // recover final column width
\r
654 if (contigs[contig + 1] - start > 0)
\r
656 int swidth = 0; // subalignment width
\r
657 if (nvismsa[j] != null)
\r
659 SequenceI mseq[] = nvismsa[j];
\r
660 AlignmentOrder order = (orders == null) ? null : orders[j];
\r
662 if (mseq.length != sequences.length)
\r
665 "Mismatch between number of sequences in block "
\r
666 + j + " (" + mseq.length
\r
667 + ") and the original view ("
\r
668 + sequences.length + ")");
\r
670 swidth = mseq[0].getLength(); // JBPNote: could ensure padded
\r
672 for (int s = 0; s < mseq.length; s++)
\r
674 if (alignment[s] == null)
\r
676 alignment[s] = mseq[s];
\r
680 alignment[s].setSequence(alignment[s]
\r
681 .getSequenceAsString()
\r
682 + mseq[s].getSequenceAsString());
\r
683 if (mseq[s].getStart() <= mseq[s].getEnd())
\r
685 alignment[s].setEnd(mseq[s].getEnd());
\r
689 order.updateSequence(mseq[s], alignment[s]);
\r
696 // recover original alignment block or place gaps
\r
699 // recover input data
\r
700 for (int s = 0; s < sequences.length; s++)
\r
702 SequenceI oseq = sequences[s].getSeq(gapCharacter)
\r
703 .getSubSequence(start, contigs[contig + 1]);
\r
704 if (swidth < oseq.getLength())
\r
706 swidth = oseq.getLength();
\r
708 if (alignment[s] == null)
\r
710 alignment[s] = oseq;
\r
714 alignment[s].setSequence(alignment[s]
\r
715 .getSequenceAsString()
\r
716 + oseq.getSequenceAsString());
\r
717 if (oseq.getEnd() >= oseq.getStart())
\r
719 alignment[s].setEnd(oseq.getEnd());
\r
729 // advance to begining of visible region
\r
730 start = contigs[contig + 1] + contigs[contig + 2];
\r
731 // add hidden segment to right of next region
\r
732 for (int s = 0; s < sequences.length; s++)
\r
734 SequenceI hseq = sequences[s].getSeq(gapCharacter)
\r
735 .getSubSequence(contigs[contig + 1], start);
\r
736 if (alignment[s] == null)
\r
738 alignment[s] = hseq;
\r
742 alignment[s].setSequence(alignment[s].getSequenceAsString()
\r
743 + hseq.getSequenceAsString());
\r
744 if (hseq.getEnd() >= hseq.getStart())
\r
746 alignment[s].setEnd(hseq.getEnd());
\r
750 // mark hidden segment as hidden in the new alignment
\r
751 columnselection.hideColumns(nwidth, nwidth + contigs[contig + 2]
\r
753 nwidth += contigs[contig + 2];
\r
755 // Do final segment - if it exists
\r
756 if (j < nvismsa.length)
\r
759 if (nvismsa[j] != null)
\r
761 SequenceI mseq[] = nvismsa[j];
\r
762 AlignmentOrder order = (orders != null) ? orders[j] : null;
\r
763 swidth = mseq[0].getLength();
\r
764 for (int s = 0; s < mseq.length; s++)
\r
766 if (alignment[s] == null)
\r
768 alignment[s] = mseq[s];
\r
772 alignment[s].setSequence(alignment[s].getSequenceAsString()
\r
773 + mseq[s].getSequenceAsString());
\r
774 if (mseq[s].getEnd() >= mseq[s].getStart())
\r
776 alignment[s].setEnd(mseq[s].getEnd());
\r
780 order.updateSequence(mseq[s], alignment[s]);
\r
787 if (start < owidth)
\r
789 // recover input data or place gaps
\r
792 // recover input data
\r
793 for (int s = 0; s < sequences.length; s++)
\r
795 SequenceI oseq = sequences[s].getSeq(gapCharacter)
\r
796 .getSubSequence(start, owidth + 1);
\r
797 if (swidth < oseq.getLength())
\r
799 swidth = oseq.getLength();
\r
801 if (alignment[s] == null)
\r
803 alignment[s] = oseq;
\r
807 alignment[s].setSequence(alignment[s]
\r
808 .getSequenceAsString()
\r
809 + oseq.getSequenceAsString());
\r
810 if (oseq.getEnd() >= oseq.getStart())
\r
812 alignment[s].setEnd(oseq.getEnd());
\r
821 throw new Error("Padding not yet implemented.");
\r
827 return new Object[]
\r
828 { alignment, columnselection };
\r
832 if (nvismsa.length != 1)
\r
835 "Mismatch between visible blocks to update and number of contigs in view (contigs=0,blocks="
\r
838 if (nvismsa[0] != null)
\r
840 return new Object[]
\r
841 { nvismsa[0], new ColumnSelection() };
\r
845 return getAlignmentAndColumnSelection(gapCharacter);
\r
851 * returns simple array of start end positions of visible range on alignment.
\r
852 * vis_start and vis_end are inclusive - use
\r
853 * SequenceI.getSubSequence(vis_start, vis_end+1) to recover visible sequence
\r
854 * from underlying alignment.
\r
856 * @return int[] { start_i, end_i } for 1<i<n visible regions.
\r
858 public int[] getVisibleContigs()
\r
860 if (contigs != null && contigs.length > 0)
\r
864 int fwidth = width;
\r
865 for (int contig = 0; contig < contigs.length; contig += 3)
\r
867 if ((contigs[contig + 1] - start) > 0)
\r
871 fwidth += contigs[contig + 2]; // end up with full region width
\r
872 // (including hidden regions)
\r
873 start = contigs[contig + 1] + contigs[contig + 2];
\r
875 if (start < fwidth)
\r
879 int viscontigs[] = new int[nvis * 2];
\r
882 for (int contig = 0; contig < contigs.length; contig += 3)
\r
884 if ((contigs[contig + 1] - start) > 0)
\r
886 viscontigs[nvis] = start;
\r
887 viscontigs[nvis + 1] = contigs[contig + 1] - 1; // end is inclusive
\r
890 start = contigs[contig + 1] + contigs[contig + 2];
\r
892 if (start < fwidth)
\r
894 viscontigs[nvis] = start;
\r
895 viscontigs[nvis + 1] = fwidth; // end is inclusive
\r
909 * @return position of first visible column of AlignmentView within its
\r
910 * parent's alignment reference frame
\r
912 public int getAlignmentOrigin()
\r
918 * compute a deletion map for the current view according to the given
\r
922 * (as returned from SequenceI.gapMap())
\r
923 * @return int[] {intersection of visible regions with gapMap)
\r
925 public int[] getVisibleContigMapFor(int[] gapMap)
\r
927 int[] delMap = null;
\r
928 int[] viscontigs = getVisibleContigs();
\r
931 if (viscontigs != null)
\r
933 // viscontigs maps from a subset of the gapMap to the gapMap, so it will
\r
934 // always be equal to or shorter than gapMap
\r
935 delMap = new int[gapMap.length];
\r
936 for (int contig = 0; contig < viscontigs.length; contig += 2)
\r
939 while (spos < gapMap.length && gapMap[spos] < viscontigs[contig])
\r
943 while (spos < gapMap.length
\r
944 && gapMap[spos] <= viscontigs[contig + 1])
\r
946 delMap[i++] = spos++;
\r
949 int tmap[] = new int[i];
\r
950 System.arraycopy(delMap, 0, tmap, 0, i);
\r
957 * apply the getSeq(gc) method to each sequence cigar, and return the array of
\r
958 * edited sequences, optionally with hidden regions removed.
\r
961 * gap character to use for insertions
\r
963 * remove hidden regions from sequences. Note: currently implemented
\r
964 * in a memory inefficient way - space needed is 2*result set for
\r
967 * @return SequenceI[]
\r
969 public SequenceI[] getEditedSequences(char gc, boolean delete)
\r
971 SeqCigar[] msf = getSequences();
\r
972 SequenceI[] aln = new SequenceI[msf.length];
\r
973 for (int i = 0, j = msf.length; i < j; i++)
\r
975 aln[i] = msf[i].getSeq(gc);
\r
979 String[] sqs = getSequenceStrings(gc);
\r
980 for (int i = 0; i < sqs.length; i++)
\r
982 aln[i].setSequence(sqs[i]);
\r
989 public static void summariseAlignmentView(AlignmentView view,
\r
992 os.print("View has " + view.sequences.length + " of which ");
\r
993 if (view.selected == null) {
\r
996 os.print(" "+view.selected.size());
\r
998 os.println(" are selected.");
\r
999 os.print("View is " + view.getWidth() + " columns wide");
\r
1001 int[] contigs = view.getContigs();
\r
1002 if (contigs != null)
\r
1004 viswid = view.width;
\r
1005 for (int i = 0; i < contigs.length; i += 3)
\r
1007 viswid += contigs[i + 2];
\r
1009 os.println("with " + viswid + " visible columns spread over "
\r
1010 + contigs.length / 3 + " regions.");
\r
1014 viswid = view.width;
\r
1017 if (view.scGroups != null)
\r
1019 os.println("There are " + view.scGroups.size()
\r
1020 + " groups defined on the view.");
\r
1021 for (int g = 0; g < view.scGroups.size(); g++)
\r
1023 ScGroup sgr = (ScGroup) view.scGroups.elementAt(g);
\r
1024 os.println("Group " + g + ": Name = " + sgr.sg.getName()
\r
1025 + " Contains " + sgr.seqs.size() + " Seqs.");
\r
1026 os.println("This group runs from " + sgr.sg.getStartRes() + " to "
\r
1027 + sgr.sg.getEndRes());
\r
1028 for (int s = 0; s < sgr.seqs.size(); s++)
\r
1030 if (!((SeqCigar) sgr.seqs.elementAt(s)).isMemberOf(sgr))
\r
1032 os.println("** WARNING: sequence "
\r
1033 + ((SeqCigar) sgr.seqs.elementAt(s)).toString()
\r
1034 + " is not marked as member of group.");
\r
1038 AlignmentI visal = view.getVisibleAlignment('-');
\r
1039 if (visal != null)
\r
1041 os.println("Vis. alignment is " + visal.getWidth()
\r
1042 + " wide and has " + visal.getHeight() + " seqs.");
\r
1043 if (visal.getGroups() != null && visal.getGroups().size() > 0)
\r
1046 Enumeration en = visal.getGroups().elements();
\r
1048 while (en.hasMoreElements())
\r
1050 sg = (SequenceGroup) en.nextElement();
\r
1051 os.println("Group " + (i++) + " begins at column "
\r
1052 + sg.getStartRes() + " and ends at " + sg.getEndRes());
\r
1059 public static void testSelectionViews(AlignmentI alignment,
\r
1060 ColumnSelection csel, SequenceGroup selection)
\r
1062 System.out.println("Testing standard view creation:\n");
\r
1063 AlignmentView view = null;
\r
1067 .println("View with no hidden columns, no limit to selection, no groups to be collected:");
\r
1068 view = new AlignmentView(alignment, csel, selection, false, false,
\r
1070 summariseAlignmentView(view, System.out);
\r
1072 } catch (Exception e)
\r
1074 e.printStackTrace();
\r
1076 .println("Failed to generate alignment with selection but no groups marked.");
\r
1081 .println("View with no hidden columns, no limit to selection, and all groups to be collected:");
\r
1082 view = new AlignmentView(alignment, csel, selection, false, false,
\r
1084 summariseAlignmentView(view, System.out);
\r
1085 } catch (Exception e)
\r
1087 e.printStackTrace();
\r
1089 .println("Failed to generate alignment with selection marked but no groups marked.");
\r
1094 .println("View with no hidden columns, limited to selection and no groups to be collected:");
\r
1095 view = new AlignmentView(alignment, csel, selection, false, true,
\r
1097 summariseAlignmentView(view, System.out);
\r
1098 } catch (Exception e)
\r
1100 e.printStackTrace();
\r
1102 .println("Failed to generate alignment with selection restricted but no groups marked.");
\r
1107 .println("View with no hidden columns, limited to selection, and all groups to be collected:");
\r
1108 view = new AlignmentView(alignment, csel, selection, false, true,
\r
1110 summariseAlignmentView(view, System.out);
\r
1111 } catch (Exception e)
\r
1113 e.printStackTrace();
\r
1115 .println("Failed to generate alignment with selection restricted and groups marked.");
\r
1120 .println("View *with* hidden columns, no limit to selection, no groups to be collected:");
\r
1121 view = new AlignmentView(alignment, csel, selection, true, false,
\r
1123 summariseAlignmentView(view, System.out);
\r
1124 } catch (Exception e)
\r
1126 e.printStackTrace();
\r
1128 .println("Failed to generate alignment with selection but no groups marked.");
\r
1133 .println("View *with* hidden columns, no limit to selection, and all groups to be collected:");
\r
1134 view = new AlignmentView(alignment, csel, selection, true, false,
\r
1136 summariseAlignmentView(view, System.out);
\r
1137 } catch (Exception e)
\r
1139 e.printStackTrace();
\r
1141 .println("Failed to generate alignment with selection marked but no groups marked.");
\r
1146 .println("View *with* hidden columns, limited to selection and no groups to be collected:");
\r
1147 view = new AlignmentView(alignment, csel, selection, true, true,
\r
1149 summariseAlignmentView(view, System.out);
\r
1150 } catch (Exception e)
\r
1152 e.printStackTrace();
\r
1154 .println("Failed to generate alignment with selection restricted but no groups marked.");
\r
1159 .println("View *with* hidden columns, limited to selection, and all groups to be collected:");
\r
1160 view = new AlignmentView(alignment, csel, selection, true, true, true);
\r
1161 summariseAlignmentView(view, System.out);
\r
1162 } catch (Exception e)
\r
1164 e.printStackTrace();
\r
1166 .println("Failed to generate alignment with selection restricted and groups marked.");
\r