void GUITextBox::OnKeyDown(UCHAR key)
{
SetShift(keys[VK_SHIFT]);
if(GetText())
{
if((IsAlpabetic(key) || key == VK_SPACE) &&
GetTextLength() < GetMaxTextLength())
{
char* new_text = new char[strlen(GetText())+2];
if(GetShift())
sprintf(new_text, "%s%c\0", GetText(), key);
else
sprintf(new_text, "%s%c\0", GetText(), tolower(key));
try
{
delete[] GetText();
}
catch(...)
{
WriteToLog("Exception in GUITextBox::OnKeyDown()");
}
SetText(new_text);
SetTextLength(strlen(GetText()));
}
else if(key == VK_BACK)
{
UINT len = strlen(GetText());
if(len > 0)
{
string s = string(GetText());
char* new_text = new char[len];
sprintf(new_text, "%s\0", s.substr(0, s.length()-1).c_str());
try
{
delete[] GetText();
}
catch(...)
{
WriteToLog("Exception in GUITextBox::OnKeyDown()");
}
SetText(new_text);
SetTextLength(strlen(GetText()));
}
}
}
else
{
char* new_text = new char[1];
if(GetShift())
new_text[0] = key;
else
new_text[0] = tolower(key);
SetText(new_text);
}
}
GUITextBox::GUITextBox()
{
Init();
SetCaption(NULL);
SetCaptionFont(NULL);
SetCaptionColor(DEFAULT_TEXT_COLOR);
SetText("");
SetTextFont(NULL);
SetTextColor(DEFAULT_TEXT_COLOR);
SetTextCaretPos(0);
SetShift(false);
SetTextLength(0);
SetMaxTextLength(DEFAULT_MAX_TEXT_LENGTH);
}
static void AddOffset(const itk::Image<TPixel, VImageDimension>* inputImage, int offset, mitk::Image::Pointer outputImage)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::ShiftScaleImageFilter<ImageType, ImageType> FilterType;
auto filter = FilterType::New();
filter->SetInput(inputImage);
filter->SetShift(offset);
filter->Update();
// This is the tricky part that is done wrong very often. As the image data
// of ITK images and MITK images are binary compatible, we don't need to
// cast or copy the ITK output image. Instead, we just want to reference
// the image data and tell ITK that we took the ownership.
mitk::GrabItkImageMemory(filter->GetOutput(), outputImage);
}
void GUITextBox::OnKeyUp(UCHAR key)
{
if(key == VK_SHIFT)
SetShift(false);
}
// Evaluate dynamic programming matrix. Create transcript.
CNWAligner::TScore CSplicedAligner32::x_Align (SAlignInOut* data)
{
// use the banded version if there is no space for introns
const int len_dif (data->m_len2 - data->m_len1);
if(len_dif < 2 * int (m_IntronMinSize) / 3) {
const Uint1 where (len_dif < 0? 0: 1);
const size_t shift (abs(len_dif) / 2);
const size_t band (abs(len_dif) + 2*(max(data->m_len1,data->m_len2)/20 + 1));
SetShift(where, shift);
SetBand(band);
return CBandAligner::x_Align(data);
}
// redefine TScore as a floating-point type for this procedure only
typedef double TScore;
const TScore cds_penalty_extra = -2e-6;
const size_t N1 = data->m_len1 + 1;
const size_t N2 = data->m_len2 + 1;
vector<TScore> stl_rowV (N2), stl_rowF (N2);
TScore* rowV = &stl_rowV[0];
TScore* rowF = &stl_rowF[0];
// index calculation: [i,j] = i*n2 + j
SAllocator<Uint4> alloc_bm (N1*N2);
Uint4* backtrace_matrix (alloc_bm.GetPointer());
TScore* pV = rowV - 1;
const char* seq1 = m_Seq1 + data->m_offset1 - 1;
const char* seq2 = m_Seq2 + data->m_offset2 - 1;
const TNCBIScore (*sm) [NCBI_FSM_DIM] = m_ScoreMatrix.s;
bool bFreeGapLeft1 = data->m_esf_L1 && data->m_offset1 == 0;
bool bFreeGapRight1 = data->m_esf_R1 &&
m_SeqLen1 == data->m_offset1 + data->m_len1;
bool bFreeGapLeft2 = data->m_esf_L2 && data->m_offset1 == 0;
bool bFreeGapRight2 = data->m_esf_R2 &&
m_SeqLen2 == data->m_offset2 + data->m_len2;
TScore wgleft1 = bFreeGapLeft1? 0: m_Wg;
TScore wsleft1 = bFreeGapLeft1? 0: m_Ws;
TScore wg1 = wgleft1, ws1 = wsleft1;
// recurrences
TScore wgleft2 = bFreeGapLeft2? 0: m_Wg;
TScore wsleft2 = bFreeGapLeft2? 0: m_Ws;
TScore V = 0;
TScore V0 = 0;
TScore E, G, n0;
Uint4 type;
// store candidate donors
size_t* jAllDonors [splice_type_count_32];
TScore* vAllDonors [splice_type_count_32];
vector<size_t> stl_jAllDonors (splice_type_count_32 * N2);
vector<TScore> stl_vAllDonors (splice_type_count_32 * N2);
for(unsigned char st = 0; st < splice_type_count_32; ++st) {
jAllDonors[st] = &stl_jAllDonors[st*N2];
vAllDonors[st] = &stl_vAllDonors[st*N2];
}
size_t jTail[splice_type_count_32], jHead[splice_type_count_32];
TScore vBestDonor [splice_type_count_32];
size_t jBestDonor [splice_type_count_32] = {0};
// place to store gap opening starts
size_t ins_start;
vector<size_t> stl_del_start(N2);
size_t* del_start = &stl_del_start[0];
// donor/acceptor matrix
const Uint1 * dnr_acc_matrix = g_dnr_acc_matrix.GetMatrix();
// fake row (above lambda)
rowV[0] = kInfMinus;
size_t k;
for (k = 0; k < N2; k++) {
rowV[k] = rowF[k] = kInfMinus;
del_start[k] = k;
}
k = 0;
size_t cds_start = m_cds_start, cds_stop = m_cds_stop;
if(cds_start < cds_stop) {
cds_start -= data->m_offset1;
cds_stop -= data->m_offset1;
}
size_t i, j = 0, k0;
unsigned char ci;
for(i = 0; i < N1; ++i, j = 0) {
V = i > 0? (V0 += wsleft2) : 0;
E = kInfMinus;
ins_start = k0 = k;
backtrace_matrix[k++] = kTypeGap; // | del_start[0]
ci = i > 0? seq1[i]: 'N';
for(unsigned char st = 0; st < splice_type_count_32; ++st) {
jTail[st] = jHead[st] = 0;
vBestDonor[st] = kInfMinus;
}
if(i == N1 - 1 && bFreeGapRight1) {
wg1 = ws1 = 0;
}
TScore wg2 = m_Wg, ws2 = m_Ws;
// detect donor candidate
if(N2 > 2) {
unsigned char d1 = seq2[1], d2 = seq2[2];
Uint1 dnr_type = 0xF0 & dnr_acc_matrix[(size_t(d1)<<8)|d2];
for(Uint1 st = 0; st < splice_type_count_32; ++st ) {
jAllDonors[st][jTail[st]] = j;
if(dnr_type & (0x10 << st)) {
vAllDonors[st][jTail[st]] =
( d1 == g_nwspl32_donor[st][0] &&
d2 == g_nwspl32_donor[st][1] ) ? V: (V + m_Wd1);
}
else { // both chars distorted
vAllDonors[st][jTail[st]] = V + m_Wd2;
}
++(jTail[st]);
}
}
if(cds_start <= i && i < cds_stop) {
if(i != 0 || ! bFreeGapLeft1) {
ws1 += cds_penalty_extra;
}
if(j != 0 || ! bFreeGapLeft2) {
ws2 += cds_penalty_extra;
}
}
for (j = 1; j < N2; ++j, ++k) {
G = pV[j] + sm[ci][(unsigned char)seq2[j]];
pV[j] = V;
n0 = V + wg1;
if(E >= n0) {
E += ws1; // continue the gap
}
else {
E = n0 + ws1; // open a new gap
ins_start = k-1;
}
if(j == N2 - 1 && bFreeGapRight2) {
wg2 = ws2 = 0;
}
n0 = rowV[j] + wg2;
if(rowF[j] >= n0) {
rowF[j] += ws2;
}
else {
rowF[j] = n0 + ws2;
del_start[j] = k-N2;
}
// evaluate the score (V)
if (E >= rowF[j]) {
if(E >= G) {
V = E;
type = kTypeGap | ins_start;
}
else {
V = G;
type = kTypeDiag;
}
} else {
if(rowF[j] >= G) {
V = rowF[j];
type = kTypeGap | del_start[j];
}
else {
V = G;
type = kTypeDiag;
}
}
// find out if there are new donors
for(unsigned char st = 0; st < splice_type_count_32; ++st) {
if(jTail[st] > jHead[st]) {
if(j - jAllDonors[st][jHead[st]] >= m_IntronMinSize) {
if(vAllDonors[st][jHead[st]] > vBestDonor[st]) {
vBestDonor[st] = vAllDonors[st][jHead[st]];
jBestDonor[st] = jAllDonors[st][jHead[st]];
}
++(jHead[st]);
}
}
}
// check splice signal
Uint4 dnr_pos = kMax_UI4;
unsigned char c1 = seq2[j-1], c2 = seq2[j];
Uint1 acc_mask = 0x0F & dnr_acc_matrix[(size_t(c1)<<8)|c2];
for(Uint1 st = 0; st < splice_type_count_32; ++st ) {
if(acc_mask & (0x01 << st)) {
TScore vAcc = vBestDonor[st] + m_Wi[st];
if( c1 != g_nwspl32_acceptor[st][0] ||
c2 != g_nwspl32_acceptor[st][1] ) {
vAcc += m_Wd1;
}
if(vAcc > V) {
V = vAcc;
dnr_pos = k0 + jBestDonor[st];
}
}
else { // try arbitrary splice
TScore vAcc = vBestDonor[st] + m_Wi[st] + m_Wd2;
if(vAcc > V) {
V = vAcc;
dnr_pos = k0 + jBestDonor[st];
}
}
}
if(dnr_pos != kMax_UI4) {
type = kTypeIntron | dnr_pos;
}
backtrace_matrix[k] = type;
// detect donor candidates
if(j < N2 - 2) {
unsigned char d1 = seq2[j+1], d2 = seq2[j+2];
Uint1 dnr_mask = 0xF0 & dnr_acc_matrix[(size_t(d1)<<8)|d2];
for(Uint1 st = 0; st < splice_type_count_32; ++st ) {
if( dnr_mask & (0x10 << st) ) {
if( d1 == g_nwspl32_donor[st][0] &&
d2 == g_nwspl32_donor[st][1] ) {
if(V > vBestDonor[st]) {
jAllDonors[st][jTail[st]] = j;
vAllDonors[st][jTail[st]] = V;
++(jTail[st]);
}
} else {
TScore v = V + m_Wd1;
if(v > vBestDonor[st]) {
jAllDonors[st][jTail[st]] = j;
vAllDonors[st][jTail[st]] = v;
++(jTail[st]);
}
}
}
else { // both chars distorted
TScore v = V + m_Wd2;
if(v > vBestDonor[st]) {
jAllDonors[st][jTail[st]] = j;
vAllDonors[st][jTail[st]] = v;
++(jTail[st]);
}
}
}
}
}
pV[j] = V;
if(i == 0) {
V0 = wgleft2;
wg1 = m_Wg;
ws1 = m_Ws;
}
}
try {
x_DoBackTrace(backtrace_matrix, data);
}
catch(exception&) { // GCC hack
throw;
}
return CNWAligner::TScore(V);
}