private static List<SAMSequenceRecord> readSequences(final File vcf) { final VCFFileReader reader = new VCFFileReader(vcf); final VCFHeader header = reader.getFileHeader(); final SAMSequenceDictionary dict = header.getSequenceDictionary(); reader.close(); return dict.getSequences(); } }
/** * Creates a {@code Stream} of {@code VariantContext} from the indicated VCF file. * * @param vcfPath path of the VCF file * @return a {@code Stream} of {@code VariantContext} */ public static Stream<VariantContext> readVariantContexts(Path vcfPath) { Objects.requireNonNull(vcfPath, "Cannot read from null vcfPath"); logger.info("Reading variants from VCF file {}", vcfPath); try (VCFFileReader vcfReader = new VCFFileReader(vcfPath, false)) { return vcfReader.iterator().stream(); } }
/** This test doesn't even test the class, it just makes sure the cornercase test data is really a cornercase */ @Test public void ensureTestDataActuallyHasWideVariantAtTenMillion() { final Joiner joiner = Joiner.on(":"); // Cheat: do a string compare final VCFFileReader r = new VCFFileReader(VCF_WITH_MULTI_ALLELIC_VARIANT_AT_POSITION_10MILLION); Assert.assertEquals( joiner.join(r.query("1", TEN_MILLION, TEN_MILLION)), joiner.join(r.query("1", TEN_MILLION + 5, TEN_MILLION + 5)) ); r.close(); }
/** * Parse a VCF file and convert to an IntervalList The name field of the IntervalList is taken from the ID field of the variant, if it exists. if not, * creates a name of the format interval-n where n is a running number that increments only on un-named intervals * @param file * @return */ public static IntervalList fromVcf(final File file){ final VCFFileReader vcfFileReader = new VCFFileReader(file, false); final IntervalList intervalList = fromVcf(vcfFileReader); vcfFileReader.close(); return intervalList; }
public static IntervalList toIntervalList(final Path path, final boolean includeFiltered) { try (final VCFFileReader vcfReader = new VCFFileReader(path, false)) { return vcfReader.toIntervalList(includeFiltered); } }
protected VCFHeader getInputHeader() { if (inputHeader == null) { try (VCFFileReader vcfReader = new VCFFileReader(INPUT_VCF, false)) { inputHeader = vcfReader.getFileHeader(); } } return inputHeader; } protected VCFHeader getOutputHeader() {
/** * Tests that we normalize indels correctly */ @Test public void testNormalizeAllelesForIndels() { final Path truthVcfPath = Paths.get(TEST_DATA_PATH.getAbsolutePath(), NORMALIZE_ALLELES_TRUTH); final Path callVcfPath = Paths.get(TEST_DATA_PATH.getAbsolutePath(), NORMALIZE_ALLELES_CALL); final VCFFileReader truthReader = new VCFFileReader(truthVcfPath.toFile(), false); final VCFFileReader callReader = new VCFFileReader(callVcfPath.toFile(), false); final Iterator<VariantContext> truthIterator = truthReader.iterator(); final Iterator<VariantContext> callIterator = callReader.iterator(); final String truthSample = truthReader.getFileHeader().getSampleNamesInOrder().get(0); final String callSample = callReader.getFileHeader().getSampleNamesInOrder().get(0); while (truthIterator.hasNext()) { final VariantContext truthCtx = truthIterator.next(); final VariantContext callCtx = callIterator.next(); { final GenotypeConcordance.Alleles alleles = GenotypeConcordance.normalizeAlleles(truthCtx, truthSample, callCtx, callSample, false); Assert.assertEquals(alleles.truthAllele1, alleles.callAllele1); Assert.assertEquals(alleles.truthAllele2, alleles.callAllele2); } { final GenotypeConcordance.Alleles alleles = GenotypeConcordance.normalizeAlleles(callCtx, callSample, truthCtx, truthSample, false); Assert.assertEquals(alleles.truthAllele1, alleles.callAllele1); Assert.assertEquals(alleles.truthAllele2, alleles.callAllele2); } } truthReader.close(); callReader.close(); }
public Iterator<IdsvVariantContext> getAllCalls(File file, CloseableIterator<VariantContextDirectedEvidence> breakendCalls) { VCFFileReader vcfReader = new VCFFileReader(file, false); if (inputHeader != null) { inputHeader = vcfReader.getFileHeader(); } CloseableIterator<VariantContext> it = vcfReader.iterator(); Iterator<IdsvVariantContext> idsvIt = Iterators.transform(it, variant -> IdsvVariantContext.create(getContext(), null, variant)); Iterator<IdsvVariantContext> nonbeIt = Iterators.filter(idsvIt, variant -> !(variant instanceof VariantContextDirectedEvidence)); // sort back to nominal VCF position Iterator<VariantContextDirectedEvidence> bpit = new VariantContextWindowedSortingIterator<>(getContext(), SAMEvidenceSource.maximumWindowSize(getContext(), getSamEvidenceSources(), getAssemblySource()), breakendCalls); Iterator<IdsvVariantContext> mergedIt = Iterators.mergeSorted(ImmutableList.of(bpit, nonbeIt), IdsvVariantContext.ByLocationStart); return new AutoClosingIterator<>(mergedIt, vcfReader, it); } protected void saveVcf(File file, Iterator<IdsvVariantContext> calls) throws IOException {
tempIndex.deleteOnExit(); try (final VCFFileReader originalReader = new VCFFileReader(inputBCF,false); final VCFFileReader tmpReader = new VCFFileReader(tmpBCF, tempIndex,true)) { final Iterator<VariantContext> originalIt = originalReader.iterator(); while (originalIt.hasNext()) { final Iterator<VariantContext> tmpIt = tmpReader.query(vcOrig); Assert.assertTrue(tmpIt.hasNext(), "Variant not returned from indexed file"); final VariantContext vcTmp = tmpIt.next();
public void vcfTester(String inVcf){ // Credit: https://www.biostars.org/p/262943/ VCFFileReader r=new VCFFileReader(new File(inVcf)); CloseableIterator<VariantContext> t=r.iterator(); while(t.hasNext()){ t.next(); } t.close(); r.close(); }
@Test public void handleMissingInfoLinesInHeader(){ // This is fine also with original htsjdk-1.141 VCFFileReader reader = new VCFFileReader(new File("test_data/malformed_header3.vcf.gz")); reader.close(); }
&& !options.getInterval().equals("")); try (VCFFileReader vcfReader = new VCFFileReader(new File(vcfPath), useInterval)) { if (this.options.getVerbosity() >= 1) { final SAMSequenceDictionary seqDict = VCFFileReader .getSequenceDictionary(new File(vcfPath)); if (seqDict != null) { final GenomeRegionListFactoryFromSAMSequenceDictionary factory = new GenomeRegionListFactoryFromSAMSequenceDictionary(); VCFHeader vcfHeader = vcfReader.getFileHeader(); iter = vcfReader.query(itv.getContig(), itv.getStart(), itv.getEnd()); System.err.println("Will read interval " + itv.toString()); } else { System.err.println("Will read full input file"); iter = vcfReader.iterator();
final File compressedVcfInputFile = new File(VCF + ".gz"); final File compressedTbiIndexFile = new File(VCF + ".gz.tbi"); final VCFFileReader compressedVcfReader = new VCFFileReader(compressedVcfInputFile, compressedTbiIndexFile); .setOutputFile(VCF) .build(); plainTextVcfWriter.writeHeader(compressedVcfReader.getFileHeader()); for (VariantContext vc : compressedVcfReader) { if (vc != null) plainTextVcfWriter.add(vc); new VCFCodec(), TabixFormat.VCF, new VCFFileReader(plainTextVcfInputFile, false).getFileHeader().getSequenceDictionary() final VCFFileReader plainTextVcfReader = new VCFFileReader(plainTextVcfInputFile, plainTextVcfIndexFile); Assert.assertEquals(42, countIteratedElements(compressedVcfReader.query("1", 868379 - 1, 1006891 + 1))); Assert.assertEquals(42, countIteratedElements(plainTextVcfReader.query("1", 868379 - 1, 1006891 + 1))); Assert.assertEquals(13, countIteratedElements(compressedVcfReader.query("1", 1, 836463 + 1))); Assert.assertEquals(13, countIteratedElements(plainTextVcfReader.query("1", 1, 836463 + 1))); Assert.assertEquals(36, countIteratedElements(compressedVcfReader.query("1", 76690833 - 1, 76837502 + 11111111))); Assert.assertEquals(36, countIteratedElements(plainTextVcfReader.query("1", 76690833 - 1, 76837502 + 11111111))); Assert.assertEquals(0, countIteratedElements(compressedVcfReader.query("1", 36606472 + 1, 36623523 - 1))); Assert.assertEquals(0, countIteratedElements(plainTextVcfReader.query("1", 36606472 + 1, 36623523 - 1))); Assert.assertEquals(0, countIteratedElements(compressedVcfReader.query("1", 1, 10)));
/** * Loads genotypes from the supplied reader into one or more Fingerprint objects and returns them in a * Map of Sample->Fingerprint. * * @param reader - VCF reader containing genotypes for one or more samples * @param specificSample - null to load genotypes for all samples contained in the file or the name * of an individual sample to load (and exclude all others). * @param source The path of the source file used. used to emit errors. * @return a Map of Sample name to Fingerprint */ public Map<String, Fingerprint> loadFingerprintsFromQueriableReader(final VCFFileReader reader, final String specificSample, final Path source) { SequenceUtil.assertSequenceDictionariesEqual(this.haplotypes.getHeader().getSequenceDictionary(), reader.getFileHeader().getSequenceDictionary()); final SortedSet<Snp> snps = new TreeSet<>(haplotypes.getAllSnps()); return loadFingerprintsFromVariantContexts(() -> snps.stream().map(snp -> { try { return reader.query(snp.getChrom(), snp.getPos(), snp.getPos()).next(); } catch (NoSuchElementException e) { return null; } }).iterator(), specificSample, source); }
@Override public CloseableIterator<VariantContext> query(String contig, int beginPos, int endPos) { return vcfReader.query(contig, beginPos, endPos); }
public void close() throws IOException { if (vcfReader != null) { vcfReader.close(); } }
private SAMFileHeader getSAMFileHeader() { final VCFFileReader reader = getReader(CEU_TRIOS_SNPS_VCF); final SAMSequenceDictionary dict = reader.getFileHeader().getSequenceDictionary(); reader.close(); final SAMFileHeader header = new SAMFileHeader(); header.setSequenceDictionary(dict); return header; }
@Test(dataProvider = "queryableData") public void testQueryable(final File vcf, boolean expectedQueryable) { try(VCFFileReader reader = new VCFFileReader(vcf, false)) { Assert.assertEquals(reader.isQueryable(), expectedQueryable); } }
public static void assertVcfFilesAreEqual(final File actual, final File expected) throws IOException { final File indexedActual = createTemporaryIndexedVcfFromInput(actual, "assert"); final File indexedExpected = createTemporaryIndexedVcfFromInput(expected, "assert"); try (final VCFFileReader vcfReaderActual = new VCFFileReader(indexedActual); final VCFFileReader vcfReaderExpected = new VCFFileReader(indexedExpected)) { assertEquals(vcfReaderActual, vcfReaderExpected); } } }
/** * Returns true if the given file appears to be a BCF file. */ public static boolean isBCF(final File file) { return isBCF(file.toPath()); }