import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
@Override
protected void setup(Context context) throws IOException, InterruptedException {
	Configuration conf = context.getConfiguration();
	
	Path path = new Path(conf.get(GaeaVCFOutputFormat.OUT_PATH_PROP));
	SeekableStream in = WrapSeekable.openPath(path.getFileSystem(conf), path);
	header = VCFHeaderReader.readHeaderFrom(in);
	in.close();
	
	chrIndexs = new HashMap<String,Integer>();
	List<VCFContigHeaderLine> lines = header.getContigLines();
	for(int i = 0 ; i < lines.size() ; i++){
		VCFContigHeaderLine line = lines.get(i);
		chrIndexs.put(line.getID(), line.getContigIndex());
	}
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
public static SortedSet<VCFContigHeaderLine>
samSequenceDictToVCFContigHeaderLine(SAMSequenceDictionary dict)
{
SortedSet<VCFContigHeaderLine> meta2=new TreeSet<VCFContigHeaderLine>();
for(SAMSequenceRecord ssr: dict.getSequences())
	{
	Map<String,String> mapping=new HashMap<String,String>();
	mapping.put("ID", ssr.getSequenceName());
	mapping.put("length",String.valueOf(ssr.getSequenceLength()));
	String as=ssr.getAssembly();
	if(as!=null && !as.trim().isEmpty()) mapping.put("assembly",as);
	VCFContigHeaderLine h=new VCFContigHeaderLine(mapping,ssr.getSequenceIndex());
	meta2.add(h);
	}
return meta2;
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
/**
 * Given a set of VCF header lines, update the set with contig
 * lines from the provided reference dictionary.
 * @param oldLines
 * @param referenceFile
 * @param refDict
 * @param referenceNameOnly
 * @return Updated list of VCF header lines.
 */
public static Set<VCFHeaderLine> updateHeaderContigLines(
        final Set<VCFHeaderLine> oldLines,
        final File referenceFile,
        final SAMSequenceDictionary refDict,
        final boolean referenceNameOnly) {
    final Set<VCFHeaderLine> lines = new LinkedHashSet<>(oldLines.size());

    for (final VCFHeaderLine line : oldLines) {
        if (line instanceof VCFContigHeaderLine) {
            continue; // skip old contig lines
        }
        if (line.getKey().equals(VCFHeader.REFERENCE_KEY)) {
            continue; // skip the old reference key
        }
        lines.add(line);
    }

    lines.addAll(makeContigHeaderLines(refDict, referenceFile).stream().collect(Collectors.toList()));

    if (referenceFile != null) {
        final String referenceValue;
        if (referenceNameOnly) {
            final int extensionStart = referenceFile.getName().lastIndexOf(".");
            referenceValue = extensionStart == -1 ? referenceFile.getName() : referenceFile.getName().substring(0, extensionStart);
        }
        else {
            referenceValue = "file://" + referenceFile.getAbsolutePath();
        }
        lines.add(new VCFHeaderLine(VCFHeader.REFERENCE_KEY, referenceValue));
    }
    return lines;
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
private static List<VCFContigHeaderLine> makeContigHeaderLines(final SAMSequenceDictionary refDict,
                                                               final File referenceFile) {
    final List<VCFContigHeaderLine> lines = new ArrayList<>();
    final String assembly = referenceFile != null ? referenceFile.getName() : null;
    lines.addAll(refDict.getSequences().stream().map(contig -> makeContigHeaderLine(contig, assembly)).collect(Collectors.toList()));
    return lines;
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
private static VCFContigHeaderLine makeContigHeaderLine(final SAMSequenceRecord contig, final String assembly) {
    final Map<String, String> map = new LinkedHashMap<>(3);
    map.put(GaeaVCFConstants.CONTIG_ID_KEY, contig.getSequenceName());
    map.put(GaeaVCFConstants.CONTIG_LENGTH_KEY, String.valueOf(contig.getSequenceLength()));
    if (assembly != null) {
        map.put(GaeaVCFConstants.ASSEMBLY_NAME_KEY, assembly);
    }
    return new VCFContigHeaderLine(map, contig.getSequenceIndex());
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
private SortedMap<QueryInterval, List<Allele>> getQueryIntervalsMap(final File vcf) {

        final Map<String, Integer> contigIndexMap = new HashMap<>();
        final VCFFileReader vcfReader = new VCFFileReader(vcf, false);

        // We want to look at unfiltered SNP sites for which the sample is genotyped as a het
        // with high quality.
        final CompoundFilter compoundFilter = new CompoundFilter(true);
        compoundFilter.add(new SnpFilter());
        compoundFilter.add(new PassingVariantFilter());
        compoundFilter.add(new GenotypeQualityFilter(MINIMUM_GQ, SAMPLE));
        compoundFilter.add(new HeterozygosityFilter(true, SAMPLE));

        final Iterator<VariantContext> hetIterator = new FilteringVariantContextIterator(vcfReader.iterator(), compoundFilter);

        for (final VCFContigHeaderLine vcfContig : vcfReader.getFileHeader().getContigLines()) {
            contigIndexMap.put(vcfContig.getID(), vcfContig.getContigIndex());
        }

        // return a TreeMap since the keys are comparable, and this will use their order in the iteration
        final SortedMap<QueryInterval, List<Allele>> map = new TreeMap<>();

        while (hetIterator.hasNext()) {
            final VariantContext vc = hetIterator.next();
            map.put(new QueryInterval(contigIndexMap.get(vc.getContig()), vc.getStart(), vc.getEnd()), vc.getGenotype(SAMPLE).getAlleles());
        }

        vcfReader.close();

        return map;
    }
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
private void initContigDict() {
	final VCFHeader header =
		(VCFHeader)codec.readHeader(in).getHeaderValue();

	contigDict.clear();
	int i = 0;
	for (final VCFContigHeaderLine contig : header.getContigLines())
		contigDict.put(contig.getID(), i++);
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
/**
 * Given a set of VCF header lines, update the set with contig
 * lines from the provided reference dictionary.
 * @param oldLines
 * @param referencePath
 * @param refDict
 * @param referenceNameOnly
 * @return Updated list of VCF header lines.
 */
public static Set<VCFHeaderLine> updateHeaderContigLines(
        final Set<VCFHeaderLine> oldLines,
        final Path referencePath,
        final SAMSequenceDictionary refDict,
        final boolean referenceNameOnly) {
    final Set<VCFHeaderLine> lines = new LinkedHashSet<>(oldLines.size());

    for (final VCFHeaderLine line : oldLines) {
        if (line instanceof VCFContigHeaderLine) {
            continue; // skip old contig lines
        }
        if (line.getKey().equals(VCFHeader.REFERENCE_KEY)) {
            continue; // skip the old reference key
        }
        lines.add(line);
    }

    lines.addAll(makeContigHeaderLines(refDict, referencePath).stream().collect(Collectors.toList()));

    if (referencePath != null) {
        final String referenceValue;
        if (referenceNameOnly) {
            final int extensionStart = referencePath.getFileName().toString().lastIndexOf(".");
            referenceValue = extensionStart == -1 ? referencePath.getFileName().toString() : referencePath.getFileName().toString().substring(0, extensionStart);
        }
        else {
            referenceValue = referencePath.toUri().toString();
        }
        lines.add(new VCFHeaderLine(VCFHeader.REFERENCE_KEY, referenceValue));
    }
    return lines;
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
private static List<VCFContigHeaderLine> makeContigHeaderLines(final SAMSequenceDictionary refDict,
                                                               final Path referencePath) {
    final List<VCFContigHeaderLine> lines = new ArrayList<>();
    final String assembly = referencePath != null ? referencePath.getFileName().toString() : null;
    lines.addAll(refDict.getSequences().stream().map(contig -> makeContigHeaderLine(contig, assembly)).collect(Collectors.toList()));
    return lines;
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
private static VCFContigHeaderLine makeContigHeaderLine(final SAMSequenceRecord contig, final String assembly) {
    final Map<String, String> map = new LinkedHashMap<>(3);
    map.put(GATKVCFConstants.CONTIG_ID_KEY, contig.getSequenceName());
    map.put(GATKVCFConstants.CONTIG_LENGTH_KEY, String.valueOf(contig.getSequenceLength()));
    if (assembly != null) {
        map.put(GATKVCFConstants.ASSEMBLY_NAME_KEY, assembly);
    }
    return new VCFContigHeaderLine(map, contig.getSequenceIndex());
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
@Test(dataProvider = "testData")
public void testUpdateContigsReferenceNameOnly(
        final Set<VCFHeaderLine> inHeaderLines,
        final SAMSequenceDictionary seqDict,
        final Path referencePath,
        final boolean refNameOnly,
        final String expectedRefName) {

    Set<VCFHeaderLine> resultLines = VcfUtils.updateHeaderContigLines(
            inHeaderLines, referencePath, seqDict, refNameOnly
    );

    Assert.assertEquals(resultLines.size(), referencePath == null ? 2 : 3);
    for (VCFHeaderLine resultLine : resultLines) {
        if (resultLine instanceof VCFContigHeaderLine) {
            VCFContigHeaderLine headerLine = (VCFContigHeaderLine) resultLine;
            SAMSequenceRecord samSeqRec = headerLine.getSAMSequenceRecord();
            if (samSeqRec.getSequenceName().equals("contig1")) {
                Assert.assertEquals(samSeqRec.getSequenceLength(), 100);
            } else if (samSeqRec.getSequenceName().equals("contig2")) {
                Assert.assertEquals(samSeqRec.getSequenceLength(), 200);
            } else {
                Assert.fail("Bad sequence name in header lines");
            }
        } else {
            if (referencePath != null) {
                Assert.assertEquals(resultLine.getValue(), expectedRefName);
            }
            else {
                Assert.fail("Unexpected reference name in header lines");
            }
        }
    }
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
private Set<VCFHeaderLine> createHeaderLines() {
    Set<VCFHeaderLine> headerLines = new HashSet<>(2);
    headerLines.add(new VCFContigHeaderLine(
            "##contig=<ID=1,length=249250621,assembly=b37>",
            vcfHeaderVersion,
            "",
            0));
    headerLines.add(new VCFContigHeaderLine(
            "##contig=<ID=2,length=249250622,assembly=b37>",
            vcfHeaderVersion,
            "",
            0));
    return headerLines;
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
@Test(groups = "sv")
public void testSetHeader() {
    SAMSequenceDictionary referenceSequenceDictionary = new ReferenceMultiSource(
            b37_2bit_reference_20_21 , ReferenceWindowFunctions.IDENTITY_FUNCTION).getReferenceSequenceDictionary(null);
    final VCFHeader vcfHeader = SVVCFWriter.getVcfHeader(referenceSequenceDictionary);
    Assert.assertNotNull(vcfHeader.getSequenceDictionary());
    Assert.assertTrue(vcfHeader.getFilterLines().isEmpty());
    final List<String> refContigs = vcfHeader.getContigLines().stream().map(VCFContigHeaderLine::getID).collect(Collectors.toList());
    Assert.assertTrue(refContigs.size()==2);
    Assert.assertTrue(vcfHeader.getFormatHeaderLines().isEmpty());
    final List<String> headerKeys = vcfHeader.getIDHeaderLines().stream().map(VCFIDHeaderLine::getID).sorted().collect(Collectors.toList());
    Assert.assertTrue(headerKeys.remove(VCFConstants.END_KEY));
    Assert.assertTrue(headerKeys.removeAll(refContigs));
    Assert.assertEquals(headerKeys, GATKSVVCFConstants.expectedHeaderLinesInVCF);
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
private VariantContextWriter openOutputFile() {
	VariantContextWriterBuilder builder = new VariantContextWriterBuilder()
			.setReferenceDictionary(fasta.getSequenceDictionary()).setOutputFile(options.getPathOutputVCF());
	if (options.getPathOutputVCF().endsWith(".gz") || options.getPathOutputVCF().endsWith(".bcf"))
		builder.setOption(Options.INDEX_ON_THE_FLY);
	else
		builder.unsetOption(Options.INDEX_ON_THE_FLY);
	VariantContextWriter writer = builder.build();

	VCFHeader header = new VCFHeader();
	int i = 0;
	for (SAMSequenceRecord record : fasta.getSequenceDictionary().getSequences()) {
		Map<String, String> mapping = new TreeMap<String, String>();
		mapping.put("ID", record.getSequenceName());
		mapping.put("length", Integer.toString(record.getSequenceLength()));
		header.addMetaDataLine(new VCFContigHeaderLine(mapping, i++));
	}

	header.addMetaDataLine(new VCFSimpleHeaderLine("ALT", "ERROR", "Error in conversion"));
	header.addMetaDataLine(new VCFFilterHeaderLine("PARSE_ERROR",
			"Problem in parsing original HGVS variant string, written out as variant at 1:g.1N>N"));
	header.addMetaDataLine(new VCFInfoHeaderLine("ERROR_MESSAGE", 1, VCFHeaderLineType.String, "Error message"));
	header.addMetaDataLine(new VCFInfoHeaderLine("ORIG_VAR", 1, VCFHeaderLineType.String,
			"Original HGVS variant string from input file to hgvs-to-vcf"));

	writer.writeHeader(header);

	return writer;
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
@Override
protected void setup(Context context) throws IOException {
	Configuration conf = context.getConfiguration();
	contigs = new HashMap<Integer, String>();
	
	Path path = new Path(conf.get(GaeaVCFOutputFormat.OUT_PATH_PROP));
	SeekableStream in = WrapSeekable.openPath(path.getFileSystem(conf), path);
	header = VCFHeaderReader.readHeaderFrom(in);
	in.close();
	
	if(header == null)
		throw new RuntimeException("header is null !!!");
	
	List<VCFContigHeaderLine> lines = header.getContigLines();

	for (int i = 0; i < lines.size(); i++) {
		VCFContigHeaderLine line = lines.get(i);
		contigs.put(line.getContigIndex(), line.getID());
	}

	options = new JointCallingOptions();
	options.getOptionsFromHadoopConf(conf);
	
	windowSize = options.getWindowsSize();
	parser = new GenomeLocationParser(header.getSequenceDictionary());
	headers.readHeaders(conf);
	
	String sampleStr = conf.get(JointCalling.INPUT_ORDER,null);
	if(sampleStr != null)
		engine = new JointCallingEngine(options, parser,header,headers,sampleStr.split(","));
	else
		engine = new JointCallingEngine(options, parser,header,headers,null);
	genomeShare = new ReferenceShare();
	genomeShare.loadChromosomeList(options.getReference());
	dbsnpShare = new DbsnpShare(options.getDBSnp(), options.getReference());
	dbsnpShare.loadChromosomeList(options.getDBSnp() + VcfIndex.INDEX_SUFFIX);
	loader = new VCFLocalLoader(options.getDBSnp());
	filter = new VariantRegionFilter();
	header = engine.getVCFHeader();
	
	if(header == null)
		throw new RuntimeException("header is null!!!");
}
 

import htsjdk.variant.vcf.VCFContigHeaderLine; //导入依赖的package包/类
private static VCFHeader warpHeader(VCFHeader in, Map<String, Long> namesAndLength)
    throws IllegalArgumentException {
  Set<VCFHeaderLine> newLines = new HashSet<>();
  boolean hasSource = false;
  VCFHeaderVersion version = DEFAULT_VCF_VERSION;

  for (VCFHeaderLine line : in.getMetaDataInInputOrder()) {
    if (line.getKey().equals("reference")) {
      newLines.add(new VCFHeaderLine(line.getKey(), ARGS.refTargetFASTA));
    } else if (line.getKey().equals("source")) {
      newLines.add(new VCFHeaderLine(line.getKey(), line.getValue() + "_and_"
          + GENOME_WARP_VERSION));
      hasSource = true;
    } else if (line.getKey().equals("fileformat")) {
      version = VCFHeaderVersion.toHeaderVersion(line.getValue());
      if (version == null) {
        throw new IllegalArgumentException("malformed version: " + line.getValue());
      }
    } else if (line.getKey().equals(VCFConstants.CONTIG_HEADER_KEY)) {
      continue;
    } else {
      newLines.add(line);
    }
  }

  if (!hasSource) {
    newLines.add(new VCFHeaderLine("source", GENOME_WARP_VERSION));
  }

  // Add contigs
  int i = 0;
  for (Map.Entry<String, Long> entry : namesAndLength.entrySet()) {
    String currName = entry.getKey();
    long chrSize = entry.getValue();

    newLines.add(new VCFContigHeaderLine(VCFHeaderLine.toStringEncoding(
        createContigEntry(currName, chrSize, ARGS.targetAssembly, ARGS.species)),
        version, VCFConstants.CONTIG_HEADER_KEY, i++));
  }

  return new VCFHeader(newLines, in.getSampleNamesInOrder());
}