import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
-import jalview.io.gff.SequenceOntologyFactory;
+import jalview.datamodel.features.SequenceFeatures;
import jalview.io.gff.SequenceOntologyI;
import jalview.schemes.ResidueProperties;
import jalview.util.Comparison;
import jalview.util.DBRefUtils;
+import jalview.util.IntRangeComparator;
import jalview.util.MapList;
import jalview.util.MappingUtils;
import jalview.util.StringUtils;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
-import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.Set;
+import java.util.SortedMap;
import java.util.TreeMap;
/**
}
}
// TODO use Character.toLowerCase to avoid creating String objects?
- char[] upstream = new String(ds.getSequence(s.getStart() - 1
- - ustream_ds, s.getStart() - 1)).toLowerCase().toCharArray();
- char[] downstream = new String(ds.getSequence(s_end - 1, s_end
- + dstream_ds)).toLowerCase().toCharArray();
+ char[] upstream = new String(ds
+ .getSequence(s.getStart() - 1 - ustream_ds, s.getStart() - 1))
+ .toLowerCase().toCharArray();
+ char[] downstream = new String(
+ ds.getSequence(s_end - 1, s_end + dstream_ds)).toLowerCase()
+ .toCharArray();
char[] coreseq = s.getSequence();
char[] nseq = new char[offset + upstream.length + downstream.length
+ coreseq.length];
System.arraycopy(upstream, 0, nseq, p, upstream.length);
System.arraycopy(coreseq, 0, nseq, p + upstream.length,
coreseq.length);
- System.arraycopy(downstream, 0, nseq, p + coreseq.length
- + upstream.length, downstream.length);
+ System.arraycopy(downstream, 0, nseq,
+ p + coreseq.length + upstream.length, downstream.length);
s.setSequence(new String(nseq));
s.setStart(s.getStart() - ustream_ds);
s.setEnd(s_end + downstream.length);
* @return
*/
protected static boolean mapProteinToCdna(
- final AlignmentI proteinAlignment,
- final AlignmentI cdnaAlignment, Set<SequenceI> mappedDna,
- Set<SequenceI> mappedProtein, boolean xrefsOnly)
+ final AlignmentI proteinAlignment, final AlignmentI cdnaAlignment,
+ Set<SequenceI> mappedDna, Set<SequenceI> mappedProtein,
+ boolean xrefsOnly)
{
boolean mappingExistsOrAdded = false;
List<SequenceI> thisSeqs = proteinAlignment.getSequences();
* Don't map non-xrefd sequences more than once each. This heuristic
* allows us to pair up similar sequences in ordered alignments.
*/
- if (!xrefsOnly
- && (mappedProtein.contains(aaSeq) || mappedDna
- .contains(cdnaSeq)))
+ if (!xrefsOnly && (mappedProtein.contains(aaSeq)
+ || mappedDna.contains(cdnaSeq)))
{
continue;
}
/**
* Builds a mapping (if possible) of a cDNA to a protein sequence.
* <ul>
- * <li>first checks if the cdna translates exactly to the protein sequence</li>
+ * <li>first checks if the cdna translates exactly to the protein
+ * sequence</li>
* <li>else checks for translation after removing a STOP codon</li>
* <li>else checks for translation after removing a START codon</li>
* <li>if that fails, inspect CDS features on the cDNA sequence</li>
* String objects.
*/
final SequenceI proteinDataset = proteinSeq.getDatasetSequence();
- char[] aaSeqChars = proteinDataset != null ? proteinDataset
- .getSequence() : proteinSeq.getSequence();
+ char[] aaSeqChars = proteinDataset != null
+ ? proteinDataset.getSequence()
+ : proteinSeq.getSequence();
final SequenceI cdnaDataset = cdnaSeq.getDatasetSequence();
char[] cdnaSeqChars = cdnaDataset != null ? cdnaDataset.getSequence()
: cdnaSeq.getSequence();
* If lengths still don't match, try ignoring start codon.
*/
int startOffset = 0;
- if (cdnaLength != mappedLength
- && cdnaLength > 2
+ if (cdnaLength != mappedLength && cdnaLength > 2
&& String.valueOf(cdnaSeqChars, 0, CODON_LENGTH).toUpperCase()
.equals(ResidueProperties.START))
{
/*
* protein is translation of dna (+/- start/stop codons)
*/
- MapList map = new MapList(new int[] { cdnaStart, cdnaEnd }, new int[]
- { proteinStart, proteinEnd }, CODON_LENGTH, 1);
+ MapList map = new MapList(new int[] { cdnaStart, cdnaEnd },
+ new int[]
+ { proteinStart, proteinEnd }, CODON_LENGTH, 1);
return map;
}
int aaPos = 0;
int dnaPos = cdnaStart;
- for (; dnaPos < cdnaSeqChars.length - 2 && aaPos < aaSeqChars.length; dnaPos += CODON_LENGTH, aaPos++)
+ for (; dnaPos < cdnaSeqChars.length - 2
+ && aaPos < aaSeqChars.length; dnaPos += CODON_LENGTH, aaPos++)
{
String codon = String.valueOf(cdnaSeqChars, dnaPos, CODON_LENGTH);
final String translated = ResidueProperties.codonTranslate(codon);
* @param preserveUnmappedGaps
* @param preserveMappedGaps
*/
- public static void alignSequenceAs(SequenceI alignTo,
- SequenceI alignFrom, AlignedCodonFrame mapping, String myGap,
- char sourceGap, boolean preserveMappedGaps,
- boolean preserveUnmappedGaps)
+ public static void alignSequenceAs(SequenceI alignTo, SequenceI alignFrom,
+ AlignedCodonFrame mapping, String myGap, char sourceGap,
+ boolean preserveMappedGaps, boolean preserveUnmappedGaps)
{
// TODO generalise to work for Protein-Protein, dna-dna, dna-protein
int toOffset = alignTo.getStart() - 1;
int sourceGapMappedLength = 0;
boolean inExon = false;
- final char[] thisSeq = alignTo.getSequence();
- final char[] thatAligned = alignFrom.getSequence();
- StringBuilder thisAligned = new StringBuilder(2 * thisSeq.length);
+ final int toLength = alignTo.getLength();
+ final int fromLength = alignFrom.getLength();
+ StringBuilder thisAligned = new StringBuilder(2 * toLength);
/*
* Traverse the 'model' aligned sequence
*/
- for (char sourceChar : thatAligned)
+ for (int i = 0; i < fromLength; i++)
{
+ char sourceChar = alignFrom.getCharAt(i);
if (sourceChar == sourceGap)
{
sourceGapMappedLength += ratio;
*/
int intronLength = 0;
while (basesWritten + toOffset < mappedCodonEnd
- && thisSeqPos < thisSeq.length)
+ && thisSeqPos < toLength)
{
- final char c = thisSeq[thisSeqPos++];
+ final char c = alignTo.getCharAt(thisSeqPos++);
if (c != myGapChar)
{
basesWritten++;
int gapsToAdd = calculateGapsToInsert(preserveMappedGaps,
preserveUnmappedGaps, sourceGapMappedLength, inExon,
trailingCopiedGap.length(), intronLength, startOfCodon);
- for (int i = 0; i < gapsToAdd; i++)
+ for (int k = 0; k < gapsToAdd; k++)
{
thisAligned.append(myGapChar);
}
* At end of model aligned sequence. Copy any remaining target sequence, optionally
* including (intron) gaps.
*/
- while (thisSeqPos < thisSeq.length)
+ while (thisSeqPos < toLength)
{
- final char c = thisSeq[thisSeqPos++];
+ final char c = alignTo.getCharAt(thisSeqPos++);
if (c != myGapChar || preserveUnmappedGaps)
{
thisAligned.append(c);
}
else
{
- gapsToAdd = Math.min(intronLength + trailingGapLength
- - sourceGapMappedLength, trailingGapLength);
+ gapsToAdd = Math.min(
+ intronLength + trailingGapLength - sourceGapMappedLength,
+ trailingGapLength);
}
}
}
* @return
*/
static boolean alignCdsSequenceAsProtein(SequenceI cdsSeq,
- AlignmentI protein, List<AlignedCodonFrame> mappings, char gapChar)
+ AlignmentI protein, List<AlignedCodonFrame> mappings,
+ char gapChar)
{
SequenceI cdsDss = cdsSeq.getDatasetSequence();
if (cdsDss == null)
SequenceI peptide = mapping.findAlignedSequence(cdsSeq, protein);
if (peptide != null)
{
- int peptideLength = peptide.getLength();
+ final int peptideLength = peptide.getLength();
Mapping map = mapping.getMappingBetween(cdsSeq, peptide);
if (map != null)
{
{
mapList = mapList.getInverse();
}
- int cdsLength = cdsDss.getLength();
+ final int cdsLength = cdsDss.getLength();
int mappedFromLength = MappingUtils.getLength(mapList
.getFromRanges());
int mappedToLength = MappingUtils
.getLength(mapList.getToRanges());
boolean addStopCodon = (cdsLength == mappedFromLength
* CODON_LENGTH + CODON_LENGTH)
- || (peptide.getDatasetSequence().getLength() == mappedFromLength - 1);
+ || (peptide.getDatasetSequence()
+ .getLength() == mappedFromLength - 1);
if (cdsLength != mappedToLength && !addStopCodon)
{
- System.err
- .println(String
- .format("Can't align cds as protein (length mismatch %d/%d): %s",
- cdsLength, mappedToLength,
- cdsSeq.getName()));
+ System.err.println(String.format(
+ "Can't align cds as protein (length mismatch %d/%d): %s",
+ cdsLength, mappedToLength, cdsSeq.getName()));
}
/*
* walk over the aligned peptide sequence and insert mapped
* codons for residues in the aligned cds sequence
*/
- char[] alignedPeptide = peptide.getSequence();
- char[] nucleotides = cdsDss.getSequence();
int copiedBases = 0;
int cdsStart = cdsDss.getStart();
int proteinPos = peptide.getStart() - 1;
int cdsCol = 0;
- for (char residue : alignedPeptide)
+
+ for (int col = 0; col < peptideLength; col++)
{
+ char residue = peptide.getCharAt(col);
+
if (Comparison.isGap(residue))
{
cdsCol += CODON_LENGTH;
{
for (int j = codon[0]; j <= codon[1]; j++)
{
- char mappedBase = nucleotides[j - cdsStart];
+ char mappedBase = cdsDss.getCharAt(j - cdsStart);
alignedCds[cdsCol++] = mappedBase;
copiedBases++;
}
* append stop codon if not mapped from protein,
* closing it up to the end of the mapped sequence
*/
- if (copiedBases == nucleotides.length - CODON_LENGTH)
+ if (copiedBases == cdsLength - CODON_LENGTH)
{
for (int i = alignedCds.length - 1; i >= 0; i--)
{
break;
}
}
- for (int i = nucleotides.length - CODON_LENGTH; i < nucleotides.length; i++)
+ for (int i = cdsLength - CODON_LENGTH; i < cdsLength; i++)
{
- alignedCds[cdsCol++] = nucleotides[i];
+ alignedCds[cdsCol++] = cdsDss.getCharAt(i);
}
}
cdsSeq.setSequence(new String(alignedCds));
if (prot != null)
{
Mapping seqMap = mapping.getMappingForSequence(dnaSeq);
- addCodonPositions(dnaSeq, prot, protein.getGapCharacter(),
- seqMap, alignedCodons);
+ addCodonPositions(dnaSeq, prot, protein.getGapCharacter(), seqMap,
+ alignedCodons);
unmappedProtein.remove(prot);
}
}
AlignedCodon codon = sequenceCodon.getValue();
if (codon.peptideCol > 1)
{
- System.err
- .println("Problem mapping protein with >1 unmapped start positions: "
+ System.err.println(
+ "Problem mapping protein with >1 unmapped start positions: "
+ seq.getName());
}
else if (codon.peptideCol == 1)
if (lastCodon != null)
{
AlignedCodon firstPeptide = new AlignedCodon(lastCodon.pos1,
- lastCodon.pos2, lastCodon.pos3, String.valueOf(seq
- .getCharAt(0)), 0);
+ lastCodon.pos2, lastCodon.pos3,
+ String.valueOf(seq.getCharAt(0)), 0);
toAdd.put(seq, firstPeptide);
}
else
List<SequenceI> unmappedProtein)
{
/*
- * Prefill aligned sequences with gaps before inserting aligned protein
- * residues.
+ * prefill peptide sequences with gaps
*/
int alignedWidth = alignedCodons.size();
char[] gaps = new char[alignedWidth];
Arrays.fill(gaps, protein.getGapCharacter());
- String allGaps = String.valueOf(gaps);
+ Map<SequenceI, char[]> peptides = new HashMap<>();
for (SequenceI seq : protein.getSequences())
{
if (!unmappedProtein.contains(seq))
{
- seq.setSequence(allGaps);
+ peptides.put(seq, Arrays.copyOf(gaps, gaps.length));
}
}
+ /*
+ * Traverse the codons left to right (as defined by CodonComparator)
+ * and insert peptides in each column where the sequence is mapped.
+ * This gives a peptide 'alignment' where residues are aligned if their
+ * corresponding codons occupy the same columns in the cdna alignment.
+ */
int column = 0;
for (AlignedCodon codon : alignedCodons.keySet())
{
.get(codon);
for (Entry<SequenceI, AlignedCodon> entry : columnResidues.entrySet())
{
- // place translated codon at its column position in sequence
- entry.getKey().getSequence()[column] = entry.getValue().product
- .charAt(0);
+ char residue = entry.getValue().product.charAt(0);
+ peptides.get(entry.getKey())[column] = residue;
}
column++;
}
+
+ /*
+ * and finally set the constructed sequences
+ */
+ for (Entry<SequenceI, char[]> entry : peptides.entrySet())
+ {
+ entry.getKey().setSequence(new String(entry.getValue()));
+ }
+
return 0;
}
* <ul>
* <li>One alignment must be nucleotide, and the other protein</li>
* <li>At least one pair of sequences must be already mapped, or mappable</li>
- * <li>Mappable means the nucleotide translation matches the protein sequence</li>
+ * <li>Mappable means the nucleotide translation matches the protein
+ * sequence</li>
* <li>The translation may ignore start and stop codons if present in the
* nucleotide</li>
* </ul>
return false;
}
- SequenceI dnaDs = dnaSeq.getDatasetSequence() == null ? dnaSeq : dnaSeq
- .getDatasetSequence();
- SequenceI proteinDs = proteinSeq.getDatasetSequence() == null ? proteinSeq
+ SequenceI dnaDs = dnaSeq.getDatasetSequence() == null ? dnaSeq
+ : dnaSeq.getDatasetSequence();
+ SequenceI proteinDs = proteinSeq.getDatasetSequence() == null
+ ? proteinSeq
: proteinSeq.getDatasetSequence();
for (AlignedCodonFrame mapping : mappings)
* the alignment to check for presence of annotations
*/
public static void findAddableReferenceAnnotations(
- List<SequenceI> sequenceScope,
- Map<String, String> labelForCalcId,
+ List<SequenceI> sequenceScope, Map<String, String> labelForCalcId,
final Map<SequenceI, List<AlignmentAnnotation>> candidates,
AlignmentI al)
{
/**
* Set visibility of alignment annotations of specified types (labels), for
- * specified sequences. This supports controls like
- * "Show all secondary structure", "Hide all Temp factor", etc.
+ * specified sequences. This supports controls like "Show all secondary
+ * structure", "Hide all Temp factor", etc.
*
* @al the alignment to scan for annotations
* @param types
{
if (anyType || types.contains(aa.label))
{
- if ((aa.sequenceRef != null)
- && (forSequences == null || forSequences
- .contains(aa.sequenceRef)))
+ if ((aa.sequenceRef != null) && (forSequences == null
+ || forSequences.contains(aa.sequenceRef)))
{
aa.visible = doShow;
}
productSeqs = new HashSet<SequenceI>();
for (SequenceI seq : products)
{
- productSeqs.add(seq.getDatasetSequence() == null ? seq : seq
- .getDatasetSequence());
+ productSeqs.add(seq.getDatasetSequence() == null ? seq
+ : seq.getDatasetSequence());
}
}
/*
* add a mapping from CDS to the (unchanged) mapped to range
*/
- List<int[]> cdsRange = Collections.singletonList(new int[] { 1,
- cdsSeq.getLength() });
+ List<int[]> cdsRange = Collections
+ .singletonList(new int[]
+ { 1, cdsSeq.getLength() });
MapList cdsToProteinMap = new MapList(cdsRange,
mapList.getToRanges(), mapList.getFromRatio(),
mapList.getToRatio());
// 'CDS|emblcdsacc'
// assuming cds version same as dna ?!?
- DBRefEntry proteinToCdsRef = new DBRefEntry(
- primRef.getSource(), primRef.getVersion(),
- cdsSeq.getName());
+ DBRefEntry proteinToCdsRef = new DBRefEntry(primRef.getSource(),
+ primRef.getVersion(), cdsSeq.getName());
//
- proteinToCdsRef.setMap(new Mapping(cdsSeqDss, cdsToProteinMap
- .getInverse()));
+ proteinToCdsRef.setMap(
+ new Mapping(cdsSeqDss, cdsToProteinMap.getInverse()));
proteinProduct.addDBRef(proteinToCdsRef);
}
}
}
- AlignmentI cds = new Alignment(cdsSeqs.toArray(new SequenceI[cdsSeqs
- .size()]));
+ AlignmentI cds = new Alignment(
+ cdsSeqs.toArray(new SequenceI[cdsSeqs.size()]));
cds.setDataset(dataset);
return cds;
* is this mapping from the whole dna sequence (i.e. CDS)?
* allowing for possible stop codon on dna but not peptide
*/
- int mappedFromLength = MappingUtils.getLength(aMapping.getMap()
- .getFromRanges());
+ int mappedFromLength = MappingUtils
+ .getLength(aMapping.getMap().getFromRanges());
int dnaLength = seqDss.getLength();
if (mappedFromLength == dnaLength
|| mappedFromLength == dnaLength - CODON_LENGTH)
&& proteinProduct == mapping.getTo()
&& seqDss != map.getFromSeq())
{
- mappedFromLength = MappingUtils.getLength(mapping.getMap()
- .getFromRanges());
+ mappedFromLength = MappingUtils
+ .getLength(mapping.getMap().getFromRanges());
if (mappedFromLength == map.getFromSeq().getLength())
{
/*
}
else
{
- System.err
- .println("JAL-2154 regression: warning - found (and ignnored a duplicate CDS sequence):"
+ System.err.println(
+ "JAL-2154 regression: warning - found (and ignnored a duplicate CDS sequence):"
+ mtch.toString());
}
}
for (DBRefEntry cdsref : direct)
{
// clone maplist and mapping
- MapList cdsposmap = new MapList(Arrays.asList(new int[][] { new int[]
- { cdsSeq.getStart(), cdsSeq.getEnd() } }), cdsref.getMap().getMap()
- .getToRanges(), 3, 1);
- Mapping cdsmap = new Mapping(cdsref.getMap().getTo(), cdsref.getMap()
- .getMap());
+ MapList cdsposmap = new MapList(
+ Arrays.asList(new int[][]
+ { new int[] { cdsSeq.getStart(), cdsSeq.getEnd() } }),
+ cdsref.getMap().getMap().getToRanges(), 3, 1);
+ Mapping cdsmap = new Mapping(cdsref.getMap().getTo(),
+ cdsref.getMap().getMap());
// create dbref
DBRefEntry newref = new DBRefEntry(cdsref.getSource(),
- cdsref.getVersion(), cdsref.getAccessionId(), new Mapping(
- cdsmap.getTo(), cdsposmap));
+ cdsref.getVersion(), cdsref.getAccessionId(),
+ new Mapping(cdsmap.getTo(), cdsposmap));
// and see if we can map to the protein product for this mapping.
// onSource is the filtered set of accessions on protein that we are
*
* @param fromSeq
* @param toSeq
+ * @param mapping
+ * the mapping from 'fromSeq' to 'toSeq'
* @param select
* if not null, only features of this type are copied (including
* subtypes in the Sequence Ontology)
- * @param mapping
- * the mapping from 'fromSeq' to 'toSeq'
* @param omitting
*/
public static int transferFeatures(SequenceI fromSeq, SequenceI toSeq,
copyTo = copyTo.getDatasetSequence();
}
- SequenceOntologyI so = SequenceOntologyFactory.getInstance();
+ /*
+ * get features, optionally restricted by an ontology term
+ */
+ List<SequenceFeature> sfs = select == null ? fromSeq.getFeatures()
+ .getPositionalFeatures() : fromSeq.getFeatures()
+ .getFeaturesByOntology(select);
+
int count = 0;
- SequenceFeature[] sfs = fromSeq.getSequenceFeatures();
- if (sfs != null)
+ for (SequenceFeature sf : sfs)
{
- for (SequenceFeature sf : sfs)
+ String type = sf.getType();
+ boolean omit = false;
+ for (String toOmit : omitting)
{
- String type = sf.getType();
- if (select != null && !so.isA(type, select))
- {
- continue;
- }
- boolean omit = false;
- for (String toOmit : omitting)
- {
- if (type.equals(toOmit))
- {
- omit = true;
- }
- }
- if (omit)
+ if (type.equals(toOmit))
{
- continue;
+ omit = true;
}
+ }
+ if (omit)
+ {
+ continue;
+ }
- /*
- * locate the mapped range - null if either start or end is
- * not mapped (no partial overlaps are calculated)
- */
- int start = sf.getBegin();
- int end = sf.getEnd();
- int[] mappedTo = mapping.locateInTo(start, end);
- /*
- * if whole exon range doesn't map, try interpreting it
- * as 5' or 3' exon overlapping the CDS range
- */
- if (mappedTo == null)
- {
- mappedTo = mapping.locateInTo(end, end);
- if (mappedTo != null)
- {
- /*
- * end of exon is in CDS range - 5' overlap
- * to a range from the start of the peptide
- */
- mappedTo[0] = 1;
- }
- }
- if (mappedTo == null)
+ /*
+ * locate the mapped range - null if either start or end is
+ * not mapped (no partial overlaps are calculated)
+ */
+ int start = sf.getBegin();
+ int end = sf.getEnd();
+ int[] mappedTo = mapping.locateInTo(start, end);
+ /*
+ * if whole exon range doesn't map, try interpreting it
+ * as 5' or 3' exon overlapping the CDS range
+ */
+ if (mappedTo == null)
+ {
+ mappedTo = mapping.locateInTo(end, end);
+ if (mappedTo != null)
{
- mappedTo = mapping.locateInTo(start, start);
- if (mappedTo != null)
- {
- /*
- * start of exon is in CDS range - 3' overlap
- * to a range up to the end of the peptide
- */
- mappedTo[1] = toSeq.getLength();
- }
+ /*
+ * end of exon is in CDS range - 5' overlap
+ * to a range from the start of the peptide
+ */
+ mappedTo[0] = 1;
}
+ }
+ if (mappedTo == null)
+ {
+ mappedTo = mapping.locateInTo(start, start);
if (mappedTo != null)
{
- SequenceFeature copy = new SequenceFeature(sf);
- copy.setBegin(Math.min(mappedTo[0], mappedTo[1]));
- copy.setEnd(Math.max(mappedTo[0], mappedTo[1]));
- copyTo.addSequenceFeature(copy);
- count++;
+ /*
+ * start of exon is in CDS range - 3' overlap
+ * to a range up to the end of the peptide
+ */
+ mappedTo[1] = toSeq.getLength();
}
}
+ if (mappedTo != null)
+ {
+ int newBegin = Math.min(mappedTo[0], mappedTo[1]);
+ int newEnd = Math.max(mappedTo[0], mappedTo[1]);
+ SequenceFeature copy = new SequenceFeature(sf, newBegin, newEnd,
+ sf.getFeatureGroup(), sf.getScore());
+ copyTo.addSequenceFeature(copy);
+ count++;
+ }
}
return count;
}
public static List<int[]> findCdsPositions(SequenceI dnaSeq)
{
List<int[]> result = new ArrayList<int[]>();
- SequenceFeature[] sfs = dnaSeq.getSequenceFeatures();
- if (sfs == null)
+
+ List<SequenceFeature> sfs = dnaSeq.getFeatures().getFeaturesByOntology(
+ SequenceOntologyI.CDS);
+ if (sfs.isEmpty())
{
return result;
}
-
- SequenceOntologyI so = SequenceOntologyFactory.getInstance();
+ SequenceFeatures.sortFeatures(sfs, true);
int startPhase = 0;
for (SequenceFeature sf : sfs)
{
+ int phase = 0;
+ try
+ {
+ phase = Integer.parseInt(sf.getPhase());
+ } catch (NumberFormatException e)
+ {
+ // ignore
+ }
/*
- * process a CDS feature (or a sub-type of CDS)
+ * phase > 0 on first codon means 5' incomplete - skip to the start
+ * of the next codon; example ENST00000496384
*/
- if (so.isA(sf.getType(), SequenceOntologyI.CDS))
+ int begin = sf.getBegin();
+ int end = sf.getEnd();
+ if (result.isEmpty())
{
- int phase = 0;
- try
- {
- phase = Integer.parseInt(sf.getPhase());
- } catch (NumberFormatException e)
- {
- // ignore
- }
- /*
- * phase > 0 on first codon means 5' incomplete - skip to the start
- * of the next codon; example ENST00000496384
- */
- int begin = sf.getBegin();
- int end = sf.getEnd();
- if (result.isEmpty())
+ begin += phase;
+ if (begin > end)
{
- begin += phase;
- if (begin > end)
- {
- // shouldn't happen!
- System.err
- .println("Error: start phase extends beyond start CDS in "
- + dnaSeq.getName());
- }
+ // shouldn't happen!
+ System.err
+ .println("Error: start phase extends beyond start CDS in "
+ + dnaSeq.getName());
}
- result.add(new int[] { begin, end });
}
+ result.add(new int[] { begin, end });
}
/*
* ranges are assembled in order. Other cases should not use this method,
* but instead construct an explicit mapping for CDS (e.g. EMBL parsing).
*/
- Collections.sort(result, new Comparator<int[]>()
- {
- @Override
- public int compare(int[] o1, int[] o2)
- {
- return Integer.compare(o1[0], o2[0]);
- }
- });
+ Collections.sort(result, IntRangeComparator.ASCENDING);
return result;
}
count += computePeptideVariants(peptide, peptidePos, codonVariants);
}
- /*
- * sort to get sequence features in start position order
- * - would be better to store in Sequence as a TreeSet or NCList?
- */
- if (peptide.getSequenceFeatures() != null)
- {
- Arrays.sort(peptide.getSequenceFeatures(),
- new Comparator<SequenceFeature>()
- {
- @Override
- public int compare(SequenceFeature o1, SequenceFeature o2)
- {
- int c = Integer.compare(o1.getBegin(), o2.getBegin());
- return c == 0 ? Integer.compare(o1.getEnd(), o2.getEnd())
- : c;
- }
- });
- }
return count;
}
* are currently ignored here
*/
String trans = codon.contains("-") ? "-"
- : (codon.length() > CODON_LENGTH ? null : ResidueProperties
- .codonTranslate(codon));
+ : (codon.length() > CODON_LENGTH ? null
+ : ResidueProperties.codonTranslate(codon));
if (trans != null && !trans.equals(residue))
{
String residue3Char = StringUtils
String trans3Char = StringUtils
.toSentenceCase(ResidueProperties.aa2Triplet.get(trans));
String desc = "p." + residue3Char + peptidePos + trans3Char;
- // set score to 0f so 'graduated colour' option is offered! JAL-2060
SequenceFeature sf = new SequenceFeature(
SequenceOntologyI.SEQUENCE_VARIANT, desc, peptidePos,
- peptidePos, 0f, var.getSource());
+ peptidePos, var.getSource());
StringBuilder attributes = new StringBuilder(32);
String id = (String) var.variant.getValue(ID);
if (id != null)
StringBuilder link = new StringBuilder(32);
try
{
- link.append(desc)
- .append(" ")
- .append(id)
- .append("|http://www.ensembl.org/Homo_sapiens/Variation/Summary?v=")
+ link.append(desc).append(" ").append(id).append(
+ "|http://www.ensembl.org/Homo_sapiens/Variation/Summary?v=")
.append(URLEncoder.encode(id, "UTF-8"));
sf.addLink(link.toString());
} catch (UnsupportedEncodingException e)
* LinkedHashMap ensures we keep the peptide features in sequence order
*/
LinkedHashMap<Integer, List<DnaVariant>[]> variants = new LinkedHashMap<Integer, List<DnaVariant>[]>();
- SequenceOntologyI so = SequenceOntologyFactory.getInstance();
- SequenceFeature[] dnaFeatures = dnaSeq.getSequenceFeatures();
- if (dnaFeatures == null)
+ List<SequenceFeature> dnaFeatures = dnaSeq.getFeatures()
+ .getFeaturesByOntology(SequenceOntologyI.SEQUENCE_VARIANT);
+ if (dnaFeatures.isEmpty())
{
return variants;
}
// not handling multi-locus variant features
continue;
}
- if (so.isA(sf.getType(), SequenceOntologyI.SEQUENCE_VARIANT))
+ int[] mapsTo = dnaToProtein.locateInTo(dnaCol, dnaCol);
+ if (mapsTo == null)
{
- int[] mapsTo = dnaToProtein.locateInTo(dnaCol, dnaCol);
- if (mapsTo == null)
- {
- // feature doesn't lie within coding region
- continue;
- }
- int peptidePosition = mapsTo[0];
- List<DnaVariant>[] codonVariants = variants.get(peptidePosition);
- if (codonVariants == null)
- {
- codonVariants = new ArrayList[CODON_LENGTH];
- codonVariants[0] = new ArrayList<DnaVariant>();
- codonVariants[1] = new ArrayList<DnaVariant>();
- codonVariants[2] = new ArrayList<DnaVariant>();
- variants.put(peptidePosition, codonVariants);
- }
+ // feature doesn't lie within coding region
+ continue;
+ }
+ int peptidePosition = mapsTo[0];
+ List<DnaVariant>[] codonVariants = variants.get(peptidePosition);
+ if (codonVariants == null)
+ {
+ codonVariants = new ArrayList[CODON_LENGTH];
+ codonVariants[0] = new ArrayList<DnaVariant>();
+ codonVariants[1] = new ArrayList<DnaVariant>();
+ codonVariants[2] = new ArrayList<DnaVariant>();
+ variants.put(peptidePosition, codonVariants);
+ }
- /*
- * extract dna variants to a string array
- */
- String alls = (String) sf.getValue("alleles");
- if (alls == null)
- {
- continue;
- }
- String[] alleles = alls.toUpperCase().split(",");
- int i = 0;
- for (String allele : alleles)
- {
- alleles[i++] = allele.trim(); // lose any space characters "A, G"
- }
+ /*
+ * extract dna variants to a string array
+ */
+ String alls = (String) sf.getValue("alleles");
+ if (alls == null)
+ {
+ continue;
+ }
+ String[] alleles = alls.toUpperCase().split(",");
+ int i = 0;
+ for (String allele : alleles)
+ {
+ alleles[i++] = allele.trim(); // lose any space characters "A, G"
+ }
- /*
- * get this peptide's codon positions e.g. [3, 4, 5] or [4, 7, 10]
- */
- int[] codon = peptidePosition == lastPeptidePostion ? lastCodon
- : MappingUtils.flattenRanges(dnaToProtein.locateInFrom(
- peptidePosition, peptidePosition));
- lastPeptidePostion = peptidePosition;
- lastCodon = codon;
+ /*
+ * get this peptide's codon positions e.g. [3, 4, 5] or [4, 7, 10]
+ */
+ int[] codon = peptidePosition == lastPeptidePostion ? lastCodon
+ : MappingUtils.flattenRanges(dnaToProtein.locateInFrom(
+ peptidePosition, peptidePosition));
+ lastPeptidePostion = peptidePosition;
+ lastCodon = codon;
- /*
- * save nucleotide (and any variant) for each codon position
- */
- for (int codonPos = 0; codonPos < CODON_LENGTH; codonPos++)
+ /*
+ * save nucleotide (and any variant) for each codon position
+ */
+ for (int codonPos = 0; codonPos < CODON_LENGTH; codonPos++)
+ {
+ String nucleotide = String.valueOf(
+ dnaSeq.getCharAt(codon[codonPos] - dnaStart)).toUpperCase();
+ List<DnaVariant> codonVariant = codonVariants[codonPos];
+ if (codon[codonPos] == dnaCol)
{
- String nucleotide = String.valueOf(
- dnaSeq.getCharAt(codon[codonPos] - dnaStart))
- .toUpperCase();
- List<DnaVariant> codonVariant = codonVariants[codonPos];
- if (codon[codonPos] == dnaCol)
+ if (!codonVariant.isEmpty()
+ && codonVariant.get(0).variant == null)
{
- if (!codonVariant.isEmpty()
- && codonVariant.get(0).variant == null)
- {
- /*
- * already recorded base value, add this variant
- */
- codonVariant.get(0).variant = sf;
- }
- else
- {
- /*
- * add variant with base value
- */
- codonVariant.add(new DnaVariant(nucleotide, sf));
- }
+ /*
+ * already recorded base value, add this variant
+ */
+ codonVariant.get(0).variant = sf;
}
- else if (codonVariant.isEmpty())
+ else
{
/*
- * record (possibly non-varying) base value
+ * add variant with base value
*/
- codonVariant.add(new DnaVariant(nucleotide));
+ codonVariant.add(new DnaVariant(nucleotide, sf));
}
}
+ else if (codonVariant.isEmpty())
+ {
+ /*
+ * record (possibly non-varying) base value
+ */
+ codonVariant.add(new DnaVariant(nucleotide));
+ }
}
}
return variants;
*/
for (SequenceI seq : unaligned.getSequences())
{
- List<SequenceI> alignedSequences = alignedDatasets.get(seq
- .getDatasetSequence());
+ List<SequenceI> alignedSequences = alignedDatasets
+ .get(seq.getDatasetSequence());
// TODO: getSequenceAsString() will be deprecated in the future
// TODO: need to leave to SequenceI implementor to update gaps
seq.setSequence(alignedSequences.get(0).getSequenceAsString());
* @param unmapped
* @return
*/
- static Map<Integer, Map<SequenceI, Character>> buildMappedColumnsMap(
- AlignmentI unaligned, AlignmentI aligned, List<SequenceI> unmapped)
+ static SortedMap<Integer, Map<SequenceI, Character>> buildMappedColumnsMap(
+ AlignmentI unaligned, AlignmentI aligned,
+ List<SequenceI> unmapped)
{
/*
* Map will hold, for each aligned column position, a map of
* {unalignedSequence, characterPerSequence} at that position.
* TreeMap keeps the entries in ascending column order.
*/
- Map<Integer, Map<SequenceI, Character>> map = new TreeMap<Integer, Map<SequenceI, Character>>();
+ SortedMap<Integer, Map<SequenceI, Character>> map = new TreeMap<Integer, Map<SequenceI, Character>>();
/*
* record any sequences that have no mapping so can't be realigned
}
/**
- * Helper method that adds to a map the mapped column positions of a sequence. <br>
+ * Helper method that adds to a map the mapped column positions of a sequence.
+ * <br>
* For example if aaTT-Tg-gAAA is mapped to TTTAAA then the map should record
* that columns 3,4,6,10,11,12 map to characters T,T,T,A,A,A of the mapped to
* sequence.
*/
if (seqMap.getTo() == fromSeq.getDatasetSequence())
{
- seqMap = new Mapping(seq.getDatasetSequence(), seqMap.getMap()
- .getInverse());
+ seqMap = new Mapping(seq.getDatasetSequence(),
+ seqMap.getMap().getInverse());
}
- char[] fromChars = fromSeq.getSequence();
int toStart = seq.getStart();
- char[] toChars = seq.getSequence();
/*
* traverse [start, end, start, end...] ranges in fromSeq
* of the next character of the mapped-to sequence; stop when all
* the characters of the range have been counted
*/
- while (mappedCharPos <= range[1] && fromCol <= fromChars.length
+ while (mappedCharPos <= range[1] && fromCol <= fromSeq.getLength()
&& fromCol >= 0)
{
- if (!Comparison.isGap(fromChars[fromCol - 1]))
+ if (!Comparison.isGap(fromSeq.getCharAt(fromCol - 1)))
{
/*
* mapped from sequence has a character in this column
seqsMap = new HashMap<SequenceI, Character>();
map.put(fromCol, seqsMap);
}
- seqsMap.put(seq, toChars[mappedCharPos - toStart]);
+ seqsMap.put(seq, seq.getCharAt(mappedCharPos - toStart));
mappedCharPos++;
}
fromCol += (forward ? 1 : -1);