GtFeatureIndex *agn_import_canonical(int numfiles, const char **filenames, AgnLogger *logger) { GtNodeStream *gff3 = gt_gff3_in_stream_new_unsorted(numfiles, filenames); gt_gff3_in_stream_check_id_attributes((GtGFF3InStream *)gff3); gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream *)gff3); GtFeatureIndex *features = gt_feature_index_memory_new(); GtNodeStream *cgstream = agn_canon_gene_stream_new(gff3, logger); GtNodeStream *featstream = gt_feature_out_stream_new(cgstream, features); GtError *error = gt_error_new(); int result = gt_node_stream_pull(featstream, error); if(result == -1) { agn_logger_log_error(logger, "error processing node stream: %s", gt_error_get(error)); } gt_error_delete(error); if(agn_logger_has_error(logger)) { gt_feature_index_delete(features); features = NULL; } gt_node_stream_delete(gff3); gt_node_stream_delete(cgstream); gt_node_stream_delete(featstream); return features; }
GtFeatureIndex *agn_import_simple(int numfiles, const char **filenames, char *type, AgnLogger *logger) { GtFeatureIndex *features = gt_feature_index_memory_new(); GtNodeStream *gff3 = gt_gff3_in_stream_new_unsorted(numfiles, filenames); gt_gff3_in_stream_check_id_attributes((GtGFF3InStream *)gff3); gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream *)gff3); GtHashmap *typestokeep = gt_hashmap_new(GT_HASH_STRING, NULL, NULL); gt_hashmap_add(typestokeep, type, type); GtNodeStream *filterstream = agn_filter_stream_new(gff3, typestokeep); GtNodeStream *featstream = gt_feature_out_stream_new(filterstream, features); GtError *error = gt_error_new(); int result = gt_node_stream_pull(featstream, error); if(result == -1) { agn_logger_log_error(logger, "error processing node stream: %s", gt_error_get(error)); } gt_error_delete(error); if(agn_logger_has_error(logger)) { gt_feature_index_delete(features); features = NULL; } gt_node_stream_delete(gff3); gt_node_stream_delete(filterstream); gt_node_stream_delete(featstream); return features; }
int gt_diagram_unit_test(GtError *err) { int had_err = 0; GtGenomeNode *gn; GtDiagramTestShared sh; GtRange testrng = {100, 10000}; gt_error_check(err); gn = gt_feature_node_new_standard_gene(); sh.fi = gt_feature_index_memory_new(); sh.sty = gt_style_new(err); sh.err = err; sh.errstatus = 0; gt_feature_index_add_feature_node(sh.fi, gt_feature_node_cast(gn), err); gt_genome_node_delete(gn); sh.d = gt_diagram_new(sh.fi, "ctg123", &testrng, sh.sty, err); /* removed the multithreading test for now until it is fixed */ gt_diagram_unit_test_sketch_func(&sh); gt_ensure(sh.errstatus == 0); gt_style_delete(sh.sty); gt_diagram_delete(sh.d); gt_feature_index_delete(sh.fi); return had_err; }
static int feature_index_lua_delete(lua_State *L) { GtFeatureIndex **feature_index = check_feature_index(L, 1); gt_feature_index_delete(*feature_index); return 0; }
static int gt_speck_runner(int argc, const char **argv, int parsed_args, void *tool_arguments, GtError *err) { GtNodeStream *gff3_in_stream = NULL, *checker_stream = NULL, *a_in_stream = NULL, *a_out_stream = NULL, *feature_stream = NULL, *sort_stream = NULL, *last_stream = NULL; GtNodeVisitor *spec_visitor = NULL; GtSpecResults *res = NULL; GtFeatureIndex *fi = NULL; GtTimer *t = NULL; GtRegionMapping *rm = NULL; GtArray *arr = gt_array_new(sizeof (GtFeatureNode*)); SpeccheckArguments *arguments = tool_arguments; int had_err = 0; gt_error_check(err); res = gt_spec_results_new(); gt_assert(res); t = gt_timer_new(); gt_assert(t); spec_visitor = gt_spec_visitor_new(gt_str_get(arguments->specfile), res, err); if (!spec_visitor) return -1; /* add region mapping if given */ if (gt_seqid2file_option_used(arguments->s2fi)) { rm = gt_seqid2file_region_mapping_new(arguments->s2fi, err); if (!rm) had_err = -1; if (!had_err) gt_spec_visitor_add_region_mapping((GtSpecVisitor*) spec_visitor, rm); } /* set runtime error behaviour */ if (arguments->fail_hard) gt_spec_visitor_fail_on_runtime_error((GtSpecVisitor*) spec_visitor); else gt_spec_visitor_report_runtime_errors((GtSpecVisitor*) spec_visitor); /* redirect warnings */ gt_warning_set_handler(gt_speck_record_warning, res); last_stream = gff3_in_stream = gt_gff3_in_stream_new_unsorted( argc - parsed_args, argv + parsed_args); gt_assert(gff3_in_stream); gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream); /* insert sort stream if requested */ if (arguments->sort) { last_stream = sort_stream = gt_sort_stream_new(last_stream); } /* if -provideindex is given, collect input features and index them first */ if (arguments->provideindex) { fi = gt_feature_index_memory_new(); gt_assert(fi); last_stream = feature_stream = gt_feature_stream_new(last_stream, fi); gt_assert(feature_stream); last_stream = a_out_stream = gt_array_out_stream_all_new(last_stream, arr, err); if (!a_out_stream) had_err = -1; gt_timer_start(t); if (!had_err) had_err = gt_node_stream_pull(last_stream, err); if (!had_err) { gt_spec_visitor_add_feature_index((GtSpecVisitor*) spec_visitor, gt_feature_index_ref(fi)); last_stream = a_in_stream = gt_array_in_stream_new(arr, NULL, err); if (!a_in_stream) had_err = -1; } } else { gt_timer_start(t); } if (!had_err) { checker_stream = gt_visitor_stream_new(last_stream, spec_visitor); gt_assert(checker_stream); } /* perform checking */ if (!had_err) had_err = gt_node_stream_pull(checker_stream, err); gt_timer_stop(t); /* reset warnings output */ gt_warning_set_handler(gt_warning_default_handler, NULL); /* output results */ if (!had_err) gt_spec_results_report(res, arguments->outfp, gt_str_get(arguments->specfile), arguments->verbose, arguments->colored, !arguments->allexpects); if (!had_err) gt_timer_show_formatted(t, "Finished in " GT_WD ".%06ld s.\n", stderr); /* free */ gt_node_stream_delete(gff3_in_stream); gt_node_stream_delete(a_in_stream); gt_node_stream_delete(a_out_stream); gt_node_stream_delete(checker_stream); gt_node_stream_delete(feature_stream); gt_node_stream_delete(sort_stream); gt_spec_results_delete(res); gt_feature_index_delete(fi); gt_timer_delete(t); gt_array_delete(arr); return had_err; }
static void feature_visitor_free(GtNodeVisitor *gv) { GtFeatureVisitor *feature_visitor = feature_visitor_cast(gv); gt_assert(feature_visitor); gt_feature_index_delete(feature_visitor->feature_index); }
static void gaeval_visitor_free(GtNodeVisitor *nv) { AgnGaevalVisitor *v = gaeval_visitor_cast(nv); gt_feature_index_delete(v->alignments); }
int gt_feature_in_stream_unit_test(GtError *error) { GtNodeStream *src, *dest; GtFeatureIndex *prefeat, *postfeat; GtRange range1, range1test, range2, range2test; prefeat = in_stream_test_data(error); postfeat = gt_feature_index_memory_new(); src = gt_feature_in_stream_new(prefeat); dest = gt_feature_out_stream_new(src, postfeat); int result = gt_node_stream_pull(dest, error); if (result == -1) return -1; GtStrArray *seqids = gt_feature_index_get_seqids(postfeat, error); if (gt_str_array_size(seqids) != 2) { gt_error_set(error, "error in feature_in_stream unit test 1: expected 2 " "seqids, found "GT_WU"", gt_str_array_size(seqids)); return -1; } gt_str_array_delete(seqids); range1test.start = 500; range1test.end = 75000; range2test.start = 4000; range2test.end = 9500; gt_feature_index_get_range_for_seqid(postfeat, &range1, "chr1", error); gt_feature_index_get_range_for_seqid(postfeat, &range2, "scf0001",error); if (gt_range_compare(&range1, &range1test) || gt_range_compare(&range2, &range2test)) { gt_error_set(error, "error in feature_in_stream unit test 1: incorrect " "sequence regions"); return -1; } gt_feature_index_get_orig_range_for_seqid(postfeat, &range1, "chr1", error); gt_feature_index_get_orig_range_for_seqid(postfeat, &range2, "scf0001",error); if (gt_range_compare(&range1, &range1test) || gt_range_compare(&range2, &range2test)) { gt_error_set(error, "error in feature_in_stream unit test 1: incorrect " "sequence regions"); return -1; } gt_feature_index_delete(prefeat); gt_feature_index_delete(postfeat); gt_node_stream_delete(src); gt_node_stream_delete(dest); prefeat = in_stream_test_data(error); postfeat = gt_feature_index_memory_new(); src = gt_feature_in_stream_new(prefeat); dest = gt_feature_out_stream_new(src, postfeat); gt_feature_in_stream_use_orig_ranges((GtFeatureInStream *)src); result = gt_node_stream_pull(dest, error); if (result == -1) return -1; range1test.start = 500; range1test.end = 75000; range2test.start = 4000; range2test.end = 9500; gt_feature_index_get_range_for_seqid(postfeat, &range1, "chr1", error); gt_feature_index_get_range_for_seqid(postfeat, &range2, "scf0001",error); if (gt_range_compare(&range1, &range1test) || gt_range_compare(&range2, &range2test)) { gt_error_set(error, "error in feature_in_stream unit test 1: incorrect " "sequence regions"); return -1; } range1test.start = 1; range1test.end = 100000; range2test.start = 1; range2test.end = 10000; gt_feature_index_get_orig_range_for_seqid(postfeat, &range1, "chr1", error); gt_feature_index_get_orig_range_for_seqid(postfeat, &range2, "scf0001",error); if (gt_range_compare(&range1, &range1test) || gt_range_compare(&range2, &range2test)) { gt_error_set(error, "error in feature_in_stream unit test 1: incorrect " "sequence regions"); return -1; } gt_feature_index_delete(prefeat); gt_feature_index_delete(postfeat); gt_node_stream_delete(src); gt_node_stream_delete(dest); return 0; }
static int gt_sketch_page_runner(GT_UNUSED int argc, const char **argv, int parsed_args, void *tool_arguments, GtError *err) { SketchPageArguments *arguments = tool_arguments; int had_err = 0; GtFeatureIndex *features = NULL; GtRange qry_range, sequence_region_range; GtStyle *sty = NULL; GtStr *prog, *gt_style_file; GtDiagram *d = NULL; GtLayout *l = NULL; GtBioseq *bioseq = NULL; GtCanvas *canvas = NULL; const char *seqid = NULL, *outfile; unsigned long start, height, num_pages = 0; double offsetpos, usable_height; cairo_surface_t *surf = NULL; cairo_t *cr = NULL; GtTextWidthCalculator *twc; gt_error_check(err); features = gt_feature_index_memory_new(); if (cairo_version() < CAIRO_VERSION_ENCODE(1, 8, 6)) gt_warning("Your cairo library (version %s) is older than version 1.8.6! " "These versions contain a bug which may result in " "corrupted PDF output!", cairo_version_string()); /* get style */ sty = gt_style_new(err); if (gt_str_length(arguments->stylefile) == 0) { prog = gt_str_new(); gt_str_append_cstr_nt(prog, argv[0], gt_cstr_length_up_to_char(argv[0], ' ')); gt_style_file = gt_get_gtdata_path(gt_str_get(prog), err); gt_str_delete(prog); gt_str_append_cstr(gt_style_file, "/sketch/default.style"); } else { gt_style_file = gt_str_ref(arguments->stylefile); } had_err = gt_style_load_file(sty, gt_str_get(gt_style_file), err); outfile = argv[parsed_args]; if (!had_err) { /* get features */ had_err = gt_feature_index_add_gff3file(features, argv[parsed_args+1], err); if (!had_err && gt_str_length(arguments->seqid) == 0) { seqid = gt_feature_index_get_first_seqid(features); if (seqid == NULL) { gt_error_set(err, "GFF input file must contain a sequence region!"); had_err = -1; } } else if (!had_err && !gt_feature_index_has_seqid(features, gt_str_get(arguments->seqid))) { gt_error_set(err, "sequence region '%s' does not exist in GFF input file", gt_str_get(arguments->seqid)); had_err = -1; } else if (!had_err) seqid = gt_str_get(arguments->seqid); } /* set text */ if (gt_str_length(arguments->text) == 0) { gt_str_delete(arguments->text); arguments->text = gt_str_new_cstr(argv[parsed_args+1]); } if (!had_err) { /* set display range */ gt_feature_index_get_range_for_seqid(features, &sequence_region_range, seqid); qry_range.start = (arguments->range.start == GT_UNDEF_ULONG ? sequence_region_range.start : arguments->range.start); qry_range.end = (arguments->range.end == GT_UNDEF_ULONG ? sequence_region_range.end : arguments->range.end); /* set output format */ if (strcmp(gt_str_get(arguments->format), "pdf") == 0) { surf = cairo_pdf_surface_create(outfile, mm_to_pt(arguments->pwidth), mm_to_pt(arguments->pheight)); } else if (strcmp(gt_str_get(arguments->format), "ps") == 0) { surf = cairo_ps_surface_create(outfile, mm_to_pt(arguments->pwidth), mm_to_pt(arguments->pheight)); } gt_log_log("created page with %.2f:%.2f dimensions\n", mm_to_pt(arguments->pwidth), mm_to_pt(arguments->pheight)); offsetpos = TEXT_SPACER + arguments->theight + TEXT_SPACER; usable_height = mm_to_pt(arguments->pheight) - arguments->theight - arguments->theight - 4*TEXT_SPACER; if (gt_str_length(arguments->seqfile) > 0) { bioseq = gt_bioseq_new(gt_str_get(arguments->seqfile), err); } cr = cairo_create(surf); cairo_set_font_size(cr, 8); twc = gt_text_width_calculator_cairo_new(cr, sty); for (start = qry_range.start; start <= qry_range.end; start += arguments->width) { GtRange single_range; GtCustomTrack *ct = NULL; const char *seq; single_range.start = start; single_range.end = start + arguments->width; if (had_err) break; d = gt_diagram_new(features, seqid, &single_range, sty, err); if (!d) { had_err = -1; break; } if (bioseq) { seq = gt_bioseq_get_sequence(bioseq, 0); ct = gt_custom_track_gc_content_new(seq, gt_bioseq_get_sequence_length(bioseq, 0), 800, 70, 0.4, true); gt_diagram_add_custom_track(d, ct); } l = gt_layout_new_with_twc(d, mm_to_pt(arguments->width), sty, twc, err); had_err = gt_layout_get_height(l, &height, err); if (!had_err) { if (gt_double_smaller_double(usable_height - 10 - 2*TEXT_SPACER - arguments->theight, offsetpos + height)) { draw_header(cr, gt_str_get(arguments->text), argv[parsed_args+1], seqid, num_pages, mm_to_pt(arguments->pwidth), mm_to_pt(arguments->pheight), arguments->theight); cairo_show_page(cr); offsetpos = TEXT_SPACER + arguments->theight + TEXT_SPACER; num_pages++; } canvas = gt_canvas_cairo_context_new(sty, cr, offsetpos, mm_to_pt(arguments->pwidth), height, NULL, err); if (!canvas) had_err = -1; offsetpos += height; if (!had_err) had_err = gt_layout_sketch(l, canvas, err); } gt_canvas_delete(canvas); gt_layout_delete(l); gt_diagram_delete(d); if (ct) gt_custom_track_delete(ct); } draw_header(cr, gt_str_get(arguments->text), argv[parsed_args+1], seqid, num_pages, mm_to_pt(arguments->pwidth), mm_to_pt(arguments->pheight), arguments->theight); cairo_show_page(cr); num_pages++; gt_log_log("finished, should be %lu pages\n", num_pages); gt_text_width_calculator_delete(twc); cairo_destroy(cr); cairo_surface_flush(surf); cairo_surface_finish(surf); cairo_surface_destroy(surf); cairo_debug_reset_static_data(); if (bioseq) gt_bioseq_delete(bioseq); gt_style_delete(sty); gt_str_delete(gt_style_file); gt_feature_index_delete(features); } return had_err; }
static int gt_sketch_runner(int argc, const char **argv, int parsed_args, void *tool_arguments, GT_UNUSED GtError *err) { GtSketchArguments *arguments = tool_arguments; GtNodeStream *in_stream = NULL, *add_introns_stream = NULL, *gff3_out_stream = NULL, *feature_stream = NULL, *sort_stream = NULL, *last_stream; GtFeatureIndex *features = NULL; const char *file; char *seqid = NULL; GtRange qry_range, sequence_region_range; GtArray *results = NULL; GtStyle *sty = NULL; GtStr *prog, *defaultstylefile = NULL; GtDiagram *d = NULL; GtLayout *l = NULL; GtImageInfo* ii = NULL; GtCanvas *canvas = NULL; GtUword height; bool has_seqid; int had_err = 0; gt_error_check(err); gt_assert(arguments); prog = gt_str_new(); gt_str_append_cstr_nt(prog, argv[0], gt_cstr_length_up_to_char(argv[0], ' ')); defaultstylefile = gt_get_gtdata_path(gt_str_get(prog), err); gt_str_delete(prog); if (!defaultstylefile) had_err = -1; if (!had_err) { gt_str_append_cstr(defaultstylefile, "/sketch/default.style"); } file = argv[parsed_args]; if (!had_err) { /* create feature index */ features = gt_feature_index_memory_new(); parsed_args++; /* create an input stream */ if (strcmp(gt_str_get(arguments->input), "gff") == 0) { in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args, argv + parsed_args); if (arguments->verbose) gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) in_stream); } else if (strcmp(gt_str_get(arguments->input), "bed") == 0) { if (argc - parsed_args == 0) in_stream = gt_bed_in_stream_new(NULL); else in_stream = gt_bed_in_stream_new(argv[parsed_args]); } else if (strcmp(gt_str_get(arguments->input), "gtf") == 0) { if (argc - parsed_args == 0) in_stream = gt_gtf_in_stream_new(NULL); else in_stream = gt_gtf_in_stream_new(argv[parsed_args]); } last_stream = in_stream; /* create add introns stream if -addintrons was used */ if (arguments->addintrons) { sort_stream = gt_sort_stream_new(last_stream); add_introns_stream = gt_add_introns_stream_new(sort_stream); last_stream = add_introns_stream; } /* create gff3 output stream if -pipe was used */ if (arguments->pipe) { gff3_out_stream = gt_gff3_out_stream_new(last_stream, NULL); last_stream = gff3_out_stream; } /* create feature stream */ feature_stream = gt_feature_stream_new(last_stream, features); /* pull the features through the stream and free them afterwards */ had_err = gt_node_stream_pull(feature_stream, err); gt_node_stream_delete(feature_stream); gt_node_stream_delete(gff3_out_stream); gt_node_stream_delete(sort_stream); gt_node_stream_delete(add_introns_stream); gt_node_stream_delete(in_stream); } if (!had_err) { had_err = gt_feature_index_has_seqid(features, &has_seqid, gt_str_get(arguments->seqid), err); } /* if seqid is empty, take first one added to index */ if (!had_err && strcmp(gt_str_get(arguments->seqid),"") == 0) { seqid = gt_feature_index_get_first_seqid(features, err); if (seqid == NULL) { gt_error_set(err, "GFF input file must contain a sequence region!"); had_err = -1; } } else if (!had_err && !has_seqid) { gt_error_set(err, "sequence region '%s' does not exist in GFF input file", gt_str_get(arguments->seqid)); had_err = -1; } else if (!had_err) seqid = gt_str_get(arguments->seqid); results = gt_array_new(sizeof (GtGenomeNode*)); if (!had_err) { had_err = gt_feature_index_get_range_for_seqid(features, &sequence_region_range, seqid, err); } if (!had_err) { qry_range.start = (arguments->start == GT_UNDEF_UWORD ? sequence_region_range.start : arguments->start); qry_range.end = (arguments->end == GT_UNDEF_UWORD ? sequence_region_range.end : arguments->end); } if (!had_err) { if (arguments->verbose) fprintf(stderr, "# of results: "GT_WU"\n", gt_array_size(results)); /* find and load style file */ if (!(sty = gt_style_new(err))) had_err = -1; if (gt_str_length(arguments->stylefile) == 0) { gt_str_append_str(arguments->stylefile, defaultstylefile); } else { if (!had_err && gt_file_exists(gt_str_get(arguments->stylefile))) { if (arguments->unsafe) gt_style_unsafe_mode(sty); } else { had_err = -1; gt_error_set(err, "style file '%s' does not exist!", gt_str_get(arguments->stylefile)); } } if (!had_err) had_err = gt_style_load_file(sty, gt_str_get(arguments->stylefile), err); } if (!had_err) { /* create and write image file */ if (!(d = gt_diagram_new(features, seqid, &qry_range, sty, err))) had_err = -1; if (!had_err && arguments->flattenfiles) gt_diagram_set_track_selector_func(d, flattened_file_track_selector, NULL); if (had_err || !(l = gt_layout_new(d, arguments->width, sty, err))) had_err = -1; if (!had_err) had_err = gt_layout_get_height(l, &height, err); if (!had_err) { ii = gt_image_info_new(); if (strcmp(gt_str_get(arguments->format),"pdf")==0) { canvas = gt_canvas_cairo_file_new(sty, GT_GRAPHICS_PDF, arguments->width, height, ii, err); } else if (strcmp(gt_str_get(arguments->format),"ps")==0) { canvas = gt_canvas_cairo_file_new(sty, GT_GRAPHICS_PS, arguments->width, height, ii, err); } else if (strcmp(gt_str_get(arguments->format),"svg")==0) { canvas = gt_canvas_cairo_file_new(sty, GT_GRAPHICS_SVG, arguments->width, height, ii, err); } else { canvas = gt_canvas_cairo_file_new(sty, GT_GRAPHICS_PNG, arguments->width, height, ii, err); } if (!canvas) had_err = -1; if (!had_err) { had_err = gt_layout_sketch(l, canvas, err); } if (!had_err) { if (arguments->showrecmaps) { GtUword i; const GtRecMap *rm; for (i = 0; i < gt_image_info_num_of_rec_maps(ii) ;i++) { char buf[BUFSIZ]; rm = gt_image_info_get_rec_map(ii, i); (void) gt_rec_map_format_html_imagemap_coords(rm, buf, BUFSIZ); printf("%s, %s\n", buf, gt_feature_node_get_type(gt_rec_map_get_genome_feature(rm))); } } if (arguments->use_streams) { GtFile *outfile; GtStr *str = gt_str_new(); gt_canvas_cairo_file_to_stream((GtCanvasCairoFile*) canvas, str); outfile = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, file, "w+", err); if (outfile) { gt_file_xwrite(outfile, gt_str_get_mem(str), gt_str_length(str)); gt_file_delete(outfile); } else { had_err = -1; } gt_str_delete(str); } else { had_err = gt_canvas_cairo_file_to_file((GtCanvasCairoFile*) canvas, file, err); } } } } /* free */ gt_free(seqid); gt_canvas_delete(canvas); gt_layout_delete(l); gt_image_info_delete(ii); gt_style_delete(sty); gt_diagram_delete(d); gt_array_delete(results); gt_str_delete(defaultstylefile); gt_feature_index_delete(features); return had_err; }
static int gt_speck_runner(int argc, const char **argv, int parsed_args, void *tool_arguments, GtError *err) { GtNodeStream *gff3_in_stream = NULL, *checker_stream = NULL, *a_in_stream = NULL, *a_out_stream = NULL, *feature_stream = NULL, *sort_stream = NULL, *last_stream = NULL; GtNodeVisitor *spec_visitor = NULL; GtSpecResults *res = NULL; GtFeatureIndex *fi = NULL; GtTypeChecker *type_checker = NULL; GtTimer *t = NULL; GtRegionMapping *rm = NULL; GtArray *arr = gt_array_new(sizeof (GtFeatureNode*)); GtStr *prog, *speclib; SpeccheckArguments *arguments = tool_arguments; int had_err = 0; gt_error_check(err); res = gt_spec_results_new(); gt_assert(res); if (gt_file_exists(gt_str_get(arguments->format))) { speclib = gt_str_ref(arguments->format); } else { prog = gt_str_new(); gt_str_append_cstr_nt(prog, gt_error_get_progname(err), gt_cstr_length_up_to_char(gt_error_get_progname(err), ' ')); speclib = gt_get_gtdata_path(gt_str_get(prog), NULL); gt_str_delete(prog); gt_str_append_cstr(speclib, "/spec/output_drivers/"); gt_str_append_str(speclib, arguments->format); if (!gt_file_exists(gt_str_get(speclib))) { gt_error_set(err, "output driver file \"%s\" does not exist", gt_str_get(speclib)); had_err = -1; } } if (!had_err) { spec_visitor = gt_spec_visitor_new(gt_str_get(arguments->specfile), res, err); if (!spec_visitor) { gt_spec_results_delete(res); return -1; } } t = gt_timer_new(); gt_assert(t); /* add region mapping if given */ if (!had_err && gt_seqid2file_option_used(arguments->s2fi)) { rm = gt_seqid2file_region_mapping_new(arguments->s2fi, err); if (!rm) had_err = -1; if (!had_err) gt_spec_visitor_add_region_mapping((GtSpecVisitor*) spec_visitor, rm); } /* set type checker if necessary */ if (!had_err && gt_typecheck_info_option_used(arguments->tci)) { type_checker = gt_typecheck_info_create_type_checker(arguments->tci, err); if (!type_checker) had_err = -1; if (!had_err) gt_spec_visitor_add_type_checker((GtSpecVisitor*) spec_visitor, type_checker); } if (!had_err) { /* set runtime error behaviour */ if (arguments->fail_hard) gt_spec_visitor_fail_on_runtime_error((GtSpecVisitor*) spec_visitor); else gt_spec_visitor_report_runtime_errors((GtSpecVisitor*) spec_visitor); /* redirect warnings */ gt_warning_set_handler(gt_speck_record_warning, res); last_stream = gff3_in_stream = gt_gff3_in_stream_new_unsorted( argc - parsed_args, argv + parsed_args); gt_assert(gff3_in_stream); gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream); /* insert sort stream if requested */ if (arguments->sort) { last_stream = sort_stream = gt_sort_stream_new(last_stream); } /* if -provideindex is given, collect input features and index them first */ if (arguments->provideindex) { fi = gt_feature_index_memory_new(); gt_assert(fi); last_stream = feature_stream = gt_feature_stream_new(last_stream, fi); gt_assert(feature_stream); last_stream = a_out_stream = gt_array_out_stream_all_new(last_stream, arr, err); if (!a_out_stream) had_err = -1; gt_timer_start(t); if (!had_err) had_err = gt_node_stream_pull(last_stream, err); if (!had_err) { gt_spec_visitor_add_feature_index((GtSpecVisitor*) spec_visitor, gt_feature_index_ref(fi)); last_stream = a_in_stream = gt_array_in_stream_new(arr, NULL, err); if (!a_in_stream) had_err = -1; } } else { gt_timer_start(t); } if (!had_err) { checker_stream = gt_visitor_stream_new(last_stream, spec_visitor); gt_assert(checker_stream); } /* perform checking */ if (!had_err) had_err = gt_node_stream_pull(checker_stream, err); gt_timer_stop(t); /* reset warnings output */ gt_warning_set_handler(gt_warning_default_handler, NULL); /* output results */ if (!had_err) { GtStr *runtime = gt_str_new(); gt_timer_get_formatted(t, GT_WD ".%06ld", runtime); had_err = gt_spec_results_render_template(res, gt_str_get(speclib), arguments->outfp, gt_str_get(arguments->specfile), arguments->verbose, arguments->colored, gt_str_get(runtime), err); gt_str_delete(runtime); } } /* free */ gt_node_stream_delete(gff3_in_stream); gt_node_stream_delete(a_in_stream); gt_node_stream_delete(a_out_stream); gt_node_stream_delete(checker_stream); gt_node_stream_delete(feature_stream); gt_node_stream_delete(sort_stream); gt_spec_results_delete(res); gt_feature_index_delete(fi); gt_type_checker_delete(type_checker); gt_timer_delete(t); gt_array_delete(arr); gt_str_delete(speclib); return had_err; }
int main(int argc, char *argv[]) { const char *style_file, *png_file, *gff3_file; char *seqid; GtStyle *style; GtBioseq *bioseq; GtFeatureIndex *feature_index; GtRange range; GtDiagram *diagram; GtLayout *layout; GtCanvas *canvas; GtCustomTrack *custom; GtUword height, windowsize; GtError *err; if (argc != 9) { fprintf(stderr, "Usage: %s style_file PNG_file GFF3_file Seq_file seqid" " start end windowsize\n", argv[0]); return EXIT_FAILURE; } style_file = argv[1]; png_file = argv[2]; gff3_file = argv[3]; /* initialize */ gt_lib_init(); /* create error object */ err = gt_error_new(); /* create style */ if (!(style = gt_style_new(err))) handle_error(err); /* load style file */ if (gt_style_load_file(style, style_file, err)) handle_error(err); /* create feature index */ feature_index = gt_feature_index_memory_new(); /* add GFF3 file to index */ if (gt_feature_index_add_gff3file(feature_index, gff3_file, err)) handle_error(err); /* create diagram for first sequence ID in feature index */ seqid = argv[5]; if (gt_feature_index_get_range_for_seqid(feature_index, &range, seqid, err)) handle_error(err); sscanf(argv[6], "%lu", &range.start); sscanf(argv[7], "%lu", &range.end); sscanf(argv[8], "%lu", &windowsize); diagram = gt_diagram_new(feature_index, seqid, &range, style, err); if (gt_error_is_set(err)) handle_error(err); /* load sequence for GC plot */ bioseq = gt_bioseq_new(argv[4], err); if (gt_error_is_set(err)) handle_error(err); /* create custom track with GC plot for first sequence in file, window size 1000, 40px height and average line at 16.5% */ custom = gt_custom_track_gc_content_new(gt_bioseq_get_sequence(bioseq, 0), gt_bioseq_get_sequence_length(bioseq, 0), windowsize, 70, 0.165, true); gt_diagram_add_custom_track(diagram, custom); /* create layout with given width, determine resulting image height */ layout = gt_layout_new(diagram, 600, style, err); if (gt_error_is_set(err)) handle_error(err); if (gt_layout_get_height(layout, &height, err)) handle_error(err); /* create PNG canvas */ canvas = gt_canvas_cairo_file_new(style, GT_GRAPHICS_PNG, 600, height, NULL, err); if (!canvas) handle_error(err); /* sketch layout on canvas */ if (gt_layout_sketch(layout, canvas, err)) handle_error(err); /* write canvas to file */ if (gt_canvas_cairo_file_to_file((GtCanvasCairoFile*) canvas, png_file, err)) handle_error(err); /* free */ gt_custom_track_delete(custom); gt_bioseq_delete(bioseq); gt_canvas_delete(canvas); gt_layout_delete(layout); gt_diagram_delete(diagram); gt_feature_index_delete(feature_index); gt_style_delete(style); gt_error_delete(err); /* perform static data cleanup */ gt_lib_clean(); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { const char *style_file, *png_file, *gff3_file; char *seqid; GtStyle *style; GtFeatureIndex *feature_index; GtRange range; GtDiagram *diagram; GtLayout *layout; GtCanvas *canvas; GtUword height; GtError *err; if (argc != 4) { fprintf(stderr, "Usage: %s style_file PNG_file GFF3_file\n", argv[0]); return EXIT_FAILURE; } style_file = argv[1]; png_file = argv[2]; gff3_file = argv[3]; /* initialize */ gt_lib_init(); /* create error object */ err = gt_error_new(); /* create style */ if (!(style = gt_style_new(err))) handle_error(err); /* load style file */ if (gt_style_load_file(style, style_file, err)) handle_error(err); /* create feature index */ feature_index = gt_feature_index_memory_new(); /* add GFF3 file to index */ if (gt_feature_index_add_gff3file(feature_index, gff3_file, err)) handle_error(err); /* create diagram for first sequence ID in feature index */ if (!(seqid = gt_feature_index_get_first_seqid(feature_index, err))) { if (gt_error_is_set(err)) handle_error(err); } if (gt_feature_index_get_range_for_seqid(feature_index, &range, seqid, err)) handle_error(err); diagram = gt_diagram_new(feature_index, seqid, &range, style, err); gt_free(seqid); if (gt_error_is_set(err)) handle_error(err); /* create layout with given width, determine resulting image height */ layout = gt_layout_new(diagram, 600, style, err); if (!layout) handle_error(err); if (gt_layout_get_height(layout, &height, err)) handle_error(err); /* create PNG canvas */ canvas = gt_canvas_cairo_file_new(style, GT_GRAPHICS_PNG, 600, height, NULL, err); if (!canvas) handle_error(err); /* */ gt_layout_set_track_ordering_func(layout, rev_order_func, "foooo"); /* sketch layout on canvas */ if (gt_layout_sketch(layout, canvas, err)) handle_error(err); /* write canvas to file */ if (gt_canvas_cairo_file_to_file((GtCanvasCairoFile*) canvas, png_file, err)) handle_error(err); /* free */ gt_canvas_delete(canvas); gt_layout_delete(layout); gt_diagram_delete(diagram); gt_feature_index_delete(feature_index); gt_style_delete(style); gt_error_delete(err); /* perform static data cleanup */ gt_lib_clean(); return EXIT_SUCCESS; }