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; }