int main(int argc, char **argv)
{
if(argc != 2)
{
fputs("usage: vang schema.file\n", stderr);
return 1;
}
gt_lib_init();
char *schemafile = argv[1];
FILE *schema = fopen(schemafile, "r");
if(schema == NULL)
{
fprintf(stderr, "error: unable to open schema file '%s'\n", schemafile);
return 1;
}
GtArray *entry_datatypes = gt_array_new( sizeof(char *) );
GtHashmap *entries = gt_hashmap_new( GT_HASH_STRING, NULL,
(GtFree)vang_schema_entry_delete );
VangSchemaEntry *entry;
while( (entry = vang_schema_entry_next(schema)) != NULL )
{
char *datatype = (char *)vang_schema_entry_get_datatype(entry);
VangSchemaEntry *testentry = gt_hashmap_get(entries, datatype);
if(testentry != NULL)
{
fprintf( stderr, "warning: already have an entry for data type '%s'; "
"replacing\n", datatype );
vang_schema_entry_delete(testentry);
}
gt_hashmap_add(entries, datatype, entry);
gt_array_add(entry_datatypes, datatype);
}
unsigned long i;
for(i = 0; i < gt_array_size(entry_datatypes); i++)
{
const char *type = *(const char **)gt_array_get(entry_datatypes, i);
VangSchemaEntry *entry = gt_hashmap_get(entries, type);
vang_schema_entry_to_string(entry, stdout);
puts("");
}
gt_array_delete(entry_datatypes);
gt_hashmap_delete(entries);
gt_lib_clean();
return 0;
}
int main(int argc, char *argv[])
{
GtError *err;
GtWord readlong;
bool haserr = false, withsequence = false;
char *indexname = NULL, *mumlength_string = NULL;
if (argc == 3)
{
withsequence = false;
indexname = argv[1];
mumlength_string = argv[2];
} else
{
if (argc == 4)
{
if (strcmp(argv[1],"-s") != 0)
{
usage(argv[0]);
return EXIT_FAILURE;
}
withsequence = true;
indexname = argv[2];
mumlength_string = argv[3];
} else
{
usage(argv[0]);
return EXIT_FAILURE;
}
}
if (sscanf(mumlength_string,GT_WD,&readlong) != 1 || readlong < 0)
{
usage(argv[0]);
return EXIT_FAILURE;
}
gt_lib_init();
err = gt_error_new();
if (gt_stree_mum(indexname, (GtUword) readlong, withsequence, err) != 0)
{
fprintf(stderr,"%s: failure when enumerating branch locs for "
" index %s: %s\n",
argv[0],indexname,gt_error_get(err));
haserr = true;
}
gt_error_delete(err);
if (gt_lib_clean() != 0)
{
return GT_EXIT_PROGRAMMING_ERROR;
}
return haserr ? EXIT_FAILURE : EXIT_SUCCESS;
}
int main(int argc, const char *argv[])
{
GtNodeStream *gff3_in_stream;
GtGenomeNode *gn;
GtError *err;
int had_err;
if (gt_version_check(GT_MAJOR_VERSION, GT_MINOR_VERSION, GT_MICRO_VERSION)) {
fprintf(stderr, "error: %s\n", gt_version_check(GT_MAJOR_VERSION,
GT_MINOR_VERSION,
GT_MICRO_VERSION));
return EXIT_FAILURE;
}
/* initialize */
gt_lib_init();
/* create error object */
err = gt_error_new();
/* create GFF3 input stream (with ID attribute checking) */
gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc-1, argv+1);
gt_gff3_in_stream_check_id_attributes((GtGFF3InStream*) gff3_in_stream);
/* pull the features through the stream and free them afterwards */
while (!(had_err = gt_node_stream_next(gff3_in_stream, &gn, err)) && gn)
gt_genome_node_delete(gn);
/* handle error */
if (had_err)
fprintf(stderr, "%s: error: %s\n", argv[0], gt_error_get(err));
else
printf("input is valid GFF3\n");
/* free */
gt_node_stream_delete(gff3_in_stream);
gt_error_delete(err);
if (had_err)
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
int main(int argc, char ** argv)
{
GtNodeStream * in, * score, * out;
GtFile * out_file;
GtError * err;
if (argc != 4)
{
usage(argv[0]);
exit(1);
}
// initilaize genometools
gt_lib_init();
err = gt_error_new();
if (!(in = gt_gff3_in_stream_new_sorted(argv[1])))
{
fprintf(stderr, "Failed to open input stream with arg %s\n", argv[1]);
exit(1);
}
if (!(out_file = gt_file_new(argv[2], "w+", err)))
{
gt_node_stream_delete(in);
fprintf(stderr, "Failed to create output file %s\n", argv[2]);
exit(1);
}
if (!(score = CpGI_score_stream_new(in, argv[3])))
{
gt_file_delete(out_file);
gt_node_stream_delete(in);
fprintf(stderr, "Failed to create CpGI score stream\n");
exit(1);
}
out = gt_gff3_out_stream_new(in, out_file);
if (!(out = gt_gff3_out_stream_new(score, out_file)))
{
gt_node_stream_delete(score);
gt_file_delete(out_file);
gt_node_stream_delete(in);
fprintf(stderr, "Failed to create output stream\n");
exit(1);
}
if (gt_node_stream_pull(out, err))
{
fprintf(stderr, "Failed to pull through out stream\n");
}
// close genome tools
gt_node_stream_delete(out);
gt_node_stream_delete(score);
gt_file_delete(out_file);
gt_node_stream_delete(in);
gt_error_delete(err);
gt_lib_clean();
return 0;
}
// Main method
int main(int argc, char * const *argv)
{
GtError *error;
GtLogger *logger;
GtQueue *streams;
GtNodeStream *stream, *last_stream;
CanonGFF3Options options = { NULL, NULL, false };
gt_lib_init();
error = gt_error_new();
canon_gff3_parse_options(argc, argv + 0, &options, error);
streams = gt_queue_new();
logger = gt_logger_new(true, "", stderr);
stream = gt_gff3_in_stream_new_unsorted(argc - optind, (const char **)
argv+optind);
gt_gff3_in_stream_check_id_attributes((GtGFF3InStream *)stream);
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream *)stream);
gt_queue_add(streams, stream);
last_stream = stream;
if(options.infer)
{
GtHashmap *type_parents = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
gt_free_func);
gt_hashmap_add(type_parents, gt_cstr_dup("mRNA"), gt_cstr_dup("gene"));
gt_hashmap_add(type_parents, gt_cstr_dup("tRNA"), gt_cstr_dup("gene"));
stream = agn_infer_parent_stream_new(last_stream,
type_parents);
gt_hashmap_delete(type_parents);
gt_queue_add(streams, stream);
last_stream = stream;
}
stream = agn_gene_stream_new(last_stream, logger);
gt_queue_add(streams, stream);
last_stream = stream;
if(options.source != NULL)
{
GtNodeVisitor *ssv = gt_set_source_visitor_new(options.source);
stream = gt_visitor_stream_new(last_stream, ssv);
gt_queue_add(streams, stream);
last_stream = stream;
}
stream = gt_gff3_out_stream_new(last_stream, options.outstream);
if(!options.infer)
gt_gff3_out_stream_retain_id_attributes((GtGFF3OutStream *)stream);
gt_queue_add(streams, stream);
last_stream = stream;
if(gt_node_stream_pull(last_stream, error) == -1)
{
fprintf(stderr, "[CanonGFF3] error processing node stream: %s",
gt_error_get(error));
}
while(gt_queue_size(streams) > 0)
{
stream = gt_queue_get(streams);
gt_node_stream_delete(stream);
}
gt_queue_delete(streams);
if(options.source != NULL)
gt_str_delete(options.source);
if(options.outstream != NULL)
gt_file_delete(options.outstream);
gt_error_delete(error);
gt_logger_delete(logger);
gt_lib_clean();
return 0;
}
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;
}
