int gt_graphics_cairo_save_to_file(const GtGraphics *gg, const char *filename, GtError *err) { const GtGraphicsCairo *g = (const GtGraphicsCairo*) gg; cairo_surface_t *bgsurf = NULL; cairo_t *bgc = NULL; cairo_status_t rval; GtFile *outfile; gt_error_check(err); gt_assert(g && filename); /* do nothing if no surface was created */ if (g->from_context) return 0; switch (g->type) { case GT_GRAPHICS_PNG: /* blend rendered image with background color */ bgsurf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, g->width, g->height); bgc = cairo_create(bgsurf); cairo_set_source_rgba(bgc, g->bg_color.red, g->bg_color.green, g->bg_color.blue, g->bg_color.alpha); cairo_paint(bgc); cairo_set_source_surface(bgc, g->surf, 0, 0); cairo_paint(bgc); rval = cairo_surface_write_to_png(bgsurf, filename); gt_assert(rval == CAIRO_STATUS_SUCCESS || rval == CAIRO_STATUS_WRITE_ERROR); if (rval == CAIRO_STATUS_WRITE_ERROR) { cairo_destroy(bgc); cairo_surface_destroy(bgsurf); gt_error_set(err, "an I/O error occurred while attempting " "to write image file \"%s\"", filename); return -1; } cairo_destroy(bgc); cairo_surface_destroy(bgsurf); break; default: cairo_show_page(g->cr); cairo_surface_flush(g->surf); cairo_surface_finish(g->surf); outfile = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, filename, "w+", err); if (outfile) { gt_file_xwrite(outfile, gt_str_get_mem(g->outbuf), gt_str_length(g->outbuf)); gt_file_delete(outfile); } else return -1; break; } return 0; }
static int run_orffinder(GtRegionMapping *rmap, GtFeatureNode *gf, unsigned long start, GT_UNUSED unsigned long end, unsigned int min, unsigned int max, bool all, GtError *err) { int had_err = 0, i; unsigned long sum; GtCodonIterator* ci = NULL; GtTranslator* translator = NULL; GtORFIterator* orfi = NULL; GtORFIteratorStatus state; GtRange orf_rng, tmp_orf_rng[3]; GtStr *seq; unsigned int orf_frame; /* forward strand */ seq = gt_str_new(); had_err = gt_extract_feature_sequence(seq, (GtGenomeNode*) gf, gt_feature_node_get_type(gf), false, NULL, NULL, rmap, err); ci = gt_codon_iterator_simple_new(gt_str_get(seq), gt_str_length(seq), err); gt_assert(ci); translator = gt_translator_new(ci); gt_assert(translator); orfi = gt_orf_iterator_new(ci, translator); gt_assert(orfi); for (i = 0; i < 3; i++) { tmp_orf_rng[i].start = GT_UNDEF_ULONG; tmp_orf_rng[i].end = GT_UNDEF_ULONG; } while ((state = gt_orf_iterator_next(orfi, &orf_rng, &orf_frame, err)) == GT_ORF_ITERATOR_OK) { if (all) { process_orf(orf_rng, orf_frame, GT_STRAND_FORWARD, gf, start, min, max, err); } else { if (gt_range_length(&orf_rng) > gt_range_length(&tmp_orf_rng[orf_frame])) { tmp_orf_rng[orf_frame].start = orf_rng.start; tmp_orf_rng[orf_frame].end = orf_rng.end; } } } if (state == GT_ORF_ITERATOR_ERROR) had_err = -1; if (!had_err) { if (!all) { for (i = 0; i < 3; i++) { if (tmp_orf_rng[i].start != GT_UNDEF_ULONG) { process_orf(tmp_orf_rng[i], (unsigned int) i, GT_STRAND_FORWARD, gf, start, min, max, err); } } } gt_codon_iterator_delete(ci); gt_translator_delete(translator); gt_orf_iterator_delete(orfi); orfi = NULL; ci = NULL; translator = NULL; for (i = 0; i < 3; i++) { tmp_orf_rng[i].start = GT_UNDEF_ULONG; tmp_orf_rng[i].end = GT_UNDEF_ULONG; } /* reverse strand */ if (!had_err) { GT_UNUSED int rval = 0; unsigned long length = gt_str_length(seq); char *strp = (char*) gt_str_get_mem(seq); rval = gt_reverse_complement(strp, gt_str_length(seq), err); gt_assert(!rval); /* XXX */ ci = gt_codon_iterator_simple_new(gt_str_get(seq), gt_str_length(seq), err); gt_assert(ci); translator = gt_translator_new(ci); gt_assert(translator); orfi = gt_orf_iterator_new(ci, translator); gt_assert(orfi); sum = start + length - 1; while ((state = gt_orf_iterator_next(orfi, &orf_rng, &orf_frame, err)) == GT_ORF_ITERATOR_OK) { if (all) { process_orf(orf_rng, orf_frame, GT_STRAND_REVERSE, gf, sum, min, max, err); } else { if (gt_range_length(&orf_rng) > gt_range_length(&tmp_orf_rng[orf_frame])) { tmp_orf_rng[orf_frame].start = orf_rng.start; tmp_orf_rng[orf_frame].end = orf_rng.end; } } } if (state == GT_ORF_ITERATOR_ERROR) had_err = -1; if (!had_err) { if (!all) { for (i = 0; i < 3; i++) { if (tmp_orf_rng[i].start != GT_UNDEF_ULONG) { process_orf(tmp_orf_rng[i], (unsigned int) i, GT_STRAND_REVERSE, gf, sum, min, max, err); } } } } } gt_str_delete(seq); gt_codon_iterator_delete(ci); gt_translator_delete(translator); gt_orf_iterator_delete(orfi); } 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; }