}
/**
- * Returns a hashCode derived from the hashcodes of the mappings
+ * Returns a hashCode derived from the hashcodes of the mappings and fromSeq
*
* @see SequenceToSequenceMapping#hashCode()
*/
@Override
public int hashCode()
{
- return mappings.hashCode();
+ return (fromSeq == null ? 0 : fromSeq.hashCode() * 31)
+ + mapping.hashCode();
}
/**
{
return that.mapping == null;
}
- return this.mapping.equals(that.mapping);
+ // TODO: can simplify by asserting fromSeq is a dataset sequence
+ return (this.fromSeq == that.fromSeq
+ || (this.fromSeq != null && that.fromSeq != null
+ && this.fromSeq.getDatasetSequence() != null
+ && this.fromSeq.getDatasetSequence() == that.fromSeq
+ .getDatasetSequence()))
+ && this.mapping.equals(that.mapping);
}
public SequenceI getFromSeq()
{
return mapping;
}
+
+ /**
+ * Returns true if the mapping covers the full length of the given sequence.
+ * This allows us to distinguish the CDS that codes for a protein from
+ * another overlapping CDS in the parent dna sequence.
+ *
+ * @param seq
+ * @return
+ */
+ public boolean covers(SequenceI seq)
+ {
+ 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
+ {
+ return false;
+ }
+
+ /*
+ * check that each mapped range lies within the sequence range
+ * (necessary for circular CDS - example EMBL:J03321:AAA91567)
+ * and mapped length covers (at least) sequence length
+ */
+ int length = countRange(mappedRanges,mstart,mend);
+
+ if (length != -1)
+ {
+ // add 3 to mapped length to allow for a mapped stop codon
+ if (length + 3 >= (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 < mstart || to > mend)
+ {
+ return -1;
+ }
+ length += (to - from + 1);
+ }
+ return length;
+ }
+
+ /**
+ * Adds any regions mapped to or from position {@code pos} in sequence
+ * {@code seq} to the given search results
+ *
+ * @param seq
+ * @param pos
+ * @param sr
+ */
+ public void markMappedRegion(SequenceI seq, int pos, SearchResultsI sr)
+ {
+ int[] codon = null;
+ SequenceI mappedSeq = null;
+ SequenceI ds = seq.getDatasetSequence();
+ if (ds == null)
+ {
+ ds = seq;
+ }
+
+ if (this.fromSeq == seq || this.fromSeq == ds)
+ {
+ codon = this.mapping.map.locateInTo(pos, pos);
+ mappedSeq = this.mapping.to;
+ }
+ else if (this.mapping.to == seq || this.mapping.to == ds)
+ {
+ codon = this.mapping.map.locateInFrom(pos, pos);
+ mappedSeq = this.fromSeq;
+ }
+
+ if (codon != null)
+ {
+ for (int i = 0; i < codon.length; i += 2)
+ {
+ sr.addResult(mappedSeq, codon[i], codon[i + 1]);
+ }
+ }
+ }
}
private List<SequenceToSequenceMapping> mappings;
*/
public AlignedCodonFrame()
{
- mappings = new ArrayList<SequenceToSequenceMapping>();
+ mappings = new ArrayList<>();
}
/**
*/
public void addMap(SequenceI dnaseq, SequenceI aaseq, MapList map)
{
+ addMap(dnaseq, aaseq, map, null);
+ }
+
+ /**
+ * Adds a mapping between the dataset sequences for the associated dna and
+ * protein sequence objects
+ *
+ * @param dnaseq
+ * @param aaseq
+ * @param map
+ * @param mapFromId
+ */
+ public void addMap(SequenceI dnaseq, SequenceI aaseq, MapList map,
+ String mapFromId)
+ {
// JBPNote DEBUG! THIS !
// dnaseq.transferAnnotation(aaseq, mp);
// aaseq.transferAnnotation(dnaseq, new Mapping(map.getInverse()));
SequenceI fromSeq = (dnaseq.getDatasetSequence() == null) ? dnaseq
: dnaseq.getDatasetSequence();
- SequenceI toSeq = (aaseq.getDatasetSequence() == null) ? aaseq : aaseq
- .getDatasetSequence();
+ SequenceI toSeq = (aaseq.getDatasetSequence() == null) ? aaseq
+ : aaseq.getDatasetSequence();
/*
* if we already hold a mapping between these sequences, just add to it
* otherwise, add a new sequence mapping
*/
Mapping mp = new Mapping(toSeq, map);
+ mp.setMappedFromId(mapFromId);
mappings.add(new SequenceToSequenceMapping(fromSeq, mp));
}
{
// TODO return a list instead?
// return dnaSeqs;
- List<SequenceI> seqs = new ArrayList<SequenceI>();
+ List<SequenceI> seqs = new ArrayList<>();
for (SequenceToSequenceMapping ssm : mappings)
{
seqs.add(ssm.fromSeq);
public SequenceI[] getAaSeqs()
{
// TODO not used - remove?
- List<SequenceI> seqs = new ArrayList<SequenceI>();
+ List<SequenceI> seqs = new ArrayList<>();
for (SequenceToSequenceMapping ssm : mappings)
{
seqs.add(ssm.mapping.to);
public MapList[] getdnaToProt()
{
- List<MapList> maps = new ArrayList<MapList>();
+ List<MapList> maps = new ArrayList<>();
for (SequenceToSequenceMapping ssm : mappings)
{
maps.add(ssm.mapping.map);
public Mapping[] getProtMappings()
{
- List<Mapping> maps = new ArrayList<Mapping>();
+ List<Mapping> maps = new ArrayList<>();
for (SequenceToSequenceMapping ssm : mappings)
{
maps.add(ssm.mapping);
/**
* Returns the first mapping found which is to or from the given sequence, or
- * null.
+ * null if none is found
*
* @param seq
* @return
* where highlighted regions go
*/
public void markMappedRegion(SequenceI seq, int index,
- SearchResults results)
+ SearchResultsI results)
{
int[] codon;
SequenceI ds = seq.getDatasetSequence();
{
SequenceI targetDs = target.getDatasetSequence() == null ? target
: target.getDatasetSequence();
- SequenceI queryDs = query.getDatasetSequence() == null ? query : query
- .getDatasetSequence();
+ SequenceI queryDs = query.getDatasetSequence() == null ? query
+ : query.getDatasetSequence();
if (targetDs == null || queryDs == null /*|| dnaToProt == null*/)
{
return null;
{
MapList ml = null;
SequenceI dnaSeq = null;
- List<char[]> result = new ArrayList<char[]>();
+ List<char[]> result = new ArrayList<>();
for (SequenceToSequenceMapping ssm : mappings)
{
- if (ssm.mapping.to == protein)
+ if (ssm.mapping.to == protein
+ && ssm.mapping.getMap().getFromRatio() == 3)
{
ml = ssm.mapping.map;
dnaSeq = ssm.fromSeq;
* Read off the mapped nucleotides (converting to position base 0)
*/
codonPos = MappingUtils.flattenRanges(codonPos);
- char[] dna = dnaSeq.getSequence();
int start = dnaSeq.getStart();
- result.add(new char[] { dna[codonPos[0] - start],
- dna[codonPos[1] - start], dna[codonPos[2] - start] });
+ char c1 = dnaSeq.getCharAt(codonPos[0] - start);
+ char c2 = dnaSeq.getCharAt(codonPos[1] - start);
+ char c3 = dnaSeq.getCharAt(codonPos[2] - start);
+ result.add(new char[] { c1, c2, c3 });
}
}
return result.isEmpty() ? null : result;
*/
public List<Mapping> getMappingsFromSequence(SequenceI seq)
{
- List<Mapping> result = new ArrayList<Mapping>();
- List<SequenceI> related = new ArrayList<SequenceI>();
+ List<Mapping> result = new ArrayList<>();
+ List<SequenceI> related = new ArrayList<>();
SequenceI seqDs = seq.getDatasetSequence();
seqDs = seqDs != null ? seqDs : seq;
*/
protected int realiseWith(SequenceI seq, boolean doUpdate)
{
- SequenceI ds = seq.getDatasetSequence() != null ? seq
- .getDatasetSequence() : seq;
+ SequenceI ds = seq.getDatasetSequence() != null
+ ? seq.getDatasetSequence()
+ : seq;
int count = 0;
/*
{
int start = replacement.getStart();
int end = replacement.getEnd();
- boolean mappingOverlapsSequence = (mapStart >= start && mapStart <= end)
- || (mapEnd >= start && mapEnd <= end);
+ boolean mappingOverlapsSequence = (mapStart >= start
+ && mapStart <= end) || (mapEnd >= start && mapEnd <= end);
if (mappingOverlapsSequence)
{
return true;
}
/**
- * Returns the first mapping found that is from 'fromSeq' to 'toSeq', or null
- * if none found
+ * Returns the first mapping found that is between 'fromSeq' and 'toSeq', or
+ * null if none found
*
* @param fromSeq
* aligned or dataset sequence
*/
public Mapping getMappingBetween(SequenceI fromSeq, SequenceI toSeq)
{
+ SequenceI dssFrom = fromSeq.getDatasetSequence() == null ? fromSeq
+ : fromSeq.getDatasetSequence();
+ SequenceI dssTo = toSeq.getDatasetSequence() == null ? toSeq
+ : toSeq.getDatasetSequence();
+
for (SequenceToSequenceMapping mapping : mappings)
{
SequenceI from = mapping.fromSeq;
SequenceI to = mapping.mapping.to;
- if ((from == fromSeq || from == fromSeq.getDatasetSequence())
- && (to == toSeq || to == toSeq.getDatasetSequence()))
+ if ((from == dssFrom && to == dssTo)
+ || (from == dssTo && to == dssFrom))
{
return mapping.mapping;
}
git://source.jalview.org / jalview.git / blobdiff