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(alignment.getGroups());
\r
119 ScGroup[] sgrps = null;
\r
120 boolean addedgps[] = null;
\r
124 if (selection != null && selectedRegionOnly)
\r
126 // trim annotation to the region being stored.
\r
127 // strip out any groups that do not actually intersect with the
\r
128 // visible and selected region
\r
129 int ssel = selection.getStartRes(), esel = selection.getEndRes();
\r
130 Vector isg = new Vector();
\r
131 Enumeration<?> en = grps.elements();
\r
132 while (en.hasMoreElements())
\r
134 sg = (SequenceGroup) en.nextElement();
\r
136 if (!(sg.getStartRes() > esel || sg.getEndRes() < ssel))
\r
138 // adjust bounds of new group, if necessary.
\r
139 if (sg.getStartRes() < ssel)
\r
141 sg.setStartRes(ssel);
\r
143 if (sg.getEndRes() > esel)
\r
145 sg.setEndRes(esel);
\r
147 isg.addElement(sg);
\r
153 sgrps = new ScGroup[grps.size()];
\r
154 addedgps = new boolean[grps.size()];
\r
155 for (int g = 0; g < sgrps.length; g++)
\r
157 sg = (SequenceGroup) grps.elementAt(g);
\r
158 sgrps[g] = new ScGroup();
\r
159 sgrps[g].sg = new SequenceGroup(sg);
\r
160 addedgps[g] = false;
\r
161 grps.setElementAt(sg.getSequences(null), g);
\r
163 // grps now contains vectors (should be sets) for each group, so we can
\r
164 // track when we've done with the group
\r
167 for (int i = 0; i < selseqs.length; i++)
\r
169 if (selseqs[i] != null)
\r
171 if (selection != null && !selectedRegionOnly)
\r
173 sequences[csi].setGroupMembership(selected);
\r
174 selected.addElement(sequences[csi]);
\r
178 for (int sg = 0; sg < sgrps.length; sg++)
\r
180 if (((Vector) grps.get(sg)).contains(selseqs[i]))
\r
182 sequences[csi].setGroupMembership(sgrps[sg]);
\r
183 sgrps[sg].sg.deleteSequence(selseqs[i], false);
\r
184 sgrps[sg].seqs.addElement(sequences[csi]);
\r
187 if (scGroups == null)
\r
189 scGroups = new Vector();
\r
191 addedgps[sg] = true;
\r
192 scGroups.addElement(sgrps[sg]);
\r
200 // finally, delete the remaining sequences (if any) not selected
\r
201 for (int sg = 0; sg < sgrps.length; sg++)
\r
203 SequenceI[] sqs = sgrps[sg].sg.getSequencesAsArray(null);
\r
204 for (int si = 0; si < sqs.length; si++)
\r
206 sgrps[sg].sg.deleteSequence(sqs[si], false);
\r
213 * construct an alignmentView from a SeqCigarArray. Errors are thrown if the
\r
214 * seqcigararray.isSeqCigarArray() flag is not set.
\r
216 public AlignmentView(CigarArray seqcigararray)
\r
218 if (!seqcigararray.isSeqCigarArray())
\r
221 "Implementation Error - can only make an alignment view from a CigarArray of sequences.");
\r
223 // contigs = seqcigararray.applyDeletions();
\r
224 contigs = seqcigararray.getDeletedRegions();
\r
225 sequences = seqcigararray.getSeqCigarArray();
\r
226 width = seqcigararray.getWidth(); // visible width
\r
230 * Create an alignmentView where the first column corresponds with the
\r
231 * 'firstcol' column of some reference alignment
\r
236 public AlignmentView(CigarArray sdata, int firstcol)
\r
239 firstCol = firstcol;
\r
242 public void setSequences(SeqCigar[] sequences)
\r
244 this.sequences = sequences;
\r
247 public void setContigs(int[] contigs)
\r
249 this.contigs = contigs;
\r
252 public SeqCigar[] getSequences()
\r
258 * @see CigarArray.getDeletedRegions
\r
259 * @return int[] { vis_start, sym_start, length }
\r
261 public int[] getContigs()
\r
267 * get the full alignment and a columnselection object marking the hidden
\r
270 * @param gapCharacter
\r
272 * @return Object[] { SequenceI[], ColumnSelection}
\r
274 public Object[] getAlignmentAndColumnSelection(char gapCharacter)
\r
276 ColumnSelection colsel = new ColumnSelection();
\r
278 return new Object[]
\r
280 SeqCigar.createAlignmentSequences(sequences, gapCharacter, colsel,
\r
281 contigs), colsel };
\r
285 * return the visible alignment corresponding to this view. Sequences in this
\r
286 * alignment are edited versions of the parent sequences - where hidden
\r
287 * regions have been removed. NOTE: the sequence data in this alignment is not
\r
293 public AlignmentI getVisibleAlignment(char c)
\r
295 SequenceI[] aln = getVisibleSeqs(c);
\r
297 AlignmentI vcal = new Alignment(aln);
\r
298 addPrunedGroupsInOrder(vcal, -1, -1, true);
\r
303 * add groups from view to the given alignment
\r
307 * -1 or 0 to width-1
\r
309 * -1 or gstart to width-1
\r
310 * @param viscontigs
\r
311 * - true if vcal is alignment of the visible regions of the view
\r
312 * (e.g. as returned from getVisibleAlignment)
\r
314 private void addPrunedGroupsInOrder(AlignmentI vcal, int gstart,
\r
315 int gend, boolean viscontigs)
\r
318 if (gstart > -1 && gstart <= gend)
\r
323 SequenceI[] aln = vcal.getSequencesArray();
\r
326 * prune any groups to the visible coordinates of the alignment.
\r
329 int nvg = scGroups != null ? scGroups.size() : 0;
\r
332 SequenceGroup[] nsg = new SequenceGroup[nvg];
\r
333 for (int g = 0; g < nvg; g++)
\r
335 SequenceGroup sg = ((ScGroup) scGroups.elementAt(g)).sg;
\r
338 if (sg.getStartRes() > gend || sg.getEndRes() < gstart)
\r
345 // may need to shift/trim start and end ?
\r
346 if (r && !viscontigs)
\r
348 if (nsg[g].getStartRes() < gstart)
\r
350 nsg[g].setStartRes(0);
\r
354 nsg[g].setStartRes(nsg[g].getStartRes() - gstart);
\r
355 nsg[g].setEndRes(nsg[g].getEndRes() - gstart);
\r
357 if (nsg[g].getEndRes() > gend)
\r
359 nsg[g].setEndRes(gend);
\r
363 // clone group properties
\r
364 nsg[g] = new SequenceGroup(sg);
\r
368 // prune groups to cover just the visible positions between
\r
370 if (contigs != null)
\r
373 ShiftList prune = new ShiftList();
\r
376 // adjust for start of alignment within visible window.
\r
377 prune.addShift(gstart, -gstart); //
\r
379 for (int h = 0; h < contigs.length; h += 3)
\r
382 prune.addShift(p + contigs[h + 1], contigs[h + 2]
\r
385 p = contigs[h + 1] + contigs[h + 2];
\r
387 for (int g = 0; g < nsg.length; g++)
\r
389 if (nsg[g] != null)
\r
391 int s = nsg[g].getStartRes(), t = nsg[g].getEndRes();
\r
404 s = prune.shift(s);
\r
405 t = prune.shift(t);
\r
406 nsg[g].setStartRes(s);
\r
407 nsg[g].setEndRes(t);
\r
413 for (int nsq = 0; nsq < aln.length; nsq++)
\r
415 for (int g = 0; g < nvg; g++)
\r
418 && sequences[nsq].isMemberOf(scGroups.elementAt(g)))
\r
420 nsg[g].addSequence(aln[nsq], false);
\r
424 for (int g = 0; g < nvg; g++)
\r
426 if (nsg[g] != null && nsg[g].getSize() > 0)
\r
428 vcal.addGroup(nsg[g]);
\r
438 * generate sequence array corresponding to the visible parts of the
\r
444 private SequenceI[] getVisibleSeqs(char c)
\r
446 SequenceI[] aln = new SequenceI[sequences.length];
\r
447 for (int i = 0, j = sequences.length; i < j; i++)
\r
449 aln[i] = sequences[i].getSeq('-');
\r
451 // Remove hidden regions from sequence objects.
\r
452 String seqs[] = getSequenceStrings('-');
\r
453 for (int i = 0, j = aln.length; i < j; i++)
\r
455 aln[i].setSequence(seqs[i]);
\r
461 * creates new alignment objects for all contiguous visible segments
\r
466 * @param regionOfInterest
\r
467 * specify which sequences to include (or null to include all
\r
469 * @return AlignmentI[] - all alignments where each sequence is a subsequence
\r
470 * constructed from visible contig regions of view
\r
472 public AlignmentI[] getVisibleContigAlignments(char c)
\r
475 int[] vcontigs = getVisibleContigs();
\r
476 SequenceI[][] contigviews = getVisibleContigs(c);
\r
477 AlignmentI[] vcals = new AlignmentI[contigviews.length];
\r
478 for (nvc = 0; nvc < contigviews.length; nvc++)
\r
480 vcals[nvc] = new Alignment(contigviews[nvc]);
\r
481 if (scGroups!=null && scGroups.size()>0)
\r
483 addPrunedGroupsInOrder(vcals[nvc], vcontigs[nvc*2],vcontigs[nvc*2+1], true);
\r
491 * get an array of visible sequence strings for a view on an alignment using
\r
492 * the given gap character
\r
498 public String[] getSequenceStrings(char c)
\r
500 String[] seqs = new String[sequences.length];
\r
501 for (int n = 0; n < sequences.length; n++)
\r
503 String fullseq = sequences[n].getSequenceString(c);
\r
504 if (contigs != null)
\r
508 for (int h = 0; h < contigs.length; h += 3)
\r
510 seqs[n] += fullseq.substring(p, contigs[h + 1]);
\r
511 p = contigs[h + 1] + contigs[h + 2];
\r
513 seqs[n] += fullseq.substring(p);
\r
525 * @return visible number of columns in alignment view
\r
527 public int getWidth()
\r
532 protected void setWidth(int width)
\r
534 this.width = width;
\r
538 * get the contiguous subalignments in an alignment view.
\r
540 * @param gapCharacter
\r
542 * @return SequenceI[][]
\r
544 public SequenceI[][] getVisibleContigs(char gapCharacter)
\r
546 SequenceI[][] smsa;
\r
548 if (sequences == null || width <= 0)
\r
552 if (contigs != null && contigs.length > 0)
\r
556 int fwidth = width;
\r
557 for (int contig = 0; contig < contigs.length; contig += 3)
\r
559 if ((contigs[contig + 1] - start) > 0)
\r
563 fwidth += contigs[contig + 2]; // end up with full region width
\r
564 // (including hidden regions)
\r
565 start = contigs[contig + 1] + contigs[contig + 2];
\r
567 if (start < fwidth)
\r
571 smsa = new SequenceI[njobs][];
\r
574 for (int contig = 0; contig < contigs.length; contig += 3)
\r
576 if (contigs[contig + 1] - start > 0)
\r
578 SequenceI mseq[] = new SequenceI[sequences.length];
\r
579 for (int s = 0; s < mseq.length; s++)
\r
581 mseq[s] = sequences[s].getSeq(gapCharacter).getSubSequence(
\r
582 start, contigs[contig + 1]);
\r
587 start = contigs[contig + 1] + contigs[contig + 2];
\r
589 if (start < fwidth)
\r
591 SequenceI mseq[] = new SequenceI[sequences.length];
\r
592 for (int s = 0; s < mseq.length; s++)
\r
594 mseq[s] = sequences[s].getSeq(gapCharacter).getSubSequence(start,
\r
603 smsa = new SequenceI[1][];
\r
604 smsa[0] = new SequenceI[sequences.length];
\r
605 for (int s = 0; s < sequences.length; s++)
\r
607 smsa[0][s] = sequences[s].getSeq(gapCharacter);
\r
614 * return full msa and hidden regions with visible blocks replaced with new
\r
620 * AlignmentOrder[] corresponding to each SequenceI[] block.
\r
623 public Object[] getUpdatedView(SequenceI[][] nvismsa,
\r
624 AlignmentOrder[] orders, char gapCharacter)
\r
626 if (sequences == null || width <= 0)
\r
628 throw new Error("empty view cannot be updated.");
\r
630 if (nvismsa == null)
\r
633 "nvismsa==null. use getAlignmentAndColumnSelection() instead.");
\r
635 if (contigs != null && contigs.length > 0)
\r
637 SequenceI[] alignment = new SequenceI[sequences.length];
\r
638 ColumnSelection columnselection = new ColumnSelection();
\r
639 if (contigs != null && contigs.length > 0)
\r
643 int owidth = width;
\r
645 for (int contig = 0; contig < contigs.length; contig += 3)
\r
647 owidth += contigs[contig + 2]; // recover final column width
\r
648 if (contigs[contig + 1] - start > 0)
\r
650 int swidth = 0; // subalignment width
\r
651 if (nvismsa[j] != null)
\r
653 SequenceI mseq[] = nvismsa[j];
\r
654 AlignmentOrder order = (orders == null) ? null : orders[j];
\r
656 if (mseq.length != sequences.length)
\r
659 "Mismatch between number of sequences in block "
\r
660 + j + " (" + mseq.length
\r
661 + ") and the original view ("
\r
662 + sequences.length + ")");
\r
664 swidth = mseq[0].getLength(); // JBPNote: could ensure padded
\r
666 for (int s = 0; s < mseq.length; s++)
\r
668 if (alignment[s] == null)
\r
670 alignment[s] = mseq[s];
\r
674 alignment[s].setSequence(alignment[s]
\r
675 .getSequenceAsString()
\r
676 + mseq[s].getSequenceAsString());
\r
677 if (mseq[s].getStart() <= mseq[s].getEnd())
\r
679 alignment[s].setEnd(mseq[s].getEnd());
\r
683 order.updateSequence(mseq[s], alignment[s]);
\r
690 // recover original alignment block or place gaps
\r
693 // recover input data
\r
694 for (int s = 0; s < sequences.length; s++)
\r
696 SequenceI oseq = sequences[s].getSeq(gapCharacter)
\r
697 .getSubSequence(start, contigs[contig + 1]);
\r
698 if (swidth < oseq.getLength())
\r
700 swidth = oseq.getLength();
\r
702 if (alignment[s] == null)
\r
704 alignment[s] = oseq;
\r
708 alignment[s].setSequence(alignment[s]
\r
709 .getSequenceAsString()
\r
710 + oseq.getSequenceAsString());
\r
711 if (oseq.getEnd() >= oseq.getStart())
\r
713 alignment[s].setEnd(oseq.getEnd());
\r
723 // advance to begining of visible region
\r
724 start = contigs[contig + 1] + contigs[contig + 2];
\r
725 // add hidden segment to right of next region
\r
726 for (int s = 0; s < sequences.length; s++)
\r
728 SequenceI hseq = sequences[s].getSeq(gapCharacter)
\r
729 .getSubSequence(contigs[contig + 1], start);
\r
730 if (alignment[s] == null)
\r
732 alignment[s] = hseq;
\r
736 alignment[s].setSequence(alignment[s].getSequenceAsString()
\r
737 + hseq.getSequenceAsString());
\r
738 if (hseq.getEnd() >= hseq.getStart())
\r
740 alignment[s].setEnd(hseq.getEnd());
\r
744 // mark hidden segment as hidden in the new alignment
\r
745 columnselection.hideColumns(nwidth, nwidth + contigs[contig + 2]
\r
747 nwidth += contigs[contig + 2];
\r
749 // Do final segment - if it exists
\r
750 if (j < nvismsa.length)
\r
753 if (nvismsa[j] != null)
\r
755 SequenceI mseq[] = nvismsa[j];
\r
756 AlignmentOrder order = (orders != null) ? orders[j] : null;
\r
757 swidth = mseq[0].getLength();
\r
758 for (int s = 0; s < mseq.length; s++)
\r
760 if (alignment[s] == null)
\r
762 alignment[s] = mseq[s];
\r
766 alignment[s].setSequence(alignment[s].getSequenceAsString()
\r
767 + mseq[s].getSequenceAsString());
\r
768 if (mseq[s].getEnd() >= mseq[s].getStart())
\r
770 alignment[s].setEnd(mseq[s].getEnd());
\r
774 order.updateSequence(mseq[s], alignment[s]);
\r
781 if (start < owidth)
\r
783 // recover input data or place gaps
\r
786 // recover input data
\r
787 for (int s = 0; s < sequences.length; s++)
\r
789 SequenceI oseq = sequences[s].getSeq(gapCharacter)
\r
790 .getSubSequence(start, owidth + 1);
\r
791 if (swidth < oseq.getLength())
\r
793 swidth = oseq.getLength();
\r
795 if (alignment[s] == null)
\r
797 alignment[s] = oseq;
\r
801 alignment[s].setSequence(alignment[s]
\r
802 .getSequenceAsString()
\r
803 + oseq.getSequenceAsString());
\r
804 if (oseq.getEnd() >= oseq.getStart())
\r
806 alignment[s].setEnd(oseq.getEnd());
\r
815 throw new Error("Padding not yet implemented.");
\r
821 return new Object[]
\r
822 { alignment, columnselection };
\r
826 if (nvismsa.length != 1)
\r
829 "Mismatch between visible blocks to update and number of contigs in view (contigs=0,blocks="
\r
832 if (nvismsa[0] != null)
\r
834 return new Object[]
\r
835 { nvismsa[0], new ColumnSelection() };
\r
839 return getAlignmentAndColumnSelection(gapCharacter);
\r
845 * returns simple array of start end positions of visible range on alignment.
\r
846 * vis_start and vis_end are inclusive - use
\r
847 * SequenceI.getSubSequence(vis_start, vis_end+1) to recover visible sequence
\r
848 * from underlying alignment.
\r
850 * @return int[] { start_i, end_i } for 1<i<n visible regions.
\r
852 public int[] getVisibleContigs()
\r
854 if (contigs != null && contigs.length > 0)
\r
858 int fwidth = width;
\r
859 for (int contig = 0; contig < contigs.length; contig += 3)
\r
861 if ((contigs[contig + 1] - start) > 0)
\r
865 fwidth += contigs[contig + 2]; // end up with full region width
\r
866 // (including hidden regions)
\r
867 start = contigs[contig + 1] + contigs[contig + 2];
\r
869 if (start < fwidth)
\r
873 int viscontigs[] = new int[nvis * 2];
\r
876 for (int contig = 0; contig < contigs.length; contig += 3)
\r
878 if ((contigs[contig + 1] - start) > 0)
\r
880 viscontigs[nvis] = start;
\r
881 viscontigs[nvis + 1] = contigs[contig + 1] - 1; // end is inclusive
\r
884 start = contigs[contig + 1] + contigs[contig + 2];
\r
886 if (start < fwidth)
\r
888 viscontigs[nvis] = start;
\r
889 viscontigs[nvis + 1] = fwidth; // end is inclusive
\r
903 * @return position of first visible column of AlignmentView within its
\r
904 * parent's alignment reference frame
\r
906 public int getAlignmentOrigin()
\r
912 * compute a deletion map for the current view according to the given
\r
916 * (as returned from SequenceI.gapMap())
\r
917 * @return int[] {intersection of visible regions with gapMap)
\r
919 public int[] getVisibleContigMapFor(int[] gapMap)
\r
921 int[] delMap = null;
\r
922 int[] viscontigs = getVisibleContigs();
\r
925 if (viscontigs != null)
\r
927 // viscontigs maps from a subset of the gapMap to the gapMap, so it will
\r
928 // always be equal to or shorter than gapMap
\r
929 delMap = new int[gapMap.length];
\r
930 for (int contig = 0; contig < viscontigs.length; contig += 2)
\r
933 while (spos < gapMap.length && gapMap[spos] < viscontigs[contig])
\r
937 while (spos < gapMap.length
\r
938 && gapMap[spos] <= viscontigs[contig + 1])
\r
940 delMap[i++] = spos++;
\r
943 int tmap[] = new int[i];
\r
944 System.arraycopy(delMap, 0, tmap, 0, i);
\r
951 * apply the getSeq(gc) method to each sequence cigar, and return the array of
\r
952 * edited sequences, optionally with hidden regions removed.
\r
955 * gap character to use for insertions
\r
957 * remove hidden regions from sequences. Note: currently implemented
\r
958 * in a memory inefficient way - space needed is 2*result set for
\r
961 * @return SequenceI[]
\r
963 public SequenceI[] getEditedSequences(char gc, boolean delete)
\r
965 SeqCigar[] msf = getSequences();
\r
966 SequenceI[] aln = new SequenceI[msf.length];
\r
967 for (int i = 0, j = msf.length; i < j; i++)
\r
969 aln[i] = msf[i].getSeq(gc);
\r
973 String[] sqs = getSequenceStrings(gc);
\r
974 for (int i = 0; i < sqs.length; i++)
\r
976 aln[i].setSequence(sqs[i]);
\r
983 public static void summariseAlignmentView(AlignmentView view,
\r
986 os.println("View has " + view.sequences.length + " of which "
\r
987 + (view.selected == null ? "None" : view.selected.size())
\r
988 + " are selected.");
\r
989 os.print("View is " + view.getWidth() + " columns wide");
\r
991 int[] contigs = view.getContigs();
\r
992 if (contigs != null)
\r
994 viswid = view.width;
\r
995 for (int i = 0; i < contigs.length; i += 3)
\r
997 viswid += contigs[i + 2];
\r
999 os.println("with " + viswid + " visible columns spread over "
\r
1000 + contigs.length / 3 + " regions.");
\r
1004 viswid = view.width;
\r
1007 if (view.scGroups != null)
\r
1009 os.println("There are " + view.scGroups.size()
\r
1010 + " groups defined on the view.");
\r
1011 for (int g = 0; g < view.scGroups.size(); g++)
\r
1013 ScGroup sgr = (ScGroup) view.scGroups.elementAt(g);
\r
1014 os.println("Group " + g + ": Name = " + sgr.sg.getName()
\r
1015 + " Contains " + sgr.seqs.size() + " Seqs.");
\r
1016 os.println("This group runs from " + sgr.sg.getStartRes() + " to "
\r
1017 + sgr.sg.getEndRes());
\r
1018 for (int s = 0; s < sgr.seqs.size(); s++)
\r
1020 if (!((SeqCigar) sgr.seqs.elementAt(s)).isMemberOf(sgr))
\r
1022 os.println("** WARNING: sequence "
\r
1023 + ((SeqCigar) sgr.seqs.elementAt(s)).toString()
\r
1024 + " is not marked as member of group.");
\r
1028 AlignmentI visal = view.getVisibleAlignment('-');
\r
1029 if (visal != null)
\r
1031 os.println("Vis. alignment is " + visal.getWidth()
\r
1032 + " wide and has " + visal.getHeight() + " seqs.");
\r
1033 if (visal.getGroups() != null && visal.getGroups().size() > 0)
\r
1036 Enumeration en = visal.getGroups().elements();
\r
1038 while (en.hasMoreElements())
\r
1040 sg = (SequenceGroup) en.nextElement();
\r
1041 os.println("Group " + (i++) + " begins at column "
\r
1042 + sg.getStartRes() + " and ends at " + sg.getEndRes());
\r
1049 public static void testSelectionViews(AlignmentI alignment,
\r
1050 ColumnSelection csel, SequenceGroup selection)
\r
1052 System.out.println("Testing standard view creation:\n");
\r
1053 AlignmentView view = null;
\r
1057 .println("View with no hidden columns, no limit to selection, no groups to be collected:");
\r
1058 view = new AlignmentView(alignment, csel, selection, false, false,
\r
1060 summariseAlignmentView(view, System.out);
\r
1062 } catch (Exception e)
\r
1064 e.printStackTrace();
\r
1066 .println("Failed to generate alignment with selection but no groups marked.");
\r
1071 .println("View with no hidden columns, no limit to selection, and all groups to be collected:");
\r
1072 view = new AlignmentView(alignment, csel, selection, false, false,
\r
1074 summariseAlignmentView(view, System.out);
\r
1075 } catch (Exception e)
\r
1077 e.printStackTrace();
\r
1079 .println("Failed to generate alignment with selection marked but no groups marked.");
\r
1084 .println("View with no hidden columns, limited to selection and no groups to be collected:");
\r
1085 view = new AlignmentView(alignment, csel, selection, false, true,
\r
1087 summariseAlignmentView(view, System.out);
\r
1088 } catch (Exception e)
\r
1090 e.printStackTrace();
\r
1092 .println("Failed to generate alignment with selection restricted but no groups marked.");
\r
1097 .println("View with no hidden columns, limited to selection, and all groups to be collected:");
\r
1098 view = new AlignmentView(alignment, csel, selection, false, true,
\r
1100 summariseAlignmentView(view, System.out);
\r
1101 } catch (Exception e)
\r
1103 e.printStackTrace();
\r
1105 .println("Failed to generate alignment with selection restricted and groups marked.");
\r
1110 .println("View *with* hidden columns, no limit to selection, no groups to be collected:");
\r
1111 view = new AlignmentView(alignment, csel, selection, true, false,
\r
1113 summariseAlignmentView(view, System.out);
\r
1114 } catch (Exception e)
\r
1116 e.printStackTrace();
\r
1118 .println("Failed to generate alignment with selection but no groups marked.");
\r
1123 .println("View *with* hidden columns, no limit to selection, and all groups to be collected:");
\r
1124 view = new AlignmentView(alignment, csel, selection, true, false,
\r
1126 summariseAlignmentView(view, System.out);
\r
1127 } catch (Exception e)
\r
1129 e.printStackTrace();
\r
1131 .println("Failed to generate alignment with selection marked but no groups marked.");
\r
1136 .println("View *with* hidden columns, limited to selection and no groups to be collected:");
\r
1137 view = new AlignmentView(alignment, csel, selection, true, true,
\r
1139 summariseAlignmentView(view, System.out);
\r
1140 } catch (Exception e)
\r
1142 e.printStackTrace();
\r
1144 .println("Failed to generate alignment with selection restricted but no groups marked.");
\r
1149 .println("View *with* hidden columns, limited to selection, and all groups to be collected:");
\r
1150 view = new AlignmentView(alignment, csel, selection, true, true, true);
\r
1151 summariseAlignmentView(view, System.out);
\r
1152 } catch (Exception e)
\r
1154 e.printStackTrace();
\r
1156 .println("Failed to generate alignment with selection restricted and groups marked.");
\r