chip-seq/ 0000744 0227442 0026227 00000000000 13433535475 013071 5 ustar ambrosin gr-bucher chip-seq/chipcenter.c 0000744 0227442 0026227 00000062534 13351136302 015357 0 ustar ambrosin gr-bucher /*
chip_center.c
Tag centering Tool.
The program moves observed ChIP-tags to
estimate center-position of DNA fragments.
# Arguments:
# feature type, relative tag shift
Giovanna Ambrosini, ISREC, Giovanna.Ambrosini@isrec.ch
Copyright (c) 2014 EPFL and Swiss Institute of Bioinformatics.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
#define DEBUG
*/
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include "hashtable.h"
#ifdef DEBUG
#include
#endif
#include "version.h"
/*#define BUF_SIZE 4096 */
#define BUF_SIZE 8192
#define LINE_SIZE 1024
#define FT_MAX 64
#define SEQ_ID 32
#define POS_MAX 16
#define CNT_MAX 16
#define EXT_MAX 256
#define CHR_NB 18
#define AC_MAX 18
#define CHR_SIZE 10
typedef struct _options_t {
int help;
int debug;
char *dbPath;
int db;
int strand;
} options_t;
static options_t options;
typedef struct _feature_t {
char seq_id[SEQ_ID];
unsigned long *pos;
char **feature;
char strand;
int *cnt;
char **ext;
} feature_t, *feature_p_t;
feature_t ft_plus, ft_minus;
typedef struct _end_line_t {
char seq_id[SEQ_ID];
unsigned long pos;
char feature[5];
char strand;
int cnt;
} _end_line_t;
_end_line_t end_line;
static hash_table_t *size_table = NULL;
char *Feature = NULL;
char *newFeature = NULL;
int Shift = 0;
int ft_specs = 1; /* if = 0 Process all features */
int Coff = 1;
int ext_flag = 0;
int end_line_flag = 0;
unsigned long Len = 0; /* Total Sequence Length */
unsigned long Counts = 0; /* Total Target Counts */
int
process_size()
{
FILE *input;
int c;
char buf[LINE_SIZE];
char *chrSizeFile;
int cLen;
if (options.db) {
cLen = (int)strlen(options.dbPath) + 10;
if ((chrSizeFile = (char*)malloc(cLen * sizeof(char))) == NULL) {
perror("process_ac: malloc");
exit(1);
}
strcpy(chrSizeFile, options.dbPath);
} else {
cLen = 16 + 10;
if ((chrSizeFile = (char*)malloc(cLen * sizeof(char))) == NULL) {
perror("process_ac: malloc");
exit(1);
}
strcpy(chrSizeFile, "/local/db/genome");
}
strcat(chrSizeFile, "/chr_size");
input = fopen(chrSizeFile, "r");
if (input == NULL) {
fprintf(stderr, "Could not open file %s: %s(%d)\n",
chrSizeFile, strerror(errno), errno);
return 1;
}
do {
c = fgetc(input);
} while(c != '\n');
size_table = hash_table_new(MODE_COPY);
while (fgets(buf, LINE_SIZE, input) != NULL) {
char *s;
char chr_size[CHR_SIZE] = "";
char ncbi_ac[AC_MAX] = "";
int i = 0;
int ac_len = 0;
int size_len = 0;
/*int valid = 1;*/
s = buf;
/* Check line */
/* Get first character: if # skip line */
if (*s == '#')
continue;
/* Chromosome NCBI AC */
i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= AC_MAX) {
fprintf(stderr, "AC too long \"%s\" \n", s);
fclose(input);
exit(1);
}
ncbi_ac[i++] = *s++;
}
if (i < AC_MAX)
ncbi_ac[i] = 0;
ac_len = i + 1;
while (isspace(*s))
s++;
i = 0;
/* Chrom SIZE */
while (*s != 0 && !isspace(*s)) {
if (i >= CHR_SIZE) {
fprintf(stderr, "Size too long in %s\n", s);
fclose(input);
exit(1);
}
chr_size[i++] = *s++;
}
if (i < CHR_NB)
chr_size[i] = 0;
size_len = i + 1;
/* printf("adding key %s (len = %d) value %s (ac) (len = %d) to hash table\n", ncbi_ac, ac_len, chr_size, size_len); */
hash_table_add(size_table, ncbi_ac, (size_t)ac_len, chr_size, (size_t)size_len);
if (options.debug) {
char *csize = hash_table_lookup(size_table, ncbi_ac, (size_t)ac_len);
fprintf (stderr, " SIZE Hash table: %s (len = %d) -> %s (len = %d)\n", ncbi_ac, ac_len, csize, size_len);
}
}
return 0;
}
void
merge(unsigned int size1, unsigned int size2)
{
/* Merge the two sorted sub-lists and print the result*/
unsigned int j = 0;
unsigned int k = 0;
while (j < size1 && k < size2) {
if (ft_plus.pos[j] < ft_minus.pos[k]) {
if (ext_flag) {
if (newFeature != NULL) {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_plus.seq_id, newFeature, ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j], ft_plus.ext[j]);
} else {
if (Feature != NULL)
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_plus.seq_id, Feature, ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j], ft_plus.ext[j]);
else
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_plus.seq_id, ft_plus.feature[j], ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j], ft_plus.ext[j]);
}
} else {
if (newFeature != NULL) {
printf("%s\t%s\t%lu\t%c\t%d\n",ft_plus.seq_id, newFeature, ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j]);
} else {
if (Feature != NULL)
printf("%s\t%s\t%lu\t%c\t%d\n",ft_plus.seq_id, Feature, ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j]);
else
printf("%s\t%s\t%lu\t%c\t%d\n",ft_plus.seq_id, ft_plus.feature[j], ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j]);
}
}
j++;
} else {
if (ext_flag) {
if (newFeature != NULL) {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_minus.seq_id, newFeature, ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k], ft_minus.ext[k]);
} else {
if (Feature != NULL)
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_minus.seq_id, Feature, ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k], ft_minus.ext[k]);
else
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_minus.seq_id, ft_minus.feature[k], ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k], ft_minus.ext[k]);
}
} else {
if (newFeature != NULL) {
printf("%s\t%s\t%lu\t%c\t%d\n",ft_minus.seq_id, newFeature, ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k]);
} else {
if (Feature != NULL)
printf("%s\t%s\t%lu\t%c\t%d\n",ft_minus.seq_id, Feature, ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k]);
else
printf("%s\t%s\t%lu\t%c\t%d\n",ft_minus.seq_id, ft_minus.feature[k], ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k]);
}
}
k++;
}
}
while (j < size1) {
if (ext_flag) {
if (newFeature != NULL) {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_plus.seq_id, newFeature, ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j], ft_plus.ext[j]);
} else {
if (Feature != NULL)
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_plus.seq_id, Feature, ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j], ft_plus.ext[j]);
else
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_plus.seq_id, ft_plus.feature[j], ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j], ft_plus.ext[j]);
}
} else {
if (newFeature != NULL) {
printf("%s\t%s\t%lu\t%c\t%d\n",ft_plus.seq_id, newFeature, ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j]);
} else {
if (Feature != NULL)
printf("%s\t%s\t%lu\t%c\t%d\n",ft_plus.seq_id, Feature, ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j]);
else
printf("%s\t%s\t%lu\t%c\t%d\n",ft_plus.seq_id, ft_plus.feature[j], ft_plus.pos[j], ft_plus.strand, ft_plus.cnt[j]);
}
}
j++;
}
while (k < size2) {
if (ext_flag) {
if (newFeature != NULL) {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_minus.seq_id, newFeature, ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k], ft_minus.ext[k]);
} else {
if (Feature != NULL)
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_minus.seq_id, Feature, ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k], ft_minus.ext[k]);
else
printf("%s\t%s\t%lu\t%c\t%d\t%s\n",ft_minus.seq_id, ft_minus.feature[k], ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k], ft_minus.ext[k]);
}
} else {
if (newFeature != NULL) {
printf("%s\t%s\t%lu\t%c\t%d\n",ft_minus.seq_id, newFeature, ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k]);
} else {
if (Feature != NULL)
printf("%s\t%s\t%lu\t%c\t%d\n",ft_minus.seq_id, Feature, ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k]);
else
printf("%s\t%s\t%lu\t%c\t%d\n",ft_minus.seq_id, ft_minus.feature[k], ft_minus.pos[k], ft_minus.strand, ft_minus.cnt[k]);
}
}
k++;
}
if (end_line_flag)
printf("%s\t%s\t%lu\t%c\t%d\n",end_line.seq_id, end_line.feature, end_line.pos, end_line.strand, end_line.cnt);
}
int
process_sga(FILE *input)
{
char seq_id_prev[SEQ_ID] = "";
int pos, cnt, last_pos = 0;
int first = 1;
size_t mLen1 = BUF_SIZE;
size_t mLen2 = BUF_SIZE;
unsigned int k = 0;
unsigned int j = 0;
char *s, *res, *buf;
size_t mLen = LINE_SIZE;
int ac_len = 0;
char *csize = NULL;
int chr_size = 0;
if ((ft_plus.pos = (unsigned long*)calloc(mLen1, sizeof(unsigned long))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if ((ft_minus.pos = (unsigned long*)calloc(mLen2, sizeof(unsigned long))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if ((ft_plus.cnt = (int*)calloc(mLen1, sizeof(int))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if ((ft_minus.cnt = (int*)calloc(mLen2, sizeof(int))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if (Feature == NULL) {
if ((ft_plus.feature = (char**)calloc(mLen1, sizeof(*(ft_plus.feature)))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if ((ft_minus.feature = (char**)calloc(mLen2, sizeof(*(ft_minus.feature)))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
}
if ((s = malloc(mLen * sizeof(char))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
#ifdef DEBUG
int c = 1;
#endif
if (options.strand) {
ft_minus.strand = '0';
ft_plus.strand = '0';
} else {
ft_minus.strand = '-';
ft_plus.strand = '+';
}
/*
while (fscanf(f,"%s %s %d %c %d", seq_id, ft, &pos, &strand, &cnt) != EOF) {
*/
while ((res = fgets(s, (int) mLen, input)) != NULL) {
size_t cLen = strlen(s);
char seq_id[SEQ_ID] = "";
char ft[FT_MAX] = "";
char position[POS_MAX] = "";
char count[CNT_MAX] = "";
char strand = '\0';
char ext[EXT_MAX];
unsigned int i = 0;
memset(ext, 0, (size_t)EXT_MAX);
while (cLen + 1 == mLen && s[cLen - 1] != '\n') {
mLen *= 2;
if ((s = realloc(s, mLen)) == NULL) {
perror("process_file: realloc");
exit(1);
}
res = fgets(s + cLen, (int) (mLen - cLen), input);
cLen = strlen(s);
}
if (s[cLen - 1] == '\n')
s[cLen - 1] = 0;
buf = s;
/* Get SGA fields */
/* SEQ ID */
while (*buf != 0 && !isspace(*buf)) {
if (i >= SEQ_ID) {
fprintf(stderr, "Seq ID is too long \"%s\" \n", buf);
exit(1);
}
seq_id[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* FEATURE */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature is too long \"%s\" \n", buf);
exit(1);
}
ft[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "Position is too large \"%s\" \n", buf);
exit(1);
}
position[i++] = *buf++;
}
position[i] = 0;
pos = atoi(position);
while (isspace(*buf))
buf++;
/* Strand */
strand = *buf++;
while (isspace(*buf))
buf++;
/* Counts */
i = 0;
while (isdigit(*buf) || *buf == '+' || *buf == '-') {
if (i >= CNT_MAX) {
fprintf(stderr, "Count is too large \"%s\" \n", buf);
exit(1);
}
count[i++] = *buf++;
}
count[i] = 0;
cnt = atoi(count);
while (isspace(*buf))
buf++;
/* SGA Extension */
i = 0;
while (*buf != 0) {
if (i >= EXT_MAX) {
fprintf(stderr, "Extension is too long \"%s\" \n", buf);
exit(1);
}
ext[i++] = *buf++;
ext_flag = 1;
}
#ifdef DEBUG
printf(" [%d] seq ID: %s Feat: %s%c Pos: %d Cnts: %d Ext: %s\n", c++, seq_id, ft, strand, pos, cnt, ext);
#endif
if (ext_flag && first) {
if ((ft_plus.ext = (char**)calloc(mLen1, sizeof(*(ft_plus.ext)))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if ((ft_minus.ext = (char**)calloc(mLen2, sizeof(*(ft_minus.ext)))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
first = 0;
}
if (j >= mLen1 - 1) {
mLen1 *= 2;
#ifdef DEBUG
fprintf(stderr, "reallocating memory for ft_plus (j=%d, size=%d)\n", j, (int)mLen1);
#endif
if ((ft_plus.pos = (unsigned long*)realloc(ft_plus.pos, mLen1 * sizeof(unsigned long))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
if ((ft_plus.cnt = (int*)realloc(ft_plus.cnt, mLen1 * sizeof(int))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
if (ext_flag) {
if ((ft_plus.ext = (char**)realloc(ft_plus.ext, mLen1 * sizeof(*(ft_minus.ext)))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
}
if (Feature == NULL) {
if ((ft_plus.feature = (char**)realloc(ft_plus.feature, mLen1 * sizeof(*(ft_minus.feature)))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
}
}
if (k >= mLen2 - 1) {
mLen2 *= 2;
#ifdef DEBUG
fprintf(stderr, "reallocating memory for ft_minus (k=%d, size=%d)\n", k, (int)mLen2);
#endif
if ((ft_minus.pos = (unsigned long*)realloc(ft_minus.pos, mLen2 * sizeof(unsigned long))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
if ((ft_minus.cnt = (int*)realloc(ft_minus.cnt, mLen2 * sizeof(int))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
if (ext_flag) {
if ((ft_minus.ext = (char**)realloc(ft_minus.ext, mLen2 * sizeof(*(ft_minus.ext)))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
}
if (Feature == NULL) {
if ((ft_minus.feature = (char**)realloc(ft_minus.feature, mLen2 * sizeof(*(ft_minus.feature)))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
}
}
/* Check Chromosome BEGINNING and Merge tag lists of previous Chrom */
if (strcmp(seq_id, seq_id_prev) != 0) {
/* Get Chromosome size */
ac_len = (int)strlen(seq_id) + 1;
//printf ("Chr ID: SeqID %s, len %d\n", seq_id, ac_len);
csize = hash_table_lookup(size_table, seq_id, (size_t)ac_len);
//printf ("Chr SIZE: csize %s\n", csize);
if (csize != NULL) {
chr_size = (int) atoi(csize);
} else {
chr_size = 0;
}
merge(j, k);
strcpy(seq_id_prev, seq_id);
if (Feature == NULL) {
for (i = 0; i < j; i++) {
if (ft_plus.feature[i] != NULL)
free(ft_plus.feature[i]);
}
for (i = 0; i < k; i++) {
if (ft_minus.feature[i] != NULL)
free(ft_minus.feature[i]);
}
}
if (ext_flag) {
for (i = 0; i < j; i++) {
if (ft_plus.ext[i] != NULL)
free(ft_plus.ext[i]);
}
for (i = 0; i < k; i++) {
if (ft_minus.ext[i] != NULL)
free(ft_minus.ext[i]);
}
}
Len += last_pos;
j = 0;
k = 0;
}
/* Check tag positions at Chromosome END and store END line */
if (strcmp(ft, "END") == 0 && (j > 0 || k > 0)) {
/* Check if last positions in ft_plus array go beyond END position */
while ((j > 0) && (ft_plus.pos[j-1] > (unsigned int)pos)) {
if (Feature != NULL)
fprintf (stderr, "WARNING: TAG: %s\t%s\t%lu\t%c\t%d\t goes beyond chrom bounds (END=%d)\n", ft_plus.seq_id, Feature, ft_plus.pos[j-1], '+', ft_plus.cnt[j-1], pos);
else
fprintf (stderr, "WARNING: TAG: %s\t%s\t%lu\t%c\t%d\t goes beyond chrom bounds (END=%d)\n", ft_plus.seq_id, ft_plus.feature[j-1], ft_plus.pos[j-1], '+', ft_plus.cnt[j-1], pos);
/* skip tag */
j--;
}
/* Check if last positions in ft_minus array go beyond END position */
while (((unsigned int)k > 0) && (ft_minus.pos[k-1] > (unsigned int)pos)) {
if (Feature != NULL)
fprintf (stderr, "WARNING: TAG: %s\t%s\t%lu\t%c\t%d\t goes beyond chrom bounds (Chrom END=%d)\n", ft_minus.seq_id, Feature, ft_minus.pos[k-1], '-', ft_minus.cnt[k-1], pos);
else
fprintf (stderr, "WARNING: TAG: %s\t%s\t%lu\t%c\t%d\t goes beyond chrom bounds (Chrom END=%d)\n", ft_minus.seq_id, ft_minus.feature[k-1], ft_minus.pos[k-1], '-', ft_minus.cnt[k-1], pos);
/* skip tag */
k--;
}
/* Add END Line */
strcpy(end_line.seq_id, seq_id);
strcpy(end_line.feature, "END");
end_line.pos = (unsigned long)pos;
end_line.strand = '0';
end_line.cnt = 1;
end_line_flag = 1;
} /* Chromosome END */
if (!ft_specs) { /* Process all features */
if (strand == '+') {
/* Check Chromosome Boundaries */
if ((pos + Shift <= 0) || (pos + Shift > chr_size)) {
fprintf (stderr, "WARNING: TAG: %s\t%s\t%d\t%c\t%d\t goes beyond chromosome boundaries (pos after TAG Shift=%d, chron size = %d)\n", seq_id, ft, pos, '+', cnt, pos + Shift, chr_size);
continue;
}
strcpy(ft_plus.seq_id, seq_id);
ft_plus.feature[j] = malloc(strlen(ft) + 1);
strcpy(ft_plus.feature[j], ft);
if (ext_flag) {
ft_plus.ext[j] = malloc(strlen(ext) + 1);
strcpy(ft_plus.ext[j], ext);
}
ft_plus.pos[j] = pos + Shift;
if (cnt > Coff)
ft_plus.cnt[j] = Coff;
else
ft_plus.cnt[j] = cnt;
Counts += ft_plus.cnt[j];
j++;
}
if (strand == '-') {
/* Check Chromosome Boundaries */
if ((pos - Shift <= 0) || (pos - Shift > chr_size)) {
fprintf (stderr, "WARNING: TAG: %s\t%s\t%d\t%c\t%d\t goes beyond chromosome boundaries (pos after TAG Shift=%d, chrom size = %d)\n", seq_id, ft, pos, '-', cnt, pos - Shift, chr_size);
continue;
}
strcpy(ft_minus.seq_id, seq_id);
ft_minus.feature[k] = malloc(strlen(ft) + 1);
strcpy(ft_minus.feature[k], ft);
if (ext_flag) {
ft_minus.ext[k] = malloc(strlen(ext) + 1);
strcpy(ft_minus.ext[k], ext);
}
ft_minus.pos[k] = pos - Shift;
if (cnt > Coff)
ft_minus.cnt[k] = Coff;
else
ft_minus.cnt[k] = cnt;
Counts += ft_minus.cnt[k];
k++;
}
} else {
if (strcmp(ft, Feature) == 0 && strand == '+') {
/* Check Chromosome Boundary */
if ((pos + Shift <= 0) || (pos + Shift > chr_size)) {
fprintf (stderr, "WARNING: TAG: %s\t%s\t%d\t%c\t%d\t goes beyond chromosome boundaries (pos after TAG Shift=%d, chron size = %d)\n", seq_id, ft, pos, '+', cnt, pos + Shift, chr_size);
continue;
}
strcpy(ft_plus.seq_id, seq_id);
if (ext_flag) {
ft_plus.ext[j] = malloc(strlen(ext) + 1);
strcpy(ft_plus.ext[j], ext);
}
ft_plus.pos[j] = pos + Shift;
if (cnt > Coff)
ft_plus.cnt[j] = Coff;
else
ft_plus.cnt[j] = cnt;
Counts += ft_plus.cnt[j];
j++;
}
if (strcmp(ft, Feature) == 0 && strand == '-') {
/* Check Chromosome Boundary */
if ((pos - Shift <= 0) || (pos - Shift > chr_size)) {
fprintf (stderr, "WARNING: TAG: %s\t%s\t%d\t%c\t%d\t goes beyond chromosome boundaries (pos after TAG Shift=%d, chrom size = %d)\n", seq_id, ft, pos, '-', cnt, pos - Shift, chr_size);
continue;
}
strcpy(ft_minus.seq_id, seq_id);
if (ext_flag) {
ft_minus.ext[k] = malloc(strlen(ext) + 1);
strcpy(ft_minus.ext[k], ext);
}
ft_minus.pos[k] = pos - Shift;
if (cnt > Coff)
ft_minus.cnt[k] = Coff;
else
ft_minus.cnt[k] = cnt;
Counts += ft_minus.cnt[k];
k++;
}
}
last_pos = pos;
} /* End of While */
free(s);
/* Merge tag lists from last Chromosome */
Len += last_pos;
merge(j, k);
fprintf (stderr, "Total Tag Counts : %lu , Total Sequence Len : %lu\n", Counts, Len);
if (Feature == NULL) {
for (unsigned int i = 0; i < j; i++) {
if (ft_plus.feature[i] != NULL)
free(ft_plus.feature[i]);
}
for (unsigned int i = 0; i < k; i++) {
if (ft_minus.feature[i] != NULL)
free(ft_minus.feature[i]);
}
free(ft_plus.feature);
free(ft_minus.feature);
}
if (ext_flag) {
for (unsigned int i = 0; i < j; i++) {
if (ft_plus.ext[i] != NULL)
free(ft_plus.ext[i]);
}
for (unsigned int i = 0; i < k; i++) {
if (ft_minus.ext[i] != NULL)
free(ft_minus.ext[i]);
}
free(ft_plus.ext);
free(ft_minus.ext);
}
free(ft_plus.pos);
free(ft_plus.cnt);
free(ft_minus.pos);
free(ft_minus.cnt);
if (input != stdin) {
fclose(input);
}
return 0;
}
int
main(int argc, char *argv[])
{
#ifdef DEBUG
mcheck(NULL);
mtrace();
#endif
FILE *input;
while (1) {
int c = getopt(argc, argv, "f:dhi:zs:c:r:");
if (c == -1)
break;
switch (c) {
case 'c':
Coff = atoi(optarg);
break;
case 'd':
options.debug = 1;
break;
case 'f':
Feature = optarg;
break;
case 'h':
options.help = 1;
break;
case 'i':
options.dbPath = optarg;
options.db = 1;
break;
case 'r':
newFeature = optarg;
break;
case 's':
Shift = atoi(optarg);
break;
case 'z':
options.strand = 1;
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
if (optind > argc || options.help == 1 || Shift == 0 || Coff < 0) {
fprintf(stderr, "Usage: %s [options] [-f ] -s [<] \n"
" - version %s\n"
" where options are:\n"
" \t\t -h Show this help text\n"
" \t\t -d Print debug information\n"
" \t\t -i Use to locate the chr_size file\n"
" \t\t [Default=/local/db/genome]\n"
" \t\t -z Set strand to zero\n"
" \t\t -c Count Cut-off (default is %d)\n"
" \t\t -r New feature name (for feature replacement)\n"
"\n\tFeature Centering Tool for ChIP-seq data analysis.\n"
"\tThe program reads a ChIP-seq data file (or from stdin [<]) in SGA format (), and\n"
"\tshifts (by ) ChIP-tag positions corresponding to feature to the estimated\n"
"\tcenter-positions of DNA fragments. If no feature specification is set, the program accepts\n"
"\tall lines of the input SGA. If -r is specified, the feature field is replaced\n"
"\twith the new string. The program checks whether, after shifting, the new genome\n"
"\tcoordinates are still within chromosome boundaries. Consequently, the file chr_size must be read.\n\n",
argv[0], VERSION, Coff);
return 1;
}
if (argc > optind) {
if(!strcmp(argv[optind],"-")) {
input = stdin;
} else {
input = fopen(argv[optind], "r");
if (NULL == input) {
fprintf(stderr, "Unable to open '%s': %s(%d)\n",
argv[optind], strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", argv[optind]);
}
} else {
input = stdin;
}
if (options.debug) {
fprintf(stderr, " Arguments:\n");
fprintf(stderr, " Selected Feature : %s\n", Feature);
fprintf(stderr, " Relative Shift : %d\n\n", Shift);
}
/* Check Feature Specs */
if (Feature == NULL) {
ft_specs = 0; /* Process all features */
} else {
char *s = Feature;
int i = 0;
while (*s != 0 && !isspace(*s++)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature Description too long \"%s\" \n", Feature);
return 1;
}
i++;
}
Feature[i] = '\0';
}
/* Check newFeature Specs */
if (newFeature != NULL) {
char *s = newFeature;
int i = 0;
while (*s != 0 && !isspace(*s++)) {
if (i >= FT_MAX) {
fprintf(stderr, "New Feature Name too long \"%s\" \n", newFeature);
return 1;
}
i++;
}
}
if (options.debug) {
if (!ft_specs) {
fprintf(stderr, "Feature Specs: ALL -> Process all features\n");
} else {
fprintf(stderr, "Feature Specs: Feature name : %s\n", Feature);
}
if (newFeature != NULL) {
fprintf(stderr, "Replace feature name with : %s\n", newFeature);
}
}
if (process_size() == 0) {
if (options.debug)
fprintf(stderr, " HASH Table for chromosome size initialized\n");
} else {
return 1;
}
if (process_sga(input) != 0) {
return 1;
}
return 0;
}
chip-seq/chipcenter.1.gz 0000744 0227442 0026227 00000001600 13046354254 015710 0 ustar ambrosin gr-bucher ؙX chipcenter.1 }UMo8W t)Л I[mTC@S#XTI*Y;Cv~\lxșy~x r&s(ߍz<]tDPC+ eQ7oM"sCezxVZ#+ 5nuSW/<5#T Wʈ ^ + Vu!Fc16_B4NQB榹XAEAlXT;U W_@߱z
byF3yXl2z95-s,J) yŜ%_ [AQsl!P ʂ-rљa݁+QilXة~&@Hzl1eGO[ZRL^Bҫ'4fI,^TISĵA{cl]e 0d x^\)Ҏl.
*/
//#define DEBUG
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#ifdef DEBUG
#include
#endif
#include "version.h"
/*#define BUF_SIZE 4096 */
#define BUF_SIZE 8192
#define LINE_SIZE 1024
#define FT_MAX 64
#define SEQ_ID 32
#define FT_MAX 64
#define SEQ_ID 32
#define POS_MAX 16
#define CNT_MAX 16
#define EXT_MAX 256
typedef struct _options_t {
int help;
int debug;
} options_t;
static options_t options;
typedef struct _feature_t {
char seq_id[SEQ_ID];
char *ft;
char ft_str;
char **name;
char *strand;
int *pos;
int *cnt;
int *npo;
int *nct;
} feature_t, *feature_p_t;
feature_t ref_ft;
int strand_flag = 0;
char *Feature = NULL;
float Dthres = 0;
int Tpen = 0;
int Coff = 1;
unsigned long TotLen = 0;
unsigned long TotCnts = 0;
int TotSeqs = 0;
int NumSegs = 0;
unsigned long TotFragLen = 0;
unsigned long AvFragLen = 0;
unsigned long AvCntsFrag = 0;
unsigned long TotCntsFrag = 0;
void
split_seq(int len, int end, int last_seq)
{
/* Partitioning Algorithm */
/* X(i) partitioning ends in over-representation state
Y(i) partitioning ends in under-representation state
q(i) trace-back codes
Recursion
X(i) = max X(i-1) + cnt(i) - (pos(i)-pos(i-1))*Dthres, (XX)
Y(i-1) + Tpen + cnt(i) - Dthres + (pos(i)-pos(i-1)-1)*Dthres, (YX)
X(i-1) + 2*Tpen + cnt(i) - Dthres + (pos(i)-pos(i-1)-2)*Dthres (ZX)
Y(i) = max X(i-1) + Tpen + (pos(i)-pos(i-1))*Dthres - cnt(i), (XY)
Y(i-1) + (pos(i)-pos(i-1))*Dthres - cnt(i) (YY)
*/
int i, j, k = 1;
size_t mLen1 = BUF_SIZE;
size_t mLen2 = BUF_SIZE;
size_t mLen3 = BUF_SIZE;
float Xmax = 0;
float Ymax = 0;
float XX, YX, ZX, YY, XY;
int *q;
int **Reg;
int *cnt;
int seq_len = 0;
int tot_cnts = 0;
if (( q = (int*)calloc(mLen1, sizeof(int))) == NULL) {
perror("split_seq: malloc");
exit(1);
}
if (( cnt = (int*)calloc(mLen2, sizeof(int))) == NULL) {
perror("split_seq: malloc");
exit(1);
}
if (( Reg = (int**)calloc((size_t)2, sizeof(int*))) == NULL) {
perror("split_seq: malloc");
exit(1);
}
for(i = 0; i < 2; i++) {
Reg[i] = (int*)calloc(mLen3, sizeof(int));
}
if (end == 0) {
ref_ft.pos[len + 1] = ref_ft.pos[len];
ref_ft.name[len + 1] = ref_ft.name[len];
} else
ref_ft.pos[len + 1] = end;
ref_ft.cnt[len + 1] = 0;
q[0] = 0;
/* Fill in trace-back codes q[i] */
/*
0 Xmax = XX ; Ymax = YY
1 Xmax = ZX ; Ymax = YY
2 Xmax = YX ; Ymax = YY
3 Xmax = XX ; Ymax = XY
4 Xmax = ZX ; Ymax = XY
5 Xmax = YX ; Ymax = XY
*/
for (i = 1; i <= len + 1; i++) {
XX = Xmax + ref_ft.cnt[i] - (ref_ft.pos[i] - ref_ft.pos[i - 1])*Dthres;
YX = Ymax + Tpen + ref_ft.cnt[i] - Dthres + (ref_ft.pos[i] - ref_ft.pos[i - 1] - 1)*Dthres;
ZX = Xmax + 2*Tpen + ref_ft.cnt[i] - Dthres + (ref_ft.pos[i] - ref_ft.pos[i - 1] - 1)*Dthres;
YY = Ymax - ref_ft.cnt[i] + (ref_ft.pos[i] - ref_ft.pos[i - 1])*Dthres;
XY = Xmax + Tpen - ref_ft.cnt[i] + (ref_ft.pos[i] - ref_ft.pos[i - 1])*Dthres;
if ((unsigned int)i >= mLen1) {
mLen1 *= 2;
if (( q = (int *)realloc(q, mLen1 * sizeof(int))) == NULL) {
perror("split_seq: realloc");
exit(1);
}
}
q[i] = 0;
if ((YX < XX) && (ZX < XX)) {
Xmax = XX;
} else if (YX < ZX) {
Xmax = ZX;
q[i] += 1;
} else {
Xmax = YX;
q[i] += 2;
}
if (XY < YY) {
Ymax = YY;
} else {
Ymax = XY;
q[i] += 3;
}
}
/* Trace-back */
k = 1;
if (Xmax > Ymax) {
Reg[0][k] = 0;
Reg[1][k] = ref_ft.pos[len + 1];
} else {
Reg[0][k] = 0;
Reg[1][k] = 0;
}
for (i = len + 1; i > 0; i--) {
if (Reg[1][k] == 0) {
if (q[i] > 2)
Reg[1][k] = ref_ft.pos[i - 1]; /* Enter a signal rich region
(we are in a poor region) */
} else {
if (q[i] > 2)
q[i] -= 3;
if ((unsigned int)k >= mLen2) {
mLen2 *= 2;
if ((cnt = (int*)realloc(cnt , mLen2 * sizeof(int))) == NULL) {
perror("split_seq: realloc");
exit(1);
}
memset((void *)&cnt[k], 0, mLen2 * sizeof(int) / 2);
}
if (q[i] == 1) { /* Enter signal-rich region for the first time.
We first close the previous one */
Reg[0][k] = ref_ft.pos[i];
cnt[k] += ref_ft.cnt[i];
k++;
if ((unsigned int)k >= mLen3) {
mLen3 *= 2;
for(j = 0; j < 2; j++) {
if ((Reg[j] = (int*)realloc(Reg[j], mLen3 * sizeof(int))) == NULL) {
perror("split_seq: realloc");
exit(1);
}
}
}
Reg[0][k] = 0;
Reg[1][k] = ref_ft.pos[i - 1];
} else if (q[i] == 2) { /* We are at the end of a signal-rich region
we are closing it, without creating a new one
(we're going into a signal-poor region) */
Reg[0][k] = ref_ft.pos[i];
cnt[k] += ref_ft.cnt[i];
k++;
if ((unsigned int)k >= mLen3) {
mLen3 *= 2;
for(j = 0; j < 2; j++) {
if ((Reg[j] = (int*)realloc(Reg[j], mLen3 * sizeof(int))) == NULL) {
perror("split_seq: realloc");
exit(1);
}
}
}
Reg[0][k] = 0;
Reg[1][k] = 0;
} else { /* Extend signal-rich region */
cnt[k] += ref_ft.cnt[i];
}
}
#ifdef DEBUG
fprintf (stderr, "%d, %d, %d, %d, %d\n", i, k, Reg[0][k], Reg[1][k], cnt[k]);
#endif
}
/* Print out signal enriched regions */
if (Reg[1][k] == 0) k--;
if (Reg[0][k] == 0) Reg[0][k] = 1;
#ifdef DEBUG
fprintf(stderr, "Printout number of Regions: k= %d\n", k);
#endif
for (i = k; i >= 1; i--) {
/* Print out (SGA format) */
/* printf("%s\t%s\t%d\t%c\t%d\n", ref_ft.seq_id, ref_ft.name[i], Reg[0][i], '+', cnt[i]);
printf("%s\t%s\t%d\t%c\t%d\n", ref_ft.seq_id, ref_ft.name[i], Reg[1][i], '-', cnt[i]);
*/
printf("%s\t%s\t%d\t%c\t%d\n", ref_ft.seq_id, ref_ft.name[i], Reg[0][i], '+', cnt[i]);
printf("%s\t%s\t%d\t%c\t%d\n", ref_ft.seq_id, ref_ft.name[i], Reg[1][i], '-', cnt[i]);
seq_len += Reg[1][i] - Reg[0][i];
tot_cnts += cnt[i];
}
if (end != 0)
printf("%s\t%s\t%d\t%c\t%d\n", ref_ft.seq_id, ref_ft.name[len + 1], ref_ft.pos[len + 1], '0', 1);
if (k && (len != 0)) {
/*
fprintf(stderr,"# %s : Number of segments %d, Tot. length %d, Ave. length %d, Tot. counts %d\n", ref_ft.seq_id, k, seq_len, seq_len/k, tot_cnts);
*/
NumSegs += k;
TotFragLen += seq_len;
AvFragLen += seq_len/k;
TotCntsFrag += tot_cnts;
AvCntsFrag += tot_cnts/k;
}
if (last_seq) {
fprintf(stderr,"# Num of Sequences : %d , Total Sequence Length : %lu (bp) , Total Counts : %lu , Total Num of Fragments : %d\n\n", TotSeqs, TotLen, TotCnts, NumSegs);
fprintf(stderr,"# Total Fragment Length : %lu , Average Fragment Length : %lu (bp) , Percentage of Total Length : %2.5f\n\n", TotFragLen, AvFragLen/TotSeqs, (float)TotFragLen/(float)TotLen);
fprintf(stderr,"# Percentage of Total Counts : %2.5f , Average Num of Counts per Fragment : %lu , Num of Counts per bp : %2.5f \n", (float)TotCntsFrag/(float)TotCnts, AvCntsFrag/TotSeqs, (float)TotCntsFrag/(float)TotFragLen);
}
free(q);
free(cnt);
for(j = 0; j < 2; j++) {
if (Reg[j] != NULL)
free(Reg[j]);
}
free(Reg);
}
int
process_sga(FILE *input, char *iFile)
{
char seq_id_prev[SEQ_ID] = "";
int pos, cnt, end = 0, last_pos = 0;
size_t mLen = BUF_SIZE;
char *s, *res, *buf;
size_t bLen = LINE_SIZE;
unsigned int k = 0;
unsigned int i = 0;
int end_flag = 0;
if (options.debug && input != stdin) {
char sort_cmd[1024] = "sort -s -c -k1,1 -k3,3n ";
fprintf(stderr, "Check whether file %s is properly sorted\n", iFile);
if (strcat(sort_cmd, iFile) == NULL) {
fprintf(stderr, "strcat failed\n");
return 1;
}
if (strcat(sort_cmd, " 2>/tmp/sortcheck.out") == NULL) {
fprintf(stderr, "strcat failed\n");
return 1;
}
fprintf(stderr, "executing : %s\n", sort_cmd);
int sys_code = system(sort_cmd);
/*fprintf(stderr,"system command sort : return code %d\n", sys_code);*/
if (sys_code != 0) {
fprintf(stderr, "system command failed\n");
return 1;
}
struct stat file_status;
if(stat("/tmp/sortcheck.out", &file_status) != 0){
fprintf(stderr, "could not stat\n");
return 1;
}
if (file_status.st_size != 0) {
fprintf(stderr, "SGA file %s is not properly sorted\n", iFile);
return 1;
} else {
system("/bin/rm /tmp/sortcheck.out");
}
}
if ((ref_ft.pos = (int*)calloc(mLen, sizeof(int))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if ((ref_ft.strand = (char*)calloc(mLen, sizeof(char))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if ((ref_ft.cnt = (int*)calloc(mLen, sizeof(int))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if ((ref_ft.name = (char**)calloc(mLen, sizeof(*(ref_ft.name)))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if ((s = malloc(bLen * sizeof(char))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
#ifdef DEBUG
int c = 1;
#endif
/*
while (fscanf(f,"%s %s %d %c %d", seq_id, ft, &pos, &strand, &cnt) != EOF) {
*/
while ((res = fgets(s, (int) bLen, input)) != NULL) {
size_t cLen = strlen(s);
char seq_id[SEQ_ID] = "";
char ft[FT_MAX] = "";
char position[POS_MAX] = "";
char count[CNT_MAX] = "";
char strand = '\0';
char ext[EXT_MAX];
unsigned int j = 0;
memset(ext, 0, (size_t)EXT_MAX);
while (cLen + 1 == bLen && s[cLen - 1] != '\n') {
bLen *= 2;
if ((s = realloc(s, bLen)) == NULL) {
perror("process_file: realloc");
exit(1);
}
res = fgets(s + cLen, (int) (bLen - cLen), input);
cLen = strlen(s);
}
if (s[cLen - 1] == '\n')
s[cLen - 1] = 0;
buf = s;
/* Get SGA fields */
/* SEQ ID */
while (*buf != 0 && !isspace(*buf)) {
if (j >= SEQ_ID) {
fprintf(stderr, "Seq ID is too long \"%s\" \n", buf);
exit(1);
}
seq_id[j++] = *buf++;
}
while (isspace(*buf))
buf++;
/* FEATURE */
j = 0;
while (*buf != 0 && !isspace(*buf)) {
if (j >= FT_MAX) {
fprintf(stderr, "Feature is too long \"%s\" \n", buf);
exit(1);
}
ft[j++] = *buf++;
}
while (isspace(*buf))
buf++;
/* Position */
j = 0;
while (isdigit(*buf)) {
if (j >= POS_MAX) {
fprintf(stderr, "Position is too large \"%s\" \n", buf);
exit(1);
}
position[j++] = *buf++;
}
position[j] = 0;
pos = atoi(position);
while (isspace(*buf))
buf++;
/* Strand */
strand = *buf++;
while (isspace(*buf))
buf++;
/* Counts */
j = 0;
while (isdigit(*buf)) {
if (j >= CNT_MAX) {
fprintf(stderr, "Count is too large \"%s\" \n", buf);
exit(1);
}
count[j++] = *buf++;
}
count[j] = 0;
cnt = atoi(count);
while (isspace(*buf))
buf++;
/* SGA Extension */
j = 0;
while (*buf != 0) {
if (j >= EXT_MAX) {
fprintf(stderr, "Extension is too long \"%s\" \n", buf);
exit(1);
}
ext[j++] = *buf++;
}
#ifdef DEBUG
printf(" [%d] seq ID: %s Feat: %s (%c) Pos: %d Cnts: %d Ext: %s\n", c++, seq_id, ft, strand, pos, cnt, ext);
#endif
if (k >= mLen - 1) {
mLen *= 2;
#ifdef DEBUG
fprintf(stderr, "reallocating memory for ref_ft.pos ref_ft.strand ref_ft.cnt (k=%d, size=%d)\n", c, mLen);
#endif
if ((ref_ft.pos = (int *)realloc(ref_ft.pos, mLen * sizeof(int))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
if ((ref_ft.cnt = (int *)realloc(ref_ft.cnt, mLen * sizeof(int))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
if ((ref_ft.strand = (char *)realloc(ref_ft.strand, mLen * sizeof(char))) == NULL) {
perror("process_sga: realloc");
exit(1);
}
if ((ref_ft.name = (char**)realloc(ref_ft.name, mLen * sizeof(*(ref_ft.name)))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
}
/* Check Chromosome BEGINNING, split sequences in regions and printout results*/
if (strcmp(seq_id, seq_id_prev) != 0) {
split_seq((int)k, end, 0);
for (i = 1; i <= k; i++) {
if (ref_ft.name[i] != NULL)
free(ref_ft.name[i]);
}
if (end_flag) {
if (ref_ft.name[k + 1] != NULL)
free(ref_ft.name[k + 1]);
}
k = 0;
end = 0;
end_flag = 0;
TotLen += last_pos;
TotSeqs ++;
ref_ft.pos[0] = 1;
ref_ft.cnt[0] = 0;
strcpy(seq_id_prev, seq_id);
strcpy(ref_ft.seq_id, seq_id);
}
if (ref_ft.ft == NULL) {
k++;
ref_ft.name[k] = malloc(strlen(ft) + 1);
strcpy(ref_ft.name[k], ft);
ref_ft.strand[k] = strand;
ref_ft.pos[k] = pos;
if (cnt > Coff)
ref_ft.cnt[k] = Coff;
else
ref_ft.cnt[k] = cnt;
TotCnts += ref_ft.cnt[k];
} else if (ref_ft.ft_str == '\0') {
if (strcmp(ft, ref_ft.ft) == 0) {
k++;
ref_ft.name[k] = malloc(strlen(ft) + 1);
strcpy(ref_ft.name[k], ft);
ref_ft.strand[k] = strand;
ref_ft.pos[k] = pos;
if (cnt > Coff)
ref_ft.cnt[k] = Coff;
else
ref_ft.cnt[k] = cnt;
TotCnts += ref_ft.cnt[k];
}
} else if (strand_flag == 1) {
if (strand == ref_ft.ft_str) {
k++;
ref_ft.name[k] = malloc(strlen(ft) + 1);
strcpy(ref_ft.name[k], ft);
ref_ft.strand[k] = strand;
ref_ft.pos[k] = pos;
if (cnt > Coff)
ref_ft.cnt[k] = Coff;
else
ref_ft.cnt[k] = cnt;
TotCnts += ref_ft.cnt[k];
}
} else if (strcmp(ft, ref_ft.ft) == 0 && strand == ref_ft.ft_str) {
k++;
ref_ft.name[k] = malloc(strlen(ft) + 1);
strcpy(ref_ft.name[k], ft);
ref_ft.strand[k] = strand;
ref_ft.pos[k] = pos;
if (cnt > Coff)
ref_ft.cnt[k] = Coff;
else
ref_ft.cnt[k] = cnt;
TotCnts += ref_ft.cnt[k];
}
if (strcmp(ft, "END") == 0 ) {
ref_ft.name[k + 1] = malloc(strlen(ft) + 1);
strcpy(ref_ft.name[k + 1], ft);
end = pos;
end_flag = 1;
}
last_pos = pos;
#ifdef DEBUG
fprintf(stderr,"k = [%d] pos = %d cnts = %d\n", k, ref_ft.pos[k], ref_ft.cnt[k]);
#endif
} /* End of While */
free(s);
/* Partition last chromosome */
TotLen += last_pos;
split_seq((int)k, end, 1);
for (i = 1; i <= k; i++) {
if (ref_ft.name[i] != NULL)
free(ref_ft.name[i]);
}
if (end_flag) {
if (ref_ft.name[k + 1] != NULL)
free(ref_ft.name[k + 1]);
}
free(ref_ft.name);
free(ref_ft.pos);
free(ref_ft.cnt);
free(ref_ft.strand);
if (input != stdin) {
fclose(input);
}
return 0;
}
int
main(int argc, char *argv[])
{
#ifdef DEBUG
mcheck(NULL);
mtrace();
#endif
FILE *input;
while (1) {
int c = getopt(argc, argv, "f:dhs:p:c:");
if (c == -1)
break;
switch (c) {
case 'f':
Feature = optarg;
break;
case 'd':
options.debug = 1;
break;
case 'h':
options.help = 1;
break;
case 's':
Dthres = atof(optarg);
break;
case 'p':
Tpen = atoi(optarg);
break;
case 'c':
Coff = atoi(optarg);
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
if (optind > argc || options.help == 1 || Dthres == 0 || Tpen == 0 || Coff < 0) {
fprintf(stderr, "Usage: %s [options] [-f ] -s -p [<] \n"
" - version %s\n"
" where options are:\n"
" \t\t -h Show this help text\n"
" \t\t -d Print debug information and check SGA file\n"
" \t\t -c Count Cut-off (default is %d). It must be >= 0.\n"
"\n\tPartitioning Tool.\n"
"\n\tThe program reads a ChIP-seq data file (or from stdin [<]) in SGA format (),\n"
"\tand heuristically partitions the data corresponding to a specific feature\n"
"\t, if the latter is given.\n"
"\tThe parameter is a name that corresponds to the second field of the SGA file.\n"
"\tIt might optionally include the strand specification (+|-).\n"
"\tIf no feature is given then all input tags are processed.\n"
"\tThe SGA input file MUST BE sorted by sequence name (or chromosome id), position,\n"
"\tand strand.\n"
"\tOne should check the input SGA file with the following command:\n"
"\tsort -s -c -k1,1 -k3,3n -k4,4 .\n\n"
"\tIn debug mode (-d), the program performs the sorting order check.\n\n"
"\tInput parameters are the density threshold (),\n"
"\tthe transition penalty (), which are used to\n"
"\tsplit the data in regions of high density count.\n"
"\tA value can be optionally specified as a cut-off for the feature counts.\n"
"\tThe output is an SGA-formatted list containing the regions of interest.\n"
"\tThe program also generates (to stderr) a statistical report with the\n"
"\tfollowing information:\n"
"\t - Total number of processed sequences, total DNA length, and\n"
"\t total number of fragments;\n"
"\t - Total length of fragments, average fragment length, and\n"
"\t percentage of total DNA length;\n"
"\t - Percentage of total counts, average number of counts, and\n"
"\t number of count per bp (count density).\n\n",
argv[0], VERSION, Coff);
return 1;
}
if (argc > optind) {
if(!strcmp(argv[optind],"-")) {
input = stdin;
} else {
input = fopen(argv[optind], "r");
if (NULL == input) {
fprintf(stderr, "Unable to open '%s': %s(%d)\n",
argv[optind], strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", argv[optind]);
}
} else {
input = stdin;
}
if (options.debug) {
fprintf(stderr, " Arguments:\n");
fprintf(stderr, " Selected Feature : %s\n", Feature);
fprintf(stderr, " Density Threshold : %f\n\n", Dthres);
fprintf(stderr, " Transition Penalty : %d\n\n", Tpen);
fprintf(stderr, " Count Cut-off : %d\n\n", Coff);
}
/* Process Feature Specs */
if (Feature == NULL) {
ref_ft.ft = NULL; /* Process all features */
ref_ft.ft_str = '\0';
} else {
ref_ft.ft = malloc(FT_MAX * sizeof(char));
char *s = Feature;
int i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature Description too long \"%s\" \n", Feature);
return 1;
}
ref_ft.ft[i++] = *s++;
}
ref_ft.ft[i] = '\0';
ref_ft.ft_str = '\0';
while (isspace(*s++))
ref_ft.ft_str = *s;
}
if (options.debug) {
if (ref_ft.ft_str == '\0' && ref_ft.ft == NULL) {
fprintf(stderr, "Feature Specs: ALL -> Process all features\n");
} else if (ref_ft.ft_str == '\0') {
fprintf(stderr, "Feature Specs: Feature name : %s\n", ref_ft.ft);
} else {
fprintf(stderr, "Feature Specs: Feature name/str : %s %c\n", ref_ft.ft, ref_ft.ft_str);
}
}
if ( ref_ft.ft != NULL && (strcmp(ref_ft.ft, "+") == 0 || strcmp(ref_ft.ft, "-") == 0)) {
strcpy(&ref_ft.ft_str, ref_ft.ft);
strand_flag = 1;
if (options.debug)
fprintf(stderr, "Feature Specs: Process all features on str : %c\n", ref_ft.ft_str);
}
if (process_sga(input, argv[optind++]) != 0) {
return 1;
}
free(ref_ft.ft);
return 0;
}
chip-seq/tools/ 0000744 0227442 0026227 00000000000 13433535237 014225 5 ustar ambrosin gr-bucher chip-seq/tools/sga2gff.pl 0000744 0227442 0026227 00000024467 11553014432 016107 0 ustar ambrosin gr-bucher #!/usr/bin/perl
# converts sga format to gff format
# usage: ./sga2gff [-l taglen -x -e] file.sga
use strict;
use Getopt::Long;
use Storable qw (retrieve nstore); # package to store persistently variables in files [http://search.cpan.org/author/AMS/Storable-2.07/Storable.pm]
#my %opts;
#getopt('lf:', \%opts);
my %opt;
my @options = ("help", "h", "taglen=i", "l=i", "x", "ext", "e", "db=s");
my $file = "";
my $taglen = 0;
my $expand = 0;
my $ext_flag = 0;
#my $DB = "/home/local/db/genome/";
my $DB = "/db/genome/";
if( ! GetOptions( \%opt, @options ) ) { &Usage(); }
&Usage() if defined($opt{'help'}) || defined($opt{'h'});
&Usage() if $#ARGV < 0;
#define options
if ($opt{'db'} ne '') {
$DB = $opt{'db'};
}
open FH, $DB."chro_idx.nstorage" or die "Wrong Chrom Id Storable file $DB.\"chro_idx.nstorage\": $!";
# hash defining chromosome from SV of chromosomes in current genome assemblies
my $chr2SV = retrieve($DB."chro_idx.nstorage");
if ($opt{'l'} ne '') {
$taglen = $opt{'l'};
}
if ($opt{'taglen'} ne '') {
$taglen = $opt{'taglen'};
}
if ($opt{'x'} ne '') {
$expand = 1;
}
if ($opt{'e'} ne '') {
$ext_flag = 1;
}
if ($opt{'ext'} ne '') {
$ext_flag = 1;
}
$file = $ARGV[0];
#print "SGA file : $file\n";
#print "Options: taglen : $taglen, Expand : $expand\n";
# open the SGA file
open (my $SGA, "$file") || die "can't open $file : $!";
my $start;
my $end;
my $source = "ChIPSeq";
my $firstline = <$SGA>;
my @f = split(/\t/,$firstline);
chomp $f[0];
chomp $f[4];
if ($ext_flag) {
chomp $f[5];
if (not defined($f[5])) {
print STDERR "The extension option is incompatible with the format of your SGA file : it must have the 'description' field defined!/n";
exit(1);
}
}
if ($f[0] =~ /^chr/) {
print "##gff-version 3\n";
if ($f[3] eq '0') {
$f[3] = '.';
$start=$f[2];
$end=$start;
}
if ($f[3] eq '+') {
$start=$f[2];
$end=$start + $taglen;
} elsif($f[3] eq '-') {
$start=$f[2] - $taglen;
$end=$f[2];
}
if ($ext_flag) {
if ($expand) {
for (my $i = $f[4]; $i > 0; $i--) {
print "$f[0]\t$f[1]\t$f[5]\t$start\t$end\t.\t$f[3]\t.\t1\n";
}
} else {
print "$f[0]\t$f[1]\t$f[5]\t$start\t$end\t$f[4]\t$f[3]\t.\t1\n";
}
print_gff_1_ext($SGA);
} else {
if ($expand) {
for (my $i = $f[4]; $i > 0; $i--) {
print "$f[0]\t$source\t$f[1]\t$start\t$end\t.\t$f[3]\t.\t1\n";
}
} else {
print "$f[0]\t$source\t$f[1]\t$start\t$end\t$f[4]\t$f[3]\t.\t1\n";
}
print_gff_1($SGA);
}
} elsif ($f[0] =~ /N[CT]_\S+\.\d+/ && exists($chr2SV->{$f[0]})) {
print "##gff-version 3\n";
if ($f[3] eq '0') {
$f[3] = '.';
$start=$f[2];
$end=$start;
}
if ($f[3] eq '+') {
$start=$f[2];
$end=$start + $taglen;
} elsif($f[3] eq '-') {
$start=$f[2] - $taglen;
$end=$f[2];
}
if ($ext_flag) {
if ($expand) {
for (my $i = $f[4]; $i > 0; $i--) {
print $chr2SV->{$f[0]},"\t$f[1]\t$f[5]\t$start\t$end\t.\t$f[3]\t.\t1\n";
}
} else {
print $chr2SV->{$f[0]},"\t$f[1]\t$f[5]\t$start\t$end\t$f[4]\t$f[3]\t.\t1\n";
}
print_gff_2_ext($SGA);
} else {
if ($expand) {
for (my $i = $f[4]; $i > 0; $i--) {
print $chr2SV->{$f[0]},"\t$source\t$f[1]\t$start\t$end\t.\t$f[3]\t.\t1\n";
}
} else {
print $chr2SV->{$f[0]},"\t$source\t$f[1]\t$start\t$end\t$f[4]\t$f[3]\t.\t1\n";
}
print_gff_2($SGA);
}
} else {
print STDERR "Unrecognized sequence version $f[0] : please, check the chromosome identifier!\n";
exit(1);
}
close ($SGA);
sub print_gff_1 {
my ($fh) = @_;
my $count = 1;
if ($expand) {
while(<$fh>){
my $lin=$_;
chomp $lin;
my @ar=split(/\t/,$lin);
$count++;
if ($ar[3] eq '0') {
$ar[3] = '.';
$start=$ar[2];
$end=$start;
}
if ($ar[3] eq '+') {
$start=$ar[2];
$end=$start + $taglen;
} elsif($ar[3] eq '-') {
$start=$ar[2] - $taglen;
$end=$ar[2];
}
for (my $i = $ar[4]; $i > 0; $i--) {
print "$ar[0]\t$source\t$ar[1]\t$start\t$end\t.\t$ar[3]\t.\t$count\n";
}
}
} else {
while(<$fh>){
my $lin=$_;
chomp $lin;
my @ar=split(/\t/,$lin);
# if (exists($chr2SV->{$species}->{$ar[0]})){
$count++;
if ($ar[3] eq '0') {
$ar[3] = '.';
$start=$ar[2];
$end=$start;
}
if ($ar[3] eq '+') {
$start=$ar[2];
$end=$start + $taglen;
} elsif($ar[3] eq '-') {
$start=$ar[2] - $taglen;
$end=$ar[2];
}
print "$ar[0]\t$source\t$ar[1]\t$start\t$end\t$ar[4]\t$ar[3]\t.\t$count\n";
# }
# else {
# my $line = $count + 1;
# print STDERR "line: $line - Sequence version $ar[0] not in current genome assembly!\n";
# }
}
}
}
sub print_gff_1_ext {
my ($fh) = @_;
my $count = 1;
if ($expand) {
while(<$fh>){
my $lin=$_;
chomp $lin;
my @ar=split(/\t/,$lin);
$count++;
if ($ar[3] eq '0') {
$ar[3] = '.';
$start=$ar[2];
$end=$start;
}
if ($ar[3] eq '+') {
$start=$ar[2];
$end=$start + $taglen;
} elsif($ar[3] eq '-') {
$start=$ar[2] - $taglen;
$end=$ar[2];
}
for (my $i = $ar[4]; $i > 0; $i--) {
print "$ar[0]\t$ar[1]\t$ar[5]\t$start\t$end\t.\t$ar[3]\t.\t$count\n";
}
}
} else {
while(<$fh>){
my $lin=$_;
chomp $lin;
my @ar=split(/\t/,$lin);
# if (exists($chr2SV->{$species}->{$ar[0]})){
$count++;
if ($ar[3] eq '0') {
$ar[3] = '.';
$start=$ar[2];
$end=$start;
}
if ($ar[3] eq '+') {
$start=$ar[2];
$end=$start + $taglen;
} elsif($ar[3] eq '-') {
$start=$ar[2] - $taglen;
$end=$ar[2];
}
print "$ar[0]\t$ar[1]\t$ar[5]\t$start\t$end\t$ar[4]\t$ar[3]\t.\t$count\n";
# }
# else {
# my $line = $count + 1;
# print STDERR "line: $line - Sequence version $ar[0] not in current genome assembly!\n";
# }
}
}
}
sub print_gff_2 {
my ($fh) = @_;
my $count = 1;
if ($expand) {
while(<$fh>){
my $lin=$_;
chomp $lin;
my @ar=split(/\t/,$lin);
$count++;
if ($ar[3] eq '0') {
$ar[3] = '.';
$start=$ar[2];
$end=$start;
}
if ($ar[3] eq '+') {
$start=$ar[2];
$end=$start + $taglen;
} elsif($ar[3] eq '-') {
$start=$ar[2] - $taglen;
$end=$ar[2];
}
for (my $i = $ar[4]; $i > 0; $i--) {
print $chr2SV->{$ar[0]},"\t$source\t$ar[1]\t$start\t$end\t.\t$ar[3]\t.\t$count\n";
}
}
} else {
while(<$fh>){
my $lin=$_;
chomp $lin;
my @ar=split(/\t/,$lin);
# if (exists($chr2SV->{$ar[0]})){
$count++;
if ($ar[3] eq '0') {
$ar[3] = '.';
$start=$ar[2];
$end=$start;
}
if ($ar[3] eq '+') {
$start=$ar[2];
$end=$start + $taglen;
} elsif($ar[3] eq '-') {
$start=$ar[2] - $taglen;
$end=$ar[2];
}
print $chr2SV->{$ar[0]},"\t$source\t$ar[1]\t$start\t$end\t$ar[4]\t$ar[3]\t.\t$count\n";
# }
# else {
# my $line = $count + 1;
# print STDERR "line: $line - Sequence version $ar[0] not in current genome assembly!\n";
# }
}
}
}
sub print_gff_2_ext {
my ($fh) = @_;
my $count = 1;
if ($expand) {
while(<$fh>){
my $lin=$_;
chomp $lin;
my @ar=split(/\t/,$lin);
$count++;
if ($ar[3] eq '0') {
$ar[3] = '.';
$start=$ar[2];
$end=$start;
}
if ($ar[3] eq '+') {
$start=$ar[2];
$end=$start + $taglen;
} elsif($ar[3] eq '-') {
$start=$ar[2] - $taglen;
$end=$ar[2];
}
for (my $i = $ar[4]; $i > 0; $i--) {
print $chr2SV->{$ar[0]},"\t$ar[1]\t$ar[5]\t$start\t$end\t.\t$ar[3]\t.\t$count\n";
}
}
} else {
while(<$fh>){
my $lin=$_;
chomp $lin;
my @ar=split(/\t/,$lin);
# if (exists($chr2SV->{$ar[0]})){
$count++;
if ($ar[3] eq '0') {
$ar[3] = '.';
$start=$ar[2];
$end=$start;
}
if ($ar[3] eq '+') {
$start=$ar[2];
$end=$start + $taglen;
} elsif($ar[3] eq '-') {
$start=$ar[2] - $taglen;
$end=$ar[2];
}
print $chr2SV->{$ar[0]},"\t$ar[1]\t$ar[5]\t$start\t$end\t$ar[4]\t$ar[3]\t.\t$count\n";
# }
# else {
# my $line = $count + 1;
# print STDERR "line: $line - Sequence version $ar[0] not in current genome assembly!\n";
# }
}
}
}
sub Usage {
print STDERR <<"_USAGE_";
sga2gff.pl [options]
where options are:
-h|--help Show this stuff
--db Use to locate Chrom Id Storable File 'chro_idx.nstorage'
-l|--taglen Set Read length
-x Expand SGA lines into multiple GFF lines
-e|--ext Use SGA 6th field to set GFF feature field
and store SGA feature into GFF source field
_USAGE_
exit(1);
}
1;
chip-seq/tools/gff2sga.pl 0000744 0227442 0026227 00000046017 12276126030 016103 0 ustar ambrosin gr-bucher #!/usr/bin/perl
# converts gff format to sga format
# usage: ./gff2sga.pl [<-a feature> <-s species> <-c centered> <-u unoriented> <-x extended SGA>]
use strict;
use Getopt::Long;
use Storable qw (retrieve nstore); # package to store persistently variables in files [http://search.cpan.org/author/AMS/Storable-2.07/Storable.pm]
use Math::Round;
#my %opts;
#getopt('asf:', \%opts); # -a, -s, & -f take arg. Values in %opts, Hash keys will be the switch names
my %opt;
my @options = ( "help", "h", "species=s", "s=s", "feature=s", "f=s", "c", "u", "x", "db=s");
my $file = "";
my $species = "";
my $feature = "";
my $centered = 0;
my $unoriented = 0;
my $extended = 0;
my $ext_sc = 0;
my $score = 0;
#my $DB = "/home/local/db/genome/";
my $DB = "/db/genome/";
if( ! GetOptions( \%opt, @options ) ) { &Usage(); }
&Usage() if defined($opt{'help'}) || defined($opt{'h'});
&Usage() if $#ARGV < 0;
if ($opt{'db'} ne '') {
$DB = $opt{'db'};
}
open FH, $DB."chro_idx.nstorage" or die "Wrong Chrom Id Storable file $DB.\"chro_idx.nstorage\": $!";
my $chr2SV = retrieve($DB."chro_idx.nstorage");
if ($opt{'f'} ne '') {
$feature = $opt{'f'};
}
if ($opt{'feature'} ne '') {
$feature = $opt{'feature'};
}
if ($opt{'s'} ne '') {
$species = $opt{'s'};
}
if ($opt{'species'} ne '') {
$species = $opt{'species'};
}
if ($opt{'c'} ne '') {
$centered = 1;
}
if ($opt{'u'} ne '') {
$unoriented = 1;
}
if ($opt{'x'} ne '') {
$extended = 1;
}
$file = $ARGV[0];
#print "GFF file : $file\n";
#print "Options: feature : $feature, Species $species, Centered: $centered, Unoriented : $unoriented\n";
my $wrong_seqs = 0;
# open the GFF file
open (my $GFF3, "$file") || die "can't open $file : $!";
if ($centered) {
if ($unoriented) {
if ($extended) {
print_peak_sga_ext($GFF3);
} else {
print_peak_sga($GFF3);
}
} else {
if ($extended) {
print_peak_sga_oriented_ext($GFF3);
} else {
print_peak_sga_oriented($GFF3);
}
}
} else {
if ($extended) {
print_sga_ext($GFF3);
} else {
print_sga($GFF3);
}
}
close ($GFF3);
sub print_sga {
my ($fh) = @_;
if ($species ne '') {
while(<$fh>){
# chr2 NimbleScan 1859802:RajiIPH3/SJOIPH3:BLOCK1 132843487 132843531 -0.11 + . seq_id=18S_CHR2:132843487-132849513;probe_id=CHR0200P132843487;count=1
chomp;
### skip comments
next if (/^\#/);
### skip blank lines
next if (/^\s*$/);
###################
## syntax checks ##
###################
my @cols = split(/\t/);
### we should have at least 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
#$wrong_seqs++;
next;
}
# $cols[5]=1;
if (($cols[5] != int($cols[5])) || ($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
unless (exists($chr2SV->{$species}->{$cols[0]}) || $cols[0] =~ /N[CT]_\S+\.\d+/){
print STDERR "Chromosome $cols[0] without sequence accession, line $.\n";
next;
}
my $id = "";
if ($cols[0] =~ /N[CT]_\S+\.\d+/) {
$id = $cols[0];
} else {
$id = $chr2SV->{$species}->{$cols[0]};
}
if ($feature ne '') {
$cols[2] = $feature;
}
if ($cols[6] eq '+'){
if ($ext_sc) {
print $id,"\t$cols[2]\t$cols[3]\t$cols[6]\t$cols[5]\t$score\n";
} else {
print $id,"\t$cols[2]\t$cols[3]\t$cols[6]\t$cols[5]\n";
}
} elsif ($cols[6] eq '-'){
if ($ext_sc) {
print $id,"\t$cols[2]\t$cols[4]\t$cols[6]\t$cols[5]\t$score\n";
} else {
print $id,"\t$cols[2]\t$cols[4]\t$cols[6]\t$cols[5]\n";
}
} elsif ($cols[6] eq '.' || $cols[6] eq '?'){
if ($ext_sc) {
print $id,"\t$cols[2]\t$cols[4]\t0\t1\t$score\n";
} else {
print $id,"\t$cols[2]\t$cols[4]\t0\t1\n";
}
}
undef @cols;
}
} else { #if (species) not defined
while(<$fh>){
# chr2 NimbleScan 1859802:RajiIPH3/SJOIPH3:BLOCK1 132843487 132843531 -0.11 + . seq_id=18S_CHR2:132843487-132849513;probe_id=CHR0200P132843487;count=1
chomp;
### skip comments
next if (/^\#/);
### skip blank lines
next if (/^\s*$/);
###################
## syntax checks ##
###################
my @cols = split(/\t/);
### we should have 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
next;
}
if (($cols[5] != int($cols[5])) || ($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
if ($feature ne '') {
$cols[2] = $feature;
}
if ($cols[6] eq '+'){
if ($ext_sc) {
print $cols[0],"\t$cols[2]\t$cols[3]\t$cols[6]\t$cols[5]\t$score\n";
} else {
print $cols[0],"\t$cols[2]\t$cols[3]\t$cols[6]\t$cols[5]\n";
}
} elsif ($cols[6] eq '-'){
if ($ext_sc) {
print $cols[0],"\t$cols[2]\t$cols[4]\t$cols[6]\t$cols[5]\t$score\n";
} else {
print $cols[0],"\t$cols[2]\t$cols[4]\t$cols[6]\t$cols[5]\n";
}
} elsif ($cols[6] eq '.' || $cols[6] eq '?'){
if ($ext_sc) {
print $cols[0],"\t$cols[2]\t$cols[4]\t0\t1\t$score\n";
} else {
print $cols[0],"\t$cols[2]\t$cols[4]\t0\t1\n";
}
}
undef @cols;
}
}
}
sub print_sga_ext {
my ($fh) = @_;
if ($species ne '') {
while(<$fh>){
# chr2 NimbleScan 1859802:RajiIPH3/SJOIPH3:BLOCK1 132843487 132843531 -0.11 + . seq_id=18S_CHR2:132843487-132849513;probe_id=CHR0200P132843487;count=1
chomp;
### skip comments
next if (/^\#/);
### skip blank lines
next if (/^\s*$/);
###################
## syntax checks ##
###################
my @cols = split(/\t/);
### we should have at least 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
#$wrong_seqs++;
next;
}
# $cols[5]=1;
if (($cols[5] != int($cols[5])) || ($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
unless (exists($chr2SV->{$species}->{$cols[0]}) || $cols[0] =~ /N[CT]_\S+\.\d+/){
print STDERR "Chromosome $cols[0] without sequence accession, line $.\n";
next;
}
my $id = "";
if ($cols[0] =~ /N[CT]_\S+\.\d+/) {
$id = $cols[0];
} else {
$id = $chr2SV->{$species}->{$cols[0]};
}
if ($feature ne '') {
$cols[1] = $feature;
}
if ($cols[6] eq '+'){
print $id,"\t$cols[1]\t$cols[3]\t$cols[6]\t$cols[5]\t$cols[2] $score\n";
} elsif ($cols[6] eq '-'){
print $id,"\t$cols[1]\t$cols[4]\t$cols[6]\t$cols[5]\t$cols[2] $score\n";
} elsif ($cols[6] eq '.' || $cols[6] eq '?'){
print $id,"\t$cols[1]\t$cols[4]\t0\t1\t$cols[2] $score\n";
}
undef @cols;
}
} else { #if (species) not defined
while(<$fh>){
# chr2 NimbleScan 1859802:RajiIPH3/SJOIPH3:BLOCK1 132843487 132843531 -0.11 + . seq_id=18S_CHR2:132843487-132849513;probe_id=CHR0200P132843487;count=1
chomp;
### skip comments
next if (/^\#/);
### skip blank lines
next if (/^\s*$/);
###################
## syntax checks ##
###################
my @cols = split(/\t/);
### we should have 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
next;
}
if (($cols[5] != int($cols[5])) || ($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
if ($feature ne '') {
$cols[1] = $feature;
}
if ($cols[6] eq '+'){
print $cols[0],"\t$cols[1]\t$cols[3]\t$cols[6]\t$cols[5]\t$cols[2] $score\n";
} elsif ($cols[6] eq '-'){
print $cols[0],"\t$cols[1]\t$cols[4]\t$cols[6]\t$cols[5]\t$cols[2] $score\n";
} elsif ($cols[6] eq '.' || $cols[6] eq '?'){
print $cols[0],"\t$cols[1]\t$cols[4]\t0\t1\t$cols[2] $score\n";
}
undef @cols;
}
}
}
sub print_peak_sga {
my ($fh) = @_;
if ($species ne '') {
while(<$fh>){
# chr2 NimbleScan 1859802:RajiIPH3/SJOIPH3:BLOCK1 132843487 132843531 -0.11 + . seq_id=18S_CHR2:132843487-132849513;probe_id=CHR0200P132843487;count=1
chomp;
next if (/^\#/);
next if (/^\s*$/);
my @cols = split(/\t/);
### we should have at least 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
#$wrong_seqs++;
next;
}
if (($cols[5] != int($cols[5])) || ($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
unless (exists($chr2SV->{$species}->{$cols[0]}) || $cols[0] =~ /N[CT]_\S+\.\d+/){
print STDERR "Chromosome $cols[0] without sequence accession, line $.\n";
next;
}
my $id = "";
if ($cols[0] =~ /N[CT]_\S+\.\d+/) {
$id = $cols[0];
} else {
$id = $chr2SV->{$species}->{$cols[0]};
}
if ($feature ne '') {
$cols[2] = $feature;
}
my $center = int(($cols[3]+$cols[4])/2);
if ($ext_sc) {
print $id,"\t$cols[2]\t$center\t0\t$cols[5]\t$score\n";
} else {
print $id,"\t$cols[2]\t$center\t0\t$cols[5]\n";
}
undef @cols;
}
} else { #if (species) not defined
while(<$fh>){
chomp;
next if (/^\#/);
next if (/^\s*$/);
my @cols = split(/\t/);
### we should have 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
next;
}
if (($cols[5] != int($cols[5]))||($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
if ($feature ne '') {
$cols[2] = $feature;
}
my $center = int(($cols[3]+$cols[4])/2);
if ($ext_sc) {
print "$cols[0]\t$cols[2]\t$center\t0\t$cols[5]\t$score\n";
} else {
print "$cols[0]\t$cols[2]\t$center\t0\t$cols[5]\n";
}
undef @cols;
}
}
}
sub print_peak_sga_ext {
my ($fh) = @_;
if ($species ne '') {
while(<$fh>){
# chr2 NimbleScan 1859802:RajiIPH3/SJOIPH3:BLOCK1 132843487 132843531 -0.11 + . seq_id=18S_CHR2:132843487-132849513;probe_id=CHR0200P132843487;count=1
chomp;
next if (/^\#/);
next if (/^\s*$/);
my @cols = split(/\t/);
### we should have at least 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
#$wrong_seqs++;
next;
}
if (($cols[5] != int($cols[5]))||($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
unless (exists($chr2SV->{$species}->{$cols[0]}) || $cols[0] =~ /N[CT]_\S+\.\d+/){
print STDERR "Chromosome $cols[0] without sequence accession, line $.\n";
next;
}
my $id = "";
if ($cols[0] =~ /N[CT]_\S+\.\d+/) {
$id = $cols[0];
} else {
$id = $chr2SV->{$species}->{$cols[0]};
}
if ($feature ne '') {
$cols[1] = $feature;
}
my $center = int(($cols[3]+$cols[4])/2);
print $id,"\t$cols[1]\t$center\t0\t$cols[5]\t$cols[2] $score\n";
undef @cols;
}
} else { #if (species) not defined
while(<$fh>){
chomp;
next if (/^\#/);
next if (/^\s*$/);
my @cols = split(/\t/);
### we should have 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
next;
}
if (($cols[5] != int($cols[5]))||($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
if ($feature ne '') {
$cols[1] = $feature;
}
my $center = int(($cols[3]+$cols[4])/2);
print "$cols[0]\t$cols[1]\t$center\t0\t$cols[5]\t$cols[2] $score\n";
undef @cols;
}
}
}
sub print_peak_sga_oriented {
my ($fh) = @_;
if ($species ne '') {
while(<$fh>){
# chr2 NimbleScan 1859802:RajiIPH3/SJOIPH3:BLOCK1 132843487 132843531 -0.11 + . seq_id=18S_CHR2:132843487-132849513;probe_id=CHR0200P132843487;count=1
chomp;
next if (/^\#/);
next if (/^\s*$/);
my @cols = split(/\t/);
### we should have at least 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
#$wrong_seqs++;
next;
}
if (($cols[5] != int($cols[5]))||($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
unless (exists($chr2SV->{$species}->{$cols[0]}) || $cols[0] =~ /N[CT]_\S+\.\d+/){
print STDERR "Chromosome $cols[0] without sequence accession, line $.\n";
next;
}
my $id = "";
if ($cols[0] =~ /N[CT]_\S+\.\d+/) {
$id = $cols[0];
} else {
$id = $chr2SV->{$species}->{$cols[0]};
}
if ($feature ne '') {
$cols[2] = $feature;
}
my $center = int(($cols[3]+$cols[4])/2);
if ($ext_sc) {
print $id,"\t$cols[2]\t$center\t$cols[6]\t$cols[5]\t$score\n";
} else {
print $id,"\t$cols[2]\t$center\t$cols[6]\t$cols[5]\n";
}
undef @cols;
}
} else { #if (species) not defined
while(<$fh>){
chomp;
next if (/^\#/);
next if (/^\s*$/);
my @cols = split(/\t/);
### we should have 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
next;
}
if (($cols[5] != int($cols[5]))||($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
if ($feature ne '') {
$cols[2] = $feature;
}
my $center = int(($cols[3]+$cols[4])/2);
if ($ext_sc) {
print "$cols[0]\t$cols[2]\t$center\t$cols[6]\t$cols[5]\t$score\n";
} else {
print "$cols[0]\t$cols[2]\t$center\t$cols[6]\t$cols[5]\n";
}
undef @cols;
}
}
}
sub print_peak_sga_oriented_ext {
my ($fh) = @_;
if ($species ne '') {
while(<$fh>){
# chr2 NimbleScan 1859802:RajiIPH3/SJOIPH3:BLOCK1 132843487 132843531 -0.11 + . seq_id=18S_CHR2:132843487-132849513;probe_id=CHR0200P132843487;count=1
chomp;
next if (/^\#/);
next if (/^\s*$/);
my @cols = split(/\t/);
### we should have at least 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
#$wrong_seqs++;
next;
}
if (($cols[5] != int($cols[5]))||($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
unless (exists($chr2SV->{$species}->{$cols[0]}) || $cols[0] =~ /N[CT]_\S+\.\d+/){
print STDERR "Chromosome $cols[0] without sequence accession, line $.\n";
next;
}
my $id = "";
if ($cols[0] =~ /N[CT]_\S+\.\d+/) {
$id = $cols[0];
} else {
$id = $chr2SV->{$species}->{$cols[0]};
}
if ($feature ne '') {
$cols[1] = $feature;
}
my $center = int(($cols[3]+$cols[4])/2);
print $id,"\t$cols[1]\t$center\t$cols[6]\t$cols[5]\t$cols[2] $score\n";
undef @cols;
}
} else { #if (species) not defined
while(<$fh>){
chomp;
next if (/^\#/);
next if (/^\s*$/);
my @cols = split(/\t/);
### we should have 8 columns.
if (scalar(@cols) < 8) {
print STDERR "Incorrect column count, line $.\n";
next;
}
if (($cols[5] != int($cols[5]))||($cols[5] eq '.') || ($cols[5] < 0) || ($ext_sc)) {
$score = $cols[5];
$cols[5] = 1;
$ext_sc = 1;
}
if ($feature ne '') {
$cols[1] = $feature;
}
my $center = int(($cols[3]+$cols[4])/2);
print "$cols[0]\t$cols[1]\t$center\t$cols[6]\t$cols[5]\t$cols[2] $score\n";
undef @cols;
}
}
}
sub Usage {
print STDERR <<"_USAGE_";
gff2sga.pl [options]
where options are:
-h|--help Show this stuff
--db Use to locate Chrom Id Storable File 'chro_idx.nstorage'
-f|--feature Set Feature name
-s|--species Assembly (i.e hg18)
-c Generate a Centered SGA file
-u Generate an Unoriented SGA file
-x Generate an extended SGA file with the
6th field equal to the GFF 'feature' field,
and the feature field equal to the GFF 'source'
_USAGE_
exit(1);
}
1;
chip-seq/tools/check_bed.pl 0000744 0227442 0026227 00000003260 12166546052 016454 0 ustar ambrosin gr-bucher #!/usr/bin/perl
# check BED file : check whether tag mapping on chromosomes is correct
# usage: ./check_bed.pl <-s species>] -f
use strict;
use Getopt::Std;
use Storable qw (retrieve nstore); # package to store persistently variables in files [http://search.cpan.org/author/AMS/Storable-2.07/Storable.pm]
my %opts;
getopt('sf:', \%opts); # -s, & -f take arg. Values in %opts, Hash keys will be the switch names
my $DB = "/db/genome/";
#my $DB = "/home/local/db/genome/";
my $chr2SV = retrieve($DB."chro_idx.nstorage");
&Usage() unless ($opts{'f'} && $opts{'s'});
# open the BED file
open(my $BED, "grep \'\^chr\' $opts{'f'}|") || die "can't open $opts{'f'} : $!";
#open(my $BED, "$opts{'f'}") || die "can't open $opts{'f'} : $!";
my $cnt = 0;
my $err_cnt = 0;
while(<$BED>) {
chomp;
my @f=split/\t/;
my $chr_len = $chr2SV->{'length'}->{$chr2SV->{$opts{'s'}}->{$f[0]}};
$cnt++;
#print "chrom: $f[0] length: $chr_len\n";
if ($f[1] > $chr_len or $f[2] > $chr_len) {
print STDERR "Error line $cnt : position $f[1] exceeds chrom length $chr_len (chrom: $f[0] )!\n";
$err_cnt++;
}
}
close($BED);
if ($err_cnt) {
print STDERR "\n\nWarning : Out of a total of $cnt BED lines, $err_cnt lines could not be mapped to the given genome assembly.\nPlease, check that the assembly you're using is the correct one.\n\n";
} else {
print STDERR "\ncheck_bed: correct.\nTotal number of BED lines : ($cnt)\n\n";
}
sub Usage {
print STDERR <<"_USAGE_";
check_bed.pl -s -f
Check whether tag positions on chromosomes are correctly mapped (e.g. positions do not exceed cromosome length).
_USAGE_
exit(1);
}
1;
chip-seq/tools/sga2wig.c 0000744 0227442 0026227 00000076637 13401230654 015750 0 ustar ambrosin gr-bucher /*
sga2wig.c
Convert SGA file to Wiggle Track (WIG) format.
There are two options for formatting wiggle data:
- variableStep [0]
- fixedStep [1]
variableStep is for data with irregular intervals between new data points.
It begins with a declaration line and is followed by two columns containing chromosome positions and data values:
variableStep chrom=chrN [span=windowSize]
chromStartA dataValueA
chromStartB dataValueB
... etc ... ... etc ...
fixedStep is for data with regular intervals between new data values.
It begins with a declaration line and is followed by a single column of data values:
fixedStep chrom=chrN start=position step=stepInterval [span=windowSize = stepInterval]
dataValue1
dataValue2
... etc ...
(For more details on WIG format see https://genome.ucsc.edu/goldenPath/help/wiggle.html)
# Arguments:
# SGA File
# Options:
# Set Path to locate chr_NC_gi file
# (used for NCBI id to chromosome name conversion)
# Set WIG format option: variableStep[0]/fixedStep[1] (def=0)
# Set Chromosome number (by def=0 i.e. take all chromosomes))
# Set chromosome start coordinate (def=-1, i.e. entire chromosome region)
# Set chromosome end coordinate (def=-1, i.e. entire chromosome region)
# Set count cut-off for SGA count field (def=99999)
# Set normalisation factor for total raead counts within a step interval
# - For fixedStep WIG format (def=0, i.e. take sum of total counts)
# Set Wiggle span parameter (def=150)
# Set Wiggle step parameter (fixedStep Format) (def=150 step=span)
# SGA input file is a peak file, expand peak coordinates by span value
# on both upstream and downstream directions
# Set data viewing paramenter: autoscale (def=OFF)
# Set data viewing paramenter: always0 (include zero) (def=OFF)
# Set data viewing paramenter: wfunction function (def=mean+whiskers, maximum|mean|minimum)
# Set data viewing paramenter: smoothing window (def=OFF[0], =0,2..16)
# Set data viewing paramenter: visibility mode (def=full, dense|hide)
# Set Wiggle track name (def=Custom-Wig)
# Set Wiggle track description (def=ChIP-Seq)
# Set Wiggle track color (def= 0,200,100)
Giovanna Ambrosini, EPFL/ISREC, Giovanna.Ambrosini@epfl.ch
Copyright (c) 2014 EPFL and Swiss Institute of Bioinformatics.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
#define DEBUG
*/
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "hashtable.h"
#ifdef DEBUG
#include
#endif
#include "version.h"
#define BUF_SIZE 8192
#define LINE_SIZE 1024
#define FT_MAX 64
#define SEQ_ID 32
#define CHR_NB 18
#define AC_MAX 18
#define CHR_SIZE 10
#define POS_MAX 16
#define CNT_MAX 16
#define EXT_MAX 256
#define FIELD_MAX 64
typedef struct _options_t {
char *dbPath;
int help;
int debug;
int db;
int wigFormat;
char *chrNb;
char *chrName;
int chrFlag;
unsigned long chrStart;
unsigned long chrEnd;
int cutOff;
int norm;
int span;
int step;
int peakFlag;
char *autoscale;
char *always0;
char *wfunction;
char *smoothing;
char *visibility;
char *trackName;
char *trackDesc;
char *trackColor;
} options_t;
static options_t options;
typedef struct _feature_t {
char seq_id[SEQ_ID];
unsigned long *pos;
int *cnt;
} feature_t, *feature_p_t;
static feature_t sga_ft;
static hash_table_t *ac_table = NULL;
static hash_table_t *size_table = NULL;
unsigned long endPos = 0;
unsigned long startPos = 0;
int
process_ac()
{
FILE *input;
int c;
char buf[LINE_SIZE];
char *chrFile;
char chrom[12];
int cLen;
if (options.db) {
cLen = (int)strlen(options.dbPath) + 12;
if ((chrFile = (char*)malloc(cLen * sizeof(char))) == NULL) {
perror("process_ac: malloc");
exit(1);
}
strcpy(chrFile, options.dbPath);
} else {
cLen = 21 + 12;
if ((chrFile = (char*)malloc(cLen * sizeof(char))) == NULL) {
perror("process_ac: malloc");
exit(1);
}
strcpy(chrFile, "/home/local/db/genome");
}
strcat(chrFile, "/chr_NC_gi");
input = fopen(chrFile, "r");
if (input == NULL) {
fprintf(stderr, "Could not open file %s: %s(%d)\n",
chrFile, strerror(errno), errno);
return 1;
}
do {
c = fgetc(input);
} while(c != '\n');
ac_table = hash_table_new(MODE_COPY);
while (fgets(buf, LINE_SIZE, input) != NULL) {
char *s;
char chr_nb[CHR_NB] = "";
char ncbi_ac[AC_MAX] = "";
int i = 0;
int nb_len = 0;
int ac_len = 0;
/*int valid = 1;*/
s = buf;
/* Check line */
/* Get first character: if # skip line */
if (*s == '#')
continue;
/* Chrom NB */
while (*s != 0 && !isspace(*s)) {
if (i >= CHR_NB) {
fprintf(stderr, "AC too long in %s\n", s);
fclose(input);
exit(1);
}
chr_nb[i++] = *s++;
}
if (i < CHR_NB)
chr_nb[i] = 0;
nb_len = i + 1;
while (isspace(*s))
s++;
/* Chromosome NCBI AC */
i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= AC_MAX) {
fprintf(stderr, "AC too long \"%s\" \n", s);
fclose(input);
exit(1);
}
ncbi_ac[i++] = *s++;
}
if (i < AC_MAX)
ncbi_ac[i] = 0;
ac_len = i + 1;
strcpy(chrom, "chr");
strcat(chrom, chr_nb);
nb_len = (int)strlen(chrom) + 1;
/* printf("adding key %s (len = %d) value %s (ac) (len = %d) to hash table\n", chrom, nb_len, ncbi_ac, ac_len); */
/* Store both NCBI identifier to chrom number and chrom number to chrom number keys */
hash_table_add(ac_table, ncbi_ac, (size_t)ac_len, chrom, (size_t)nb_len);
if (options.debug) {
char *cn = hash_table_lookup(ac_table, ncbi_ac, (size_t)ac_len);
fprintf (stderr, " AC Hash table: %s (len = %d) -> %s (len = %d)\n", ncbi_ac, ac_len, cn, nb_len);
}
hash_table_add(ac_table, chrom, (size_t)nb_len, chrom, (size_t)nb_len);
if (options.debug) {
char *cn = hash_table_lookup(ac_table, chrom, (size_t)nb_len);
fprintf (stderr, " AC Hash table: %s (len = %d) -> %s (len = %d)\n", chrom, nb_len, cn, nb_len);
}
}
return 0;
}
int
process_size()
{
FILE *input;
int c;
char buf[LINE_SIZE];
char *chrSizeFile;
int cLen;
if (options.db) {
cLen = (int)strlen(options.dbPath) + 10;
if ((chrSizeFile = (char*)malloc(cLen * sizeof(char))) == NULL) {
perror("process_ac: malloc");
exit(1);
}
strcpy(chrSizeFile, options.dbPath);
} else {
cLen = 21 + 10;
if ((chrSizeFile = (char*)malloc(cLen * sizeof(char))) == NULL) {
perror("process_ac: malloc");
exit(1);
}
strcpy(chrSizeFile, "/home/local/db/genome");
}
strcat(chrSizeFile, "/chr_size");
input = fopen(chrSizeFile, "r");
if (input == NULL) {
fprintf(stderr, "Could not open file %s: %s(%d)\n",
chrSizeFile, strerror(errno), errno);
return 1;
}
do {
c = fgetc(input);
} while(c != '\n');
size_table = hash_table_new(MODE_COPY);
while (fgets(buf, LINE_SIZE, input) != NULL) {
char *s;
char chr_size[CHR_SIZE] = "";
char ncbi_ac[AC_MAX] = "";
int i = 0;
int ac_len = 0;
int size_len = 0;
/*int valid = 1;*/
s = buf;
/* Check line */
/* Get first character: if # skip line */
if (*s == '#')
continue;
/* Chromosome NCBI AC */
i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= AC_MAX) {
fprintf(stderr, "AC too long \"%s\" \n", s);
fclose(input);
exit(1);
}
ncbi_ac[i++] = *s++;
}
if (i < AC_MAX)
ncbi_ac[i] = 0;
ac_len = i + 1;
while (isspace(*s))
s++;
i = 0;
/* Chrom SIZE */
while (*s != 0 && !isspace(*s)) {
if (i >= CHR_SIZE) {
fprintf(stderr, "Size too long in %s\n", s);
fclose(input);
exit(1);
}
chr_size[i++] = *s++;
}
if (i < CHR_NB)
chr_size[i] = 0;
size_len = i + 1;
/* printf("adding key %s (len = %d) value %s (ac) (len = %d) to hash table\n", ncbi_ac, ac_len, chr_size, size_len); */
hash_table_add(size_table, ncbi_ac, (size_t)ac_len, chr_size, (size_t)size_len);
if (options.debug) {
char *csize = hash_table_lookup(size_table, ncbi_ac, (size_t)ac_len);
fprintf (stderr, " SIZE Hash table: %s (len = %d) -> %s (len = %d)\n", ncbi_ac, ac_len, csize, size_len);
}
}
return 0;
}
char** str_split(char* a_str, const char a_delim)
{
char** result = 0;
size_t count = 0;
char* tmp = a_str;
char* last_comma = 0;
char delim[2];
delim[0] = a_delim;
delim[1] = 0;
/* Count how many elements will be extracted. */
while (*tmp) {
if (a_delim == *tmp) {
count++;
last_comma = tmp;
}
tmp++;
}
/* Add space for trailing token. */
count += last_comma < (a_str + strlen(a_str) - 1);
/* Add space for terminating null string so caller
knows where the list of returned strings ends. */
count++;
result = malloc(sizeof(char*) *count);
if (result) {
size_t idx = 0;
char* token = strtok(a_str, delim);
while (token) {
assert(idx < count);
*(result + idx++) = strdup(token);
token = strtok(0, delim);
}
assert(idx == count - 1);
*(result + idx) = 0;
}
return result;
}
void write_wig_vs (unsigned long *pos, int *counts, unsigned int len, char *ac)
{
unsigned int i = 0;
unsigned int k = 0;
unsigned long *p = pos;
int *cnt = counts;
int ac_len = 0;
if (endPos == 0) {
return;
}
if (ac == NULL)
return;
ac_len = (int)strlen(ac) + 1;
char *chr_nb = hash_table_lookup(ac_table, ac, (size_t)ac_len);
if (chr_nb == NULL)
return;
printf ("variableStep chrom=%s span=%d\n", chr_nb, options.span);
printf ("1 0\n");
int offset = 2;
for (i = 0; i < len; i++) {
if (options.peakFlag) {
long new_pos = *p++ - options.span/2;
if (new_pos <= 1){
new_pos = offset++;
}
printf("%ld %d\n", new_pos, *cnt++);
} else {
k = 1;
/* allows data composed of contiguous runs of options.span bases
the same data value to be specified more succinctly */
while((i + k < len) && (p[i + k] < p[i] + options.span)) {
if (cnt[i] == cnt[i + k])
k++;
else
break;
}
//printf("%lu %d\n", *s++, *cnt++);
printf("%lu %d\n", p[i], cnt[i]);
if (k == options.span)
i = i + k - 1;
}
}
}
void write_wig_fs (unsigned long *pos, int *counts, unsigned int len, char *ac)
{
unsigned int i = 0;
unsigned int k = 0;
unsigned long *s = pos;
int *cnt = counts;
int ac_len = 0;
char *csize = NULL;
unsigned long chr_size = 0;
long sum = 0;
if (endPos == 0) {
return;
}
unsigned long end_loop = endPos - options.step;
if (ac == NULL)
return;
ac_len = (int)strlen(ac) + 1;
csize = hash_table_lookup(size_table, ac, (size_t)ac_len);
if (csize == NULL)
return;
chr_size = (unsigned long) atoi(csize);
char *chr_nb = hash_table_lookup(ac_table, ac, (size_t)ac_len);
if (chr_nb == NULL)
return;
if (end_loop > chr_size) {
end_loop = chr_size - options.span + 1;
}
printf ("fixedStep chrom=%s start=%lu step=%d span=%d\n", chr_nb, startPos, options.step, options.span);
for (i = startPos; i <= end_loop; i += options.step) {
while ( (k < len) && (pos[k] <= i + options.step) ){
sum += counts[k++];
}
if (options.norm) {
sum = (long)((sum * options.norm)/options.step);
}
printf("%ld\n", sum);
sum = 0;
}
}
int
process_sga(FILE *input, char *iFile)
{
unsigned long start, end;
unsigned long pos;
int cnt;
char *name;
int first = 1;
int wig_hdr = 1;
char *s, *res, *buf;
size_t bLen = LINE_SIZE;
size_t sga_mLen = BUF_SIZE;
char seq_id[SEQ_ID] = "";
char seq_id_prev[SEQ_ID] = "";
unsigned int k = 0;
if (options.debug)
fprintf(stderr, " Processing SGA file %s\n", iFile);
if ((s = malloc(bLen * sizeof(char))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
/* Malloc position and count arrays */
if ((sga_ft.pos = (unsigned long *)calloc(sga_mLen, sizeof(unsigned long))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if ((sga_ft.cnt = (int *)calloc(sga_mLen, sizeof(int))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
#ifdef DEBUG
int c = 1;
#endif
while ((res = fgets(s, (int) bLen, input)) != NULL) {
size_t cLen = strlen(s);
char ft[FT_MAX] = "";
char position[POS_MAX] = "";
char count[CNT_MAX] = "";
char strand = '\0';
char ext[EXT_MAX];
int i = 0;
int id_len = 0;
char *cn = NULL;
memset(ext, 0, (size_t)EXT_MAX);
memset(seq_id, 0, (size_t)SEQ_ID);
while (cLen + 1 == bLen && s[cLen - 1] != '\n') {
bLen *= 2;
if ((s = realloc(s, bLen)) == NULL) {
perror("process_file: realloc");
exit(1);
}
res = fgets(s + cLen, (int) (bLen - cLen), input);
cLen = strlen(s);
}
if (s[cLen - 1] == '\n')
s[cLen - 1] = 0;
buf = s;
/* Get SGA fields */
/* SEQ ID */
while (*buf != 0 && !isspace(*buf)) {
if (i >= SEQ_ID) {
fprintf(stderr, "Seq ID is too long \"%s\" \n", buf);
exit(1);
}
seq_id[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* FEATURE */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature is too long \"%s\" \n", buf);
exit(1);
}
ft[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "Position is too large \"%s\" \n", buf);
exit(1);
}
position[i++] = *buf++;
}
position[i] = 0;
pos = atoi(position);
while (isspace(*buf))
buf++;
/* Strand */
strand = *buf++;
while (isspace(*buf))
buf++;
/* Counts */
i = 0;
while (isdigit(*buf) || *buf == '-') {
if (i >= CNT_MAX) {
fprintf(stderr, "Count is too large \"%s\" \n", buf);
exit(1);
}
count[i++] = *buf++;
}
count[i] = 0;
cnt = atoi(count);
while (isspace(*buf))
buf++;
/* SGA Extension */
i = 0;
while (*buf != 0) {
if (i >= EXT_MAX) {
fprintf(stderr, "Extension is too long \"%s\" \n", buf);
exit(1);
}
ext[i++] = *buf++;
}
#ifdef DEBUG
printf(" [%d] seq ID: %s Feat: %s (%c) Pos: %d Cnts: %d Ext: %s\n", c++, seq_id, ft, strand, pos, cnt, ext);
#endif
//printf(" seq ID: %s Feat: %s (%c) Pos: %d Cnts: %d Ext: %s\n", seq_id, ft, strand, pos, cnt, ext);
if (k > sga_mLen - 1) {
sga_mLen *= 2;
if ((sga_ft.pos = (unsigned long *)realloc(sga_ft.pos, sga_mLen * sizeof(unsigned long))) == NULL) {
perror("process_sga: realloc pos array");
exit(1);
}
if ((sga_ft.cnt = (int *)realloc(sga_ft.cnt, sga_mLen * sizeof(int))) == NULL) {
perror("process_sga: realloc count array");
exit(1);
}
}
if (strcmp(seq_id, seq_id_prev) != 0) {
if (k > 0)
endPos = sga_ft.pos[k - 1];
else
endPos = 0;
if (options.wigFormat) {
write_wig_fs(sga_ft.pos, sga_ft.cnt, k, seq_id_prev);
} else {
write_wig_vs(sga_ft.pos, sga_ft.cnt, k, seq_id_prev);
}
strcpy(seq_id_prev, seq_id);
k = 0;
wig_hdr = 1;
}
/* Set WIG annotation track line */
if (first) {
if (options.trackName == NULL) {
if ((options.trackName = malloc((strlen(ft) + 1) * sizeof(char))) == NULL) {
perror("process_sga: malloc Feature");
exit(1);
}
strcpy(options.trackName, ft);
}
if (options.chrName != NULL) {
//printf("chr : %s start : %d end : %d\n", options.chrName, options.chrStart, options.chrEnd);
if ((options.chrStart != -1) && (options.chrEnd != -1)) {
printf("browser position %s:%d-%d\n", options.chrName, options.chrStart, options.chrEnd);
} else if (options.chrStart != -1) {
printf("browser position %s:%d-%d\n", options.chrName, options.chrStart, options.chrStart + 100000);
} else {
printf("browser position %s:%d-%d\n", options.chrName, 1, 100000);
}
} else {
printf("browser full refGene\n");
}
printf("track type=wiggle_0 name=\"%s\" description=\"%s\" visibility=%s color=%s autoScale=%s alwaysZero=%s maxHeightPixels=100:50:20 graphType=bar priority=30 windowingFunction=%s smoothingWindow=%s\n", options.trackName, options.trackDesc, options.visibility, options.trackColor, options.autoscale, options.always0, options.wfunction, options.smoothing);
first = 0;
}
/* Get Chromosome name */
//printf("Seq ID: %s pos: %lu cnt: %d\n", seq_id, pos, cnt);
id_len = (int)strlen(seq_id) + 1;
cn = hash_table_lookup(ac_table, seq_id, (size_t)id_len);
//printf("Chr name: %s\n", cn);
if (options.chrFlag) { /* Chromosome name has been specified */
if ((options.chrStart != -1) && (options.chrEnd != -1)) {
if (cn != NULL) {
//printf ("chr: %s\tselected chr: %s\n", cn, options.chrName);
if (strcmp(cn, options.chrName) == 0 && pos >= options.chrStart && pos <= options.chrEnd) {
//printf("Adding chr: %s pos: %lu ([%lu-%lu])\n", cn, pos, options.chrStart, options.chrEnd);
if (cnt > options.cutOff)
sga_ft.cnt[k] = options.cutOff;
else
sga_ft.cnt[k] = cnt;
sga_ft.pos[k] = pos;
k++;
if (wig_hdr) {
startPos = options.chrStart;
wig_hdr = 0;
}
}
}
} else if (options.chrStart != -1) {
if (cn != NULL) {
if (strcmp(cn, options.chrName) == 0 && pos >= options.chrStart) {
if (cnt > options.cutOff)
sga_ft.cnt[k] = options.cutOff;
else
sga_ft.cnt[k] = cnt;
sga_ft.pos[k] = pos;
k++;
if (wig_hdr) {
startPos = options.chrStart;
wig_hdr = 0;
}
}
}
} else {
if (cn != NULL) {
if (strcmp(cn, options.chrName) == 0) {
if (cnt > options.cutOff)
sga_ft.cnt[k] = options.cutOff;
else
sga_ft.cnt[k] = cnt;
sga_ft.pos[k] = pos;
k++;
if (wig_hdr) {
startPos = pos;
wig_hdr = 0;
}
}
}
}
} else { /* Scan entire SGA */
if (cnt > options.cutOff)
sga_ft.cnt[k] = options.cutOff;
else
sga_ft.cnt[k] = cnt;
sga_ft.pos[k] = pos;
k++;
if (wig_hdr) {
startPos = pos;
wig_hdr = 0;
}
}
} /* End of While */
if (input != stdin) {
fclose(input);
}
/* The last time (at EOF) */
if (k > 0)
endPos = sga_ft.pos[k - 1];
else
return 0;
//printf("The last time: SEQ_ID %s, endPos: %lu len: %d\n", seq_id, endPos, k);
if (options.wigFormat) {
write_wig_fs(sga_ft.pos, sga_ft.cnt, k, seq_id);
} else {
write_wig_vs(sga_ft.pos, sga_ft.cnt, k, seq_id);
}
free(sga_ft.pos);
free(sga_ft.cnt);
return 0;
}
int
main(int argc, char *argv[])
{
options.wigFormat = 0;
options.peakFlag = 0;
options.chrNb = NULL;
options.chrName = NULL;
options.chrFlag = 0;
options.chrStart = -1;
options.chrEnd = -1;
options.cutOff = 99999;
options.span = 150;
options.step = 150;
#ifdef DEBUG
mcheck(NULL);
mtrace();
#endif
FILE *input;
int i = 0;
int j = 0;
int usage = 0;
static struct option long_options[] =
{
/* These options may or may not set a flag.
We distinguish them by their indices. */
{"debug", no_argument, 0, 'd'},
{"help", no_argument, 0, 'h'},
{"db", required_argument, 0, 'i'},
{"format", required_argument, 0, 'o'},
{"chrnb", required_argument, 0, 'n'},
{"start", required_argument, 0, 'b'},
{"end", required_argument, 0, 'e'},
{"coff", required_argument, 0, 'c'},
{"norm", required_argument, 0, 'f'},
{"span", required_argument, 0, 's'},
{"name", required_argument, 0, 0 },
{"desc", required_argument, 0, 0 },
{"color", required_argument, 0, 0 },
{"autoscale", required_argument, 0, 0 },
{"always0", required_argument, 0, 0 },
{"wfunction", required_argument, 0, 0 },
{"smoothing", required_argument, 0, 0 },
{"visibility", required_argument, 0, 0 },
/* These option only sets a flag. */
{"peakf", no_argument, &options.peakFlag, 1},
{0, 0, 0, 0}
};
int option_index = 0;
while (1) {
int c = getopt_long(argc, argv, "dhi:o:n:b:e:c:f:s:", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'd':
options.debug = 1;
break;
case 'h':
options.help = 1;
break;
case 'i':
options.dbPath = optarg;
options.db = 1;
break;
case 'o':
options.wigFormat = atoi(optarg);
break;
case 'n':
options.chrNb = optarg;
if (strcmp(options.chrNb, "0") != 0) {
if ( (options.chrName = malloc((strlen(options.chrNb) + 4) * sizeof(char))) == NULL) {
perror("process_sga: malloc Chr Name");
exit(1);
}
strcpy(options.chrName, "chr");
strcat(options.chrName, options.chrNb);
options.chrFlag = 1;
}
break;
case 'b':
options.chrStart = atoi(optarg);
break;
case 'e':
options.chrEnd = atoi(optarg);
if (options.chrEnd != -1 && options.chrStart == -1)
options.chrStart = 1;
break;
case 'c':
options.cutOff = atoi(optarg);
break;
case 'f':
options.norm = atoi(optarg);
break;
case 's':
options.span = atoi(optarg);
options.step = options.span;
break;
case 0:
/* This option is to set the annotation track line */
if (strcmp(long_options[option_index].name, "name") == 0) {
options.trackName = optarg;
}
if (strcmp(long_options[option_index].name, "desc") == 0) {
options.trackDesc = optarg;
}
if (strcmp(long_options[option_index].name, "color") == 0) {
options.trackColor = optarg;
}
if (strcmp(long_options[option_index].name, "autoscale") == 0) {
options.autoscale = optarg;
}
if (strcmp(long_options[option_index].name, "always0") == 0) {
options.always0 = optarg;
}
if (strcmp(long_options[option_index].name, "wfunction") == 0) {
options.wfunction = optarg;
}
if (strcmp(long_options[option_index].name, "smoothing") == 0) {
options.smoothing = optarg;
}
if (strcmp(long_options[option_index].name, "visibility") == 0) {
options.visibility = optarg;
}
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
usage = 1;
}
}
/* printf("optind: %d argc: %d\n", optind, argc); */
if (optind > argc || options.help == 1 || usage) {
fprintf(stderr, "Usage: %s [options] [<] \n"
" - version %s\n"
" where options are:\n"
" \t\t -d|--debug Produce Debug information\n"
" \t\t -h|--help Show this Help text\n"
" \t\t -i|--db Use to locate the chr_NC_gi and chr_size files\n"
" \t\t [default is: $HOME/db/genome]\n"
" \t\t -o|--format <0|1> Set Wiggle Track data format: variableStep[def=0]/fixedStep[1]\n"
" \t\t -n|--chrnb Chromosome number [def: 0 (all chromosomes)]\n"
" \t\t -b|--start Chromosome start [def: -1 (entire chromosome)]\n"
" \t\t -e|--end Chromosome end [def: -1 (entire chromosome)]\n"
" \t\t -c|--coff Count cut-off for the SGA input file [def=99999]\n"
" \t\t -s|--span Wiggle Track Span(/stepInterval) parameter [def=%d]\n"
" \t\t For fixedStep data format, it defines the step parameter\n"
" \t\t -f|--norm Normalization factor for total tag counts within step intervals [def=0]\n"
" \t\t This option is only valid for fixedStep data format\n"
" \t\t --peakf Indicate that the The SGA input file represents a peak file\n"
" \t\t [i.e. coordinates are peak centers]\n"
" \t\t In such case, the span range begins upstream of [span=]%d bp\n"
" \t\t chromosome position specified, and ends [span=]%d bp downstream\n"
" \t\t --name Set name for track name field [def. name=SGA-feature]\n"
" \t\t --desc Set track description field [def. desc=\"ChIP-Seq Custom data\"]\n"
" \t\t --color Define the track color in comma-separated RGB values [def. 100,100,100]\n"
" \t\t --autoscale Data viewing paramenter: set auto-scale to UCSC data view [def=OFF]\n"
" \t\t --always0 Data viewing paramenter: always include zero [def=OFF]\n"
" \t\t --wfunction Data viewing paramenter: windowing function [def=mean+whiskers|maximum|mean|minimum]\n"
" \t\t --smoothing Data viewing paramenter: smoothing window [def=OFF[0], =0,2..16]\n"
" \t\t --visibility Display mode: [def=full|dense|hide]\n"
"\n\tConvert SGA format into Wiggle Track format (WIG).\n"
"\tWIG format is line-oriented, and is composed of declaration lines and data lines.\n\n"
"\t- variableStep is for data with irregular intervals between new data points.\n"
"\t It begins with a declaration line and is followed by two columns containing chromosome positions and data values:\n\n"
"\t variableStep chrom=chrN [span=windowSize]\n"
"\t chromStartA dataValueA\n"
"\t chromStartB dataValueB\n"
"\t ... etc ... ... etc ...\n\n"
"\t- fixedStep is for data with regular intervals between new data values.\n"
"\t It begins with a declaration line and is followed by a single column of data values:\n\n"
"\t fixedStep chrom=chrN start=position step=stepInterval [span=windowSize = stepInterval]\n"
"\t dataValue1\n"
"\t dataValue2\n"
"\t ... etc ...\n\n",
argv[0], VERSION, options.span, options.span, options.span);
return 1;
}
/* printf("argc: %d optind: %d\n", argc, optind); */
if (argc > optind) {
if(!strcmp(argv[optind],"-")) {
input = stdin;
} else {
input = fopen(argv[optind], "r");
if (NULL == input) {
fprintf(stderr, "Unable to open '%s': %s(%d)\n",
argv[optind], strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", argv[optind]);
}
} else {
input = stdin;
}
if (options.trackDesc == NULL) {
if ((options.trackDesc = malloc(32 * sizeof(char))) == NULL) {
perror("main: malloc trackDesc");
exit(1);
}
strcpy(options.trackDesc, "ChIP-Seq Custom data");
}
if (options.trackColor == NULL) {
if ((options.trackColor = malloc(12 * sizeof(char))) == NULL) {
perror("main: malloc trackColor");
exit(1);
}
strcpy(options.trackColor, "0,200,100");
}
if (options.autoscale == NULL) {
if ((options.autoscale = malloc(4 * sizeof(char))) == NULL) {
perror("main: malloc autoscale");
exit(1);
}
strcpy(options.autoscale, "off");
}
if (options.always0 == NULL) {
if ((options.always0 = malloc(4 * sizeof(char))) == NULL) {
perror("main: malloc always0");
exit(1);
}
strcpy(options.always0, "off");
}
if (options.wfunction == NULL) {
if ((options.wfunction = malloc(5 * sizeof(char))) == NULL) {
perror("main: malloc wfunction");
exit(1);
}
strcpy(options.wfunction, "mean");
}
if (options.smoothing == NULL) {
if ((options.smoothing = malloc(4 * sizeof(char))) == NULL) {
perror("main: malloc smoothing");
exit(1);
}
strcpy(options.smoothing, "off");
}
if (options.visibility == NULL) {
if ((options.visibility = malloc(5 * sizeof(char))) == NULL) {
perror("main: malloc visibility");
exit(1);
}
strcpy(options.visibility, "full");
}
if (options.peakFlag) {
options.span *= 2;
}
if (options.debug) {
fprintf(stderr, " Arguments:\n");
fprintf(stderr, " Wiggle data format : %d\n", options.wigFormat);
fprintf(stderr, " Chromosome Nb : %s Name : %s\n", options.chrNb, options.chrName);
fprintf(stderr, " Chromosome Start : %d\n", options.chrStart);
fprintf(stderr, " Chromosome End : %d\n", options.chrEnd);
fprintf(stderr, " Count cut-off : %d\n", options.cutOff);
fprintf(stderr, " Normalisation factor for fixedStep WIG : %d\n", options.norm);
fprintf(stderr, " WIG Span/Step Interval: %d\n", options.span);
fprintf(stderr, " Peak Flag (for SGA input file): %d\n", options.peakFlag);
fprintf(stderr, " Wiggle Track Display options:\n");
fprintf(stderr, " -----------------------------\n");
fprintf(stderr, " Track name: %s\n", options.trackName);
fprintf(stderr, " Track description: %s\n", options.trackDesc);
fprintf(stderr, " Track color: %s\n", options.trackColor);
fprintf(stderr, " Autoscale: %s\n", options.autoscale);
fprintf(stderr, " Always0: %s\n", options.always0);
fprintf(stderr, " Wfunction: %s\n", options.wfunction);
fprintf(stderr, " Smoothing: %s\n", options.smoothing);
fprintf(stderr, " Visibility: %s\n", options.visibility);
fprintf(stderr, "\n");
}
if (!((optind == 1) && (optind == argc))) {
if (process_ac() == 0) {
if (options.debug)
fprintf(stderr, " HASH Table for chromosome access identifier initialized\n");
} else {
return 1;
}
if (process_size() == 0) {
if (options.debug)
fprintf(stderr, " HASH Table for chromosome size initialized\n");
} else {
return 1;
}
} else {
return 1;
}
if (process_sga(input, argv[optind++]) != 0) {
return 1;
}
return 0;
}
chip-seq/tools/partit2gff.pl 0000744 0227442 0026227 00000002745 11537713130 016636 0 ustar ambrosin gr-bucher #!/usr/local/bin/perl
# converts sga format from partitioning to gff format
# usage: ./partit2gff file.sga
use strict;
&Usage() if $#ARGV < 0;
use Storable qw (retrieve nstore); # package to store persistently variables in files [http://search.cpan.org/author/AMS/Storable-2.07/Storable.pm]
# hash defining chromosome from SV of chromosomes in current genome assemblies
my $chr2SV = retrieve("/db/genome/chro_idx.nstorage");
my @pos = ();
my $count = 0;
print "##gff-version 3\n";
while(<>){
#print $chr2AC{$chro},"\t$exp\t$pos\t+\t",$score_ref->{$chr2AC{$chro}}->{'+'}->{$pos},"\n";
# Partitioning algorithm reports positions of start and end of tag,
#NC_000001.9 CTCF 227595 + 1 Start Line
#NC_000001.9 CTCF 227633 - 1 End Line
my $lin=$_;
chomp $lin;
my @ar=split(/\t/,$lin);
# eventually escape offending characters?
if ($ar[3] eq '+') {
$pos[0] = $ar[2];
} elsif ($ar[3] eq '-') {
$pos[1] = $ar[2];
$count++;
if (exists($chr2SV->{$ar[0]})){
# ChrX . gene XXXX YYYY . + . ID=gene01;name=resA
print $chr2SV->{$ar[0]},"\tChIPSeq\t$ar[1]\t$pos[0]\t$pos[1]\t$ar[4]\t+\t.\t$count\n";
}
else {
print $ar[0],"\tChIPSeq\t$ar[1]\t$pos[0]\t$pos[1]\t$ar[4]\t+\t.\t$count\n";
#print STDERR "Sequence version $ar[0] not in current genome assembly!\n";
}
@pos = ();
}
}
sub Usage {
print STDERR <<"_USAGE_";
partit2gff.pl
_USAGE_
exit(1);
}
1;
chip-seq/tools/bed2bed_display.c 0000744 0227442 0026227 00000043674 13351220465 017417 0 ustar ambrosin gr-bucher /*
bed2bed_display.c
Convert BED file to BED format suitable for displaying ChIP-seq peaks.
# Arguments:
#
# BED File
# Minimal BED score - 5th field (integer) [-a min]
# Maximal BED score - 5th field (integer) [-b max]
#
# Options:
#
# Set Feature name [-f fname]
# BED output formats: [-o 1|2] def=1
#
# 1- BED track with score and strand fields -use score to visualize the track
# the score value will determine the level of gray in which this feature is displayed
# (higher numbers = darker gray).
#
# Track Parameters:
#
# ex: track name=STAT1Peaks description="Robertson 2007, STAT1 peaks" visibility=2 useScore=1
#
# 2- BedGraph format
# The bedGraph format allows display of continuous-valued data in track format.
# chromA chromStartA chromEndA dataValueA
# chromB chromStartB chromEndB dataValueB
#
# Parameters for bedGraph track definition lines:
#
# track type=bedGraph name=track_label description=center_label visibility=1|2|3 color=r,g,b graphType=bar|points
Giovanna Ambrosini, EPFL/ISREC, Giovanna.Ambrosini@epfl.ch
Copyright (c) 2014 EPFL and Swiss Institute of Bioinformatics.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
#define DEBUG
*/
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "hashtable.h"
#ifdef DEBUG
#include
#endif
#include "version.h"
#define BUF_SIZE 8192
#define LINE_SIZE 1024
#define FT_MAX 64
#define CHR_NB 18
#define AC_MAX 18
#define POS_MAX 16
#define SCORE_MAX 12
#define NAME_MAX 128
#define FIELD_MAX 64
typedef struct _options_t {
int help;
int debug;
char *feature;
int oformat;
char *autoscale;
char *always0;
char *wfunction;
char *smoothing;
char *visibility;
char *trackName;
char *trackDesc;
char *trackColor;
} options_t;
static options_t options;
int minScore = -1;
int maxScore = -1;
int rescale_score(int s) /* Rescale score range to [167,1000] */
{
int a = 167;
int b = 1000;
int val;
if (maxScore-minScore > 0) {
val = ((b-a)*(s-minScore)/(maxScore-minScore)) + a;
} else {
val = s;
}
return(val);
}
int
process_bed(FILE *input, char *iFile)
{
unsigned long start, end;
int score;
int new_score;
int count = 1;
char *s, *res, *buf;
size_t bLen = LINE_SIZE;
if (options.debug)
fprintf(stderr, " Processing BED file %s\n", iFile);
if ((s = malloc(bLen * sizeof(char))) == NULL) {
perror("process_bed: malloc");
exit(1);
}
/* Print Track Header */
if (options.oformat == 1) {
printf("track name=\"%s\" description=\"%s\" visibility=%s useScore=1\n", options.trackName, options.trackDesc, options.visibility);
} else if (options.oformat == 2) {
printf("track type=bedGraph name=\"%s\" description=\"%s\" visibility=%s color=%s autoScale=%s alwaysZero=%s maxHeightPixels=100:50:20 graphType=bar priority=30 windowingFunction=%s smoothingWindow=%s\n", options.trackName, options.trackDesc, options.visibility, options.trackColor, options.autoscale, options.always0, options.wfunction, options.smoothing);
}
#ifdef DEBUG
int c = 1;
#endif
while ((res = fgets(s, (int) bLen, input)) != NULL) {
size_t cLen = strlen(s);
char bed_fld[12][FIELD_MAX];
char strand = '\0';
char field[32];
int i = 0;
while (cLen + 1 == bLen && s[cLen - 1] != '\n') {
bLen *= 2;
if ((s = realloc(s, bLen)) == NULL) {
perror("process_file: realloc");
exit(1);
}
res = fgets(s + cLen, (int) (bLen - cLen), input);
cLen = strlen(s);
}
if (s[cLen - 1] == '\n')
s[cLen - 1] = 0;
else if (s[cLen - 1] == '\n' && s[cLen - 2] == '\r')
s[cLen - 2] = 0;
buf = s;
/* printf ("BED line : %s\n", s); */
/* Check line */
/* Get first word/field */
if ( sscanf(s, "%31[^ ]", field) == 1 ) {
if ( (strcmp(field, "track") == 0) || (strcmp(field, "browser") == 0) || (strcmp(field, "itemRgb") == 0) )
continue;
}
/* Get BED fields */
/* Chrom NB */
while (*buf != 0 && !isspace(*buf)) {
if (i >= CHR_NB) {
bed_fld[0][i] = 0;
fprintf(stderr, "Chrom NB too long \"%s\" Skipping line...\n", bed_fld[0]);
break;
}
bed_fld[0][i++] = *buf++;
}
if (i < AC_MAX)
bed_fld[0][i] = 0;
else
continue;
while (isspace(*buf))
buf++;
/* Start Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "Start position too large \"%s\" \n", buf);
exit(1);
}
bed_fld[1][i++] = *buf++;
}
bed_fld[1][i] = 0;
start = (unsigned long)atoi(bed_fld[1]);
while (isspace(*buf))
buf++;
/* End Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "End position too large \"%s\" \n", buf);
exit(1);
}
bed_fld[2][i++] = *buf++;
}
bed_fld[2][i] = 0;
end = (unsigned long)atoi(bed_fld[2]);
while (isspace(*buf))
buf++;
/* Name/Feature */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field Name too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[3][i++] = *buf++;
}
bed_fld[3][i] = 0;
while (isspace(*buf))
buf++;
/* Score */
i = 0;
while (isdigit(*buf) || *buf == '+' || *buf == '-' || *buf == '.') {
if (i >= SCORE_MAX) {
fprintf(stderr, "Score too large \"%s\" \n", buf);
exit(1);
}
bed_fld[4][i++] = *buf++;
}
bed_fld[4][i] = 0;
score = atoi(bed_fld[4]);
while (isspace(*buf))
buf++;
/* Field 6/Strand */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 6 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[5][i++] = *buf++;
}
bed_fld[5][i] = 0;
while (isspace(*buf))
buf++;
/* Field 7 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 7 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[6][i++] = *buf++;
}
bed_fld[6][i] = 0;
while (isspace(*buf))
buf++;
/* Field 8 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 8 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[7][i++] = *buf++;
}
bed_fld[7][i] = 0;
while (isspace(*buf))
buf++;
/* Field 9 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 9 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[8][i++] = *buf++;
}
bed_fld[8][i] = 0;
while (isspace(*buf))
buf++;
/* Field 10 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 10 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[9][i++] = *buf++;
}
bed_fld[9][i] = 0;
while (isspace(*buf))
buf++;
/* Field 11 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 11 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[10][i++] = *buf++;
}
bed_fld[10][i] = 0;
while (isspace(*buf))
buf++;
/* Field 12 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 12 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[11][i++] = *buf++;
}
bed_fld[11][i] = 0;
while (isspace(*buf))
buf++;
#ifdef DEBUG
printf(" [%d] Chr nb: %s Start: %lu End: %lu Name: %s Score: %d Strand: %c Field #7 %s Field #8 %s Field #9 %s Field #10 %s Field #11 %s Field #12 %s\n", c++, bed_fld[0], start, end, bed_fld[3], score, bed_fld[5], bed_fld[6], bed_fld[7], bed_fld[8], bed_fld[9], bed_fld[10], bed_fld[11]);
#endif
/* Set Strand field */
if (bed_fld[5][0] == '+' || bed_fld[5][0] == '-')
strand = bed_fld[5][0];
else
strand = '.';
/* Set Feature/Name field */
if (options.feature == NULL) {
if (bed_fld[3][0] != '\0') {
options.feature = malloc((strlen(bed_fld[3])+1) * sizeof(char));
strcpy(options.feature, bed_fld[3]);
}
}
/* Print out BED line */
if (options.oformat == 1) {
/* Rescale Score */
new_score = rescale_score(score);
printf("%s\t%lu\t%lu\t%s%d\t%d\t%c\n", bed_fld[0], start, end, options.feature, count, new_score, strand);
count++;
} else if (options.oformat == 2) {
printf("%s\t%lu\t%lu\t%d\n", bed_fld[0], start, end, score);
}
} /* End of While */
if (input != stdin) {
fclose(input);
}
return 0;
}
int
main(int argc, char *argv[])
{
#ifdef DEBUG
mcheck(NULL);
mtrace();
#endif
FILE *input;
int i = 0;
int usage = 0;
options.oformat = 1;
static struct option long_options[] =
{
/* These options may or may not set a flag.
We distinguish them by their indices. */
{"debug", no_argument, 0, 'd'},
{"help", no_argument, 0, 'h'},
{"feature", required_argument, 0, 'f'},
{"oformat", required_argument, 0, 'o'},
{"minscore", required_argument, 0, 'a'},
{"maxscore", required_argument, 0, 'b'},
{"name", required_argument, 0, 0 },
{"desc", required_argument, 0, 0 },
{"color", required_argument, 0, 0 },
{"autoscale", required_argument, 0, 0 },
{"always0", required_argument, 0, 0 },
{"wfunction", required_argument, 0, 0 },
{"smoothing", required_argument, 0, 0 },
{"visibility", required_argument, 0, 0 },
{0, 0, 0, 0}
};
int option_index = 0;
while (1) {
int c = getopt_long(argc, argv, "dhf:a:b:o:", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'd':
options.debug = 1;
break;
case 'h':
options.help = 1;
break;
case 'f':
options.feature = optarg;
break;
case 'a':
minScore = atoi(optarg);
break;
case 'b':
maxScore = atoi(optarg);
break;
case 'o':
options.oformat = atoi(optarg);
break;
case 0:
/* This option is to set the annotation track line */
if (strcmp(long_options[option_index].name, "name") == 0) {
options.trackName = optarg;
}
if (strcmp(long_options[option_index].name, "desc") == 0) {
options.trackDesc = optarg;
}
if (strcmp(long_options[option_index].name, "color") == 0) {
options.trackColor = optarg;
}
if (strcmp(long_options[option_index].name, "autoscale") == 0) {
options.autoscale = optarg;
}
if (strcmp(long_options[option_index].name, "always0") == 0) {
options.always0 = optarg;
}
if (strcmp(long_options[option_index].name, "wfunction") == 0) {
options.wfunction = optarg;
}
if (strcmp(long_options[option_index].name, "smoothing") == 0) {
options.smoothing = optarg;
}
if (strcmp(long_options[option_index].name, "visibility") == 0) {
options.visibility = optarg;
}
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
usage = 1;
}
}
if (optind > argc || options.help == 1 || usage || minScore == -1 || maxScore == -1) {
fprintf(stderr, "Usage: %s [options] [-a ] [-b ] [<] \n"
" - version %s\n"
" where options are:\n"
" \t\t -d|--debug Produce Debug information\n"
" \t\t -h|--help Show this Help text\n"
" \t\t -f|--feature Set Feature name \n"
" \t\t -o|--oformat <1|2> Set output Format (1:BED[Def] 2:BedGraph)\n"
" \t\t --name Set name for track name field [def. name=SGA-feature]\n"
" \t\t --desc Set track description field [def. desc=\"ChIP-Seq Custom data\"]\n"
" \t\t --color Define the track color in comma-separated RGB values [def. 100,100,100]\n"
" \t\t --autoscale Data viewing paramenter: set auto-scale to UCSC data view [def=OFF]\n"
" \t\t --always0 Data viewing paramenter: always include zero [def=OFF]\n"
" \t\t --wfunction Data viewing paramenter: windowing function [def=mean+whiskers|maximum|mean|minimum]\n"
" \t\t --smoothing Data viewing paramenter: smoothing window [def=OFF[0], =0,2..16]\n"
" \t\t --visibility Display mode: [def=dense|full|hide] or [def=1|2|3]\n"
"\n\tConvert BED file to BED format suitable for displaying ChIP-seq peaks.\n"
" \tTwo formats are supported: 1) BED Track with Score field; 2) BedGraph.\n"
" \tFor BED track format, only the graphical parameter 'visibility' can be set.\n\n",
argv[0], VERSION);
return 1;
}
if (argc > optind) {
if(!strcmp(argv[optind],"-")) {
input = stdin;
} else {
input = fopen(argv[optind], "r");
if (NULL == input) {
fprintf(stderr, "Unable to open '%s': %s(%d)\n",
argv[optind], strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", argv[optind]);
}
} else {
input = stdin;
}
if (options.feature != NULL) {
char *s = options.feature;
i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature Name too long \"%s\" \n", options.feature);
return 1;
}
s++;
}
}
if (options.trackName == NULL) {
if (options.feature != NULL) {
if ((options.trackName = malloc((strlen(options.feature) + 1) * sizeof(char))) == NULL) {
perror("process_sga: malloc Feature");
exit(1);
}
strcpy(options.trackName, options.feature);
} else {
if ((options.trackDesc = malloc(24 * sizeof(char))) == NULL) {
perror("main: malloc trackDesc");
exit(1);
}
strcpy(options.trackName, "ChIP-SeqPeaks");
}
}
if (options.trackDesc == NULL) {
if ((options.trackDesc = malloc(32 * sizeof(char))) == NULL) {
perror("main: malloc trackDesc");
exit(1);
}
strcpy(options.trackDesc, "ChIP-Seq Custom data");
}
if (options.trackColor == NULL) {
if ((options.trackColor = malloc(12 * sizeof(char))) == NULL) {
perror("main: malloc trackColor");
exit(1);
}
strcpy(options.trackColor, "0,200,100");
}
if (options.autoscale == NULL) {
if ((options.autoscale = malloc(4 * sizeof(char))) == NULL) {
perror("main: malloc autoscale");
exit(1);
}
strcpy(options.autoscale, "off");
}
if (options.always0 == NULL) {
if ((options.always0 = malloc(4 * sizeof(char))) == NULL) {
perror("main: malloc always0");
exit(1);
}
strcpy(options.always0, "off");
}
if (options.wfunction == NULL) {
if ((options.wfunction = malloc(5 * sizeof(char))) == NULL) {
perror("main: malloc wfunction");
exit(1);
}
strcpy(options.wfunction, "mean");
}
if (options.smoothing == NULL) {
if ((options.smoothing = malloc(4 * sizeof(char))) == NULL) {
perror("main: malloc smoothing");
exit(1);
}
strcpy(options.smoothing, "off");
}
if (options.visibility == NULL) {
if ((options.visibility = malloc(5 * sizeof(char))) == NULL) {
perror("main: malloc visibility");
exit(1);
}
if (options.oformat == 1) {
strcpy(options.visibility, "1");
} else if (options.oformat == 2) {
strcpy(options.visibility, "dense");
}
}
if (options.debug) {
fprintf(stderr, " Arguments:\n");
if (options.feature != NULL)
fprintf(stderr, " Feature : %s\n", options.feature);
fprintf(stderr, " Minimal BED Score: %d\n", minScore);
fprintf(stderr, " maximal BED score: %d\n", maxScore);
if (options.oformat == 1) {
fprintf(stderr, " BED Track Display options:\n");
fprintf(stderr, " Visibility: %s\n", options.visibility);
fprintf(stderr, " useScore=1\n");
} else if (options.oformat == 2) {
fprintf(stderr, " BedGraph Track Display options:\n");
fprintf(stderr, " -----------------------------\n");
fprintf(stderr, " Track name: %s\n", options.trackName);
fprintf(stderr, " Track description: %s\n", options.trackDesc);
fprintf(stderr, " Track color: %s\n", options.trackColor);
fprintf(stderr, " Autoscale: %s\n", options.autoscale);
fprintf(stderr, " Always0: %s\n", options.always0);
fprintf(stderr, " Wfunction: %s\n", options.wfunction);
fprintf(stderr, " Smoothing: %s\n", options.smoothing);
fprintf(stderr, " Visibility: %s\n", options.visibility);
}
}
if (process_bed(input, argv[optind++]) != 0) {
return 1;
}
return 0;
}
chip-seq/tools/eland2sga.pl 0000744 0227442 0026227 00000010452 11553015221 016412 0 ustar ambrosin gr-bucher #!/usr/local/bin/perl
# transform ChIP-seq eland mappings via hash variable into sorted sga
# usage: eland2sga.pl -a feature -s species -f eland_file
use strict;
use Storable qw (retrieve nstore); # package to store persistently variables in files [http://search.cpan.org/author/AMS/Storable-2.07/Storable.pm]
use Getopt::Std;
my %opts;
getopt('asf:', \%opts); # -a, -s, & -f take arg. Values in %opts, Hash keys will be the switch names
die("\nusage: eland2sga.pl -a feature -s species -f eland_file\n\n") unless (($opts{'f'})&&($opts{'a'})&&($opts{'s'}));
# hash defining chromosome from SV of chromosomes in current genome assemblies
my $DB = "/db/genome/";
#my $DB = "/home/local/db/genome/";
my $chr2AC = retrieve($DB."chro_idx.nstorage");
# eventually add older assemblies?
my $species=$opts{'s'};
die ("Sorry, $species is not a supported species!\n\n") unless ($chr2AC->{$species});
my ($score_ref);
open(FI, "$opts{'f'}") or die ("Cannot open $opts{'f'}: $!\n") ;
while(){
my $lin=$_;
chomp $lin;
my @ar=split(/\t/,$lin);
$ar[6] =~ s/^.+hromosome\.//;
$ar[6] =~ s/\.fa$//;
# my ($chr)= $ar[6] =~ /hromosome.([0-9RLYX]+).fa/;
my $chr = 'chr'.$ar[6];
if (exists($chr2AC->{$species}->{$chr})){
# attribute each tag to its start position and increment counter (multiple column formats)
# >EAS38_3_1_526_564 TGTTCTCTGCATGCTATTTTTTAGTATTGCCGTAA U0 1 0 0 Mus_musculus.NCBIM37.48.dna.chromosome.15.fa 15876793 R ..
#.bed: chr12 119248213 119248236 U0 0 +
if ($ar[8] eq 'F'){
$score_ref->{$chr2AC->{$species}->{$chr}}->{'+'}->{$ar[7]} +=1;
}
elsif ($ar[8] eq 'R'){
my $pos=$ar[7] + length($ar[1]);
$score_ref->{$chr2AC->{$species}->{$chr}}->{'-'}->{$pos} +=1;
}
else{
warn "parsing error of orientation in following line:\n$lin\n";
}
# attribute counts to its center position and record in hash (force into numeric)
# $score_ref->{$chr2AC{$ar[0]}}->{int(($ar[1]+$ar[2])/2)}=eval($ar[3]);
}
else{
# warn "parsing error of chromosome number in following line:\n$lin\n";
}
}
close(FI);
#nstore (\$score_ref, "/scratch/frt/cschmid/EMO-4_bed_ori.nstorage");
my @chr;
my $spec='T'; # flag
foreach my $ac(keys %$score_ref){
unless (($spec eq 'T')||($spec eq $chr2AC->{'assembly'}->{$ac})){
die "The file $opts{'f'} contains entries from both $spec and from ",$chr2AC->{'assembly'}->{$ac}," (chromosome $ac)\n";
}
$species = $chr2AC->{'assembly'}->{$ac};
$chr2AC->{$ac} =~ s/chr//;
push(@chr, $chr2AC->{$ac});
}
# order chromosome array as in sga files
my @chrb = sort {$a<=>$b} @chr;
my (@spl,$sc);
foreach $sc('X','Y'){
if ($chrb[0] eq $sc){
push(@spl, shift(@chrb));
}
}
push(@chrb,@spl);
foreach my $chro(@chrb){
# foreach position with data, print out counts in sga format:
# versioned genome sequence ID
# feature type
# position
# strand (+, -, or 0 for un-oriented features)
# tag count (or signal intensity, positive int)
my @arr=keys %{$score_ref->{$chr2AC->{$species}->{'chr'.$chro}}->{'+'}};
push @arr,keys %{$score_ref->{$chr2AC->{$species}->{'chr'.$chro}}->{'-'}};
my %double; # hash to control for positions with tags in both ori
foreach my $pos(sort {$a <=> $b} @arr){
if ((exists($score_ref->{$chr2AC->{$species}->{'chr'.$chro}}->{'+'}->{$pos}))&&(!$double{$pos})){
print $chr2AC->{$species}->{'chr'.$chro},"\t$opts{'a'}\t$pos\t+\t",$score_ref->{$chr2AC->{$species}->{'chr'.$chro}}->{'+'}->{$pos},"\n";
$double{$pos}='T';
}
elsif (exists($score_ref->{$chr2AC->{$species}->{'chr'.$chro}}->{'-'}->{$pos})){
print $chr2AC->{$species}->{'chr'.$chro},"\t$opts{'a'}\t$pos\t-\t",$score_ref->{$chr2AC->{$species}->{'chr'.$chro}}->{'-'}->{$pos},"\n";
}
else{
print "trouble for position $pos on chro 'chr'.$chro: no tags in either orientation??\n";
die;
}
}
# read length of chromosome from /db/genome/eukaryote.ptr
my $line = `grep $chr2AC->{$species}->{'chr'.$chro} /db/genome/eukaryote.ptr`;
my @ar = split(/\s+/, $line);
print "$ar[0]\tEND\t$ar[2]\t0\t1\n";
# grep 'Mm/ch' /db/genome/eukaryote.ptr| perl -ane 'if (/^\w+\_\d+\.\d+\s+/){@ar=split/\s+/;print "$ar[0]\tEND\t$ar[2]\t0\t1\n";}'
}
1;
chip-seq/tools/fps2sga.pl 0000744 0227442 0026227 00000005675 12632304700 016134 0 ustar ambrosin gr-bucher #!/usr/bin/perl
# converts fps format to sga format
# usage: ./fps2sga.pl [-f -s <-x extended SGA>]
use strict;
use Getopt::Long;
my %opt;
my @options = ("help", "h", "species=s", "s=s", "feature=s", "f=s", "x", "ignore0flag");
my $file = "";
my $species = "";
my $feature = "CHIP";
my $extended = 0;
my $ignore0flag = 0;
if( ! GetOptions( \%opt, @options ) ) { &Usage(); }
&Usage() if defined($opt{'help'}) || defined($opt{'h'});
&Usage() if $#ARGV < 0;
if ($opt{'f'} ne '') {
$feature = $opt{'f'};
}
if ($opt{'feature'} ne '') {
$feature = $opt{'feature'};
}
if ($opt{'s'} ne '') {
$species = $opt{'s'};
}
if ($opt{'species'} ne '') {
$species = $opt{'species'};
}
if ($opt{'x'} ne '') {
$extended = 1;
}
if ($opt{'ignore0flag'} ne '') {
$ignore0flag = 1;
}
$file = $ARGV[0];
#print "FPS file : $file\n";
#print "Options: feature : $feature, Species $species\n";
#my $err_cnt = 0;
my $tot_lines = 0;
open(IN, "$file") or die ("Cannot open $file: $!\n") ;
while(){
#FP H3K36me1_1 :+U EU:NC_000001.9 1- 532614; 99999.
# if (/FP (.{20}):[-+][SMRU ] EU:(N[TC]_\d+\.?\d*)\s+[01]([-+])\s*(\d+)(;.+)/){
next if /#/;
next if (!/^FP/);
my @fps_fields = unpack('a5 a20 a5 a3 a18 a1 a1 a10 a7', $_);
#if (/FP (.{20}):[-+][SMRU ](\d|\s) EU:(N[TC]_\d+\.?\d*)\s+[01]([-+])\s*(\d{10})(.+)/) {
#my $counts=(split(/_/,$1))[1];
my $counts = "";
my $strand = "";
my $desc = $fps_fields[1];
my $id = $fps_fields[4];
my $pos = $fps_fields[7];
$desc =~ s/\s+//g;
$id =~ s/\s+//g;
$pos =~ s/\s+//g;
$counts = 1 if ($counts eq '');
if ($ignore0flag) {
$strand = $fps_fields[6];
} else {
if ($2 eq 0) {
$strand = '0';
} else {
$strand = $fps_fields[6];
}
}
if ($extended) {
$desc =~ s/\s+$//;
print "$id\t".$feature."\t$pos\t$strand\t$counts\t$desc\n";
} else {
print "$id\t".$feature."\t$pos\t$strand\t$counts\n";
}
$tot_lines++;
}
close(IN);
#if ($err_cnt) {
# print STDERR "\nWarning : Out of a total of $tot_lines FP lines, $err_cnt lines could not be mapped to the genome.\n\nPlease, check that the functional position reference is a genomic coordinate.\nThe accepted genome db code and entry number are the following:\n EU:N[TC]_\d+\.?\d*\n";
#}
sub Usage {
print STDERR <<"_USAGE_";
fps2sga.pl [options]
where options are:
-h|--help Show this stuff
-f|--feature Set Feature name
-s|--species Assembly (i.e hg18)
-x Generate an extended SGA file with the
6th field equal to the FPS 'description' field
--ignore0flag Ignore 0 flag at position 29 of the FP line,
so keep orientation the same as original
_USAGE_
exit(1);
}
1;
chip-seq/tools/version.h 0000777 0227442 0026227 00000000000 13354703337 020133 2../version.h ustar ambrosin gr-bucher chip-seq/tools/bed2sga.c 0000744 0227442 0026227 00000053346 13350730441 015706 0 ustar ambrosin gr-bucher /*
bed2sga.c
Convert BED file to SGA format.
# Arguments:
# BED File
# Species (e.g. hg19)
# Options:
# Set Path to locate chr_NC_gi file
# (used for chrom name to NCBI id conversion)
# Set Feature name
# Center SGA file
# Unoriented SGA file
# Extended SGA file
# Use BED score field to set SGA count field
# Input is ENCODE narrowPeak format
Giovanna Ambrosini, EPFL/ISREC, Giovanna.Ambrosini@epfl.ch
Copyright (c) 2014 EPFL and Swiss Institute of Bioinformatics.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
#define DEBUG
*/
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "hashtable.h"
#ifdef DEBUG
#include
#endif
#include "version.h"
#define BUF_SIZE 8192
#define LINE_SIZE 1024
#define FT_MAX 64
#define CHR_NB 18
#define AC_MAX 18
#define POS_MAX 16
#define SCORE_MAX 12
#define NAME_MAX 128
#define FIELD_MAX 64
typedef struct _options_t {
char *dbPath;
char *extField;
int help;
int debug;
int db;
int useScore;
int useSigVal;
int center;
int unoriented;
int extend;
int narrowPeak;
int regional;
} options_t;
static options_t options;
static hash_table_t *ac_table = NULL;
char *Species = NULL;
char *Feature = NULL;
int check_name_flag = 0;
int extIdx[10];
int extLen = 0;
int
process_ac()
{
FILE *input;
int c;
char buf[LINE_SIZE];
char *chrFile;
char chrom[12];
int cLen;
int break_flag = 0;
int read_chr_nc = 0;
if (options.db) {
/*cLen = (int)strlen(options.dbPath) + (int)strlen(Species) + 12;*/
cLen = (int)strlen(options.dbPath) + 12;
if ((chrFile = (char*)malloc(cLen * sizeof(char))) == NULL) {
perror("process_ac: malloc");
exit(1);
}
strcpy(chrFile, options.dbPath);
} else {
/*cLen = 21 + (int)strlen(Species) + 12;*/
cLen = 21 + 12;
if ((chrFile = (char*)malloc(cLen * sizeof(char))) == NULL) {
perror("process_ac: malloc");
exit(1);
}
strcpy(chrFile, "/home/local/db/genome");
}
/* strcat(chrFile, "/"); */
/*strcat(chrFile, Species); */
strcat(chrFile, "/chr_NC_gi");
input = fopen(chrFile, "r");
if (input == NULL) {
fprintf(stderr, "Could not open file %s: %s(%d)\n",
chrFile, strerror(errno), errno);
return 1;
}
do {
c = fgetc(input);
} while(c != '\n');
ac_table = hash_table_new(MODE_COPY);
while (fgets(buf, LINE_SIZE, input) != NULL) {
char *s;
char chr_nb[CHR_NB] = "";
char ncbi_ac[AC_MAX] = "";
char field[128];
int i = 0;
int nb_len = 0;
int ac_len = 0;
s = buf;
/* Check line */
/* Get first character: if (char=# and not break_flag) check species */
/* printf ("chr_NC_gi line : %s\n", s); */
if (*s == '#') {
if (!break_flag) {
/* Get first word */
s++;
if ( sscanf(s, "%127[^\t]", field) == 1 ) {
/* printf ("field: %s Species: %s\n", field, Species); */
if ((strcmp(field, Species) == 0)) {
/* printf ("setting flags read_chr_nc break_flag...\n"); */
read_chr_nc = 1;;
break_flag = 1;
} else {
/* printf ("next line...\n"); */
continue;
}
}
} else {
break;
}
}
if (read_chr_nc) {
/* Chrom NB */
while (*s != 0 && !isspace(*s)) {
if (i >= CHR_NB) {
fprintf(stderr, "Chrom NB too long in %s\n", s);
fclose(input);
exit(1);
}
chr_nb[i++] = *s++;
}
if (i < CHR_NB)
chr_nb[i] = 0;
nb_len = i + 1;
while (isspace(*s))
s++;
/* Chromosome NCBI AC */
i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= AC_MAX) {
fprintf(stderr, "AC too long \"%s\" \n", s);
fclose(input);
exit(1);
}
ncbi_ac[i++] = *s++;
}
if (i < AC_MAX)
ncbi_ac[i] = 0;
ac_len = i + 1;
strcpy(chrom, "chr");
strcat(chrom, chr_nb);
nb_len = (int)strlen(chrom) + 1;
/* printf("adding key %s (len = %d) value %s (ac) (len = %d) to hash table\n", chrom, nb_len, ncbi_ac, ac_len); */
/* Store both chromosome number to NCBI identifier and NCBI identifier to NCBI identifier keys */
hash_table_add(ac_table, chrom, (size_t)nb_len, ncbi_ac, (size_t)ac_len);
if (options.debug) {
char *ac = hash_table_lookup(ac_table, chrom, (size_t)nb_len);
fprintf (stderr, " AC Hash table: %s (len = %d) -> %s (len = %d)\n", chrom, nb_len, ac, ac_len);
}
hash_table_add(ac_table, ncbi_ac, (size_t)ac_len, ncbi_ac, (size_t)ac_len);
if (options.debug) {
char *ac = hash_table_lookup(ac_table, ncbi_ac, (size_t)ac_len);
fprintf (stderr, " AC Hash table: %s (len = %d) -> %s (len = %d)\n", ncbi_ac, ac_len, ac, ac_len);
}
}
}
return 0;
}
int
process_bed(FILE *input, char *iFile)
{
unsigned long start, end;
int score;
char *s, *res, *buf;
size_t bLen = LINE_SIZE;
if (options.debug)
fprintf(stderr, " Processing BED file %s\n", iFile);
if ((s = malloc(bLen * sizeof(char))) == NULL) {
perror("process_bed: malloc");
exit(1);
}
#ifdef DEBUG
int c = 1;
#endif
while ((res = fgets(s, (int) bLen, input)) != NULL) {
size_t cLen = strlen(s);
char bed_fld[12][FIELD_MAX];
char ext_buf[LINE_SIZE];
char strand = '\0';
char field[32];
float signal_val = 0.0;
unsigned long pos = 0;
unsigned long pos2 = 0;
int count = 0;
int id_len = 0;
char *ac;
int i = 0;
while (cLen + 1 == bLen && s[cLen - 1] != '\n') {
bLen *= 2;
if ((s = realloc(s, bLen)) == NULL) {
perror("process_file: realloc");
exit(1);
}
res = fgets(s + cLen, (int) (bLen - cLen), input);
cLen = strlen(s);
}
if (s[cLen - 1] == '\n')
s[cLen - 1] = 0;
else if (s[cLen - 1] == '\n' && s[cLen - 2] == '\r')
s[cLen - 2] = 0;
buf = s;
/* printf ("BED line : %s\n", s); */
/* Check line */
/* Get first word/field */
if ( sscanf(s, "%31[^ ]", field) == 1 ) {
if ( (strcmp(field, "track") == 0) || (strcmp(field, "browser") == 0) || (strcmp(field, "itemRgb") == 0) )
continue;
}
/* Get BED fields */
/* Chrom NB */
while (*buf != 0 && !isspace(*buf)) {
if (i >= CHR_NB) {
bed_fld[0][i] = 0;
fprintf(stderr, "Chrom NB too long \"%s\" Skipping line...\n", bed_fld[0]);
break;
}
bed_fld[0][i++] = *buf++;
}
if (i < AC_MAX)
bed_fld[0][i] = 0;
else
continue;
while (isspace(*buf))
buf++;
/* Start Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "Start position too large \"%s\" \n", buf);
exit(1);
}
bed_fld[1][i++] = *buf++;
}
bed_fld[1][i] = 0;
start = (unsigned long)atoi(bed_fld[1]);
while (isspace(*buf))
buf++;
/* End Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "End position too large \"%s\" \n", buf);
exit(1);
}
bed_fld[2][i++] = *buf++;
}
bed_fld[2][i] = 0;
end = (unsigned long)atoi(bed_fld[2]);
while (isspace(*buf))
buf++;
/* Name */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field Name too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[3][i++] = *buf++;
}
bed_fld[3][i] = 0;
while (isspace(*buf))
buf++;
/* Score */
i = 0;
while (isdigit(*buf) || *buf == '+' || *buf == '-' || *buf == '.') {
if (i >= SCORE_MAX) {
fprintf(stderr, "Score too large \"%s\" \n", buf);
exit(1);
}
bed_fld[4][i++] = *buf++;
}
bed_fld[4][i] = 0;
score = atoi(bed_fld[4]);
while (isspace(*buf))
buf++;
/* Field 6/Strand */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 6 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[5][i++] = *buf++;
}
bed_fld[5][i] = 0;
while (isspace(*buf))
buf++;
/* Field 7 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 7 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[6][i++] = *buf++;
}
bed_fld[6][i] = 0;
while (isspace(*buf))
buf++;
/* Field 8 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 8 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[7][i++] = *buf++;
}
bed_fld[7][i] = 0;
while (isspace(*buf))
buf++;
/* Field 9 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 9 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[8][i++] = *buf++;
}
bed_fld[8][i] = 0;
while (isspace(*buf))
buf++;
/* Field 10 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 10 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[9][i++] = *buf++;
}
bed_fld[9][i] = 0;
while (isspace(*buf))
buf++;
/* Field 11 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 11 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[10][i++] = *buf++;
}
bed_fld[10][i] = 0;
while (isspace(*buf))
buf++;
/* Field 12 */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FIELD_MAX) {
fprintf(stderr, "Field 12 too long \"%s\" \n", buf);
fclose(input);
exit(1);
}
bed_fld[11][i++] = *buf++;
}
bed_fld[11][i] = 0;
while (isspace(*buf))
buf++;
#ifdef DEBUG
printf(" [%d] Chr nb: %s Start: %lu End: %lu Name: %s Score: %s Strand: %c Field #7 %s Field #8 %s Field #9 %s Field #10 %s Field #11 %s Field #12 %s\n", c++, bed_fld[0], start, end, bed_fld[3], score, bed_fld[5], bed_fld[6], bed_fld[7], bed_fld[8], bed_fld[9], bed_fld[10], bed_fld[11]);
#endif
/* Set SGA Strand field */
if (!options.regional) {
if (bed_fld[5][0] == '+' || bed_fld[5][0] == '-')
strand = bed_fld[5][0];
else
strand = '0';
}
/* Set SGA Feature field */
if (check_name_flag) {
if (bed_fld[3][0] != '\0')
strcpy(Feature, bed_fld[3]);
}
count = 1;
if (!options.narrowPeak) {
/* Set SGA Position field */
if (options.regional) { /* Set star (line +) and end positions (line -) */
pos = start + 1;
pos2 = end;
} else {
if (options.center) {
pos = (unsigned long)((long double)(start + end)/2 + 0.5);
/* Set strand to zero - no strand */
//if ((strand == '\0') || (strand == '.') || (options.unoriented)) {
if (options.unoriented) {
strand = '0';
}
} else {
if (strand == '+') {
pos = start + 1;
} else if (strand == '-') {
pos = end;
} else { /* BED file has no strand: Center position */
pos = (unsigned long)((long double)(start + end)/2 + 0.5);
/* printf ("Start %lu End %lu Position %lu\n", start, end, pos); */
strand = '0';
}
}
}
/* Set SGA Count field */
if (options.useScore) { /* Use BED score field to set SGA count field */
count = score;
}
} else { /* ENCODE narrowPeak format */
/* Set SGA Position field */
long peak_offset = (long)atoi(bed_fld[9]);
if (peak_offset == -1) {
pos = (unsigned long)((long double)(start + end)/2 + 0.5);
strand = '0';
} else {
pos = start + peak_offset + 1;
}
/* Set SGA Count field */
if (options.useSigVal) { /* Use BED signalValue field to set SGA count field */
signal_val = atof(bed_fld[6]);
count = (int)(signal_val + 0.5);
}
}
/* Check for extension option */
if (options.extend) {
/* printf (" Extended fileds: %d\n", extLen); */
/* printf (" concatenating field: %d\n", extIdx[0]); */
strcpy(ext_buf, bed_fld[extIdx[0]-1]);
for (i = 1; i < extLen; i++) {
/* printf (" concatenating field: %d %s\n", extIdx[i], bed_fld[extIdx[i]-1]); */
strcat(ext_buf, "\t");
strcat(ext_buf, bed_fld[extIdx[i]-1]);
}
/* printf(" Extended fields: %s\n", ext_buf); */
if (options.debug)
fprintf(stderr, " Extended fields: %s\n", ext_buf);
}
if (Species != NULL) {
id_len = (int)strlen(bed_fld[0]) + 1;
ac = hash_table_lookup(ac_table, bed_fld[0], (size_t)id_len);
if (ac == NULL)
continue;
} else {
ac = malloc (strlen(bed_fld[0]) + 1);
strcpy(ac, bed_fld[0]);
}
/* Print out SGA line(s) */
if (options.regional) { /* 2-line SGA format */
if (options.extend) {
printf("%s\t%s\t%lu\t+\t%d\t%s\n", ac, Feature, pos, count, ext_buf);
printf("%s\t%s\t%lu\t-\t%d\t%s\n", ac, Feature, pos2, count, ext_buf);
} else {
printf("%s\t%s\t%lu\t+\t%d\n", ac, Feature, pos, count);
printf("%s\t%s\t%lu\t-\t%d\n", ac, Feature, pos, count);
}
} else {
if (options.extend) {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n", ac, Feature, pos, strand, count, ext_buf);
} else {
printf("%s\t%s\t%lu\t%c\t%d\n", ac, Feature, pos, strand, count);
}
}
} /* End of While */
if (input != stdin) {
fclose(input);
}
return 0;
}
char** str_split(char* a_str, const char a_delim)
{
char** result = 0;
size_t count = 0;
char* tmp = a_str;
char* last_comma = 0;
char delim[2];
delim[0] = a_delim;
delim[1] = 0;
/* Count how many elements will be extracted. */
while (*tmp) {
if (a_delim == *tmp) {
count++;
last_comma = tmp;
}
tmp++;
}
/* Add space for trailing token. */
count += last_comma < (a_str + strlen(a_str) - 1);
/* Add space for terminating null string so caller
knows where the list of returned strings ends. */
count++;
result = malloc(sizeof(char*) *count);
if (result) {
size_t idx = 0;
char* token = strtok(a_str, delim);
while (token) {
assert(idx < count);
*(result + idx++) = strdup(token);
token = strtok(0, delim);
}
assert(idx == count - 1);
*(result + idx) = 0;
}
return result;
}
int
main(int argc, char *argv[])
{
char** tokens;
#ifdef DEBUG
mcheck(NULL);
mtrace();
#endif
FILE *input;
int i = 0;
int usage = 0;
static struct option long_options[] =
{
/* These options may or may not set a flag.
We distinguish them by their indices. */
{"debug", no_argument, 0, 'd'},
{"help", no_argument, 0, 'h'},
{"db", required_argument, 0, 'i'},
{"feature", required_argument, 0, 'f'},
{"species", required_argument, 0, 's'},
{"extend", required_argument, 0, 'e'},
{"center", no_argument, 0, 'c'},
{"unoriented", no_argument, 0, 'u'},
{"regional", no_argument, 0, 'r'},
/* These options only set a flag. */
{"useScore", no_argument, &options.useScore, 1},
{"useSigVal", no_argument, &options.useSigVal, 1},
{"narrowPeak", no_argument, &options.narrowPeak, 1},
{0, 0, 0, 0}
};
int option_index = 0;
while (1) {
int c = getopt_long(argc, argv, "dhf:i:s:cure:", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'd':
options.debug = 1;
break;
case 'h':
options.help = 1;
break;
case 'i':
options.dbPath = optarg;
options.db = 1;
break;
case 'f':
Feature = optarg;
break;
case 's':
Species = optarg;
break;
case 'c':
options.center = 1;
break;
case 'e':
options.extField = optarg;
options.extend = 1;
break;
case 'u':
options.unoriented = 1;
break;
case 'r':
options.regional = 1;
break;
case 0:
/* If this option set a flag, do nothing else now. */
if (long_options[option_index].flag != 0)
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
usage = 1;
}
}
if (optind > argc || options.help == 1 || usage) {
fprintf(stderr, "Usage: %s [options] [-s ] [<] \n"
" - version %s\n"
" where options are:\n"
" \t\t -d|--debug Produce Debug information\n"
" \t\t -h|--help Show this Help text\n"
" \t\t -i|--db Use to locate the assembly-specific chr_NC_gi file\n"
" \t\t [default is: $HOME/db/genome]\n"
" \t\t -f|--feature Set Feature name \n"
" \t\t -s|--species Assembly (i.e hg19)\n"
" \t\t -c|--center Generate a Centered SGA file\n"
" \t\t -u|--unoriented Generate an unoriented SGA file\n"
" \t\t -r|--regional Generate a 2-line[+/-] SGA file representing BED regions\n"
" \t\t (e.g. RepeatMasker regions)\n"
" \t\t -e|--extend Produce an extended SGA file with additional fields specified\n"
" \t\t by a comma-separated list of BED column numbers (from 1 to n)\n"
" \t\t --useScore Use the BED 'score' field (#5) to set the SGA 'count' field\n"
" \t\t --useSigVal Use the BED 'Signal Value' field (#7) to set the SGA 'count' field\n"
" \t\t [This option is only valid for ENCODE narrowPeak]\n"
" \t\t --narrowPeak Use this option for ENCODE narrowPeak format\n"
" \t\t [Options --useScore, -c, and -u are ignored]\n"
"\n\tConvert BED format into SGA format.\n\n",
argv[0], VERSION);
return 1;
}
if (argc > optind) {
if(!strcmp(argv[optind],"-")) {
input = stdin;
} else {
input = fopen(argv[optind], "r");
if (NULL == input) {
fprintf(stderr, "Unable to open '%s': %s(%d)\n",
argv[optind], strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", argv[optind]);
}
} else {
input = stdin;
}
if (Feature == NULL) {
if ((Feature = malloc(6 * sizeof(char))) == NULL) {
perror("main: malloc Feature");
exit(1);
}
strcpy(Feature, "chIP");
check_name_flag = 1;
} else {
char *s = Feature;
i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature Name too long \"%s\" \n", Feature);
return 1;
}
s++;
}
}
if (options.narrowPeak) {
options.center = 0;
options.unoriented = 0;
options.useScore = 0;
} else {
options.useSigVal = 0;
}
if (options.regional) {
options.center = 0;
options.unoriented = 0;
}
if (options.extend) {
tokens = str_split(options.extField, ',');
if (tokens) {
for (i = 0; *(tokens + i); i++) {
extIdx[i] = atoi(*(tokens + i));
free(*(tokens + i));
}
extLen = i;
if (options.debug) {
fprintf(stderr, " Number of TOKENS: %d\n", extLen);
}
free(tokens);
}
}
if (options.debug) {
fprintf(stderr, " Arguments:\n");
fprintf(stderr, " Feature : %s\n", Feature);
if (Species != NULL)
fprintf(stderr, " Species : %s\n", Species);
fprintf(stderr, " Centered SGA [on/off]: %d\n", options.center);
fprintf(stderr, " Unoriented SGA [on/off]: %d\n", options.unoriented);
fprintf(stderr, " Extended SGA [on/off]: %d. BED fields:", options.extend);
for (i = 0; i < extLen; i++) {
if (i == (extLen - 1)) {
fprintf(stderr, " %d", extIdx[i]);
} else {
fprintf(stderr, " %d,", extIdx[i]);
}
}
fprintf(stderr, "\n");
fprintf(stderr, " Use Score [on/off]: %d\n", options.useScore);
fprintf(stderr, " NarrowPeak format [on/off]: %d\n", options.narrowPeak);
fprintf(stderr, " Use Signal Value [on/off]: %d\n", options.useSigVal);
}
if (Species != NULL) {
if (process_ac() == 0) {
if (options.debug)
fprintf(stderr, " HASH Table for chromosome access identifier initialized\n");
} else {
return 1;
}
}
if (process_bed(input, argv[optind++]) != 0) {
return 1;
}
return 0;
}
chip-seq/tools/compactsga.c 0000744 0227442 0026227 00000014062 13301537674 016521 0 ustar ambrosin gr-bucher /*
compactsga.c
Merge equal tag positions within a SGA File
# Arguments:
# SGA file
Giovanna Ambrosini, EPFL/ISREC, Giovanna.Ambrosini@epfl.ch
Copyright (c) 2014 EPFL and Swiss Institute of Bioinformatics.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
#define DEBUG
*/
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#ifdef DEBUG
#include
#endif
#include "version.h"
/*#define BUF_SIZE 4096 */
#define BUF_SIZE 8192
#define LINE_SIZE 1024
#define FT_MAX 64
#define SEQ_ID 32
#define POS_MAX 16
#define CNT_MAX 16
#define EXT_MAX 256
typedef struct _options_t {
int help;
int debug;
} options_t;
static options_t options;
/*
int
process_sga(char *iFile)
*/
int
process_sga()
{
/*
FILE *f = fopen(iFile, "r");
*/
unsigned long pos;
char chr[SEQ_ID] = "";
unsigned long p = 0;
int tc = 0;
int cnt = 0;
char ft[FT_MAX] = "";
char str = '\0';
char desc[EXT_MAX] = "";
char *s, *res, *buf;
size_t bLen = LINE_SIZE;
/*
if (f == NULL) {
fprintf(stderr, "Could not open file %s: %s(%d)\n",
iFile, strerror(errno), errno);
return 1;
}
*/
if ((s = malloc(bLen * sizeof(char))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
/*
if (options.debug)
fprintf(stderr, "Processing file %s\n", iFile);
*/
#ifdef DEBUG
int lc = 1;
#endif
/*
while ((res = fgets(s, (int) bLen, f)) != NULL) {
*/
while ((res = fgets(s, (int) bLen, stdin)) != NULL) {
char seq_id[SEQ_ID] = "";
char feature[FT_MAX] = "";
char position[POS_MAX] = "";
char count[CNT_MAX] = "";
char strand = '\0';
char ext[EXT_MAX] = "";
size_t cLen = strlen(s);
unsigned int i = 0;
memset(ext, 0, (size_t)EXT_MAX);
while (cLen + 1 == bLen && s[cLen - 1] != '\n') {
bLen *= 2;
if ((s = realloc(s, bLen)) == NULL) {
perror("process_file: realloc");
exit(1);
}
/*
res = fgets(s + cLen, (int) (bLen - cLen), f);
*/
res = fgets(s + cLen, (int) (bLen - cLen), stdin);
cLen = strlen(s);
}
if (s[cLen - 1] == '\n')
s[cLen - 1] = 0;
buf = s;
/* Get SGA fields */
/* SEQ ID */
while (*buf != 0 && !isspace(*buf)) {
if (i >= SEQ_ID) {
fprintf(stderr, "Seq ID is too long \"%s\" \n", buf);
exit(1);
}
seq_id[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* FEATURE */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature is too long \"%s\" \n", buf);
exit(1);
}
feature[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "Position is too large \"%s\" \n", buf);
exit(1);
}
position[i++] = *buf++;
}
position[i] = 0;
pos = (unsigned long)atol(position);
while (isspace(*buf))
buf++;
/* Strand */
strand = *buf++;
while (isspace(*buf))
buf++;
/* Counts */
i = 0;
while (isdigit(*buf)) {
if (i >= CNT_MAX) {
fprintf(stderr, "Count is too large \"%s\" \n", buf);
exit(1);
}
count[i++] = *buf++;
}
count[i] = 0;
cnt = atoi(count);
while (isspace(*buf))
buf++;
/* SGA Extension */
i = 0;
while (*buf != 0) {
if (i >= EXT_MAX) {
fprintf(stderr, "Extension is too long \"%s\" \n", buf);
exit(1);
}
ext[i++] = *buf++;
}
#ifdef DEBUG
printf(" [%d] seq ID: %s Feat: %s (%c) Pos: %lu Cnts: %d Ext: %s\n", lc++, seq_id, feature, strand, pos, cnt, ext);
#endif
if (!strcmp(feature, "END")) {
continue;
}
if (pos == p && strcmp(seq_id, chr) == 0 && strand == str) {
tc += cnt;
} else {
if (tc > 0) {
if (strcmp(desc, "")) {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n", chr, ft , p, str, tc, desc);
} else {
printf("%s\t%s\t%lu\t%c\t%d\n", chr, ft , p, str, tc);
}
}
strcpy(chr, seq_id);
strcpy(ft, feature);
strcpy(desc, ext);
p = pos;
str = strand;
tc = cnt;
}
} /* End of While */
free(s);
if (tc > 0) {
if (strcmp(desc, "")) {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n", chr, ft , p, str, tc, desc);
} else {
printf("%s\t%s\t%lu\t%c\t%d\n", chr, ft , p, str, tc);
}
}
return 0;
}
int
main(int argc, char *argv[])
{
#ifdef DEBUG
mcheck(NULL);
mtrace();
#endif
while (1) {
int c = getopt(argc, argv, "dh");
if (c == -1)
break;
switch (c) {
case 'd':
options.debug = 1;
break;
case 'h':
options.help = 1;
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
/*
if (optind == argc || options.help == 1) {
*/
if (options.help == 1) {
fprintf(stderr, "Usage: %s [options] < \n"
" - version %s\n"
" where options are:\n"
" \t\t -h Show this help text\n"
" \t\t -d Print debug information\n"
"\n\tThe program reads a ChIP-seq data file in SGA format (),\n"
"\tand merges equal tag positions into a single line adjusting the count\n"
"\tfield accordingly\n\n",
argv[0], VERSION);
return 1;
}
/*
if (process_sga(argv[optind++]) != 0) {
return 1;
}
*/
if (process_sga() != 0) {
return 1;
}
return 0;
}
chip-seq/tools/featreplace.c 0000744 0227442 0026227 00000015037 13362373530 016652 0 ustar ambrosin gr-bucher /*
featreplace.c
Replace Feature field within an SGA File
# Arguments:
# feature name
Giovanna Ambrosini, EPFL/ISREC, Giovanna.Ambrosini@epfl.ch
Copyright (c) 2014 EPFL and Swiss Institute of Bioinformatics.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
#define DEBUG
*/
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#ifdef DEBUG
#include
#endif
#include "version.h"
/*#define BUF_SIZE 4096 */
#define BUF_SIZE 8192
#define LINE_SIZE 1024
#define FT_MAX 64
#define SEQ_ID 32
#define POS_MAX 16
#define CNT_MAX 16
#define EXT_MAX 256
typedef struct _options_t {
int help;
int debug;
} options_t;
static options_t options;
char *Feature = NULL;
int
process_sga(FILE *input, char *iFile)
{
unsigned long pos;
int cnt;
char *s, *res, *buf;
size_t bLen = LINE_SIZE;
if ((s = malloc(bLen * sizeof(char))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", iFile);
#ifdef DEBUG
int c = 1;
#endif
while ((res = fgets(s, (int) bLen, input)) != NULL) {
size_t cLen = strlen(s);
char seq_id[SEQ_ID] = "";
char ft[FT_MAX] = "";
char position[POS_MAX] = "";
char count[CNT_MAX] = "";
char strand = '\0';
char ext[EXT_MAX];
unsigned int i = 0;
memset(ext, 0, (size_t)EXT_MAX);
while (cLen + 1 == bLen && s[cLen - 1] != '\n') {
bLen *= 2;
if ((s = realloc(s, bLen)) == NULL) {
perror("process_file: realloc");
exit(1);
}
res = fgets(s + cLen, (int) (bLen - cLen), input);
cLen = strlen(s);
}
if (s[cLen - 1] == '\n')
s[cLen - 1] = 0;
buf = s;
/* Get SGA fields */
/* SEQ ID */
while (*buf != 0 && !isspace(*buf)) {
if (i >= SEQ_ID) {
fprintf(stderr, "Seq ID is too long \"%s\" \n", buf);
exit(1);
}
seq_id[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* FEATURE */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature is too long \"%s\" \n", buf);
exit(1);
}
ft[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "Position is too large \"%s\" \n", buf);
exit(1);
}
position[i++] = *buf++;
}
position[i] = 0;
pos = (unsigned long)atol(position);
while (isspace(*buf))
buf++;
/* Strand */
strand = *buf++;
while (isspace(*buf))
buf++;
/* Counts */
i = 0;
while (isdigit(*buf)) {
if (i >= CNT_MAX) {
fprintf(stderr, "Count is too large \"%s\" \n", buf);
exit(1);
}
count[i++] = *buf++;
}
count[i] = 0;
cnt = atoi(count);
while (isspace(*buf))
buf++;
/* SGA Extension */
i = 0;
while (*buf != 0) {
if (i >= EXT_MAX) {
fprintf(stderr, "Extension is too long \"%s\" \n", buf);
exit(1);
}
ext[i++] = *buf++;
}
#ifdef DEBUG
printf(" [%d] seq ID: %s Feat: %s (%c) Pos: %lu Cnts: %d Ext: %s\n", c++, seq_id, ft, strand, pos, cnt, ext);
#endif
if (!strcmp(ext, "")) {
if (!strcmp(ft, "END")) {
printf("%s\t%s\t%lu\t%c\t%d\n", seq_id, ft , pos, strand, cnt);
} else {
printf("%s\t%s\t%lu\t%c\t%d\n", seq_id, Feature, pos, strand, cnt);
}
} else {
if (!strcmp(ft, "END")) {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n", seq_id, ft, pos, strand, cnt, ext);
} else {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n", seq_id, Feature, pos, strand, cnt, ext);
}
}
} /* End of While */
free(s);
if (input != stdin) {
fclose(input);
}
return 0;
}
int
main(int argc, char *argv[])
{
#ifdef DEBUG
mcheck(NULL);
mtrace();
#endif
FILE *input;
int free_flag = 0;
while (1) {
int c = getopt(argc, argv, "f:dh");
if (c == -1)
break;
switch (c) {
case 'f':
Feature = optarg;
break;
case 'd':
options.debug = 1;
break;
case 'h':
options.help = 1;
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
if (optind > argc || options.help == 1) {
fprintf(stderr, "Usage: %s [options] -f [<] \n"
" - version %s\n"
" where options are:\n"
" \t\t -h Show this help text\n"
" \t\t -d Print debug information\n"
"\n\tThe program reads a ChIP-seq data file (or from stdin [<]) in SGA format (),\n"
"\tand changes the name of the feature field according to the specified parameter \n"
"\t(by default ='FT').\n\n",
argv[0], VERSION);
return 1;
}
if (argc > optind) {
if(!strcmp(argv[optind],"-")) {
input = stdin;
} else {
input = fopen(argv[optind], "r");
if (NULL == input) {
fprintf(stderr, "Unable to open '%s': %s(%d)\n",
argv[optind], strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", argv[optind]);
}
} else {
input = stdin;
}
if (options.debug) {
fprintf(stderr, " Feature name: %s\n\n", Feature);
}
/* Process Feature Specs */
if (Feature == NULL) {
if ((Feature = malloc(3 * sizeof(char))) == NULL) {
perror("process_sga: malloc Feature");
exit(1);
}
strcpy(Feature, "FT");
free_flag = 1;
} else {
char *s = Feature;
int i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature Name too long \"%s\" \n", Feature);
return 1;
}
s++;
i++;
}
}
if (process_sga(input, argv[optind++]) != 0) {
return 1;
}
if (free_flag)
free(Feature);
return 0;
}
chip-seq/tools/sga2bed.c 0000744 0227442 0026227 00000053377 13401230641 015704 0 ustar ambrosin gr-bucher /*
sga2bed.c
Convert SGA file to BED format.
# Arguments:
# SGA File
# Options:
# Set Path to locate chr_NC_gi file
# (used for NCBI id to chromosome name conversion)
# Set Read length (def=0)
# Set Score factor for BED score field (5th field) (def=1)
# Create BED format without annotation track header lines
# Transfer SGA optional field(s) to BED field(s)
# Expand SGA lines into multiple BED lines
# Set BED track name
# Set BED track description
# Set BED track color
Giovanna Ambrosini, EPFL/ISREC, Giovanna.Ambrosini@epfl.ch
Copyright (c) 2014 EPFL and Swiss Institute of Bioinformatics.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
#define DEBUG
*/
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "hashtable.h"
#ifdef DEBUG
#include
#endif
#include "version.h"
#define BUF_SIZE 8192
#define LINE_SIZE 1024
#define FT_MAX 64
#define SEQ_ID 32
#define CHR_NB 18
#define AC_MAX 18
#define POS_MAX 16
#define CNT_MAX 16
#define EXT_MAX 256
#define FIELD_MAX 64
typedef struct _options_t {
char *dbPath;
char *extField;
int help;
int debug;
int db;
int readLen;
int scoreFact;
int normFact;
int noHdr;
int expand;
int extend;
char *trackName;
char *trackDesc;
char *trackColor;
} options_t;
static options_t options;
static hash_table_t *ac_table = NULL;
static hash_table_t *ext_fields = NULL;
int extIdx[10];
int extLen = 0;
int
process_ac()
{
FILE *input;
int c;
char buf[LINE_SIZE];
char *chrFile;
char chrom[12];
int cLen;
if (options.db) {
cLen = (int)strlen(options.dbPath) + 12;
if ((chrFile = (char*)malloc(cLen * sizeof(char))) == NULL) {
perror("process_ac: malloc");
exit(1);
}
strcpy(chrFile, options.dbPath);
} else {
cLen = 21 + 12;
if ((chrFile = (char*)malloc(cLen * sizeof(char))) == NULL) {
perror("process_ac: malloc");
exit(1);
}
strcpy(chrFile, "/home/local/db/genome");
}
strcat(chrFile, "/chr_NC_gi");
input = fopen(chrFile, "r");
if (input == NULL) {
fprintf(stderr, "Could not open file %s: %s(%d)\n",
chrFile, strerror(errno), errno);
return 1;
}
do {
c = fgetc(input);
} while(c != '\n');
ac_table = hash_table_new(MODE_COPY);
while (fgets(buf, LINE_SIZE, input) != NULL) {
char *s;
char chr_nb[CHR_NB] = "";
char ncbi_ac[AC_MAX] = "";
int i = 0;
int nb_len = 0;
int ac_len = 0;
/*int valid = 1;*/
s = buf;
/* Check line */
/* Get first character: if # skip line */
if (*s == '#')
continue;
/* Chrom NB */
while (*s != 0 && !isspace(*s)) {
if (i >= CHR_NB) {
fprintf(stderr, "AC too long in %s\n", s);
fclose(input);
exit(1);
}
chr_nb[i++] = *s++;
}
if (i < CHR_NB)
chr_nb[i] = 0;
nb_len = i + 1;
while (isspace(*s))
s++;
/* Chromosome NCBI AC */
i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= AC_MAX) {
fprintf(stderr, "AC too long \"%s\" \n", s);
fclose(input);
exit(1);
}
ncbi_ac[i++] = *s++;
}
if (i < AC_MAX)
ncbi_ac[i] = 0;
ac_len = i + 1;
/* Check if chrom contains valid numeric characters */
/*
for (i = 0; i < strlen(chr_nb); ++i) {
if (!isdigit(chr_nb[i])) {
valid = 0;
break;
}
}
if (valid) {
strcpy(chrom, "chr");
strcat(chrom, chr_nb);
} else {
strcpy(chrom, chr_nb);
} */
strcpy(chrom, "chr");
strcat(chrom, chr_nb);
nb_len = (int)strlen(chrom) + 1;
/* printf("adding key %s (len = %d) value %s (ac) (len = %d) to hash table\n", chrom, nb_len, ncbi_ac, ac_len); */
/* Store both NCBI identifier to chrom number and chrom number to chrom number keys */
hash_table_add(ac_table, ncbi_ac, (size_t)ac_len, chrom, (size_t)nb_len);
if (options.debug) {
char *cn = hash_table_lookup(ac_table, ncbi_ac, (size_t)ac_len);
fprintf (stderr, " AC Hash table: %s (len = %d) -> %s (len = %d)\n", ncbi_ac, ac_len, cn, nb_len);
}
hash_table_add(ac_table, chrom, (size_t)nb_len, chrom, (size_t)nb_len);
if (options.debug) {
char *cn = hash_table_lookup(ac_table, chrom, (size_t)nb_len);
fprintf (stderr, " AC Hash table: %s (len = %d) -> %s (len = %d)\n", chrom, nb_len, cn, nb_len);
}
}
return 0;
}
char** str_split(char* a_str, const char a_delim)
{
char** result = 0;
size_t count = 0;
char* tmp = a_str;
char* last_comma = 0;
char delim[2];
delim[0] = a_delim;
delim[1] = 0;
/* Count how many elements will be extracted. */
while (*tmp) {
if (a_delim == *tmp) {
count++;
last_comma = tmp;
}
tmp++;
}
/* Add space for trailing token. */
count += last_comma < (a_str + strlen(a_str) - 1);
/* Add space for terminating null string so caller
knows where the list of returned strings ends. */
count++;
result = malloc(sizeof(char*) *count);
if (result) {
size_t idx = 0;
char* token = strtok(a_str, delim);
while (token) {
assert(idx < count);
*(result + idx++) = strdup(token);
token = strtok(0, delim);
}
assert(idx == count - 1);
*(result + idx) = 0;
}
return result;
}
int
process_sga(FILE *input, char *iFile)
{
unsigned long start, end;
unsigned long pos;
int cnt;
char *name = NULL;
int score;
int value;
char *ext_str = NULL;
int first = 1;
char *s, *res, *buf;
size_t bLen = LINE_SIZE;
if (options.debug)
fprintf(stderr, " Processing SGA file %s\n", iFile);
if ((s = malloc(bLen * sizeof(char))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
#ifdef DEBUG
int c = 1;
#endif
while ((res = fgets(s, (int) bLen, input)) != NULL) {
size_t cLen = strlen(s);
char seq_id[SEQ_ID] = "";
char ft[FT_MAX] = "";
char position[POS_MAX] = "";
char count[CNT_MAX] = "";
char strand = '\0';
char ext[EXT_MAX];
char sga_ext_f[12][FIELD_MAX];
int first_name_ext = 1;
int first_val_ext = 1;
int i = 0;
int id_len = 0;
char *cn;
char** tokens;
int no_strand = 0;
memset(ext, 0, (size_t)EXT_MAX);
while (cLen + 1 == bLen && s[cLen - 1] != '\n') {
bLen *= 2;
if ((s = realloc(s, bLen)) == NULL) {
perror("process_file: realloc");
exit(1);
}
res = fgets(s + cLen, (int) (bLen - cLen), input);
cLen = strlen(s);
}
if (s[cLen - 1] == '\n')
s[cLen - 1] = 0;
buf = s;
/* Get SGA fields */
/* SEQ ID */
while (*buf != 0 && !isspace(*buf)) {
if (i >= SEQ_ID) {
fprintf(stderr, "Seq ID is too long \"%s\" \n", buf);
exit(1);
}
seq_id[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* FEATURE */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature is too long \"%s\" \n", buf);
exit(1);
}
ft[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "Position is too large \"%s\" \n", buf);
exit(1);
}
position[i++] = *buf++;
}
position[i] = 0;
pos = atoi(position);
while (isspace(*buf))
buf++;
/* Strand */
strand = *buf++;
while (isspace(*buf))
buf++;
/* Counts */
i = 0;
while (isdigit(*buf)) {
if (i >= CNT_MAX) {
fprintf(stderr, "Count is too large \"%s\" \n", buf);
exit(1);
}
count[i++] = *buf++;
}
count[i] = 0;
cnt = atoi(count);
while (isspace(*buf))
buf++;
/* SGA Extension */
i = 0;
while (*buf != 0) {
if (i >= EXT_MAX) {
fprintf(stderr, "Extension is too long \"%s\" \n", buf);
exit(1);
}
ext[i++] = *buf++;
}
#ifdef DEBUG
printf(" [%d] seq ID: %s Feat: %s (%c) Pos: %d Cnts: %d Ext: %s\n", c++, seq_id, ft, strand, pos, cnt, ext);
#endif
//printf(" seq ID: %s Feat: %s (%c) Pos: %d Cnts: %d Ext: %s\n", seq_id, ft, strand, pos, cnt, ext);
/* Set BED annotation track line */
if (!options.noHdr) {
if (first) {
if (options.trackName == NULL) {
if ( (options.trackName = malloc((strlen(ft) + 1) * sizeof(char))) == NULL) {
perror("process_sga: malloc Feature");
exit(1);
}
strcpy(options.trackName, ft);
}
printf("track name=\"%s\" description=\"%s\" visibility=1 color=%s\n", options.trackName, options.trackDesc, options.trackColor);
first = 0;
}
}
/* Set BED start/end positions and strand */
if (options.readLen == 0) {
start = pos - 1;
end = pos;
} else {
if (strand == '+') {
start = pos - 1;
end = start + options.readLen;
} else if (strand == '-') {
start = pos - options.readLen;
end = pos;
} else {
start = pos - 1 - (unsigned long)((long double)options.readLen/2 + 0.5);
end = pos - 1 + (unsigned long)((long double)options.readLen/2 + 0.5);
}
}
if (strand == '0') {
no_strand = 1;
strand ='.';
}
/* Set BED name field (4th) with SGA feature */
if ((name = malloc((strlen(ft) + 1) * sizeof(char))) == NULL) {
perror("process_sga: malloc Name field");
exit(1);
}
strcpy(name, ft);
/* Set BED score field */
score = cnt * options.scoreFact;
/* Check extension flag - if present only redefine BED fields 4 and/or 5 and/or 7 */
if (options.extend) {
/* Extract SGA extended fields */
tokens = str_split(ext, '\t');
if (tokens) {
for (i = 0; *(tokens + i); i++) {
strcpy (sga_ext_f[i], *(tokens + i));
//printf(" SGA ext field %s\n", sga_ext_f[i]);
free(*(tokens + i));
}
free(tokens);
}
/* Extract extension keys from ext_fields hash table */
void **keys = NULL;
size_t key_num = hash_table_get_keys(ext_fields, &keys);
//for (i = 0; i < key_num; i++) {
for (i = key_num - 1; i >= 0; i--) {
hash_table_element_t *el = keys[i];
int *sga_f = el->key;
int *bed_f = NULL;
bed_f = (int* ) HT_LOOKUP(ext_fields, sga_f);
//fprintf(stderr, " Ext fields: found SGA field %d -> BED field %d\n", *sga_f, *bed_f);
if (*bed_f == 4) {
if (*sga_f > 5) {
if (sga_ext_f[*sga_f - 6] != NULL) {
if ((name = realloc(name, (strlen(sga_ext_f[*sga_f - 6]) + 1) * sizeof(char))) == NULL) {
perror("process_sga: malloc SGA field");
exit(1);
}
}
} else {
perror("process_sga: SGA extension field must be > 5");
exit(1);
}
if (first_name_ext) {
strcpy(name, sga_ext_f[*sga_f - 6]);
first_name_ext = 0;
} else {
strcat(name, " ");
strcat(name, sga_ext_f[*sga_f - 6]);
}
} else if (*bed_f == 5) { /* Set BED score field */
if (*sga_f > 5) {
if (sga_ext_f[*sga_f - 6] != NULL) {
score = round(atof(sga_ext_f[*sga_f - 6])) * options.scoreFact;
}
} else {
perror("process_sga: SGA extension field must be > 5");
exit(1);
}
} else if (*bed_f == 7) { /* Set Extention fields, from 7 and on... */
if (*sga_f > 5) {
if (sga_ext_f[*sga_f - 6] != NULL) {
value = round(atof(sga_ext_f[*sga_f - 6])*options.normFact);
if (value == INT_MIN || value == INT_MAX)
value = 0;
//printf("value = %d \n", value);
}
if (first_val_ext) {
if ((ext_str = malloc((strlen(sga_ext_f[*sga_f - 6]) + 1) * sizeof(char))) == NULL) {
perror("process_sga: malloc ext String");
exit(1);
}
sprintf(ext_str, "%d", value);
first_val_ext = 0;
//printf("Extension String: %s\n", ext_str);
} else {
if ((ext_str = realloc(ext_str, (strlen(sga_ext_f[*sga_f - 6]) + 1) * sizeof(char))) == NULL) {
perror("process_sga: malloc SGA field");
exit(1);
}
sprintf(ext_str, "%s\t%d", ext_str, value);
}
} else {
perror("process_sga: SGA extension field must be > 5");
exit(1);
}
} else {
perror("process_sga: Allowed BED extension fields are 4, 5, and 7");
exit(1);
}
}
}
id_len = (int)strlen(seq_id) + 1;
cn = hash_table_lookup(ac_table, seq_id, (size_t)id_len);
if (cn == NULL)
continue;
/* Print out BED line */
if (options.expand) {
for (i = 0; i < cnt; i++) {
if (ext_str == NULL) {
if (no_strand)
printf("%s\t%lu\t%lu\t%s\t%d\n", cn, start, end, name, 0);
else
printf("%s\t%lu\t%lu\t%s\t%d\t%c\n", cn, start, end, name, 0, strand);
} else {
printf("%s\t%lu\t%lu\t%s\t%d\t%c\t%s\n", cn, start, end, name, 0, strand, ext_str);
}
}
} else {
if (ext_str == NULL) {
if (no_strand)
printf("%s\t%lu\t%lu\t%s\t%d\n", cn, start, end, name, score);
else
printf("%s\t%lu\t%lu\t%s\t%d\t%c\n", cn, start, end, name, score, strand);
} else {
printf("%s\t%lu\t%lu\t%s\t%d\t%c\t%s\n", cn, start, end, name, score, strand, ext_str);
}
}
} /* End of While */
if (input != stdin) {
fclose(input);
}
return 0;
}
int
main(int argc, char *argv[])
{
char** tokens_1;
char** tokens_2;
#ifdef DEBUG
mcheck(NULL);
mtrace();
#endif
FILE *input;
int i = 0;
int j = 0;
int usage = 0;
options.scoreFact = 1;
options.normFact = 1;
static struct option long_options[] =
{
/* These options may or may not set a flag.
We distinguish them by their indices. */
{"debug", no_argument, 0, 'd'},
{"help", no_argument, 0, 'h'},
{"db", required_argument, 0, 'i'},
{"readlen", required_argument, 0, 'l'},
{"score", required_argument, 0, 'c'},
{"norm", required_argument, 0, 'n'},
{"extend", required_argument, 0, 'e'},
{"nohdr", no_argument, 0, 'r'},
{"expand", no_argument, 0, 'x'},
{"name", required_argument, 0, 0 },
{"desc", required_argument, 0, 0 },
{"color", required_argument, 0, 0 },
{0, 0, 0, 0}
};
int option_index = 0;
while (1) {
int c = getopt_long(argc, argv, "dhi:l:c:e:n:rx", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'd':
options.debug = 1;
break;
case 'h':
options.help = 1;
break;
case 'i':
options.dbPath = optarg;
options.db = 1;
break;
case 'l':
options.readLen = atoi(optarg);
break;
case 'c':
options.scoreFact = atoi(optarg);
break;
case 'e':
options.extField = optarg;
options.extend = 1;
break;
case 'n':
options.normFact = atoi(optarg);
break;
case 'r':
options.noHdr = 1;
break;
case 'x':
options.expand = 1;
break;
case 0:
/* This option is to set the annotation track line */
if (strcmp(long_options[option_index].name, "name") == 0) {
options.trackName = optarg;
}
if (strcmp(long_options[option_index].name, "desc") == 0) {
options.trackDesc = optarg;
}
if (strcmp(long_options[option_index].name, "color") == 0) {
options.trackColor = optarg;
}
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
usage = 1;
}
}
/*printf("optind: %d argc: %d\n", optind, argc); */
if (optind > argc || options.help == 1 || usage) {
fprintf(stderr, "Usage: %s [options] [<] \n"
" - version %s\n"
" where options are:\n"
" \t\t -d|--debug Produce Debug information\n"
" \t\t -h|--help Show this Help text\n"
" \t\t -i|--db Use to locate the chr_NC_gi file\n"
" \t\t [default is: $HOME/db/genome]\n"
" \t\t -l|--readlen Set Read length \n"
" \t\t Unoriented SGA files are extended by +/-/2\n"
" \t\t -c|--score Normalisation factor for BED score field (5th) [score=1]\n"
" \t\t -n|--norm Normalisation factor for BED score field (7th) [normf=1]\n"
" \t\t -e|--extend f1:F1[,f2:F2] Set SGA optional field(s) f1(,f2,...) to BED field(s) F1,(F2,..)\n"
" \t\t Fields are specified by column numbers\n"
" \t\t Accepted BED field values are 4, 5, and 7\n"
" \t\t Except BED field 5 (score field), BED fields 4 and 7\n"
" \t\t can be used to set multiple extension values from SGA\n"
" \t\t Fields 5 and 7 convert into numerical values whereas\n"
" \t\t BED field 4 takes character strings as they are\n"
" \t\t -r|--nohdr BED format without annotation track header lines\n"
" \t\t -x|--expand Expand SGA lines into multiple BED lines\n"
" \t\t --name Set name for track name field [def. name=SGA-feature]\n"
" \t\t --desc Set track description field [def. desc=\"ChIP-Seq Custom data\"]\n"
" \t\t --color Define the track color in comma-separated RGB values [def. 100,100,100]\n"
"\n\tConvert SGA format into BED format.\n\n",
argv[0], VERSION);
return 1;
}
/*printf("argc: %d optind: %d\n", argc, optind);*/
if (argc > optind) {
if(!strcmp(argv[optind],"-")) {
input = stdin;
} else {
input = fopen(argv[optind], "r");
if (NULL == input) {
fprintf(stderr, "Unable to open '%s': %s(%d)\n",
argv[optind], strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", argv[optind]);
}
} else {
input = stdin;
}
if (options.trackDesc == NULL) {
if ((options.trackDesc = malloc(32 * sizeof(char))) == NULL) {
perror("main: malloc trackDesc");
exit(1);
}
strcpy(options.trackDesc, "ChIP-Seq Custom data");
}
if (options.trackColor == NULL) {
if ((options.trackColor = malloc(12 * sizeof(char))) == NULL) {
perror("main: malloc trackColor");
exit(1);
}
strcpy(options.trackColor, "100,100,100");
}
if (options.extend) {
int ht_el[2];
ext_fields = hash_table_new(MODE_COPY);
if (options.debug)
fprintf(stderr, " Extend SGA specs: %s\n", options.extField);
tokens_1 = str_split(options.extField, ',');
if (tokens_1) {
for (i = 0; *(tokens_1 + i); i++) {
tokens_2 = str_split(*(tokens_1 + i), ':');
if (tokens_2) {
for (j = 0; *(tokens_2 + j); j++) {
ht_el[j] = atoi(*(tokens_2 + j));
}
HT_ADD(ext_fields, &ht_el[0], &ht_el[1]);
free(*(tokens_2 + j));
}
free(*(tokens_1 + i));
}
free(tokens_1);
}
if (options.debug) {
void **keys = NULL;
size_t key_num = hash_table_get_keys(ext_fields, &keys);
for (i = 0; i < key_num; i++) {
hash_table_element_t *el = keys[i];
int *key = el->key;
int *val = NULL;
val = (int* ) HT_LOOKUP(ext_fields, key);
fprintf(stderr, " Ext fields: found (key) SGA field %d -> (val) BED field %d\n", *key, *val);
}
}
}
if (options.debug) {
fprintf(stderr, " Arguments:\n");
fprintf(stderr, " Read length : %d\n", options.readLen);
fprintf(stderr, " Score factor : %d\n", options.scoreFact);
fprintf(stderr, " Normalization factor (BED 7th fiels) : %d\n", options.normFact);
fprintf(stderr, " Extend SGA [on/off]: %d\n", options.extend);
fprintf(stderr, " Expand SGA [on/off]: %d\n", options.expand);
fprintf(stderr, " Track name: %s\n", options.trackName);
fprintf(stderr, " Track description: %s\n", options.trackDesc);
fprintf(stderr, " Track color: %s\n", options.trackColor);
fprintf(stderr, "\n");
}
if (process_ac() == 0) {
if (options.debug)
fprintf(stderr, " HASH Table for chromosome access identifier initialized\n");
} else {
return 1;
}
if (process_sga(input, argv[optind++]) != 0) {
return 1;
}
return 0;
}
chip-seq/tools/README 0000744 0227442 0026227 00000003533 13362375067 015120 0 ustar ambrosin gr-bucher ChIP-Seq auxiliary Perl and C applications
============================================================================
In this directory we have collected a series of Perl scripts and C programs that can be used to perform format conversion tasks as well as other auxiliary tasks such as read counts filtering or SAG file compression.
The ChIP-seq main programs use as a format a simplified BED format, called SGA (Simplified Genome Annotation), which is sorted by sequence name and position.
In a typical data analysis pipeline, the SGA file is often generated from a variety of richer formats, such as the Solexa genome mapping foramt, BAM BED, or FPS (Functional Position Set). The latter is used by the Signal Search Analysis programs at SIB (SSA).
We therefore provide simple and fast tools to convert SGA data files to other formats, especially BED, WIG (Wiggle Track Format) and FPS, and vice-versa.
WIG and BED files are used for viewing ChIP-seq data and results at the UCSC genome browser.
The binary file chro_idx.nstorage includes a Perl hash table that, for each supported assembly, stores chromosome number-NCBI identifier pairs as well as chromosome lengths indexed by chromosome NCBI identifiers.
This file is used by most conversion scripts. When required, its location () must by set by using the --db option.
The text file chr_NC_gi is used by the C format conversion programs (such as sga2bed, bed2sga, etc) to generate a hash table to link chromosome numbers to NCBI RefSeq identifiers and viceversa. When required, its location () must by set by using the -i|--db option.
The text file chr_size is used by a few C program to fetch the chromosome size based on the corresponding chromosome NCBI identifier. In this way, it is possible to check whether the genome coordinates of the data files go beyong the chromosome boundaries.
chip-seq/tools/fetch_sga.pl 0000744 0227442 0026227 00000001473 11537713130 016506 0 ustar ambrosin gr-bucher #!/usr/local/bin/perl
# This tool is used to extract SGA lines
#
$fn = $ARGV[0];
if($ARGV[1] =~ m/(\S+):(\d+)\-(\d+)/) {
$sq=$1; $b=$2; $e=$3}
search();
while() {
if(/(\S+)\s+\S+\s+(\S+)/) {
if ($1 gt $sq) {last}
elsif($2 > $e) {last}
elsif($2 >= $b) {print}
}
}
exit;
sub search {
# file initialization
$size = -s $fn;
open(SGA, "<$fn");
# dichotomy search
$low = 0;
$high = $size;
for ($i=0; $i<20; $i++) {
$n = $low + int(($high-$low)/2);
seek SGA, $n, 0;
; $line = ;
#print $line;
if($line =~ m/(\S+)\s+\S+\s+(\S+)/) {
if ($1 lt $sq) {$low = $n}
elsif($1 gt $sq) {$high = $n}
elsif($2 < $b-1000) {$low = $n}
elsif($2 > $b) {$high = $n}
else {last}
}
else {last}
}
}
chip-seq/tools/chr_replace_sga.pl 0000744 0227442 0026227 00000001617 11553015066 017665 0 ustar ambrosin gr-bucher #!/usr/bin/perl
# converts chrom names into RefSeq ids within SGA
# usage: ./chr_replace_sga.pl <-s species> -f
use strict;
use Getopt::Std;
use Storable qw (retrieve nstore); # package to store persistently variables in files [http://search.cpan.org/author/AMS/Storable-2.07/Storable.pm]
my %opts;
getopt('sf:', \%opts); # -s, & -f take arg. Values in %opts, Hash keys will be the switch names
my $DB = "/db/genome/";
#my $DB = "/home/local/db/genome/";
my $chr2SV = retrieve($DB."chro_idx.nstorage");
&Usage() unless ($opts{'f'} and $opts{'s'});
# open the SGA file
open(my $SGA, "$opts{'f'}") || die "can't open $opts{'f'} : $!";
while(<$SGA>) {
chomp;
if (/(\S+)\t(.*)/) {
print "$chr2SV->{$opts{'s'}}->{$1}\t$2\n";
}
}
close($SGA);
sub Usage {
print STDERR <<"_USAGE_";
chr_replace_sga.pl -s -f
_USAGE_
exit(1);
}
1;
chip-seq/tools/hashtable.h 0000777 0227442 0026227 00000000000 13354703337 020647 2../hashtable.h ustar ambrosin gr-bucher chip-seq/tools/partit2sga.pl 0000744 0227442 0026227 00000005055 13354407153 016647 0 ustar ambrosin gr-bucher #!/usr/bin/perl
#
# reformats partitioning output files (SGA) into bed format
# usage: partit2bed.pl [-t track_name -d desc -n chr_nb -b chr_start -e -chr_end]
use strict;
use Getopt::Long;
use Storable qw (retrieve nstore); # package to store persistently variables in files [http://search.cpan.org/author/AMS/Storable-2.07/Storable.pm]
my %opt;
my @options = ("help", "h", "db=s");
my $DB = "/home/local/db/genome/";
#my $DB = "/db/genome/";
if( ! GetOptions( \%opt, @options ) ) { &Usage(); }
&Usage() if defined($opt{'help'}) || defined($opt{'h'});
#define options
if ($opt{'db'} ne '') {
$DB = $opt{'db'};
}
open FH, $DB."chro_idx.nstorage" or die "Wrong Chrom Id Storable file $DB.\"chro_idx.nstorage\": $!";
my $chroac = retrieve($DB."chro_idx.nstorage");
&Usage() if $#ARGV < 0;
my $file = $ARGV[0];
# Chromosome size table
my %chr_size = ();
my @pos = ();
# Read First line of Partition File
#
# Get chrom sizes
my $assembly = "";
# Read Firstline and get assembly from chrom identifier
open(PART, "<$file") || die "can't read $file : $!";
my $firstline = ;
chomp $firstline;
my @field=split(/\t/,$firstline);
if (defined($field[0])){
$assembly = $chroac->{'assembly'}->{$field[0]};
}
if ($assembly ne "") {
open (CHR, "/home/local/db/genome/$assembly/$assembly".".chrom.sizes") || die "can't open /home/local/db/genome/$assembly/$assembly'.'.chrom.sizes' : $!";
while () {
chomp;
my @f=split(/\t/,$_);
$chr_size{$f[0]} = $f[1];
}
close (CHR);
}
seek (PART, 0, 0);
while (){
# Partitioning algorithm reports positions of start and end of tag,
#NC_000001.9 CTCF 227595 + 1 Start Line
#NC_000001.9 CTCF 227633 - 1 End Line
#Generate centered SGA file
my $lin=$_;
chomp $lin;
my @field=split(/\t/,$lin);
if (defined($field[0])){
if ($field[3] eq '+' || $field[3] eq '0') {
$pos[0] = $field[2];
} elsif ($field[3] eq '-') {
$pos[1] = $field[2];
my $center = int(($pos[0] + $pos[1])/2);
next if (defined($chr_size{$field[0]}) && $center > $chr_size{$field[0]});
print $field[0],"\t",$field[1],"\t",$center,"\t"."0"."\t$field[4]\n";
@pos = ();
}
}
}
close (PART);
sub Usage {
print STDERR <<"_USAGE_";
partit2sga.pl [options]
where options are:
-h|--help Show this stuff
--db Use to locate Chrom Id Storable File 'chro_idx.nstorage'
The program converts the output of the ChIP-Seq partitioning program to centered SGA format.
_USAGE_
exit(1);
}
1;
chip-seq/tools/sga2fps.pl 0000744 0227442 0026227 00000011445 12453211136 016125 0 ustar ambrosin gr-bucher #!/usr/bin/perl
# converts sga format to fps format
# usage: ./sga2fps.pl [<-s species>] file.sga
use strict;
use Getopt::Long;
use Storable qw (retrieve nstore); # package to store persistently variables in files [http://search.cpan.org/author/AMS/Storable-2.07/Storable.pm]
#my %opts;
#getopt('sf:', \%opts); # -s, & -f take arg. Values in %opts, Hash keys will be the switch names
my %opt;
my @options = ("help", "h", "species=s", "s=s", "f=s", "set0flag", "db=s");
my $file = "";
my $species = "";
my $feature = "";
my $ft_flag = 0;
my $set0flag = 0;
#my $DB = "/home/local/db/genome/";
my $DB = "/db/genome/";
if( ! GetOptions( \%opt, @options ) ) { &Usage(); }
&Usage() if defined($opt{'help'}) || defined($opt{'h'});
#&Usage() if $#ARGV < 0;
if ($opt{'db'} ne '') {
$DB = $opt{'db'};
}
open FH, $DB."chro_idx.nstorage" or die "Wrong Chrom Id Storable file $DB.\"chro_idx.nstorage\": $!";
my $chr2SV = retrieve($DB."chro_idx.nstorage");
if ($opt{'s'} ne '') {
$species = $opt{'s'};
}
if ($opt{'species'} ne '') {
$species = $opt{'species'};
}
if ($opt{'f'} ne '') {
$feature = $opt{'f'};
$ft_flag = 1;
}
if ($opt{'set0flag'} ne '') {
$set0flag = 1;
}
$file = $ARGV[0];
#print "SGA file : $file\n";
#print "Options: Species $species\n";
my $char29 = " ";
my $count = 1;
# open the SGA file
my $SGA;
if ($file ne "") {
open ($SGA, "$file") || die "can't open $file : $!";
} else {
$SGA = "STDIN";
}
my $firstline = <$SGA>;
my @f = split(/\t/,$firstline);
chomp $f[0];
chomp $f[4];
chomp $f[5];
if ($f[0] =~ /[NA][CT]_\S+\.\d+/ && exists($chr2SV->{$f[0]})) {
if ($f[3] eq "0") {
$f[3] = "+";
if ($set0flag) {
$char29 = "0";
}
}
if (!$ft_flag) {
if ($f[5] ne "") {
$feature=substr($f[5], 0, 19);
} else {
$feature=substr($f[1], 0, 19-length($f[4])).'_'.$f[4];
}
}
printf("FP %-20s:+U%1s EU:%-18s1%1s%10s;%6d.\n", $feature, $char29, $f[0], $f[3], $f[2], $count);
print_fps_1($SGA);
} elsif ($f[0] =~ /^chr/) {
if ($species && exists($chr2SV->{$species}->{$f[0]})) {
if ($f[3] eq "0") {
$f[3] = "+";
if ($set0flag) {
$char29 = "0";
}
}
if (!$ft_flag) {
if ($f[5] ne "") {
$feature=substr($f[5], 0, 19);
} else {
$feature=substr($f[1], 0, 19-length($f[4])).'_'.$f[4];
}
}
printf("FP %-20s:+U%1s EU:%-18s1%1s%10s;%6d.\n", $feature, $char29, $chr2SV->{$species}->{$f[0]}, $f[3], $f[2], $count);
print_fps_2($SGA, $species);
} else {
print STDERR "Please, provide a valid genome assembly (e.g. -s hg18) for chrom name to RefSeq id conversion!\n";
exit(1);
}
} else {
print STDERR "Unrecognized sequence version $f[0] : please, check the chromosome identifier (only valid RefSeq ids are accepted)!\n";
exit(1);
}
close ($SGA);
sub print_fps_1 {
my ($fh) = @_;
while(<$fh>){
my $lin=$_;
$count++;
chomp $lin;
my @ar=split(/\t/,$lin);
if ($ar[3] eq "0") {
$ar[3] = "+";
if ($set0flag) {
$char29 = "0";
}
}
# truncate description to fit field length
if (!$ft_flag) {
if ($ar[5] ne "") {
$feature=substr($ar[5], 0, 19);
} else {
$feature=substr($ar[1], 0, 19-length($ar[4])).'_'.$ar[4];
}
}
printf("FP %-20s:+U%1s EU:%-18s1%1s%10s;%6d.\n", $feature, $char29, $ar[0], $ar[3], $ar[2], $count);
}
}
sub print_fps_2 {
my ($fh, $species) = @_;
while(<$fh>){
my $lin=$_;
$count++;
chomp $lin;
my @ar=split(/\t/,$lin);
if ($ar[3] eq "0") {
$ar[3] = "+";
if ($set0flag) {
$char29 = "0";
}
}
# truncate description to fit field length
if (!$ft_flag) {
if ($ar[5] ne "") {
$feature=substr($ar[5], 0, 19);
} else {
$feature=substr($ar[1], 0, 19-length($ar[4])).'_'.$ar[4];
}
}
# convert chr to chromosome SV
printf("FP %-20s:+U%1s EU:%-18s1%1s%10s;%6d.\n", $feature, $char29, $chr2SV->{$species}->{$ar[0]}, $ar[3], $ar[2], $count);
}
}
sub Usage {
print STDERR <<"_USAGE_";
sga2fps.pl [options]
where options are:
-h|--help Show this stuff
--db Use to locate Chrom Id Storable File 'chro_idx.nstorage'
-f Set field
-s|--species Assembly (i.e hg18)
--set0flag Set 0 flag at postion 29 of the FP line, forcing unoriented output
(default : blank)
_USAGE_
exit(1);
}
1;
chip-seq/tools/filter_counts.c 0000744 0227442 0026227 00000016727 13362373540 017267 0 ustar ambrosin gr-bucher /*
filter_counts.c
Filter Feature read counts that occur within user-defined regions
of interest such as Repeat Mask regions.
If the -r option is set, the prpgram retains read counts that occur
within user-defined regions of interest.
# Arguments:
# Feature name of the user-defined regions of interest (e.g. RMSK)
Giovanna Ambrosini, EPFL/ISREC, Giovanna.Ambrosini@epfl.ch
Copyright (c) 2014 EPFL and Swiss Institute of Bioinformatics.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
#define DEBUG
*/
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#ifdef DEBUG
#include
#endif
#include "version.h"
/*#define BUF_SIZE 4096 */
#define BUF_SIZE 8192
#define LINE_SIZE 1024
#define FT_MAX 64
#define SEQ_ID 32
#define POS_MAX 16
#define CNT_MAX 16
#define EXT_MAX 256
typedef struct _options_t {
int help;
int debug;
int retain;
} options_t;
static options_t options;
char *Feature = NULL;
int
process_sga(FILE *input, char *iFile)
{
unsigned long pos;
int cnt;
char *s, *res, *buf;
size_t bLen = LINE_SIZE;
int prt = 0;
char annotation[EXT_MAX];
if ((s = malloc(bLen * sizeof(char))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", iFile);
#ifdef DEBUG
int c = 1;
#endif
while ((res = fgets(s, (int) bLen, input)) != NULL) {
size_t cLen = strlen(s);
char seq_id[SEQ_ID] = "";
char ft[FT_MAX] = "";
char position[POS_MAX] = "";
char count[CNT_MAX] = "";
char strand = '\0';
char ext[EXT_MAX];
unsigned int i = 0;
memset(ext, 0, (size_t)EXT_MAX);
while (cLen + 1 == bLen && s[cLen - 1] != '\n') {
bLen *= 2;
if ((s = realloc(s, bLen)) == NULL) {
perror("process_file: realloc");
exit(1);
}
res = fgets(s + cLen, (int) (bLen - cLen), input);
cLen = strlen(s);
}
if (s[cLen - 1] == '\n')
s[cLen - 1] = 0;
buf = s;
/* Get SGA fields */
/* SEQ ID */
while (*buf != 0 && !isspace(*buf)) {
if (i >= SEQ_ID) {
fprintf(stderr, "Seq ID is too long \"%s\" \n", buf);
exit(1);
}
seq_id[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* FEATURE */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature is too long \"%s\" \n", buf);
exit(1);
}
ft[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "Position is too large \"%s\" \n", buf);
exit(1);
}
position[i++] = *buf++;
}
position[i] = 0;
pos = (unsigned long)atol(position);
while (isspace(*buf))
buf++;
/* Strand */
strand = *buf++;
while (isspace(*buf))
buf++;
/* Counts */
i = 0;
while (isdigit(*buf)) {
if (i >= CNT_MAX) {
fprintf(stderr, "Count is too large \"%s\" \n", buf);
exit(1);
}
count[i++] = *buf++;
}
count[i] = 0;
cnt = atoi(count);
while (isspace(*buf))
buf++;
/* SGA Extension */
i = 0;
while (*buf != 0) {
if (i >= EXT_MAX) {
fprintf(stderr, "Extension is too long \"%s\" \n", buf);
exit(1);
}
ext[i++] = *buf++;
}
#ifdef DEBUG
fprintf(stderr, " [%d] seq ID: %s Feat: %s (%c) Pos: %lu Cnts: %d Ext: %s\n", c++, seq_id, ft, strand, pos, cnt, ext);
#endif
if (!strcmp(ft, Feature)) {
if (strand == '+') {
prt++;
strcpy(annotation, ext);
} else if (strand == '-') {
prt--;
}
} else {
if (options.retain) {
if (prt >= 1) {
if (!strcmp(ext, "")) {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n", seq_id, ft , pos, strand, cnt, annotation);
} else {
printf("%s\t%s\t%lu\t%c\t%d\t%s\t%s\n", seq_id, ft, pos, strand, cnt, ext, annotation);
}
}
} else {
if (prt < 1) {
if (!strcmp(ext, "")) {
printf("%s\t%s\t%lu\t%c\t%d\n", seq_id, ft , pos, strand, cnt);
} else {
printf("%s\t%s\t%lu\t%c\t%d\t%s\n", seq_id, ft, pos, strand, cnt, ext);
}
}
}
}
} /* End of While */
free(s);
return 0;
}
int
main(int argc, char *argv[])
{
#ifdef DEBUG
mcheck(NULL);
mtrace();
#endif
FILE *input;
int free_flag = 0;
while (1) {
int c = getopt(argc, argv, "f:dhr");
if (c == -1)
break;
switch (c) {
case 'f':
Feature = optarg;
break;
case 'd':
options.debug = 1;
break;
case 'h':
options.help = 1;
break;
case 'r':
options.retain = 1;
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
if (optind > argc || options.help == 1) {
fprintf(stderr, "Usage: %s [options] [<] \n"
" - version %s\n"
" where options are:\n"
" \t\t -h Show this help text\n"
" \t\t -d Print debug information\n"
" \t\t -f Feature defining the user-defined regions of interest (default=RMSK)\n"
" \t\t -r Retain Mode on\n"
"\n\tThe program reads a ChIP-seq data file (or from stdin [<]) in SGA format ()\n"
"\tand filters out all read counts that occur within user-defined regions of interest, such\n"
"\tas Repeat Mask regions (feature=RMSK).\n"
"\tIf 'Retain Mode' is on, it only retains those lines that are within the user-defined regions,\n"
"\tin which case the annotation of the user-defined regions is added to the output SGA file.\n\n",
argv[0], VERSION);
return 1;
}
if (argc > optind) {
if(!strcmp(argv[optind],"-")) {
input = stdin;
} else {
input = fopen(argv[optind], "r");
if (NULL == input) {
fprintf(stderr, "Unable to open '%s': %s(%d)\n",
argv[optind], strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", argv[optind]);
}
} else {
input = stdin;
}
if (options.debug) {
fprintf(stderr, " Feature name: %s\n\n", Feature);
}
/* Process Feature */
if (Feature == NULL) {
if ((Feature = malloc(5 * sizeof(char))) == NULL) {
perror("process_sga: malloc Feature");
exit(1);
}
strcpy(Feature, "RMSK");
free_flag = 1;
} else {
char *s = Feature;
int i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature Name too long \"%s\" \n", Feature);
return 1;
}
s++;
}
}
if (process_sga(input, argv[optind++]) != 0) {
return 1;
}
if (free_flag)
free(Feature);
return 0;
}
chip-seq/tools/countsga.c 0000744 0227442 0026227 00000020563 13046350703 016216 0 ustar ambrosin gr-bucher /*
countsga.c
Count tags and compute total sequence length of an SGA file
# Arguments:
# feature type, count cut-off
# SGA file
Giovanna Ambrosini, EPFL/ISREC, Giovanna.Ambrosini@epfl.ch
Copyright (c) 2014 EPFL and Swiss Institute of Bioinformatics.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
#define DEBUG
*/
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#ifdef DEBUG
#include
#endif
#include "version.h"
/*#define BUF_SIZE 4096 */
#define BUF_SIZE 8192
#define LINE_SIZE 1024
#define FT_MAX 64
#define SEQ_ID 32
#define POS_MAX 16
#define CNT_MAX 16
#define EXT_MAX 256
typedef struct _options_t {
int help;
int debug;
int cutOff;
char *ftName;
char strand;
} options_t;
static options_t options;
char *Feature = NULL;
int ft_specs = 1;
unsigned long Counts = 0; /* Total Target Counts */
unsigned long Len = 0; /* Total Sequence Length */
int
process_sga(FILE *input)
{
char seq_id_prev[SEQ_ID] = "";
unsigned long pos;
int cnt = 0;
unsigned long last_pos = 0;
char *s, *res, *buf;
size_t bLen = LINE_SIZE;
if ((s = malloc(bLen * sizeof(char))) == NULL) {
perror("process_sga: malloc");
exit(1);
}
/*
if (options.debug)
fprintf(stderr, "Processing file %s\n", iFile);
*/
#ifdef DEBUG
int lc = 1;
#endif
/*
while ((res = fgets(s, (int) bLen, f)) != NULL) {
*/
while ((res = fgets(s, (int) bLen, input)) != NULL) {
char seq_id[SEQ_ID] = "";
char feature[FT_MAX] = "";
char position[POS_MAX] = "";
char count[CNT_MAX] = "";
char strand = '\0';
char ext[EXT_MAX];
size_t cLen = strlen(s);
unsigned int i = 0;
memset(ext, 0, (size_t)EXT_MAX);
while (cLen + 1 == bLen && s[cLen - 1] != '\n') {
bLen *= 2;
if ((s = realloc(s, bLen)) == NULL) {
perror("process_file: realloc");
exit(1);
}
/*
res = fgets(s + cLen, (int) (bLen - cLen), f);
*/
res = fgets(s + cLen, (int) (bLen - cLen), input);
cLen = strlen(s);
}
if (s[cLen - 1] == '\n')
s[cLen - 1] = 0;
buf = s;
/* Get SGA fields */
/* SEQ ID */
while (*buf != 0 && !isspace(*buf)) {
if (i >= SEQ_ID) {
fprintf(stderr, "Seq ID is too long \"%s\" \n", buf);
exit(1);
}
seq_id[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* FEATURE */
i = 0;
while (*buf != 0 && !isspace(*buf)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature is too long \"%s\" \n", buf);
exit(1);
}
feature[i++] = *buf++;
}
while (isspace(*buf))
buf++;
/* Position */
i = 0;
while (isdigit(*buf)) {
if (i >= POS_MAX) {
fprintf(stderr, "Position is too large \"%s\" \n", buf);
exit(1);
}
position[i++] = *buf++;
}
position[i] = 0;
pos = (unsigned long)atol(position);
while (isspace(*buf))
buf++;
/* Strand */
strand = *buf++;
while (isspace(*buf))
buf++;
/* Counts */
i = 0;
while (isdigit(*buf)) {
if (i >= CNT_MAX) {
fprintf(stderr, "Count is too large \"%s\" \n", buf);
exit(1);
}
count[i++] = *buf++;
}
count[i] = 0;
cnt = atoi(count);
while (isspace(*buf))
buf++;
/* SGA Extension */
i = 0;
while (*buf != 0) {
if (i >= EXT_MAX) {
fprintf(stderr, "Extension is too long \"%s\" \n", buf);
exit(1);
}
ext[i++] = *buf++;
}
#ifdef DEBUG
printf(" [%d] seq ID: %s Feat: %s (%c) Pos: %lu Cnts: %d Ext: %s\n", lc++, seq_id, feature, strand, pos, cnt, ext);
#endif
if (!strcmp(feature, "END")) {
continue;
}
if (strcmp(seq_id, seq_id_prev) != 0) {
Len += last_pos;
strcpy(seq_id_prev, seq_id);
}
if (ft_specs == 0) {
if (cnt > options.cutOff)
Counts += (unsigned int)options.cutOff;
else
Counts += (unsigned int)cnt;
} else {
if (options.strand == '\0') {
if (strcmp(feature, options.ftName) == 0) {
if (cnt > options.cutOff)
Counts += (unsigned int)options.cutOff;
else
Counts += (unsigned int)cnt;
}
} else {
if (strcmp(feature, options.ftName) == 0 && strand == options.strand) {
if (cnt > options.cutOff)
Counts += (unsigned int)options.cutOff;
else
Counts += (unsigned int)cnt;
}
}
}
last_pos = pos;
} /* End of While */
free(s);
/* The last time (at EOF) */
Len += last_pos;
/*
fprintf (stderr, "Total Tag Counts : %lu , Total Sequence Len : %lu\n", Counts, Len);
*/
printf ("Total Tag Counts : %lu , Total Sequence Len : %lu\n", Counts, Len);
return 0;
}
int
main(int argc, char *argv[])
{
#ifdef DEBUG
mcheck(NULL);
mtrace();
#endif
FILE *input;
options.cutOff = 1;
options.ftName = NULL;
options.strand = '\0';
while (1) {
int c = getopt(argc, argv, "f:dhc:");
if (c == -1)
break;
switch (c) {
case 'd':
options.debug = 1;
break;
case 'h':
options.help = 1;
break;
case 'c':
options.cutOff = atoi(optarg);
break;
case 'f':
Feature = optarg;
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
/*
if (optind == argc || options.help == 1) {
*/
if (optind > argc || options.help == 1) {
fprintf(stderr, "Usage: %s [options] [<] \n"
" - version %s\n"
" where options are:\n"
" \t\t -h Show this help text\n"
" \t\t -d Print debug information\n"
" \t\t -f Feature specifications [name [+|-]]\n"
" \t\t -c Count Cut-off (default is %d)\n"
"\n\tThe program reads a ChIP-seq data file (or from stdin [<]) in SGA format (),\n"
"\tand computes the total number of tag counts as well as the total sequence length.\n"
"\tThe parameter is a name that corresponds to the second field of the SGA file.\n"
"\tIt might optionally include the strand specification (+|-).\n"
"\tIf no feature is given then all input tags are processed.\n\n", argv[0], VERSION, options.cutOff);
return 1;
}
if (argc > optind) {
if(!strcmp(argv[optind],"-")) {
input = stdin;
} else {
input = fopen(argv[optind], "r");
if (NULL == input) {
fprintf(stderr, "Unable to open '%s': %s(%d)\n",
argv[optind], strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (options.debug)
fprintf(stderr, "Processing file %s\n", argv[optind]);
}
} else {
input = stdin;
}
if (options.debug) {
fprintf(stderr, " Arguments:\n");
fprintf(stderr, " Selected Feature : %s\n", Feature);
}
/* Process Feature Specs */
if (Feature == NULL) {
ft_specs = 0; /* Process all features */
} else {
options.ftName = malloc((FT_MAX + 2) * sizeof(char));
char *s = Feature;
int i = 0;
while (*s != 0 && !isspace(*s)) {
if (i >= FT_MAX) {
fprintf(stderr, "Feature Description too long \"%s\" \n", Feature);
return 1;
}
options.ftName[i++] = *s++;
}
options.ftName[i] = '\0';
while (isspace(*s++))
options.strand = *s;
}
if (options.debug) {
if (!ft_specs) {
fprintf(stderr, "Feature Specs: ALL -> Process all features\n");
} else {
if (options.strand == '\0')
fprintf(stderr, "Feature Specs: Name : %s\n", options.ftName);
else
fprintf(stderr, "Feature Specs: Name : %s Strand %c\n", options.ftName, options.strand);
}
}
if (process_sga(input) != 0) {
return 1;
}
if (input != stdin) {
fclose(input);
}
return 0;
}
chip-seq/tools/partit2bed.pl 0000744 0227442 0026227 00000022556 12705363767 016647 0 ustar ambrosin gr-bucher #!/usr/bin/perl
#
# reformats partitioning output files (SGA) into bed format
# usage: partit2bed.pl [-t track_name -d desc -n chr_nb -b chr_start -e -chr_end]
use strict;
use Getopt::Long;
use Storable qw (retrieve nstore); # package to store persistently variables in files [http://search.cpan.org/author/AMS/Storable-2.07/Storable.pm]
my %opt;
my @options = ("help", "h", "desc=s", "d=s", "track=s", "t=s",
"n=i", "b=i", "e=i", "db=s");
my $desc = "ChIP-Seq";
my $track_name = "Test-BED";
my $chr_nb = "chr0";
my $chr_start = -1;
my $chr_end = -1;
#my $DB = "/home/local/db/genome/";
my $DB = "/db/genome/";
if( ! GetOptions( \%opt, @options ) ) { &Usage(); }
&Usage() if defined($opt{'help'}) || defined($opt{'h'});
#define options
if ($opt{'db'} ne '') {
$DB = $opt{'db'};
}
open FH, $DB."chro_idx.nstorage" or die "Wrong Chrom Id Storable file $DB.\"chro_idx.nstorage\": $!";
my $chroac = retrieve($DB."chro_idx.nstorage");
if ($opt{'d'} ne '') {
$desc = $opt{'d'};
}
if ($opt{'desc'} ne '') {
$desc = $opt{'desc'};
}
if ($opt{'t'} ne '') {
$track_name = $opt{'t'};
}
if ($opt{'track'} ne '') {
$track_name = $opt{'track'};
}
if ($opt{'n'} ne '') {
$chr_nb = "chr".$opt{'n'};
}
if ($opt{'b'} ne '') {
$chr_start = $opt{'b'};
}
if ($opt{'e'} ne '') {
$chr_end = $opt{'e'};
}
&Usage() if $#ARGV < 0;
my $file = $ARGV[0];
my $start_reg = -1;
my $end_reg = -1;
my $chr_start_flag = 0;
my $chr_end_flag = 0;
my $chr_nb_flag = 0;
my $chr_name_flag = 1;
my $assembly = "";
my @pos = ();
# Read First line of Partition File
# Print out BED File Header
open(PART, "<$file") || die "can't read $file : $!";
my $lin=;
my @field=split(/\t/,$lin);
if ( $chr_start != -1) {
$start_reg = $chr_start;
$chr_start_flag = 1;
} else {
$start_reg = $field[2];
}
if ( $chr_end != -1) {
$end_reg = $chr_end;
$chr_end_flag = 1;
} else {
$end_reg = $field[2] + 1000000;
}
if ($chr_nb ne "chr0") {
$chr_nb_flag = 1;
}
if (exists($chroac->{$field[0]})) {
$chr_name_flag = 0;
}
#if ($chr_nb_flag) {
# print "browser position $chr_nb:$start_reg-$end_reg\n";
#} elsif (!$chr_name_flag) {
# print "browser position $chroac->{$field[0]}:$start_reg-$end_reg\n";
#} else {
# print "browser position $field[0]:$start_reg-$end_reg\n";
#}
#print "browser full refGene\n";
chomp $track_name;
chomp $desc;
print "track name=$track_name description=\"$desc\" visibility=1 color=200,100,0\n";
#if ($chr_name_flag) {
# print "track name=$track_name description=\"ChIP-Seq-$experiment/$exp_data Partitioning\" visibility=1 color=200,100,0\n";
#} else {
# print "track name=$track_name description=\"",$chroac->{'assembly'}->{$field[0]},"-ChIP-Seq-$experiment/$exp_data Partitioning\" visibility=1 color=200,100,0\n";
#}
close(PART);
# generate BED-file
open(PART, "<$file") || die "can't read $file : $!";
if ($chr_name_flag) { # we deal with chromosome names (chrx)
my $i = 0;
while (){
# Partitioning algorithm reports positions of start and end of tag,
#NC_000001.9 CTCF 227595 + 1 Start Line
#NC_000001.9 CTCF 227633 - 1 End Line
my $lin=$_;
chomp $lin;
my @field=split(/\t/,$lin);
if (defined($field[0])){
if ($field[3] eq '+' || $field[3] eq '0') {
$pos[0] = $field[2] - 1;
} elsif ($field[3] eq '-') {
$i++;
$pos[1] = $field[2];
if ( $chr_nb_flag && !$chr_start_flag && !$chr_end_flag ) {
if ($field[0] eq $chr_nb) {
#print $field[0],"\t",$pos[0],"\t",$pos[1],"\t\t\t\+\n";
print $field[0],"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
} elsif ($chr_nb_flag && $chr_start_flag && !$chr_end_flag) {
if ($field[0] eq $chr_nb && ($pos[0] >= $chr_start || $pos[1] >= $chr_start)) {
#print $field[0],"\t",$pos[0],"\t",$pos[1],"\t\t\t\+\n";
print $field[0],"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
} elsif ($chr_nb_flag && $chr_start_flag && $chr_end_flag) {
if ($field[0] eq $chr_nb && (($pos[0] >= $chr_start || $pos[1] >= $chr_start) && ($pos[0] <= $chr_end || $pos[1] <= $chr_end))) {
#print $field[0],"\t",$pos[0],"\t",$pos[1],"\t\t\t\+\n";
print $field[0],"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
} else {
#print $field[0],"\t",$pos[0],"\t",$pos[1],"\t\t\t\+\n";
print $field[0],"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
@pos = ();
}
}
}
} else { # Chrom name Flag = 0 (NCBI IDs)
my $i = 1;
my $firstline = ;
chomp $firstline;
my @field=split(/\t/,$firstline);
if (defined($field[0])){
$assembly = $chroac->{'assembly'}->{$field[0]};
}
close (CHR);
$pos[0] = $field[2] - 1;
my $secondline = ;
chomp $secondline;
my @field=split(/\t/,$secondline);
$pos[1] = $field[2];
if ( $chr_nb_flag && !$chr_start_flag && !$chr_end_flag ) {
if ($chroac->{$field[0]} eq $chr_nb) {
print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
} elsif ($chr_nb_flag && $chr_start_flag && !$chr_end_flag) {
if ($chroac->{$field[0]} eq $chr_nb && ($pos[0] >= $chr_start || $pos[1] >= $chr_start)) {
print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
} elsif ($chr_nb_flag && $chr_start_flag && $chr_end_flag) {
if ($chroac->{$field[0]} eq $chr_nb && (($pos[0] >= $chr_start || $pos[1] >= $chr_start) && ($pos[0] <= $chr_end || $pos[1] <= $chr_end))) {
print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
} else {
print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
@pos = ();
while (){
# Partitioning algorithm reports positions of start and end of tag,
#NC_000001.9 CTCF 227595 + 1 Start Line
#NC_000001.9 CTCF 227633 - 1 End Line
my $lin=$_;
chomp $lin;
my @field=split(/\t/,$lin);
if (defined($field[0])){
if ($assembly ne $chroac->{'assembly'}->{$field[0]}) {
if ($assembly) {
print STDERR "The partition output $file appears to contain entries from different species: $field[0] from ",$chroac->{'assembly'}->{$field[0]}," vs. preceeding sequences from $assembly\n";
}
$assembly = $chroac->{'assembly'}->{$field[0]};
}
if ($field[3] eq '+' || $field[3] eq '0') {
$pos[0] = $field[2] - 1;
# check chromosome boundaries
next if ($pos[0] > $chroac->{'length'}->{$field[0]});
} elsif ($field[3] eq '-') {
$i++;
$pos[1] = $field[2];
# check chromosome boundaries
next if ($pos[1] > $chroac->{'length'}->{$field[0]});
if ( $chr_nb_flag && !$chr_start_flag && !$chr_end_flag ) {
if ($chroac->{$field[0]} eq $chr_nb) {
#print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t\t\t\+\n";
print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
} elsif ($chr_nb_flag && $chr_start_flag && !$chr_end_flag) {
if ($chroac->{$field[0]} eq $chr_nb && ($pos[0] >= $chr_start || $pos[1] >= $chr_start)) {
#print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t\t\t\+\n";
print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
} elsif ($chr_nb_flag && $chr_start_flag && $chr_end_flag) {
if ($chroac->{$field[0]} eq $chr_nb && (($pos[0] >= $chr_start || $pos[1] >= $chr_start) && ($pos[0] <= $chr_end || $pos[1] <= $chr_end))) {
#print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t\t\t\+\n";
print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
} else {
#print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t\t\t\+\n";
print $chroac->{$field[0]},"\t",$pos[0],"\t",$pos[1],"\t"."R:$i"."\t$field[4]\n";
}
@pos = ();
}
}
}
}
close (PART);
sub Usage {
print STDERR <<"_USAGE_";
partit2bed.pl [options]
where options are:
-h|--help Show this stuff
--db Use to locate Chrom Id Storable File 'chro_idx.nstorage'
-t|--track