2 * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
\r
3 * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, 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.List;
\r
25 import java.util.Vector;
\r
28 * Transient object compactly representing a 'view' of an alignment - with
\r
29 * discontinuities marked. Extended in Jalview 2.7 to optionally record sequence
\r
30 * groups and specific selected regions on the alignment.
\r
32 public class AlignmentView
\r
34 private SeqCigar[] sequences = null;
\r
36 private int[] contigs = null;
\r
38 private int width = 0;
\r
40 private int firstCol = 0;
\r
43 * one or more ScGroup objects, which are referenced by each seqCigar's group
\r
46 private Vector scGroups;
\r
49 * Group defined over SeqCigars. Unlike AlignmentI associated groups, each
\r
50 * SequenceGroup hold just the essential properties for the group, but no
\r
51 * references to the sequences involved. SeqCigars hold references to the
\r
52 * seuqenceGroup entities themselves.
\r
54 private class ScGroup
\r
58 public SequenceGroup sg;
\r
62 seqs = new Vector();
\r
67 * vector of selected seqCigars. This vector is also referenced by each
\r
68 * seqCigar contained in it.
\r
70 private Vector selected;
\r
73 * Construct an alignmentView from a live jalview alignment view. Note -
\r
74 * hidden rows will be excluded from alignmentView
\r
77 * - alignment as referenced by an AlignViewport
\r
78 * @param columnSelection
\r
81 * @param hasHiddenColumns
\r
82 * - mark the hidden columns in columnSelection as hidden in the view
\r
83 * @param selectedRegionOnly
\r
84 * - when set, only include the selected region in the view,
\r
85 * otherwise just mark the selected region on the constructed view.
\r
86 * @param recordGroups
\r
87 * - when set, any groups on the given alignment will be marked on
\r
90 public AlignmentView(AlignmentI alignment,
\r
91 ColumnSelection columnSelection, SequenceGroup selection,
\r
92 boolean hasHiddenColumns, boolean selectedRegionOnly,
\r
93 boolean recordGroups)
\r
95 // refactored from AlignViewport.getAlignmentView(selectedOnly);
\r
96 this(new jalview.datamodel.CigarArray(alignment,
\r
97 (hasHiddenColumns ? columnSelection : null),
\r
98 (selectedRegionOnly ? selection : null)),
\r
99 (selectedRegionOnly && selection != null) ? selection
\r
100 .getStartRes() : 0);
\r
101 // walk down SeqCigar array and Alignment Array - optionally restricted by
\r
102 // selected region.
\r
103 // test group membership for each sequence in each group, store membership
\r
104 // and record non-empty groups in group list.
\r
105 // record / sub-select selected region on the alignment view
\r
106 SequenceI[] selseqs;
\r
107 if (selection != null)
\r
109 List<SequenceI> sel = selection.getSequences(null);
\r
110 this.selected = new Vector();
\r
111 selseqs = selection.getSequencesInOrder(alignment, selectedRegionOnly);
\r
115 selseqs = alignment.getSequencesArray();
\r
118 // get the alignment's group list and make a copy
\r
119 Vector grps = new Vector();
\r
120 List<SequenceGroup> gg = alignment.getGroups();
\r
122 ScGroup[] sgrps = null;
\r
123 boolean addedgps[] = null;
\r
127 if (selection != null && selectedRegionOnly)
\r
129 // trim annotation to the region being stored.
\r
130 // strip out any groups that do not actually intersect with the
\r
131 // visible and selected region
\r
132 int ssel = selection.getStartRes(), esel = selection.getEndRes();
\r
133 Vector isg = new Vector();
\r
134 Enumeration en = grps.elements();
\r
135 while (en.hasMoreElements())
\r
137 sg = (SequenceGroup) en.nextElement();
\r
139 if (!(sg.getStartRes() > esel || sg.getEndRes() < ssel))
\r
141 // adjust bounds of new group, if necessary.
\r
142 if (sg.getStartRes() < ssel)
\r
144 sg.setStartRes(ssel);
\r
146 if (sg.getEndRes() > esel)
\r
148 sg.setEndRes(esel);
\r
150 sg.setStartRes(sg.getStartRes()-ssel+1);
\r
151 sg.setEndRes(sg.getEndRes()-ssel+1);
\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
352 // clone group properties
\r
353 nsg[g] = new SequenceGroup(sg);
\r
355 // may need to shift/trim start and end ?
\r
356 if (r && !viscontigs)
\r
358 // Not fully tested code - routine not yet called with viscontigs==false
\r
359 if (nsg[g].getStartRes() < gstart)
\r
361 nsg[g].setStartRes(0);
\r
365 nsg[g].setStartRes(nsg[g].getStartRes() - gstart);
\r
366 nsg[g].setEndRes(nsg[g].getEndRes() - gstart);
\r
368 if (nsg[g].getEndRes() > (gend-gstart))
\r
370 nsg[g].setEndRes(gend-gstart);
\r
376 // prune groups to cover just the visible positions between
\r
378 if (contigs != null)
\r
381 ShiftList prune = new ShiftList();
\r
384 // adjust for start of alignment within visible window.
\r
385 prune.addShift(gstart, -gstart); //
\r
387 for (int h = 0; h < contigs.length; h += 3)
\r
390 prune.addShift(p + contigs[h + 1], contigs[h + 2]
\r
393 p = contigs[h + 1] + contigs[h + 2];
\r
395 for (int g = 0; g < nsg.length; g++)
\r
397 if (nsg[g] != null)
\r
399 int s = nsg[g].getStartRes(), t = nsg[g].getEndRes();
\r
412 s = prune.shift(s);
\r
413 t = prune.shift(t);
\r
414 nsg[g].setStartRes(s);
\r
415 nsg[g].setEndRes(t);
\r
421 for (int nsq = 0; nsq < aln.length; nsq++)
\r
423 for (int g = 0; g < nvg; g++)
\r
426 && sequences[nsq].isMemberOf(scGroups.elementAt(g)))
\r
428 nsg[g].addSequence(aln[nsq], false);
\r
432 for (int g = 0; g < nvg; g++)
\r
434 if (nsg[g] != null && nsg[g].getSize() > 0)
\r
436 vcal.addGroup(nsg[g]);
\r
446 * generate sequence array corresponding to the visible parts of the
\r
452 private SequenceI[] getVisibleSeqs(char c)
\r
454 SequenceI[] aln = new SequenceI[sequences.length];
\r
455 for (int i = 0, j = sequences.length; i < j; i++)
\r
457 aln[i] = sequences[i].getSeq('-');
\r
459 // Remove hidden regions from sequence objects.
\r
460 String seqs[] = getSequenceStrings('-');
\r
461 for (int i = 0, j = aln.length; i < j; i++)
\r
463 aln[i].setSequence(seqs[i]);
\r
469 * creates new alignment objects for all contiguous visible segments
\r
474 * @param regionOfInterest
\r
475 * specify which sequences to include (or null to include all
\r
477 * @return AlignmentI[] - all alignments where each sequence is a subsequence
\r
478 * constructed from visible contig regions of view
\r
480 public AlignmentI[] getVisibleContigAlignments(char c)
\r
483 int[] vcontigs = getVisibleContigs();
\r
484 SequenceI[][] contigviews = getVisibleContigs(c);
\r
485 AlignmentI[] vcals = new AlignmentI[contigviews.length];
\r
486 for (nvc = 0; nvc < contigviews.length; nvc++)
\r
488 vcals[nvc] = new Alignment(contigviews[nvc]);
\r
489 if (scGroups!=null && scGroups.size()>0)
\r
491 addPrunedGroupsInOrder(vcals[nvc], vcontigs[nvc*2],vcontigs[nvc*2+1], true);
\r
499 * get an array of visible sequence strings for a view on an alignment using
\r
500 * the given gap character
\r
506 public String[] getSequenceStrings(char c)
\r
508 String[] seqs = new String[sequences.length];
\r
509 for (int n = 0; n < sequences.length; n++)
\r
511 String fullseq = sequences[n].getSequenceString(c);
\r
512 if (contigs != null)
\r
516 for (int h = 0; h < contigs.length; h += 3)
\r
518 seqs[n] += fullseq.substring(p, contigs[h + 1]);
\r
519 p = contigs[h + 1] + contigs[h + 2];
\r
521 seqs[n] += fullseq.substring(p);
\r
533 * @return visible number of columns in alignment view
\r
535 public int getWidth()
\r
540 protected void setWidth(int width)
\r
542 this.width = width;
\r
546 * get the contiguous subalignments in an alignment view.
\r
548 * @param gapCharacter
\r
550 * @return SequenceI[][]
\r
552 public SequenceI[][] getVisibleContigs(char gapCharacter)
\r
554 SequenceI[][] smsa;
\r
556 if (sequences == null || width <= 0)
\r
560 if (contigs != null && contigs.length > 0)
\r
564 int fwidth = width;
\r
565 for (int contig = 0; contig < contigs.length; contig += 3)
\r
567 if ((contigs[contig + 1] - start) > 0)
\r
571 fwidth += contigs[contig + 2]; // end up with full region width
\r
572 // (including hidden regions)
\r
573 start = contigs[contig + 1] + contigs[contig + 2];
\r
575 if (start < fwidth)
\r
579 smsa = new SequenceI[njobs][];
\r
582 for (int contig = 0; contig < contigs.length; contig += 3)
\r
584 if (contigs[contig + 1] - start > 0)
\r
586 SequenceI mseq[] = new SequenceI[sequences.length];
\r
587 for (int s = 0; s < mseq.length; s++)
\r
589 mseq[s] = sequences[s].getSeq(gapCharacter).getSubSequence(
\r
590 start, contigs[contig + 1]);
\r
595 start = contigs[contig + 1] + contigs[contig + 2];
\r
597 if (start < fwidth)
\r
599 SequenceI mseq[] = new SequenceI[sequences.length];
\r
600 for (int s = 0; s < mseq.length; s++)
\r
602 mseq[s] = sequences[s].getSeq(gapCharacter).getSubSequence(start,
\r
611 smsa = new SequenceI[1][];
\r
612 smsa[0] = new SequenceI[sequences.length];
\r
613 for (int s = 0; s < sequences.length; s++)
\r
615 smsa[0][s] = sequences[s].getSeq(gapCharacter);
\r
622 * return full msa and hidden regions with visible blocks replaced with new
\r
628 * AlignmentOrder[] corresponding to each SequenceI[] block.
\r
631 public Object[] getUpdatedView(SequenceI[][] nvismsa,
\r
632 AlignmentOrder[] orders, char gapCharacter)
\r
634 if (sequences == null || width <= 0)
\r
636 throw new Error("empty view cannot be updated.");
\r
638 if (nvismsa == null)
\r
641 "nvismsa==null. use getAlignmentAndColumnSelection() instead.");
\r
643 if (contigs != null && contigs.length > 0)
\r
645 SequenceI[] alignment = new SequenceI[sequences.length];
\r
646 ColumnSelection columnselection = new ColumnSelection();
\r
647 if (contigs != null && contigs.length > 0)
\r
651 int owidth = width;
\r
653 for (int contig = 0; contig < contigs.length; contig += 3)
\r
655 owidth += contigs[contig + 2]; // recover final column width
\r
656 if (contigs[contig + 1] - start > 0)
\r
658 int swidth = 0; // subalignment width
\r
659 if (nvismsa[j] != null)
\r
661 SequenceI mseq[] = nvismsa[j];
\r
662 AlignmentOrder order = (orders == null) ? null : orders[j];
\r
664 if (mseq.length != sequences.length)
\r
667 "Mismatch between number of sequences in block "
\r
668 + j + " (" + mseq.length
\r
669 + ") and the original view ("
\r
670 + sequences.length + ")");
\r
672 swidth = mseq[0].getLength(); // JBPNote: could ensure padded
\r
674 for (int s = 0; s < mseq.length; s++)
\r
676 if (alignment[s] == null)
\r
678 alignment[s] = mseq[s];
\r
682 alignment[s].setSequence(alignment[s]
\r
683 .getSequenceAsString()
\r
684 + mseq[s].getSequenceAsString());
\r
685 if (mseq[s].getStart() <= mseq[s].getEnd())
\r
687 alignment[s].setEnd(mseq[s].getEnd());
\r
691 order.updateSequence(mseq[s], alignment[s]);
\r
698 // recover original alignment block or place gaps
\r
701 // recover input data
\r
702 for (int s = 0; s < sequences.length; s++)
\r
704 SequenceI oseq = sequences[s].getSeq(gapCharacter)
\r
705 .getSubSequence(start, contigs[contig + 1]);
\r
706 if (swidth < oseq.getLength())
\r
708 swidth = oseq.getLength();
\r
710 if (alignment[s] == null)
\r
712 alignment[s] = oseq;
\r
716 alignment[s].setSequence(alignment[s]
\r
717 .getSequenceAsString()
\r
718 + oseq.getSequenceAsString());
\r
719 if (oseq.getEnd() >= oseq.getStart())
\r
721 alignment[s].setEnd(oseq.getEnd());
\r
731 // advance to begining of visible region
\r
732 start = contigs[contig + 1] + contigs[contig + 2];
\r
733 // add hidden segment to right of next region
\r
734 for (int s = 0; s < sequences.length; s++)
\r
736 SequenceI hseq = sequences[s].getSeq(gapCharacter)
\r
737 .getSubSequence(contigs[contig + 1], start);
\r
738 if (alignment[s] == null)
\r
740 alignment[s] = hseq;
\r
744 alignment[s].setSequence(alignment[s].getSequenceAsString()
\r
745 + hseq.getSequenceAsString());
\r
746 if (hseq.getEnd() >= hseq.getStart())
\r
748 alignment[s].setEnd(hseq.getEnd());
\r
752 // mark hidden segment as hidden in the new alignment
\r
753 columnselection.hideColumns(nwidth, nwidth + contigs[contig + 2]
\r
755 nwidth += contigs[contig + 2];
\r
757 // Do final segment - if it exists
\r
758 if (j < nvismsa.length)
\r
761 if (nvismsa[j] != null)
\r
763 SequenceI mseq[] = nvismsa[j];
\r
764 AlignmentOrder order = (orders != null) ? orders[j] : null;
\r
765 swidth = mseq[0].getLength();
\r
766 for (int s = 0; s < mseq.length; s++)
\r
768 if (alignment[s] == null)
\r
770 alignment[s] = mseq[s];
\r
774 alignment[s].setSequence(alignment[s].getSequenceAsString()
\r
775 + mseq[s].getSequenceAsString());
\r
776 if (mseq[s].getEnd() >= mseq[s].getStart())
\r
778 alignment[s].setEnd(mseq[s].getEnd());
\r
782 order.updateSequence(mseq[s], alignment[s]);
\r
789 if (start < owidth)
\r
791 // recover input data or place gaps
\r
794 // recover input data
\r
795 for (int s = 0; s < sequences.length; s++)
\r
797 SequenceI oseq = sequences[s].getSeq(gapCharacter)
\r
798 .getSubSequence(start, owidth + 1);
\r
799 if (swidth < oseq.getLength())
\r
801 swidth = oseq.getLength();
\r
803 if (alignment[s] == null)
\r
805 alignment[s] = oseq;
\r
809 alignment[s].setSequence(alignment[s]
\r
810 .getSequenceAsString()
\r
811 + oseq.getSequenceAsString());
\r
812 if (oseq.getEnd() >= oseq.getStart())
\r
814 alignment[s].setEnd(oseq.getEnd());
\r
823 throw new Error("Padding not yet implemented.");
\r
829 return new Object[]
\r
830 { alignment, columnselection };
\r
834 if (nvismsa.length != 1)
\r
837 "Mismatch between visible blocks to update and number of contigs in view (contigs=0,blocks="
\r
840 if (nvismsa[0] != null)
\r
842 return new Object[]
\r
843 { nvismsa[0], new ColumnSelection() };
\r
847 return getAlignmentAndColumnSelection(gapCharacter);
\r
853 * returns simple array of start end positions of visible range on alignment.
\r
854 * vis_start and vis_end are inclusive - use
\r
855 * SequenceI.getSubSequence(vis_start, vis_end+1) to recover visible sequence
\r
856 * from underlying alignment.
\r
858 * @return int[] { start_i, end_i } for 1<i<n visible regions.
\r
860 public int[] getVisibleContigs()
\r
862 if (contigs != null && contigs.length > 0)
\r
866 int fwidth = width;
\r
867 for (int contig = 0; contig < contigs.length; contig += 3)
\r
869 if ((contigs[contig + 1] - start) > 0)
\r
873 fwidth += contigs[contig + 2]; // end up with full region width
\r
874 // (including hidden regions)
\r
875 start = contigs[contig + 1] + contigs[contig + 2];
\r
877 if (start < fwidth)
\r
881 int viscontigs[] = new int[nvis * 2];
\r
884 for (int contig = 0; contig < contigs.length; contig += 3)
\r
886 if ((contigs[contig + 1] - start) > 0)
\r
888 viscontigs[nvis] = start;
\r
889 viscontigs[nvis + 1] = contigs[contig + 1] - 1; // end is inclusive
\r
892 start = contigs[contig + 1] + contigs[contig + 2];
\r
894 if (start < fwidth)
\r
896 viscontigs[nvis] = start;
\r
897 viscontigs[nvis + 1] = fwidth; // end is inclusive
\r
911 * @return position of first visible column of AlignmentView within its
\r
912 * parent's alignment reference frame
\r
914 public int getAlignmentOrigin()
\r
920 * compute a deletion map for the current view according to the given
\r
924 * (as returned from SequenceI.gapMap())
\r
925 * @return int[] {intersection of visible regions with gapMap)
\r
927 public int[] getVisibleContigMapFor(int[] gapMap)
\r
929 int[] delMap = null;
\r
930 int[] viscontigs = getVisibleContigs();
\r
933 if (viscontigs != null)
\r
935 // viscontigs maps from a subset of the gapMap to the gapMap, so it will
\r
936 // always be equal to or shorter than gapMap
\r
937 delMap = new int[gapMap.length];
\r
938 for (int contig = 0; contig < viscontigs.length; contig += 2)
\r
941 while (spos < gapMap.length && gapMap[spos] < viscontigs[contig])
\r
945 while (spos < gapMap.length
\r
946 && gapMap[spos] <= viscontigs[contig + 1])
\r
948 delMap[i++] = spos++;
\r
951 int tmap[] = new int[i];
\r
952 System.arraycopy(delMap, 0, tmap, 0, i);
\r
959 * apply the getSeq(gc) method to each sequence cigar, and return the array of
\r
960 * edited sequences, optionally with hidden regions removed.
\r
963 * gap character to use for insertions
\r
965 * remove hidden regions from sequences. Note: currently implemented
\r
966 * in a memory inefficient way - space needed is 2*result set for
\r
969 * @return SequenceI[]
\r
971 public SequenceI[] getEditedSequences(char gc, boolean delete)
\r
973 SeqCigar[] msf = getSequences();
\r
974 SequenceI[] aln = new SequenceI[msf.length];
\r
975 for (int i = 0, j = msf.length; i < j; i++)
\r
977 aln[i] = msf[i].getSeq(gc);
\r
981 String[] sqs = getSequenceStrings(gc);
\r
982 for (int i = 0; i < sqs.length; i++)
\r
984 aln[i].setSequence(sqs[i]);
\r
991 public static void summariseAlignmentView(AlignmentView view,
\r
994 os.print("View has " + view.sequences.length + " of which ");
\r
995 if (view.selected == null) {
\r
998 os.print(" "+view.selected.size());
\r
1000 os.println(" are selected.");
\r
1001 os.print("View is " + view.getWidth() + " columns wide");
\r
1003 int[] contigs = view.getContigs();
\r
1004 if (contigs != null)
\r
1006 viswid = view.width;
\r
1007 for (int i = 0; i < contigs.length; i += 3)
\r
1009 viswid += contigs[i + 2];
\r
1011 os.println("with " + viswid + " visible columns spread over "
\r
1012 + contigs.length / 3 + " regions.");
\r
1016 viswid = view.width;
\r
1019 if (view.scGroups != null)
\r
1021 os.println("There are " + view.scGroups.size()
\r
1022 + " groups defined on the view.");
\r
1023 for (int g = 0; g < view.scGroups.size(); g++)
\r
1025 ScGroup sgr = (ScGroup) view.scGroups.elementAt(g);
\r
1026 os.println("Group " + g + ": Name = " + sgr.sg.getName()
\r
1027 + " Contains " + sgr.seqs.size() + " Seqs.");
\r
1028 os.println("This group runs from " + sgr.sg.getStartRes() + " to "
\r
1029 + sgr.sg.getEndRes());
\r
1030 for (int s = 0; s < sgr.seqs.size(); s++)
\r
1032 if (!((SeqCigar) sgr.seqs.elementAt(s)).isMemberOf(sgr))
\r
1034 os.println("** WARNING: sequence "
\r
1035 + ((SeqCigar) sgr.seqs.elementAt(s)).toString()
\r
1036 + " is not marked as member of group.");
\r
1040 AlignmentI visal = view.getVisibleAlignment('-');
\r
1041 if (visal != null)
\r
1043 os.println("Vis. alignment is " + visal.getWidth()
\r
1044 + " wide and has " + visal.getHeight() + " seqs.");
\r
1045 if (visal.getGroups() != null && visal.getGroups().size() > 0)
\r
1049 for (SequenceGroup sg:visal.getGroups())
\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