BOOL COFSNcDlg2::LoadWindow(IXMLDOMNode *pXmlRoot, CRect &r, CRect &rMin, CRect &rMax)
{
ASSERT(pXmlRoot != NULL);
CComPtr<IXMLDOMNode> pWindow = NULL;
CComBSTR bs, bsBgPath;
LoadSkins skin;
long nErrorCode = 0;
IStreamPtr pStream = NULL;
CPaintDC dc(this);
WCHAR *szNULL = L"\0x00";
pXmlRoot->selectSingleNode(CComBSTR(L"Window"), &pWindow);
if(pWindow)
{
// Load window size
bs.Empty();
SelectChildNode(pWindow, CComBSTR(L"XLen"), NULL, &bs);
if(bs.m_str != NULL)
r.right = r.left + wcstol(bs.m_str, &szNULL, 10);
bs.Empty();
SelectChildNode(pWindow, CComBSTR(L"YLen"), NULL, &bs);
if(bs.m_str != NULL)
r.bottom = r.top + wcstol(bs.m_str, &szNULL, 10);
// Load min size
LoadRect(pWindow, _T("MinSize"), rMin);
// Load max size
LoadRect(pWindow, _T("MaxSize"), rMax);
// Load regions for corners
DeleteObject(m_rgnTL);
DeleteObject(m_rgnTR);
DeleteObject(m_rgnBL);
DeleteObject(m_rgnBR);
m_rgnTL = m_rgnTR = m_rgnBL = m_rgnBR = NULL;
LoadRegion(pWindow, _T("TL"), &m_rgnTL);
LoadRegion(pWindow, _T("TR"), &m_rgnTR);
LoadRegion(pWindow, _T("BL"), &m_rgnBL);
LoadRegion(pWindow, _T("BR"), &m_rgnBR);
CenterRect(r);
AdjustRect(r);
// Try Fix Focus behavior [7/23/2002]
SetWindowPos(NULL, r.left, r.top, r.Width(), r.Height(), SWP_NOZORDER|SWP_NOACTIVATE);
// Load background image
m_bBackgroundPicture = (LoadPictures(pWindow) > 0);
//pWindow->Release();
}
return TRUE;
}
Region* RegionPagerBase::GetRegion(int x, int y) {
x = snapToBase(REGION_WIDTH, x);
y = snapToBase(REGION_HEIGHT, y);
//get the region by various means
Region* ptr = nullptr;
ptr = FindRegion(x, y);
if (ptr) return ptr;
ptr = LoadRegion(x, y);
if (ptr) return ptr;
return CreateRegion(x, y);
}
bool CSkin::ReadButton(const char *skinFile, int num)
{
char buffer[2048];
CString path = skinFile;
int index = path.ReverseFind('\\');
if(index != -1) {
path = path.Left(index+1);
}
sprintf(buffer, "button-%d", num);
CString name = buffer;
if(!GetPrivateProfileString(name, "normal", "", buffer, 2048, skinFile)) {
m_error = "Missing button bitmap for " + name;
return false;
}
CString normalBmp = path + buffer;
HBITMAP bmp = LoadImage(normalBmp);
if(!bmp) {
m_error = "Error loading button bitmap " + normalBmp;
return false;
}
m_buttons[num].SetNormalBitmap(bmp);
if(!GetPrivateProfileString(name, "down", "", buffer, 2048, skinFile)) {
m_error = "Missing button down bitmap " + name;
return false;
}
CString downBmp = path + buffer;
bmp = LoadImage(downBmp);
if (!bmp) {
m_error = "Error loading button down bitmap " + downBmp;
return false;
}
m_buttons[num].SetDownBitmap(bmp);
if(GetPrivateProfileString(name, "over", "", buffer, 2048, skinFile)) {
CString overBmp = path + buffer;
bmp = LoadImage(overBmp);
if (!bmp) {
m_error = "Error loading button over bitmap " + overBmp;
return false;
}
m_buttons[num].SetOverBitmap(bmp);
}
if(GetPrivateProfileString(name, "region", "", buffer, 2048, skinFile)) {
CString region = path + buffer;
HRGN rgn = LoadRegion(region);
if(!rgn) {
m_error = "Error loading button region " + region;
return false;
}
m_buttons[num].SetRegion(rgn);
}
if(!GetPrivateProfileString(name, "id", "", buffer, 2048, skinFile)) {
"Missing button ID for " + name;
return false;
}
m_buttons[num].SetId(buffer);
if(!GetPrivateProfileString(name, "rect", "", buffer, 2048, skinFile)) {
m_error = "Missing button rectangle for " + name;
return false;
}
RECT r;
if(!ParseRect(buffer, r)) {
m_error = "Invalid button rectangle for " + name;
return false;
}
m_buttons[num].SetRect(r);
return true;
}
// ----------------------------------------------------------------------------
// skin retrieval helper
// ----------------------------------------------------------------------------
bool CSkin::GetSkinData(const char *skinFile)
{
// -------------------------------------------------
// retrieve the skin bitmap from resource.
// -------------------------------------------------
char buffer[2048];
if(!GetPrivateProfileString("skin", "image", "", buffer, 2048, skinFile)) {
m_error = "Missing skin bitmap";
return false;
}
CString bmpName = buffer;
CString rgn = "";
if(GetPrivateProfileString("skin", "region", "", buffer, 2048, skinFile)) {
rgn = buffer;
}
if(!GetPrivateProfileString("skin", "draw", "", buffer, 2048, skinFile)) {
m_error = "Missing draw rectangle";
return false;
}
if(!ParseRect(buffer, m_rect)) {
m_error = "Invalid draw rectangle";
return false;
}
m_nButtons = GetPrivateProfileInt("skin", "buttons", 0, skinFile);
if(m_nButtons) {
m_buttons = new SkinButton[m_nButtons];
for(int i = 0; i < m_nButtons; i++) {
if(!ReadButton(skinFile, i))
return false;
}
}
CString path = skinFile;
int index = path.ReverseFind('\\');
if(index != -1) {
path = path.Left(index+1);
}
bmpName = path + bmpName;
if(strcmp(rgn, ""))
rgn = path + rgn;
m_hBmp = LoadImage(bmpName);
if (!m_hBmp) {
m_error = "Error loading skin bitmap " + bmpName;
return false;
}
// get skin info
BITMAP bmp;
GetObject(m_hBmp, sizeof(bmp), &bmp);
// get skin dimensions
m_iWidth = bmp.bmWidth;
m_iHeight = bmp.bmHeight;
if(strcmp(rgn, "")) {
m_rgnSkin = LoadRegion(rgn);
if(m_rgnSkin == NULL) {
m_error = "Error loading skin region " + rgn;
return false;
}
}
// -------------------------------------------------
// well, things are looking good...
// as a quick providence, just create and keep
// a device context for our later blittings.
// -------------------------------------------------
// create a context compatible with the user desktop
m_dcSkin = CreateCompatibleDC(0);
if (!m_dcSkin) return false;
// select our bitmap
m_hOldBmp = (HBITMAP)SelectObject(m_dcSkin, m_hBmp);
// -------------------------------------------------
// done
// -------------------------------------------------
return true;
}
void PhaseEstimator::EstimatorWorker()
{
DPTreephaser treephaser(flow_order_, windowSize_);
vector<BasecallerRead *> useful_reads;
useful_reads.reserve(10000);
while (true) {
pthread_mutex_lock(&job_queue_mutex_);
while (job_queue_.empty()) {
if (jobs_in_progress_ == 0) {
pthread_mutex_unlock(&job_queue_mutex_);
return;
}
// No jobs available now, but more may come, so stick around
pthread_cond_wait(&job_queue_cond_, &job_queue_mutex_);
}
Subblock &s = *job_queue_.front();
job_queue_.pop_front();
jobs_in_progress_++;
pthread_mutex_unlock(&job_queue_mutex_);
// Processing
int numGlobalIterations = 1; // 3 iterations at top level, 1 at all other levels
if (s.level == 1)
numGlobalIterations = 3;
for (int iGlobalIteration = 0; iGlobalIteration < numGlobalIterations; iGlobalIteration++) {
ClockTimer timer;
timer.StartTimer();
size_t iotimer = 0;
treephaser.SetModelParameters(s.cf, s.ie, s.dr);
useful_reads.clear();
for (vector<int>::iterator region = s.sorted_regions.begin(); region != s.sorted_regions.end(); ++region) {
iotimer += LoadRegion(*region);
// Ensure region loaded.
// Grab reads, filter
// Enough reads? Stop.
if (action_map_[*region] == 0 and region_num_reads_[*region])
action_map_[*region] = s.level;
// Filter. Reads that survive filtering are stored in useful_reads
//! \todo: Rethink filtering. Maybe a rule that adjusts the threshold to keep at least 20% of candidate reads.
for (vector<BasecallerRead>::iterator R = region_reads_[*region].begin(); R != region_reads_[*region].end(); ++R) {
for (int flow = 0; flow < flow_order_.num_flows(); flow++)
R->normalized_measurements[flow] = R->raw_measurements[flow];
treephaser.Solve (*R, min(100, flow_order_.num_flows()));
use_pid_norm_ ? (void)treephaser.PIDNormalize(*R, 8, 40) : (void)treephaser.Normalize(*R, 11, 80);
treephaser.Solve (*R, min(120, flow_order_.num_flows()));
use_pid_norm_ ? (void)treephaser.PIDNormalize(*R, 8, 80) : (void)treephaser.Normalize(*R, 11, 100);
treephaser.Solve (*R, min(120, flow_order_.num_flows()));
float metric = 0;
for (int flow = 20; flow < 100 and flow < flow_order_.num_flows(); ++flow) {
if (R->normalized_measurements[flow] > 1.2)
continue;
float delta = R->normalized_measurements[flow] - R->prediction[flow];
if (!isnan(delta))
metric += delta * delta;
else
metric += 1e10;
}
if (metric > residual_threshold_) {
//printf("\nRejecting metric=%1.5f solution=%s", metric, R->sequence.c_str());
continue;
}
useful_reads.push_back(&(*R));
}
if (useful_reads.size() >= 5000)
break;
}
if (s.level > 1 and useful_reads.size() < 1000) // Not enough reads to even try
break;
// Do estimation with reads collected, update estimates
float parameters[3];
parameters[0] = s.cf;
parameters[1] = s.ie;
parameters[2] = s.dr;
NelderMeadOptimization(useful_reads, treephaser, parameters, use_pid_norm_);
s.cf = parameters[0];
s.ie = parameters[1];
s.dr = parameters[2];
printf("Completed (%d,%d,%d) :(%2d-%2d)x(%2d-%2d), total time %5.2lf sec, i/o time %5.2lf sec, %d reads, CF=%1.2f%% IE=%1.2f%% DR=%1.2f%%\n",
s.level, s.pos_x, s.pos_y, s.begin_x, s.end_x, s.begin_y, s.end_y,
(double)timer.GetMicroSec()/1000000.0, (double)iotimer/1000000.0, (int)useful_reads.size(),
100.0*s.cf, 100.0*s.ie, 100.0*s.dr);
}
if (useful_reads.size() >= 1000 or s.level == 1) {
for (int region_x = s.begin_x; region_x <= s.end_x and region_x < num_regions_x_; region_x++) {
for (int region_y = s.begin_y; region_y <= s.end_y and region_y < num_regions_y_; region_y++) {
int region = region_x + region_y * num_regions_x_;
if (region_x == s.begin_x and region_y == s.begin_y)
subblock_map_[region] = '+';
else if(region_x == s.begin_x and region_y == s.end_y)
subblock_map_[region] = '+';
else if(region_x == s.end_x and region_y == s.begin_y)
subblock_map_[region] = '+';
else if(region_x == s.end_x and region_y == s.end_y)
subblock_map_[region] = '+';
else if (region_x == s.begin_x)
subblock_map_[region] = '|';
else if (region_x == s.end_x)
subblock_map_[region] = '|';
else if (region_y == s.begin_y)
subblock_map_[region] = '-';
else if (region_y == s.end_y)
subblock_map_[region] = '-';
}
}
}
if (s.subblocks[0] == NULL or useful_reads.size() < 4000) {
// Do not subdivide this block
for (vector<int>::iterator region = s.sorted_regions.begin(); region != s.sorted_regions.end(); region++)
region_reads_[*region].clear();
pthread_mutex_lock(&job_queue_mutex_);
jobs_in_progress_--;
if (jobs_in_progress_ == 0) // No more work, let everyone know
pthread_cond_broadcast(&job_queue_cond_);
pthread_mutex_unlock(&job_queue_mutex_);
} else {
// Subdivide. Spawn new jobs:
pthread_mutex_lock(&job_queue_mutex_);
jobs_in_progress_--;
for (int subjob = 0; subjob < 4; subjob++) {
s.subblocks[subjob]->cf = s.cf;
s.subblocks[subjob]->ie = s.ie;
s.subblocks[subjob]->dr = s.dr;
job_queue_.push_back(s.subblocks[subjob]);
}
pthread_cond_broadcast(&job_queue_cond_); // More work, let everyone know
pthread_mutex_unlock(&job_queue_mutex_);
}
}
}
