bcftools/bcfutils.c

   1 #include <string.h>
   2 #include "bcf.h"
   3 #include "kstring.h"
   4 #include "khash.h"
   5 KHASH_MAP_INIT_STR(str2id, int)
   6
   7 void *bcf_build_refhash(bcf_hdr_t *h)
   8 {
   9         khash_t(str2id) *hash;
  10         int i, ret;
  11         hash = kh_init(str2id);
  12         for (i = 0; i < h->n_ref; ++i) {
  13                 khint_t k;
  14                 k = kh_put(str2id, hash, h->ns[i], &ret); // FIXME: check ret
  15                 kh_val(hash, k) = i;
  16         }
  17         return hash;
  18 }
  19
  20 void *bcf_str2id_init()
  21 {
  22         return kh_init(str2id);
  23 }
  24
  25 void bcf_str2id_destroy(void *_hash)
  26 {
  27         khash_t(str2id) *hash = (khash_t(str2id)*)_hash;
  28         if (hash) kh_destroy(str2id, hash); // Note that strings are not freed.
  29 }
  30
  31 int bcf_str2id(void *_hash, const char *str)
  32 {
  33         khash_t(str2id) *hash = (khash_t(str2id)*)_hash;
  34         khint_t k;
  35         if (!hash) return -1;
  36         k = kh_get(str2id, hash, str);
  37         return k == kh_end(hash)? -1 : kh_val(hash, k);
  38 }
  39
  40 int bcf_str2id_add(void *_hash, const char *str)
  41 {
  42         khint_t k;
  43         int ret;
  44         khash_t(str2id) *hash = (khash_t(str2id)*)_hash;
  45         if (!hash) return -1;
  46         k = kh_put(str2id, hash, str, &ret);
  47         if (ret == 0) return kh_val(hash, k);
  48         kh_val(hash, k) = kh_size(hash) - 1;
  49         return kh_val(hash, k);
  50 }
  51
  52 int bcf_shrink_alt(bcf1_t *b, int n)
  53 {
  54         char *p;
  55         int i, j, k, *z, n_smpl = b->n_smpl;
  56         if (b->n_alleles <= n) return -1;
  57         if (n > 1) {
  58                 for (p = b->alt, k = 1; *p; ++p)
  59                         if (*p == ',' && ++k == n) break;
  60                 *p = '\0';
  61         } else p = b->alt, *p = '\0';
  62         ++p;
  63         memmove(p, b->flt, b->str + b->l_str - b->flt);
  64         b->l_str -= b->flt - p;
  65         z = alloca(sizeof(int) / 2 * n * (n+1));
  66         for (i = k = 0; i < n; ++i)
  67                 for (j = 0; j < n - i; ++j)
  68                         z[k++] = i * b->n_alleles + j;
  69         for (i = 0; i < b->n_gi; ++i) {
  70                 bcf_ginfo_t *g = b->gi + i;
  71                 if (g->fmt == bcf_str2int("PL", 2)) {
  72                         int l, x = b->n_alleles * (b->n_alleles + 1) / 2;
  73                         uint8_t *d = (uint8_t*)g->data;
  74                         g->len = n * (n + 1) / 2;
  75                         for (l = k = 0; l < n_smpl; ++l) {
  76                                 uint8_t *dl = d + l * x;
  77                                 for (j = 0; j < g->len; ++j) d[k++] = dl[z[j]];
  78                         }
  79                 } // FIXME: to add GL
  80         }
  81         b->n_alleles = n;
  82         bcf_sync(b);
  83         return 0;
  84 }
  85
  86 int bcf_gl2pl(bcf1_t *b)
  87 {
  88         char *p;
  89         int i, n_smpl = b->n_smpl;
  90         bcf_ginfo_t *g;
  91         float *d0;
  92         uint8_t *d1;
  93         if (strstr(b->fmt, "PL")) return -1;
  94         if ((p = strstr(b->fmt, "GL")) == 0) return -1;
  95         *p = 'P';
  96         for (i = 0; i < b->n_gi; ++i)
  97                 if (b->gi[i].fmt == bcf_str2int("GL", 2))
  98                         break;
  99         g = b->gi + i;
 100         g->fmt = bcf_str2int("PL", 2);
 101         g->len /= 4; // 4 == sizeof(float)
 102         d0 = (float*)g->data; d1 = (uint8_t*)g->data;
 103         for (i = 0; i < n_smpl * g->len; ++i) {
 104                 int x = (int)(-10. * d0[i] + .499);
 105                 if (x > 255) x = 255;
 106                 if (x < 0) x = 0;
 107                 d1[i] = x;
 108         }
 109         return 0;
 110 }
 111 /* FIXME: this function will fail given AB:GTX:GT. BCFtools never
 112  * produces such FMT, but others may do. */
 113 int bcf_fix_gt(bcf1_t *b)
 114 {
 115         char *s;
 116         int i;
 117         uint32_t tmp;
 118         bcf_ginfo_t gt;
 119         // check the presence of the GT FMT
 120         if ((s = strstr(b->fmt, ":GT")) == 0) return 0; // no GT or GT is already the first
 121         if (s[3] != '\0' && s[3] != ':') return 0; // :GTX in fact
 122         tmp = bcf_str2int("GT", 2);
 123         for (i = 0; i < b->n_gi; ++i)
 124                 if (b->gi[i].fmt == tmp) break;
 125         if (i == b->n_gi) return 0; // no GT in b->gi; probably a bug...
 126         gt = b->gi[i];
 127         // move GT to the first
 128         for (; i > 0; --i) b->gi[i] = b->gi[i-1];
 129         b->gi[0] = gt;
 130         memmove(b->fmt + 3, b->fmt, s + 1 - b->fmt);
 131         b->fmt[0] = 'G'; b->fmt[1] = 'T'; b->fmt[2] = ':';
 132         return 0;
 133 }