/**
* Gets all the results from a particular feature set that pass the filter
*
* @param featureSet
* @param f the filter used to decide which results to get
* @return
*/
public static Set<SeqFeatureI> getResults(SeqFeatureI featureSet, Filter f) {
HashSet<SeqFeatureI> result = new HashSet<SeqFeatureI>();
if (featureSet instanceof FeaturePairI && f.keep(featureSet)) {
result.add(featureSet);
} else if (featureSet.getFeatures() != null) {
for (int i = 0, size = featureSet.getFeatures().size(); i < size; i++) {
SeqFeatureI feature = featureSet.getFeatureAt(i);
result.addAll(getResults(feature, f));
}
}
return result;
}
/**
* Gets all the results from a particular feature set Don't think this is used...
*
* @param type the type of results wanted, ether AA or DNA
* @param featureSet
* @return
*/
public static Set<SeqFeatureI> getResults(String type, SeqFeatureI featureSet) {
HashSet<SeqFeatureI> result = new HashSet<SeqFeatureI>();
if (featureSet instanceof FeaturePairI) {
FeaturePairI feature = (FeaturePairI) featureSet;
SequenceI sequence = feature.getFeatureSequence();
String seqType = sequence.getResidueType();
String alignment = feature.getExplicitAlignment();
if (alignment != null
&& (type.equals(seqType) || type.equals(SequenceI.AA) == isAminoAcid(alignment))) {
result.add(featureSet);
}
} else if (featureSet.getFeatures() != null) {
for (int i = 0, size = featureSet.getFeatures().size(); i < size; i++) {
SeqFeatureI feature = featureSet.getFeatureAt(i);
result.addAll(getResults(type, feature));
}
}
return result;
}
/**
* Gets all the annotations in a particular feature set
*
* @param featureSet
* @return
*/
public static Set<SeqFeatureI> getAnnotations(SeqFeatureI featureSet) {
HashSet<SeqFeatureI> result = new HashSet<SeqFeatureI>();
if (featureSet.isTranscript()) {
if (featureSet.isContainedByRefSeq())
// only add if its fully in range
result.add(featureSet);
} else if (featureSet.isAnnotTop() && !featureSet.hasKids()) {
// only add if its fully in range
if (featureSet.isContainedByRefSeq()) result.add(featureSet);
} else {
for (int i = 0, size = featureSet.getFeatures().size(); i < size; i++) {
SeqFeatureI feature = featureSet.getFeatureAt(i);
if (feature.canHaveChildren()) {
result.addAll(getAnnotations(feature));
}
}
}
return result;
}
/**
* Get component to be rendered, if pos outside of current range getFeatureAtPosition and reset
* currentRange, if feature is non null and not an instance of FeatureSetI then its an exon, and
* set isExon flag
*/
public Component getBaseComponent(int position, TierI tier, Orientation o) {
transcript = null;
int bp = tier.getBasePair(position);
int oldPos = position;
// We need to change the position if dealing with aa view
if (tier.getType() == SequenceType.AA) {
int offset = getOffset(position, tier);
bp += offset * tier.getStrand().toInt();
position = tier.getPosition(bp);
}
char base = tier.charAt(position);
if (tier.featureExsitsAt(position, TierI.Level.BOTTOM)) {
this.state = State.EXON;
SeqFeatureI feature = tier.featureAt(position, TierI.Level.BOTTOM);
Transcript parentClone = null;
Transcript otherParentClone = null;
if (tier.getType() == SequenceType.AA
&& feature.getParent() != null
&& feature.getParent().isTranscript()) {
FeatureSetI parent = feature.getParent();
int index = parent.getFeatureIndex(feature);
int start = parent.getEnd();
// the transcript start might be different than the lowest exon start
// when in the middle of an edit
if (parent.canHaveChildren()) {
for (int i = 0; i < parent.size(); i++) {
SeqFeatureI sf = parent.getFeatureAt(i);
if ((Strand.valueOf(sf.getStrand()) == Strand.FORWARD && sf.getStart() < start)
|| (Strand.valueOf(sf.getStrand()) == Strand.REVERSE && sf.getStart() > start))
start = sf.getStart();
}
}
int translationStart = parent.getTranslationStart();
int translationEnd = parent.getTranslationEnd();
int translationPos = parent.getFeaturePosition(translationStart);
int oldstart = start;
start += ((translationPos - 1) % 3) * parent.getStrand();
// Tring to avoid all the recalculation...
if (feature.getParent() == currentParent
&& start == currentStart
&& featureStart == feature.getStart()
&& featureEnd == feature.getEnd()) {
parentClone = currentParentClone;
otherParentClone = currentParentClone2;
} else {
// need to get a full translation so that we can get the amino acids
// in the UTR region
parentClone = (Transcript) feature.getParent().clone();
otherParentClone = (Transcript) feature.getParent().clone();
if (!parentClone.setTranslationStart(start)) {
start = oldstart;
TranslationI cds = otherParentClone.getTranslation();
cds.calcTranslationStartForLongestPeptide();
translationStart = otherParentClone.getTranslationStart();
translationPos = otherParentClone.getFeaturePosition(translationStart);
start += ((translationPos - 1) % 3) * otherParentClone.getStrand();
parentClone.setTranslationStart(start);
}
parentClone.setTranslationEnd(parentClone.getEnd());
parentClone.setPeptideSequence(null);
String translation = parentClone.translate();
SequenceI sequence = parentClone.getPeptideSequence();
currentParent = (Transcript) feature.getParent();
currentParentClone = parentClone;
currentParentClone2 = otherParentClone;
currentStart = start;
featureStart = feature.getStart();
featureEnd = feature.getEnd();
if (otherParentClone.getFeatureContaining(translationEnd) == null) {
TranslationI cds = otherParentClone.getTranslation();
cds.setTranslationEndFromStart();
}
}
SeqFeatureI sf = parentClone.getFeatureAt(index);
if (bp >= sf.getLow() && bp <= sf.getHigh()) {
base = getPeptide(bp, sf);
} else {
base = '\0';
}
if (otherParentClone != null) {
feature = otherParentClone.getFeatureAt(index);
}
} else if (tier.getType() == SequenceType.AA
&& feature.getParent() != null
&& !feature.getParent().isTranscript()) {
base = '\0';
}
if (isUTR(bp, feature, tier)) {
this.state = State.UTR;
}
if (isTranslationStart(bp, feature)) {
this.state = State.TRANSLATION_START;
}
if (isTranslationEnd(bp, feature)) {
this.state = State.TRANSLATION_END;
}
// Can have an error or a shift on a position but not both
if (isSequencingErrorPosition(bp, feature, tier.getType())) {
this.state = State.ERROR;
// set base to the base of the new sequence?
}
if (isShiftPosition(bp, feature, tier.getType())) {
this.state = State.SHIFT;
}
} else if (tier.featureExsitsAt(position, TierI.Level.TOP)) {
SeqFeatureI feature = tier.featureAt(position, Level.TOP);
this.state = State.INTRON;
if (tier.getType() == SequenceType.AA) {
base = '\0';
}
int start = feature.getEnd();
int end = feature.getStart();
if (feature.canHaveChildren()) {
for (int i = 0; i < feature.size(); i++) {
SeqFeatureI sf = feature.getFeatureAt(i);
if ((Strand.valueOf(sf.getStrand()) == Strand.FORWARD && sf.getStart() < start)
|| (Strand.valueOf(sf.getStrand()) == Strand.REVERSE && sf.getStart() > start))
start = sf.getStart();
if ((Strand.valueOf(sf.getStrand()) == Strand.FORWARD && sf.getEnd() > end)
|| (Strand.valueOf(sf.getStrand()) == Strand.REVERSE && sf.getEnd() < end))
end = sf.getEnd();
}
}
if (bp <= Math.min(start, end) || bp >= Math.max(start, end)) {
this.state = State.OUT;
base = '\0';
}
} else {
this.state = State.OUT;
base = '\0';
}
if (!(state == State.SHIFT || state == State.ERROR)
&& getRegionLow() <= position
&& position <= getRegionHigh()) {
this.state = State.SELECTED;
base = tier.charAt(oldPos);
}
init(base);
return this;
}