int main_vcfview(int argc, char *argv[])
{
int i, c, clevel = -1, flag = 0, n_samples = -1, *imap = 0, excl_snp = 0, excl_indel = 0;
char *fn_ref = 0, *fn_out = 0, moder[8], **samples = 0;
bcf_hdr_t *h, *hsub = 0;
htsFile *in;
bcf1_t *b;
while ((c = getopt(argc, argv, "l:bSt:o:T:s:GNI")) >= 0) {
switch (c) {
case 'l': clevel = atoi(optarg); flag |= 2; break;
case 'S': flag |= 1; break;
case 'b': flag |= 2; break;
case 'G': n_samples = 0; break;
case 't': fn_ref = optarg; flag |= 1; break;
case 'o': fn_out = optarg; break;
case 's': samples = hts_readlines(optarg, &n_samples); break;
case 'N': excl_snp = 1; break;
case 'I': excl_indel = 1; break;
}
}
if (argc == optind) {
fprintf(stderr, "\nUsage: vcfview [options] <in.bcf>|<in.vcf>|<in.vcf.gz>\n\n");
fprintf(stderr, "Options: -b output in BCF\n");
fprintf(stderr, " -S input is VCF\n");
fprintf(stderr, " -o FILE output file name [stdout]\n");
fprintf(stderr, " -l INT compression level [%d]\n", clevel);
fprintf(stderr, " -t FILE list of reference names and lengths [null]\n");
fprintf(stderr, " -s FILE/STR list of samples (STR if started with ':'; FILE otherwise) [null]\n");
fprintf(stderr, " -G drop individual genotype information\n");
fprintf(stderr, " -N exclude SNPs\n");
fprintf(stderr, " -I exclude INDELs\n");
fprintf(stderr, "\n");
return 1;
}
strcpy(moder, "r");
if ((flag&1) == 0 && !(file_type(argv[optind])&(IS_VCF|IS_VCF_GZ))) strcat(moder, "b");
in = hts_open(argv[optind], moder, fn_ref);
h = vcf_hdr_read(in);
if (h == 0) {
fprintf(stderr, "[E::%s] fail to read the VCF/BCF2 header\n", __func__);
hts_close(in);
return 1;
}
if (n_samples >= 0) {
if (n_samples) imap = (int*)malloc(n_samples * sizeof(int));
hsub = bcf_hdr_subset(h, n_samples, samples, imap);
}
b = bcf_init1();
if ((flag&4) == 0) { // VCF/BCF output
htsFile *out;
char modew[8];
strcpy(modew, "w");
if (clevel >= 0 && clevel <= 9) sprintf(modew + 1, "%d", clevel);
if (flag&2) strcat(modew, "b");
out = hts_open(fn_out? fn_out : "-", modew, 0);
vcf_hdr_write(out, hsub? hsub : h);
if (optind + 1 < argc && !(flag&1)) { // BAM input and has a region
hts_idx_t *idx;
if ((idx = bcf_index_load(argv[optind])) == 0) {
fprintf(stderr, "[E::%s] fail to load the BCF index\n", __func__);
return 1;
}
for (i = optind + 1; i < argc; ++i) {
hts_itr_t *iter;
if ((iter = bcf_itr_querys(idx, h, argv[i])) == 0) {
fprintf(stderr, "[E::%s] fail to parse region '%s'\n", __func__, argv[i]);
continue;
}
while (bcf_itr_next((BGZF*)in->fp, iter, b) >= 0) {
if (excl_snp && bcf_is_snp(b)) continue;
if (excl_indel && !bcf_is_snp(b)) continue;
if (n_samples >= 0) {
bcf_subset(h, b, n_samples, imap);
vcf_write1(out, hsub, b);
} else vcf_write1(out, h, b);
}
hts_itr_destroy(iter);
}
hts_idx_destroy(idx);
} else {
while (vcf_read1(in, h, b) >= 0) {
if (excl_snp && bcf_is_snp(b)) continue;
if (excl_indel && !bcf_is_snp(b)) continue;
if (n_samples >= 0) {
bcf_subset(h, b, n_samples, imap);
vcf_write1(out, hsub, b);
} else vcf_write1(out, h, b);
}
}
hts_close(out);
}
bcf_destroy1(b);
if (n_samples > 0) {
for (i = 0; i < n_samples; ++i) free(samples[i]);
free(samples);
bcf_hdr_destroy(hsub);
free(imap);
}
bcf_hdr_destroy(h);
hts_close(in);
return 0;
}
int main_vcfcall(int argc, char *argv[])
{
char *samples_fname = NULL;
args_t args;
memset(&args, 0, sizeof(args_t));
args.argc = argc; args.argv = argv;
args.aux.prior_type = -1;
args.aux.indel_frac = -1;
args.aux.theta = 1e-3;
args.aux.pref = 0.5;
args.aux.min_perm_p = 0.01;
args.aux.min_lrt = 1;
args.flag = CF_ACGT_ONLY;
args.output_fname = "-";
args.output_type = FT_VCF;
args.aux.trio_Pm_SNPs = 1 - 1e-8;
args.aux.trio_Pm_ins = args.aux.trio_Pm_del = 1 - 1e-9;
int i, c, samples_is_file = 0;
static struct option loptions[] =
{
{"help",0,0,'h'},
{"gvcf",1,0,'g'},
{"format-fields",1,0,'f'},
{"output",1,0,'o'},
{"output-type",1,0,'O'},
{"regions",1,0,'r'},
{"regions-file",1,0,'R'},
{"samples",1,0,'s'},
{"samples-file",1,0,'S'},
{"targets",1,0,'t'},
{"targets-file",1,0,'T'},
{"keep-alts",0,0,'A'},
{"insert-missed",0,0,'i'},
{"skip-Ns",0,0,'N'}, // now the new default
{"keep-masked-refs",0,0,'M'},
{"skip-variants",1,0,'V'},
{"variants-only",0,0,'v'},
{"consensus-caller",0,0,'c'},
{"constrain",1,0,'C'},
{"multiallelic-caller",0,0,'m'},
{"pval-threshold",1,0,'p'},
{"prior",1,0,'P'},
{"chromosome-X",0,0,'X'},
{"chromosome-Y",0,0,'Y'},
{"novel-rate",1,0,'n'},
{0,0,0,0}
};
char *tmp = NULL;
while ((c = getopt_long(argc, argv, "h?o:O:r:R:s:S:t:T:ANMV:vcmp:C:XYn:P:f:ig:", loptions, NULL)) >= 0)
{
switch (c)
{
case 'g':
args.flag |= CF_GVCF;
args.gvcf.min_dp = strtol(optarg,&tmp,10);
if ( *tmp ) error("Could not parse, expected integer argument: -g %s\n", optarg);
break;
case 'f': args.aux.output_tags |= parse_format_flag(optarg); break;
case 'M': args.flag &= ~CF_ACGT_ONLY; break; // keep sites where REF is N
case 'N': args.flag |= CF_ACGT_ONLY; break; // omit sites where first base in REF is N (the new default)
case 'A': args.aux.flag |= CALL_KEEPALT; break;
case 'c': args.flag |= CF_CCALL; break; // the original EM based calling method
case 'i': args.flag |= CF_INS_MISSED; break;
case 'v': args.aux.flag |= CALL_VARONLY; break;
case 'o': args.output_fname = optarg; break;
case 'O':
switch (optarg[0]) {
case 'b': args.output_type = FT_BCF_GZ; break;
case 'u': args.output_type = FT_BCF; break;
case 'z': args.output_type = FT_VCF_GZ; break;
case 'v': args.output_type = FT_VCF; break;
default: error("The output type \"%s\" not recognised\n", optarg);
}
break;
case 'C':
if ( !strcasecmp(optarg,"alleles") ) args.aux.flag |= CALL_CONSTR_ALLELES;
else if ( !strcasecmp(optarg,"trio") ) args.aux.flag |= CALL_CONSTR_TRIO;
else error("Unknown argument to -C: \"%s\"\n", optarg);
break;
case 'X': args.aux.flag |= CALL_CHR_X; break;
case 'Y': args.aux.flag |= CALL_CHR_Y; break;
case 'V':
if ( !strcasecmp(optarg,"snps") ) args.flag |= CF_INDEL_ONLY;
else if ( !strcasecmp(optarg,"indels") ) args.flag |= CF_NO_INDEL;
else error("Unknown skip category \"%s\" (-S argument must be \"snps\" or \"indels\")\n", optarg);
break;
case 'm': args.flag |= CF_MCALL; break; // multiallelic calling method
case 'p': args.aux.pref = atof(optarg); break;
case 'P': args.aux.theta = strtod(optarg,&tmp);
if ( *tmp ) error("Could not parse, expected float argument: -P %s\n", optarg);
break;
case 'n': parse_novel_rate(&args,optarg); break;
case 'r': args.regions = optarg; break;
case 'R': args.regions = optarg; args.regions_is_file = 1; break;
case 't': args.targets = optarg; break;
case 'T': args.targets = optarg; args.targets_is_file = 1; break;
case 's': samples_fname = optarg; break;
case 'S': samples_fname = optarg; samples_is_file = 1; break;
default: usage(&args);
}
}
if ( optind>=argc )
{
if ( !isatty(fileno((FILE *)stdin)) ) args.bcf_fname = "-"; // reading from stdin
else usage(&args);
}
else args.bcf_fname = argv[optind++];
// Sanity check options and initialize
if ( samples_fname )
{
args.samples = read_samples(&args.aux, samples_fname, samples_is_file, &args.nsamples);
args.aux.ploidy = (uint8_t*) calloc(args.nsamples+1, 1);
args.aux.all_diploid = 1;
for (i=0; i<args.nsamples; i++)
{
args.aux.ploidy[i] = args.samples[i][strlen(args.samples[i]) + 1];
if ( args.aux.ploidy[i]!=2 ) args.aux.all_diploid = 0;
}
}
if ( args.flag & CF_GVCF )
{
// Force some flags to avoid unnecessary branching
args.aux.flag &= ~CALL_KEEPALT;
args.aux.flag |= CALL_VARONLY;
}
if ( (args.flag & CF_CCALL ? 1 : 0) + (args.flag & CF_MCALL ? 1 : 0) + (args.flag & CF_QCALL ? 1 : 0) > 1 ) error("Only one of -c or -m options can be given\n");
if ( !(args.flag & CF_CCALL) && !(args.flag & CF_MCALL) && !(args.flag & CF_QCALL) ) error("Expected -c or -m option\n");
if ( args.aux.n_perm && args.aux.ngrp1_samples<=0 ) error("Expected -1 with -U\n"); // not sure about this, please fix
if ( args.aux.flag & CALL_CONSTR_ALLELES )
{
if ( !args.targets ) error("Expected -t or -T with \"-C alleles\"\n");
if ( !(args.flag & CF_MCALL) ) error("The \"-C alleles\" mode requires -m\n");
}
if ( args.aux.flag & CALL_CHR_X && args.aux.flag & CALL_CHR_Y ) error("Only one of -X or -Y should be given\n");
if ( args.flag & CF_INS_MISSED && !(args.aux.flag&CALL_CONSTR_ALLELES) ) error("The -i option requires -C alleles\n");
init_data(&args);
while ( bcf_sr_next_line(args.aux.srs) )
{
bcf1_t *bcf_rec = args.aux.srs->readers[0].buffer[0];
if ( args.samples_map ) bcf_subset(args.aux.hdr, bcf_rec, args.nsamples, args.samples_map);
bcf_unpack(bcf_rec, BCF_UN_STR);
// Skip unwanted sites
if ( args.aux.flag & CALL_VARONLY )
{
int is_ref = 0;
if ( bcf_rec->n_allele==1 ) is_ref = 1; // not a variant
else if ( bcf_rec->n_allele==2 )
{
// second allele is mpileup's X, not a variant
if ( bcf_rec->d.allele[1][0]=='X' ) is_ref = 1;
else if ( bcf_rec->d.allele[1][0]=='<' && bcf_rec->d.allele[1][1]=='X' && bcf_rec->d.allele[1][2]=='>' ) is_ref = 1;
}
if ( is_ref )
{
// gVCF output
if ( args.flag & CF_GVCF ) gvcf_write(args.out_fh, &args.gvcf, args.aux.hdr, bcf_rec, 1);
continue;
}
}
if ( (args.flag & CF_INDEL_ONLY) && bcf_is_snp(bcf_rec) ) continue; // not an indel
if ( (args.flag & CF_NO_INDEL) && !bcf_is_snp(bcf_rec) ) continue; // not a SNP
if ( (args.flag & CF_ACGT_ONLY) && (bcf_rec->d.allele[0][0]=='N' || bcf_rec->d.allele[0][0]=='n') ) continue; // REF[0] is 'N'
bcf_unpack(bcf_rec, BCF_UN_ALL);
// Various output modes: QCall output (todo)
if ( args.flag & CF_QCALL )
{
qcall(&args.aux, bcf_rec);
continue;
}
// Calling modes which output VCFs
int ret;
if ( args.flag & CF_MCALL )
ret = mcall(&args.aux, bcf_rec);
else
ret = ccall(&args.aux, bcf_rec);
if ( ret==-1 ) error("Something is wrong\n");
// gVCF output
if ( args.flag & CF_GVCF )
{
gvcf_write(args.out_fh, &args.gvcf, args.aux.hdr, bcf_rec, ret?0:1);
continue;
}
// Normal output
if ( (args.aux.flag & CALL_VARONLY) && ret==0 ) continue; // not a variant
bcf_write1(args.out_fh, args.aux.hdr, bcf_rec);
}
if ( args.flag & CF_GVCF ) gvcf_write(args.out_fh, &args.gvcf, args.aux.hdr, NULL, 0);
if ( args.flag & CF_INS_MISSED ) bcf_sr_regions_flush(args.aux.srs->targets);
destroy_data(&args);
return 0;
}
int subset_vcf(args_t *args, bcf1_t *line)
{
if ( args->min_alleles && line->n_allele < args->min_alleles ) return 0; // min alleles
if ( args->max_alleles && line->n_allele > args->max_alleles ) return 0; // max alleles
if (args->novel || args->known)
{
if ( args->novel && (line->d.id[0]!='.' || line->d.id[1]!=0) ) return 0; // skip sites which are known, ID != '.'
if ( args->known && line->d.id[0]=='.' && line->d.id[1]==0 ) return 0; // skip sites which are novel, ID == '.'
}
if (args->include || args->exclude)
{
int line_type = bcf_get_variant_types(line);
if ( args->include && !(line_type&args->include) ) return 0; // include only given variant types
if ( args->exclude && line_type&args->exclude ) return 0; // exclude given variant types
}
if ( args->filter )
{
int ret = filter_test(args->filter, line, NULL);
if ( args->filter_logic==FLT_INCLUDE ) { if ( !ret ) return 0; }
else if ( ret ) return 0;
}
hts_expand(int, line->n_allele, args->mac, args->ac);
int i, an = 0, non_ref_ac = 0;
if (args->calc_ac) {
bcf_calc_ac(args->hdr, line, args->ac, BCF_UN_INFO|BCF_UN_FMT); // get original AC and AN values from INFO field if available, otherwise calculate
for (i=1; i<line->n_allele; i++)
non_ref_ac += args->ac[i];
for (i=0; i<line->n_allele; i++)
an += args->ac[i];
}
if (args->n_samples)
{
int non_ref_ac_sub = 0, *ac_sub = (int*) calloc(line->n_allele,sizeof(int));
bcf_subset(args->hdr, line, args->n_samples, args->imap);
if (args->calc_ac) {
bcf_calc_ac(args->hsub, line, ac_sub, BCF_UN_FMT); // recalculate AC and AN
an = 0;
for (i=0; i<line->n_allele; i++) {
args->ac[i] = ac_sub[i];
an += ac_sub[i];
}
for (i=1; i<line->n_allele; i++)
non_ref_ac_sub += ac_sub[i];
if (args->private_vars) {
if (args->private_vars == FLT_INCLUDE && !(non_ref_ac_sub > 0 && non_ref_ac == non_ref_ac_sub)) { free(ac_sub); return 0; } // select private sites
if (args->private_vars == FLT_EXCLUDE && non_ref_ac_sub > 0 && non_ref_ac == non_ref_ac_sub) { free(ac_sub); return 0; } // exclude private sites
}
non_ref_ac = non_ref_ac_sub;
}
free(ac_sub);
}
bcf_fmt_t *gt_fmt;
if ( args->gt_type && (gt_fmt=bcf_get_fmt(args->hdr,line,"GT")) )
{
int nhet = 0, nhom = 0, nmiss = 0;
for (i=0; i<bcf_hdr_nsamples(args->hdr); i++)
{
int type = bcf_gt_type(gt_fmt,i,NULL,NULL);
if ( type==GT_HET_RA || type==GT_HET_AA )
{
if ( args->gt_type==GT_NO_HET ) return 0;
nhet = 1;
}
else if ( type==GT_UNKN )
{
if ( args->gt_type==GT_NO_MISSING ) return 0;
nmiss = 1;
}
else
{
if ( args->gt_type==GT_NO_HOM ) return 0;
nhom = 1;
}
}
if ( args->gt_type==GT_NEED_HOM && !nhom ) return 0;
else if ( args->gt_type==GT_NEED_HET && !nhet ) return 0;
else if ( args->gt_type==GT_NEED_MISSING && !nmiss ) return 0;
}
int minor_ac = 0;
int major_ac = 0;
if ( args->calc_ac )
{
minor_ac = args->ac[0];
major_ac = args->ac[0];
for (i=1; i<line->n_allele; i++){
if (args->ac[i] < minor_ac) { minor_ac = args->ac[i]; }
if (args->ac[i] > major_ac) { major_ac = args->ac[i]; }
}
}
if (args->min_ac)
{
if (args->min_ac_type == ALLELE_NONREF && args->min_ac>non_ref_ac) return 0; // min AC
else if (args->min_ac_type == ALLELE_MINOR && args->min_ac>minor_ac) return 0; // min minor AC
else if (args->min_ac_type == ALLELE_ALT1 && args->min_ac>args->ac[1]) return 0; // min 1st alternate AC
else if (args->min_ac_type == ALLELE_MAJOR && args->min_ac > major_ac) return 0; // min major AC
else if (args->min_ac_type == ALLELE_NONMAJOR && args->min_ac > an-major_ac) return 0; // min non-major AC
}
if (args->max_ac)
{
if (args->max_ac_type == ALLELE_NONREF && args->max_ac<non_ref_ac) return 0; // max AC
else if (args->max_ac_type == ALLELE_MINOR && args->max_ac<minor_ac) return 0; // max minor AC
else if (args->max_ac_type == ALLELE_ALT1 && args->max_ac<args->ac[1]) return 0; // max 1st alternate AC
else if (args->max_ac_type == ALLELE_MAJOR && args->max_ac < major_ac) return 0; // max major AC
else if (args->max_ac_type == ALLELE_NONMAJOR && args->max_ac < an-major_ac) return 0; // max non-major AC
}
if (args->min_af)
{
if (an == 0) return 0; // freq not defined, skip site
if (args->min_af_type == ALLELE_NONREF && args->min_af>non_ref_ac/(double)an) return 0; // min AF
else if (args->min_af_type == ALLELE_MINOR && args->min_af>minor_ac/(double)an) return 0; // min minor AF
else if (args->min_af_type == ALLELE_ALT1 && args->min_af>args->ac[1]/(double)an) return 0; // min 1st alternate AF
else if (args->min_af_type == ALLELE_MAJOR && args->min_af > major_ac/(double)an) return 0; // min major AF
else if (args->min_af_type == ALLELE_NONMAJOR && args->min_af > (an-major_ac)/(double)an) return 0; // min non-major AF
}
if (args->max_af)
{
if (an == 0) return 0; // freq not defined, skip site
if (args->max_af_type == ALLELE_NONREF && args->max_af<non_ref_ac/(double)an) return 0; // max AF
else if (args->max_af_type == ALLELE_MINOR && args->max_af<minor_ac/(double)an) return 0; // max minor AF
else if (args->max_af_type == ALLELE_ALT1 && args->max_af<args->ac[1]/(double)an) return 0; // max 1st alternate AF
else if (args->max_af_type == ALLELE_MAJOR && args->max_af < major_ac/(double)an) return 0; // max major AF
else if (args->max_af_type == ALLELE_NONMAJOR && args->max_af < (an-major_ac)/(double)an) return 0; // max non-major AF
}
if (args->uncalled) {
if (args->uncalled == FLT_INCLUDE && an > 0) return 0; // select uncalled
if (args->uncalled == FLT_EXCLUDE && an == 0) return 0; // skip if uncalled
}
if (args->calc_ac && args->update_info) {
bcf_update_info_int32(args->hdr, line, "AC", &args->ac[1], line->n_allele-1);
bcf_update_info_int32(args->hdr, line, "AN", &an, 1);
}
if (args->trim_alts)
{
int ret = bcf_trim_alleles(args->hsub ? args->hsub : args->hdr, line);
if ( ret==-1 ) error("Error: some GT index is out of bounds at %s:%d\n", bcf_seqname(args->hsub ? args->hsub : args->hdr, line), line->pos+1);
}
if (args->phased) {
int phased = bcf_all_phased(args->hdr, line);
if (args->phased == FLT_INCLUDE && !phased) { return 0; } // skip unphased
if (args->phased == FLT_EXCLUDE && phased) { return 0; } // skip phased
}
if (args->sites_only) bcf_subset(args->hsub ? args->hsub : args->hdr, line, 0, 0);
return 1;
}
