*/
public boolean covers(SequenceI seq)
{
- List<int[]> mappedRanges = null;
+ return covers(seq,false,false);
+ }
+ /**
+ *
+ * @param seq
+ * @param localCover - when true - compare extent of seq's dataset sequence rather than the local extent
+ * @param either - when true coverage is required for either seq or the mapped sequence
+ * @return true if mapping covers full length of given sequence (or the other if either==true)
+ */
+ public boolean covers(SequenceI seq, boolean localCover,boolean either)
+ {
+ List<int[]> mappedRanges = null,otherRanges=null;
MapList mapList = mapping.getMap();
+ int mstart=seq.getStart(),mend=seq.getEnd(),ostart,oend;
+ ;
if (fromSeq == seq || fromSeq == seq.getDatasetSequence())
{
+ if (localCover && fromSeq !=seq)
+ {
+ mstart=fromSeq.getStart();
+ mend=fromSeq.getEnd();
+ }
mappedRanges = mapList.getFromRanges();
+ otherRanges=mapList.getToRanges();
+ ostart=mapping.to.getStart();
+ oend=mapping.to.getEnd();
}
else if (mapping.to == seq || mapping.to == seq.getDatasetSequence())
{
+ if (localCover && mapping.to !=seq)
+ {
+ mstart=mapping.to.getStart();
+ mend=mapping.to.getEnd();
+ }
mappedRanges = mapList.getToRanges();
+ otherRanges=mapList.getFromRanges();
+ ostart=fromSeq.getStart();
+ oend=fromSeq.getEnd();
}
else
{
* (necessary for circular CDS - example EMBL:J03321:AAA91567)
* and mapped length covers (at least) sequence length
*/
- int length = 0;
+ int length = countRange(mappedRanges,mstart,mend);
+
+ if (length != -1)
+ {
+ // add 1 to mapped length to allow for a mapped stop codon
+ if (length + 1 >= (mend - mstart + 1))
+ {
+ return true;
+ }
+ }
+ if (either)
+ {
+ // also check coverage of the other range
+ length = countRange(otherRanges, ostart, oend);
+ if (length != -1)
+ {
+ if (length + 1 >= (oend - ostart + 1))
+ {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ private int countRange(List<int[]> mappedRanges,int mstart,int mend)
+ {
+ int length=0;
for (int[] range : mappedRanges)
{
int from = Math.min(range[0], range[1]);
int to = Math.max(range[0], range[1]);
- if (from < seq.getStart() || to > seq.getEnd())
+ if (from < mstart || to > mend)
{
- return false;
+ return -1;
}
length += (to - from + 1);
}
- // add 1 to mapped length to allow for a mapped stop codon
- if (length + 1 < (seq.getEnd() - seq.getStart() + 1))
- {
- return false;
- }
- return true;
+ return length;
}
}
/**
* Return the corresponding aligned or dataset dna sequence for given amino
- * acid sequence, or null if not found. returns the sequence from
- * the first mapping found that involves the protein sequence.
+ * acid sequence, or null if not found. returns the sequence from the first
+ * mapping found that involves the protein sequence.
*
* @param aaSeqRef
* @return
*/
public SequenceI findAlignedSequence(SequenceI seq, AlignmentI al)
{
+ return findAlignedSequence(seq, al, null);
+ }
+ /**
+ * Convenience method to return the first aligned sequence in the given
+ * alignment whose dataset has a mapping with the given (aligned or dataset)
+ * sequence, and optionally the mapping that relates them
+ *
+ * @param seq
+ * @param al
+ * @param map - list to add the mapping to
+ * @return sequence from al that maps to seq
+ */
+ public SequenceI findAlignedSequence(SequenceI seq, AlignmentI al,List<SequenceToSequenceMapping> map)
+ {
/*
* Search mapped protein ('to') sequences first.
*/
for (SequenceToSequenceMapping ssm : mappings)
{
- if (ssm.fromSeq == seq || ssm.fromSeq == seq.getDatasetSequence())
+ int mStart=ssm.getMapping().getMap().getFromLowest(),mEnd=ssm.getMapping().map.getFromHighest();
+ if ((ssm.fromSeq == seq || ssm.fromSeq == seq.getDatasetSequence())
+ // here AlignmentUtilsTest. testAlignProteinAsDna_incompleteStartCodon fails because mStart/mEnd is contained by seq
+ // without this filter, we don't get the correct mapping, however
+ )// && seq.getStart()>=mStart && seq.getEnd()<=mEnd)
{
for (SequenceI sourceAligned : al.getSequences())
{
- if (ssm.mapping.to == sourceAligned.getDatasetSequence()
- || ssm.mapping.to == sourceAligned)
+ if (ssm.covers(sourceAligned,true,false))
{
+ if (map != null)
+ {
+ map.add(ssm);
+ }
return sourceAligned;
}
}
*/
for (SequenceToSequenceMapping ssm : mappings)
{
- if (ssm.mapping.to == seq
+ int mStart=ssm.getMapping().getMap().getToLowest(),mEnd=ssm.getMapping().map.getToHighest();
+ if ((ssm.mapping.to == seq
|| ssm.mapping.to == seq.getDatasetSequence())
+ && seq.getStart()>=mStart && seq.getEnd()<=mEnd)
{
for (SequenceI sourceAligned : al.getSequences())
{
- if (ssm.fromSeq == sourceAligned.getDatasetSequence())
+ if (ssm.covers(sourceAligned,true,true))
{
+ if (map != null)
+ {
+ map.add(ssm);
+ }
return sourceAligned;
}
}
* Two AlignedCodonFrame objects are equal if they hold the same ordered list
* of mappings
*
- * @see SequenceToSequenceMapping#
+ * @see SequenceToSequenceMapping#equals
*/
@Override
public boolean equals(Object obj)
return mappings;
}
- public SequenceToSequenceMapping getCoveringMapping(SequenceI cds,
- SequenceI peptide)
+ /**
+ * Returns the first mapping found which is between the two given sequences,
+ * and covers the full extent of both.
+ *
+ * @param seq1
+ * @param seq2
+ * @return
+ */
+ public SequenceToSequenceMapping getCoveringMapping(SequenceI seq1,
+ SequenceI seq2)
{
for (SequenceToSequenceMapping mapping : mappings)
{
- if (mapping.covers(peptide) && mapping.covers(cds))
+ if (mapping.covers(seq2) && mapping.covers(seq1))
{
return mapping;
}
git://source.jalview.org / jalview.git / blobdiff