Java Feature.getEnd方法代码示例

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
@Override
public Iterator<Feature> query(String chr, int start, int end) throws IOException {

    // Tribble iterators must be closed, so we need to copy the features and insure closure before exiting.
    CloseableTribbleIterator<Feature> iter = null;
    try {
        iter = wrappedReader.query(chr, start, end);
        List<Feature> featureList = new ArrayList<Feature>();
        while (iter.hasNext()) {
            Feature f = iter.next();
            if (f.getStart() > end) {
                break;
            } else if (f.getEnd() < start) {
                continue;
            } else {
                featureList.add(f);
            }
        }
        return featureList.iterator();
    } finally {
        if(iter != null) iter.close();
    }
}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
@Override
protected Iterator<Feature> queryRaw(String chr, int start, int end) throws IOException {

    // Tribble iterators must be closed, so we need to copy the features and insure closure before exiting.
    CloseableTribbleIterator<Feature> iter = null;
    try {
        iter = tribbleFeatureReader.query(chr, start, end);
        List<Feature> featureList = new ArrayList<Feature>();
        while (iter.hasNext()) {
            Feature f = iter.next();
            if (f.getStart() > end) {
                break;
            } else if (f.getEnd() < start) {
                continue;
            } else {
                featureList.add(f);
            }
        }
        return featureList.iterator();
    } finally {
        if (iter != null) iter.close();
    }
}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
public int compare(Feature feat1, Feature feat2) {

            // Prefer the shortest chromosome name.  Longer names are most likely "weird"
            // e.g.  chr1_gl000191_random
            int nameLen1 = feat1.getChr().length();
            int nameLen2 = feat2.getChr().length();
            if (nameLen1 != nameLen2) {
                return nameLen1 - nameLen2;
            }


            int len1 = (feat1.getEnd() - feat1.getStart());
            int len2 = (feat2.getEnd() - feat2.getStart());
            int toRet;
            if (!this.descending) {
                toRet = len1 - len2;
            } else {
                toRet = len2 - len1;
            }

            return toRet;

        }
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
private DataTile computeCoverage(String chr, int start, int end) {

            int nBins = (end - start) / windowSize + 1;
            int[] starts = new int[nBins];
            int[] ends = new int[nBins];
            for (int i = 0; i < nBins; i++) {
                starts[i] = start + i * windowSize;
                ends[i] = starts[i] + windowSize;
            }
            float[] values = new float[nBins];
            List<Feature> features = featureMap.get(chr);
            if (features != null) {
                for (Feature f : features) {
                    int startBin = f.getStart() / windowSize;
                    int endBin = f.getEnd() / windowSize;
                    for (int i = startBin; i < endBin; i++) {
                        values[i] = values[i] + 1;
                        dataMax = Math.max(dataMax, values[i]);
                    }
                }
            }
            return new DataTile(starts, ends, values, null);

        }
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
public static int convertEnd(Feature feature) {
	int end = feature.getEnd();
	if (end <= 0) {
		// If feature end cannot be determined (e.g. because a read is not
		// really aligned),
		// then treat this as a one base feature for indexing purposes.
		end = feature.getStart() + 1;
	}
	return end;
}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
/**
 * Create a bed file of "TSS regions", define as the 20 bp region downstream of the start of the feature.
 * <p/>
 * It is assume that iFile is sorted by start position.
 *
 * @param iFile
 * @param outputFile
 */
static void createTSSFile(String iFile, String outputFile) throws IOException {

    BufferedReader br = null;
    PrintWriter pw = null;

    try {
        br = new BufferedReader(new FileReader(iFile));
        pw = new PrintWriter(new BufferedWriter(new FileWriter(outputFile)));
        FeatureParser parser = AbstractFeatureParser.getInstanceFor(new ResourceLocator(iFile), null);
        List<Feature> features = parser.loadFeatures(br, null);
        IGVBEDCodec codec = new IGVBEDCodec();


        Map<String, List<BasicFeature>> genes = new HashMap<String, List<BasicFeature>>();

        int lastTSS = -1;
        for (Feature f : features) {

            BasicFeature transcript = (BasicFeature) f;

            int tss = transcript.getStrand() == Strand.POSITIVE ? f.getStart() : f.getEnd();
            if (tss != lastTSS) {
                int tssEnd = transcript.getStrand() == Strand.POSITIVE ? tss + 20 : tss - 20;
                pw.println(transcript.getChr() + "\t" + Math.min(tss, tssEnd) + "\t" + Math.max(tss, tssEnd));
                lastTSS = tss;
            }


        }
    } finally {
        if (br != null) br.close();
        if (pw != null) pw.close();
    }
}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
public static Predicate<Feature> getOverlapPredicate(final String chr, final int start, final int end) {
    Predicate<Feature> overlapPredicate = new Predicate<Feature>() {
        @Override
        public boolean apply(Feature object) {
            return chr.equals(object.getChr()) && object.getStart() <= end && object.getEnd() > start;
        }
    };
    return overlapPredicate;
}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
/**
 * Return a feature from the supplied list at the given position.
 *
 * @param position
 * @param maxLength
 * @param features
 * @return
 */
