bool RS232Console::handleEvent(Dashboard *dash, SDL_Event *event)
{
int width, height, dummy;
getMetrics(dash, width, dummy, height);
bool hit_test = (event->button.x >= x) &&
(event->button.y >= y) &&
(event->button.x < x + width) &&
(event->button.y < y + height);
switch (event->type) {
case SDL_MOUSEBUTTONDOWN:
if (event->button.button == SDL_BUTTON_LEFT)
focused = hit_test;
break;
case SDL_MOUSEBUTTONUP:
if (!hit_test)
break;
if (event->button.button == SDL_BUTTON_WHEELDOWN) {
scroll_position = min(scroll_position + 2, maxScrollPosition());
scrollbar_persist_frames = SCROLLBAR_PERSIST_TIME_MSEC / Dashboard::FRAME_INTERVAL_MSEC;
} else if (event->button.button == SDL_BUTTON_WHEELUP) {
scroll_position = max(scroll_position - 2, 0);
scrollbar_persist_frames = SCROLLBAR_PERSIST_TIME_MSEC / Dashboard::FRAME_INTERVAL_MSEC;
}
break;
}
return false;
}
void RS232Console::render(Dashboard *dash, SDLColor color, SDLColor bg_color,
int font_size)
{
int char_width, char_height, height, width, mid_height;
getCharMetrics(dash, char_width, char_height);
getMetrics(dash, width, mid_height, height);
rectangleColor(dash->screen, x, y, x + width - 1, y + height - 1,
color.toUInt32());
lineColor(dash->screen, x, y + mid_height - 1, x + width - 1, y + mid_height - 1, color.toUInt32());
int current_y = y + 2;
int to_line = min((int)stored_text.size(), scroll_position + rows);
for (int i = scroll_position; i < to_line; i++) {
dash->putMonoText(x + 2, current_y, stored_text[i].substr(0, columns),
font_size + 2, color);
current_y += char_height;
}
if (scrollbar_persist_frames) {
drawScrollbar(dash, color);
scrollbar_persist_frames--;
}
}
void RS232Console::drawScrollbar(Dashboard *dash, SDLColor color)
{
const int PADDING = 6;
const int BAR_WIDTH = 12;
if ((int)stored_text.size() <= rows)
return;
int height, width, mid_height;
getMetrics(dash, width, mid_height, height);
int bar_x = x + width - PADDING - BAR_WIDTH;
int bar_y = y + PADDING;
int bar_w = BAR_WIDTH;
int bar_h = mid_height - 2 * PADDING;
int thumb_y = bar_y + bar_h * scroll_position / stored_text.size();
int thumb_h = bar_h * rows / stored_text.size();
rectangleColor(dash->screen, bar_x, bar_y, bar_x + bar_w - 1, bar_y + bar_h - 1,
color.toUInt32());
boxColor(dash->screen, bar_x, thumb_y, bar_x + bar_w - 1, thumb_y + thumb_h - 1,
color.toUInt32());
}
QSize SpinBox2::minimumSizeHint() const
{
getMetrics();
QSize size = mSpinbox->minimumSizeHint();
size.setWidth(size.width() - wSpinboxHide + wUpdown2);
return size;
}
void
ApplicationImpl::generateLoad(uint32_t nAccounts, uint32_t nTxs,
uint32_t txRate, bool autoRate)
{
getMetrics().NewMeter({"loadgen", "run", "start"}, "run").Mark();
getLoadGenerator().generateLoad(*this, nAccounts, nTxs, txRate, autoRate);
}
void PerformanceTest::writeMetrics(const string &suiteName, const string &caseName, const string& fileName)
{
Metrics metrics = getMetrics();
// For thousands separation
setlocale(LC_ALL, "");
if (!fileName.empty())
{
FILE* f = fopen(fileName.c_str(), "a+");
fprintf(f,
"%s;%s;%zu;%zu;%lu;%f;%f;%f;%f\n",
suiteName.c_str(),
caseName.c_str(),
m_repeatsCount,
m_threadsCount,
metrics.executedOperations,
metrics.operationsPerSecond,
metrics.avgOperationDuration,
metrics.iterationDuration,
metrics.repeatDuration);
fclose(f);
}
printf("Operations/sec:\t\t\t%'f\n"
"Avg. operation duration:\t%f nsec\n"
"Iteration duration:\t\t%f sec\n"
"Repeat duration:\t\t%f sec\n",
metrics.operationsPerSecond,
metrics.avgOperationDuration,
metrics.iterationDuration,
metrics.repeatDuration);
}
/******************************************************************************
* Set the positions and sizes of all the child widgets.
*/
void SpinBox2::arrange()
{
getMetrics();
mUpdown2->move(-mUpdown2->width(), 0); // keep completely hidden
QRect arrowRect = style()->visualRect((mRightToLeft ? Qt::RightToLeft : Qt::LeftToRight), rect(), QRect(0, 0, wUpdown2, height()));
QRect r(wUpdown2, 0, width() - wUpdown2, height());
if (mRightToLeft)
r.moveLeft(0);
mSpinboxFrame->setGeometry(r);
mSpinbox->setGeometry(mRightToLeft ? 0 : -wSpinboxHide, 0, mSpinboxFrame->width() + wSpinboxHide, height());
// qCDebug(KALARM_LOG) << "arrowRect="<<arrowRect<<", mUpdown2="<<mUpdown2->geometry()<<", mSpinboxFrame="<<mSpinboxFrame->geometry()<<", mSpinbox="<<mSpinbox->geometry()<<", width="<<width();
mSpinMirror->resize(wUpdown2, mUpdown2->height());
mSpinMirror->setGeometry(arrowRect);
mSpinMirror->setButtonPos(mButtonPos);
mSpinMirror->setButtons();
}
void litiv::IDatasetEvaluator_<litiv::eDatasetEval_BinaryClassifier>::writeEvalReport() const {
if(getBatches(false).empty() || !isUsingEvaluator()) {
IDatasetEvaluator_<litiv::eDatasetEval_None>::writeEvalReport();
return;
}
for(const auto& pGroupIter : getBatches(true))
pGroupIter->shared_from_this_cast<const IDataReporter_<eDatasetEval_BinaryClassifier>>(true)->IDataReporter_<eDatasetEval_BinaryClassifier>::writeEvalReport();
IMetricsCalculatorConstPtr pMetrics = getMetrics(true);
lvAssert(pMetrics.get());
const BinClassifMetricsCalculator& oMetrics = dynamic_cast<const BinClassifMetricsCalculator&>(*pMetrics.get());
std::cout << CxxUtils::clampString(getName(),12) << " => Rcl=" << std::fixed << std::setprecision(4) << oMetrics.dRecall << " Prc=" << oMetrics.dPrecision << " FM=" << oMetrics.dFMeasure << " MCC=" << oMetrics.dMCC << std::endl;
std::ofstream oMetricsOutput(getOutputPath()+"/overall.txt");
if(oMetricsOutput.is_open()) {
oMetricsOutput << std::fixed;
oMetricsOutput << "Video segmentation evaluation report for dataset '" << getName() << "' :\n\n";
oMetricsOutput << " | Rcl | Spc | FPR | FNR | PBC | Prc | FM | MCC \n";
oMetricsOutput << "------------|------------|------------|------------|------------|------------|------------|------------|------------\n";
size_t nOverallPacketCount = 0;
double dOverallTimeElapsed = 0.0;
for(const auto& pGroupIter : getBatches(true)) {
oMetricsOutput << pGroupIter->shared_from_this_cast<const IDataReporter_<eDatasetEval_BinaryClassifier>>(true)->IDataReporter_<eDatasetEval_BinaryClassifier>::writeInlineEvalReport(0);
nOverallPacketCount += pGroupIter->getTotPackets();
dOverallTimeElapsed += pGroupIter->getProcessTime();
}
oMetricsOutput << "------------|------------|------------|------------|------------|------------|------------|------------|------------\n";
oMetricsOutput << " overall|" <<
std::setw(12) << oMetrics.dRecall << "|" <<
std::setw(12) << oMetrics.dSpecificity << "|" <<
std::setw(12) << oMetrics.dFPR << "|" <<
std::setw(12) << oMetrics.dFNR << "|" <<
std::setw(12) << oMetrics.dPBC << "|" <<
std::setw(12) << oMetrics.dPrecision << "|" <<
std::setw(12) << oMetrics.dFMeasure << "|" <<
std::setw(12) << oMetrics.dMCC << "\n";
oMetricsOutput << "\nHz: " << nOverallPacketCount/dOverallTimeElapsed << "\n";
oMetricsOutput << CxxUtils::getLogStamp();
}
}
std::string litiv::IDataReporter_<litiv::eDatasetEval_BinaryClassifier>::writeInlineEvalReport(size_t nIndentSize) const {
if(!getTotPackets())
return std::string();
const size_t nCellSize = 12;
std::stringstream ssStr;
ssStr << std::fixed;
if(isGroup() && !isBare())
for(const auto& pBatch : getBatches(true))
ssStr << pBatch->shared_from_this_cast<const IDataReporter_<eDatasetEval_BinaryClassifier>>(true)->IDataReporter_<eDatasetEval_BinaryClassifier>::writeInlineEvalReport(nIndentSize+1);
IMetricsCalculatorConstPtr pMetrics = getMetrics(true);
lvAssert(pMetrics.get());
const BinClassifMetricsCalculator& oMetrics = dynamic_cast<const BinClassifMetricsCalculator&>(*pMetrics.get());
ssStr << CxxUtils::clampString((std::string(nIndentSize,'>')+' '+getName()),nCellSize) << "|" <<
std::setw(nCellSize) << oMetrics.dRecall << "|" <<
std::setw(nCellSize) << oMetrics.dSpecificity << "|" <<
std::setw(nCellSize) << oMetrics.dFPR << "|" <<
std::setw(nCellSize) << oMetrics.dFNR << "|" <<
std::setw(nCellSize) << oMetrics.dPBC << "|" <<
std::setw(nCellSize) << oMetrics.dPrecision << "|" <<
std::setw(nCellSize) << oMetrics.dFMeasure << "|" <<
std::setw(nCellSize) << oMetrics.dMCC << "\n";
return ssStr.str();
}
void litiv::IDataReporter_<litiv::eDatasetEval_BinaryClassifier>::writeEvalReport() const {
if(!getTotPackets() || !getDatasetInfo()->isUsingEvaluator()) {
IDataReporter_<litiv::eDatasetEval_None>::writeEvalReport();
return;
}
else if(isGroup() && !isBare())
for(const auto& pBatch : getBatches(true))
pBatch->writeEvalReport();
IMetricsCalculatorConstPtr pMetrics = getMetrics(true);
lvAssert(pMetrics.get());
const BinClassifMetricsCalculator& oMetrics = dynamic_cast<const BinClassifMetricsCalculator&>(*pMetrics.get());;
std::cout << "\t" << CxxUtils::clampString(std::string(size_t(!isGroup()),'>')+getName(),12) << " => Rcl=" << std::fixed << std::setprecision(4) << oMetrics.dRecall << " Prc=" << oMetrics.dPrecision << " FM=" << oMetrics.dFMeasure << " MCC=" << oMetrics.dMCC << std::endl;
std::ofstream oMetricsOutput(PlatformUtils::AddDirSlashIfMissing(getOutputPath())+"../"+getName()+".txt");
if(oMetricsOutput.is_open()) {
oMetricsOutput << std::fixed;
oMetricsOutput << "Video segmentation evaluation report for '" << getName() << "' :\n\n";
oMetricsOutput << " | Rcl | Spc | FPR | FNR | PBC | Prc | FM | MCC \n";
oMetricsOutput << "------------|------------|------------|------------|------------|------------|------------|------------|------------\n";
oMetricsOutput << IDataReporter_<eDatasetEval_BinaryClassifier>::writeInlineEvalReport(0);
oMetricsOutput << "\nHz: " << getTotPackets()/getProcessTime() << "\n";
oMetricsOutput << CxxUtils::getLogStamp();
}
}
HTMLMarqueeElement::AnimationParameters
HTMLMarqueeElement::getAnimationParameters() {
AnimationParameters parameters;
Metrics metrics = getMetrics();
double totalWidth = metrics.marqueeWidth + metrics.contentWidth;
double totalHeight = metrics.marqueeHeight + metrics.contentHeight;
double innerWidth = metrics.marqueeWidth - metrics.contentWidth;
double innerHeight = metrics.marqueeHeight - metrics.contentHeight;
switch (getBehavior()) {
case kAlternate:
switch (getDirection()) {
case kRight:
parameters.transformBegin =
createTransform(innerWidth >= 0 ? 0 : innerWidth);
parameters.transformEnd =
createTransform(innerWidth >= 0 ? innerWidth : 0);
parameters.distance = std::abs(innerWidth);
break;
case kUp:
parameters.transformBegin =
createTransform(innerHeight >= 0 ? innerHeight : 0);
parameters.transformEnd =
createTransform(innerHeight >= 0 ? 0 : innerHeight);
parameters.distance = std::abs(innerHeight);
break;
case kDown:
parameters.transformBegin =
createTransform(innerHeight >= 0 ? 0 : innerHeight);
parameters.transformEnd =
createTransform(innerHeight >= 0 ? innerHeight : 0);
parameters.distance = std::abs(innerHeight);
break;
case kLeft:
default:
parameters.transformBegin =
createTransform(innerWidth >= 0 ? innerWidth : 0);
parameters.transformEnd =
createTransform(innerWidth >= 0 ? 0 : innerWidth);
parameters.distance = std::abs(innerWidth);
}
if (m_loopCount % 2)
std::swap(parameters.transformBegin, parameters.transformEnd);
break;
case kSlide:
switch (getDirection()) {
case kRight:
parameters.transformBegin = createTransform(-metrics.contentWidth);
parameters.transformEnd = createTransform(innerWidth);
parameters.distance = metrics.marqueeWidth;
break;
case kUp:
parameters.transformBegin = createTransform(metrics.marqueeHeight);
parameters.transformEnd = "translateY(0)";
parameters.distance = metrics.marqueeHeight;
break;
case kDown:
parameters.transformBegin = createTransform(-metrics.contentHeight);
parameters.transformEnd = createTransform(innerHeight);
parameters.distance = metrics.marqueeHeight;
break;
case kLeft:
default:
parameters.transformBegin = createTransform(metrics.marqueeWidth);
parameters.transformEnd = "translateX(0)";
parameters.distance = metrics.marqueeWidth;
}
break;
case kScroll:
default:
switch (getDirection()) {
case kRight:
parameters.transformBegin = createTransform(-metrics.contentWidth);
parameters.transformEnd = createTransform(metrics.marqueeWidth);
parameters.distance = totalWidth;
break;
case kUp:
parameters.transformBegin = createTransform(metrics.marqueeHeight);
parameters.transformEnd = createTransform(-metrics.contentHeight);
parameters.distance = totalHeight;
break;
case kDown:
parameters.transformBegin = createTransform(-metrics.contentHeight);
parameters.transformEnd = createTransform(metrics.marqueeHeight);
parameters.distance = totalHeight;
break;
case kLeft:
default:
parameters.transformBegin = createTransform(metrics.marqueeWidth);
parameters.transformEnd = createTransform(-metrics.contentWidth);
parameters.distance = totalWidth;
}
break;
}
return parameters;
}
void MenuButton::layoutSubviews() {
auto height = 48.0f;
auto menu = getMenu();
if (!menu) {
return;
}
auto menuMetrics = menu->getMetrics();
auto font = (menuMetrics == MenuMetrics::Navigation)?FontType::Body_1:FontType::Subhead;
_menuNameLabel->setFont(font);
_menuValueLabel->setFont(font);
_menuNameLabel->setVisible(false);
_menuValueLabel->setVisible(false);
_menuNameIcon->setVisible(false);
_menuValueIcon->setVisible(false);
if (_source) {
bool enabled = (_source->getCallback() != nullptr || _source->getNextMenu() != nullptr);
float namePos = metrics::menuFirstLeftKeyline(menuMetrics);
auto nameIcon = _source->getNameIcon();
if (nameIcon != IconName::None) {
_menuNameIcon->setIconName(nameIcon);
_menuNameIcon->setPosition(cocos2d::Vec2(namePos, height / 2));
_menuNameIcon->setVisible(true);
_menuNameIcon->setOpacity((enabled) ? 222 : 138);
namePos = metrics::menuSecondLeftKeyline(menuMetrics);
} else {
_menuNameIcon->setVisible(false);
}
auto name = _source->getName();
if (!name.empty()) {
_menuNameLabel->setString(name);
_menuNameLabel->setPosition(cocos2d::Vec2(namePos, height / 2));
_menuNameLabel->setVisible(true);
_menuNameLabel->setOpacity((enabled) ? 222 : 138);
} else {
_menuNameLabel->setVisible(false);
}
if (_source->getNextMenu()) {
_menuValueIcon->setIconName(IconName::Navigation_arrow_drop_down);
_menuValueIcon->setPosition(cocos2d::Vec2(_contentSize.width - 8, height / 2));
_menuValueIcon->setVisible(true);
_menuValueIcon->setRotated(true);
} else {
_menuValueIcon->setVisible(false);
_menuValueIcon->setRotated(false);
}
if (!_source->getValue().empty() && !_menuValueIcon->isVisible()) {
_menuValueLabel->setVisible(true);
_menuValueLabel->setString(_source->getValue());
_menuValueLabel->setPosition(cocos2d::Vec2(_contentSize.width - 16, height / 2));
_menuValueLabel->setOpacity((enabled) ? 222 : 138);
} else {
_menuValueLabel->setVisible(false);
}
if (_source->getValueIcon() != IconName::Empty && _source->getValueIcon() != IconName::None
&& !_menuValueLabel->isVisible() && !_menuValueIcon->isVisible()) {
_menuValueIcon->setIconName(_source->getValueIcon());
_menuValueIcon->setPosition(cocos2d::Vec2(_contentSize.width - 16, height / 2));
_menuValueIcon->setVisible(true);
_menuValueIcon->setOpacity((enabled) ? 222 : 138);
}
if (_source->isSelected()) {
setSelected(true, true);
} else {
setSelected(false);
}
setEnabled(enabled && _menu->isEnabled());
}
}
void Font::renderString(
const std::wstring & str,
glm::vec2 & cursor,
float fontSize,
float maxWidth) {
float scale = Text::Font::DTP_TO_METERS * fontSize / mFontSize;
bool wrap = (maxWidth == maxWidth);
if (wrap) {
maxWidth /= scale;
}
gl::MatrixStack & mv = gl::Stacks::modelview();
size_t mvDepth = mv.size();
glm::vec4 aspectTest = gl::Stacks::projection().top() * glm::vec4(1, 1, 0, 1);
float aspect = std::abs(aspectTest.x / aspectTest.y);
mv.push().translate(cursor).translate(glm::vec2(0, scale * -mAscent));
// scale the modelview from into font units
mv.scale(scale);
gl::ProgramPtr program = GlUtils::getProgram(
Resource::SHADERS_TEXT_VS,
Resource::SHADERS_TEXT_FS);
program->use();
program->setUniform("Color", glm::vec4(1));
program->setUniform("Font", 0);
program->setUniform4x4f("Projection",
gl::Stacks::projection().top());
mTexture->bind();
mGeometry->bindVertexArray();
std::vector<std::wstring> tokens = Tokenize(str);
// Stores how far we've moved from the start of the string, in DTP units
glm::vec2 advance;
static std::wstring SPACE = toUtf16(" ");
for_each(tokens.begin(), tokens.end(), [&](const std::wstring & token) {
float tokenWidth = measureWidth(token, fontSize) ;
if (wrap && 0 != advance.x && (advance.x + tokenWidth) > maxWidth) {
advance.x = 0;
advance.y -= (mAscent + mDescent);
}
for_each(token.begin(), token.end(), [&](::uint16_t id) {
if ('\n' == id) {
advance.x = 0;
advance.y -= (mAscent + mDescent);
return;
}
if (!contains(id)) {
id = '?';
}
// get metrics for this character to speed up measurements
const Font::Metrics & m = getMetrics(id);
if (wrap && ((advance.x + m.d) > maxWidth)) {
advance.x = 0;
advance.y -= (mAscent + mDescent);
}
// We create an offset vec2 to hold the local offset of this character
// This includes compensating for the inverted Y axis of the font
// coordinates
glm::vec2 offset(advance);
offset.y -= m.size.y;
// Bind the new position
mv.push().translate(offset).apply(program).pop();
// Render the item
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, (void*)(m.indexOffset * sizeof(GLuint)));
advance.x += m.d;//+ m.offset.x;// font->getAdvance(m, mFontSize);
});
advance.x += getMetrics(' ').d;
});
gl::VertexArray::unbind();
gl::Texture2d::unbind();
gl::Program::clear();
mv.pop();
//cursor.x += advance * scale;
}
