void emboss_graph_shutdown(Tcl_Interp *interp,
seq_result *s_result,
element *e)
{
in_emboss *input = s_result->input;
seq_reg_key_name info;
static char buf[80];
/* find key name BEFORE deregister */
info.job = SEQ_KEY_NAME;
info.line = buf;
seq_result_notify(s_result->id, (seq_reg_data *)&info, 0);
seq_deregister(GetSeqNum(s_result->seq_id[HORIZONTAL]),
emboss_graph_callback, (seq_result *)s_result);
if (s_result->seq_id[VERTICAL] != -1) {
seq_deregister(GetSeqNum(s_result->seq_id[VERTICAL]),
emboss_graph_callback, (seq_result *)s_result);
}
if (e->num_results > 0) {
e->replot_func(e);
}
if (s_result->graph == SEQ_E_DOT) {
DestroySequencePairDisplay(interp, s_result->id);
}
free(input->params);
xfree(s_result->input);
xfree(s_result);
}
/*
* create a random sequence from either dna or protein input sequence
* add sequence to sequence manager
*/
int ScrambleSeq(Tcl_Interp *interp,
int seq_num)
{
char *seq1 = GetSeqSequence(seq_num);
int length = GetSeqLength(seq_num);
int seq_id = GetSeqId(seq_num);
char *seq2;
char *name;
time_t tim;
int seed;
char *parental_name, *child_name;
int new_seq_num, start, end;
static int num = 0;
if (NULL == (seq2 = (char *)xmalloc((length+1) * sizeof(char))))
return -1;
memcpy(seq2, seq1, length);
tim = time(NULL);
seed = (int) tim;
scramble_seq(seq2, length, seed);
seq2[length] = '\0';
parental_name = GetParentalSeqName(seq_num);
child_name = GetSeqName(seq_num);
if (NULL == (name = (char *)xmalloc((strlen(parental_name)+13) *
sizeof(char))))
return -1;
sprintf(name, "%s_x%d", parental_name, num);
if (-1 == (new_seq_num = AddSequence(interp, -1, GetSeqLibrary(seq_num),
name, seq2, GetSeqStructure(seq_num),
GetSeqType(seq_num), NULL , " ")))
return -1;
xfree(name);
if (strcmp(parental_name, child_name) != 0) {
/* sub-sequence */
/*
* need to get seq num from seq_id instead of using seq_num incase
* AddSequence has deleted duplicate names
*/
start = GetSubSeqStart(GetSeqNum(seq_id));
end = GetSubSeqEnd(GetSeqNum(seq_id));
if (NULL == (name = (char *)xmalloc((strlen(child_name)+13) *
sizeof(char))))
return -1;
sprintf(name, "%s_x%d", child_name, num);
if (-1 == (AddSubSequence(interp, GetSeqId(new_seq_num), start, end, name)))
return -1;
}
num++;
return 0;
}
/*
* copy range of sequence
* add new sequence name to sequence manager
*/
int CopyRange(Tcl_Interp *interp,
int seq_id,
int start,
int end)
{
int seq_num = GetSeqNum(seq_id);
char *seq1 = GetSeqSequence(seq_num);
char *seq2;
char *name;
int length = end - start + 1;
int new_seq_num;
char *parental_name, *child_name;
static int count = 1;
if (NULL == (seq2 = (char *)xmalloc((length+2) * sizeof(char))))
return -1;
strncpy(seq2, &seq1[start-1], end - start + 1);
seq2[end - start + 1] = '\0';
parental_name = GetParentalSeqName(seq_num);
child_name = GetSeqName(seq_num);
if (NULL == (name = (char *)xmalloc((strlen(parental_name)+20) *
sizeof(char))))
return -1;
sprintf(name, "%s_n%d", parental_name, count++);
if (-1 == (new_seq_num = AddSequence(interp, -1, GetSeqLibrary(seq_num),
name, seq2, GetSeqStructure(seq_num),
GetSeqType(seq_num), NULL, " ")))
return -1;
xfree(name);
/* don't think I need to deal with subsequences in copying a sequence. */
#if 0
if (strcmp(parental_name, child_name) != 0) {
/* sub-sequence */
/*
* need to get seq num from seq_id instead of using seq_num incase
* AddSequence has deleted duplicate names
*/
start = GetSubSeqStart(GetSeqNum(seq_id));
end = GetSubSeqEnd(GetSeqNum(seq_id));
if (NULL == (name = (char *)xmalloc((strlen(child_name)+3) *
sizeof(char))))
return -1;
sprintf(name, "%s_n%d", child_name, count++);
if (-1 == (AddSubSequence(interp, GetSeqId(new_seq_num),
start, end, name)))
return -1;
}
#endif
return 0;
}
/*
* complement sequence
* add new sequence name to sequence manager
*/
int ComplementSeq(Tcl_Interp *interp,
int seq_num)
{
char *seq1 = GetSeqSequence(seq_num);
char *seq2;
char *name;
int length = GetSeqLength(seq_num);
int seq_id = GetSeqId(seq_num);
int new_seq_num, start, end;
char *parental_name, *child_name;
if (NULL == (seq2 = (char *)xmalloc((length+1) * sizeof(char))))
return -1;
memcpy(seq2, seq1, length);
(void) complement_seq(seq2, length);
seq2[length] = '\0';
parental_name = GetParentalSeqName(seq_num);
child_name = GetSeqName(seq_num);
if (NULL == (name = (char *)xmalloc((strlen(parental_name)+3) *
sizeof(char))))
return -1;
sprintf(name, "%s_c", parental_name);
if (-1 == (new_seq_num = AddSequence(interp, -1, GetSeqLibrary(seq_num),
name, seq2, GetSeqStructure(seq_num),
GetSeqType(seq_num), NULL, " ")))
return -1;
xfree(name);
if (strcmp(parental_name, child_name) != 0) {
/* sub-sequence */
/*
* need to get seq num from seq_id instead of using seq_num incase
* AddSequence has deleted duplicate names
*/
start = GetSubSeqStart(GetSeqNum(seq_id));
end = GetSubSeqEnd(GetSeqNum(seq_id));
if (NULL == (name = (char *)xmalloc((strlen(child_name)+3) *
sizeof(char))))
return -1;
sprintf(name, "%s_c", child_name);
if (-1 == (AddSubSequence(interp, GetSeqId(new_seq_num),
length - end + 1,
length - start + 1, name)))
return -1;
}
return 0;
}
/*
* add new sequence to sequence manager, but keep as dna but with an extension
* of _rf123 which signifies to the comparison functions that the sequence
* is to translated into it's 3 reading frames, each of which will be used
* in the comparison routine
*/
int TranslateTogether(Tcl_Interp *interp,
int seq_num)
{
char *name;
char *dna_seq;
char *prot_seq;
int seq_id = GetSeqId(seq_num);
int new_seq_num;
char *parental_name, *child_name;
int start, end;
#ifdef DEBUG
printf("START translate together \n");
#endif
dna_seq = GetSeqSequence(seq_num);
if (NULL == (prot_seq = strdup(dna_seq)))
return -1;
parental_name = GetParentalSeqName(seq_num);
child_name = GetSeqName(seq_num);
if (NULL == (name = (char *)xmalloc((strlen(parental_name)+7) *
sizeof(char))))
return -1;
sprintf(name, "%s_rf123", parental_name);
if (-1 == (new_seq_num = AddSequence(interp, -1, GetSeqLibrary(seq_num),
name, prot_seq, LINEAR, PROTEIN, NULL, " ")))
return -1;
xfree(name);
if (strcmp(parental_name, child_name) != 0) {
/* sub-sequence */
/*
* need to get seq num from seq_id instead of using seq_num incase
* AddSequence has deleted duplicate names
*/
start = GetSubSeqStart(GetSeqNum(seq_id));
end = GetSubSeqEnd(GetSeqNum(seq_id));
if (NULL == (name = (char *)xmalloc((strlen(child_name)+7) *
sizeof(char))))
return -1;
sprintf(name, "%s_rf123", child_name);
new_seq_num = AddSubSequence(interp, GetSeqId(new_seq_num), start, end,
name);
}
return new_seq_num;
}
/**
* @ingroup SipUserAgent
* @brief text 기반 SMS 메시지를 전송한다.
* @param pszFrom 발신자 아이디
* @param pszTo 수신자 아이디
* @param pszText SMS 메시지
* @param pclsRoute SIP 메시지 목적지 주소 저장 객체
* @returns 성공하면 true 를 리턴하고 실패하면 false 를 리턴한다.
*/
bool CSipUserAgent::SendSms( const char * pszFrom, const char * pszTo, const char * pszText, CSipCallRoute * pclsRoute )
{
CSipMessage * pclsRequest = new CSipMessage();
if( pclsRequest == NULL ) return false;
pclsRequest->m_strSipMethod = SIP_METHOD_MESSAGE;
pclsRequest->m_clsReqUri.Set( SIP_PROTOCOL, pszTo, m_clsSipStack.m_clsSetup.m_strLocalIp.c_str(), m_clsSipStack.m_clsSetup.m_iLocalUdpPort );
pclsRequest->m_clsFrom.m_clsUri.Set( SIP_PROTOCOL, pszFrom, m_clsSipStack.m_clsSetup.m_strLocalIp.c_str(), m_clsSipStack.m_clsSetup.m_iLocalUdpPort );
pclsRequest->m_clsFrom.InsertTag();
pclsRequest->m_clsTo.m_clsUri.Set( SIP_PROTOCOL, pszTo, m_clsSipStack.m_clsSetup.m_strLocalIp.c_str(), m_clsSipStack.m_clsSetup.m_iLocalUdpPort );
pclsRequest->m_clsCSeq.m_iDigit = GetSeqNum();
pclsRequest->m_clsCSeq.m_strMethod = pclsRequest->m_strSipMethod;
pclsRequest->AddRoute( pclsRoute->m_strDestIp.c_str(), pclsRoute->m_iDestPort, pclsRoute->m_eTransport );
pclsRequest->m_clsCallId.Make( m_clsSipStack.m_clsSetup.m_strLocalIp.c_str() );
pclsRequest->m_clsContentType.Set( "text", "plain" );
pclsRequest->m_strBody = pszText;
pclsRequest->m_iContentLength = (int)pclsRequest->m_strBody.length();
if( m_clsSipStack.SendSipMessage( pclsRequest ) == false ) return false;
return true;
}
/*
* add new sequence range into seqs array
*/
int Set_SubSeqs(int seq_id,
int seq_num,
int start,
int end,
char *name,
Featcds **key_index,
char *identifier)
{
int num;
if (-1 == (num = GetSeqNum(seq_id)))
return -1;
seqs[seq_num].seq = seqs[num].seq;
seqs[seq_num].start = start;
seqs[seq_num].end = end;
seqs[seq_num].name = name;
seqs[seq_num].seq_id = CreateSeqid();
seqs[seq_num].key_index = key_index;
if (NULL == (seqs[seq_num].identifier = (char *)xmalloc((strlen(identifier)+1) *
sizeof(char))))
return -1;
strcpy(seqs[seq_num].identifier, identifier);
/* increment counter */
seqs[seq_num].seq->count++;
return 0;
}
int init_emboss_graph_create(Tcl_Interp *interp,
int seq_id,
int start,
int end,
char *filename,
Tcl_Obj **graph_obj,
int *id)
{
int seq_num, seq_len;
in_emboss *input;
Tcl_DString input_params;
text_emboss *text_data;
e_graph *data = NULL;
seq_num = GetSeqNum(seq_id);
seq_len = GetSeqLength(seq_num);
/* if the end has not been defined, set it to be the sequence length */
if (end == -1) {
end = seq_len;
}
seq_len = end - start + 1;
if (NULL == (input = (in_emboss *)xmalloc (sizeof(in_emboss))))
return -1;
read_emboss_data_file(filename, &data, graph_obj, &text_data);
if (!data) {
verror(ERR_FATAL,"emboss", "error in reading results\n");
return -1;
}
/* create inputs parameters */
Tcl_DStringInit(&input_params);
vTcl_DStringAppend(&input_params, "sequence %s: from %d to %d\n",
GetSeqName(seq_num), start, end);
vfuncparams("%s", Tcl_DStringValue(&input_params));
input->params = strdup(Tcl_DStringValue(&input_params));
Tcl_DStringFree(&input_params);
if (-1 == (*id = store_emboss_graph(seq_num, start, end, data, input,
text_data, graph_obj))) {
verror(ERR_FATAL,"emboss", "error in saving results\n");
return -1;
}
xfree(data);
return 0;
}
/*
* set active range for sequence
*
*/
int SetRange(Tcl_Interp *interp,
int seq_id,
int start,
int end)
{
char *name;
int seq_num;
static int count = 1;
seq_num = GetSeqNum(seq_id);
if (NULL == (name = (char *)xmalloc((strlen(GetSeqName(seq_num))+20)
* sizeof(char))))
return -1;
sprintf(name, "%s_s%d", GetSeqName(seq_num), count++);
return (AddSubSequence(interp, seq_id, start, end, name));
}
int init_sip_local_align_plot(Tcl_Interp *interp,
int seq_id_h,
int seq_id_v,
int result_id,
char *raster_win,
int raster_id,
char *colour,
int line_width)
{
char *opts[7];
seq_result *result;
d_plot *data;
if (NULL == (opts[1] = (char *)xmalloc((strlen(colour)+1) *
sizeof(char))))
return -1;
if (NULL == (opts[3] = (char *)xmalloc(5 * sizeof(char))))
return -1;
if (NULL == (opts[5] = (char *)xmalloc(15 * sizeof(char))))
return -1;
opts[0] = "-fg";
strcpy(opts[1], colour);
opts[2] = "-linewidth";
sprintf(opts[3], "%d", line_width);
opts[4] = "-capstyle";
strcpy(opts[5], "round");
opts[6] = NULL;
result = result_data(result_id, GetSeqNum(seq_id_h));
data = result->data;
init_dot_plot(interp, seq_id_h, seq_id_v, result_id, "local", raster_win,
raster_id, opts, 6, LINE, data->dim);
xfree(opts[1]);
xfree(opts[3]);
xfree(opts[5]);
return 0;
}
void
splice_search_text_func(void *obj)
{
seq_result *result = (seq_result *) obj;
stick *data = result->data;
text_wtmatrix **text_data = result->text_data;
int i;
char *sequence;
int seq_num;
seq_num = GetSeqNum(result->seq_id[0]);
sequence = GetSeqSequence(seq_num);
vmessage("Donor\n");
for (i = 0; i < data->ap_array[0].n_pts; i++) {
UpdateTextOutput();
vmessage("Position %8d %8d score %f %.*s\n",
data->ap_array[0].p_array[i].pos - text_data[0]->mark_pos,
data->ap_array[0].p_array[i].pos + 1,
data->ap_array[0].p_array[i].score,
text_data[0]->length,
&sequence[data->ap_array[0].p_array[i].pos - 1 -
text_data[0]->mark_pos]);
}
vmessage("Acceptor\n");
for (i = 0; i < data->ap_array[1].n_pts; i++) {
UpdateTextOutput();
vmessage("Position %8d %8d score %f %.*s\n",
data->ap_array[1].p_array[i].pos - text_data[1]->mark_pos,
data->ap_array[1].p_array[i].pos + 1,
data->ap_array[1].p_array[i].score,
text_data[1]->length,
&sequence[data->ap_array[1].p_array[i].pos - 1 -
text_data[1]->mark_pos]);
}
}
int init_sip_similar_spans_plot(Tcl_Interp *interp,
int seq_id_h,
int seq_id_v,
int result_id,
char *raster_win,
int raster_id,
char *colour,
int line_width)
{
char *opts[5];
seq_result *result;
d_plot *data;
if (NULL == (opts[1] = (char *)xmalloc((strlen(colour)+1) *
sizeof(char))))
return -1;
if (NULL == (opts[3] = (char *)xmalloc(5 * sizeof(char))))
return -1;
opts[0] = "-fg";
strcpy(opts[1], colour);
opts[2] = "-linewidth";
sprintf(opts[3], "%d", line_width);
opts[4] = NULL;
result = result_data(result_id, GetSeqNum(seq_id_h));
data = result->data;
init_dot_plot(interp, seq_id_h, seq_id_v, result_id, "similar spans",
raster_win, raster_id, opts, 4, DOT, data->dim);
xfree(opts[1]);
xfree(opts[3]);
return 0;
}
void
nip_string_search_text_func(void *obj)
{
int i;
int string_length;
char *seq_match;
seq_result *result = (seq_result *) obj;
in_string_search *input = result->input;
stick *data = result->data;
char *seq_name;
int num_matches = data->ap_array[0].n_pts;
char *sequence;
int seq_num;
int pos;
double score;
seq_num = GetSeqNum(result->seq_id[0]);
seq_name = GetSeqName(seq_num);
sequence = GetSeqSequence(seq_num);
string_length = strlen(input->string);
if (NULL == (seq_match = (char *)xcalloc((string_length + 1),
sizeof(char))))
return;
for (i = 0; i < num_matches; i++) {
pos = data->ap_array[0].p_array[i].pos;
score = data->ap_array[0].p_array[i].score;
vmessage("Position %d score %f", pos, score);
strncpy(seq_match, &sequence[pos-1], string_length);
iubc_list_alignment(input->string, seq_match, "string", seq_name, 1,
pos, "");
}
xfree(seq_match);
}
void similar_spans_text_func(void *obj)
{
seq_result *result = (seq_result *) obj;
d_plot *data = result->data;
int n_pts = data->n_pts;
int i;
char *seq1, *seq2;
int seq1_len, seq2_len;
int max_str;
char *r_seq1, *r_seq2;
int r;
int num_spaces;
int seq_num_h, seq_num_v;
int seq1_type;
seq_num_h = GetSeqNum(result->seq_id[HORIZONTAL]);
seq_num_v = GetSeqNum(result->seq_id[VERTICAL]);
seq1 = GetSeqSequence(seq_num_h);
seq1_len = GetSeqLength(seq_num_h);
seq2 = GetSeqSequence(seq_num_v);
seq2_len = GetSeqLength(seq_num_v);
if (seq1_len > seq2_len)
max_str = seq1_len;
else
max_str = seq2_len;
if (seq1_len >= data->win_len) {
if (NULL == (r_seq1 = (char *)xmalloc(seq1_len + 1)))
return;
} else {
if (NULL == (r_seq1 = (char *)xmalloc(data->win_len + 1)))
return;
}
if (seq2_len >= data->win_len) {
if (NULL == (r_seq2 = (char *)xmalloc(seq2_len + 1)))
return;
} else {
if (NULL == (r_seq2 = (char *)xmalloc(data->win_len + 1)))
return;
}
for (i = 0; i < n_pts; i++) {
UpdateTextOutput();
vmessage("Positions %10d h %10d v and score %10d\n",
data->p_array[i].x, (int)data->p_array[i].y,
data->p_array[i].score);
if (data->p_array[i].x <= 0) {
num_spaces = abs(data->p_array[i].x) + 1;
memset(r_seq1, ' ', num_spaces);
r_seq1[num_spaces] = '\0';
strncat(r_seq1, seq1, data->win_len - num_spaces);
}
if (data->p_array[i].y <= 0) {
num_spaces = abs(data->p_array[i].y) + 1;
memset(r_seq2, ' ', num_spaces);
r_seq2[num_spaces] = '\0';
strncat(r_seq2, seq2, data->win_len - num_spaces);
}
if (data->p_array[i].x > 0) {
strncpy(r_seq1, &seq1[data->p_array[i].x-1], data->win_len);
}
if (data->p_array[i].y > 0) {
strncpy(r_seq2, &seq2[(int)data->p_array[i].y-1], data->win_len);
}
r_seq1[data->win_len] = '\0';
r_seq2[data->win_len] = '\0';
/*yy*/
seq1_type = GetSeqType(seq_num_h);
r = spin_list_alignment(r_seq1, r_seq2, "H", "V", data->p_array[i].x,
data->p_array[i].y, "", seq1_type);
#ifdef DEBUG
printf("i %d \n%s\n%s\n", i, r_seq1, r_seq2);
#endif
r_seq1[0] = '\0';
r_seq2[0] = '\0';
}
xfree(r_seq1);
xfree(r_seq2);
}
void similar_spans_callback(int seq_num, void *obj, seq_reg_data *jdata)
{
seq_result *result = (seq_result *) obj;
in_comp_spans *input = result->input;
out_raster *output = result->output;
d_plot *data = result->data;
text_sim_spans *text = result->text_data;
int id = result->id;
char cmd[1024];
switch(jdata->job) {
case SEQ_QUERY_NAME:
sprintf(jdata->name.line, "Find similar spans");
break;
case SEQ_KEY_NAME:
sprintf(jdata->name.line, "similar spans #%d", result->id);
break;
case SEQ_GET_BRIEF:
sprintf(jdata->name.line, "similar spans: hori=%s vert=%s",
GetSeqBaseName(GetSeqNum(result->seq_id[HORIZONTAL])),
GetSeqBaseName(GetSeqNum(result->seq_id[VERTICAL])));
break;
case SEQ_GET_OPS:
if (output->hidden) {
jdata->get_ops.ops = "Information\0List results\0Tabulate scores\0PLACEHOLDER\0PLACEHOLDER\0"
"PLACEHOLDER\0PLACEHOLDER\0Reveal\0SEPARATOR\0Remove\0";
} else {
jdata->get_ops.ops = "Information\0List results\0Tabulate scores\0Rescan matches\0Configure\0"
"Display sequences\0Hide\0PLACEHOLDER\0SEPARATOR\0Remove\0";
}
break;
case SEQ_INVOKE_OP:
switch (jdata->invoke_op.op) {
case 0: /* information */
vfuncheader("input parameters");
vmessage("%s\n", input->params);
break;
case 1: /* results */
Tcl_Eval(output->interp, "SetBusy");
vfuncheader("results");
result->txt_func(result);
Tcl_Eval(output->interp, "ClearBusy");
break;
case 2: /* scores */
Tcl_Eval(output->interp, "SetBusy");
vfuncheader("scores");
CalcProbs(result, data->win_len, text->min_score);
Tcl_Eval(output->interp, "ClearBusy");
break;
case 3: /* rescan matches */
{
Tcl_Eval(output->interp, "sip_rescan_matches");
Tcl_Eval(output->interp, "SetBusy");
SipRescanMatches(output->interp, result, id, atoi(output->interp->result));
Tcl_Eval(output->interp, "ClearBusy");
break;
}
case 4: /* configure */
sprintf(cmd, "RasterConfig %d", id);
if (TCL_OK != Tcl_Eval(output->interp, cmd)){
puts(output->interp->result);
}
break;
case 5: /* display sequences */
SequencePairDisplay(output->interp, output->raster_win, id,
result->seq_id[HORIZONTAL],
result->seq_id[VERTICAL]);
break;
case 6: /* hide all */
output->hidden = 1;
ReplotAllCurrentZoom(output->interp, output->raster_win);
break;
case 7: /* reveal all */
output->hidden = 0;
ReplotAllCurrentZoom(output->interp, output->raster_win);
break;
case 8: /* remove */
{
Tcl_Interp *interp = output->interp;
similar_spans_shutdown(interp, result, output->raster_win,
seq_num, id);
break;
}
}
break;
case SEQ_PLOT:
result->pr_func(result, NULL);
break;
case SEQ_RESULT_INFO:
switch (jdata->info.op) {
case OUTPUT:
jdata->info.result = (void *)output;
break;
case INPUT:
jdata->info.result = (void *)input;
break;
case DIMENSIONS:
jdata->info.result = (void *)&data->dim;
break;
case INDEX:
jdata->info.result = (void *)id;
break;
case RESULT:
jdata->info.result = (void *)result;
break;
case WIN_NAME:
{
char *r_win = output->raster_win;
jdata->info.result = (void *)r_win;
break;
}
case WIN_SIZE:
{
static d_point pt;
Tcl_Interp *interp = output->interp;
pt.x = get_default_int(interp, sip_defs,
w("RASTER.PLOT_WIDTH"));
pt.y = get_default_double(interp, sip_defs,
w("RASTER.PLOT_HEIGHT"));
jdata->info.result = (void *)&pt;
break;
} /* WIN_SIZE */
}
break;
case SEQ_HIDE:
output->hidden = 1;
break;
case SEQ_REVEAL:
output->hidden = 0;
break;
case SEQ_QUIT:
case SEQ_DELETE:
{
Tcl_Interp *interp = output->interp;
similar_spans_shutdown(interp, result, output->raster_win,
seq_num, id);
break;
}
}
}
void similar_spans_shutdown(Tcl_Interp *interp,
seq_result *result,
char *raster_win,
int seq_num,
int id)
{
char *tmp;
seq_reg_key_name info;
static char buf[80];
int raster_id;
double wx0, wy0, wx1, wy1;
Tk_Raster *raster;
Tcl_CmdInfo info1;
RasterResult *raster_result;
in_comp_spans *input = result->input;
/* determine raster_id and raster_result structure */
Tcl_VarEval(interp, "GetRasterId ", raster_win, NULL);
raster_id = atoi(interp->result);
raster_result = raster_id_to_result(raster_id);
/* find key name BEFORE deregister */
info.job = SEQ_KEY_NAME;
info.line = buf;
seq_result_notify(result->id, (seq_reg_data *)&info, 0);
/* deregister horizontal sequence */
seq_deregister(GetSeqNum(result->seq_id[HORIZONTAL]),
similar_spans_callback, (seq_result *)result);
/* deregister vertical sequence */
seq_deregister(GetSeqNum(result->seq_id[VERTICAL]),
similar_spans_callback, (seq_result *)result);
/*
* only bother replotting the raster if there are still results in the
* raster
*/
if (raster_result && raster_result->num_results > 1) {
tmp = get_default_string(interp, tk_utils_defs, w("RASTER.RESULTS.WIN"));
ReplotAllCurrentZoom(interp, raster_win);
Tcl_VarEval(interp, "GetRasterId ", raster_win, NULL);
raster_id = atoi(interp->result);
if (TCL_OK != Tcl_VarEval(interp, "RemoveRasterResultKey ", raster_win,
" {", info.line, "}", NULL))
verror(ERR_WARN, "similar spans_shutdown1", "%s \n",
interp->result);
/* find original y before reset size */
Tcl_GetCommandInfo(interp, raster_win, &info1);
raster = (Tk_Raster*)info1.clientData;
RasterGetWorldScroll(raster, &wx0, &wy0, &wx1, &wy1);
/* update the scale of the remaining results in the raster window */
SeqReSetRasterWindowSize(interp, raster_win, result->graph);
ReSetRasterWindowWorld(interp, raster_win, wy1, result->graph);
ReplotAllRasterWindow(interp, raster_win);
if (TCL_OK != Tcl_VarEval(interp, "seq_result_list_update ", tmp, NULL)){
verror(ERR_WARN, "similar_spans_shutdown2", "%s\n", interp->result);
}
}
DestroySequencePairDisplay(interp, id);
free(input->params);
xfree(result->text_data);
SipFreeResult(result);
if (raster_result)
DeleteResultFromRaster(raster_result);
}
void sip_rescan_matches(Tcl_Interp *interp,
seq_result *s_result,
int id,
int min_score)
{
int i, j;
double coords[2];
int index;
char *seq1, *seq2;
int seq1_len, seq2_len;
int score;
int start;
int x, y;
int index1, index2;
double wx0, wy0, wx1, wy1;
Tcl_Obj *graph_obj = (Tcl_Obj *) s_result->data;
element *e = s_result->e;
int result_id = s_result->id;
in_sim_spans *input = s_result->input;
double invert_y;
char cmd[1024];
plot_data *result;
Graph *graph;
double m, c, pos;
d_box bbox;
result = find_plot_data(e, result_id);
graph = Tcl_GetGraphFromObj(graph_obj);
if (result->hidden) {
return;
}
index1 = GetSeqNum(s_result->seq_id[HORIZONTAL]);
index2 = GetSeqNum(s_result->seq_id[VERTICAL]);
/* if either index is -1; the corresponding seq must have been deleted */
if ((index1 == -1) || (index2 == -1)) {
return;
}
seq1 = GetSeqSequence(index1);
seq2 = GetSeqSequence(index2);
seq1_len = GetSeqLength(index1);
seq2_len = GetSeqLength(index2);
#if 0
Tcl_GetCommandInfo(interp, output->raster_win, &info);
raster = (Tk_Raster*)info.clientData;
opts[0] = "-fg";
opts[1] = "purple";
opts[2] = NULL;
index = CreateDrawEnviron(interp, raster, 2, opts);
SetDrawEnviron(output->interp, raster, index);
RasterGetWorldScroll(raster, &wx0, &wy0, &wx1, &wy1);
#endif
start = (int)(input->win_length / 2);
/* printing */
for (i = 0; i < graph->p_arrays[0].n_pts; i++) {
x = graph->p_arrays[0].p_array[i].x - start;
y = graph->p_arrays[0].p_array[i].y - start;
for (j = 0; j < input->win_length; j++, x++, y++) {
if ((x < 1) || (y < 1) || (x > seq1_len) || (y > seq2_len)) {
continue;
}
score = score_matrix[char_lookup[seq1[x - 1]]]
[char_lookup[seq2[y - 1]]];
if (score >= min_score) {
/* printf("j %d x %d y %d score %d \n", j, x, y, score); */
printf("x %d y %d %d %d\n", x, y, score, min_score);
/*
coords[0] = x;
coords[1] = (int)wy1 - y + wy0;
*/
invert_y = graph->dim.y1 - y + graph->dim.y0;
sprintf(cmd, "%s create line %d %f %d %f -fill purple -width %d -tag rescan", e->win, x, invert_y,
x+1, invert_y+1, result->line_width);
if (TCL_ERROR == Tcl_Eval(interp, cmd))
printf("ERROR %s\n", interp->result);
/* RasterDrawPoints(raster, coords, 1); */
}
}
}
/* tk_RasterRefresh(raster); */
printf("dim %f %f\n", graph->dim.y1, graph->dim.y0);
sprintf(cmd, "%s create line %d %f %d %f -fill pink -width 10 -tag rescan", e->win, 500, graph->dim.y1 - 500+ graph->dim.y0, 500, graph->dim.y1 - 500+ graph->dim.y0);
Tcl_Eval(interp, cmd);
bbox = scale_box(e);
/* use the data min and max so all graphs are to their own scale */
if (e->orientation & HORIZONTAL) {
m = (e->world->visible->y2 - e->world->visible->y1) /
(e->world->total->y2 - e->world->total->y1);
c = e->world->visible->y2 - (m * e->world->total->y2);
bbox.y1 = m * graph->dim.y0 + c;
bbox.y2 = m * graph->dim.y1 + c;
}
if (e->orientation & VERTICAL) {
m = (e->world->visible->x2 - e->world->visible->x1) /
(e->world->total->x2 - e->world->total->x1);
c = e->world->visible->x2 - (m * e->world->total->x2);
/* note that graph->dim never changes orientation */
if (!(e->orientation & HORIZONTAL)) {
/* vertical only */
bbox.x1 = m * graph->dim.y0 + c;
bbox.x2 = m * graph->dim.y1 + c;
} else {
/* dot plot */
bbox.x1 = m * graph->dim.x0 + c;
bbox.x2 = m * graph->dim.x1 + c;
}
}
{
double x_origin, y_origin;
double sf_x, sf_y;
int p_x1, p_y1, p_x2, p_y2;
int i;
double w_x1, w_x2, w_y1, w_y2;
/* initialise world coords */
w_x1 = bbox.x1;
w_x2 = bbox.x2;
w_y1 = bbox.y1;
w_y2 = bbox.y2;
p_x1 = e->pixel->x;
p_x2 = e->pixel->x + e->pixel->width;
p_y1 = (double)e->pixel->y;
p_y2 = (double)e->pixel->y + e->pixel->height;
if (e->orientation & HORIZONTAL) {
p_x1 = e->c->column[e->column_index]->pixel->x;
p_x2 = e->c->column[e->column_index]->pixel->x + e->c->column[e->column_index]->pixel->width;
}
if (e->orientation & VERTICAL) {
p_y1 = e->c->row[e->row_index]->pixel->y;
p_y2 = e->c->row[e->row_index]->pixel->y + e->c->row[e->row_index]->pixel->height;
}
x_origin = calc_zoom_origin(w_x1, p_x1, w_x2, p_x2);
sf_x = calc_zoom_sf((double)p_x1, w_x1, p_x2, w_x2);
y_origin = calc_zoom_origin(w_y1, p_y1, w_y2, p_y2);
sf_y = calc_zoom_sf(p_y1, w_y1, p_y2, w_y2);
sprintf(cmd, "%s scale rescan %f %f %f %f \n",
e->win, x_origin, y_origin, sf_x, sf_y);
printf("scale %s\n", cmd);
Tcl_Eval(interp, cmd);
}
/*
e->scrollregion_func(interp, e, e->world->total,
e->c->column[e->column_index]->pixel,
e->c->row[e->row_index]->pixel);
*/
}
int init_sip_local_align_create(Tcl_Interp *interp,
int seq_id_h,
int seq_id_v,
int start_h,
int end_h,
int start_v,
int end_v,
int num_align,
float score_align,
float match,
float transition,
float transversion,
float start_gap,
float cont_gap,
int *id)
{
char *seq1, *seq2;
int seq1_len, seq2_len;
int r_len1, r_len2;
char *r_seq1, *r_seq2;
char *name1, *name2;
int i;
int seq1_type, seq2_type;
int seq1_num;
int seq2_num;
in_sim *input;
align_int **res;
long *start1, *start2, *end1, *end2;
int cnt = 0;
int max_align;
Tcl_DString input_params;
int num_elements;
d_plot *data;
#define NUM_SCORES 100
vfuncheader("local alignment");
if (-1 == (seq1_num = GetSeqNum(seq_id_h))) {
verror(ERR_WARN, "local alignment",
"horizontal sequence undefined");
goto error;
}
if (-1 == (seq2_num = GetSeqNum(seq_id_v))) {
verror(ERR_WARN, "local alignment",
"vertical sequence undefined");
goto error;
}
/* only align dna or protein */
seq1_type = GetSeqType(seq1_num);
seq2_type = GetSeqType(seq2_num);
if (seq1_type != seq2_type) {
verror(ERR_FATAL, "sim alignment", "sequences must both be either DNA or protein");
goto error;
}
seq1 = GetSeqSequence(seq1_num);
if ((seq1_len = end_h - start_h + 1) < 1) {
verror(ERR_WARN, "align sequences", "negative length");
goto error;
}
seq2 = GetSeqSequence(seq2_num);
if ((seq2_len = end_v - start_v + 1) < 1) {
verror(ERR_WARN, "align sequences", "negative length");
goto error;
}
if (NULL == (input = (in_sim *)xmalloc(sizeof(in_sim))))
goto error;
Tcl_DStringInit(&input_params);
vTcl_DStringAppend(&input_params, "horizontal %s: %s from %d to %d\n"
"vertical %s: %s from %d to %d\n",
GetSeqLibraryName(seq1_num),
GetSeqName(seq1_num),
start_h, end_h,
GetSeqLibraryName(seq2_num),
GetSeqName(seq2_num),
start_v, end_v);
if (score_align == -1) {
vTcl_DStringAppend(&input_params, "number of alignments %d \n",
num_align);
} else {
vTcl_DStringAppend(&input_params, "alignments above score %g\n",
score_align);
}
if (GetSeqType(seq1_num) == DNA) {
vTcl_DStringAppend(&input_params, "score for match %g\n"
"score for transition %g\n"
"score for transversion %g\n",
match, transition, transversion);
}
vTcl_DStringAppend(&input_params, "penalty for starting gap %g\n"
"penalty for each residue in gap %g\n",
start_gap, cont_gap);
vfuncparams("%s", Tcl_DStringValue(&input_params));
input->params = strdup(Tcl_DStringValue(&input_params));
Tcl_DStringFree(&input_params);
if (NULL == (r_seq1 = (char *)xcalloc(((seq1_len+seq2_len)*2+1),
sizeof(char)))) {
goto error;
}
if (NULL == (r_seq2 = (char *)xcalloc(((seq1_len+seq2_len)*2+1),
sizeof(char)))) {
goto error;
}
if (score_align != -1) {
num_align = NUM_SCORES;
}
max_align = num_align;
if (NULL == (start1 = (long *)xmalloc(max_align * sizeof(long)))) {
goto error;
}
if (NULL == (start2 = (long *)xmalloc(max_align * sizeof(long)))) {
goto error;
}
if (NULL == (end1 = (long *)xmalloc(max_align * sizeof(long)))) {
goto error;
}
if (NULL == (end2 = (long *)xmalloc(max_align * sizeof(long)))) {
goto error;
}
if (NULL == (res = (align_int **)xmalloc(max_align *sizeof(align_int*)))) {
goto error;
}
for (i = 0; i < max_align; i++) {
if (NULL == (res[i] = (align_int *)xcalloc((seq1_len+seq2_len+1),
sizeof(align_int)))) {
goto error;
}
}
/*
* if finding all alignments above a certain score, the return value of
* num_align is the number of alignments found
*/
sim_align(&seq1[start_h-1], &seq2[start_v-1], seq1_len,
seq2_len, seq1_type, &num_align, score_align,
match, transition, transversion, start_gap, cont_gap, res,
start1, start2, end1, end2);
if (num_align <= 0) {
verror(ERR_WARN, "local alignment", "no matches found\n");
goto error;
}
name1 = GetSeqBaseName(seq1_num);
name2 = GetSeqBaseName(seq2_num);
num_elements = (seq1_len + seq2_len + 1) * num_align;
if (NULL == (data = (d_plot *)xmalloc(sizeof(d_plot))))
goto error;
if (NULL == (data->p_array = (pt_score *)xmalloc(sizeof(pt_score) *
num_elements)))
goto error;
for (i = 0; i < num_align; i++) {
store_sim1(&seq1[start_h+start1[i]-2],
&seq2[start_v+start2[i]-2], seq1_len,
seq2_len, end1[i]-start1[i]+1, end2[i]-start2[i]+1,
res[i], start_h+start1[i]-1, start_v+start2[i]-1,
data->p_array, &cnt);
cexpand(&seq1[start_h+start1[i]-2],
&seq2[start_v+start2[i]-2], end1[i]-start1[i]+1,
end2[i]-start2[i]+1, r_seq1, r_seq2, &r_len1, &r_len2,
ALIGN_J_SSH | ALIGN_J_PADS, res[i]);
spin_list_alignment(r_seq1, r_seq2, name1, name2, start_h+start1[i]-1,
start_v+start2[i]-1, "", seq1_type);
}
*id = store_sim2(seq1_num, seq2_num, start_h, end_h, start_v, end_v,
input, data, cnt);
xfree(r_seq1);
xfree(r_seq2);
xfree(start1);
xfree(start2);
xfree(end1);
xfree(end2);
for (i = 0; i < max_align; i++) {
xfree(res[i]);
}
xfree(res);
return 0;
error:
return -1;
}
void nip_string_search_callback(int seq_num, void *obj, seq_reg_data *jdata)
{
seq_result *result = (seq_result *) obj;
in_string_search *input = result->input;
out_raster *output = result->output;
stick *data = result->data;
int id = result->id;
char cmd[1024];
switch(jdata->job) {
case SEQ_QUERY_NAME:
sprintf(jdata->name.line, "string search");
break;
case SEQ_KEY_NAME:
sprintf(jdata->name.line, "string #%d", result->id);
break;
case SEQ_GET_BRIEF:
sprintf(jdata->name.line, "string: seq=%s",
GetSeqName(GetSeqNum(result->seq_id[0])));
break;
case SEQ_GET_OPS:
if (output->hidden) {
jdata->get_ops.ops = "Information\0List results\0"
"PLACEHOLDER\0PLACEHOLDER\0Reveal\0SEPARATOR\0Remove\0";
} else {
jdata->get_ops.ops = "Information\0List results\0Configure\0"
"Hide\0PLACEHOLDER\0SEPARATOR\0Remove\0";
}
break;
case SEQ_INVOKE_OP:
switch (jdata->invoke_op.op) {
case 0: /* information */
{
vfuncheader("input parameters");
vmessage("%s\n", input->params);
break;
}
case 1: /* results */
Tcl_Eval(output->interp, "SetBusy");
vfuncheader("results");
result->txt_func(result);
Tcl_Eval(output->interp, "ClearBusy");
break;
case 2: /* configure */
sprintf(cmd, "RasterConfig %d", id);
if (TCL_OK != Tcl_Eval(output->interp, cmd)){
puts(Tcl_GetStringResult(output->interp));
}
break;
case 3: /* hide all */
output->hidden = 1;
ReplotAllCurrentZoom(output->interp, output->raster_win);
break;
case 4: /* reveal all */
output->hidden = 0;
ReplotAllCurrentZoom(output->interp, output->raster_win);
break;
case 5: /* remove */
{
Tcl_Interp *interp = output->interp;
nip_string_search_shutdown(interp, result,
output->raster_win, seq_num);
break;
}
}
break;
case SEQ_PLOT:
result->pr_func(result, (seq_reg_plot *)jdata);
break;
case SEQ_RESULT_INFO:
switch (jdata->info.op)
{
case OUTPUT:
jdata->info.result = (void *)output;
break;
case INPUT:
jdata->info.result = (void *)input;
break;
case DIMENSIONS:
jdata->info.result = (void *)&data->ap_array[0].dim;
break;
case INDEX:
jdata->info.result = (void *)id;
break;
case RESULT:
jdata->info.result = (void *)result;
break;
case WIN_NAME:
{
char *r_win = output->raster_win;
jdata->info.result = (void *)r_win;
break;
}
case WIN_SIZE:
{
static d_point pt;
Tcl_Interp *interp = output->interp;
pt.x = get_default_int(interp, nip_defs,
w("RASTER.PLOT_WIDTH"));
pt.y = get_default_double(interp, nip_defs,
w("NIP.STRING_SEARCH.PLOT_HEIGHT"));
jdata->info.result = (void *)&pt;
break;
}
}
break;
case SEQ_HIDE:
output->hidden = 1;
break;
case SEQ_REVEAL:
output->hidden = 0;
break;
case SEQ_QUIT:
case SEQ_DELETE: {
Tcl_Interp *interp = output->interp;
nip_string_search_shutdown(interp, result, output->raster_win,
seq_num);
break;
}
}
}
int init_nip_string_search_create(char *strand_sym,
float match,
char *string,
int use_iub_code,
int start,
int end,
int seq_id,
int *id)
{
in_string_search *input;
char *seq;
int seq_len;
int seq_num;
int string_length;
int max_matches, min_match;
int n_matches;
int *pos;
int *score;
Tcl_DString input_params;
char strand[8];
vfuncheader("string search");
if (NULL == (input = (in_string_search *)xmalloc
(sizeof(in_string_search))))
return -1;
seq_num = GetSeqNum(seq_id);
seq = GetSeqSequence(seq_num);
seq_len = GetSeqLength(seq_num);
/* if the end has not been defined, set it to be the sequence length */
if (end == -1) {
end = seq_len;
}
seq_len = end - start + 1;
max_matches = seq_len;
string_length = strlen(string);
if (NULL == (pos = (int *)xmalloc((max_matches + 1) * sizeof(int))))
return -1;
if (NULL == (score = (int *)xmalloc((max_matches + 1) * sizeof(int))))
return -1;
/* convert percentage mis-matches into min matches */
min_match = (int) (ceil(string_length * match / 100));
/* complement */
if (strcmp(strand_sym, "-") == 0) {
complement_seq(string, string_length);
}
#ifdef DEBUG
printf("min_match %d match %f string %d\n", min_match, match, string_length);
#endif
n_matches = iubc_inexact_match(&seq[start-1], seq_len, string,
string_length, min_match, use_iub_code,
pos, score, max_matches);
if (n_matches <= 0) {
vmessage("String search: no matches found\n");
xfree(input);
xfree(pos);
xfree(score);
return -1;
}
input->string = strdup(string);
/* create inputs parameters */
Tcl_DStringInit(&input_params);
if (strcmp(strand_sym, "+") == 0) {
strcpy(strand, "forward");
} else {
strcpy(strand, "reverse");
}
{
char tmp[10];
if (use_iub_code)
strcpy(tmp, "iub");
else
strcpy(tmp, "literal");
vTcl_DStringAppend(&input_params, "sequence %s: from %d to %d\n"
"strand %s\nuse %s code\nminimum percent match %f\nstring %s\n",
GetSeqName(seq_num), start, end,
strand, tmp, match, string);
}
vfuncparams("%s", Tcl_DStringValue(&input_params));
input->params = strdup(Tcl_DStringValue(&input_params));
Tcl_DStringFree(&input_params);
if (-1 == (*id = store_string_search(seq_num, input, start, end, pos,
score, n_matches, string_length))){
verror(ERR_FATAL,"string search", "error in saving matches\n");
return -1;
}
xfree(pos);
xfree(score);
return 0;
}
int init_emboss_dot_create(Tcl_Interp *interp,
int seq_id_h,
int start_h,
int end_h,
int seq_id_v,
int start_v,
int end_v,
char *filename,
Tcl_Obj **graph_obj,
int *id)
{
int seq_num_h, seq_len_h, seq_num_v, seq_len_v;
in_emboss *input;
Tcl_DString input_params;
int *seq1_match = NULL;
int *seq2_match = NULL;
int *len_match = NULL;
e_graph *data = NULL;
text_emboss *text_data;
seq_num_h = GetSeqNum(seq_id_h);
seq_num_v = GetSeqNum(seq_id_v);
seq_len_h = GetSeqLength(seq_num_h);
seq_len_v = GetSeqLength(seq_num_v);
/* if the end has not been defined, set it to be the sequence length */
if (end_h == -1)
end_h = seq_len_h;
if (end_v == -1)
end_v = seq_len_v;
seq_len_h = end_h - start_h + 1;
seq_len_v = end_v - start_v + 1;
read_emboss_data_file(filename, &data, graph_obj, &text_data);
if (!data) {
verror(ERR_FATAL,"emboss", "error in reading results\n");
return -1;
}
if (NULL == (seq1_match = (int *)xmalloc((data->n_data_obj+1) * sizeof(int))))
return -1;
if (NULL == (seq2_match = (int *)xmalloc((data->n_data_obj+1) * sizeof(int))))
return -1;
if (NULL == (len_match = (int *)xmalloc((data->n_data_obj+1) * sizeof(int))))
return -1;
if (NULL == (input = (in_emboss *)xmalloc (sizeof(in_emboss))))
return -1;
/* create inputs parameters */
Tcl_DStringInit(&input_params);
vTcl_DStringAppend(&input_params, "sequence %s: from %d to %d\nsequence %s: from %d to %d\n",
GetSeqName(seq_num_h), start_h, end_h,
GetSeqName(seq_num_v), start_v, end_v);
vfuncparams("%s", Tcl_DStringValue(&input_params));
input->params = strdup(Tcl_DStringValue(&input_params));
Tcl_DStringFree(&input_params);
if (-1 == (*id = store_emboss_dot(seq_num_h, start_h, end_h,
seq_num_v, start_v, end_v,
data, input, text_data, graph_obj))) {
verror(ERR_FATAL,"emboss", "error in saving results\n");
return -1;
}
xfree(seq1_match);
xfree(seq2_match);
xfree(len_match);
xfree(data);
return 0;
}
int init_sip_similar_spans_create(Tcl_Interp *interp,
int seq_id_h,
int seq_id_v,
int start_h,
int end_h,
int start_v,
int end_v,
int win_len,
int min_match,
int *id)
{
in_comp_spans *input = NULL;
int *seq1_match = NULL;
int *seq2_match = NULL;
int *match_score = NULL;
int n_matches;
char *seq1, *seq2;
int seq1_len, seq2_len;
int same_seq;
int max_matches = get_max_matches();
int seq1_num, seq2_num;
int seq1_type, seq2_type;
int sub1_len, sub2_len;
Tcl_DString input_params;
vfuncheader("find similar spans");
if (NULL == (seq1_match = (int *)xmalloc(max_matches * sizeof(int))))
goto error;
if (NULL == (seq2_match = (int *)xmalloc(max_matches * sizeof(int))))
goto error;
if (NULL == (match_score = (int *)xmalloc(max_matches * sizeof(int))))
goto error;
if (NULL == (input = (in_comp_spans *)xmalloc(sizeof(in_comp_spans))))
goto error;
/* get first and second sequence saved using extract_sequence */
seq1_num = GetSeqNum(seq_id_h);
seq2_num = GetSeqNum(seq_id_v);
if (seq1_num == -1) {
verror(ERR_WARN, "find similar spans", "horizontal sequence undefined");
goto error;
} else if (seq2_num == -1) {
verror(ERR_WARN, "find similar spans", "vertical sequence undefined");
goto error;
}
seq1 = GetSeqSequence(seq1_num);
seq2 = GetSeqSequence(seq2_num);
seq1_len = GetSeqLength(seq1_num);
seq2_len = GetSeqLength(seq2_num);
seq1_type = GetSeqType(seq1_num);
seq2_type = GetSeqType(seq2_num);
if (end_h == -1)
end_h = seq1_len;
if (end_v == -1)
end_v = seq2_len;
if (seq1_type != seq2_type) {
verror(ERR_WARN, "find similar spans", "sequences must both be either DNA or protein");
return TCL_OK;
} else if (seq1_type == PROTEIN) {
set_char_set(PROTEIN);
set_score_matrix(get_matrix_file(PROTEIN));
} else if (seq1_type == DNA) {
set_char_set(DNA);
set_score_matrix(get_matrix_file(DNA));
}
/*
* first check if seq lengths are equal, if not the seqs cannot be the
* same
*/
/*
* Should check length of sub sequences only. These lengths are not
* stored, so have to calculate them here. Not storing them in
* seq1_len and seq2_len as I'm unsure whether subsequent functions
* expect the length of the whole sequence. Anyway, the compare_spans
* function recalculates the lengths of the sub sequences before doing
* the comparison.
*/
sub1_len = end_h - start_h + 1;
sub2_len = end_v - start_v + 1;
if (sub1_len == sub2_len) {
if (strncmp(seq1 + start_h - 1, seq2 + start_v - 1, sub1_len) == 0) {
same_seq = 1;
} else {
same_seq = 0;
}
} else {
same_seq = 0;
}
if (!get_remove_dup() && same_seq)
same_seq = 0;
Compare_Spans(seq1, seq2, seq1_len, seq2_len, start_h, end_h,
start_v, end_v, max_matches, same_seq,
win_len, min_match, 1, 0,
&seq1_match, &seq2_match, &match_score, &n_matches);
/* n_matches == -1 if malloc problem or -2 if too many matches */
if (n_matches == -2) {
verror(ERR_WARN, "find similar spans", "too many matches");
goto error;
} else if (n_matches == -1) {
goto error;
} else if (n_matches == 0) {
verror(ERR_WARN, "Find similar spans", "no matches found\n");
if (seq1_match)
xfree (seq1_match);
if (seq2_match)
xfree (seq2_match);
if (match_score)
xfree(match_score);
if (input)
xfree(input);
return -1;
}
/* create inputs parameters */
Tcl_DStringInit(&input_params);
vTcl_DStringAppend(&input_params, "horizontal %s: %s \nvertical %s: %s\n"
"window length %d min match %d number of matches %d",
GetSeqLibraryName(seq1_num),
GetSeqName(seq1_num),
GetSeqLibraryName(seq2_num),
GetSeqName(seq2_num),
win_len, min_match, n_matches);
vfuncparams("%s", Tcl_DStringValue(&input_params));
input->params = strdup(Tcl_DStringValue(&input_params));
Tcl_DStringFree(&input_params);
if (-1 == (*id = store_sip_similar_spans(seq1_num, seq2_num, win_len,
min_match, start_h, end_h,
start_v, end_v,
seq1_match, seq2_match,
match_score, n_matches,
input))) {
goto error;
}
if (seq1_match)
xfree (seq1_match);
if (seq2_match)
xfree (seq2_match);
if (match_score)
xfree(match_score);
return 0;
error:
verror(ERR_WARN, "find similar spans", "failure in find similar spans");
if (seq1_match)
xfree (seq1_match);
if (seq2_match)
xfree (seq2_match);
if (match_score)
xfree(match_score);
if (input)
xfree(input);
return -1;
}
void SipRescanMatches(Tcl_Interp *interp,
seq_result *s_result,
int id,
int min_score)
{
int i, j;
double coords[2];
int index;
char *seq1, *seq2;
int seq1_len, seq2_len;
int score;
int start;
int x, y;
int index1, index2;
double wx0, wy0, wx1, wy1;
if (output->hidden) {
return;
}
index1 = GetSeqNum(s_result->seq_id[HORIZONTAL]);
index2 = GetSeqNum(s_result->seq_id[VERTICAL]);
/* if either index is -1; the corresponding seq must have been deleted */
if ((index1 == -1) || (index2 == -1)) {
return;
}
seq1 = GetSeqSequence(index1);
seq2 = GetSeqSequence(index2);
seq1_len = GetSeqLength(index1);
seq2_len = GetSeqLength(index2);
Tcl_GetCommandInfo(interp, output->raster_win, &info);
raster = (Tk_Raster*)info.clientData;
opts[0] = "-fg";
opts[1] = "purple";
opts[2] = NULL;
index = CreateDrawEnviron(interp, raster, 2, opts);
SetDrawEnviron(output->interp, raster, index);
RasterGetWorldScroll(raster, &wx0, &wy0, &wx1, &wy1);
start = (int)(data->win_len / 2);
/* printing */
for (i = 0; i < num_pts; i++) {
x = data->p_array[i].x - start;
y = data->p_array[i].y - start;
for (j = 0; j < data->win_len; j++, x++, y++) {
if ((x < 1) || (y < 1) || (x > seq1_len) || (y > seq2_len)) {
continue;
}
score = score_matrix[char_lookup[seq1[x - 1]]]
[char_lookup[seq2[y - 1]]];
if (score >= min_score) {
/* printf("j %d x %d y %d score %d \n", j, x, y, score); */
coords[0] = x;
coords[1] = (int)wy1 - y + wy0;
RasterDrawPoints(raster, coords, 1);
}
}
}
tk_RasterRefresh(raster);
}
/*
* finds the expected score to give num_matches for a given window length
*/
int tcl_sip_find_score(ClientData clientData,
Tcl_Interp *interp,
int argc,
char *argv[])
{
find_score_arg args;
char *seq1;
char *seq2;
int seq1_len, seq2_len;
int seq1_type, seq2_type;
int seq1_num, seq2_num;
int score;
cli_args a[] = {
{"-win_len", ARG_INT, 1, NULL, offsetof(find_score_arg, win_len)},
{"-num_matches", ARG_INT, 1, NULL,
offsetof(find_score_arg, num_matches)},
{"-seq_id_h", ARG_INT, 1, NULL, offsetof(find_score_arg, seq_id_h)},
{"-seq_id_v", ARG_INT, 1, NULL, offsetof(find_score_arg, seq_id_v)},
{"-start_h", ARG_INT, 1, "1", offsetof(find_score_arg, start_h)},
{"-end_h", ARG_INT, 1, NULL, offsetof(find_score_arg, end_h)},
{"-start_v", ARG_INT, 1, "1", offsetof(find_score_arg, start_v)},
{"-end_v", ARG_INT, 1, NULL, offsetof(find_score_arg, end_v)},
{"-use_av_comp", ARG_INT, 1, "0", offsetof(find_score_arg, use_av_comp)},
{NULL, 0, 0, NULL, 0}
};
if (-1 == parse_args(a, &args, argc, argv))
return TCL_ERROR;
seq1_num = GetSeqNum(args.seq_id_h);
seq2_num = GetSeqNum(args.seq_id_v);
seq1 = GetSeqSequence(seq1_num);
seq2 = GetSeqSequence(seq2_num);
seq1_type = GetSeqType(seq1_num);
seq2_type = GetSeqType(seq2_num);
seq1_len = GetSeqLength(seq1_num);
seq2_len = GetSeqLength(seq2_num);
if (args.start_h < 1)
args.start_h = 1;
if (args.end_h > seq1_len)
args.end_h = seq1_len;
if (args.start_v < 1)
args.start_v = 1;
if (args.end_v > seq2_len)
args.end_v = seq2_len;
seq1_len = args.end_h - args.start_h + 1;
seq2_len = args.end_v - args.start_v + 1;
if (args.use_av_comp) {
seq1_len = seq1_len / 3;
seq2_len = seq2_len / 3;
seq1_type = PROTEIN;
seq2_type = PROTEIN;
}
if (seq1_type != seq2_type) {
verror(ERR_WARN, "find score", "sequences must both be either DNA or protein");
return TCL_OK;
} else if (seq1_type == PROTEIN) {
set_char_set(PROTEIN);
set_score_matrix(get_matrix_file(PROTEIN));
} else if (seq1_type == DNA) {
set_char_set(DNA);
set_score_matrix(get_matrix_file(DNA));
}
score = FindScore(seq1_len, seq2_len, args.win_len, args.num_matches);
vTcl_SetResult(interp, "%d", score);
return TCL_OK;
}
int init_nip_start_codons_create(int seq_id,
int start,
int end,
int strand_sym,
Tcl_Obj **graph_obj,
int *id)
{
in_s_codon *input1;
in_s_codon *input2;
in_s_codon *input3;
char *seq;
int seq_len;
int sequence_type;
int seq_num;
s_codon_res *start_codon;
int type = START_CODON;
Tcl_DString input_params;
char strand[8];
vfuncheader("plot start codons");
if (NULL == (input1 = (in_s_codon *)xmalloc
(sizeof(in_s_codon))))
return -1;
if (NULL == (input2 = (in_s_codon *)xmalloc
(sizeof(in_s_codon))))
return -1;
if (NULL == (input3 = (in_s_codon *)xmalloc
(sizeof(in_s_codon))))
return -1;
if (NULL == (start_codon = (s_codon_res *)xmalloc(sizeof(s_codon_res))))
return -1;
seq_num = GetSeqNum(seq_id);
seq = GetSeqSequence(seq_num);
seq_len = GetSeqLength(seq_num);
sequence_type = GetSeqStructure(seq_num);
/* if the end has not been defined, set it to be the sequence length */
if (end == -1) {
end = seq_len;
}
nip_start_codons(seq, sequence_type, start, end, strand_sym, start_codon);
/* create inputs parameters */
Tcl_DStringInit(&input_params);
if (strand_sym & TOP_S) {
strcpy(strand, "forward");
} else if (strand_sym & BOTTOM_S) {
strcpy(strand, "reverse");
} else {
strcpy(strand, "both");
}
vTcl_DStringAppend(&input_params, "sequence %s: from %d to %d\n"
"strand %s\n",
GetSeqName(seq_num), start, end, strand);
vfuncparams("%s", Tcl_DStringValue(&input_params));
input1->params = strdup(Tcl_DStringValue(&input_params));
input2->params = strdup(Tcl_DStringValue(&input_params));
input3->params = strdup(Tcl_DStringValue(&input_params));
Tcl_DStringFree(&input_params);
if (start_codon->n_match1 > 0) {
if (-1 == (id[0] = store_stop_codons(seq_num, input1, start, end,
start_codon->match1,
start_codon->n_match1,
1, type, &graph_obj[0]))){
verror(ERR_FATAL,"nip start codons", "error in saving matches\n");
return -1;
}
} else {
id[0] = -1;
free(input1->params);
xfree(input1);
xfree(start_codon->match1);
verror(ERR_WARN, "nip start codons", "no matches found for frame 1");
}
if (start_codon->n_match2 > 0) {
if (-1 == (id[1] = store_stop_codons(seq_num, input2, start, end,
start_codon->match2,
start_codon->n_match2,
2, type, &graph_obj[1]))){
verror(ERR_FATAL,"nip start codons", "error in saving matches\n");
return -1;
}
} else {
id[1] = -1;
free(input2->params);
xfree(input2);
xfree(start_codon->match2);
verror(ERR_WARN, "nip start codons", "no matches found for frame 2");
}
if (start_codon->n_match3 > 0) {
if (-1 == (id[2] = store_stop_codons(seq_num, input3, start, end,
start_codon->match3,
start_codon->n_match3,
3, type, &graph_obj[2]))){
verror(ERR_FATAL,"nip start codons", "error in saving matches\n");
return -1;
}
} else {
id[2] = -1;
free(input3->params);
xfree(input3);
xfree(start_codon->match3);
verror(ERR_WARN, "nip start codons", "no matches found for frame 3");
}
xfree(start_codon);
return 0;
}
int TranslateSeq(Tcl_Interp *interp,
int seq_num,
int rf,
int start,
int end)
{
int i;
char *name;
char *dna_seq;
char *prot_seq;
int cnt = 0;
int seq_id = GetSeqId(seq_num);
int new_seq_num;
char *ptr;
char *parental_name, *child_name;
char *new_name;
int length = end - start + 1;
static int num = 0;
#ifdef DEBUG
printf("START translate seq %d to %d\n", start, end);
#endif
dna_seq = GetSeqSequence(seq_num);
if (NULL == (prot_seq = (char *)xmalloc(((length/3)+3) * sizeof(char))))
return -1;
if (NULL == (new_name = (char *)xmalloc(strlen(GetSeqName(seq_num))
* sizeof(char))))
return -1;
for (i = rf+start-1; i < end-2; i+=3) {
prot_seq[cnt++] = codon_to_acid1(&dna_seq[i]);
}
prot_seq[cnt] = '\0';
#ifdef DEBUG
printf("%s\n", prot_seq);
#endif
/*
* special case: remove _rf123 from name before adding _rfx to end
*/
parental_name = GetParentalSeqName(seq_num);
child_name = GetSeqName(seq_num);
ptr = strstr(parental_name, "_rf123");
if (NULL == (name = (char *)xmalloc((strlen(parental_name)+28)
* sizeof(char))))
return -1;
if (ptr) {
strncpy(new_name, parental_name, (ptr - parental_name));
new_name[ptr - parental_name] = '\0';
strcat(new_name, ptr+6);
sprintf(name, "%s_rf%d_%d", new_name, rf+1, num);
} else {
sprintf(name, "%s_rf%d_%d", parental_name, rf+1, num);
}
/* proteins can only be LINEAR ! */
if (-1 == (new_seq_num = AddSequence(interp, -1, GetSeqLibrary(seq_num),
name, prot_seq, LINEAR, PROTEIN, NULL, " ")))
return -1;
xfree(name);
xfree(new_name);
if (strcmp(parental_name, child_name) != 0) {
/* sub-sequence */
/*
* need to get seq num from seq_id instead of using seq_num incase
* AddSequence has deleted duplicate names
*/
start = ceil((GetSubSeqStart(GetSeqNum(seq_id))-1)/3.0 + 1);
end = (GetSubSeqEnd(GetSeqNum(seq_id)) - rf) / 3;
if (NULL == (name = (char *)xmalloc((strlen(child_name)+15) *
sizeof(char))))
return -1;
if (NULL == (new_name = (char *)xmalloc(strlen(GetSeqName(seq_num))
* sizeof(char))))
return -1;
ptr = strstr(child_name, "_rf123");
if (ptr) {
strncpy(new_name, child_name, (ptr - child_name));
new_name[ptr - child_name] = '\0';
strcat(new_name, ptr+6);
sprintf(name, "%s_rf%d_%d", new_name, rf+1, num);
} else {
sprintf(name, "%s_rf%d_%d", child_name, rf+1, num);
}
/* sprintf(name, "%s_rf%d", child_name, rf+1); */
new_seq_num = AddSubSequence(interp, GetSeqId(new_seq_num), start, end,
name);
xfree(new_name);
}
num++;
return new_seq_num;
}
/*
* display the expected and observed scores
*/
int tcl_sip_find_probs(ClientData clientData,
Tcl_Interp *interp,
int argc,
char *argv[])
{
find_prob_arg args;
char *seq1;
char *seq2;
int seq1_len, seq2_len;
int seq1_type, seq2_type;
int seq1_num, seq2_num;
cli_args a[] = {
{"-win_len", ARG_INT, 1, NULL, offsetof(find_prob_arg, win_len)},
{"-seq_id_h", ARG_INT, 1, NULL, offsetof(find_prob_arg, seq_id_h)},
{"-seq_id_v", ARG_INT, 1, NULL, offsetof(find_prob_arg, seq_id_v)},
{"-start_h", ARG_INT, 1, "1", offsetof(find_prob_arg, start_h)},
{"-end_h", ARG_INT, 1, NULL, offsetof(find_prob_arg, end_h)},
{"-start_v", ARG_INT, 1, "1", offsetof(find_prob_arg, start_v)},
{"-end_v", ARG_INT, 1, NULL, offsetof(find_prob_arg, end_v)},
{"-type_h", ARG_INT, 1, "-1", offsetof(find_prob_arg, type_h)},
{"-type_v", ARG_INT, 1, "-1", offsetof(find_prob_arg, type_v)},
{"-use_av_comp", ARG_INT, 1, "0", offsetof(find_prob_arg, use_av_comp)},
{NULL, 0, 0, NULL, 0}
};
if (-1 == parse_args(a, &args, argc, argv))
return TCL_ERROR;
/* get first and second sequence saved using extract_sequence */
seq1_num = GetSeqNum(args.seq_id_h);
seq2_num = GetSeqNum(args.seq_id_v);
if (seq1_num == -1) {
verror(ERR_WARN, "find probabilities", "horizontal sequence undefined");
return TCL_OK;
} else if (seq2_num == -1) {
verror(ERR_WARN, "find probabilities", "vertical sequence undefined");
return TCL_OK;
}
seq1 = GetSeqSequence(seq1_num);
seq1_len = GetSeqLength(seq1_num);
seq2 = GetSeqSequence(seq2_num);
seq2_len = GetSeqLength(seq2_num);
if (args.type_h == -1)
seq1_type = GetSeqType(seq1_num);
else
seq1_type = args.type_h;
if (args.type_v == -1)
seq2_type = GetSeqType(seq2_num);
else
seq2_type = args.type_v;
if (args.use_av_comp) {
seq1_type = PROTEIN;
seq2_type = PROTEIN;
}
if (seq1_type != seq2_type) {
verror(ERR_WARN, "find score", "sequences must both be either DNA or protein");
return TCL_OK;
} else if (seq1_type == PROTEIN) {
set_char_set(PROTEIN);
set_score_matrix(get_matrix_file(PROTEIN));
} else if (seq1_type == DNA) {
set_char_set(DNA);
set_score_matrix(get_matrix_file(DNA));
}
FindProbs(seq1, seq2, args.start_h, args.end_h, args.start_v, args.end_v,
args.win_len, seq1_type, args.use_av_comp);
return TCL_OK;
}
int init_splice_search_create(int seq_id,
int start,
int end,
char *donor,
char *acceptor,
int *id) /* out */
{
in_splice *input1;
in_splice *input2;
in_splice *input3;
char *seq;
int seq_len;
int seq_num;
SpliceResults *splice_result;
Tcl_DString input_params;
int irs;
vfuncheader("splice search");
set_char_set(DNA);
if (NULL == (input1 = (in_splice *)xmalloc (sizeof(in_splice))))
return -1;
if (NULL == (input2 = (in_splice *)xmalloc (sizeof(in_splice))))
return -1;
if (NULL == (input3 = (in_splice *)xmalloc (sizeof(in_splice))))
return -1;
if (NULL == (splice_result = (SpliceResults *)xmalloc
(sizeof(SpliceResults))))
return -1;
seq_num = GetSeqNum(seq_id);
seq = GetSeqSequence(seq_num);
seq_len = GetSeqLength(seq_num);
/* if the end has not been defined, set it to be the sequence length */
if (end == -1) {
end = seq_len;
}
irs = splice_search(seq, seq_len, start, end, donor, acceptor,
splice_result);
if (irs == -1) {
xfree(splice_result);
xfree(input1);
xfree(input2);
xfree(input3);
verror(ERR_WARN, "splice search",
"error in splice search (maybe none found)");
return -1;
}
if (splice_result->ied_f1->number_of_res == 0 &&
splice_result->ied_f2->number_of_res == 0 &&
splice_result->ied_f3->number_of_res == 0 &&
splice_result->eia_f1->number_of_res == 0 &&
splice_result->eia_f2->number_of_res == 0 &&
splice_result->eia_f3->number_of_res == 0) {
verror(ERR_WARN, "splice search", "no matches found");
xfree(splice_result);
xfree(input1);
xfree(input2);
xfree(input3);
return -1;
}
/* create inputs parameters */
Tcl_DStringInit(&input_params);
vTcl_DStringAppend(&input_params, "sequence %s: from %d to %d\n"
"donor weight matrix %s\nacceptor weight matrix %s\n",
GetSeqName(seq_num), start, end, donor, acceptor);
vfuncparams("%s", Tcl_DStringValue(&input_params));
input1->params = strdup(Tcl_DStringValue(&input_params));
input2->params = strdup(Tcl_DStringValue(&input_params));
input3->params = strdup(Tcl_DStringValue(&input_params));
Tcl_DStringFree(&input_params);
if (-1 == (id[0] = StoreSpliceSearch(seq_num, splice_result->ied_f1,
splice_result->eia_f1, input1,
start, end, 1))){
verror(ERR_FATAL,"nip splice search", "error in saving matches\n");
return -1;
}
if (-1 == (id[1] = StoreSpliceSearch(seq_num, splice_result->ied_f2,
splice_result->eia_f2, input2,
start, end, 2))){
verror(ERR_FATAL,"nip splice search", "error in saving matches\n");
return -1;
}
if (-1 == (id[2] = StoreSpliceSearch(seq_num, splice_result->ied_f3,
splice_result->eia_f3, input3,
start, end, 3))){
verror(ERR_FATAL,"nip splice search", "error in saving matches\n");
return -1;
}
xfree(splice_result);
return 0;
}
int init_emboss_stick_create(Tcl_Interp *interp,
int seq_id,
int start,
int end,
char *filename,
int *id)
{
FILE *fp;
int i;
int *pos = NULL;
int *res = NULL;
int seq_num, seq_len;
in_emboss *input;
Tcl_DString input_params;
char dummy1[100];
char dummy2;
seq_num = GetSeqNum(seq_id);
seq_len = GetSeqLength(seq_num);
/* if the end has not been defined, set it to be the sequence length */
if (end == -1) {
end = seq_len;
}
seq_len = end - start + 1;
if (NULL == (pos = (int *)xmalloc((seq_len+1) * sizeof(int))))
return -1;
if (NULL == (res = (int *)xmalloc((seq_len+1) * sizeof(res))))
return -1;
if (NULL == (input = (in_emboss *)xmalloc (sizeof(in_emboss))))
return -1;
if (NULL == (fp = fopen(filename, "r"))) {
printf("unable to open file\n");
return -1;
}
if (fgetc(fp) == 'P') {
printf("first char\n");
fgets(dummy1, 100, fp);
fgets(dummy1, 100, fp);
fgets(dummy1, 100, fp);
} else {
rewind(fp);
}
i = 0;
while (fscanf(fp, "%d %c %d\n", &pos[i], &dummy2, &res[i]) != EOF) {
#ifdef DEBUG
printf("pos %d result %d\n", pos[i], res[i]);
#endif
i++;
}
fclose (fp);
printf("num points %d\n", i);
/* create inputs parameters */
Tcl_DStringInit(&input_params);
vTcl_DStringAppend(&input_params, "sequence %s: from %d to %d\n",
GetSeqName(seq_num), start, end);
vfuncparams("%s", Tcl_DStringValue(&input_params));
input->params = strdup(Tcl_DStringValue(&input_params));
Tcl_DStringFree(&input_params);
#ifdef TODO
if (-1 == (*id = store_emboss_graph(seq_num, start, end, pos, score,
i, input))) {
verror(ERR_FATAL,"emboss", "error in saving results\n");
return -1;
}
#endif
if (pos)
xfree(pos);
if (res)
xfree(res);
return 0;
}
int init_splice_search_plot(Tcl_Interp *interp,
char *raster_win,
int raster_id,
char *r_id,
int seq_id,
char *colours,
int line_width,
float tick_ht)
{
int seq_num;
int num_id;
Tcl_CmdInfo info;
Tk_Raster *raster;
RasterResult *raster_result;
cursor_t *cursor;
seq_result *nip_result = NULL;
seq_cursor_notify cn;
stick *data;
int i, cnt;
int retval = -1;
char **result_id = NULL;
char **colour = NULL;
seq_num = GetSeqNum(seq_id);
if (Tcl_SplitList(interp, colours, &num_id, &colour) != TCL_OK)
goto cleanup;
if (Tcl_SplitList(interp, r_id, &num_id, &result_id) != TCL_OK)
goto cleanup;
if (Tcl_GetCommandInfo(interp, raster_win, &info) == 0)
goto cleanup;
raster = (Tk_Raster*)info.clientData;
RasterInitPlotFunc(raster, SeqRasterPlotFunc);
raster_result = raster_id_to_result(raster_id);
cursor = find_raster_result_cursor(raster_result, seq_id, HORIZONTAL);
cnt = 0;
for (i = 0; i < num_id; i++) {
if (atoi(result_id[i]) > -1) {
nip_result = result_data(atoi(result_id[i]), seq_num);
} else {
cnt++;
}
}
/* no results were found */
if (cnt == num_id) {
retval = 0;
goto cleanup;
}
data = nip_result->data;
/* move cursor to start position if no cursor is yet present */
if (raster_result->cursor_array[cursor->id].prev_pos == -1
&& data->ap_array[0].dim.x0 > raster_result->cursor_array[cursor->id].prev_pos) {
cursor->abspos = data->ap_array[0].dim.x0;
}
for (i = 0; i < num_id; i++) {
if (-1 == NipSpliceSearchPlot(interp, atoi(result_id[i]),
seq_num, raster_win, colour[i],
line_width, tick_ht, i+1)) {
verror(ERR_FATAL,"nip splice search", "error in saving matches\n");
goto cleanup;
}
}
/*
* need to ensure done all the necessary plotting before adding the
* cursor
*/
Tcl_VarEval(interp, "update idletasks ", NULL);
cn.job = SEQ_CURSOR_NOTIFY;
cn.cursor = cursor;
cn.cursor->job = CURSOR_MOVE;
seq_notify(seq_num, (seq_reg_data *)&cn);
raster_result = raster_id_to_result(raster_id);
/* adding 3 results to a single raster */
AddResultToRaster(raster_result);
AddResultToRaster(raster_result);
AddResultToRaster(raster_result);
retval = 0;
cleanup:
if(result_id) Tcl_Free((char *)result_id);
if(colour) Tcl_Free((char *)colour);
return retval;
}
