void assemble_cluster(GthPGL *pgl, bool disableclustersas) { GthSACluster *sacluster; GthSA *sa; GtUword i; sacluster = gt_malloc(sizeof (GthSACluster)); sacluster->representative = *(GthSA**) gt_array_get_first(pgl->alignments); sacluster->members = gt_array_new(sizeof (GthSA*)); for (i = 1; i < gt_array_size(pgl->alignments); i++) { sa = *(GthSA**) gt_array_get(pgl->alignments, i); if (disableclustersas || gth_sa_cmp_genomic_actual(&sacluster->representative, &sa)) { /* spliced alignments differ -> create a new cluster */ gt_array_add(pgl->saclusters, sacluster); sacluster = gt_malloc(sizeof (GthSACluster)); sacluster->representative = sa; sacluster->members = gt_array_new(sizeof (GthSA*)); } else { /* spliced alignments are equal -> store new sa also in current cluster */ gt_array_add(sacluster->members, sa); } } /* store last cluster */ gt_array_add(pgl->saclusters, sacluster); }
GtNodeStream* gt_snp_annotator_stream_new(GtNodeStream *gvf_stream, GtNodeStream *gff_stream, GtTransTable *trans_table, GtRegionMapping *rmap) { GtSNPAnnotatorStream *sas; GtNodeStream *ns; gt_assert(gvf_stream && gff_stream && rmap); ns = gt_node_stream_create(gt_snp_annotator_stream_class(), true); sas = gt_snp_annotator_stream_cast(ns); sas->instreams = gt_array_new(sizeof (GtNodeStream*)); (void) gt_node_stream_ref(gvf_stream); gt_array_add(sas->instreams, gvf_stream); (void) gt_node_stream_ref(gff_stream); gt_array_add(sas->instreams, gff_stream); sas->cur_gene_set = gt_array_new(sizeof (GtFeatureNode*)); sas->merge_stream = gt_merge_stream_new(sas->instreams); sas->rmap = gt_region_mapping_ref(rmap); sas->cur_gene_range.start = sas->cur_gene_range.end = GT_UNDEF_UWORD; sas->snps = gt_queue_new(); sas->outqueue = gt_queue_new(); sas->tt = trans_table; return ns; }
GtNodeVisitor* gt_gtf_visitor_new(GtFile *outfp) { GtNodeVisitor *nv = gt_node_visitor_create(gt_gtf_visitor_class()); GtGTFVisitor *gtf_visitor = gtf_visitor_cast(nv); gtf_visitor->gene_id = 0; gtf_visitor->exon_features = gt_array_new(sizeof (GtGenomeNode*)); gtf_visitor->CDS_features = gt_array_new(sizeof (GtGenomeNode*)); gtf_visitor->outfp = outfp; return nv; }
GthChain* gth_chain_new(void) { GthChain *chain = gt_calloc(1, sizeof *chain); 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; chain->forwardranges = gt_array_new(sizeof (GtRange)); chain->reverseranges = gt_array_new(sizeof (GtRange)); return chain; }
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); }
static int check_cds_phases_if_necessary(GtFeatureNode *fn, GtCDSCheckVisitor *v, bool second_pass, GtError *err) { GtFeatureNodeIterator *fni; GtFeatureNode *node; GtArray *cds_features = NULL; GtHashmap *multi_features = NULL; int had_err = 0; gt_error_check(err); gt_assert(fn); fni = gt_feature_node_iterator_new_direct(fn); while ((node = gt_feature_node_iterator_next(fni))) { if (gt_feature_node_has_type(node, gt_ft_CDS)) { if (gt_feature_node_is_multi(node)) { GtArray *features; if (!multi_features) multi_features = gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_array_delete); if ((features = gt_hashmap_get(multi_features, gt_feature_node_get_multi_representative(node)))) { gt_array_add(features, node); } else { GtFeatureNode *representative; features = gt_array_new(sizeof (GtFeatureNode*)); representative = gt_feature_node_get_multi_representative(node); gt_array_add(features, representative); gt_hashmap_add(multi_features, representative, features); } } else { if (!cds_features) cds_features = gt_array_new(sizeof (GtFeatureNode*)); gt_array_add(cds_features, node); } } } if (cds_features) had_err = check_cds_phases(cds_features, v, false, second_pass, err); if (!had_err && multi_features) had_err = gt_hashmap_foreach(multi_features, check_cds_phases_hm, v, err); gt_array_delete(cds_features); gt_hashmap_delete(multi_features); gt_feature_node_iterator_delete(fni); return had_err; }
static GtArray* generic_ranges_uniq(GtArray *out_ranges, const GtArray *in_ranges, bool count) { GtUword i, *ctr_ptr, ctr = 1; GtArray *count_array = NULL; GtRange cur = { GT_UNDEF_UWORD, GT_UNDEF_UWORD }, prev = { GT_UNDEF_UWORD, GT_UNDEF_UWORD }; gt_assert(out_ranges && in_ranges); gt_assert(gt_ranges_are_sorted(in_ranges)); if (count) count_array = gt_array_new(sizeof (GtUword)); for (i = 0; i < gt_array_size(in_ranges); i++) { cur = *(GtRange*) gt_array_get(in_ranges, i); if (!i) { gt_array_add(out_ranges, cur); if (count) gt_array_add(count_array, ctr); } else { if (prev.start == cur.start && prev.end == cur.end) { if (count) { ctr_ptr = gt_array_get_last(count_array); (*ctr_ptr)++; } } else { gt_array_add(out_ranges, cur); if (count) gt_array_add(count_array, ctr); } } prev = cur; } return count_array; }
static GtArray *gaeval_visitor_union(GtArray *cov1, GtArray *cov2) { agn_assert(cov1 && cov2); gt_array_add_array(cov1, cov2); if(gt_array_size(cov1) > 1) gt_array_sort(cov1, (GtCompare)gt_range_compare); GtArray *runion = gt_array_new(sizeof(GtRange)); if(gt_array_size(cov1) == 0) return runion; GtRange *rng = gt_array_get(cov1, 0); gt_array_add(runion, *rng); GtRange *prev = gt_array_get(runion, 0); if(gt_array_size(cov1) == 1) return runion; GtUword i; for(i = 1; i < gt_array_size(cov1); i++) { rng = gt_array_get(cov1, i); if(gt_range_overlap(rng, prev)) *prev = gt_range_join(rng, prev); else { gt_array_add(runion, *rng); prev = gt_array_get(runion, gt_array_size(runion) - 1); } } return runion; }
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; }
void gt_type_node_add_is_a_vertex(GtTypeNode *src, const GtTypeNode *dst) { gt_assert(src && dst); if (!src->is_a_out_edges) src->is_a_out_edges = gt_array_new(sizeof (GtTypeNode*)); gt_array_add(src->is_a_out_edges, dst); }
void gt_type_node_part_of_add(GtTypeNode *type_node, const char *id) { gt_assert(type_node && id); if (!type_node->part_of_list) type_node->part_of_list = gt_array_new(sizeof (const char*)); gt_array_add(type_node->part_of_list, id); }
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 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 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); }
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; }
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); }
Splicedseq* gt_splicedseq_new(void) { Splicedseq *ss = gt_malloc(sizeof (Splicedseq)); ss->splicedseq = gt_str_new(); ss->positionmapping = gt_array_new(sizeof (unsigned long)); ss->forward = true; return ss; }
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 AutomaticSequenceRegion* automatic_sequence_region_new(bool is_circular) { AutomaticSequenceRegion *auto_sr; auto_sr = gt_malloc(sizeof (AutomaticSequenceRegion)); auto_sr->feature_nodes = gt_array_new(sizeof (GtFeatureNode*)); auto_sr->is_circular = is_circular; return auto_sr; }
void* gt_class_alloc(size_t size) { void *c_class; if (!c_classes) c_classes = gt_array_new(sizeof (void*)); c_class = gt_calloc(1, size); gt_array_add(c_classes, c_class); return c_class; }
static GtPBSResults* gt_pbs_results_new(GtLTRElement *elem, GtPBSOptions *opts) { GtPBSResults *res = gt_calloc(1, sizeof (GtPBSResults)); res->elem = elem; res->opts = opts; res->hits = gt_array_new(sizeof (GtPBSHit*)); return res; }
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 inverted_chain_init(GthInvertedChain *inverted_chain) { inverted_chain->gen_file_num = GT_UNDEF_ULONG; inverted_chain->gen_seq_num = GT_UNDEF_ULONG; inverted_chain->ref_file_num = GT_UNDEF_ULONG; inverted_chain->ref_seq_num = GT_UNDEF_ULONG; inverted_chain->startpos = GT_UNDEF_ULONG; inverted_chain->endpos = GT_UNDEF_ULONG; inverted_chain->forwardranges = gt_array_new(sizeof (GtRange)); }
static GtFeatureNodeIterator* feature_node_iterator_new_base(const GtFeatureNode *fn) { GtFeatureNodeIterator *fni; gt_assert(fn); fni = gt_malloc(sizeof *fni); fni->fn = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) fn); fni->feature_stack = gt_array_new(sizeof (GtFeatureNode*)); return fni; }
AgnUnitTest *agn_unit_test_new(const char *label, bool (*testfunc)(AgnUnitTest *)) { AgnUnitTest *test = gt_malloc( sizeof(AgnUnitTest) ); test->label = gt_cstr_dup(label); test->testfunc = testfunc; test->results = gt_array_new( sizeof(UnitTestResult) ); test->passed = false; return test; }
GtBlock* gt_block_new(void) { GtBlock *block = gt_calloc(1, sizeof (GtBlock)); block->elements = gt_array_new(sizeof (GtElement*)); block->caption = NULL; block->show_caption = true; block->sorted = false; block->strand = GT_STRAND_UNKNOWN; block->top_level_feature = NULL; return block; }
GtNodeStream* gt_sort_stream_new(GtNodeStream *in_stream) { GtNodeStream *ns = gt_node_stream_create(gt_sort_stream_class(), true); GtSortStream *sort_stream = gt_sort_stream_cast(ns); gt_assert(in_stream); sort_stream->in_stream = gt_node_stream_ref(in_stream); sort_stream->sorted = false; sort_stream->idx = 0; sort_stream->nodes = gt_array_new(sizeof (GtGenomeNode*)); return ns; }
GtNodeStream* gt_load_stream_new(GtNodeStream *in_stream) { GtNodeStream *ns = gt_node_stream_create(gt_load_stream_class(), true); GtLoadStream *load_stream = gt_load_stream_cast(ns); gt_assert(in_stream); load_stream->in_stream = gt_node_stream_ref(in_stream); load_stream->full = false; load_stream->idx = 0; load_stream->nodes = gt_array_new(sizeof (GtGenomeNode*)); return ns; }
GtTypeGraph* gt_type_graph_new(void) { GtTypeGraph *type_graph = gt_malloc(sizeof (GtTypeGraph)); type_graph->name2id = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL); type_graph->nodemap = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL); type_graph->nodes = gt_array_new(sizeof (GtTypeNode*)); type_graph->part_of_out_edges = gt_bool_matrix_new(); type_graph->part_of_in_edges = gt_bool_matrix_new(); type_graph->ready = false; return type_graph; }
static GtArray* gaeval_visitor_intersect(GtGenomeNode *genemodel, GtGenomeNode *alignment) { agn_assert(genemodel && alignment); GtFeatureNode *genefn = gt_feature_node_cast(genemodel); GtFeatureNode *algnfn = gt_feature_node_cast(alignment); agn_assert(gt_feature_node_has_type(genefn, "mRNA")); GtStrand genestrand = gt_feature_node_get_strand(genefn); GtStrand algnstrand = gt_feature_node_get_strand(algnfn); if(genestrand != algnstrand) return NULL; GtArray *covered_parts = gt_array_new( sizeof(GtRange) ); GtArray *exons = agn_typecheck_select(genefn, agn_typecheck_exon); GtWord i; for(i = 0; i < gt_array_size(exons); i++) { GtGenomeNode *exon = *(GtGenomeNode **)gt_array_get(exons, i); GtRange exonrange = gt_genome_node_get_range(exon); GtFeatureNodeIterator *aniter = gt_feature_node_iterator_new(algnfn); GtFeatureNode *tempaln; GtRange nullrange = {0, 0}; for(tempaln = gt_feature_node_iterator_next(aniter); tempaln != NULL; tempaln = gt_feature_node_iterator_next(aniter)) { if(gt_feature_node_has_type(tempaln, "match_gap")) continue; GtRange alnrange = gt_genome_node_get_range((GtGenomeNode *) tempaln); GtRange intr = gaeval_visitor_range_intersect(&exonrange, &alnrange); if(gt_range_compare(&intr, &nullrange) != 0) gt_array_add(covered_parts, intr); } gt_feature_node_iterator_delete(aniter); } gt_array_delete(exons); for(i = 0; i < gt_array_size(covered_parts); i++) { GtRange *r1 = gt_array_get(covered_parts, i); GtUword j; for(j = i+1; j < gt_array_size(covered_parts); j++) { GtRange *r2 = gt_array_get(covered_parts, j); agn_assert(gt_range_overlap(r1, r2) == false); } } return covered_parts; }