public static List<Feature> getAllFeaturesAt(double position,
                                             double maxLength,
                                             double minWidth,
                                             List<? extends htsjdk.tribble.Feature> features) {

    List<Feature> returnList = null;

    double adjustedPosition = Math.max(0, position - maxLength);
    int startIdx = Math.max(0, getIndexBefore(adjustedPosition, features));
    for (int idx = startIdx; idx < features.size(); idx++) {
        Feature feature = features.get(idx);
        int start = feature.getStart() - (int) (minWidth / 2);

        if (start > position) {
            break;
        }

        int end = feature.getEnd() + (int) (minWidth / 2);

        if (position >= start && position <= end) {
            if (returnList == null) returnList = new ArrayList();
            returnList.add(feature);
        }
    }

    return returnList;
}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
public int compare(Feature o1, Feature o2) {
    int genomeStart2 = o2.getStart();
    int genomeStart1 = o1.getEnd();
    if (genomeStart2 >= genomeStart1 && o2.getEnd() <= o1.getEnd()) {
        return 0;
    } else {
        return genomeStart1 - genomeStart2;
    }
}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
/**
 * Return the variant closest to the genomic position in the given reference frame, within the prescribed tolerance
 *
 * @param position
 * @param y           pixel position in panel coordinates (i.e. not track coordinates)
 * @param frameName
 * @param maxDistance
 * @return
 */
protected Variant getFeatureClosest(double position, int y, String frameName, double maxDistance) {

    PackedFeatures<IGVFeature> packedFeatures = packedFeaturesMap.get(frameName);

    if (packedFeatures == null) {
        return null;
    }

    Feature feature = null;
    List<IGVFeature> features;

    //We search only the specified row if y is a meaningful value.
    //Otherwise we search everything
    int row = ((y - top) / variantBandHeight);
    if (y < 0 || row >= getNumberOfFeatureLevels()) {
        features = packedFeatures.getFeatures();
    } else {
        features = packedFeatures.getRows().get(row).getFeatures();
    }

    if (features != null) {
        feature = FeatureUtils.getFeatureClosest(position, features);
    }
    if (feature == null ||
            ((position < feature.getStart() - maxDistance) || (position > feature.getEnd() + maxDistance))) {
        return null;
    } else {
        return (Variant) feature;
    }


}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
/**
 * Return a locus from the gene (e.g. EGFR) or locus (e.g. chr1:1-100) string
 */
Locus getLocus(String geneOrLocusString) {
    Locus locus = Locus.fromString(geneOrLocusString);
    if (locus != null && locus.isValid()) {
        return locus;
    } else {
        // Maybe its a gene or feature
        Feature gene = FeatureDB.getFeature(geneOrLocusString);
        if (gene != null) {
            return new Locus(gene.getChr(), gene.getStart(), gene.getEnd());
        }
    }
    return null;
}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
protected void computeGenomeCoverage() {
    int nBins = 1000;
    int[] starts = new int[nBins];
    int[] ends = new int[nBins];
    float[] values = new float[nBins];
    Arrays.fill(values, 0);

    Genome currentGenome = GenomeManager.getInstance().getCurrentGenome();
    double step = ((double) currentGenome.getNominalLength() / 1000) / nBins;
    for (int i = 0; i < nBins; i++) {
        starts[i] = (int) (i * step);
        ends[i] = (int) ((i + 1) * step);
    }


    for (String chr : currentGenome.getLongChromosomeNames()) {
        List<Feature> features = featureMap.get(chr);
        if (features != null) {
            long offset = currentGenome.getCumulativeOffset(chr);
            for (Feature f : features) {
                int genStart = (int) ((offset + f.getStart()) / 1000);
                int genEnd = (int) ((offset + f.getEnd()) / 1000);
                int binStart = (int) (genStart / step);
                int binEnd = (int) (genEnd / step);
                for (int i = binStart; i <= binEnd; i++) {
                    values[i] = values[i] + 1;
                }

            }
        }
    }

    coverageData.dataCache.put(Globals.CHR_ALL, new DataTile(starts, ends, values, null));
}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
static DBFeature create(Feature feature){
    if(feature instanceof AbstractFeature){
        return create((AbstractFeature) feature);
    }
    return new DBFeature(feature.getChr(), feature.getStart(), feature.getEnd(), null, null, DEFAULT_COLOR);
}
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
public boolean overlaps(Feature anotherFeature) {

        return end >= anotherFeature.getStart() && start <= anotherFeature.getEnd() &&
                chromosome.equals(anotherFeature.getChr());

    }
 

import htsjdk.tribble.Feature; //导入方法依赖的package包/类
/**
 * Some types of Features (splice junctions) should be packed on the same row even if start and end overlap.
 * This can be overridden in a subclass
 * @param feature
 * @return
 */
protected int getFeatureEndForPacking(Feature feature)
{
    return feature.getEnd();
}