static int gt_node_visitor_lua_delete(lua_State *L)
{
GtNodeVisitor **gv;
gv = check_genome_visitor(L, 1);
gt_node_visitor_delete(*gv);
return 0;
}
GtNodeVisitor* gt_snp_annotator_visitor_new(GtFeatureNode *gene,
GtTransTable *trans_table,
GtRegionMapping *rmap,
GtError *err)
{
GtNodeVisitor *nv;
GtSNPAnnotatorVisitor *sav;
gt_assert(gene && gt_feature_node_get_type(gene) == gt_symbol(gt_ft_gene));
nv = gt_node_visitor_create(gt_snp_annotator_visitor_class());
sav = snp_annotator_visitor_cast(nv);
sav->gene = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) gene);
sav->rmap = gt_region_mapping_ref(rmap);
sav->mRNA_type = gt_symbol(gt_ft_mRNA);
sav->CDS_type = gt_symbol(gt_ft_CDS);
sav->SNV_type = gt_symbol(gt_ft_SNV);
sav->SNP_type = gt_symbol(gt_ft_SNP);
sav->rnaseqs = gt_hashmap_new(GT_HASH_DIRECT, NULL, gt_free_func);
if (trans_table) {
sav->tt = trans_table;
sav->own_tt = false;
} else {
sav->tt = gt_trans_table_new_standard(err);
sav->own_tt = true;
}
if (!sav->tt || gt_snp_annotator_visitor_prepare_gene(sav, err) != 0) {
gt_node_visitor_delete(nv);
return NULL;
}
return nv;
}
int gt_feature_index_add_gff3file(GtFeatureIndex *feature_index,
const char *gff3file, GtError *err)
{
GtNodeStream *gff3_in_stream;
GtGenomeNode *gn;
GtArray *tmp;
int had_err = 0;
GtUword i;
gt_error_check(err);
gt_assert(feature_index && gff3file);
tmp = gt_array_new(sizeof (GtGenomeNode*));
gff3_in_stream = gt_gff3_in_stream_new_unsorted(1, &gff3file);
while (!(had_err = gt_node_stream_next(gff3_in_stream, &gn, err)) && gn)
gt_array_add(tmp, gn);
if (!had_err) {
GtNodeVisitor *feature_visitor = gt_feature_visitor_new(feature_index);
for (i=0;i<gt_array_size(tmp);i++) {
gn = *(GtGenomeNode**) gt_array_get(tmp, i);
/* no need to lock, add_*_node() is synchronized */
had_err = gt_genome_node_accept(gn, feature_visitor, NULL);
gt_assert(!had_err); /* cannot happen */
}
gt_node_visitor_delete(feature_visitor);
}
gt_node_stream_delete(gff3_in_stream);
for (i=0;i<gt_array_size(tmp);i++)
gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(tmp, i));
gt_array_delete(tmp);
return had_err;
}
static void sequence_node_add_stream_free(GtNodeStream *ns)
{
GtSequenceNodeAddStream *fs = gt_sequence_node_add_stream_cast(ns);
gt_node_visitor_delete(fs->collect_vis);
gt_cstr_table_delete(fs->seqid_table);
gt_str_array_delete(fs->seqids);
gt_node_stream_delete(fs->in_stream);
}
static void gff3_numsorted_out_stream_free(GtNodeStream *ns)
{
GtGFF3NumsortedOutStream *gff3_out_stream =
gff3_numsorted_out_stream_cast(ns);
gt_node_stream_delete(gff3_out_stream->in_stream);
gt_node_visitor_delete(gff3_out_stream->gff3_visitor);
gt_array_delete(gff3_out_stream->buffer);
gt_queue_delete(gff3_out_stream->outqueue);
}
static void gv_test_calc_integrity(AgnUnitTest *test)
{
const char *filename = "data/gff3/gaeval-stream-unit-test-2.gff3";
GtNodeStream *align_in = gt_gff3_in_stream_new_unsorted(1, &filename);
AgnGaevalParams params = { 0.6, 0.3, 0.05, 0.05, 400, 200, 100 };
GtNodeVisitor *nv = agn_gaeval_visitor_new(align_in, params);
AgnGaevalVisitor *gv = gaeval_visitor_cast(nv);
gt_node_stream_delete(align_in);
GtNodeStream *gff3in = gt_gff3_in_stream_new_unsorted(1, &filename);
GtHashmap *typestokeep = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
gt_hashmap_add(typestokeep, "mRNA", "mRNA");
GtNodeStream *filtstream = agn_filter_stream_new(gff3in, typestokeep);
GtLogger *logger = gt_logger_new(true, "", stderr);
GtNodeStream *ics = agn_infer_cds_stream_new(filtstream, NULL, logger);
GtNodeStream *ies = agn_infer_exons_stream_new(ics, NULL, logger);
GtError *error = gt_error_new();
GtArray *feats = gt_array_new( sizeof(GtFeatureNode *) );
GtNodeStream *featstream = gt_array_out_stream_new(ies, feats, error);
int result = gt_node_stream_pull(featstream, error);
if(result == -1)
{
fprintf(stderr, "[AgnGaevalVisitor::gv_test_calc_integrity] error "
"processing GFF3: %s\n", gt_error_get(error));
return;
}
gt_node_stream_delete(gff3in);
gt_node_stream_delete(filtstream);
gt_node_stream_delete(featstream);
gt_node_stream_delete(ics);
gt_node_stream_delete(ies);
gt_logger_delete(logger);
gt_hashmap_delete(typestokeep);
agn_assert(gt_array_size(feats) == 2);
GtFeatureNode *g1 = *(GtFeatureNode **)gt_array_get(feats, 0);
GtFeatureNode *g2 = *(GtFeatureNode **)gt_array_get(feats, 1);
double cov1 = gaeval_visitor_calculate_coverage(gv, g1, error);
double cov2 = gaeval_visitor_calculate_coverage(gv, g2, error);
double int1 = gaeval_visitor_calculate_integrity(gv, g1, cov1, NULL, error);
double int2 = gaeval_visitor_calculate_integrity(gv, g2, cov2, NULL, error);
bool test1 = fabs(cov1 - 1.000) < 0.001 &&
fabs(cov2 - 0.997) < 0.001 &&
fabs(int1 - 0.850) < 0.001 &&
fabs(int2 - 0.863) < 0.001;
agn_unit_test_result(test, "calculate integrity", test1);
gt_error_delete(error);
gt_array_delete(feats);
gt_genome_node_delete((GtGenomeNode *)g1);
gt_genome_node_delete((GtGenomeNode *)g2);
gt_node_visitor_delete(nv);
}
static void gt_ltr_cluster_stream_free(GtNodeStream *ns)
{
unsigned long i;
GtLTRClusterStream *lcs = gt_ltr_cluster_stream_cast(ns);
gt_node_visitor_delete((GtNodeVisitor*) lcs->lcv);
gt_hashmap_delete(lcs->feat_to_encseq);
gt_str_array_delete(lcs->feat_to_encseq_keys);
for (i = 0; i < gt_array_size(lcs->nodes); i++)
gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(lcs->nodes, i));
gt_array_delete(lcs->nodes);
gt_node_stream_delete(lcs->in_stream);
}
static int snp_annotator_stream_process_current_gene(GtSNPAnnotatorStream *sas,
GtError *err)
{
int had_err = 0;
GtUword i;
GtUword nof_genes = gt_array_size(sas->cur_gene_set);
gt_error_check(err);
if (gt_queue_size(sas->snps) > 0) {
/* we need to process SNPs for a gene cluster*/
gt_assert(gt_queue_size(sas->outqueue) == 0);
for (i = 0; !had_err && i < nof_genes; i++) {
GtNodeVisitor *sav;
GtFeatureNode *gene;
gene = *(GtFeatureNode**) gt_array_get(sas->cur_gene_set, i);
sav = gt_snp_annotator_visitor_new(gene, sas->tt, sas->rmap, err);
if (!sav)
had_err = -1;
if (!had_err) {
if (i < nof_genes-1) {
had_err = gt_queue_iterate(sas->snps,
snp_annotator_stream_process_snp,
sav, err);
} else {
while (!had_err && gt_queue_size(sas->snps) > 0) {
GtFeatureNode *snp = (GtFeatureNode*) gt_queue_get(sas->snps);
had_err = gt_genome_node_accept((GtGenomeNode*) snp, sav, err);
gt_queue_add(sas->outqueue, snp);
gt_genome_node_delete((GtGenomeNode*) snp);
}
}
gt_node_visitor_delete(sav);
}
gt_genome_node_delete((GtGenomeNode*) gene);
}
} else {
/* no SNPs for this gene cluster, delete it */
for (i = 0; !had_err && i < nof_genes; i++) {
gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(sas->cur_gene_set,
i));
}
}
gt_assert(gt_queue_size(sas->snps) == 0);
gt_array_reset(sas->cur_gene_set);
return had_err;
}
int gt_regioncov(int argc, const char **argv, GtError *err)
{
GtNodeVisitor *regioncov_visitor;
GtNodeStream *gff3_in_stream;
GtGenomeNode *gn;
RegionCovArguments arguments;
int parsed_args, had_err = 0;
gt_error_check(err);
/* option parsing */
switch (parse_options(&parsed_args, &arguments, argc, argv, err)) {
case OPTIONPARSER_OK: break;
case OPTIONPARSER_ERROR:
return -1;
case OPTIONPARSER_REQUESTS_EXIT:
return 0;
}
/* create gff3 input stream */
gt_assert(parsed_args < argc);
gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args]);
if (arguments.verbose)
gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);
/* create region coverage visitor */
regioncov_visitor = gt_regioncov_visitor_new(arguments.max_feature_dist);
/* pull the features through the stream and free them afterwards */
while (!(had_err = gt_node_stream_next(gff3_in_stream, &gn, err)) && gn) {
had_err = gt_genome_node_accept(gn, regioncov_visitor, err);
gt_genome_node_delete(gn);
}
/* show region coverage */
if (!had_err)
gt_regioncov_visitor_show_coverage(regioncov_visitor);
/* free */
gt_node_visitor_delete(regioncov_visitor);
gt_node_stream_delete(gff3_in_stream);
return had_err;
}
void gt_ltrfileout_stream_free(GtNodeStream *ns)
{
GtLTRdigestFileOutStream *ls = gt_ltrdigest_file_out_stream_cast(ns);
if (ls->tabout_file != NULL)
gt_file_delete(ls->tabout_file);
if (ls->pbsout_file != NULL)
gt_file_delete(ls->pbsout_file);
if (ls->pptout_file != NULL)
gt_file_delete(ls->pptout_file);
if (ls->ltr5out_file != NULL)
gt_file_delete(ls->ltr5out_file);
if (ls->ltr3out_file != NULL)
gt_file_delete(ls->ltr3out_file);
if (ls->elemout_file != NULL)
gt_file_delete(ls->elemout_file);
gt_hashmap_delete(ls->pdomout_files);
gt_hashmap_delete(ls->pdomali_files);
gt_hashmap_delete(ls->pdomaa_files);
gt_node_visitor_delete((GtNodeVisitor*) ls->lv);
gt_node_stream_delete(ls->in_stream);
}
static int gt_select_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
SelectArguments *arguments = tool_arguments;
GtNodeStream *gff3_in_stream, *select_stream,
*targetbest_select_stream = NULL, *gff3_out_stream;
int had_err;
GtFile *drop_file = NULL;
GtNodeVisitor *gff3outvis = NULL;
gt_error_check(err);
gt_assert(arguments);
/* create a gff3 input stream */
gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args,
argv + parsed_args);
if (arguments->verbose && arguments->outfp)
gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);
/* create a filter stream */
select_stream = gt_select_stream_new(gff3_in_stream, arguments->seqid,
arguments->source,
&arguments->contain_range,
&arguments->overlap_range,
arguments->strand,
arguments->targetstrand,
arguments->has_CDS,
arguments->max_gene_length,
arguments->max_gene_num,
arguments->min_gene_score,
arguments->max_gene_score,
arguments->min_average_splice_site_prob,
arguments->feature_num,
arguments->filter_files,
arguments->filter_logic,
err);
if (select_stream) {
GtSelectStream *fs = (GtSelectStream*) select_stream;
if (gt_str_length(arguments->dropped_file) > 0) {
drop_file = gt_file_new(gt_str_get(arguments->dropped_file), "w", err);
gff3outvis = gt_gff3_visitor_new(drop_file);
gt_select_stream_set_drophandler(fs, print_to_file_drophandler,
(void*) gff3outvis);
} else {
gt_select_stream_set_drophandler(fs, default_drophandler, NULL);
}
gt_select_stream_set_single_intron_factor(select_stream,
arguments->single_intron_factor);
if (arguments->targetbest)
targetbest_select_stream = gt_targetbest_select_stream_new(select_stream);
/* create a gff3 output stream */
gff3_out_stream = gt_gff3_out_stream_new(arguments->targetbest
? targetbest_select_stream
: select_stream,
arguments->outfp);
/* pull the features through the stream and free them afterwards */
had_err = gt_node_stream_pull(gff3_out_stream, err);
/* free */
gt_node_stream_delete(gff3_out_stream);
gt_node_stream_delete(select_stream);
gt_node_stream_delete(targetbest_select_stream);
} else {
had_err = -1;
}
gt_file_delete(drop_file);
gt_node_visitor_delete(gff3outvis);
gt_node_stream_delete(gff3_in_stream);
return had_err;
}
static void cds_check_stream_free(GtNodeStream *ns)
{
GtCDSCheckStream *cs = cds_check_stream_cast(ns);
gt_node_stream_delete(cs->in_stream);
gt_node_visitor_delete(cs->cds_check_visitor);
}
static void inter_feature_stream_free(GtNodeStream *ns)
{
GtInterFeatureStream *ais = gt_inter_feature_stream_cast(ns);
gt_node_visitor_delete(ais->inter_feature_visitor);
gt_node_stream_delete(ais->in_stream);
}
GtNodeVisitor*
agn_gaeval_visitor_new(GtNodeStream *astream, AgnGaevalParams gparams)
{
agn_assert(astream);
// Create the node visitor
GtNodeVisitor *nv = gt_node_visitor_create(gaeval_visitor_class());
AgnGaevalVisitor *v = gaeval_visitor_cast(nv);
v->alignments = gt_feature_index_memory_new();
v->tsvout = NULL;
v->params = gparams;
// Check that sum of weights is 1.0
double weights_total = gparams.alpha + gparams.beta +
gparams.gamma + gparams.epsilon;
if(fabs(weights_total - 1.0) > 0.0001)
{
fprintf(stderr, "[AgnGaevalVisitor::agn_gaeval_visitor_new] warning: "
"sum of weights is not 1.0 %.3lf; integrity calculations will be "
"incorrect\n", weights_total);
}
// Set up node stream to load alignment features into memory
GtQueue *streams = gt_queue_new();
GtNodeStream *stream, *last_stream;
GtHashmap *typestokeep = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
gt_hashmap_add(typestokeep, "cDNA_match", "cDNA_match");
gt_hashmap_add(typestokeep, "EST_match", "EST_match");
gt_hashmap_add(typestokeep, "nucleotide_match", "nucleotide_match");
stream = agn_filter_stream_new(astream, typestokeep);
gt_queue_add(streams, stream);
last_stream = stream;
stream = gt_feature_out_stream_new(last_stream, v->alignments);
gt_queue_add(streams, stream);
last_stream = stream;
stream = gt_inter_feature_stream_new(last_stream, "cDNA_match", "match_gap");
gt_queue_add(streams, stream);
last_stream = stream;
stream = gt_inter_feature_stream_new(last_stream, "EST_match", "match_gap");
gt_queue_add(streams, stream);
last_stream = stream;
stream = gt_inter_feature_stream_new(last_stream, "nucleotide_match",
"match_gap");
gt_queue_add(streams, stream);
last_stream = stream;
// Process the node stream
GtError *error = gt_error_new();
int result = gt_node_stream_pull(last_stream, error);
if(result == -1)
{
fprintf(stderr, "[AEGeAn::AgnGaevalStream] error parsing alignments: %s\n",
gt_error_get(error));
gt_node_visitor_delete(nv);
return NULL;
}
gt_error_delete(error);
gt_hashmap_delete(typestokeep);
while(gt_queue_size(streams) > 0)
{
stream = gt_queue_get(streams);
gt_node_stream_delete(stream);
}
gt_queue_delete(streams);
return nv;
}
static void visitor_stream_free(GtNodeStream *ns)
{
GtVisitorStream *visitor_stream = visitor_stream_cast(ns);
gt_node_visitor_delete(visitor_stream->visitor);
gt_node_stream_delete(visitor_stream->in_stream);
}
static void filter_stream_free(GtNodeStream *gs)
{
GtFilterStream *fs = gt_filter_stream_cast(gs);
gt_node_visitor_delete(fs->filter_visitor);
gt_node_stream_delete(fs->in_stream);
}
static void select_stream_free(GtNodeStream *ns)
{
GtSelectStream *fs = gt_select_stream_cast(ns);
gt_node_visitor_delete(fs->select_visitor);
gt_node_stream_delete(fs->in_stream);
}
static void stat_stream_free(GtNodeStream *ns)
{
GtStatStream *stat_stream = stat_stream_cast(ns);
gt_node_visitor_delete(stat_stream->stat_visitor);
gt_node_stream_delete(stat_stream->in_stream);
}
static void bssm_train_stream_free(GtNodeStream *ns)
{
GthBSSMTrainStream *bssm_train_stream = bssm_train_stream_cast(ns);
gt_node_visitor_delete(bssm_train_stream->bssm_train_visitor);
gt_node_stream_delete(bssm_train_stream->in_stream);
}
int gt_condenseq_output_to_gff3(const GtCondenseq *condenseq,
GtError *err)
{
int had_err = 0;
GtUword idx,
name_len,
seqnum = 0, seqstart = 0, seqend = 0,
desclen;
GtStr *filename = NULL,
*id = gt_str_new_cstr("U"),
*name = gt_str_new_cstr("unique"),
*parent_unique = gt_str_new_cstr("U"),
*seqid = gt_str_new(),
*source = gt_str_new_cstr("Condenseq");
GtFile *outfile = NULL;
GtGFF3Visitor *gffv = NULL;
GtNodeVisitor *nodev = NULL;
GtFeatureNode *fnode = NULL;
GtGenomeNode *node = NULL;
GtRange range;
gt_assert(condenseq != NULL);
filename = gt_str_new_cstr(gt_condenseq_basefilename(condenseq));
name_len = gt_str_length(name);
gt_str_append_cstr(filename, ".gff3");
outfile = gt_file_new(gt_str_get(filename), "w", err);
nodev = gt_gff3_visitor_new(outfile);
gffv = (GtGFF3Visitor *) nodev;
gt_gff3_visitor_retain_id_attributes(gffv);
node = gt_feature_node_new(seqid, "experimental_feature", (GtUword) 1,
(GtUword) 1, GT_STRAND_BOTH);
fnode = (GtFeatureNode*) node;
gt_feature_node_set_source(fnode, source);
for (idx = 0; !had_err && idx < condenseq->udb_nelems; ++idx) {
GtCondenseqUnique uq = condenseq->uniques[idx];
if (seqend <= uq.orig_startpos) {
const char *desc;
gt_genome_node_delete(node);
seqnum = gt_condenseq_pos2seqnum(condenseq, uq.orig_startpos);
seqstart = gt_condenseq_seqstartpos(condenseq, seqnum);
seqend = seqstart + condenseq_seqlength_help(condenseq, seqnum, seqstart);
desc = gt_condenseq_description(condenseq, &desclen, seqnum);
gt_str_reset(seqid);
gt_str_append_cstr_nt(seqid, desc, desclen);
node = gt_feature_node_new(seqid, "experimental_feature", (GtUword) 1,
(GtUword) 1, GT_STRAND_BOTH);
fnode = (GtFeatureNode*) node;
gt_feature_node_set_source(fnode, source);
}
gt_str_set_length(name, name_len);
gt_str_append_uword(name, idx);
gt_str_set_length(id, (GtUword) 1);
gt_str_append_uword(id, idx);
gt_feature_node_set_attribute(fnode, "Name", gt_str_get(name));
gt_feature_node_set_attribute(fnode, "ID", gt_str_get(id));
/* 1 Based coordinates! */
range.start = uq.orig_startpos + 1 - seqstart;
range.end = uq.orig_startpos + uq.len - seqstart;
gt_genome_node_set_range(node, &range);
had_err = gt_genome_node_accept(node, nodev, err);
}
gt_str_reset(name);
gt_str_append_cstr(name, "link");
gt_str_reset(id);
gt_str_append_cstr(id, "L");
name_len = gt_str_length(name);
seqend = 0;
for (idx = 0; !had_err && idx < condenseq->ldb_nelems; ++idx) {
GtCondenseqLink link = condenseq->links[idx];
if (seqend <= link.orig_startpos) {
const char *desc;
gt_genome_node_delete(node);
seqnum = gt_condenseq_pos2seqnum(condenseq, link.orig_startpos);
seqstart = gt_condenseq_seqstartpos(condenseq, seqnum);
seqend = seqstart + condenseq_seqlength_help(condenseq, seqnum, seqstart);
desc = gt_condenseq_description(condenseq, &desclen, seqnum);
gt_str_reset(seqid);
gt_str_append_cstr_nt(seqid, desc, desclen);
node = gt_feature_node_new(seqid, "experimental_feature", (GtUword) 1,
(GtUword) 1, GT_STRAND_BOTH);
fnode = (GtFeatureNode*) node;
gt_feature_node_set_source(fnode, source);
}
gt_str_set_length(name, name_len);
gt_str_append_uword(name, idx);
gt_str_set_length(id, (GtUword) 1);
gt_str_append_uword(id, idx);
gt_feature_node_set_attribute(fnode, "Name", gt_str_get(name));
gt_feature_node_set_attribute(fnode, "ID", gt_str_get(id));
gt_str_set_length(parent_unique, (GtUword) 1);
gt_str_append_uword(parent_unique, link.unique_id);
gt_feature_node_set_attribute(fnode, "Derives_from",
gt_str_get(parent_unique));
/* 1 Based coordinates! */
range.start = link.orig_startpos + 1 - seqstart;
range.end = link.orig_startpos + link.len - seqstart;
gt_genome_node_set_range(node, &range);
had_err = gt_genome_node_accept(node, nodev, err);
}
gt_file_delete(outfile);
gt_genome_node_delete(node);
gt_node_visitor_delete(nodev);
gt_str_delete(filename);
gt_str_delete(id);
gt_str_delete(name);
gt_str_delete(parent_unique);
gt_str_delete(seqid);
gt_str_delete(source);
return had_err;
}
static void feature_stream_free(GtNodeStream *gs)
{
GtFeatureStream *feature_stream = feature_stream_cast(gs);
gt_node_stream_delete(feature_stream->in_stream);
gt_node_visitor_delete(feature_stream->feature_visitor);
}
