X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FColumnSelection.java;h=d0fc9277f5c5bbda923b5b7f0acc4d695c5f11de;hb=797df64fa2a0a30773d0f48f5494d4155e5a8be3;hp=afa2e07103b168f6a73756ecb62f44240c1aebdd;hpb=4bc692b7e0ccca12c362bcb6ee9b4c88f431bd22;p=jalview.git diff --git a/src/jalview/datamodel/ColumnSelection.java b/src/jalview/datamodel/ColumnSelection.java index afa2e07..d0fc927 100644 --- a/src/jalview/datamodel/ColumnSelection.java +++ b/src/jalview/datamodel/ColumnSelection.java @@ -1,20 +1,19 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1) - * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7) + * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. + * This file is part of Jalview. * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with Jalview. If not, see . */ package jalview.datamodel; @@ -509,8 +508,9 @@ public class ColumnSelection } /** - * Use this method to find out where a visible column is in the alignment when - * hidden columns exist + * Use this method to find out where a column will appear in the visible + * alignment when hidden columns exist. If the column is not visible, then the + * left-most visible column will always be returned. * * @param hiddenColumn * int @@ -522,21 +522,21 @@ public class ColumnSelection if (hiddenColumns != null) { int index = 0; - int gaps = 0; + int[] region; do { - int[] region = (int[]) hiddenColumns.elementAt(index); + region = (int[]) hiddenColumns.elementAt(index++); if (hiddenColumn > region[1]) { result -= region[1] + 1 - region[0]; } - index++; - } while (index < hiddenColumns.size()); - - result -= gaps; + } while ((hiddenColumn > region[1]) && (index < hiddenColumns.size())); + if (hiddenColumn > region[0] && hiddenColumn < region[1]) + { + return region[0] + hiddenColumn - result; + } } - - return result; + return result; // return the shifted position after removing hidden columns. } /** @@ -1060,7 +1060,9 @@ public class ColumnSelection } /** - * add in any unselected columns from the given column selection, excluding any that are hidden. + * add in any unselected columns from the given column selection, excluding + * any that are hidden. + * * @param colsel */ public void addElementsFrom(ColumnSelection colsel) @@ -1071,7 +1073,8 @@ public class ColumnSelection while (e.hasMoreElements()) { Object eo = e.nextElement(); - if (hiddenColumns!=null && isVisible(((Integer) eo).intValue())) { + if (hiddenColumns != null && isVisible(((Integer) eo).intValue())) + { if (!selected.contains(eo)) { selected.addElement(eo); @@ -1080,27 +1083,163 @@ public class ColumnSelection } } } -/** - * set the selected columns the given column selection, excluding any columns that are hidden. - * @param colsel - */ + + /** + * set the selected columns the given column selection, excluding any columns + * that are hidden. + * + * @param colsel + */ public void setElementsFrom(ColumnSelection colsel) { + selected = new Vector(); if (colsel.selected != null && colsel.selected.size() > 0) { - if (hiddenColumns!=null && hiddenColumns.size()>0) + if (hiddenColumns != null && hiddenColumns.size() > 0) { // only select visible columns in this columns selection selected = new Vector(); addElementsFrom(colsel); - } else { - // be quick - selected = new Vector(colsel.selected); + } + else + { + // add everything regardless + Enumeration en = colsel.selected.elements(); + while (en.hasMoreElements()) + { + selected.addElement(en.nextElement()); + } } } - else + } + + /** + * Add gaps into the sequences aligned to profileseq under the given + * AlignmentView + * + * @param profileseq + * @param al - alignment to have gaps inserted into it + * @param input - alignment view where sequence corresponding to profileseq is first entry + * @return new Column selection for new alignment view, with insertions into profileseq marked as hidden. + */ + public static ColumnSelection propagateInsertions(SequenceI profileseq, + Alignment al, AlignmentView input) + { + int profsqpos=0; + +// return propagateInsertions(profileseq, al, ) + char gc = al.getGapCharacter(); + Object[] alandcolsel = input.getAlignmentAndColumnSelection(gc); + ColumnSelection nview = (ColumnSelection) alandcolsel[1]; + SequenceI origseq = ((SequenceI[]) alandcolsel[0])[profsqpos]; + nview.propagateInsertions(profileseq, + al, origseq); + return nview; + } + /** + * + * @param profileseq - sequence in al which corresponds to origseq + * @param al - alignment which is to have gaps inserted into it + * @param origseq - sequence corresponding to profileseq which defines gap map for modifying al + */ + public void propagateInsertions(SequenceI profileseq, AlignmentI al, SequenceI origseq) + { + char gc = al.getGapCharacter(); + // recover mapping between sequence's non-gap positions and positions + // mapping to view. + pruneDeletions(ShiftList + .parseMap(origseq + .gapMap())); + int[] viscontigs = getVisibleContigs(0, profileseq.getLength()); + int spos = 0; + int offset = 0; + // input.pruneDeletions(ShiftList.parseMap(((SequenceI[]) + // alandcolsel[0])[0].gapMap())) + // add profile to visible contigs + for (int v = 0; v < viscontigs.length; v += 2) { - selected = new Vector(); + if (viscontigs[v] > spos) + { + StringBuffer sb = new StringBuffer(); + for (int s = 0, ns = viscontigs[v] - spos; s < ns; s++) + { + sb.append(gc); + } + for (int s = 0, ns = al.getHeight(); s < ns; s++) + { + SequenceI sqobj = al.getSequenceAt(s); + if (sqobj != profileseq) + { + String sq = al.getSequenceAt(s).getSequenceAsString(); + if (sq.length() <= spos + offset) + { + // pad sequence + int diff = spos + offset - sq.length() - 1; + if (diff > 0) + { + // pad gaps + sq = sq + sb; + while ((diff = spos + offset - sq.length() - 1) > 0) + { + //sq = sq + // + ((diff >= sb.length()) ? sb.toString() : sb + // .substring(0, diff)); + if (diff>=sb.length()) { + sq+=sb.toString(); + } else { + char[] buf = new char[diff]; + sb.getChars(0, diff, buf, 0); + sq+=buf.toString(); + } + } + } + sq += sb.toString(); + } + else + { + al.getSequenceAt(s).setSequence( + sq.substring(0, spos + offset) + sb.toString() + + sq.substring(spos + offset)); + } + } + } + // offset+=sb.length(); + } + spos = viscontigs[v + 1] + 1; + } + if ((offset + spos) < profileseq.getLength()) + { + // pad the final region with gaps. + StringBuffer sb = new StringBuffer(); + for (int s = 0, ns = profileseq.getLength() - spos - offset; s < ns; s++) + { + sb.append(gc); + } + for (int s = 0, ns = al.getHeight(); s < ns; s++) + { + SequenceI sqobj = al.getSequenceAt(s); + if (sqobj==profileseq) + { + continue; + } + String sq = sqobj.getSequenceAsString(); + // pad sequence + int diff = origseq.getLength() - sq.length(); + while (diff > 0) + { + //sq = sq + // + ((diff >= sb.length()) ? sb.toString() : sb + // .substring(0, diff)); + if (diff>=sb.length()) { + sq+=sb.toString(); + } else { + char[] buf = new char[diff]; + sb.getChars(0, diff, buf, 0); + sq+=buf.toString(); + } + diff = origseq.getLength() - sq.length(); + } + } } } }