GtGenomeNode* gt_feature_node_new(GtStr *seqid, const char *type,
GtUword start, GtUword end,
GtStrand strand)
{
GtGenomeNode *gn;
GtFeatureNode *fn;
gt_assert(seqid && type);
gt_assert(start <= end);
gn = gt_genome_node_create(gt_feature_node_class());
fn = gt_feature_node_cast(gn);
fn->seqid = gt_str_ref(seqid);
fn->source = NULL;
fn->type = gt_symbol(type);
fn->score = GT_UNDEF_FLOAT;
fn->range.start = start;
fn->range.end = end;
fn->representative = NULL;
fn->attributes = NULL;
fn->bit_field = 0;
fn->bit_field |= strand << STRAND_OFFSET;
fn->children = NULL; /* the children list is create on demand */
fn->observer = NULL;
gt_feature_node_set_phase(fn, GT_PHASE_UNDEFINED);
set_transcriptfeaturetype(fn, TRANSCRIPT_FEATURE_TYPE_UNDETERMINED);
set_tree_status(&fn->bit_field, IS_TREE);
/* the DFS status is set to DFS_WHITE already */
fn->representative = NULL;
return gn;
}
static int pdom_hit_attach_gff3(GtPdomModel *model, GtPdomModelHit *hit,
void *data, GT_UNUSED GtError *err)
{
unsigned long i;
GtRange rng;
GtLTRdigestStream *ls = (GtLTRdigestStream *) data;
GtStrand strand;
gt_assert(model && hit);
strand = gt_pdom_model_hit_get_best_strand(hit);
/* do not use the hits on the non-predicted strand
-- maybe identify nested elements ? */
if (strand != gt_feature_node_get_strand(ls->element.mainnode))
return 0;
for (i=0;i<gt_pdom_model_hit_best_chain_length(hit);i++)
{
GtGenomeNode *gf;
GtStr *alignmentstring,
*aastring;
GtPdomSingleHit *singlehit;
GtPhase frame;
singlehit = gt_pdom_model_hit_best_single_hit(hit, i);
alignmentstring = gt_str_new();
aastring = gt_str_new();
frame = gt_pdom_single_hit_get_phase(singlehit);
rng = gt_pdom_single_hit_get_range(singlehit);
gt_pdom_single_hit_format_alignment(singlehit, GT_ALIWIDTH,
alignmentstring);
gt_pdom_single_hit_get_aaseq(singlehit, aastring);
rng.start++; rng.end++; /* GFF3 is 1-based */
gf = gt_feature_node_new(gt_genome_node_get_seqid((GtGenomeNode*)
ls->element.mainnode),
GT_PDOM_TYPE,
rng.start,
rng.end,
strand);
gt_genome_node_add_user_data((GtGenomeNode*) gf, "pdom_alignment",
alignmentstring, (GtFree) gt_str_delete);
gt_genome_node_add_user_data((GtGenomeNode*) gf, "pdom_aaseq",
aastring, (GtFree) gt_str_delete);
gt_feature_node_set_source((GtFeatureNode*) gf, ls->ltrdigest_tag);
gt_feature_node_set_score((GtFeatureNode*) gf,
gt_pdom_single_hit_get_evalue(singlehit));
gt_feature_node_set_phase((GtFeatureNode*) gf, frame);
if (gt_pdom_model_get_name(model)) {
gt_feature_node_add_attribute((GtFeatureNode*) gf, "name",
gt_pdom_model_get_name(model));
}
if (gt_pdom_model_get_acc(model)) {
gt_feature_node_add_attribute((GtFeatureNode*) gf, "id",
gt_pdom_model_get_acc(model));
}
gt_feature_node_add_child(ls->element.mainnode, (GtFeatureNode*) gf);
}
return 0;
}
static void infer_cds_visitor_check_cds_phase(AgnInferCDSVisitor *v)
{
unsigned long num_cds_feats = gt_array_size(v->cds);
if(num_cds_feats == 0)
return;
GtFeatureNode *cdsf1 = *(GtFeatureNode **)gt_array_get(v->cds, 0);
GtStrand strand = gt_feature_node_get_strand(cdsf1);
if(strand == GT_STRAND_REVERSE)
cdsf1 = *(GtFeatureNode **)gt_array_get(v->cds, num_cds_feats - 1);
gt_feature_node_set_phase(cdsf1, GT_PHASE_ZERO);
if(num_cds_feats == 1)
return;
unsigned long cds_length = gt_genome_node_get_length((GtGenomeNode *)cdsf1);
int i;
if(strand == GT_STRAND_REVERSE)
{
for(i = num_cds_feats - 2; i >= 0; i--)
{
GtFeatureNode *cds = *(GtFeatureNode **)gt_array_get(v->cds, i);
int phasenum = cds_length % 3;
GtPhase phase = GT_PHASE_ZERO;
if(phasenum == 1)
phase = GT_PHASE_TWO;
else if(phasenum == 2)
phase = GT_PHASE_ONE;
gt_feature_node_set_phase(cds, phase);
cds_length += gt_genome_node_get_length((GtGenomeNode *)cds);
}
}
else
{
for(i = 1; i < num_cds_feats; i++)
{
GtFeatureNode *cds = *(GtFeatureNode **)gt_array_get(v->cds, i);
int phasenum = cds_length % 3;
GtPhase phase = GT_PHASE_ZERO;
if(phasenum == 1)
phase = GT_PHASE_TWO;
else if(phasenum == 2)
phase = GT_PHASE_ONE;
gt_feature_node_set_phase(cds, phase);
cds_length += gt_genome_node_get_length((GtGenomeNode *)cds);
}
}
}
static int check_cds_phases(GtArray *cds_features, GtCDSCheckVisitor *v,
bool is_multi, bool second_pass, GtError *err)
{
GtPhase current_phase, correct_phase = GT_PHASE_ZERO;
GtFeatureNode *fn;
GtStrand strand;
unsigned long i, current_length;
int had_err = 0;
gt_error_check(err);
gt_assert(cds_features);
gt_assert(gt_array_size(cds_features));
fn = *(GtFeatureNode**) gt_array_get_first(cds_features);
strand = gt_feature_node_get_strand(fn);
if (strand == GT_STRAND_REVERSE)
gt_array_reverse(cds_features);
for (i = 0; !had_err && i < gt_array_size(cds_features); i++) {
fn = *(GtFeatureNode**) gt_array_get(cds_features, i);
/* the first phase can be anything (except being undefined), because the
GFF3 spec says:
NOTE 4 - CDS features MUST have have a defined phase field. Otherwise it
is not possible to infer the correct polypeptides corresponding to
partially annotated genes. */
if ((!i && gt_feature_node_get_phase(fn) == GT_PHASE_UNDEFINED) ||
(i && gt_feature_node_get_phase(fn) != correct_phase)) {
if (gt_hashmap_get(v->cds_features, fn)) {
if (v->tidy && !is_multi && !gt_feature_node_has_children(fn)) {
/* we can split the feature */
gt_warning("%s feature on line %u in file \"%s\" has multiple "
"parents which require different phases; split feature",
gt_ft_CDS,
gt_genome_node_get_line_number((GtGenomeNode*) fn),
gt_genome_node_get_filename((GtGenomeNode*) fn));
gt_hashmap_add(v->cds_features_to_split, fn, fn);
v->splitting_is_necessary = true; /* split later */
}
else {
gt_error_set(err, "%s feature on line %u in file \"%s\" has multiple "
"parents which require different phases",
gt_ft_CDS,
gt_genome_node_get_line_number((GtGenomeNode*) fn),
gt_genome_node_get_filename((GtGenomeNode*) fn));
had_err = -1;
}
}
else {
if (v->tidy) {
if (!second_pass) {
gt_warning("%s feature on line %u in file \"%s\" has the wrong "
"phase %c -> correcting it to %c", gt_ft_CDS,
gt_genome_node_get_line_number((GtGenomeNode*) fn),
gt_genome_node_get_filename((GtGenomeNode*) fn),
GT_PHASE_CHARS[gt_feature_node_get_phase(fn)],
GT_PHASE_CHARS[correct_phase]);
}
gt_feature_node_set_phase(fn, correct_phase);
}
else {
gt_error_set(err, "%s feature on line %u in file \"%s\" has the "
"wrong phase %c (should be %c)", gt_ft_CDS,
gt_genome_node_get_line_number((GtGenomeNode*) fn),
gt_genome_node_get_filename((GtGenomeNode*) fn),
GT_PHASE_CHARS[gt_feature_node_get_phase(fn)],
GT_PHASE_CHARS[correct_phase]);
had_err = -1;
}
}
}
if (!had_err) {
current_phase = gt_feature_node_get_phase(fn);
current_length = gt_genome_node_get_length((GtGenomeNode*) fn);
correct_phase = (3 - (current_length - current_phase) % 3) % 3;
gt_hashmap_add(v->cds_features, fn, fn); /* record CDS feature */
}
}
return had_err;
}
int gt_gtf_parser_parse(GtGTFParser *parser, GtQueue *genome_nodes,
GtStr *filenamestr, GtFile *fpin, bool be_tolerant,
GtError *err)
{
GtStr *seqid_str, *source_str, *line_buffer;
char *line;
size_t line_length;
GtUword i, line_number = 0;
GtGenomeNode *gn;
GtRange range;
GtPhase phase_value;
GtStrand gt_strand_value;
GtSplitter *splitter, *attribute_splitter;
float score_value;
char *seqname,
*source,
*feature,
*start,
*end,
*score,
*strand,
*frame,
*attributes,
*token,
*gene_id,
*gene_name = NULL,
*transcript_id,
*transcript_name = NULL,
**tokens;
GtHashmap *transcript_id_hash; /* map from transcript id to array of genome
nodes */
GtArray *gt_genome_node_array;
ConstructionInfo cinfo;
GTF_feature_type gtf_feature_type;
GT_UNUSED bool gff_type_is_valid = false;
const char *type = NULL;
const char *filename;
bool score_is_defined;
int had_err = 0;
gt_assert(parser && genome_nodes);
gt_error_check(err);
filename = gt_str_get(filenamestr);
/* alloc */
line_buffer = gt_str_new();
splitter = gt_splitter_new(),
attribute_splitter = gt_splitter_new();
#define HANDLE_ERROR \
if (had_err) { \
if (be_tolerant) { \
fprintf(stderr, "skipping line: %s\n", gt_error_get(err)); \
gt_error_unset(err); \
gt_str_reset(line_buffer); \
had_err = 0; \
continue; \
} \
else { \
had_err = -1; \
break; \
} \
}
while (gt_str_read_next_line_generic(line_buffer, fpin) != EOF) {
line = gt_str_get(line_buffer);
line_length = gt_str_length(line_buffer);
line_number++;
had_err = 0;
if (line_length == 0) {
gt_warning("skipping blank line " GT_WU " in file \"%s\"", line_number,
filename);
}
else if (line[0] == '#') {
/* storing comment */
if (line_length >= 2 && line[1] == '#')
gn = gt_comment_node_new(line+2); /* store '##' line as '#' line */
else
gn = gt_comment_node_new(line+1);
gt_genome_node_set_origin(gn, filenamestr, line_number);
gt_queue_add(genome_nodes, gn);
}
else {
/* process tab delimited GTF line */
gt_splitter_reset(splitter);
gt_splitter_split(splitter, line, line_length, '\t');
if (gt_splitter_size(splitter) != 9UL) {
gt_error_set(err, "line " GT_WU " in file \"%s\" contains " GT_WU
" tab (\\t) " "separated fields instead of 9", line_number,
filename,
gt_splitter_size(splitter));
had_err = -1;
break;
}
tokens = gt_splitter_get_tokens(splitter);
seqname = tokens[0];
source = tokens[1];
feature = tokens[2];
start = tokens[3];
end = tokens[4];
score = tokens[5];
strand = tokens[6];
frame = tokens[7];
attributes = tokens[8];
/* parse feature */
if (GTF_feature_type_get(>f_feature_type, feature) == -1) {
/* we skip unknown features */
fprintf(stderr, "skipping line " GT_WU " in file \"%s\": unknown "
"feature: \"%s\"\n", line_number, filename, feature);
gt_str_reset(line_buffer);
continue;
}
/* translate into GFF3 feature type */
switch (gtf_feature_type) {
case GTF_CDS:
case GTF_stop_codon:
gff_type_is_valid = gt_type_checker_is_valid(parser->type_checker,
gt_ft_CDS);
type = gt_ft_CDS;
break;
case GTF_exon:
gff_type_is_valid = gt_type_checker_is_valid(parser->type_checker,
gt_ft_exon);
type = gt_ft_exon;
}
gt_assert(gff_type_is_valid);
/* parse the range */
had_err = gt_parse_range(&range, start, end, line_number, filename, err);
HANDLE_ERROR;
/* process seqname (we have to do it here because we need the range) */
gt_region_node_builder_add_region(parser->region_node_builder, seqname,
range);
/* parse the score */
had_err = gt_parse_score(&score_is_defined, &score_value, score,
line_number, filename, err);
HANDLE_ERROR;
/* parse the strand */
had_err = gt_parse_strand(>_strand_value, strand, line_number, filename,
err);
HANDLE_ERROR;
/* parse the frame */
had_err = gt_parse_phase(&phase_value, frame, line_number, filename, err);
HANDLE_ERROR;
/* parse the attributes */
gt_splitter_reset(attribute_splitter);
gene_id = NULL;
transcript_id = NULL;
gt_splitter_split(attribute_splitter, attributes, strlen(attributes),
';');
for (i = 0; i < gt_splitter_size(attribute_splitter); i++) {
token = gt_splitter_get_token(attribute_splitter, i);
/* skip leading blanks */
while (*token == ' ')
token++;
/* look for the two mandatory attributes */
if (strncmp(token, GENE_ID_ATTRIBUTE, strlen(GENE_ID_ATTRIBUTE)) == 0) {
if (strlen(token) + 2 < strlen(GENE_ID_ATTRIBUTE)) {
gt_error_set(err, "missing value to attribute \"%s\" on line "
GT_WU "in file \"%s\"", GENE_ID_ATTRIBUTE, line_number,
filename);
had_err = -1;
}
HANDLE_ERROR;
gene_id = token + strlen(GENE_ID_ATTRIBUTE) + 1;
}
else if (strncmp(token, TRANSCRIPT_ID_ATTRIBUTE,
strlen(TRANSCRIPT_ID_ATTRIBUTE)) == 0) {
if (strlen(token) + 2 < strlen(TRANSCRIPT_ID_ATTRIBUTE)) {
gt_error_set(err, "missing value to attribute \"%s\" on line "
GT_WU "in file \"%s\"", TRANSCRIPT_ID_ATTRIBUTE,
line_number, filename);
had_err = -1;
}
HANDLE_ERROR;
transcript_id = token + strlen(TRANSCRIPT_ID_ATTRIBUTE) + 1;
}
else if (strncmp(token, GENE_NAME_ATTRIBUTE,
strlen(GENE_NAME_ATTRIBUTE)) == 0) {
if (strlen(token) + 2 < strlen(GENE_NAME_ATTRIBUTE)) {
gt_error_set(err, "missing value to attribute \"%s\" on line "
GT_WU "in file \"%s\"", GENE_NAME_ATTRIBUTE,
line_number, filename);
had_err = -1;
}
HANDLE_ERROR;
gene_name = token + strlen(GENE_NAME_ATTRIBUTE) + 1;
/* for output we want to strip quotes */
if (*gene_name == '"')
gene_name++;
if (gene_name[strlen(gene_name)-1] == '"')
gene_name[strlen(gene_name)-1] = '\0';
}
else if (strncmp(token, TRANSCRIPT_NAME_ATTRIBUTE,
strlen(TRANSCRIPT_NAME_ATTRIBUTE)) == 0) {
if (strlen(token) + 2 < strlen(TRANSCRIPT_NAME_ATTRIBUTE)) {
gt_error_set(err, "missing value to attribute \"%s\" on line "
GT_WU "in file \"%s\"", TRANSCRIPT_NAME_ATTRIBUTE,
line_number, filename);
had_err = -1;
}
HANDLE_ERROR;
transcript_name = token + strlen(TRANSCRIPT_NAME_ATTRIBUTE) + 1;
/* for output we want to strip quotes */
if (*transcript_name == '"')
transcript_name++;
if (transcript_name[strlen(transcript_name)-1] == '"')
transcript_name[strlen(transcript_name)-1] = '\0';
}
}
/* check for the mandatory attributes */
if (!gene_id) {
gt_error_set(err, "missing attribute \"%s\" on line " GT_WU
" in file \"%s\"", GENE_ID_ATTRIBUTE, line_number,
filename);
had_err = -1;
}
HANDLE_ERROR;
if (!transcript_id) {
gt_error_set(err, "missing attribute \"%s\" on line " GT_WU
" in file \"%s\"", TRANSCRIPT_ID_ATTRIBUTE, line_number,
filename);
had_err = -1;
}
HANDLE_ERROR;
/* process the mandatory attributes */
if (!(transcript_id_hash = gt_hashmap_get(parser->gene_id_hash,
gene_id))) {
transcript_id_hash = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) gt_array_delete);
gt_hashmap_add(parser->gene_id_hash, gt_cstr_dup(gene_id),
transcript_id_hash);
}
gt_assert(transcript_id_hash);
if (!(gt_genome_node_array = gt_hashmap_get(transcript_id_hash,
transcript_id))) {
gt_genome_node_array = gt_array_new(sizeof (GtGenomeNode*));
gt_hashmap_add(transcript_id_hash, gt_cstr_dup(transcript_id),
gt_genome_node_array);
}
gt_assert(gt_genome_node_array);
/* save optional gene_name and transcript_name attributes */
if (transcript_name
&& !gt_hashmap_get(parser->transcript_id_to_name_mapping,
transcript_id)) {
gt_hashmap_add(parser->transcript_id_to_name_mapping,
gt_cstr_dup(transcript_id),
gt_cstr_dup(transcript_name));
}
if (gene_name && !gt_hashmap_get(parser->gene_id_to_name_mapping,
gene_id)) {
gt_hashmap_add(parser->gene_id_to_name_mapping,
gt_cstr_dup(gene_id),
gt_cstr_dup(gene_name));
}
/* get seqid */
seqid_str = gt_hashmap_get(parser->seqid_to_str_mapping, seqname);
if (!seqid_str) {
seqid_str = gt_str_new_cstr(seqname);
gt_hashmap_add(parser->seqid_to_str_mapping, gt_str_get(seqid_str),
seqid_str);
}
gt_assert(seqid_str);
/* construct the new feature */
gn = gt_feature_node_new(seqid_str, type, range.start, range.end,
gt_strand_value);
gt_genome_node_set_origin(gn, filenamestr, line_number);
/* set source */
source_str = gt_hashmap_get(parser->source_to_str_mapping, source);
if (!source_str) {
source_str = gt_str_new_cstr(source);
gt_hashmap_add(parser->source_to_str_mapping, gt_str_get(source_str),
source_str);
}
gt_assert(source_str);
gt_feature_node_set_source((GtFeatureNode*) gn, source_str);
if (score_is_defined)
gt_feature_node_set_score((GtFeatureNode*) gn, score_value);
if (phase_value != GT_PHASE_UNDEFINED)
gt_feature_node_set_phase((GtFeatureNode*) gn, phase_value);
gt_array_add(gt_genome_node_array, gn);
}
gt_str_reset(line_buffer);
}
/* process all region nodes */
if (!had_err)
gt_region_node_builder_build(parser->region_node_builder, genome_nodes);
/* process all feature nodes */
cinfo.genome_nodes = genome_nodes;
cinfo.gene_id_to_name_mapping = parser->gene_id_to_name_mapping;
cinfo.transcript_id_to_name_mapping = parser->transcript_id_to_name_mapping;
if (!had_err) {
had_err = gt_hashmap_foreach(parser->gene_id_hash, construct_genes,
&cinfo, err);
}
/* free */
gt_splitter_delete(splitter);
gt_splitter_delete(attribute_splitter);
gt_str_delete(line_buffer);
return had_err;
}