* @param cdnaAlignment
* @return
*/
- public static boolean mapProteinToCdna(
- final AlignmentI proteinAlignment,
- final AlignmentI cdnaAlignment)
+ public static boolean mapProteinAlignmentToCdna(
+ final AlignmentI proteinAlignment, final AlignmentI cdnaAlignment)
{
if (proteinAlignment == null || cdnaAlignment == null)
{
final AlignmentI cdnaAlignment, Set<SequenceI> mappedDna,
Set<SequenceI> mappedProtein, boolean xrefsOnly)
{
- boolean mappingPerformed = false;
+ boolean mappingExistsOrAdded = false;
List<SequenceI> thisSeqs = proteinAlignment.getSequences();
for (SequenceI aaSeq : thisSeqs)
{
{
continue;
}
- if (!mappingExists(proteinAlignment.getCodonFrames(),
+ if (mappingExists(proteinAlignment.getCodonFrames(),
aaSeq.getDatasetSequence(), cdnaSeq.getDatasetSequence()))
{
- MapList map = mapProteinToCdna(aaSeq, cdnaSeq);
+ mappingExistsOrAdded = true;
+ }
+ else
+ {
+ MapList map = mapProteinSequenceToCdna(aaSeq, cdnaSeq);
if (map != null)
{
acf.addMap(cdnaSeq, aaSeq, map);
- mappingPerformed = true;
+ mappingExistsOrAdded = true;
proteinMapped = true;
mappedDna.add(cdnaSeq);
mappedProtein.add(aaSeq);
proteinAlignment.addCodonFrame(acf);
}
}
- return mappingPerformed;
+ return mappingExistsOrAdded;
}
/**
* @param cdnaSeq
* @return
*/
- public static MapList mapProteinToCdna(SequenceI proteinSeq,
+ public static MapList mapProteinSequenceToCdna(SequenceI proteinSeq,
SequenceI cdnaSeq)
{
/*
*/
final int mappedLength = 3 * aaSeqChars.length;
int cdnaLength = cdnaSeqChars.length;
- int cdnaStart = 1;
- int cdnaEnd = cdnaLength;
- final int proteinStart = 1;
- final int proteinEnd = aaSeqChars.length;
+ int cdnaStart = cdnaSeq.getStart();
+ int cdnaEnd = cdnaSeq.getEnd();
+ final int proteinStart = proteinSeq.getStart();
+ final int proteinEnd = proteinSeq.getEnd();
/*
* If lengths don't match, try ignoring stop codon.
/*
* If lengths still don't match, try ignoring start codon.
*/
+ int startOffset = 0;
if (cdnaLength != mappedLength
&& cdnaLength > 2
&& String.valueOf(cdnaSeqChars, 0, 3).toUpperCase()
- .equals(
- ResidueProperties.START))
+ .equals(ResidueProperties.START))
{
+ startOffset += 3;
cdnaStart += 3;
cdnaLength -= 3;
}
{
return null;
}
- if (!translatesAs(cdnaSeqChars, cdnaStart - 1, aaSeqChars))
+ if (!translatesAs(cdnaSeqChars, startOffset, aaSeqChars))
{
return null;
}
- MapList map = new MapList(new int[]
- { cdnaStart, cdnaEnd }, new int[]
- { proteinStart, proteinEnd }, 3, 1);
+ MapList map = new MapList(new int[] { cdnaStart, cdnaEnd }, new int[] {
+ proteinStart, proteinEnd }, 3, 1);
return map;
}
&& aaResidue < aaSeqChars.length; i += 3, aaResidue++)
{
String codon = String.valueOf(cdnaSeqChars, i, 3);
- final String translated = ResidueProperties.codonTranslate(
- codon);
+ final String translated = ResidueProperties.codonTranslate(codon);
/*
* allow * in protein to match untranslatable in dna
*/
{
continue;
}
- if (translated == null
- || !(aaRes == translated.charAt(0)))
+ if (translated == null || !(aaRes == translated.charAt(0)))
{
// debug
// System.out.println(("Mismatch at " + i + "/" + aaResidue + ": "
boolean preserveUnmappedGaps)
{
/*
- * Get any mappings from the source alignment to the target (dataset) sequence.
+ * Get any mappings from the source alignment to the target (dataset)
+ * sequence.
*/
// TODO there may be one AlignedCodonFrame per dataset sequence, or one with
// all mappings. Would it help to constrain this?
{
return false;
}
-
+
/*
* Locate the aligned source sequence whose dataset sequence is mapped. We
* just take the first match here (as we can't align cDNA like more than one
break;
}
}
-
+
if (alignFrom == null)
{
return false;
* @param preserveMappedGaps
*/
public static void alignSequenceAs(SequenceI alignTo,
- SequenceI alignFrom,
- AlignedCodonFrame mapping, String myGap, char sourceGap,
- boolean preserveMappedGaps, boolean preserveUnmappedGaps)
+ SequenceI alignFrom, AlignedCodonFrame mapping, String myGap,
+ char sourceGap, boolean preserveMappedGaps,
+ boolean preserveUnmappedGaps)
{
// TODO generalise to work for Protein-Protein, dna-dna, dna-protein
final char[] thisSeq = alignTo.getSequence();
final char[] thatAligned = alignFrom.getSequence();
StringBuilder thisAligned = new StringBuilder(2 * thisSeq.length);
-
+
// aligned and dataset sequence positions, all base zero
int thisSeqPos = 0;
int sourceDsPos = 0;
/*
* Traverse the aligned protein sequence.
*/
+ int fromOffset = alignFrom.getStart() - 1;
+ int toOffset = alignTo.getStart() - 1;
int sourceGapMappedLength = 0;
boolean inExon = false;
for (char sourceChar : thatAligned)
sourceDsPos++;
// Note mapping positions are base 1, our sequence positions base 0
int[] mappedPos = mapping.getMappedRegion(alignTo, alignFrom,
- sourceDsPos);
+ sourceDsPos + fromOffset);
if (mappedPos == null)
{
/*
* But then 'align dna as protein' doesn't make much sense otherwise.
*/
int intronLength = 0;
- while (basesWritten < mappedCodonEnd && thisSeqPos < thisSeq.length)
+ while (basesWritten + toOffset < mappedCodonEnd
+ && thisSeqPos < thisSeq.length)
{
final char c = thisSeq[thisSeqPos++];
if (c != myGapChar)
{
basesWritten++;
-
- if (basesWritten < mappedCodonStart)
+ int sourcePosition = basesWritten + toOffset;
+ if (sourcePosition < mappedCodonStart)
{
/*
* Found an unmapped (intron) base. First add in any preceding gaps
}
else
{
- final boolean startOfCodon = basesWritten == mappedCodonStart;
+ final boolean startOfCodon = sourcePosition == mappedCodonStart;
int gapsToAdd = calculateGapsToInsert(preserveMappedGaps,
preserveUnmappedGaps, sourceGapMappedLength, inExon,
trailingCopiedGap.length(), intronLength, startOfCodon);
*/
protected static int calculateGapsToInsert(boolean preserveMappedGaps,
boolean preserveUnmappedGaps, int sourceGapMappedLength,
- boolean inExon, int trailingGapLength,
- int intronLength, final boolean startOfCodon)
+ boolean inExon, int trailingGapLength, int intronLength,
+ final boolean startOfCodon)
{
int gapsToAdd = 0;
if (startOfCodon)
// mapping is from protein to nucleotide
toDna = true;
// should ideally get gap count ratio from mapping
- gap = String.valueOf(new char[]
- { gapCharacter, gapCharacter, gapCharacter });
+ gap = String.valueOf(new char[] { gapCharacter, gapCharacter,
+ gapCharacter });
}
else
{
int column = 0;
for (AlignedCodon codon : alignedCodons.keySet())
{
- final Map<SequenceI, String> columnResidues = alignedCodons.get(codon);
- for (Entry<SequenceI, String> entry : columnResidues
- .entrySet())
+ final Map<SequenceI, String> columnResidues = alignedCodons
+ .get(codon);
+ for (Entry<SequenceI, String> entry : columnResidues.entrySet())
{
// place translated codon at its column position in sequence
entry.getKey().getSequence()[column] = entry.getValue().charAt(0);
* the map we are building up
*/
static void addCodonPositions(SequenceI dna, SequenceI protein,
- char gapChar,
- Mapping seqMap,
+ char gapChar, Mapping seqMap,
Map<AlignedCodon, Map<SequenceI, String>> alignedCodons)
{
Iterator<AlignedCodon> codons = seqMap.getCodonIterator(dna, gapChar);
* @return
*/
protected static boolean isMappable(SequenceI dnaSeq,
- SequenceI proteinSeq,
- Set<AlignedCodonFrame> mappings)
+ SequenceI proteinSeq, Set<AlignedCodonFrame> mappings)
{
if (dnaSeq == null || proteinSeq == null)
{
return false;
}
- SequenceI dnaDs = dnaSeq.getDatasetSequence() == null ? dnaSeq : dnaSeq.getDatasetSequence();
+ SequenceI dnaDs = dnaSeq.getDatasetSequence() == null ? dnaSeq : dnaSeq
+ .getDatasetSequence();
SequenceI proteinDs = proteinSeq.getDatasetSequence() == null ? proteinSeq
: proteinSeq.getDatasetSequence();
-
+
/*
* Already mapped?
*/
- for (AlignedCodonFrame mapping : mappings) {
- if ( proteinDs == mapping.getAaForDnaSeq(dnaDs)) {
+ for (AlignedCodonFrame mapping : mappings)
+ {
+ if (proteinDs == mapping.getAaForDnaSeq(dnaDs))
+ {
return true;
}
}
* Just try to make a mapping (it is not yet stored), test whether
* successful.
*/
- return mapProteinToCdna(proteinDs, dnaDs) != null;
+ return mapProteinSequenceToCdna(proteinDs, dnaDs) != null;
}
/**
* 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)
{
{
return;
}
-
+
/*
* For each sequence in scope, make a list of any annotations on the
* underlying dataset sequence which are not already on the alignment.
* sequence.
*/
final Iterable<AlignmentAnnotation> matchedAlignmentAnnotations = al
- .findAnnotations(seq, dsann.getCalcId(),
- dsann.label);
+ .findAnnotations(seq, dsann.getCalcId(), dsann.label);
if (!matchedAlignmentAnnotations.iterator().hasNext())
{
result.add(dsann);
endRes = selectionGroup.getEndRes();
}
copyAnn.restrict(startRes, endRes);
-
+
/*
* Add to the sequence (sets copyAnn.datasetSequence), unless the
* original annotation is already on the sequence.
Collection<String> types, List<SequenceI> forSequences,
boolean anyType, boolean doShow)
{
- for (AlignmentAnnotation aa : al
- .getAlignmentAnnotation())
+ for (AlignmentAnnotation aa : al.getAlignmentAnnotation())
{
if (anyType || types.contains(aa.label))
{
{
Set<AlignedCodonFrame> newMappings = new LinkedHashSet<AlignedCodonFrame>();
List<SequenceI> exonSequences = new ArrayList<SequenceI>();
-
+
for (SequenceI dnaSeq : dna)
{
final SequenceI ds = dnaSeq.getDatasetSequence();
* contiguous exons
*/
List<int[]> exonRange = new ArrayList<int[]>();
- exonRange.add(new int[]
- { 1, newSequence.length() });
+ exonRange.add(new int[] { 1, newSequence.length() });
MapList map = new MapList(exonRange, seqMapping.getMap()
- .getToRanges(),
- 3, 1);
+ .getToRanges(), 3, 1);
newMapping.addMap(exon.getDatasetSequence(), seqMapping.getTo(), map);
MapList cdsToDnaMap = new MapList(dnaExonRanges, exonRange, 1, 1);
newMapping.addMap(dnaSeq, exon.getDatasetSequence(), cdsToDnaMap);