GtMatchIterator* gt_match_iterator_open_new(const char *matchfile, GtError *err)
{
GtMatchIterator *mp;
GtMatchIteratorOpen *mpo;
mp = gt_match_iterator_create(gt_match_iterator_open_class());
mpo = (GtMatchIteratorOpen*) mp;
mpo->pvt = gt_calloc(1, sizeof (GtMatchIteratorOpenMembers));
GtFileMode mode;
if (gt_file_exists(matchfile)) {
mode = gt_file_mode_determine(matchfile);
if (mode == GT_FILE_MODE_UNCOMPRESSED) {
mpo->pvt->matchfilep = fopen(matchfile, "r");
mpo->pvt->gtmatchfilep = NULL;
if (!mpo->pvt->matchfilep) {
gt_error_set(err, "Could not open %s", matchfile);
return NULL;
}
} else {
mpo->pvt->gtmatchfilep = gt_file_open(mode, matchfile, "r", err);
mpo->pvt->matchfilep = NULL;
if (!mpo->pvt->gtmatchfilep)
return NULL;
}
mpo->pvt->matchfile = matchfile;
return mp;
} else {
gt_error_set(err, "No such file or directory %s", matchfile);
return NULL;
}
}
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;
}
GtNodeStream* gt_ltrdigest_file_out_stream_new(GtNodeStream *in_stream,
int tests_to_run,
GtRegionMapping *rmap,
char *file_prefix,
unsigned int seqnamelen,
GtError* err)
{
GtNodeStream *ns;
GtLTRdigestFileOutStream *ls;
char fn[GT_MAXFILENAMELEN];
gt_error_check(err);
gt_assert(file_prefix && in_stream && rmap);
ns = gt_node_stream_create(gt_ltrdigest_file_out_stream_class(), false);
ls = gt_ltrdigest_file_out_stream_cast(ns);
/* ref GFF input stream and sequences*/
ls->in_stream = gt_node_stream_ref(in_stream);
ls->rmap = rmap;
ls->tests_to_run = tests_to_run;
ls->seqnamelen = seqnamelen;
ls->write_pdom_alignments = false;
ls->write_pdom_aaseqs = false;
/* open outfiles */
ls->fileprefix = file_prefix;
(void) snprintf(fn, (size_t) (GT_MAXFILENAMELEN-1),
"%s_tabout.csv", file_prefix);
ls->tabout_file = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, fn, "w+", err);
if (tests_to_run & GT_LTRDIGEST_RUN_PPT)
{
(void) snprintf(fn, (size_t) (GT_MAXFILENAMELEN-1),
"%s_ppt.fas", file_prefix);
ls->pptout_file = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, fn, "w+", err);
}
if (tests_to_run & GT_LTRDIGEST_RUN_PBS)
{
(void) snprintf(fn, (size_t) (GT_MAXFILENAMELEN-1),
"%s_pbs.fas", file_prefix);
ls->pbsout_file = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, fn, "w+", err);
}
(void) snprintf(fn, (size_t) (GT_MAXFILENAMELEN-1),
"%s_5ltr.fas", file_prefix);
ls->ltr5out_file = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, fn, "w+", err);
(void) snprintf(fn, (size_t) (GT_MAXFILENAMELEN-1),
"%s_3ltr.fas", file_prefix);
ls->ltr3out_file = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, fn, "w+", err);
(void) snprintf(fn, (size_t) (GT_MAXFILENAMELEN-1),
"%s_complete.fas", file_prefix);
ls->elemout_file = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, fn, "w+", err);
/* create hashmaps to hold protein domain output files */
ls->pdomout_files = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) gt_file_delete);
ls->pdomali_files = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) gt_file_delete);
ls->pdomaa_files = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) gt_file_delete);
/* print tabular outfile headline */
gt_file_xprintf(ls->tabout_file,
"element start\telement end\telement length\tsequence\t"
"lLTR start\tlLTR end\tlLTR length\t"
"rLTR start\trLTR end\trLTR length\t"
"lTSD start\tlTSD end\tlTSD motif\t"
"rTSD start\trTSD end\trTSD motif\t"
"PPT start\tPPT end\tPPT motif\tPPT strand\tPPT offset");
gt_file_xprintf(ls->tabout_file,
"\tPBS start\tPBS end\tPBS strand\ttRNA\ttRNA motif\tPBS offset\t"
"tRNA offset\tPBS/tRNA edist");
#ifdef HAVE_HMMER
gt_file_xprintf(ls->tabout_file, "\tProtein domain hits");
#endif
gt_file_xprintf(ls->tabout_file, "\n");
/* create visitor */
ls->lv = (GtLTRVisitor*) gt_ltr_visitor_new(&ls->element);
return ns;
}
int gt_ltrdigest_file_out_stream_write_metadata(GtLTRdigestFileOutStream *ls,
int tests_to_run,
const char *trnafilename,
const char *gfffilename,
GtRange ppt_len,
GtRange ubox_len,
unsigned int ppt_radius,
GtRange alilen,
unsigned int max_edist,
GtRange offsetlen,
GtRange trnaoffsetlen,
unsigned int pbs_radius,
GtStrArray *hmm_files,
unsigned int chain_max_gap_length,
double evalue_cutoff,
GtError *err)
{
int buflen = 1024;
GtFile *metadata_file;
char *buffer,
fn[GT_MAXFILENAMELEN];
(void) snprintf(fn, (size_t) (GT_MAXFILENAMELEN-1),
"%s_conditions.csv", ls->fileprefix);
metadata_file = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, fn, "w+", err);
if (!metadata_file)
return -1;
buffer = gt_calloc((size_t) (buflen+1), sizeof (char));
/* get working directory */
while (getcwd(buffer, (size_t) buflen) == NULL) {
buflen += 1024;
buffer = gt_realloc(buffer, (buflen+1) * sizeof (char));
}
gt_assert(buffer && strlen(buffer) > 0);
/* append working dir to relative paths if necessary */
if (gfffilename == NULL) {
gt_file_xprintf(metadata_file,
"GFF3 input used\t<stdin>\n");
} else {
if (gfffilename[0] != GT_PATH_SEPARATOR)
gt_file_xprintf(metadata_file,
"GFF3 input used\t%s/%s\n", buffer, gfffilename);
else
gt_file_xprintf(metadata_file,
"GFF3 input used\t%s\n", gfffilename);
}
if (tests_to_run & GT_LTRDIGEST_RUN_PPT)
{
gt_file_xprintf(metadata_file,
"PPT length\t"GT_WU"-"GT_WU"nt\t8-30nt\n",
ppt_len.start,
ppt_len.end);
gt_file_xprintf(metadata_file,
"U-box length\t"GT_WU"-"GT_WU"nt\t3-30nt\n",
ubox_len.start,
ubox_len.end);
gt_file_xprintf(metadata_file,
"PPT search radius\t%u\t30\n", ppt_radius);
}
if (tests_to_run & GT_LTRDIGEST_RUN_PBS)
{
if (trnafilename[0] != GT_PATH_SEPARATOR)
gt_file_xprintf(metadata_file,
"tRNA library for PBS detection\t%s/%s\n",
buffer, trnafilename);
else
gt_file_xprintf(metadata_file,
"tRNA library for PBS detection\t%s\n",
trnafilename);
gt_file_xprintf(metadata_file,
"allowed PBS/tRNA alignment length"
" range\t"GT_WU"-"GT_WU"nt\t11-30nt\n",
alilen.start,
alilen.end);
gt_file_xprintf(metadata_file,
"PBS/tRNA maximum unit edit distance\t%u\t1\n",
max_edist);
gt_file_xprintf(metadata_file,
"allowed PBS offset from 5' LTR range"
"\t"GT_WU"-"GT_WU"nt\t0-5nt\n",
offsetlen.start,
offsetlen.end);
gt_file_xprintf(metadata_file,
"allowed PBS offset from 3' tRNA end"
" range\t"GT_WU"-"GT_WU"nt\t0-5nt\n",
trnaoffsetlen.start,
trnaoffsetlen.end);
gt_file_xprintf(metadata_file,
"PBS search radius\t%d\t30\n", pbs_radius);
}
if (tests_to_run & GT_LTRDIGEST_RUN_PDOM)
{
GtUword i;
gt_file_xprintf(metadata_file,
"Protein domain models\t"GT_WU" (",
gt_str_array_size(hmm_files));
for (i=0;i<gt_str_array_size(hmm_files);i++)
{
gt_file_xprintf(metadata_file, "%s", gt_str_array_get(hmm_files, i));
if (i != gt_str_array_size(hmm_files)-1)
gt_file_xprintf(metadata_file, ", ");
}
gt_file_xprintf(metadata_file, ")\n");
gt_file_xprintf(metadata_file,
"pHMM e-value cutoff \t%g\t%g\n",
evalue_cutoff, 0.000001);
gt_file_xprintf(metadata_file,
"maximal allowed gap length between fragments to chain"
" \t%u\t%u\n",
chain_max_gap_length, 50);
}
gt_file_xprintf(metadata_file, "\n");
if (metadata_file != NULL)
gt_file_delete(metadata_file);
gt_free(buffer);
return 0;
}
static int store_in_subset_file(void *data, GthSA *sa,
const char *outputfilename, GtError *err)
{
Store_in_subset_file_data *store_in_subset_file_data =
(Store_in_subset_file_data*) data;
double split_determing_percentage = 0.0;
unsigned long filenum;
char filenamesuffix[4];
int had_err = 0;
gt_error_check(err);
/* filter before we do any further processing */
if (gth_sa_filter_filter_sa(store_in_subset_file_data->sa_filter, sa)) {
/* and free it afterwards */
gth_sa_delete(sa);
/* discard */
return 0;
}
/* check whether we got a new output file to process */
if (!store_in_subset_file_data->current_outputfilename) {
store_in_subset_file_data->current_outputfilename =
gt_cstr_dup(outputfilename);
}
else if (strcmp(store_in_subset_file_data->current_outputfilename,
outputfilename)) {
/* close current output files */
close_output_files(store_in_subset_file_data);
gt_free(store_in_subset_file_data->current_outputfilename);
}
/* determine in which file the current sa needs to be put */
switch (store_in_subset_file_data->gthsplitinfo->splitmode) {
case ALIGNMENTSCORE_SPLIT:
split_determing_percentage = gth_sa_score(sa);
strcpy(filenamesuffix, "scr");
break;
case COVERAGE_SPLIT:
split_determing_percentage = gth_sa_coverage(sa);
strcpy(filenamesuffix, "cov");
break;
default: gt_assert(0);
}
gt_assert(split_determing_percentage >= 0.0);
/* XXX: change into an assertion when coverage problem is fixed */
if (split_determing_percentage > 1.0)
split_determing_percentage = 1.0;
if (split_determing_percentage == 1.0)
filenum = store_in_subset_file_data->num_of_subset_files - 1;
else {
filenum = floor(split_determing_percentage * 100.0 /
store_in_subset_file_data->gthsplitinfo->range);
}
gt_assert(filenum < store_in_subset_file_data->num_of_subset_files);
/* make sure the file exists and is open */
if (!store_in_subset_file_data->subset_files[filenum]) {
gt_assert(store_in_subset_file_data->subset_filenames[filenum] == NULL);
store_in_subset_file_data->subset_filenames[filenum] = gt_str_new();
gt_str_append_cstr_nt(store_in_subset_file_data->subset_filenames[filenum],
outputfilename,
gt_file_basename_length(outputfilename));
gt_str_append_char(store_in_subset_file_data->subset_filenames[filenum],
'.');
gt_str_append_cstr(store_in_subset_file_data->subset_filenames[filenum],
filenamesuffix);
gt_str_append_ulong(store_in_subset_file_data->subset_filenames[filenum],
filenum *
store_in_subset_file_data->gthsplitinfo->range);
gt_str_append_char(store_in_subset_file_data->subset_filenames[filenum],
'-');
gt_str_append_ulong(store_in_subset_file_data->subset_filenames[filenum],
(filenum + 1) *
store_in_subset_file_data->gthsplitinfo->range);
gt_str_append_cstr(store_in_subset_file_data->subset_filenames[filenum],
gt_file_mode_suffix(store_in_subset_file_data
->gthsplitinfo->file_mode));
/* if not disabled by -force, check if file already exists */
if (!store_in_subset_file_data->gthsplitinfo->force) {
store_in_subset_file_data->subset_files[filenum] =
gt_file_open(store_in_subset_file_data->gthsplitinfo->file_mode,
gt_str_get(store_in_subset_file_data
->subset_filenames[filenum]), "r", NULL);
if (store_in_subset_file_data->subset_files[filenum]) {
gt_error_set(err, "file \"%s\" exists already. use option -%s to "
"overwrite", gt_str_get(store_in_subset_file_data
->subset_filenames[filenum]),
GT_FORCE_OPT_CSTR);
had_err = -1;
}
}
if (!had_err) {
/* open split file for writing */
store_in_subset_file_data->subset_files[filenum] =
gt_file_xopen_file_mode(store_in_subset_file_data->gthsplitinfo
->file_mode,
gt_str_get(store_in_subset_file_data
->subset_filenames[filenum]), "w");
/* store XML header in file */
gth_xml_show_leader(true,
store_in_subset_file_data->subset_files[filenum]);
}
}
/* put it there */
if (!had_err) {
gth_xml_inter_sa_visitor_set_outfp(store_in_subset_file_data->sa_visitor,
store_in_subset_file_data
->subset_files[filenum]);
gth_sa_visitor_visit_sa(store_in_subset_file_data->sa_visitor, sa);
}
/* adjust counter */
if (!had_err)
store_in_subset_file_data->subset_file_sa_counter[filenum]++;
/* and free it afterwards */
gth_sa_delete(sa);
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;
}
GtFile* gt_file_new(const char *path, const char *mode, GtError *err)
{
gt_error_check(err);
gt_assert(mode);
return gt_file_open(gt_file_mode_determine(path), path, mode, err);
}
