static void gtf_visitor_free(GtNodeVisitor *nv)
{
GtGTFVisitor *gtf_visitor = gtf_visitor_cast(nv);
gt_assert(gtf_visitor);
gt_array_delete(gtf_visitor->exon_features);
gt_array_delete(gtf_visitor->CDS_features);
}
static bool chain_is_filled_and_consistent(GthChain *chain,
unsigned long gen_total_length,
unsigned long gen_offset)
{
GtArray *testranges;
/* check of file sequence numbers are defined */
if (chain->gen_file_num == GT_UNDEF_ULONG ||
chain->gen_seq_num == GT_UNDEF_ULONG ||
chain->ref_file_num == GT_UNDEF_ULONG ||
chain->ref_seq_num == GT_UNDEF_ULONG) {
return false;
}
if (!gt_ranges_are_consecutive(chain->forwardranges))
return false;
testranges = gt_array_new(sizeof (GtRange));
gt_ranges_copy_to_opposite_strand(testranges, chain->reverseranges,
gen_total_length, gen_offset);
if (!gt_ranges_are_equal(testranges, chain->forwardranges)) {
gt_array_delete(testranges);
return false;
}
gt_array_delete(testranges);
return true;
}
static void snp_annotator_stream_free(GtNodeStream *ns)
{
GtUword i;
GtSNPAnnotatorStream *sas;
if (!ns) return;
sas = gt_snp_annotator_stream_cast(ns);
gt_region_mapping_delete(sas->rmap);
while (gt_queue_size(sas->snps) > 0) {
gt_genome_node_delete((GtGenomeNode*) gt_queue_get(sas->snps));
}
while (gt_queue_size(sas->outqueue) > 0) {
gt_genome_node_delete((GtGenomeNode*) gt_queue_get(sas->outqueue));
}
for (i = 0; i < gt_array_size(sas->instreams); i++) {
gt_node_stream_delete(*(GtNodeStream**) gt_array_get(sas->instreams, i));
}
for (i = 0; i < gt_array_size(sas->cur_gene_set); i++) {
gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(sas->cur_gene_set, i));
}
gt_array_delete(sas->cur_gene_set);
gt_node_stream_delete(sas->merge_stream);
gt_array_delete(sas->instreams);
gt_queue_delete(sas->snps);
gt_queue_delete(sas->outqueue);
}
void gt_type_node_delete(GtTypeNode *type_node)
{
if (!type_node) return;
gt_hashmap_delete(type_node->cache);
gt_array_delete(type_node->is_a_out_edges);
gt_array_delete(type_node->part_of_list);
gt_array_delete(type_node->is_a_list);
gt_free(type_node);
}
void gth_chain_delete(GthChain *chain)
{
if (!chain) return;
if (chain->jump_table_delete) {
chain->jump_table_delete(chain->reverse_jump_table);
chain->jump_table_delete(chain->forward_jump_table);
}
gt_array_delete(chain->forwardranges);
gt_array_delete(chain->reverseranges);
gt_free(chain);
}
static void gt_hmmer_model_hit_delete(GtHMMERModelHit *mh)
{
unsigned long i;
if (!mh) return;
for (i = 0; i < gt_array_size(mh->fwd_hits); i++)
gt_free(*(GtHMMERSingleHit**) gt_array_get(mh->fwd_hits, i));
gt_array_delete(mh->fwd_hits);
for (i = 0; i < gt_array_size(mh->rev_hits); i++)
gt_free(*(GtHMMERSingleHit**) gt_array_get(mh->rev_hits, i));
gt_array_delete(mh->rev_hits);
gt_free(mh);
}
static void gv_test_introns_confirmed(AgnUnitTest *test)
{
GtGenomeNode *intron, *gap;
GtStr *seqid = gt_str_new_cstr("chr");
GtArray *introns = gt_array_new( sizeof(GtGenomeNode *) );
intron = gt_feature_node_new(seqid, "intron", 1000, 1170, GT_STRAND_REVERSE);
gt_array_add(introns, intron);
intron = gt_feature_node_new(seqid, "intron", 1225, 1305, GT_STRAND_REVERSE);
gt_array_add(introns, intron);
intron = gt_feature_node_new(seqid, "intron", 1950, 2110, GT_STRAND_REVERSE);
gt_array_add(introns, intron);
intron = gt_feature_node_new(seqid, "intron", 2545, 2655, GT_STRAND_REVERSE);
gt_array_add(introns, intron);
intron = gt_feature_node_new(seqid, "intron", 2800, 2950, GT_STRAND_REVERSE);
gt_array_add(introns, intron);
GtArray *gaps = gt_array_new( sizeof(GtGenomeNode *) );
double intcon = gaeval_visitor_introns_confirmed(introns, gaps);
bool test1 = fabs(intcon - 0.0) < 0.0001;
agn_unit_test_result(test, "introns confirmed (no gaps)", test1);
gap = gt_feature_node_new(seqid, "match_gap", 1000, 1170, GT_STRAND_REVERSE);
gt_array_add(gaps, gap);
gap = gt_feature_node_new(seqid, "match_gap", 1225, 1302, GT_STRAND_REVERSE);
gt_array_add(gaps, gap);
gap = gt_feature_node_new(seqid, "match_gap", 1950, 2110, GT_STRAND_REVERSE);
gt_array_add(gaps, gap);
gap = gt_feature_node_new(seqid, "match_gap", 2575, 2655, GT_STRAND_REVERSE);
gt_array_add(gaps, gap);
gap = gt_feature_node_new(seqid, "match_gap", 2800, 2950, GT_STRAND_REVERSE);
gt_array_add(gaps, gap);
intcon = gaeval_visitor_introns_confirmed(introns, gaps);
bool test2 = fabs(intcon - 0.6) < 0.0001;
agn_unit_test_result(test, "introns confirmed (gaps)", test2);
while(gt_array_size(introns) > 0)
{
intron = *(GtGenomeNode **)gt_array_pop(introns);
gt_genome_node_delete(intron);
}
gt_array_delete(introns);
while(gt_array_size(gaps) > 0)
{
gap = *(GtGenomeNode **)gt_array_pop(gaps);
gt_genome_node_delete(gap);
}
gt_array_delete(gaps);
gt_str_delete(seqid);
}
bool gth_sa_exons_are_forward_and_consecutive(const GthSA *sa)
{
GtArray *ranges;
gt_assert(sa);
ranges = gt_array_new(sizeof (GtRange));
gth_sa_get_exons(sa, ranges);
if (!gt_ranges_are_consecutive(ranges)) {
gt_array_delete(ranges);
return false;
}
gt_array_delete(ranges);
return true;
}
void gth_sa_delete(GthSA *sa)
{
if (!sa) return;
gth_backtrace_path_delete(sa->backtrace_path);
gt_array_delete(sa->exons);
gt_array_delete(sa->introns);
gt_str_delete(sa->gen_id);
gt_str_delete(sa->ref_id);
gt_str_delete(sa->gen_md5);
gt_str_delete(sa->ref_md5);
gt_str_delete(sa->gen_desc);
gt_str_delete(sa->ref_desc);
gt_str_delete(sa->gff3_target_attribute);
gt_free(sa);
}
void agn_bron_kerbosch( GtArray *R, GtArray *P, GtArray *X, GtArray *cliques,
bool skipsimplecliques )
{
gt_assert(R != NULL && P != NULL && X != NULL && cliques != NULL);
if(gt_array_size(P) == 0 && gt_array_size(X) == 0)
{
if(skipsimplecliques == false || gt_array_size(R) != 1)
{
GtUword i;
AgnTranscriptClique *clique = agn_transcript_clique_new();
for(i = 0; i < gt_array_size(R); i++)
{
GtFeatureNode *transcript = *(GtFeatureNode **)gt_array_get(R, i);
agn_transcript_clique_add(clique, transcript);
}
gt_array_add(cliques, clique);
}
}
while(gt_array_size(P) > 0)
{
GtGenomeNode *v = *(GtGenomeNode **)gt_array_get(P, 0);
// newR = R \union {v}
GtArray *newR = agn_gt_array_copy(R, sizeof(GtGenomeNode *));
gt_array_add(newR, v);
// newP = P \intersect N(v)
GtArray *newP = agn_feature_neighbors(v, P);
// newX = X \intersect N(v)
GtArray *newX = agn_feature_neighbors(v, X);
// Recursive call
// agn_bron_kerbosch(R \union {v}, P \intersect N(v), X \intersect N(X))
agn_bron_kerbosch(newR, newP, newX, cliques, skipsimplecliques);
// Delete temporary arrays just created
gt_array_delete(newR);
gt_array_delete(newP);
gt_array_delete(newX);
// P := P \ {v}
gt_array_rem(P, 0);
// X := X \union {v}
gt_array_add(X, v);
}
}
static void infer_cds_visitor_test_data(GtQueue *queue)
{
GtError *error = gt_error_new();
const char *file = "data/gff3/grape-codons.gff3";
GtNodeStream *gff3in = gt_gff3_in_stream_new_unsorted(1, &file);
gt_gff3_in_stream_check_id_attributes((GtGFF3InStream *)gff3in);
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream *)gff3in);
GtLogger *logger = gt_logger_new(true, "", stderr);
GtNodeStream *icv_stream = agn_infer_cds_stream_new(gff3in, NULL, logger);
GtArray *feats = gt_array_new( sizeof(GtFeatureNode *) );
GtNodeStream *arraystream = gt_array_out_stream_new(icv_stream, feats, error);
int pullresult = gt_node_stream_pull(arraystream, error);
if(pullresult == -1)
{
fprintf(stderr, "[AgnInferCDSVisitor::infer_cds_visitor_test_data] error "
"processing features: %s\n", gt_error_get(error));
}
gt_node_stream_delete(gff3in);
gt_node_stream_delete(icv_stream);
gt_node_stream_delete(arraystream);
gt_logger_delete(logger);
gt_array_sort(feats, (GtCompare)agn_genome_node_compare);
gt_array_reverse(feats);
while(gt_array_size(feats) > 0)
{
GtFeatureNode *fn = *(GtFeatureNode **)gt_array_pop(feats);
gt_queue_add(queue, fn);
}
gt_array_delete(feats);
gt_error_delete(error);
}
static int feature_index_lua_get_features_for_range(lua_State *L)
{
GtFeatureIndex **feature_index;
const char *seqid;
GtRange *range;
GtError *err;
bool has_seqid;
GtArray *features;
GT_UNUSED int had_err;
feature_index = check_feature_index(L, 1);
seqid = luaL_checkstring(L, 2);
err = gt_error_new();
if (gt_feature_index_has_seqid(*feature_index, &has_seqid, seqid, err))
return gt_lua_error(L, err);
gt_error_delete(err);
luaL_argcheck(L, has_seqid, 2,
"feature_index does not contain seqid");
range = check_range(L, 3);
features = gt_array_new(sizeof (GtGenomeNode*));
err = gt_error_new();
had_err = gt_feature_index_get_features_for_range(*feature_index, features,
seqid, range, err);
if (had_err)
return gt_lua_error(L, err);
gt_error_delete(err);
push_features_as_table(L, features);
gt_array_delete(features);
return 1;
}
void gt_splicedseq_delete(Splicedseq *ss)
{
if (!ss) return;
gt_str_delete(ss->splicedseq);
gt_array_delete(ss->positionmapping);
gt_free(ss);
}
void gt_diagram_delete(GtDiagram *diagram)
{
if (!diagram) return;
gt_rwlock_wrlock(diagram->lock);
gt_array_delete(diagram->features);
if (diagram->blocks)
gt_hashmap_delete(diagram->blocks);
gt_hashmap_delete(diagram->nodeinfo);
gt_hashmap_delete(diagram->collapsingtypes);
gt_hashmap_delete(diagram->groupedtypes);
gt_hashmap_delete(diagram->caption_display_status);
gt_array_delete(diagram->custom_tracks);
gt_rwlock_unlock(diagram->lock);
gt_rwlock_delete(diagram->lock);
gt_free(diagram);
}
void gt_tool_iterator_delete(GtToolIterator *tool_iterator)
{
if (!tool_iterator) return;
gt_array_delete(tool_iterator->tool_stack);
gt_str_delete(tool_iterator->prefixptr);
gt_free(tool_iterator);
}
static void split_cds_feature(GtFeatureNode *cds_feature, GtFeatureNode *fn)
{
GtArray *parents;
unsigned long i;
gt_assert(cds_feature && fn);
/* find parents */
parents = find_cds_parents(cds_feature, fn);
/* remove CDS feature */
gt_feature_node_remove_leaf(fn, cds_feature);
/* add CDS feature to all parents */
for (i = 0; i < gt_array_size(parents); i++) {
GtFeatureNode *parent = *(GtFeatureNode**) gt_array_get(parents, i);
const char *id = gt_feature_node_get_attribute(parent, GT_GFF_ID);
if (!i) {
gt_feature_node_set_attribute(cds_feature, GT_GFF_PARENT, id);
gt_feature_node_add_child(parent, cds_feature);
}
else {
GtFeatureNode *new_cds = gt_feature_node_clone(cds_feature);
gt_feature_node_set_attribute(new_cds, GT_GFF_PARENT, id);
gt_feature_node_add_child(parent, new_cds);
gt_genome_node_delete((GtGenomeNode*) cds_feature);
}
}
gt_array_delete(parents);
}
static void potentialintronspostpro(GtArray *intronstoprocess,
unsigned long icdelta,
unsigned long icminremintronlength)
{
GtArray *originalintrons;
GtRange potintron;
unsigned long i, potintronlength,
minintronlength = 2 * icdelta + icminremintronlength;
originalintrons = gt_array_new(sizeof (GtRange));
/* save all (potential) introns */
gt_array_add_array(originalintrons, intronstoprocess);
/* reset introns to process */
gt_array_set_size(intronstoprocess, 0);
/* store introns */
for (i = 0; i < gt_array_size(originalintrons); i++) {
potintron = *(GtRange*) gt_array_get(originalintrons, i);
potintronlength = potintron.end - potintron.start + 1;
if (potintronlength >= minintronlength) {
/* keep this intron (plus/minus intron deltas)
that is, this intron is cut out later */
potintron.start += icdelta;
potintron.end -= icdelta;
gt_array_add(intronstoprocess, potintron);
}
/* else: skip this intron
that is, this intron is not cut out later */
}
gt_array_delete(originalintrons);
}
void gt_feature_node_iterator_delete(GtFeatureNodeIterator *fni)
{
if (!fni) return;
gt_genome_node_delete((GtGenomeNode*) fni->fn);
gt_array_delete(fni->feature_stack);
gt_free(fni);
}
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 findmaximalscores_withoverlaps(GtChain *chain,
GtChaininfo *chaininfo,
GtFragment *fragments,
unsigned long num_of_fragments,
unsigned long max_gap_width,
unsigned long seqlen1,
double mincoverage,
GtChainProc chainprocessor,
void *cpinfo,
Overlapinfo *overlapinfo)
{
unsigned long i, startfrag;
GtArray *startfragments;
gt_assert(seqlen1 != GT_UNDEF_ULONG);
gt_assert(mincoverage != GT_UNDEF_DOUBLE);
startfragments = gt_array_new(sizeof (unsigned long));
/* compute chain array */
for (i = 0; i < num_of_fragments; i++) {
if (overlapinfo[i].active) {
/* current fragment is active */
if (overlapinfo[overlapinfo[i].startofchain].chainarray ==
UNDEFPREVIOUS) {
if (((double) overlapinfo[i].dim1lengthofchain / (double) seqlen1) >=
mincoverage) {
/* no other fragment has the same start fragment yet and coverage is
high enough -> store end fragment */
overlapinfo[overlapinfo[i].startofchain].chainarray = i;
/* since this is the first time, store start fragment number
to avoid additional scan of all fragments below */
gt_array_add(startfragments, overlapinfo[i].startofchain);
}
}
else if (overlapinfo[i].dim1lengthofchain >
overlapinfo[overlapinfo[overlapinfo[i].startofchain].chainarray]
.dim1lengthofchain) {
/* coverage is higher then coverage of earlier start fragment
-> update end fragment */
overlapinfo[overlapinfo[i].startofchain].chainarray = i;
}
}
}
/* retrieve maximal chains */
for (i = 0; i < gt_array_size(startfragments); i++) {
startfrag = *(unsigned long*) gt_array_get(startfragments, i);
gt_assert(overlapinfo[startfrag].chainarray != UNDEFPREVIOUS);
gt_chain_reset(chain);
gt_chain_set_score(chain,
chaininfo[overlapinfo[startfrag].chainarray].score);
retracepreviousinchain(chain, chaininfo, num_of_fragments,
overlapinfo[startfrag].chainarray);
chainprocessor(chain, fragments, num_of_fragments, max_gap_width, cpinfo);
}
gt_array_delete(startfragments);
}
static int gt_ltrdigest_pdom_visitor_attach_hit(GtLTRdigestPdomVisitor *lv,
GtHMMERModelHit *modelhit,
GtHMMERSingleHit *singlehit)
{
GT_UNUSED GtUword i;
GtGenomeNode *gf;
int had_err = 0;
GtRange rrng;
gt_assert(lv && singlehit);
rrng = gt_ltrdigest_pdom_visitor_coords(lv, singlehit);
if (gt_array_size(singlehit->chains) > 0 || lv->output_all_chains) {
char buf[32];
gf = gt_feature_node_new(gt_genome_node_get_seqid((GtGenomeNode*)
lv->ltr_retrotrans),
gt_ft_protein_match,
rrng.start,
rrng.end,
singlehit->strand);
gt_genome_node_add_user_data((GtGenomeNode*) gf, "pdom_alignment",
gt_str_ref(singlehit->alignment),
(GtFree) gt_str_delete);
gt_genome_node_add_user_data((GtGenomeNode*) gf, "pdom_aaseq",
gt_str_ref(singlehit->aastring),
(GtFree) gt_str_delete);
gt_feature_node_set_source((GtFeatureNode*) gf, lv->tag);
gt_feature_node_set_score((GtFeatureNode*) gf, (float) singlehit->evalue);
(void) snprintf(buf, (size_t) 32, "%d", (int) singlehit->frame);
gt_feature_node_add_attribute((GtFeatureNode*) gf,
"reading_frame", buf);
if (modelhit->modelname != NULL) {
gt_feature_node_add_attribute((GtFeatureNode*) gf, "name",
modelhit->modelname);
}
if (gt_array_size(singlehit->chains) > 1UL && lv->output_all_chains) {
GtStr *buffer;
GtUword j;
gt_assert(singlehit->chains != NULL);
buffer = gt_str_new();
for (j = 0UL; j < gt_array_size(singlehit->chains); j++) {
gt_str_append_cstr(buffer, modelhit->modelname);
gt_str_append_char(buffer, ':');
gt_str_append_ulong(buffer,
*(GtUword*) gt_array_get(singlehit->chains, j));
if (j != gt_array_size(singlehit->chains) - 1) {
gt_str_append_char(buffer, ',');
}
}
gt_feature_node_set_attribute((GtFeatureNode*) gf, "chains",
gt_str_get(buffer));
gt_str_delete(buffer);
}
gt_feature_node_add_child(lv->ltr_retrotrans, (GtFeatureNode*) gf);
}
gt_array_delete(singlehit->chains);
singlehit->chains = NULL;
return had_err;
}
static int m2i_change_target_seqids(GtFeatureNode *fn, const char *target,
GtRegionMapping *region_mapping,
GtError *err)
{
GtStrArray *target_ids;
GtArray *target_ranges, *target_strands;
GtStr *desc, *new_seqid;
unsigned long i;
int had_err;
gt_error_check(err);
gt_assert(fn && target && region_mapping);
target_ids = gt_str_array_new();
target_ranges = gt_array_new(sizeof (GtRange));
target_strands = gt_array_new(sizeof (GtStrand));
desc = gt_str_new();
new_seqid = gt_str_new();
had_err = gt_gff3_parser_parse_all_target_attributes(target, false,
target_ids,
target_ranges,
target_strands, "", 0,
err);
for (i = 0; !had_err && i < gt_str_array_size(target_ids); i++) {
GtStr *seqid;
gt_str_reset(desc);
gt_str_reset(new_seqid);
seqid = gt_str_array_get_str(target_ids, i);
had_err = gt_region_mapping_get_description(region_mapping, desc, seqid,
err);
if (!had_err)
gt_regular_seqid_save(new_seqid, desc);
gt_str_array_set(target_ids, i, new_seqid);
}
if (!had_err) {
GtStr *new_target = gt_str_new();
gt_gff3_parser_build_target_str(new_target, target_ids, target_ranges,
target_strands);
gt_feature_node_set_attribute(fn, GT_GFF_TARGET, gt_str_get(new_target));
gt_str_delete(new_target);
}
gt_str_delete(new_seqid);
gt_str_delete(desc);
gt_array_delete(target_strands);
gt_array_delete(target_ranges);
gt_str_array_delete(target_ids);
return had_err;
}
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);
}
void gth_pgl_collection_delete(GthPGLCollection *pgl_collection)
{
GtUword i;
if (!pgl_collection) return;
for (i = 0; i < gt_array_size(pgl_collection->pgls); i++)
gth_pgl_delete(*(GthPGL**) gt_array_get(pgl_collection->pgls, i));
gt_array_delete(pgl_collection->pgls);
gt_free(pgl_collection);
}
void gt_class_alloc_clean(void)
{
GtUword i;
if (!c_classes) return;
for (i = 0; i < gt_array_size(c_classes); i++)
gt_free(*(void**) gt_array_get(c_classes, i));
gt_array_delete(c_classes);
c_classes = NULL;
}
void gt_clustered_set_union_find_delete(GtClusteredSet *cs,
GT_UNUSED GtError *err)
{
if (!cs) return;
GtClusteredSetUF *cs_uf = (GtClusteredSetUF*) cs;
gt_free(cs_uf->cluster_elems);
gt_array_delete(cs_uf->cluster_info);
gt_bittab_delete(cs_uf->in_cluster);
}
void gt_layout_delete(GtLayout *layout)
{
if (!layout) return;
if (layout->twc && layout->own_twc)
gt_text_width_calculator_delete(layout->twc);
gt_hashmap_delete(layout->tracks);
gt_array_delete(layout->custom_tracks);
gt_free(layout);
}
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 blocklist_delete(void *value)
{
GtUword i;
GtArray *a;
if (!value) return;
a = (GtArray*) value;
for (i = 0; i < gt_array_size(a); i++)
gt_block_delete(*(GtBlock**) gt_array_get(a, i));
gt_array_delete(a);
}
static int infer_cds_visitor_visit_feature_node(GtNodeVisitor *nv,
GtFeatureNode *fn,
GtError *error)
{
AgnInferCDSVisitor *v = infer_cds_visitor_cast(nv);
gt_error_check(error);
GtFeatureNodeIterator *iter = gt_feature_node_iterator_new(fn);
GtFeatureNode *current;
for(current = gt_feature_node_iterator_next(iter);
current != NULL;
current = gt_feature_node_iterator_next(iter))
{
if(!agn_typecheck_mrna(current))
continue;
v->cds = agn_typecheck_select(current, agn_typecheck_cds);
v->utrs = agn_typecheck_select(current, agn_typecheck_utr);
v->exons = agn_typecheck_select(current, agn_typecheck_exon);
v->starts = agn_typecheck_select(current, agn_typecheck_start_codon);
v->stops = agn_typecheck_select(current, agn_typecheck_stop_codon);
v->mrna = current;
infer_cds_visitor_infer_cds(v);
infer_cds_visitor_check_start(v);
infer_cds_visitor_check_stop(v);
infer_cds_visitor_infer_utrs(v);
infer_cds_visitor_check_cds_multi(v);
infer_cds_visitor_check_cds_phase(v);
infer_cds_visitor_set_utrs(v);
v->mrna = NULL;
gt_array_delete(v->cds);
gt_array_delete(v->utrs);
gt_array_delete(v->exons);
gt_array_delete(v->starts);
gt_array_delete(v->stops);
}
gt_feature_node_iterator_delete(iter);
return 0;
}
