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;
}
int gt_block_unit_test(GtError *err)
{
GtRange r1, r2, r_temp, b_range;
GtStrand s;
GtGenomeNode *gn1, *gn2;
GtElement *e1, *e2;
double height;
GtBlock *b;
GtStr *seqid, *caption1, *caption2;
int had_err = 0;
GtStyle *sty;
GtError *testerr;
gt_error_check(err);
seqid = gt_str_new_cstr("seqid");
caption1 = gt_str_new_cstr("foo");
caption2 = gt_str_new_cstr("bar");
testerr = gt_error_new();
r1.start = 10UL;
r1.end = 50UL;
r2.start = 40UL;
r2.end = 50UL;
gn1 = gt_feature_node_new(seqid, gt_ft_gene, r1.start, r1.end,
GT_STRAND_FORWARD);
gn2 = gt_feature_node_new(seqid, gt_ft_exon, r2.start, r2.end,
GT_STRAND_FORWARD);
e1 = gt_element_new((GtFeatureNode*) gn1);
e2 = gt_element_new((GtFeatureNode*) gn2);
b = gt_block_new();
/* test gt_block_insert_elements */
gt_ensure((0UL == gt_block_get_size(b)));
gt_block_insert_element(b, (GtFeatureNode*) gn1);
gt_ensure((1UL == gt_block_get_size(b)));
gt_block_insert_element(b, (GtFeatureNode*) gn2);
gt_ensure((2UL == gt_block_get_size(b)));
/* test gt_block_set_range & gt_block_get_range */
r_temp = gt_range_join(&r1, &r2);
gt_block_set_range(b, r_temp);
b_range = gt_block_get_range(b);
gt_ensure((0 == gt_range_compare(&b_range, &r_temp)));
gt_ensure((1 == gt_range_compare(&r2, &r_temp)));
/* tests gt_block_set_caption & gt_block_get_caption */
gt_block_set_caption(b, caption1);
gt_ensure((0 == gt_str_cmp(gt_block_get_caption(b), caption1)));
gt_ensure((0 != gt_str_cmp(gt_block_get_caption(b), caption2)));
/* tests gt_block_set_strand & gt_block_get_range */
s = gt_block_get_strand(b);
gt_ensure((GT_STRAND_UNKNOWN == s));
gt_block_set_strand(b, GT_STRAND_FORWARD);
s = gt_block_get_strand(b);
gt_ensure((GT_STRAND_FORWARD == s));
/* test gt_block_get_max_height() */
sty = gt_style_new(err);
gt_ensure(gt_block_get_max_height(b, &height, sty, err) == 0);
gt_ensure(!gt_error_is_set(testerr));
gt_ensure(height == BAR_HEIGHT_DEFAULT);
gt_style_set_num(sty, "exon", "bar_height", 42);
gt_ensure(gt_block_get_max_height(b, &height, sty, err) == 0);
gt_ensure(!gt_error_is_set(testerr));
gt_ensure(height == 42);
gt_style_set_num(sty, "gene", "bar_height", 23);
gt_ensure(gt_block_get_max_height(b, &height, sty, err) == 0);
gt_ensure(!gt_error_is_set(testerr));
gt_ensure(height == 42);
gt_style_unset(sty, "exon", "bar_height");
gt_ensure(gt_block_get_max_height(b, &height, sty, err) == 0);
gt_ensure(!gt_error_is_set(testerr));
gt_ensure(height == 23);
gt_str_delete(caption2);
gt_str_delete(seqid);
gt_element_delete(e1);
gt_element_delete(e2);
gt_block_delete(b);
gt_style_delete(sty);
gt_error_delete(testerr);
gt_genome_node_delete(gn1);
gt_genome_node_delete(gn2);
return had_err;
}
int gt_track_unit_test(GtError *err)
{
int had_err = 0;
GtBlock *b[4];
GtRange r[4];
GtTrack *track;
GtGenomeNode *parent[4], *gn[4];
GtStr *title;
double height, tmp;
GtStyle *sty;
unsigned long i;
GtLineBreaker *lb;
double t_rest = 0,
l_rest = 0;
gt_error_check(err);
title = gt_str_new_cstr("test");
r[0].start=100UL;
r[0].end=1000UL;
r[1].start=1001UL;
r[1].end=1500UL;
r[2].start=700UL;
r[2].end=1200UL;
r[3].start=10UL;
r[3].end=200UL;
for (i=0; i<4; i++)
{
parent[i] = gt_feature_node_new(title, gt_ft_gene, r[i].start, r[i].end,
GT_STRAND_FORWARD);
gn[i] = gt_feature_node_new(title, gt_ft_exon, r[i].start, r[i].end,
GT_STRAND_FORWARD);
gt_feature_node_add_child((GtFeatureNode*) parent[i],
(GtFeatureNode*) gn[i]);
gt_feature_node_add_attribute((GtFeatureNode*) parent[i], GT_GFF_NAME,
"parent");
gt_feature_node_add_attribute((GtFeatureNode*) gn[i], GT_GFF_NAME, "child");
}
for (i=0; i<4; i++)
{
b[i] = gt_block_new();
gt_block_set_range(b[i], r[i]);
gt_block_insert_element(b[i], (GtFeatureNode*) parent[i]);
gt_block_insert_element(b[i], (GtFeatureNode*) gn[i]);
}
lb = gt_line_breaker_bases_new();
sty = gt_style_new(err);
if (gt_style_get_num(sty, "format", "track_caption_font_size", &tmp,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
tmp = TEXT_SIZE_DEFAULT;
}
t_rest += tmp;
if (gt_style_get_num(sty, "format", "track_caption_space", &tmp,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
tmp = CAPTION_BAR_SPACE_DEFAULT;
}
t_rest += tmp;
if (gt_style_get_num(sty, "format", "track_vspace", &tmp,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
tmp = TRACK_VSPACE_DEFAULT;
}
t_rest += tmp;
if (gt_style_get_num(sty, "format", "bar_vspace", &l_rest,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
l_rest = BAR_VSPACE_DEFAULT;
}
track = gt_track_new(title, GT_UNDEF_ULONG, true, lb);
gt_ensure(had_err, track);
gt_ensure(had_err, gt_track_get_title(track) == title);
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 0);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_insert_block(track, b[0], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 1);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + l_rest + BAR_HEIGHT_DEFAULT);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_insert_block(track, b[1], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 1);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + l_rest + BAR_HEIGHT_DEFAULT);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_insert_block(track, b[2], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 2);
gt_ensure(had_err, gt_track_insert_block(track, b[3], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 2);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest + BAR_HEIGHT_DEFAULT));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_set_num(sty, "exon", "bar_height", 42);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+42));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_set_num(sty, "gene", "bar_height", 23);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+42));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_unset(sty, "exon", "bar_height");
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+23));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_unset(sty, "gene", "bar_height");
gt_style_set_num(sty, "format", "bar_height", 99);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+99));
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_discarded_blocks(track) == 0);
gt_track_delete(track);
gt_str_delete(title);
gt_style_delete(sty);
for (i=0; i<4; i++)
{
gt_block_delete(b[i]);
gt_genome_node_delete(parent[i]);
}
return had_err;
}
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;
}
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;
}
