static int gt_ltrdigest_pdom_visitor_attach_hit(GtLTRdigestPdomVisitor *lv,
GtHMMERModelHit *modelhit,
GtHMMERSingleHit *singlehit)
{
GT_UNUSED GtUword i;
GtGenomeNode *gf;
int had_err = 0;
GtRange rrng;
gt_assert(lv && singlehit);
rrng = gt_ltrdigest_pdom_visitor_coords(lv, singlehit);
if (gt_array_size(singlehit->chains) > 0 || lv->output_all_chains) {
char buf[32];
gf = gt_feature_node_new(gt_genome_node_get_seqid((GtGenomeNode*)
lv->ltr_retrotrans),
gt_ft_protein_match,
rrng.start,
rrng.end,
singlehit->strand);
gt_genome_node_add_user_data((GtGenomeNode*) gf, "pdom_alignment",
gt_str_ref(singlehit->alignment),
(GtFree) gt_str_delete);
gt_genome_node_add_user_data((GtGenomeNode*) gf, "pdom_aaseq",
gt_str_ref(singlehit->aastring),
(GtFree) gt_str_delete);
gt_feature_node_set_source((GtFeatureNode*) gf, lv->tag);
gt_feature_node_set_score((GtFeatureNode*) gf, (float) singlehit->evalue);
(void) snprintf(buf, (size_t) 32, "%d", (int) singlehit->frame);
gt_feature_node_add_attribute((GtFeatureNode*) gf,
"reading_frame", buf);
if (modelhit->modelname != NULL) {
gt_feature_node_add_attribute((GtFeatureNode*) gf, "name",
modelhit->modelname);
}
if (gt_array_size(singlehit->chains) > 1UL && lv->output_all_chains) {
GtStr *buffer;
GtUword j;
gt_assert(singlehit->chains != NULL);
buffer = gt_str_new();
for (j = 0UL; j < gt_array_size(singlehit->chains); j++) {
gt_str_append_cstr(buffer, modelhit->modelname);
gt_str_append_char(buffer, ':');
gt_str_append_ulong(buffer,
*(GtUword*) gt_array_get(singlehit->chains, j));
if (j != gt_array_size(singlehit->chains) - 1) {
gt_str_append_char(buffer, ',');
}
}
gt_feature_node_set_attribute((GtFeatureNode*) gf, "chains",
gt_str_get(buffer));
gt_str_delete(buffer);
}
gt_feature_node_add_child(lv->ltr_retrotrans, (GtFeatureNode*) gf);
}
gt_array_delete(singlehit->chains);
singlehit->chains = NULL;
return had_err;
}
GtBlock* gt_block_clone(GtBlock *block)
{
GtBlock* newblock;
GtUword i;
gt_assert(block);
newblock = gt_block_new();
for (i=0;i<gt_array_size(block->elements);i++)
{
GtElement *elem;
elem = gt_element_ref(*(GtElement**) gt_array_get(block->elements, i));
gt_assert(elem);
gt_array_add(newblock->elements, elem);
}
gt_assert(gt_block_get_size(newblock) == gt_block_get_size(block));
newblock->caption = gt_str_ref(block->caption);
newblock->type = block->type;
newblock->range.start = block->range.start;
newblock->range.end = block->range.end;
newblock->show_caption = block->show_caption;
newblock->strand = block->strand;
newblock->top_level_feature = (GtFeatureNode*)
gt_genome_node_ref((GtGenomeNode*)
block->top_level_feature);
return newblock;
}
static void feature_node_change_seqid(GtGenomeNode *gn, GtStr *seqid)
{
GtFeatureNode *fn = gt_feature_node_cast(gn);
gt_assert(fn && seqid);
gt_str_delete(fn->seqid);
fn->seqid = gt_str_ref(seqid);
}
static GtBioseq* bioseq_new_with_recreate_and_type(GtStr *sequence_file,
bool recreate, GtError *err)
{
GtBioseq *bs;
int had_err = 0;
gt_error_check(err);
bs = gt_calloc(1, sizeof *bs);
if (!strcmp(gt_str_get(sequence_file), "-"))
bs->use_stdin = true;
if (!bs->use_stdin && !gt_file_exists(gt_str_get(sequence_file))) {
gt_error_set(err, "sequence file \"%s\" does not exist or is not readable",
gt_str_get(sequence_file));
had_err = -1;
}
if (!had_err) {
bs->sequence_file = gt_str_ref(sequence_file);
had_err = bioseq_fill(bs, recreate, err);
}
if (had_err) {
gt_bioseq_delete(bs);
return NULL;
}
gt_assert(bs->encseq);
bs->descriptions = gt_calloc(gt_encseq_num_of_sequences(bs->encseq),
sizeof (char*));
return bs;
}
GtGenomeNode* gt_feature_node_new(GtStr *seqid, const char *type,
GtUword start, GtUword end,
GtStrand strand)
{
GtGenomeNode *gn;
GtFeatureNode *fn;
gt_assert(seqid && type);
gt_assert(start <= end);
gn = gt_genome_node_create(gt_feature_node_class());
fn = gt_feature_node_cast(gn);
fn->seqid = gt_str_ref(seqid);
fn->source = NULL;
fn->type = gt_symbol(type);
fn->score = GT_UNDEF_FLOAT;
fn->range.start = start;
fn->range.end = end;
fn->representative = NULL;
fn->attributes = NULL;
fn->bit_field = 0;
fn->bit_field |= strand << STRAND_OFFSET;
fn->children = NULL; /* the children list is create on demand */
fn->observer = NULL;
gt_feature_node_set_phase(fn, GT_PHASE_UNDEFINED);
set_transcriptfeaturetype(fn, TRANSCRIPT_FEATURE_TYPE_UNDETERMINED);
set_tree_status(&fn->bit_field, IS_TREE);
/* the DFS status is set to DFS_WHITE already */
fn->representative = NULL;
return gn;
}
static void sequence_node_change_seqid(GtGenomeNode *gn, GtStr *seqid)
{
GtSequenceNode *sn = gt_sequence_node_cast(gn);
gt_assert(sn && seqid);
gt_str_delete(sn->description);
sn->description = gt_str_ref(seqid);
}
static void region_node_change_seqid(GtGenomeNode *gn, GtStr *seqid)
{
GtRegionNode *rn = gt_region_node_cast(gn);
gt_assert(rn && seqid);
gt_str_delete(rn->seqid);
rn->seqid = gt_str_ref(seqid);
}
GtAlphabet* gt_alphabet_clone(const GtAlphabet *alphabet)
{
unsigned int i;
GtAlphabet *newalpha;
gt_assert(alphabet);
newalpha = gt_malloc(sizeof *newalpha);
newalpha->domainsize = alphabet->domainsize;
newalpha->mapsize = alphabet->mapsize;
newalpha->mappedwildcards = alphabet->mappedwildcards;
newalpha->wildcardshow = alphabet->wildcardshow;
newalpha->bitspersymbol = alphabet->bitspersymbol;
newalpha->alphadef = gt_str_ref(alphabet->alphadef);
newalpha->reference_count = 0;
newalpha->refmutex = gt_mutex_new();
for (i=0; i<=(unsigned int) GT_MAXALPHABETCHARACTER; i++)
{
newalpha->symbolmap[i] = alphabet->symbolmap[i];
}
newalpha->characters = gt_malloc(alphabet->mapsize * sizeof (GtUchar));
for (i=0; i<newalpha->mapsize; i++)
{
newalpha->characters[i] = alphabet->characters[i];
}
newalpha->mapdomain = gt_malloc(alphabet->domainsize * sizeof (GtUchar));
for (i=0; i<newalpha->domainsize; i++)
{
newalpha->mapdomain[i] = alphabet->mapdomain[i];
}
return newalpha;
}
GtRegionMapping* gt_region_mapping_new_seqfile(GtStr *sequence_filename)
{
GtRegionMapping *rm;
gt_assert(sequence_filename);
rm = gt_calloc(1, sizeof (GtRegionMapping));
rm->sequence_filename = gt_str_ref(sequence_filename);
return rm;
}
void agn_infer_cds_visitor_set_source(AgnInferCDSVisitor *v,
GtStr *source)
{
agn_assert(v && source);
if(v->source != NULL)
gt_str_delete(v->source);
v->source = gt_str_ref(source);
}
void gt_tool_iterator_set_prefix_target(GtToolIterator *ti, GtStr *prefix,
char sep)
{
gt_assert(ti);
if (ti->prefixptr)
gt_str_delete(ti->prefixptr);
ti->prefixptr = gt_str_ref(prefix);
ti->prefixsep = sep;
}
GtGenomeNode* gt_sequence_node_new(const char *description, GtStr *sequence)
{
GtGenomeNode *gn = gt_genome_node_create(gt_sequence_node_class());
GtSequenceNode *sn = gt_sequence_node_cast(gn);
gt_assert(description && sequence);
sn->description = gt_str_new_cstr(description);
sn->sequence = gt_str_ref(sequence);
return gn;
}
void gt_feature_node_set_source(GtFeatureNode *fn, GtStr *source)
{
gt_assert(fn && source);
if (fn->source)
gt_str_delete(fn->source);
fn->source = gt_str_ref(source);
if (fn->observer && fn->observer->source_changed)
fn->observer->source_changed(fn, source, fn->observer->data);
}
GtNodeVisitor* gt_gff3_visitor_new_to_str(GtStr *outstr)
{
GtNodeVisitor *nv = gt_node_visitor_create(gt_gff3_visitor_class());
GtGFF3Visitor *gff3_visitor = gff3_visitor_cast(nv);
gt_gff3_visitor_init(gff3_visitor);
gff3_visitor->outfp = NULL;
gff3_visitor->outstr = gt_str_ref(outstr);
return nv;
}
static GtStr* region_mapping_map(GtRegionMapping *rm,
const char *sequence_region, GtError *err)
{
gt_error_check(err);
gt_assert(rm && sequence_region);
if (rm->sequence_filename)
return gt_str_ref(rm->sequence_filename);
else
return gt_mapping_map_string(rm->mapping, sequence_region, err);
}
GtXRFAbbrEntry* gt_xrf_abbr_entry_new(GtUword line,
GtStr *filename)
{
GtXRFAbbrEntry *abbr_entry = gt_malloc(sizeof *abbr_entry);
abbr_entry->content = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) gt_str_delete);
abbr_entry->line = line;
abbr_entry->filename = gt_str_ref(filename);
return abbr_entry;
}
static void add_tool_to_stack(const char *name, GtTool *tool, void *data)
{
ToolIterationInfo *ti_info = data;
ToolEntry entry;
gt_assert(name && tool && data);
entry.name = name;
entry.tool = tool;
entry.prefix = gt_str_ref(ti_info->str);
gt_array_add(ti_info->arr, entry);
}
static int construct_bioseq_files(GtBioseq *bs, GtStr *bioseq_indexname,
GtError *err)
{
GtStr *sequence_filename;
GtEncseqEncoder *ee;
GtStrArray *indexfn;
int had_err = 0;
gt_error_check(err);
/* register the signal handler to remove incomplete files upon termination */
if (!bs->use_stdin) {
gt_bioseq_index_filename = gt_str_get(bs->sequence_file);
gt_sig_register_all(remove_bioseq_files);
}
/* if stdin is used as input, we need to create a tempfile containing the
sequence as GtEncseq cannot be built from stdin directly */
if (bs->use_stdin) {
GtStr *tmpfilename;
FILE *tmpfile = NULL;
int i;
char buf[BUFSIZ];
tmpfilename = gt_str_new();
tmpfile = gt_xtmpfp(tmpfilename);
gt_assert(tmpfile);
i = 1;
while (i > 0) {
i = fread(buf, 1, BUFSIZ, stdin);
if (i > 0) fwrite(buf, 1, i, tmpfile);
}
gt_fa_xfclose(tmpfile);
sequence_filename = tmpfilename;
} else {
sequence_filename = gt_str_ref(bs->sequence_file);
}
gt_assert(gt_str_length(sequence_filename) > 0);
ee = gt_encseq_encoder_new();
gt_encseq_encoder_enable_description_support(ee);
gt_encseq_encoder_enable_md5_support(ee);
gt_encseq_encoder_enable_multiseq_support(ee);
gt_encseq_encoder_enable_lossless_support(ee);
indexfn = gt_str_array_new();
gt_str_array_add(indexfn, sequence_filename);
gt_str_delete(sequence_filename);
had_err = gt_encseq_encoder_encode(ee, indexfn,
gt_str_get(bioseq_indexname), err);
/* unregister the signal handler */
if (!bs->use_stdin)
gt_sig_unregister_all();
gt_str_array_delete(indexfn);
gt_encseq_encoder_delete(ee);
return had_err;
}
GtNodeVisitor* gt_select_visitor_new(GtStr *seqid,
GtStr *source,
const GtRange *contain_range,
const GtRange *overlap_range,
GtStrand strand, GtStrand targetstrand,
bool has_CDS,
unsigned long max_gene_length,
unsigned long max_gene_num,
double min_gene_score,
double max_gene_score,
double min_average_splice_site_prob,
unsigned long feature_num)
{
GtNodeVisitor *nv = gt_node_visitor_create(gt_select_visitor_class());
GtSelectVisitor *select_visitor = select_visitor_cast(nv);
select_visitor->node_buffer = gt_queue_new();
select_visitor->seqid = gt_str_ref(seqid);
select_visitor->source = gt_str_ref(source);
if (contain_range)
select_visitor->contain_range = *contain_range;
else {
select_visitor->contain_range.start = GT_UNDEF_ULONG;
select_visitor->contain_range.end = GT_UNDEF_ULONG;
}
if (overlap_range)
select_visitor->overlap_range = *overlap_range;
else {
select_visitor->overlap_range.start = GT_UNDEF_ULONG;
select_visitor->overlap_range.end = GT_UNDEF_ULONG;
}
select_visitor->strand = strand;
select_visitor->targetstrand = targetstrand;
select_visitor->has_CDS = has_CDS;
select_visitor->max_gene_length = max_gene_length;
select_visitor->gene_num = 0;
select_visitor->max_gene_num = max_gene_num;
select_visitor->min_gene_score = min_gene_score;
select_visitor->max_gene_score = max_gene_score;
select_visitor->min_average_splice_site_prob = min_average_splice_site_prob;
select_visitor->feature_num = feature_num;
return nv;
}
GtGenomeNode* gt_region_node_new(GtStr *seqid, unsigned long start,
unsigned long end)
{
GtGenomeNode *gn = gt_genome_node_create(gt_region_node_class());
GtRegionNode *rn = gt_region_node_cast(gn);
gt_assert(seqid);
gt_assert(start <= end);
rn->seqid = gt_str_ref(seqid);
rn->range.start = start;
rn->range.end = end;
return gn;
}
GtFastaReader* gt_fasta_reader_fsm_new(GtStr *sequence_filename)
{
GtFastaReader *fr = gt_fasta_reader_create(gt_fasta_reader_fsm_class());
GtFastaReaderFSM *gt_fasta_reader_fsm = gt_fasta_reader_fsm_cast(fr);
gt_fasta_reader_fsm->sequence_filename = gt_str_ref(sequence_filename);
if (sequence_filename) {
gt_fasta_reader_fsm->sequence_file =
gt_file_xopen(gt_str_get(sequence_filename), "r");
}
else
gt_fasta_reader_fsm->sequence_filename = gt_str_new_cstr("stdin");
return fr;
}
GtTrack* gt_track_new(GtStr *title, unsigned long max_num_lines,
bool split_lines, GtLineBreaker *lb)
{
GtTrack *track;
gt_assert(title && lb);
track = gt_calloc(1, sizeof (GtTrack));
gt_assert(track);
track->title = gt_str_ref(title);
track->lines = gt_array_new(sizeof (GtLine*));
track->max_num_lines = max_num_lines;
track->split = split_lines;
track->lb = lb;
track->y_index = GT_UNDEF_ULONG;
return track;
}
static int store_ids(GtFeatureNode *fn, void *data, GtError *err)
{
GtGFF3Visitor *gff3_visitor = (GtGFF3Visitor*) data;
AddIDInfo add_id_info;
int had_err = 0;
GtStr *id;
gt_error_check(err);
gt_assert(fn && gff3_visitor);
if (gt_feature_node_has_children(fn) || gt_feature_node_is_multi(fn) ||
(gff3_visitor->retain_ids && gt_feature_node_get_attribute(fn, "ID"))) {
if (gt_feature_node_is_multi(fn)) {
id = gt_hashmap_get(gff3_visitor->feature_node_to_unique_id_str,
gt_feature_node_get_multi_representative(fn));
if (!id) {
/* the representative does not have its own id yet -> create it */
if (gff3_visitor->retain_ids) {
id = make_id_unique(gff3_visitor,
gt_feature_node_get_multi_representative(fn));
}
else {
id = create_unique_id(gff3_visitor,
gt_feature_node_get_multi_representative(fn));
}
}
/* store id for feature, if the feature was not the representative */
if (gt_feature_node_get_multi_representative(fn) != fn) {
gt_hashmap_add(gff3_visitor->feature_node_to_unique_id_str, fn,
gt_str_ref(id));
}
}
else {
if (gff3_visitor->retain_ids)
id = make_id_unique(gff3_visitor, fn);
else
id = create_unique_id(gff3_visitor, fn);
}
/* for each child -> store the parent feature in the hash map */
add_id_info.gt_feature_node_to_id_array =
gff3_visitor->feature_node_to_id_array,
add_id_info.id = gt_str_get(id);
had_err = gt_feature_node_traverse_direct_children(fn, &add_id_info, add_id,
err);
}
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;
}
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 GtOPrval parse_options(int *parsed_args,
Cmppairwiseopt *pw,
int argc, const char **argv, GtError *err)
{
GtOptionParser *op;
GtOption *optionstrings,
*optionfiles,
*optioncharlistlen,
*optiontext,
*optionshowedist;
GtStrArray *charlistlen;
GtOPrval oprval;
gt_error_check(err);
charlistlen = gt_str_array_new();
pw->strings = gt_str_array_new();
pw->files = gt_str_array_new();
pw->text = gt_str_new();
pw->charlistlen = NULL;
pw->showedist = false;
op = gt_option_parser_new("options", "Apply function to pairs of strings.");
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
optionstrings = gt_option_new_string_array("ss", "use two strings",
pw->strings);
gt_option_parser_add_option(op, optionstrings);
optionfiles = gt_option_new_filename_array("ff", "use two files",
pw->files);
gt_option_parser_add_option(op, optionfiles);
optioncharlistlen = gt_option_new_string_array("a",
"use character list and length",
charlistlen);
gt_option_parser_add_option(op, optioncharlistlen);
optiontext = gt_option_new_string("t", "use text", pw->text, NULL);
gt_option_parser_add_option(op, optiontext);
optionshowedist = gt_option_new_bool("e", "output unit edit distance",
&pw->showedist, false);
gt_option_parser_add_option(op, optionshowedist);
gt_option_exclude(optionstrings, optionfiles);
gt_option_exclude(optionstrings, optioncharlistlen);
gt_option_exclude(optionstrings, optiontext);
gt_option_exclude(optionfiles, optioncharlistlen);
gt_option_exclude(optionfiles, optiontext);
gt_option_exclude(optioncharlistlen, optiontext);
gt_option_imply(optionshowedist, optionstrings);
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
if (oprval == GT_OPTION_PARSER_OK)
{
if (gt_option_is_set(optionstrings))
{
if (gt_str_array_size(pw->strings) != 2UL)
{
gt_error_set(err, "option -ss requires two string arguments");
oprval = GT_OPTION_PARSER_ERROR;
}
} else
{
if (gt_option_is_set(optionfiles))
{
if (gt_str_array_size(pw->files) != 2UL)
{
gt_error_set(err, "option -ff requires two filename arguments");
oprval = GT_OPTION_PARSER_ERROR;
}
} else
{
if (gt_option_is_set(optioncharlistlen))
{
GtWord readint;
if (gt_str_array_size(charlistlen) != 2UL)
{
gt_error_set(err,
"option -a requires charlist and length argument");
oprval = GT_OPTION_PARSER_ERROR;
}
pw->charlistlen = gt_malloc(sizeof *pw->charlistlen);
pw->charlistlen->charlist =
gt_str_ref(gt_str_array_get_str(charlistlen,
0));
if (sscanf(gt_str_array_get(charlistlen,1UL), GT_WD, &readint) != 1 ||
readint < 1L)
{
gt_error_set(err,
"option -a requires charlist and length argument");
oprval = GT_OPTION_PARSER_ERROR;
}
pw->charlistlen->len = (GtUword) readint;
} else
{
if (!gt_option_is_set(optiontext))
{
gt_error_set(err,
"use exactly one of the options -ss, -ff, -a, -t");
oprval = GT_OPTION_PARSER_ERROR;
}
}
}
}
}
gt_option_parser_delete(op);
if (oprval == GT_OPTION_PARSER_OK && *parsed_args != argc)
{
gt_error_set(err, "superfluous program parameters");
oprval = GT_OPTION_PARSER_ERROR;
}
gt_str_array_delete(charlistlen);
return oprval;
}
static GtIndexOptions*
gt_index_options_register_generic_output(GtOptionParser *op,
GtIndexOptions *idxo,
GtStr *indexname,
GtEncseqOptions *encopts)
{
gt_assert(idxo != NULL);
gt_assert(op != NULL && idxo->type != GT_INDEX_OPTIONS_UNDEFINED &&
encopts != NULL);
idxo->encopts = encopts;
idxo->indexname = indexname != NULL ? gt_str_ref(indexname) : NULL;
idxo->optionkys = gt_option_new_string("kys",
"output/sort according to keys of the form "
"|key| in fasta header",
idxo->kysargumentstring,
"nosort");
gt_option_argument_is_optional(idxo->optionkys);
gt_option_imply(idxo->optionkys, gt_encseq_options_sds_option(idxo->encopts));
gt_option_parser_add_option(op, idxo->optionkys);
gt_encseq_options_add_readmode_option(op, idxo->dir);
if (idxo->type == GT_INDEX_OPTIONS_ESA)
{
idxo->optionoutsuftab = gt_option_new_bool("suf",
"output suffix array (suftab) to file",
&idxo->outsuftab,
false);
gt_option_parser_add_option(op, idxo->optionoutsuftab);
idxo->optionoutlcptab = gt_option_new_bool("lcp",
"output lcp table (lcptab) to file",
&idxo->outlcptab,
false);
gt_option_parser_add_option(op, idxo->optionoutlcptab);
idxo->option = gt_option_new_bool("lcpdist",
"output distributions of values in lcptab",
&idxo->lcpdist,
false);
gt_option_is_extended_option(idxo->option);
gt_option_imply(idxo->option, idxo->optionoutlcptab);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("swallow-tail",
"swallow the tail of the suffix array and lcptab",
&idxo->swallow_tail,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->optionoutbwttab = gt_option_new_bool("bwt",
"output Burrows-Wheeler Transformation "
"(bwttab) to file",
&idxo->outbwttab,
false);
gt_option_exclude(idxo->optionspmopt, idxo->optionoutbwttab);
gt_option_parser_add_option(op, idxo->optionoutbwttab);
idxo->optionoutbcktab = gt_option_new_bool("bck",
"output bucket table to file",
&idxo->outbcktab,
false);
gt_option_parser_add_option(op, idxo->optionoutbcktab);
} else {
idxo->optionoutsuftab
= idxo->optionoutlcptab = idxo->optionoutbwttab = NULL;
idxo->sfxstrategy.spmopt_minlength = 0;
#ifndef S_SPLINT_S
gt_registerPackedIndexOptions(op,
&idxo->bwtIdxParams,
BWTDEFOPT_CONSTRUCTION,
idxo->indexname);
#endif
}
gt_option_parser_register_hook(op, gt_index_options_check_set_out_opts, idxo);
return idxo;
}
