From cfb555030705793c96221979835a7ef8e3d49e9d Mon Sep 17 00:00:00 2001 From: hansonr Date: Mon, 28 Jan 2019 21:20:51 -0600 Subject: [PATCH] experiment using a register buffer instead of creating thousands of int[]. Turns out, it's no diffent in Chrome. --- unused/AlignmentAnnotation.java | 1718 +++++++++++++++++++++++++++++++++++++++ unused/MapList.java | 1286 +++++++++++++++++++++++++++++ unused/Mapping.java | 752 +++++++++++++++++ 3 files changed, 3756 insertions(+) create mode 100644 unused/AlignmentAnnotation.java create mode 100644 unused/MapList.java create mode 100644 unused/Mapping.java diff --git a/unused/AlignmentAnnotation.java b/unused/AlignmentAnnotation.java new file mode 100644 index 0000000..e9ca0c4 --- /dev/null +++ b/unused/AlignmentAnnotation.java @@ -0,0 +1,1718 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors + * + * This file is part of Jalview. + * + * 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. + * + * 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 . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ +package jalview.datamodel; + +import jalview.analysis.Rna; +import jalview.analysis.SecStrConsensus.SimpleBP; +import jalview.analysis.WUSSParseException; +import jalview.util.MapList; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +/** + * DOCUMENT ME! + * + * @author $author$ + * @version $Revision$ + */ +public class AlignmentAnnotation +{ + private static final String ANNOTATION_ID_PREFIX = "ann"; + + /* + * Identifers for different types of profile data + */ + public static final int SEQUENCE_PROFILE = 0; + + public static final int STRUCTURE_PROFILE = 1; + + public static final int CDNA_PROFILE = 2; + + private static long counter = 0; + + /** + * If true, this annotations is calculated every edit, eg consensus, quality + * or conservation graphs + */ + public boolean autoCalculated = false; + + /** + * unique ID for this annotation, used to match up the same annotation row + * shown in multiple views and alignments + */ + public String annotationId; + + /** + * the sequence this annotation is associated with (or null) + */ + public SequenceI sequenceRef; + + /** label shown in dropdown menus and in the annotation label area */ + public String label; + + /** longer description text shown as a tooltip */ + public String description; + + /** Array of annotations placed in the current coordinate system */ + public Annotation[] annotations; + + public List bps = null; + + /** + * RNA secondary structure contact positions + */ + public SequenceFeature[] _rnasecstr = null; + + /** + * position of annotation resulting in invalid WUSS parsing or -1. -2 means + * there was no RNA structure in this annotation + */ + private long invalidrnastruc = -2; + + /** + * Updates the _rnasecstr field Determines the positions that base pair and + * the positions of helices based on secondary structure from a Stockholm file + * + * @param rnaAnnotation + */ + private void _updateRnaSecStr(CharSequence rnaAnnotation) + { + try + { + _rnasecstr = Rna.getHelixMap(rnaAnnotation); + invalidrnastruc = -1; + } catch (WUSSParseException px) + { + // DEBUG System.out.println(px); + invalidrnastruc = px.getProblemPos(); + } + if (invalidrnastruc > -1) + { + return; + } + + if (_rnasecstr != null && _rnasecstr.length > 0) + { + // show all the RNA secondary structure annotation symbols. + isrna = true; + showAllColLabels = true; + scaleColLabel = true; + _markRnaHelices(); + } + // System.out.println("featuregroup " + _rnasecstr[0].getFeatureGroup()); + + } + + private void _markRnaHelices() + { + int mxval = 0; + // Figure out number of helices + // Length of rnasecstr is the number of pairs of positions that base pair + // with each other in the secondary structure + for (int x = 0; x < _rnasecstr.length; x++) + { + + /* + * System.out.println(this.annotation._rnasecstr[x] + " Begin" + + * this.annotation._rnasecstr[x].getBegin()); + */ + // System.out.println(this.annotation._rnasecstr[x].getFeatureGroup()); + int val = 0; + try + { + val = Integer.valueOf(_rnasecstr[x].getFeatureGroup()); + if (mxval < val) + { + mxval = val; + } + } catch (NumberFormatException q) + { + } + ; + + annotations[_rnasecstr[x].getBegin()].value = val; + annotations[_rnasecstr[x].getEnd()].value = val; + + // annotations[_rnasecstr[x].getBegin()].displayCharacter = "" + val; + // annotations[_rnasecstr[x].getEnd()].displayCharacter = "" + val; + } + setScore(mxval); + } + + /** + * Get the RNA Secondary Structure SequenceFeature Array if present + */ + public SequenceFeature[] getRnaSecondaryStructure() + { + return this._rnasecstr; + } + + /** + * Check the RNA Secondary Structure is equivalent to one in given + * AlignmentAnnotation param + */ + public boolean rnaSecondaryStructureEquivalent(AlignmentAnnotation that) + { + return rnaSecondaryStructureEquivalent(that, true); + } + + public boolean rnaSecondaryStructureEquivalent(AlignmentAnnotation that, boolean compareType) + { + SequenceFeature[] thisSfArray = this.getRnaSecondaryStructure(); + SequenceFeature[] thatSfArray = that.getRnaSecondaryStructure(); + if (thisSfArray == null || thatSfArray == null) + { + return thisSfArray == null && thatSfArray == null; + } + if (thisSfArray.length != thatSfArray.length) + { + return false; + } + Arrays.sort(thisSfArray, new SFSortByEnd()); // probably already sorted + // like this + Arrays.sort(thatSfArray, new SFSortByEnd()); // probably already sorted + // like this + for (int i=0; i < thisSfArray.length; i++) { + SequenceFeature thisSf = thisSfArray[i]; + SequenceFeature thatSf = thatSfArray[i]; + if (compareType) { + if (thisSf.getType() == null || thatSf.getType() == null) { + if (thisSf.getType() == null && thatSf.getType() == null) { + continue; + } else { + return false; + } + } + if (! thisSf.getType().equals(thatSf.getType())) { + return false; + } + } + if (!(thisSf.getBegin() == thatSf.getBegin() + && thisSf.getEnd() == thatSf.getEnd())) + { + return false; + } + } + return true; + + } + + /** + * map of positions in the associated annotation + */ + private Map sequenceMapping; + + /** + * lower range for quantitative data + */ + public float graphMin; + + /** + * Upper range for quantitative data + */ + public float graphMax; + + /** + * Score associated with label and description. + */ + public double score = Double.NaN; + + /** + * flag indicating if annotation has a score. + */ + public boolean hasScore = false; + + public GraphLine threshold; + + // Graphical hints and tips + + /** Can this row be edited by the user ? */ + public boolean editable = false; + + /** Indicates if annotation has a graphical symbol track */ + public boolean hasIcons; // + + /** Indicates if annotation has a text character label */ + public boolean hasText; + + /** is the row visible */ + public boolean visible = true; + + public int graphGroup = -1; + + /** Displayed height of row in pixels */ + public int height = 0; + + public int graph = 0; + + public int graphHeight = 40; + + public boolean padGaps = false; + + public static final int NO_GRAPH = 0; + + public static final int BAR_GRAPH = 1; + + public static final int LINE_GRAPH = 2; + + public boolean belowAlignment = true; + + public SequenceGroup groupRef = null; + + /** + * display every column label, even if there is a row of identical labels + */ + public boolean showAllColLabels = false; + + /** + * scale the column label to fit within the alignment column. + */ + public boolean scaleColLabel = false; + + /** + * centre the column labels relative to the alignment column + */ + public boolean centreColLabels = false; + + private boolean isrna; + + public static int getGraphValueFromString(String string) + { + if (string.equalsIgnoreCase("BAR_GRAPH")) + { + return BAR_GRAPH; + } + else if (string.equalsIgnoreCase("LINE_GRAPH")) + { + return LINE_GRAPH; + } + else + { + return NO_GRAPH; + } + } + + /** + * Creates a new AlignmentAnnotation object. + * + * @param label + * short label shown under sequence labels + * @param description + * text displayed on mouseover + * @param annotations + * set of positional annotation elements + */ + public AlignmentAnnotation(String label, String description, + Annotation[] annotations) + { + setAnnotationId(); + // always editable? + editable = true; + this.label = label; + this.description = description; + this.annotations = annotations; + + validateRangeAndDisplay(); + } + + /** + * Checks if annotation labels represent secondary structures + * + */ + void areLabelsSecondaryStructure() + { + boolean nonSSLabel = false; + isrna = false; + StringBuffer rnastring = new StringBuffer(); + + char firstChar = 0; + for (int i = 0; i < annotations.length; i++) + { + // DEBUG System.out.println(i + ": " + annotations[i]); + if (annotations[i] == null) + { + continue; + } + if (annotations[i].secondaryStructure == 'H' + || annotations[i].secondaryStructure == 'E') + { + // DEBUG System.out.println( "/H|E/ '" + + // annotations[i].secondaryStructure + "'"); + hasIcons |= true; + } + else + // Check for RNA secondary structure + { + // DEBUG System.out.println( "/else/ '" + + // annotations[i].secondaryStructure + "'"); + // TODO: 2.8.2 should this ss symbol validation check be a function in + // RNA/ResidueProperties ? + if (annotations[i].secondaryStructure == '(' + || annotations[i].secondaryStructure == '[' + || annotations[i].secondaryStructure == '<' + || annotations[i].secondaryStructure == '{' + || annotations[i].secondaryStructure == 'A' + || annotations[i].secondaryStructure == 'B' + || annotations[i].secondaryStructure == 'C' + || annotations[i].secondaryStructure == 'D' + // || annotations[i].secondaryStructure == 'E' // ambiguous on + // its own -- already checked above + || annotations[i].secondaryStructure == 'F' + || annotations[i].secondaryStructure == 'G' + // || annotations[i].secondaryStructure == 'H' // ambiguous on + // its own -- already checked above + || annotations[i].secondaryStructure == 'I' + || annotations[i].secondaryStructure == 'J' + || annotations[i].secondaryStructure == 'K' + || annotations[i].secondaryStructure == 'L' + || annotations[i].secondaryStructure == 'M' + || annotations[i].secondaryStructure == 'N' + || annotations[i].secondaryStructure == 'O' + || annotations[i].secondaryStructure == 'P' + || annotations[i].secondaryStructure == 'Q' + || annotations[i].secondaryStructure == 'R' + || annotations[i].secondaryStructure == 'S' + || annotations[i].secondaryStructure == 'T' + || annotations[i].secondaryStructure == 'U' + || annotations[i].secondaryStructure == 'V' + || annotations[i].secondaryStructure == 'W' + || annotations[i].secondaryStructure == 'X' + || annotations[i].secondaryStructure == 'Y' + || annotations[i].secondaryStructure == 'Z') + { + hasIcons |= true; + isrna |= true; + } + } + + // System.out.println("displaychar " + annotations[i].displayCharacter); + + if (annotations[i].displayCharacter == null + || annotations[i].displayCharacter.length() == 0) + { + rnastring.append('.'); + continue; + } + if (annotations[i].displayCharacter.length() == 1) + { + firstChar = annotations[i].displayCharacter.charAt(0); + // check to see if it looks like a sequence or is secondary structure + // labelling. + if (annotations[i].secondaryStructure != ' ' && !hasIcons && + // Uncomment to only catch case where + // displayCharacter==secondary + // Structure + // to correctly redisplay SS annotation imported from Stockholm, + // exported to JalviewXML and read back in again. + // && + // annotations[i].displayCharacter.charAt(0)==annotations[i].secondaryStructure + firstChar != ' ' && firstChar != '$' && firstChar != 0xCE + && firstChar != '(' && firstChar != '[' && firstChar != '<' + && firstChar != '{' && firstChar != 'A' && firstChar != 'B' + && firstChar != 'C' && firstChar != 'D' && firstChar != 'E' + && firstChar != 'F' && firstChar != 'G' && firstChar != 'H' + && firstChar != 'I' && firstChar != 'J' && firstChar != 'K' + && firstChar != 'L' && firstChar != 'M' && firstChar != 'N' + && firstChar != 'O' && firstChar != 'P' && firstChar != 'Q' + && firstChar != 'R' && firstChar != 'S' && firstChar != 'T' + && firstChar != 'U' && firstChar != 'V' && firstChar != 'W' + && firstChar != 'X' && firstChar != 'Y' && firstChar != 'Z' + && firstChar != '-' + && firstChar < jalview.schemes.ResidueProperties.aaIndex.length) + { + if (jalview.schemes.ResidueProperties.aaIndex[firstChar] < 23) // TODO: + // parameterise + // to + // gap + // symbol + // number + { + nonSSLabel = true; + } + } + } + else + { + rnastring.append(annotations[i].displayCharacter.charAt(1)); + } + + if (annotations[i].displayCharacter.length() > 0) + { + hasText = true; + } + } + + if (nonSSLabel) + { + hasIcons = false; + for (int j = 0; j < annotations.length; j++) + { + if (annotations[j] != null + && annotations[j].secondaryStructure != ' ') + { + annotations[j].displayCharacter = String + .valueOf(annotations[j].secondaryStructure); + annotations[j].secondaryStructure = ' '; + } + + } + } + else + { + if (isrna) + { + _updateRnaSecStr(new AnnotCharSequence()); + } + } + } + + /** + * flyweight access to positions in the alignment annotation row for RNA + * processing + * + * @author jimp + * + */ + private class AnnotCharSequence implements CharSequence + { + int offset = 0; + + int max = 0; + + public AnnotCharSequence() + { + this(0, annotations.length); + } + + AnnotCharSequence(int start, int end) + { + offset = start; + max = end; + } + + @Override + public CharSequence subSequence(int start, int end) + { + return new AnnotCharSequence(offset + start, offset + end); + } + + @Override + public int length() + { + return max - offset; + } + + @Override + public char charAt(int index) + { + return ((index + offset < 0) || (index + offset) >= max + || annotations[index + offset] == null + || (annotations[index + offset].secondaryStructure <= ' ') + ? ' ' + : annotations[index + offset].displayCharacter == null + || annotations[index + + offset].displayCharacter + .length() == 0 + ? annotations[index + + offset].secondaryStructure + : annotations[index + + offset].displayCharacter + .charAt(0)); + } + + @Override + public String toString() + { + char[] string = new char[max - offset]; + int mx = annotations.length; + + for (int i = offset; i < mx; i++) + { + string[i] = (annotations[i] == null + || (annotations[i].secondaryStructure <= 32)) + ? ' ' + : (annotations[i].displayCharacter == null + || annotations[i].displayCharacter + .length() == 0 + ? annotations[i].secondaryStructure + : annotations[i].displayCharacter + .charAt(0)); + } + return new String(string); + } + }; + + private long _lastrnaannot = -1; + + public String getRNAStruc() + { + if (isrna) + { + String rnastruc = new AnnotCharSequence().toString(); + if (_lastrnaannot != rnastruc.hashCode()) + { + // ensure rna structure contacts are up to date + _lastrnaannot = rnastruc.hashCode(); + _updateRnaSecStr(rnastruc); + } + return rnastruc; + } + return null; + } + + /** + * Creates a new AlignmentAnnotation object. + * + * @param label + * DOCUMENT ME! + * @param description + * DOCUMENT ME! + * @param annotations + * DOCUMENT ME! + * @param min + * DOCUMENT ME! + * @param max + * DOCUMENT ME! + * @param winLength + * DOCUMENT ME! + */ + public AlignmentAnnotation(String label, String description, + Annotation[] annotations, float min, float max, int graphType) + { + setAnnotationId(); + // graphs are not editable + editable = graphType == 0; + + this.label = label; + this.description = description; + this.annotations = annotations; + graph = graphType; + graphMin = min; + graphMax = max; + validateRangeAndDisplay(); + } + + /** + * checks graphMin and graphMax, secondary structure symbols, sets graphType + * appropriately, sets null labels to the empty string if appropriate. + */ + public void validateRangeAndDisplay() + { + + if (annotations == null) + { + visible = false; // try to prevent renderer from displaying. + invalidrnastruc = -1; + return; // this is a non-annotation row annotation - ie a sequence score. + } + + int graphType = graph; + float min = graphMin; + float max = graphMax; + boolean drawValues = true; + _linecolour = null; + if (min == max) + { + min = 999999999; + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] == null) + { + continue; + } + + if (drawValues && annotations[i].displayCharacter != null + && annotations[i].displayCharacter.length() > 1) + { + drawValues = false; + } + + if (annotations[i].value > max) + { + max = annotations[i].value; + } + + if (annotations[i].value < min) + { + min = annotations[i].value; + } + if (_linecolour == null && annotations[i].colour != null) + { + _linecolour = annotations[i].colour; + } + } + // ensure zero is origin for min/max ranges on only one side of zero + if (min > 0) + { + min = 0; + } + else + { + if (max < 0) + { + max = 0; + } + } + } + + graphMin = min; + graphMax = max; + + areLabelsSecondaryStructure(); + + if (!drawValues && graphType != NO_GRAPH) + { + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] != null) + { + annotations[i].displayCharacter = ""; + } + } + } + } + + /** + * Copy constructor creates a new independent annotation row with the same + * associated sequenceRef + * + * @param annotation + */ + public AlignmentAnnotation(AlignmentAnnotation annotation) + { + setAnnotationId(); + this.label = new String(annotation.label); + if (annotation.description != null) + { + this.description = new String(annotation.description); + } + this.graphMin = annotation.graphMin; + this.graphMax = annotation.graphMax; + this.graph = annotation.graph; + this.graphHeight = annotation.graphHeight; + this.graphGroup = annotation.graphGroup; + this.groupRef = annotation.groupRef; + this.editable = annotation.editable; + this.autoCalculated = annotation.autoCalculated; + this.hasIcons = annotation.hasIcons; + this.hasText = annotation.hasText; + this.height = annotation.height; + this.label = annotation.label; + this.padGaps = annotation.padGaps; + this.visible = annotation.visible; + this.centreColLabels = annotation.centreColLabels; + this.scaleColLabel = annotation.scaleColLabel; + this.showAllColLabels = annotation.showAllColLabels; + this.calcId = annotation.calcId; + if (annotation.properties != null) + { + properties = new HashMap<>(); + for (Map.Entry val : annotation.properties.entrySet()) + { + properties.put(val.getKey(), val.getValue()); + } + } + if (this.hasScore = annotation.hasScore) + { + this.score = annotation.score; + } + if (annotation.threshold != null) + { + threshold = new GraphLine(annotation.threshold); + } + Annotation[] ann = annotation.annotations; + if (annotation.annotations != null) + { + this.annotations = new Annotation[ann.length]; + for (int i = 0; i < ann.length; i++) + { + if (ann[i] != null) + { + annotations[i] = new Annotation(ann[i]); + if (_linecolour != null) + { + _linecolour = annotations[i].colour; + } + } + } + } + if (annotation.sequenceRef != null) + { + this.sequenceRef = annotation.sequenceRef; + if (annotation.sequenceMapping != null) + { + Integer p = null; + sequenceMapping = new HashMap<>(); + Iterator pos = annotation.sequenceMapping.keySet() + .iterator(); + while (pos.hasNext()) + { + // could optimise this! + p = pos.next(); + Annotation a = annotation.sequenceMapping.get(p); + if (a == null) + { + continue; + } + if (ann != null) + { + for (int i = 0; i < ann.length; i++) + { + if (ann[i] == a) + { + sequenceMapping.put(p, annotations[i]); + } + } + } + } + } + else + { + this.sequenceMapping = null; + } + } + // TODO: check if we need to do this: JAL-952 + // if (this.isrna=annotation.isrna) + { + // _rnasecstr=new SequenceFeature[annotation._rnasecstr]; + } + validateRangeAndDisplay(); // construct hashcodes, etc. + } + + /** + * clip the annotation to the columns given by startRes and endRes (inclusive) + * and prune any existing sequenceMapping to just those columns. + * + * @param startRes + * @param endRes + */ + public void restrict(int startRes, int endRes) + { + if (annotations == null) + { + // non-positional + return; + } + if (startRes < 0) + { + startRes = 0; + } + if (startRes >= annotations.length) + { + startRes = annotations.length - 1; + } + if (endRes >= annotations.length) + { + endRes = annotations.length - 1; + } + if (annotations == null) + { + return; + } + Annotation[] temp = new Annotation[endRes - startRes + 1]; + if (startRes < annotations.length) + { + System.arraycopy(annotations, startRes, temp, 0, + endRes - startRes + 1); + } + if (sequenceRef != null) + { + // Clip the mapping, if it exists. + int spos = sequenceRef.findPosition(startRes); + int epos = sequenceRef.findPosition(endRes); + if (sequenceMapping != null) + { + Map newmapping = new HashMap<>(); + Iterator e = sequenceMapping.keySet().iterator(); + while (e.hasNext()) + { + Integer pos = e.next(); + if (pos.intValue() >= spos && pos.intValue() <= epos) + { + newmapping.put(pos, sequenceMapping.get(pos)); + } + } + sequenceMapping.clear(); + sequenceMapping = newmapping; + } + } + annotations = temp; + } + + /** + * set the annotation row to be at least length Annotations + * + * @param length + * minimum number of columns required in the annotation row + * @return false if the annotation row is greater than length + */ + public boolean padAnnotation(int length) + { + if (annotations == null) + { + return true; // annotation row is correct - null == not visible and + // undefined length + } + if (annotations.length < length) + { + Annotation[] na = new Annotation[length]; + System.arraycopy(annotations, 0, na, 0, annotations.length); + annotations = na; + return true; + } + return annotations.length > length; + + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + @Override + public String toString() + { + if (annotations == null) + { + return ""; + } + StringBuilder buffer = new StringBuilder(256); + + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] != null) + { + if (graph != 0) + { + buffer.append(annotations[i].value); + } + else if (hasIcons) + { + buffer.append(annotations[i].secondaryStructure); + } + else + { + buffer.append(annotations[i].displayCharacter); + } + } + + buffer.append(", "); + } + // TODO: remove disgusting hack for 'special' treatment of consensus line. + if (label.indexOf("Consensus") == 0) + { + buffer.append("\n"); + + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] != null) + { + buffer.append(annotations[i].description); + } + + buffer.append(", "); + } + } + + return buffer.toString(); + } + + public void setThreshold(GraphLine line) + { + threshold = line; + } + + public GraphLine getThreshold() + { + return threshold; + } + + /** + * Attach the annotation to seqRef, starting from startRes position. If + * alreadyMapped is true then the indices of the annotation[] array are + * sequence positions rather than alignment column positions. + * + * @param seqRef + * @param startRes + * @param alreadyMapped + */ + public void createSequenceMapping(SequenceI seqRef, int startRes, + boolean alreadyMapped) + { + + if (seqRef == null) + { + return; + } + sequenceRef = seqRef; + if (annotations == null) + { + return; + } + sequenceMapping = new HashMap<>(); + + int seqPos; + + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] != null) + { + if (alreadyMapped) + { + seqPos = seqRef.findPosition(i); + } + else + { + seqPos = i + startRes; + } + + sequenceMapping.put(new Integer(seqPos), annotations[i]); + } + } + + } + + /** + * When positional annotation and a sequence reference is present, clears and + * resizes the annotations array to the current alignment width, and adds + * annotation according to aligned positions of the sequenceRef given by + * sequenceMapping. + */ + public void adjustForAlignment() + { + if (sequenceRef == null) + { + return; + } + + if (annotations == null) + { + return; + } + + int a = 0, aSize = sequenceRef.getLength(); + + if (aSize == 0) + { + // Its been deleted + return; + } + + int position; + Annotation[] temp = new Annotation[aSize]; + Integer index; + if (sequenceMapping != null) + { + for (a = sequenceRef.getStart(); a <= sequenceRef.getEnd(); a++) + { + index = new Integer(a); + Annotation annot = sequenceMapping.get(index); + if (annot != null) + { + position = sequenceRef.findIndex(a) - 1; + + temp[position] = annot; + } + } + } + annotations = temp; + } + + /** + * remove any null entries in annotation row and return the number of non-null + * annotation elements. + * + * @return + */ + public int compactAnnotationArray() + { + int i = 0, iSize = annotations.length; + while (i < iSize) + { + if (annotations[i] == null) + { + if (i + 1 < iSize) + { + System.arraycopy(annotations, i + 1, annotations, i, + iSize - i - 1); + } + iSize--; + } + else + { + i++; + } + } + Annotation[] ann = annotations; + annotations = new Annotation[i]; + System.arraycopy(ann, 0, annotations, 0, i); + ann = null; + return iSize; + } + + /** + * Associate this annotation with the aligned residues of a particular + * sequence. sequenceMapping will be updated in the following way: null + * sequenceI - existing mapping will be discarded but annotations left in + * mapped positions. valid sequenceI not equal to current sequenceRef: mapping + * is discarded and rebuilt assuming 1:1 correspondence TODO: overload with + * parameter to specify correspondence between current and new sequenceRef + * + * @param sequenceI + */ + public void setSequenceRef(SequenceI sequenceI) + { + if (sequenceI != null) + { + if (sequenceRef != null) + { + boolean rIsDs = sequenceRef.getDatasetSequence() == null, + tIsDs = sequenceI.getDatasetSequence() == null; + if (sequenceRef != sequenceI + && (rIsDs && !tIsDs + && sequenceRef != sequenceI.getDatasetSequence()) + && (!rIsDs && tIsDs + && sequenceRef.getDatasetSequence() != sequenceI) + && (!rIsDs && !tIsDs + && sequenceRef.getDatasetSequence() != sequenceI + .getDatasetSequence()) + && !sequenceRef.equals(sequenceI)) + { + // if sequenceRef isn't intersecting with sequenceI + // throw away old mapping and reconstruct. + sequenceRef = null; + if (sequenceMapping != null) + { + sequenceMapping = null; + // compactAnnotationArray(); + } + createSequenceMapping(sequenceI, 1, true); + adjustForAlignment(); + } + else + { + // Mapping carried over + sequenceRef = sequenceI; + } + } + else + { + // No mapping exists + createSequenceMapping(sequenceI, 1, true); + adjustForAlignment(); + } + } + else + { + // throw away the mapping without compacting. + sequenceMapping = null; + sequenceRef = null; + } + } + + /** + * @return the score + */ + public double getScore() + { + return score; + } + + /** + * @param score + * the score to set + */ + public void setScore(double score) + { + hasScore = true; + this.score = score; + } + + /** + * + * @return true if annotation has an associated score + */ + public boolean hasScore() + { + return hasScore || !Double.isNaN(score); + } + + /** + * Score only annotation + * + * @param label + * @param description + * @param score + */ + public AlignmentAnnotation(String label, String description, double score) + { + this(label, description, null); + setScore(score); + } + + /** + * copy constructor with edit based on the hidden columns marked in colSel + * + * @param alignmentAnnotation + * @param colSel + */ + public AlignmentAnnotation(AlignmentAnnotation alignmentAnnotation, + HiddenColumns hidden) + { + this(alignmentAnnotation); + if (annotations == null) + { + return; + } + makeVisibleAnnotation(hidden); + } + + public void setPadGaps(boolean padgaps, char gapchar) + { + this.padGaps = padgaps; + if (padgaps) + { + hasText = true; + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] == null) + { + annotations[i] = new Annotation(String.valueOf(gapchar), null, + ' ', 0f, null); + } + else if (annotations[i].displayCharacter == null + || annotations[i].displayCharacter.equals(" ")) + { + annotations[i].displayCharacter = String.valueOf(gapchar); + } + } + } + } + + /** + * format description string for display + * + * @param seqname + * @return Get the annotation description string optionally prefixed by + * associated sequence name (if any) + */ + public String getDescription(boolean seqname) + { + if (seqname && this.sequenceRef != null) + { + int i = description.toLowerCase().indexOf(""); + if (i > -1) + { + // move the html tag to before the sequence reference. + return "" + sequenceRef.getName() + " : " + + description.substring(i + 6); + } + return sequenceRef.getName() + " : " + description; + } + return description; + } + + public boolean isValidStruc() + { + return invalidrnastruc == -1; + } + + public long getInvalidStrucPos() + { + return invalidrnastruc; + } + + /** + * machine readable ID string indicating what generated this annotation + */ + protected String calcId = ""; + + /** + * properties associated with the calcId + */ + protected Map properties = new HashMap<>(); + + /** + * base colour for line graphs. If null, will be set automatically by + * searching the alignment annotation + */ + public java.awt.Color _linecolour; + + public String getCalcId() + { + return calcId; + } + + public void setCalcId(String calcId) + { + this.calcId = calcId; + } + + public boolean isRNA() + { + return isrna; + } + + /** + * transfer annotation to the given sequence using the given mapping from the + * current positions or an existing sequence mapping + * + * @param sq + * @param sp2sq + * map involving sq as To or From + */ + public void liftOver(SequenceI sq, Mapping sp2sq) + { + if (sp2sq.getMappedWidth() != sp2sq.getWidth()) + { + // TODO: employ getWord/MappedWord to transfer annotation between cDNA and + // Protein reference frames + throw new Error( + "liftOver currently not implemented for transfer of annotation between different types of seqeunce"); + } + boolean mapIsTo = (sp2sq != null) + ? (sp2sq.getTo() == sq + || sp2sq.getTo() == sq.getDatasetSequence()) + : false; + + // TODO build a better annotation element map and get rid of annotations[] + Map mapForsq = new HashMap<>(); + if (sequenceMapping != null) + { + if (sp2sq != null) + { + int[] reg = new int[MapList.LEN]; + for (Entry ie : sequenceMapping.entrySet()) + { + reg[MapList.POS] = ie.getKey(); + int mpos = sp2sq.getPosition(reg, mapIsTo); + if (mpos >= sq.getStart() && mpos <= sq.getEnd()) + { + mapForsq.put(mpos, ie.getValue()); + } + } + sequenceMapping = mapForsq; + sequenceRef = sq; + adjustForAlignment(); + } + else + { + // trim positions + } + } + } + + /** + * like liftOver but more general. + * + * Takes an array of int pairs that will be used to update the internal + * sequenceMapping and so shuffle the annotated positions + * + * @param newref + * - new sequence reference for the annotation row - if null, + * sequenceRef is left unchanged + * @param mapping + * array of ints containing corresponding positions + * @param from + * - column for current coordinate system (-1 for index+1) + * @param to + * - column for destination coordinate system (-1 for index+1) + * @param idxoffset + * - offset added to index when referencing either coordinate system + * @note no checks are made as to whether from and/or to are sensible + * @note caller should add the remapped annotation to newref if they have not + * already + */ + public void remap(SequenceI newref, HashMap mapping, + int from, int to, int idxoffset) + { + if (mapping != null) + { + Map old = sequenceMapping; + Map remap = new HashMap<>(); + int index = -1; + for (int mp[] : mapping.values()) + { + if (index++ < 0) + { + continue; + } + Annotation ann = null; + if (from == -1) + { + ann = sequenceMapping.get(Integer.valueOf(idxoffset + index)); + } + else + { + if (mp != null && mp.length > from) + { + ann = sequenceMapping.get(Integer.valueOf(mp[from])); + } + } + if (ann != null) + { + if (to == -1) + { + remap.put(Integer.valueOf(idxoffset + index), ann); + } + else + { + if (to > -1 && to < mp.length) + { + remap.put(Integer.valueOf(mp[to]), ann); + } + } + } + } + sequenceMapping = remap; + old.clear(); + if (newref != null) + { + sequenceRef = newref; + } + adjustForAlignment(); + } + } + + public String getProperty(String property) + { + if (properties == null) + { + return null; + } + return properties.get(property); + } + + public void setProperty(String property, String value) + { + if (properties == null) + { + properties = new HashMap<>(); + } + properties.put(property, value); + } + + public boolean hasProperties() + { + return properties != null && properties.size() > 0; + } + + public Collection getProperties() + { + if (properties == null) + { + return Collections.emptyList(); + } + return properties.keySet(); + } + + /** + * Returns the Annotation for the given sequence position (base 1) if any, + * else null + * + * @param position + * @return + */ + public Annotation getAnnotationForPosition(int position) + { + return sequenceMapping == null ? null : sequenceMapping.get(position); + + } + + /** + * Set the id to "ann" followed by a counter that increments so as to be + * unique for the lifetime of the JVM + */ + protected final void setAnnotationId() + { + this.annotationId = ANNOTATION_ID_PREFIX + Long.toString(nextId()); + } + + /** + * Returns the match for the last unmatched opening RNA helix pair symbol + * preceding the given column, or '(' if nothing found to match. + * + * @param column + * @return + */ + public String getDefaultRnaHelixSymbol(int column) + { + String result = "("; + if (annotations == null) + { + return result; + } + + /* + * for each preceding column, if it contains an open bracket, + * count whether it is still unmatched at column, if so return its pair + * (likely faster than the fancy alternative using stacks) + */ + for (int col = column - 1; col >= 0; col--) + { + Annotation annotation = annotations[col]; + if (annotation == null) + { + continue; + } + String displayed = annotation.displayCharacter; + if (displayed == null || displayed.length() != 1) + { + continue; + } + char symbol = displayed.charAt(0); + if (!Rna.isOpeningParenthesis(symbol)) + { + continue; + } + + /* + * found an opening bracket symbol + * count (closing-opening) symbols of this type that follow it, + * up to and excluding the target column; if the count is less + * than 1, the opening bracket is unmatched, so return its match + */ + String closer = String + .valueOf(Rna.getMatchingClosingParenthesis(symbol)); + String opener = String.valueOf(symbol); + int count = 0; + for (int j = col + 1; j < column; j++) + { + if (annotations[j] != null) + { + String s = annotations[j].displayCharacter; + if (closer.equals(s)) + { + count++; + } + else if (opener.equals(s)) + { + count--; + } + } + } + if (count < 1) + { + return closer; + } + } + return result; + } + + protected static synchronized long nextId() + { + return counter++; + } + + /** + * + * @return true for rows that have a range of values in their annotation set + */ + public boolean isQuantitative() + { + return graphMin < graphMax; + } + + /** + * delete any columns in alignmentAnnotation that are hidden (including + * sequence associated annotation). + * + * @param hiddenColumns + * the set of hidden columns + */ + public void makeVisibleAnnotation(HiddenColumns hiddenColumns) + { + if (annotations != null) + { + makeVisibleAnnotation(0, annotations.length, hiddenColumns); + } + } + + /** + * delete any columns in alignmentAnnotation that are hidden (including + * sequence associated annotation). + * + * @param start + * remove any annotation to the right of this column + * @param end + * remove any annotation to the left of this column + * @param hiddenColumns + * the set of hidden columns + */ + public void makeVisibleAnnotation(int start, int end, + HiddenColumns hiddenColumns) + { + if (annotations != null) + { + if (hiddenColumns.hasHiddenColumns()) + { + removeHiddenAnnotation(start, end, hiddenColumns); + } + else + { + restrict(start, end); + } + } + } + + /** + * The actual implementation of deleting hidden annotation columns + * + * @param start + * remove any annotation to the right of this column + * @param end + * remove any annotation to the left of this column + * @param hiddenColumns + * the set of hidden columns + */ + private void removeHiddenAnnotation(int start, int end, + HiddenColumns hiddenColumns) + { + // mangle the alignmentAnnotation annotation array + ArrayList annels = new ArrayList<>(); + Annotation[] els = null; + + int w = 0; + + Iterator blocks = hiddenColumns.getVisContigsIterator(start, + end + 1, false); + + int copylength; + int annotationLength; + while (blocks.hasNext()) + { + int[] block = blocks.next(); + annotationLength = block[1] - block[0] + 1; + + if (blocks.hasNext()) + { + // copy just the visible segment of the annotation row + copylength = annotationLength; + } + else + { + if (annotationLength + block[0] <= annotations.length) + { + // copy just the visible segment of the annotation row + copylength = annotationLength; + } + else + { + // copy to the end of the annotation row + copylength = annotations.length - block[0]; + } + } + + els = new Annotation[annotationLength]; + annels.add(els); + System.arraycopy(annotations, block[0], els, 0, copylength); + w += annotationLength; + } + + if (w != 0) + { + annotations = new Annotation[w]; + + w = 0; + for (Annotation[] chnk : annels) + { + System.arraycopy(chnk, 0, annotations, w, chnk.length); + w += chnk.length; + } + } + } + + public static Iterable findAnnotations( + Iterable list, SequenceI seq, String calcId, + String label) + { + + ArrayList aa = new ArrayList<>(); + for (AlignmentAnnotation ann : list) + { + if ((calcId == null || (ann.getCalcId() != null + && ann.getCalcId().equals(calcId))) + && (seq == null || (ann.sequenceRef != null + && ann.sequenceRef == seq)) + && (label == null + || (ann.label != null && ann.label.equals(label)))) + { + aa.add(ann); + } + } + return aa; + } + + /** + * Answer true if any annotation matches the calcId passed in (if not null). + * + * @param list + * annotation to search + * @param calcId + * @return + */ + public static boolean hasAnnotation(List list, + String calcId) + { + + if (calcId != null && !"".equals(calcId)) + { + for (AlignmentAnnotation a : list) + { + if (a.getCalcId() == calcId) + { + return true; + } + } + } + return false; + } + + public static Iterable findAnnotation( + List list, String calcId) + { + + List aa = new ArrayList<>(); + if (calcId == null) + { + return aa; + } + for (AlignmentAnnotation a : list) + { + + if (a.getCalcId() == calcId || (a.getCalcId() != null + && calcId != null && a.getCalcId().equals(calcId))) + { + aa.add(a); + } + } + return aa; + } + +} diff --git a/unused/MapList.java b/unused/MapList.java new file mode 100644 index 0000000..a5aa8fd --- /dev/null +++ b/unused/MapList.java @@ -0,0 +1,1286 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors + * + * This file is part of Jalview. + * + * 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. + * + * 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 . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ +package jalview.util; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * A simple way of bijectively mapping a non-contiguous linear range to another + * non-contiguous linear range. + * + * Use at your own risk! + * + * TODO: efficient implementation of private posMap method + * + * TODO: test/ensure that sense of from and to ratio start position is conserved + * (codon start position recovery) + */ +public class MapList +{ + + public static final int POS = 0; + public static final int POS_FROM = 1; // for countPos + public static final int DIR_FROM = 2; // for countPos + public static final int POS_TO = 3; // for countToPos + public static final int DIR_TO = 4; // for countToPos + private static final int FROM_REMAINDER = 5; + public static final int LEN = 6; +/* + * Subregions (base 1) described as { [start1, end1], [start2, end2], ...} + */ + private List fromShifts; + + /* + * Same format as fromShifts, for the 'mapped to' sequence + */ + private List toShifts; + + /* + * number of steps in fromShifts to one toRatio unit + */ + private int fromRatio; + + /* + * number of steps in toShifts to one fromRatio + */ + private int toRatio; + + /* + * lowest and highest value in the from Map + */ + private int fromLowest; + + private int fromHighest; + + /* + * lowest and highest value in the to Map + */ + private int toLowest; + + private int toHighest; + + /** + * Constructor + */ + public MapList() + { + fromShifts = new ArrayList<>(); + toShifts = new ArrayList<>(); + } + + /** + * Two MapList objects are equal if they are the same object, or they both + * have populated shift ranges and all values are the same. + */ + @Override + public boolean equals(Object o) + { + if (o == null || !(o instanceof MapList)) + { + return false; + } + + MapList obj = (MapList) o; + if (obj == this) + { + return true; + } + if (obj.fromRatio != fromRatio || obj.toRatio != toRatio + || obj.fromShifts == null || obj.toShifts == null) + { + return false; + } + return Arrays.deepEquals(fromShifts.toArray(), obj.fromShifts.toArray()) + && Arrays.deepEquals(toShifts.toArray(), + obj.toShifts.toArray()); + } + + /** + * Returns a hashcode made from the fromRatio, toRatio, and from/to ranges + */ + @Override + public int hashCode() + { + int hashCode = 31 * fromRatio; + hashCode = 31 * hashCode + toRatio; + for (int[] shift : fromShifts) + { + hashCode = 31 * hashCode + shift[0]; + hashCode = 31 * hashCode + shift[1]; + } + for (int[] shift : toShifts) + { + hashCode = 31 * hashCode + shift[0]; + hashCode = 31 * hashCode + shift[1]; + } + + return hashCode; + } + + /** + * Returns the 'from' ranges as {[start1, end1], [start2, end2], ...} + * + * @return + */ + public List getFromRanges() + { + return fromShifts; + } + + /** + * Returns the 'to' ranges as {[start1, end1], [start2, end2], ...} + * + * @return + */ + public List getToRanges() + { + return toShifts; + } + + /** + * Flattens a list of [start, end] into a single [start1, end1, start2, + * end2,...] array. + * + * @param shifts + * @return + */ + protected static int[] getRanges(List shifts) + { + int[] rnges = new int[2 * shifts.size()]; + int i = 0; + for (int[] r : shifts) + { + rnges[i++] = r[0]; + rnges[i++] = r[1]; + } + return rnges; + } + + /** + * + * @return length of mapped phrase in from + */ + public int getFromRatio() + { + return fromRatio; + } + + /** + * + * @return length of mapped phrase in to + */ + public int getToRatio() + { + return toRatio; + } + + public int getFromLowest() + { + return fromLowest; + } + + public int getFromHighest() + { + return fromHighest; + } + + public int getToLowest() + { + return toLowest; + } + + public int getToHighest() + { + return toHighest; + } + + /** + * Constructor given from and to ranges as [start1, end1, start2, end2,...]. + * If any end is equal to the next start, the ranges will be merged. There is + * no validation check that the ranges do not overlap each other. + * + * @param from + * contiguous regions as [start1, end1, start2, end2, ...] + * @param to + * same format as 'from' + * @param fromRatio + * phrase length in 'from' (e.g. 3 for dna) + * @param toRatio + * phrase length in 'to' (e.g. 1 for protein) + */ + public MapList(int from[], int to[], int fromRatio, int toRatio) + { + this(); + this.fromRatio = fromRatio; + this.toRatio = toRatio; + fromLowest = Integer.MAX_VALUE; + fromHighest = Integer.MIN_VALUE; + int added = 0; + + for (int i = 0; i < from.length; i += 2) + { + /* + * note lowest and highest values - bearing in mind the + * direction may be reversed + */ + fromLowest = Math.min(fromLowest, Math.min(from[i], from[i + 1])); + fromHighest = Math.max(fromHighest, Math.max(from[i], from[i + 1])); + if (added > 0 && from[i] == fromShifts.get(added - 1)[1]) + { + /* + * this range starts where the last ended - just extend it + */ + fromShifts.get(added - 1)[1] = from[i + 1]; + } + else + { + fromShifts.add(new int[] { from[i], from[i + 1] }); + added++; + } + } + + toLowest = Integer.MAX_VALUE; + toHighest = Integer.MIN_VALUE; + added = 0; + for (int i = 0; i < to.length; i += 2) + { + toLowest = Math.min(toLowest, Math.min(to[i], to[i + 1])); + toHighest = Math.max(toHighest, Math.max(to[i], to[i + 1])); + if (added > 0 && to[i] == toShifts.get(added - 1)[1]) + { + toShifts.get(added - 1)[1] = to[i + 1]; + } + else + { + toShifts.add(new int[] { to[i], to[i + 1] }); + added++; + } + } + } + + /** + * Copy constructor. Creates an identical mapping. + * + * @param map + */ + public MapList(MapList map) + { + this(); + // TODO not used - remove? + this.fromLowest = map.fromLowest; + this.fromHighest = map.fromHighest; + this.toLowest = map.toLowest; + this.toHighest = map.toHighest; + + this.fromRatio = map.fromRatio; + this.toRatio = map.toRatio; + if (map.fromShifts != null) + { + for (int[] r : map.fromShifts) + { + fromShifts.add(new int[] { r[0], r[1] }); + } + } + if (map.toShifts != null) + { + for (int[] r : map.toShifts) + { + toShifts.add(new int[] { r[0], r[1] }); + } + } + } + + /** + * Constructor given ranges as lists of [start, end] positions. There is no + * validation check that the ranges do not overlap each other. + * + * @param fromRange + * @param toRange + * @param fromRatio + * @param toRatio + */ + public MapList(List fromRange, List toRange, int fromRatio, + int toRatio) + { + this(); + fromRange = coalesceRanges(fromRange); + toRange = coalesceRanges(toRange); + this.fromShifts = fromRange; + this.toShifts = toRange; + this.fromRatio = fromRatio; + this.toRatio = toRatio; + + fromLowest = Integer.MAX_VALUE; + fromHighest = Integer.MIN_VALUE; + for (int[] range : fromRange) + { + if (range.length != 2) + { + // throw new IllegalArgumentException(range); + System.err.println( + "Invalid format for fromRange " + Arrays.toString(range) + + " may cause errors"); + } + fromLowest = Math.min(fromLowest, Math.min(range[0], range[1])); + fromHighest = Math.max(fromHighest, Math.max(range[0], range[1])); + } + + toLowest = Integer.MAX_VALUE; + toHighest = Integer.MIN_VALUE; + for (int[] range : toRange) + { + if (range.length != 2) + { + // throw new IllegalArgumentException(range); + System.err.println("Invalid format for toRange " + + Arrays.toString(range) + + " may cause errors"); + } + toLowest = Math.min(toLowest, Math.min(range[0], range[1])); + toHighest = Math.max(toHighest, Math.max(range[0], range[1])); + } + } + + /** + * Consolidates a list of ranges so that any contiguous ranges are merged. + * This assumes the ranges are already in start order (does not sort them). + * + * @param ranges + * @return the same list (if unchanged), else a new merged list, leaving the + * input list unchanged + */ + public static List coalesceRanges(final List ranges) + { + if (ranges == null || ranges.size() < 2) + { + return ranges; + } + + boolean changed = false; + List merged = new ArrayList<>(); + int[] lastRange = ranges.get(0); + int lastDirection = lastRange[1] >= lastRange[0] ? 1 : -1; + lastRange = new int[] { lastRange[0], lastRange[1] }; + merged.add(lastRange); + boolean first = true; + + for (final int[] range : ranges) + { + if (first) + { + first = false; + continue; + } + if (range[0] == lastRange[0] && range[1] == lastRange[1]) + { + // drop duplicate range + changed = true; + continue; + } + + /* + * drop this range if it lies within the last range + */ + if ((lastDirection == 1 && range[0] >= lastRange[0] + && range[0] <= lastRange[1] && range[1] >= lastRange[0] + && range[1] <= lastRange[1]) + || (lastDirection == -1 && range[0] <= lastRange[0] + && range[0] >= lastRange[1] + && range[1] <= lastRange[0] + && range[1] >= lastRange[1])) + { + changed = true; + continue; + } + + int direction = range[1] >= range[0] ? 1 : -1; + + /* + * if next range is in the same direction as last and contiguous, + * just update the end position of the last range + */ + boolean sameDirection = range[1] == range[0] + || direction == lastDirection; + boolean extending = range[0] == lastRange[1] + lastDirection; + boolean overlapping = (lastDirection == 1 && range[0] >= lastRange[0] + && range[0] <= lastRange[1]) + || (lastDirection == -1 && range[0] <= lastRange[0] + && range[0] >= lastRange[1]); + if (sameDirection && (overlapping || extending)) + { + lastRange[1] = range[1]; + changed = true; + } + else + { + lastRange = new int[] { range[0], range[1] }; + merged.add(lastRange); + // careful: merging [5, 5] after [7, 6] should keep negative direction + lastDirection = (range[1] == range[0]) ? lastDirection : direction; + } + } + + return changed ? merged : ranges; + } + +// /** +// * get all mapped positions from 'from' to 'to' +// * +// * @return int[][] { int[] { fromStart, fromFinish, toStart, toFinish }, int +// * [fromFinish-fromStart+2] { toStart..toFinish mappings}} +// */ +// protected int[][] makeFromMap() +// { +// // TODO not used - remove?? +// return posMap(fromShifts, fromRatio, toShifts, toRatio); +// } +// +// /** +// * get all mapped positions from 'to' to 'from' +// * +// * @return int[to position]=position mapped in from +// */ +// protected int[][] makeToMap() +// { +// // TODO not used - remove?? +// return posMap(toShifts, toRatio, fromShifts, fromRatio); +// } + +// /** +// * construct an int map for intervals in intVals +// * +// * @param shiftTo +// * @return int[] { from, to pos in range }, int[range.to-range.from+1] +// * returning mapped position +// */ +// private int[][] posMap(List shiftTo, int ratio, +// List shiftFrom, int toRatio) +// { +// // TODO not used - remove?? +// +// int[] reg = new int[LEN]; +// +// int iv = 0, ivSize = shiftTo.size(); +// if (iv >= ivSize) +// { +// return null; +// } +// int[] intv = shiftTo.get(iv++); +// int from = intv[0], to = intv[1]; +// if (from > to) +// { +// from = intv[1]; +// to = intv[0]; +// } +// while (iv < ivSize) +// { +// intv = shiftTo.get(iv++); +// if (intv[0] < from) +// { +// from = intv[0]; +// } +// if (intv[1] < from) +// { +// from = intv[1]; +// } +// if (intv[0] > to) +// { +// to = intv[0]; +// } +// if (intv[1] > to) +// { +// to = intv[1]; +// } +// } +// int tF = 0, tT = 0; +// int mp[][] = new int[to - from + 2][]; +// for (int i = 0; i < mp.length; i++) +// { +// reg[POS] = i + from; +// int[] m = shift(reg, shiftTo, ratio, shiftFrom, toRatio); +// if (m != null) +// { +// if (i == 0) +// { +// tF = tT = m[0]; +// } +// else +// { +// if (m[0] < tF) +// { +// tF = m[0]; +// } +// if (m[0] > tT) +// { +// tT = m[0]; +// } +// } +// } +// mp[i] = m; +// } +// int[][] map = new int[][] { new int[] { from, to, tF, tT }, +// new int[to - from + 2] }; +// +// map[0][2] = tF; +// map[0][3] = tT; +// +// for (int i = 0; i < mp.length; i++) +// { +// if (mp[i] != null) +// { +// map[1][i] = mp[i][0] - tF; +// } +// else +// { +// map[1][i] = -1; // indicates an out of range mapping +// } +// } +// return map; +// } + + /** + * addShift + * + * @param pos + * start position for shift (in original reference frame) + * @param shift + * length of shift + * + * public void addShift(int pos, int shift) { int sidx = 0; int[] + * rshift=null; while (sidx shiftTo, int fromRatio, + List shiftFrom, int toRatio) + { + // TODO: javadoc; tests + reg = countPos(shiftTo, reg); + if (reg == null) + { + return null; + } + reg[FROM_REMAINDER] = (reg[POS_FROM] - 1) % fromRatio; + reg[POS] = 1 + (((reg[POS_FROM] - 1) / fromRatio) * toRatio); // toCount + reg = countToPos(shiftFrom, reg); + if (reg == null) + { + return null; // throw new Error("Bad Mapping!"); + } + // reg is now filled + // System.out.println(fromCount[0]+" "+fromCount[1]+" "+toCount); +// ret3[0] = toPos[0]; +// ret3[1] = fromRemainder; +// ret3[2] = toPos[1]; + return reg; + } + + /** + * count how many positions pos is along the series of intervals. + * + * @param shiftTo + * @param pos + * @return number of positions or null if pos is not within intervals + */ + protected static int[] countPos(List shiftTo, int[] reg) + { + int pos = reg[POS]; + int count = 0, iv = 0, ivSize = shiftTo.size(); + while (iv < ivSize) + { + int[] intv = shiftTo.get(iv++); + if (intv[0] <= intv[1]) + { + if (pos >= intv[0] && pos <= intv[1]) + { + reg[POS_FROM] = count + pos - intv[0] + 1; + reg[DIR_FROM] = 1; + return reg; + } + else + { + count += intv[1] - intv[0] + 1; + } + } + else + { + if (pos >= intv[1] && pos <= intv[0]) + { + reg[POS_FROM] = count - pos + intv[0] + 1; + reg[DIR_FROM] = -1; + return reg; + } + else + { + count += intv[0] - intv[1] + 1; + } + } + } + return null; + } + + /** + * count out pos positions into a series of intervals and return the position + * + * @param shiftFrom + * @param pos + * @return position pos in interval set + */ + protected static int[] countToPos(List shiftFrom, int[] reg) + { + int count = 0, diff = 0, iv = 0, ivSize = shiftFrom.size(); + int pos = reg[POS]; + while (iv < ivSize) + { + int[] intv = shiftFrom.get(iv++); + diff = intv[1] - intv[0]; + if (diff >= 0) + { + if (pos <= count + 1 + diff) + { + reg[POS_TO] = intv[0] + pos - count - 1; + reg[DIR_TO] = 1; + return reg; + } + else + { + count += 1 + diff; + } + } + else + { + if (pos <= count + 1 - diff) + { + reg[POS_TO] = intv[0] - (pos - count - 1); + reg[DIR_TO] = -1; + return reg; + } + else + { + count += 1 - diff; + } + } + } + return null;// (diff<0) ? (intv[1]-1) : (intv[0]+1); + } + + /** + * find series of intervals mapping from start-end in the From map. + * + * @param start + * position mapped 'to' + * @param end + * position mapped 'to' + * @return series of [start, end] ranges in sequence mapped 'from' + */ + public int[] locateInFrom(int start, int end) + { + int[] reg = new int[LEN]; + // inefficient implementation + reg[POS] = start; + reg = shiftTo(reg); + if (reg == null) + return null; + // needs to be inclusive of end of symbol position + start = reg[POS_TO]; + reg[POS] = end; + reg = shiftTo(reg); + if (reg == null) + return null; + end = reg[POS_TO]; + return getIntervals(fromShifts, start, end, fromRatio); + } + + /** + * find series of intervals mapping from start-end in the to map. + * + * @param start + * position mapped 'from' + * @param end + * position mapped 'from' + * @return series of [start, end] ranges in sequence mapped 'to' + */ + public int[] locateInTo(int start, int end) + { + int[] reg = new int[LEN]; + reg[POS] = start; + reg = shiftFrom(reg); + if (reg == null) + return null; + start = reg[POS_FROM]; + reg[POS] = end; + reg = shiftFrom(reg); + if (reg == null) + return null; + end = reg[POS_FROM]; + return getIntervals(toShifts, start, end, toRatio); + } + + /** + * like shift - except returns the intervals in the given vector of shifts + * which were spanned in traversing fromStart to fromEnd + * + * @param shiftFrom + * @param fromStart + * @param fromEnd + * @param fromRatio2 + * @return series of from,to intervals from from first position of starting + * region to final position of ending region inclusive + */ + protected static int[] getIntervals(List shiftFrom, + int startpos, int endpos, int fromRatio2) + { +// if (fromStart == null || fromEnd == null) +// { +// return null; +// } +// int startpos, endpos; +// startpos = fromStart[0]; // first position in fromStart +// endpos = fromEnd[0]; // last position in fromEnd + int endindx = (fromRatio2 - 1); // additional positions to get to last + // position from endpos + int intv = 0, intvSize = shiftFrom.size(); + int iv[], i = 0, fs = -1, fe_s = -1, fe = -1; // containing intervals + // search intervals to locate ones containing startpos and count endindx + // positions on from endpos + while (intv < intvSize && (fs == -1 || fe == -1)) + { + iv = shiftFrom.get(intv++); + if (fe_s > -1) + { + endpos = iv[0]; // start counting from beginning of interval + endindx--; // inclusive of endpos + } + if (iv[0] <= iv[1]) + { + if (fs == -1 && startpos >= iv[0] && startpos <= iv[1]) + { + fs = i; + } + if (endpos >= iv[0] && endpos <= iv[1]) + { + if (fe_s == -1) + { + fe_s = i; + } + if (fe_s != -1) + { + if (endpos + endindx <= iv[1]) + { + fe = i; + endpos = endpos + endindx; // end of end token is within this + // interval + } + else + { + endindx -= iv[1] - endpos; // skip all this interval too + } + } + } + } + else + { + if (fs == -1 && startpos <= iv[0] && startpos >= iv[1]) + { + fs = i; + } + if (endpos <= iv[0] && endpos >= iv[1]) + { + if (fe_s == -1) + { + fe_s = i; + } + if (fe_s != -1) + { + if (endpos - endindx >= iv[1]) + { + fe = i; + endpos = endpos - endindx; // end of end token is within this + // interval + } + else + { + endindx -= endpos - iv[1]; // skip all this interval too + } + } + } + } + i++; + } + if (fs == fe && fe == -1) + { + return null; + } + List ranges = new ArrayList<>(); + if (fs <= fe) + { + intv = fs; + i = fs; + // truncate initial interval + iv = shiftFrom.get(intv++); + iv = new int[] { iv[0], iv[1] };// clone + if (i == fs) + { + iv[0] = startpos; + } + while (i != fe) + { + ranges.add(iv); // add initial range + iv = shiftFrom.get(intv++); // get next interval + iv = new int[] { iv[0], iv[1] };// clone + i++; + } + if (i == fe) + { + iv[1] = endpos; + } + ranges.add(iv); // add only - or final range + } + else + { + // walk from end of interval. + i = shiftFrom.size() - 1; + while (i > fs) + { + i--; + } + iv = shiftFrom.get(i); + iv = new int[] { iv[1], iv[0] };// reverse and clone + // truncate initial interval + if (i == fs) + { + iv[0] = startpos; + } + while (--i != fe) + { // fix apparent logic bug when fe==-1 + ranges.add(iv); // add (truncated) reversed interval + iv = shiftFrom.get(i); + iv = new int[] { iv[1], iv[0] }; // reverse and clone + } + if (i == fe) + { + // interval is already reversed + iv[1] = endpos; + } + ranges.add(iv); // add only - or final range + } + // create array of start end intervals. + int[] range = null; + if (ranges != null && ranges.size() > 0) + { + range = new int[ranges.size() * 2]; + intv = 0; + intvSize = ranges.size(); + i = 0; + while (intv < intvSize) + { + iv = ranges.get(intv); + range[i++] = iv[0]; + range[i++] = iv[1]; + ranges.set(intv++, null); // remove + } + } + return range; + } + +// /** +// * get the 'initial' position of mpos in To +// * +// * @param mpos +// * position in from +// * @return position of first word in to reference frame +// */ +// public int getToPosition(int[]) +// { +// // TODO not used - remove?? +// int[] mp = shiftTo(mpos); +// if (mp != null) +// { +// return mp[0]; +// } +// return mpos; +// } +// +// /** +// * get range of positions in To frame for the mpos word in From +// * +// * @param mpos +// * position in From +// * @return null or int[] first position in To for mpos, last position in to +// * for Mpos +// */ +// public int[] getToWord(int mpos) +// { +// // never called +// int[] mp = shiftTo(mpos); +// if (mp != null) +// { +// return new int[] { mp[0], mp[0] + mp[2] * (getFromRatio() - 1) }; +// } +// return null; +// } + + /** + * get From position in the associated reference frame for position pos in the + * associated sequence. + * + * @param pos + * @return + */ + public int getMappedPosition(int[] reg) + { + // TODO not used - remove?? + int pos = reg[POS]; + reg = shiftFrom(reg); + if (reg != null) + { + return reg[POS_TO]; + } + return pos; + } + +// public int[] getMappedWord(int[] reg) +// { +// // TODO not used - remove?? +// reg = shiftFrom(reg); +// if (reg != null) +// { +// return new int[] { mp[0], mp[0] + mp[2] * (getToRatio() - 1) }; +// } +// return null; +// } + + /** + * + * @return a MapList whose From range is this maplist's To Range, and vice + * versa + */ + public MapList getInverse() + { + return new MapList(getToRanges(), getFromRanges(), getToRatio(), + getFromRatio()); + } + + /** + * test for containment rather than equivalence to another mapping + * + * @param map + * to be tested for containment + * @return true if local or mapped range map contains or is contained by this + * mapping + */ + public boolean containsEither(boolean local, MapList map) + { + // TODO not used - remove? + if (local) + { + return ((getFromLowest() >= map.getFromLowest() + && getFromHighest() <= map.getFromHighest()) + || (getFromLowest() <= map.getFromLowest() + && getFromHighest() >= map.getFromHighest())); + } + else + { + return ((getToLowest() >= map.getToLowest() + && getToHighest() <= map.getToHighest()) + || (getToLowest() <= map.getToLowest() + && getToHighest() >= map.getToHighest())); + } + } + + /** + * String representation - for debugging, not guaranteed not to change + */ + @Override + public String toString() + { + StringBuilder sb = new StringBuilder(64); + sb.append("["); + for (int[] shift : fromShifts) + { + sb.append(" ").append(Arrays.toString(shift)); + } + sb.append(" ] "); + sb.append(fromRatio).append(":").append(toRatio); + sb.append(" to ["); + for (int[] shift : toShifts) + { + sb.append(" ").append(Arrays.toString(shift)); + } + sb.append(" ]"); + return sb.toString(); + } + + /** + * Extend this map list by adding the given map's ranges. There is no + * validation check that the ranges do not overlap existing ranges (or each + * other), but contiguous ranges are merged. + * + * @param map + */ + public void addMapList(MapList map) + { + if (this.equals(map)) + { + return; + } + this.fromLowest = Math.min(fromLowest, map.fromLowest); + this.toLowest = Math.min(toLowest, map.toLowest); + this.fromHighest = Math.max(fromHighest, map.fromHighest); + this.toHighest = Math.max(toHighest, map.toHighest); + + for (int[] range : map.getFromRanges()) + { + addRange(range, fromShifts); + } + for (int[] range : map.getToRanges()) + { + addRange(range, toShifts); + } + } + + /** + * Adds the given range to a list of ranges. If the new range just extends + * existing ranges, the current endpoint is updated instead. + * + * @param range + * @param addTo + */ + static void addRange(int[] range, List addTo) + { + /* + * list is empty - add to it! + */ + if (addTo.size() == 0) + { + addTo.add(range); + return; + } + + int[] last = addTo.get(addTo.size() - 1); + boolean lastForward = last[1] >= last[0]; + boolean newForward = range[1] >= range[0]; + + /* + * contiguous range in the same direction - just update endpoint + */ + if (lastForward == newForward && last[1] == range[0]) + { + last[1] = range[1]; + return; + } + + /* + * next range starts at +1 in forward sense - update endpoint + */ + if (lastForward && newForward && range[0] == last[1] + 1) + { + last[1] = range[1]; + return; + } + + /* + * next range starts at -1 in reverse sense - update endpoint + */ + if (!lastForward && !newForward && range[0] == last[1] - 1) + { + last[1] = range[1]; + return; + } + + /* + * just add the new range + */ + addTo.add(range); + } + + /** + * Returns true if mapping is from forward strand, false if from reverse + * strand. Result is just based on the first 'from' range that is not a single + * position. Default is true unless proven to be false. Behaviour is not well + * defined if the mapping has a mixture of forward and reverse ranges. + * + * @return + */ + public boolean isFromForwardStrand() + { + return isForwardStrand(getFromRanges()); + } + + /** + * Returns true if mapping is to forward strand, false if to reverse strand. + * Result is just based on the first 'to' range that is not a single position. + * Default is true unless proven to be false. Behaviour is not well defined if + * the mapping has a mixture of forward and reverse ranges. + * + * @return + */ + public boolean isToForwardStrand() + { + return isForwardStrand(getToRanges()); + } + + /** + * A helper method that returns true unless at least one range has start > end. + * Behaviour is undefined for a mixture of forward and reverse ranges. + * + * @param ranges + * @return + */ + private boolean isForwardStrand(List ranges) + { + boolean forwardStrand = true; + for (int[] range : ranges) + { + if (range[1] > range[0]) + { + break; // forward strand confirmed + } + else if (range[1] < range[0]) + { + forwardStrand = false; + break; // reverse strand confirmed + } + } + return forwardStrand; + } + + /** + * + * @return true if from, or to is a three to 1 mapping + */ + public boolean isTripletMap() + { + return (toRatio == 3 && fromRatio == 1) + || (fromRatio == 3 && toRatio == 1); + } + + /** + * Returns a map which is the composite of this one and the input map. That + * is, the output map has the fromRanges of this map, and its toRanges are the + * toRanges of this map as transformed by the input map. + *

+ * Returns null if the mappings cannot be traversed (not all toRanges of this + * map correspond to fromRanges of the input), or if this.toRatio does not + * match map.fromRatio. + * + * 

+   * Example 1:
+   *    this:   from [1-100] to [501-600]
+   *    input:  from [10-40] to [60-90]
+   *    output: from [10-40] to [560-590]
+   * Example 2 ('reverse strand exons'):
+   *    this:   from [1-100] to [2000-1951], [1000-951] // transcript to loci
+   *    input:  from [1-50]  to [41-90] // CDS to transcript
+   *    output: from [10-40] to [1960-1951], [1000-971] // CDS to gene loci
+   *
+ * + * @param map + * @return + */ + public MapList traverse(MapList map) + { + if (map == null) + { + return null; + } + + /* + * compound the ratios by this rule: + * A:B with M:N gives A*M:B*N + * reduced by greatest common divisor + * so 1:3 with 3:3 is 3:9 or 1:3 + * 1:3 with 3:1 is 3:3 or 1:1 + * 1:3 with 1:3 is 1:9 + * 2:5 with 3:7 is 6:35 + */ + int outFromRatio = getFromRatio() * map.getFromRatio(); + int outToRatio = getToRatio() * map.getToRatio(); + int gcd = MathUtils.gcd(outFromRatio, outToRatio); + outFromRatio /= gcd; + outToRatio /= gcd; + + List toRanges = new ArrayList<>(); + List ranges = getToRanges(); + + for (int ir = 0, nr = ranges.size(); ir < nr; ir++) + { + int[] range = ranges.get(ir); + int[] transferred = map.locateInTo(range[0], range[1]); + if (transferred == null || transferred.length % 2 != 0) + { + return null; + } + + /* + * convert [start1, end1, start2, end2, ...] + * to [[start1, end1], [start2, end2], ...] + */ + for (int i = 0, n = transferred.length; i < n; i += 2) + { + toRanges.add(new int[] { transferred[i], transferred[i + 1] }); + } + } + + return new MapList(getFromRanges(), toRanges, outFromRatio, outToRatio); + } + +} diff --git a/unused/Mapping.java b/unused/Mapping.java new file mode 100644 index 0000000..85f4356 --- /dev/null +++ b/unused/Mapping.java @@ -0,0 +1,752 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors + * + * This file is part of Jalview. + * + * 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. + * + * 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 . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ +package jalview.datamodel; + +import jalview.util.Comparison; +import jalview.util.MapList; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Vector; + +public class Mapping +{ + /** + * An iterator that serves the aligned codon positions (with their protein + * products). + * + * @author gmcarstairs + * + */ + public class AlignedCodonIterator implements Iterator + { + /* + * The gap character used in the aligned sequence + */ + private final char gap; + + /* + * The characters of the aligned sequence e.g. "-cGT-ACgTG-" + */ + private final SequenceI alignedSeq; + + /* + * the sequence start residue + */ + private int start; + + /* + * Next position (base 0) in the aligned sequence + */ + private int alignedColumn = 0; + + /* + * Count of bases up to and including alignedColumn position + */ + private int alignedBases = 0; + + /* + * [start, end] from ranges (base 1) + */ + private Iterator fromRanges; + + /* + * [start, end] to ranges (base 1) + */ + private Iterator toRanges; + + /* + * The current [start, end] (base 1) from range + */ + private int[] currentFromRange = null; + + /* + * The current [start, end] (base 1) to range + */ + private int[] currentToRange = null; + + /* + * The next 'from' position (base 1) to process + */ + private int fromPosition = 0; + + /* + * The next 'to' position (base 1) to process + */ + private int toPosition = 0; + + /** + * Constructor + * + * @param seq + * the aligned sequence + * @param gapChar + */ + public AlignedCodonIterator(SequenceI seq, char gapChar) + { + this.alignedSeq = seq; + this.start = seq.getStart(); + this.gap = gapChar; + fromRanges = map.getFromRanges().iterator(); + toRanges = map.getToRanges().iterator(); + if (fromRanges.hasNext()) + { + currentFromRange = fromRanges.next(); + fromPosition = currentFromRange[0]; + } + if (toRanges.hasNext()) + { + currentToRange = toRanges.next(); + toPosition = currentToRange[0]; + } + } + + /** + * Returns true unless we have already traversed the whole mapping. + */ + @Override + public boolean hasNext() + { + if (fromRanges.hasNext()) + { + return true; + } + if (currentFromRange == null || fromPosition >= currentFromRange[1]) + { + return false; + } + return true; + } + + /** + * Returns the next codon's aligned positions, and translated value. + * + * @throws NoSuchElementException + * if hasNext() would have returned false + * @throws IncompleteCodonException + * if not enough mapped bases are left to make up a codon + */ + @Override + public AlignedCodon next() throws IncompleteCodonException + { + if (!hasNext()) + { + throw new NoSuchElementException(); + } + + int[] codon = getNextCodon(); + int[] alignedCodon = getAlignedCodon(codon); + + String peptide = getPeptide(); + int peptideCol = toPosition - 1 - Mapping.this.to.getStart(); + return new AlignedCodon(alignedCodon[0], alignedCodon[1], + alignedCodon[2], peptide, peptideCol); + } + + /** + * Retrieve the translation as the 'mapped to' position in the mapped to + * sequence. + * + * @return + * @throws NoSuchElementException + * if the 'toRange' is exhausted (nothing to map to) + */ + private String getPeptide() + { + // TODO should ideally handle toRatio other than 1 as well... + // i.e. code like getNextCodon() + if (toPosition <= currentToRange[1]) + { + SequenceI seq = Mapping.this.to; + char pep = seq.getCharAt(toPosition - seq.getStart()); + toPosition++; + return String.valueOf(pep); + } + if (!toRanges.hasNext()) + { + throw new NoSuchElementException( + "Ran out of peptide at position " + toPosition); + } + currentToRange = toRanges.next(); + toPosition = currentToRange[0]; + return getPeptide(); + } + + /** + * Get the (base 1) dataset positions for the next codon in the mapping. + * + * @throws IncompleteCodonException + * if less than 3 remaining bases are mapped + */ + private int[] getNextCodon() + { + int[] codon = new int[3]; + int codonbase = 0; + + while (codonbase < 3) + { + if (fromPosition <= currentFromRange[1]) + { + /* + * Add next position from the current start-end range + */ + codon[codonbase++] = fromPosition++; + } + else + { + /* + * Move to the next range - if there is one + */ + if (!fromRanges.hasNext()) + { + throw new IncompleteCodonException(); + } + currentFromRange = fromRanges.next(); + fromPosition = currentFromRange[0]; + } + } + return codon; + } + + /** + * Get the aligned column positions (base 0) for the given sequence + * positions (base 1), by counting ungapped characters in the aligned + * sequence. + * + * @param codon + * @return + */ + private int[] getAlignedCodon(int[] codon) + { + int[] aligned = new int[codon.length]; + for (int i = 0; i < codon.length; i++) + { + aligned[i] = getAlignedColumn(codon[i]); + } + return aligned; + } + + /** + * Get the aligned column position (base 0) for the given sequence position + * (base 1). + * + * @param sequencePos + * @return + */ + private int getAlignedColumn(int sequencePos) + { + /* + * allow for offset e.g. treat pos 8 as 2 if sequence starts at 7 + */ + int truePos = sequencePos - (start - 1); + int length = alignedSeq.getLength(); + while (alignedBases < truePos && alignedColumn < length) + { + char c = alignedSeq.getCharAt(alignedColumn++); + if (c != gap && !Comparison.isGap(c)) + { + alignedBases++; + } + } + return alignedColumn - 1; + } + + @Override + public void remove() + { + // ignore + } + + } + + /* + * Contains the start-end pairs mapping from the associated sequence to the + * sequence in the database coordinate system. It also takes care of step + * difference between coordinate systems. + */ + MapList map = null; + + /* + * The sequence that map maps the associated sequence to (if any). + */ + SequenceI to = null; + + /* + * optional sequence id for the 'from' ranges + */ + private String mappedFromId; + + public Mapping(MapList map) + { + super(); + this.map = map; + } + + public Mapping(SequenceI to, MapList map) + { + this(map); + this.to = to; + } + + /** + * create a new mapping from + * + * @param to + * the sequence being mapped + * @param exon + * int[] {start,end,start,end} series on associated sequence + * @param is + * int[] {start,end,...} ranges on the reference frame being mapped + * to + * @param i + * step size on associated sequence + * @param j + * step size on mapped frame + */ + public Mapping(SequenceI to, int[] exon, int[] is, int i, int j) + { + this(to, new MapList(exon, is, i, j)); + } + + /** + * create a duplicate (and independent) mapping object with the same reference + * to any SequenceI being mapped to. + * + * @param map2 + */ + public Mapping(Mapping map2) + { + if (map2 != this && map2 != null) + { + if (map2.map != null) + { + map = new MapList(map2.map); + } + to = map2.to; + mappedFromId = map2.mappedFromId; + } + } + + /** + * @return the map + */ + public MapList getMap() + { + return map; + } + + /** + * @param map + * the map to set + */ + public void setMap(MapList map) + { + this.map = map; + } + + /** + * Equals that compares both the to references and MapList mappings. + * + * @param o + * @return + * @see MapList#equals + */ + @Override + public boolean equals(Object o) + { + if (o == null || !(o instanceof Mapping)) + { + return false; + } + Mapping other = (Mapping) o; + if (other == this) + { + return true; + } + if (other.to != to) + { + return false; + } + if ((map != null && other.map == null) + || (map == null && other.map != null)) + { + return false; + } + if ((map == null && other.map == null) || map.equals(other.map)) + { + return true; + } + return false; + } + + /** + * Returns a hashCode made from the sequence and maplist + */ + @Override + public int hashCode() + { + int hashCode = (this.to == null ? 1 : this.to.hashCode()); + if (this.map != null) + { + hashCode = hashCode * 31 + this.map.hashCode(); + } + + return hashCode; + } + +// /** +// * gets boundary in direction of mapping +// * +// * @param position +// * in mapped reference frame +// * @return int{start, end} positions in associated sequence (in direction of +// * mapped word) +// */ +// public int[] getWord(int mpos) +// { +// // BH never called +// if (map != null) +// { +// return map.getToWord(mpos); +// } +// return null; +// } + + /** + * width of mapped unit in associated sequence + * + */ + public int getWidth() + { + if (map != null) + { + return map.getFromRatio(); + } + return 1; + } + + /** + * width of unit in mapped reference frame + * + * @return + */ + public int getMappedWidth() + { + if (map != null) + { + return map.getToRatio(); + } + return 1; + } + + /** + * get the 'initial' position in the associated sequence for a position in the + * mapped reference frame + * + * or the mapped position in the associated reference frame for position pos in + * the associated sequence. + * + * + * @param reg reg[POS] + * @param isMapped + * + * @return position or mapped position + */ + public int getPosition(int[] reg, boolean isMapped) + { + int pos = reg[MapList.POS]; + if (map != null) + { + reg = (isMapped ? map.shiftFrom(reg) : map.shiftTo(reg)); + if (reg != null) + { + return reg[MapList.POS_TO]; // was newArray[0], but shift puts the result in COUNT_TO + } + } + return pos; + } + +// /** +//* get mapped position in the associated reference frame for position pos in +//* the associated sequence. +// * +// * @param pos +// * @return +// */ +// public int getMappedPosition(int[] reg) +// { +// int mpos = reg[MapList.POS]; +// if (map != null) +// { +// reg = map.shiftFrom(reg); +// if (reg != null) +// { +// return reg[MapList.POS_TO]; // was newArray[0], but shift puts the result in COUNT_TO +// } +// } +// return mpos; +// } + +// public int[] getMappedWord(int pos) +// { +// // BH Not used? +// if (map != null) +// { +// reg = map.shiftFrom(reg); +// if (reg != null) +// { +// reg[MP_0] = +// return new int[] { mp[0], mp[0] + mp[2] * (map.getToRatio() - 1) }; +// } +// } +// return null; +// } + + /** + * locates the region of feature f in the associated sequence's reference + * frame + * + * @param f + * @return one or more features corresponding to f + */ + public SequenceFeature[] locateFeature(SequenceFeature f) + { + if (true) + { // f.getBegin()!=f.getEnd()) { + if (map != null) + { + int[] frange = map.locateInFrom(f.getBegin(), f.getEnd()); + if (frange == null) + { + // JBPNote - this isprobably not the right thing to doJBPHack + return null; + } + SequenceFeature[] vf = new SequenceFeature[frange.length / 2]; + for (int i = 0, v = 0; i < frange.length; i += 2, v++) + { + vf[v] = new SequenceFeature(f, frange[i], frange[i + 1], + f.getFeatureGroup(), f.getScore()); + if (frange.length > 2) + { + vf[v].setDescription(f.getDescription() + "\nPart " + (v + 1)); + } + } + return vf; + } + } + + // give up and just return the feature. + return new SequenceFeature[] { f }; + } + + /** + * return a series of contigs on the associated sequence corresponding to the + * from,to interval on the mapped reference frame + * + * @param from + * @param to + * @return int[] { from_i, to_i for i=1 to n contiguous regions in the + * associated sequence} + */ + public int[] locateRange(int from, int to) + { + if (map != null) + { + if (from <= to) + { + from = (map.getToLowest() < from) ? from : map.getToLowest(); + to = (map.getToHighest() > to) ? to : map.getToHighest(); + if (from > to) + { + return null; + } + } + else + { + from = (map.getToHighest() > from) ? from : map.getToHighest(); + to = (map.getToLowest() < to) ? to : map.getToLowest(); + if (from < to) + { + return null; + } + } + return map.locateInFrom(from, to); + } + return new int[] { from, to }; + } + + /** + * return a series of mapped contigs mapped from a range on the associated + * sequence + * + * @param from + * @param to + * @return + */ + public int[] locateMappedRange(int from, int to) + { + if (map != null) + { + + if (from <= to) + { + from = (map.getFromLowest() < from) ? from : map.getFromLowest(); + to = (map.getFromHighest() > to) ? to : map.getFromHighest(); + if (from > to) + { + return null; + } + } + else + { + from = (map.getFromHighest() > from) ? from : map.getFromHighest(); + to = (map.getFromLowest() < to) ? to : map.getFromLowest(); + if (from < to) + { + return null; + } + } + return map.locateInTo(from, to); + } + return new int[] { from, to }; + } + + /** + * return a new mapping object with a maplist modifed to only map the visible + * regions defined by viscontigs. + * + * @param viscontigs + * @return + */ + public Mapping intersectVisContigs(int[] viscontigs) + { + Mapping copy = new Mapping(this); + if (map != null) + { +// int vpos = 0; +// int apos = 0; + List toRange = new ArrayList(); + List fromRange = new ArrayList(); + for (int vc = 0; vc < viscontigs.length; vc += 2) + { + // find a mapped range in this visible region + int[] mpr = locateMappedRange(1 + viscontigs[vc], + viscontigs[vc + 1] - 1); + if (mpr != null) + { + for (int m = 0; m < mpr.length; m += 2) + { + toRange.add(new int[] { mpr[m], mpr[m + 1] }); + int[] xpos = locateRange(mpr[m], mpr[m + 1]); + for (int x = 0; x < xpos.length; x += 2) + { + fromRange.add(new int[] { xpos[x], xpos[x + 1] }); + } + } + } + } + int[] from = new int[fromRange.size() * 2]; + int[] to = new int[toRange.size() * 2]; + int[] r; + for (int f = 0, fSize = fromRange.size(); f < fSize; f++) + { + r = fromRange.get(f); + from[f * 2] = r[0]; + from[f * 2 + 1] = r[1]; + } + for (int f = 0, fSize = toRange.size(); f < fSize; f++) + { + r = toRange.get(f); + to[f * 2] = r[0]; + to[f * 2 + 1] = r[1]; + } + copy.setMap( + new MapList(from, to, map.getFromRatio(), map.getToRatio())); + } + return copy; + } + + /** + * get the sequence being mapped to - if any + * + * @return null or a dataset sequence + */ + public SequenceI getTo() + { + return to; + } + + /** + * set the dataset sequence being mapped to if any + * + * @param tto + */ + public void setTo(SequenceI tto) + { + to = tto; + } + + /** + * Returns an iterator which can serve up the aligned codon column positions + * and their corresponding peptide products + * + * @param seq + * an aligned (i.e. possibly gapped) sequence + * @param gapChar + * @return + */ + public Iterator getCodonIterator(SequenceI seq, + char gapChar) + { + return new AlignedCodonIterator(seq, gapChar); + } + + /** + * Readable representation for debugging only, not guaranteed not to change + */ + @Override + public String toString() + { + return String.format("%s %s", this.map.toString(), + this.to == null ? "" : this.to.getName()); + } + + /** + * Returns the identifier for the 'from' range sequence, or null if not set + * + * @return + */ + public String getMappedFromId() + { + return mappedFromId; + } + + /** + * Sets the identifier for the 'from' range sequence + */ + public void setMappedFromId(String mappedFromId) + { + this.mappedFromId = mappedFromId; + } + +} -- 1.7.10.2