static void xlsx_new_page(const pGEcontext gc, pDevDesc dd) {
XLSX_dev *xlsx_obj = (XLSX_dev*) dd->deviceSpecific;
if (xlsx_obj->pageno > 0) {
Rf_error("xlsx device only supports one page");
}
xlsx_obj->clp->set_clipping_region(0.0, 0.0, dd->right, dd->bottom);
main_tree mt(xlsx_obj->new_id(), xlsx_obj->new_id(),
xlsx_obj->offx, xlsx_obj->offy,
dd->right, dd->bottom, xlsx_obj->standalone);
fprintf(xlsx_obj->file, "%s", mt.x_opening_tag().c_str() );
int bg_fill, fill, col;
a_color bg_temp(gc->fill);
if (bg_temp.is_visible())
bg_fill = gc->fill;
else bg_fill = dd->startfill;
a_color bg_color(bg_fill);
if( bg_color.is_transparent() < 1 ){
fill = gc->fill;
col = gc->col;
gc->fill = bg_fill;
gc->col = bg_fill;
xlsx_rect(0, 0, dd->right, dd->bottom, gc, dd);
gc->fill = fill;
gc->col = col;
}
xlsx_obj->pageno++;
}
void OverlayMenuDisplay::openingAnimation()
{
ROS_DEBUG("openningAnimation");
prepareOverlay();
int current_width = animation_t_ / animate_duration * overlay_->getTextureWidth();
int current_height = animation_t_ / animate_duration * overlay_->getTextureHeight();
{
ScopedPixelBuffer buffer = overlay_->getBuffer();
QColor bg_color(0, 0, 0, 255.0 / 2.0);
QColor transparent(0, 0, 0, 0.0);
QImage Hud = buffer.getQImage(*overlay_);
for (int i = 0; i < overlay_->getTextureWidth(); i++) {
for (int j = 0; j < overlay_->getTextureHeight(); j++) {
if (i > (overlay_->getTextureWidth() - current_width) / 2.0 &&
i < overlay_->getTextureWidth() - (overlay_->getTextureWidth() - current_width) / 2.0 &&
j > (overlay_->getTextureHeight() - current_height) / 2.0 &&
j < overlay_->getTextureHeight() - (overlay_->getTextureHeight() - current_height) / 2.0) {
Hud.setPixel(i, j, bg_color.rgba());
}
else {
Hud.setPixel(i, j, transparent.rgba());
}
}
}
}
overlay_->setDimensions(overlay_->getTextureWidth(), overlay_->getTextureHeight());
int window_width = context_->getViewManager()->getRenderPanel()->width();
int window_height = context_->getViewManager()->getRenderPanel()->height();
double window_left = (window_width - (int)overlay_->getTextureWidth()) / 2.0;
double window_top = (window_height - (int)overlay_->getTextureHeight()) / 2.0;
overlay_->setPosition(window_left, window_top);
current_menu_ = next_menu_;
}
void OverlayMenuDisplay::redraw()
{
ROS_DEBUG("redraw");
prepareOverlay();
{
ScopedPixelBuffer buffer = overlay_->getBuffer();
QColor bg_color(0, 0, 0, 255.0 / 2.0);
QColor fg_color(25, 255, 240, 255.0);
QImage Hud = buffer.getQImage(*overlay_, bg_color);
QPainter painter( &Hud );
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setPen(QPen(fg_color, 1, Qt::SolidLine));
painter.setFont(font());
int line_height = fontMetrics().height();
int w = drawAreaWidth(next_menu_);
painter.drawText(menu_padding_x, menu_padding_y,
w, line_height,
Qt::TextWordWrap | Qt::AlignLeft | Qt::AlignTop,
next_menu_->title.c_str());
for (size_t i = 0; i < next_menu_->menus.size(); i++) {
std::string menu = getMenuString(next_menu_, i);
painter.drawText(menu_padding_x, line_height * ( 1 + i ) + menu_padding_y + menu_last_padding_y,
w, line_height,
Qt::TextWordWrap | Qt::AlignLeft | Qt::AlignTop,
menu.c_str());
}
if (next_menu_->current_index <= next_menu_->menus.size()) {
// draw '>'
painter.drawText(menu_padding_x - fontMetrics().width(">") * 2,
line_height * ( 1 + next_menu_->current_index ) + menu_padding_y + menu_last_padding_y,
w, line_height,
Qt::TextWordWrap | Qt::AlignLeft | Qt::AlignTop,
">");
}
// draw line
int texture_width = overlay_->getTextureWidth();
int texture_height = overlay_->getTextureHeight();
painter.drawLine(menu_padding_x / 2, menu_last_padding_y / 2 + line_height,
menu_padding_x / 2, texture_height - menu_last_padding_y / 2);
painter.drawLine(texture_width - menu_padding_x / 2, menu_last_padding_y / 2 + line_height,
texture_width - menu_padding_x / 2, texture_height - menu_last_padding_y / 2);
painter.drawLine(menu_padding_x / 2, menu_last_padding_y / 2 + line_height,
texture_width - menu_padding_x / 2, menu_last_padding_y / 2 + line_height);
painter.drawLine(menu_padding_x / 2, texture_height - menu_last_padding_y / 2,
texture_width - menu_padding_x / 2, texture_height - menu_last_padding_y / 2);
painter.end();
current_menu_ = next_menu_;
}
overlay_->setDimensions(overlay_->getTextureWidth(), overlay_->getTextureHeight());
int window_width = context_->getViewManager()->getRenderPanel()->width();
int window_height = context_->getViewManager()->getRenderPanel()->height();
double window_left = (window_width - (int)overlay_->getTextureWidth()) / 2.0;
double window_top = (window_height - (int)overlay_->getTextureHeight()) / 2.0;
overlay_->setPosition(window_left, window_top);
}
void GrabCut::show()
{
Scalar fg_color(255,0,0);
Scalar bg_color(0,255,0);
cv::Mat scribbled_src = _src.clone();
const float alpha = 0.7f;
for(int y=0; y < _gcut.rows; y++){
for(int x=0; x < _gcut.cols; x++){
if(_gcut.at<uchar>(y, x) == cv::GC_FGD) {
cv::circle(scribbled_src, cv::Point(x, y), 2, fg_color, -1);
}
else if(_gcut.at<uchar>(y, x) == cv::GC_BGD) {
cv::circle(scribbled_src, cv::Point(x, y), 2, bg_color, -1);
}
else if(_gcut.at<uchar>(y, x) == cv::GC_PR_BGD) {
cv::Vec3b& pix = scribbled_src.at<cv::Vec3b>(y, x);
pix[0] = (uchar)(pix[0] * alpha + bg_color[0] * (1-alpha));
pix[1] = (uchar)(pix[1] * alpha + bg_color[1] * (1-alpha));
pix[2] = (uchar)(pix[2] * alpha + bg_color[2] * (1-alpha));
}
else if(_gcut.at<uchar>(y, x) == cv::GC_PR_FGD) {
cv::Vec3b& pix = scribbled_src.at<cv::Vec3b>(y, x);
pix[0] = (uchar)(pix[0] * alpha + fg_color[0] * (1-alpha));
pix[1] = (uchar)(pix[1] * alpha + fg_color[1] * (1-alpha));
pix[2] = (uchar)(pix[2] * alpha + fg_color[2] * (1-alpha));
}
}
}
Rect roi;
Mat scrb;
roi = Rect(_src.cols,0,_src.cols,_src.rows);
scribbled_src.copyTo(_dsp(roi));
Mat msk = getBinMask();
cv::Mat send = msk.clone();
cv::Mat sendFilter;
cv::Mat resultMat = filterMaskAndMergeMat(send, _cutResultMask, _gcutBuffer);
Mat fg = getFGByMask(resultMat);//getFG();
roi = Rect(_src.cols,_src.rows,_src.cols,_src.rows);
fg.copyTo(_dsp(roi));
// imshow("fg", fg);
// imshow("mergeResultMat", resultMat);
_cutResultMask = resultMat;
//Rect tmp = getMaskRct(_gcutBuffer);
cvtColor(msk,msk,COLOR_GRAY2BGR);
roi = Rect(0,_src.rows,_src.cols,_src.rows);
msk.copyTo(_dsp(roi));
//imshow("msk", msk);
//imshow("_mask", _mask);
imshow(_name,_dsp);
waitKey(1);
}
/**
* Main game loop
*/
void Game::Game::run()
{
std::cout << "Game Launched" << std::endl;
while(WindowManager::gw->isOpen())
{
sf::Color bg_color(87,123,255);
WindowManager::gw->clear(bg_color);
checkEvents();
GameEngine::gc->update();
GameEngine::gc->draw();
WindowManager::gw->display();
}
}
static void setupHardware(void) {
// TODO: Put hardware configuration and initialisation in here
SystemInit();
resetGPIO();
setInput_P2();
ADCInit(ADC_CLK);
//resetto il termometro
pinMode(OUTPUT);
digitalWrite(HIGH);
Initial_Hardware(); //init lcd hardware
Initial_GLCD_Hor(); //init lcd "software"
bg_color(BLACK);
int sto_premendo = 0;
eMBErrorCode eStatus;
eStatus = eMBInit( MB_RTU, 0x0A, 0, 38400, MB_PAR_NONE );
/* Initialize the holding register values before starting the
* Modbus stack
*/
int i;
for( i = 0; i < REG_HOLDING_NREGS; i++ )
{
usRegHoldingBuf[i] = 0;
}
sensors.distance1 = 1;
sensors.distance2 = 2;
sensors.lumino = 3;
sensors.mic = 4;
sensors.vibro = 5;
actual_DHT11.humidity = 666;
actual_DHT11.temperature = 666;
//associo ai registri holding il valore dei sensori
*(usRegHoldingBuf ) = (USHORT *) &sensors.distance1;
*(usRegHoldingBuf + 1 ) = (USHORT *) &sensors.distance2;
*(usRegHoldingBuf + 2 ) = (USHORT *) &sensors.lumino;
*(usRegHoldingBuf + 3 ) = (USHORT *) &sensors.mic;
*(usRegHoldingBuf + 4 ) = (USHORT *) &sensors.vibro;
*(usRegHoldingBuf + 5 ) = (USHORT *) &actual_DHT11.humidity;
*(usRegHoldingBuf + 6 ) = (USHORT *) &actual_DHT11.temperature;
/* Enable the Modbus Protocol Stack. */
eStatus = eMBEnable( );
// Warning: If you do not initialize the hardware clock, the timings will be inaccurate
}
BOOL CColorEditSampleDlg::OnInitDialog() {
CDialog::OnInitDialog();
CDC *dc = __super::GetDC();
// icon
HICON icon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
SetIcon(icon, TRUE);
SetIcon(icon, FALSE);
// edit
LOGFONT font;
{
CString font_name = _T("Tahoma");
LONG font_size = 14;
_tcsncpy_s(font.lfFaceName, font_name, LF_FACESIZE);
{
static const int kPhysicalPx = 72;
int logicalPx = dc->GetDeviceCaps(LOGPIXELSY);
font.lfHeight = font_size * 10 * (-1) * logicalPx / kPhysicalPx;
}
font.lfWidth = 0;
font.lfEscapement = 0;
font.lfOrientation = 0;
font.lfWeight = FW_NORMAL;
font.lfItalic = FALSE;
font.lfUnderline = FALSE;
font.lfStrikeOut = FALSE;
font.lfCharSet = DEFAULT_CHARSET;
font.lfOutPrecision = OUT_DEFAULT_PRECIS;
font.lfClipPrecision = CLIP_DEFAULT_PRECIS;
font.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
font.lfQuality = DEFAULT_QUALITY;
}
CSize edit_size(320, 100);
COLORREF text_color(RGB(0, 0, 128));
COLORREF placeholder_color(RGB(128, 0, 0));
COLORREF bg_color(RGB(64, 128, 128));
COLORREF border_color(RGB(139, 87, 66));
COLORREF focus_text_color(RGB(0, 64, 255));
COLORREF focus_placeholder_color(RGB(255, 64, 0));
COLORREF focus_bg_color(RGB(128, 255, 255));
COLORREF focus_border_color(RGB(139, 69, 0));
UINT border_width = 10;
LONG left_margin = 10;
LONG right_margin = 10;
CPoint id_pos(50, 50);
id_edit_.CreateEdit(100,
this,
id_pos,
edit_size,
false,
_T(""),
_T("Id or email"),
&font,
text_color,
placeholder_color,
bg_color,
border_color,
focus_text_color,
focus_placeholder_color,
focus_bg_color,
focus_border_color,
border_width,
left_margin,
right_margin);
CPoint pw_pos(50, 160);
pw_edit_.CreateEdit(101,
this,
pw_pos,
edit_size,
true,
_T(""),
_T("Password"),
&font,
text_color,
placeholder_color,
bg_color,
border_color,
focus_text_color,
focus_placeholder_color,
focus_bg_color,
focus_border_color,
border_width,
left_margin,
right_margin);
//
__super::ReleaseDC(dc);
return TRUE;
}
// Load map general properties
bool j1Map::LoadMap()
{
bool ret = true;
pugi::xml_node map = map_file.child("map");
if(map == NULL)
{
LOG("Error parsing map xml file: Cannot find 'map' tag.");
ret = false;
}
else
{
data.width = map.attribute("width").as_int();
data.height = map.attribute("height").as_int();
data.tile_width = map.attribute("tilewidth").as_int();
data.tile_height = map.attribute("tileheight").as_int();
p2SString bg_color(map.attribute("backgroundcolor").as_string());
data.background_color.r = 0;
data.background_color.g = 0;
data.background_color.b = 0;
data.background_color.a = 0;
if(bg_color.Length() > 0)
{
p2SString red, green, blue;
bg_color.SubString(1, 2, red);
bg_color.SubString(3, 4, green);
bg_color.SubString(5, 6, blue);
int v = 0;
sscanf_s(red.GetString(), "%x", &v);
if(v >= 0 && v <= 255) data.background_color.r = v;
sscanf_s(green.GetString(), "%x", &v);
if(v >= 0 && v <= 255) data.background_color.g = v;
sscanf_s(blue.GetString(), "%x", &v);
if(v >= 0 && v <= 255) data.background_color.b = v;
}
p2SString orientation(map.attribute("orientation").as_string());
if(orientation == "orthogonal")
{
data.type = MAPTYPE_ORTHOGONAL;
}
else if(orientation == "isometric")
{
data.type = MAPTYPE_ISOMETRIC;
}
else if(orientation == "staggered")
{
data.type = MAPTYPE_STAGGERED;
}
else
{
data.type = MAPTYPE_UNKNOWN;
}
}
return ret;
}
void PieChartDisplay::drawPlot(double val)
{
QColor fg_color(fg_color_);
if (auto_color_change_) {
double r
= std::min(1.0, fabs((val - min_value_) / (max_value_ - min_value_)));
fg_color.setRed((max_color_.red() - fg_color_.red()) * r
+ fg_color_.red());
fg_color.setGreen((max_color_.green() - fg_color_.green()) * r
+ fg_color_.green());
fg_color.setBlue((max_color_.blue() - fg_color_.blue()) * r
+ fg_color_.blue());
}
QColor fg_color2(fg_color);
QColor bg_color(bg_color_);
QColor text_color(text_color_);
fg_color.setAlpha(fg_alpha_);
fg_color2.setAlpha(fg_alpha2_);
bg_color.setAlpha(bg_alpha_);
text_color.setAlpha(text_alpha_);
int width = overlay_->getTextureWidth();
int height = overlay_->getTextureHeight();
{
ScopedPixelBuffer buffer = overlay_->getBuffer();
QImage Hud = buffer.getQImage(*overlay_, bg_color);
QPainter painter( &Hud );
painter.setRenderHint(QPainter::Antialiasing, true);
const int outer_line_width = 5;
const int value_line_width = 10;
const int value_indicator_line_width = 2;
const int value_padding = 5;
const int value_aabb_offset
= outer_line_width + value_padding + value_line_width / 2;
painter.setPen(QPen(fg_color, outer_line_width, Qt::SolidLine));
painter.drawEllipse(outer_line_width / 2, outer_line_width / 2,
width - outer_line_width ,
height - outer_line_width - caption_offset_);
painter.setPen(QPen(fg_color2, value_indicator_line_width, Qt::SolidLine));
painter.drawEllipse(value_aabb_offset, value_aabb_offset,
width - value_aabb_offset * 2,
height - value_aabb_offset * 2 - caption_offset_);
const double ratio = (val - min_value_) / (max_value_ - min_value_);
const double ratio_angle = ratio * 360.0;
const double start_angle_offset = -90;
painter.setPen(QPen(fg_color, value_line_width, Qt::SolidLine));
painter.drawArc(QRectF(value_aabb_offset, value_aabb_offset,
width - value_aabb_offset * 2,
height - value_aabb_offset * 2 - caption_offset_),
start_angle_offset * 16 ,
ratio_angle * 16);
QFont font = painter.font();
font.setPointSize(text_size_);
font.setBold(true);
painter.setFont(font);
painter.setPen(QPen(text_color, value_line_width, Qt::SolidLine));
std::ostringstream s;
s << std::fixed << std::setprecision(2) << val;
painter.drawText(0, 0, width, height - caption_offset_,
Qt::AlignCenter | Qt::AlignVCenter,
s.str().c_str());
// caption
if (show_caption_) {
painter.drawText(0, height - caption_offset_, width, caption_offset_,
Qt::AlignCenter | Qt::AlignVCenter,
getName());
}
// done
painter.end();
// Unlock the pixel buffer
}
}
void CCalendarWidget::paintCell (QPainter *painter, const QRect &rect, const QDate &date) const
{
QSize fsize = fontMetrics().size (Qt::TextSingleLine, "A");
if (moon_mode)
{
int moon_day = moon_phase_by_algo (moon_phase_algo, date.year(), date.month(), date.day());
bool has_image = true;
if (moon_day == 0 || moon_day == 30 || moon_day == 1)
has_image = false;
//вычисляем ряд и колонку
//правильно
//int row = moon_day / 8;
int cursorOffset = moon_day;
int off = 0;
int row = 0;
while (cursorOffset >= (off + 8))
{
off += 7;
row++;
}
int col = cursorOffset - off;
// qDebug() << "moon day: " << moon_day << "| date:" << date.toString("dd") << " | row = " << row << " col = " << col;
//вычисляем, откуда копировать
int pad = 3;
int x = (col - 1) * 73 + (pad * col) - pad;
int y = row * 73 + (pad * row);
QRect r (x, y, 66, 73);
QImage tile = moon_tiles.copy (r);
QColor bg_color (Qt::black);
painter->fillRect (rect, bg_color);
if (has_image)
{
if (northern_hemisphere)
painter->drawImage (rect.x(), rect.y(), tile);
else
painter->drawImage (rect.x(), rect.y(), tile.mirrored (true, false));
}
painter->setPen (QPen (Qt::yellow));
QTextCharFormat tcf = dateTextFormat (date);
if (tcf.fontStrikeOut())
painter->setPen (QPen (Qt::magenta));
else
if (tcf.fontUnderline())
painter->setPen (QPen (Qt::red));
painter->drawText (QPoint (rect.x() + 5, rect.y() + fsize.height()), date.toString("dd") + " / " + QString::number (moon_day));
if (selectedDate() == date)
{
QPen dpen (Qt::yellow);
dpen.setWidth (5);
painter->setPen (dpen);
painter->drawRect (rect);
}
}
else
QCalendarWidget::paintCell (painter, rect, date);
}
////////////////////////////////////////////////////////////////////////////////
// Project Remaining Avg Age Complete 0% 100%
// A 12 13d 55% XXXXXXXXXXXXX-----------
// B 109 3d 12h 10% XXX---------------------
int CmdSummary::execute (std::string& output)
{
int rc = 0;
// Scan the pending tasks.
handleRecurrence ();
// Apply filter.
std::vector <Task> filtered;
filter (filtered);
context.tdb2.commit ();
// Generate unique list of project names from all pending tasks.
std::map <std::string, bool> allProjects;
std::vector <Task>::iterator task;
for (task = filtered.begin (); task != filtered.end (); ++task)
if (task->getStatus () == Task::pending)
allProjects[task->get ("project")] = false;
// Initialize counts, sum.
std::map <std::string, int> countPending;
std::map <std::string, int> countCompleted;
std::map <std::string, double> sumEntry;
std::map <std::string, int> counter;
time_t now = time (NULL);
// Initialize counters.
std::map <std::string, bool>::iterator project;
for (project = allProjects.begin (); project != allProjects.end (); ++project)
{
countPending [project->first] = 0;
countCompleted [project->first] = 0;
sumEntry [project->first] = 0.0;
counter [project->first] = 0;
}
// Count the various tasks.
for (task = filtered.begin (); task != filtered.end (); ++task)
{
std::string project = task->get ("project");
++counter[project];
if (task->getStatus () == Task::pending ||
task->getStatus () == Task::waiting)
{
++countPending[project];
time_t entry = strtol (task->get ("entry").c_str (), NULL, 10);
if (entry)
sumEntry[project] = sumEntry[project] + (double) (now - entry);
}
else if (task->getStatus () == Task::completed)
{
++countCompleted[project];
time_t entry = strtol (task->get ("entry").c_str (), NULL, 10);
time_t end = strtol (task->get ("end").c_str (), NULL, 10);
if (entry && end)
sumEntry[project] = sumEntry[project] + (double) (end - entry);
}
}
// Create a table for output.
ViewText view;
view.width (context.getWidth ());
view.add (Column::factory ("string", STRING_CMD_SUMMARY_PROJECT));
view.add (Column::factory ("string.right", STRING_CMD_SUMMARY_REMAINING));
view.add (Column::factory ("string.right", STRING_CMD_SUMMARY_AVG_AGE));
view.add (Column::factory ("string.right", STRING_CMD_SUMMARY_COMPLETE));
view.add (Column::factory ("string.left_fixed", "0% 100%"));
Color bar_color (context.config.get ("color.summary.bar"));
Color bg_color (context.config.get ("color.summary.background"));
int barWidth = 30;
std::vector <std::string> processed;
std::map <std::string, bool>::iterator i;
for (i = allProjects.begin (); i != allProjects.end (); ++i)
{
if (countPending[i->first] > 0)
{
const std::vector <std::string> parents = extractParents (i->first);
std::vector <std::string>::const_iterator parent;
for (parent = parents.begin (); parent != parents.end (); parent++)
{
if (std::find (processed.begin (), processed.end (), *parent)
== processed.end ())
{
int row = view.addRow ();
view.set (row, 0, indentProject (*parent));
processed.push_back (*parent);
}
}
int row = view.addRow ();
view.set (row, 0, (i->first == ""
? STRING_CMD_SUMMARY_NONE
: indentProject (i->first, " ", '.')));
view.set (row, 1, countPending[i->first]);
if (counter[i->first])
view.set (row, 2, Duration ((int) (sumEntry[i->first] / (double)counter[i->first])).format ());
int c = countCompleted[i->first];
int p = countPending[i->first];
int completedBar = (c * barWidth) / (c + p);
std::string bar;
std::string subbar;
if (context.color ())
{
bar += bar_color.colorize (std::string ( completedBar, ' '));
bar += bg_color.colorize (std::string (barWidth - completedBar, ' '));
}
else
{
bar += std::string ( completedBar, '=')
+ std::string (barWidth - completedBar, ' ');
}
view.set (row, 4, bar);
char percent[12];
sprintf (percent, "%d%%", 100 * c / (c + p));
view.set (row, 3, percent);
processed.push_back (i->first);
}
}
std::stringstream out;
if (view.rows ())
{
out << optionalBlankLine ()
<< view.render ()
<< optionalBlankLine ();
if (view.rows ())
out << format (STRING_CMD_PROJECTS_SUMMARY2, view.rows ());
else
out << STRING_CMD_PROJECTS_SUMMARY;
out << "\n";
}
else {
out << STRING_CMD_PROJECTS_NO << "\n";
rc = 1;
}
output = out.str ();
return rc;
}
Ref<Texture> CurvePreviewGenerator::generate(const Ref<Resource> &p_from) {
Ref<Curve> curve_ref = p_from;
ERR_FAIL_COND_V(curve_ref.is_null(), Ref<Texture>());
Curve &curve = **curve_ref;
int thumbnail_size = EditorSettings::get_singleton()->get("filesystem/file_dialog/thumbnail_size");
thumbnail_size *= EDSCALE;
Ref<Image> img_ref;
img_ref.instance();
Image &im = **img_ref;
im.create(thumbnail_size, thumbnail_size / 2, 0, Image::FORMAT_RGBA8);
im.lock();
Color bg_color(0.1, 0.1, 0.1, 1.0);
for (int i = 0; i < thumbnail_size; i++) {
for (int j = 0; j < thumbnail_size / 2; j++) {
im.set_pixel(i, j, bg_color);
}
}
Color line_color(0.8, 0.8, 0.8, 1.0);
float range_y = curve.get_max_value() - curve.get_min_value();
int prev_y = 0;
for (int x = 0; x < im.get_width(); ++x) {
float t = static_cast<float>(x) / im.get_width();
float v = (curve.interpolate_baked(t) - curve.get_min_value()) / range_y;
int y = CLAMP(im.get_height() - v * im.get_height(), 0, im.get_height());
// Plot point
if (y >= 0 && y < im.get_height()) {
im.set_pixel(x, y, line_color);
}
// Plot vertical line to fix discontinuity (not 100% correct but enough for a preview)
if (x != 0 && Math::abs(y - prev_y) > 1) {
int y0, y1;
if (y < prev_y) {
y0 = y;
y1 = prev_y;
} else {
y0 = prev_y;
y1 = y;
}
for (int ly = y0; ly < y1; ++ly) {
im.set_pixel(x, ly, line_color);
}
}
prev_y = y;
}
im.unlock();
Ref<ImageTexture> ptex = Ref<ImageTexture>(memnew(ImageTexture));
ptex->create_from_image(img_ref, 0);
return ptex;
}
void Plotter2DDisplay::drawPlot()
{
QColor fg_color(fg_color_);
QColor bg_color(bg_color_);
fg_color.setAlpha(fg_alpha_);
bg_color.setAlpha(bg_alpha_);
if (auto_color_change_) {
double r
= std::min(std::max((buffer_[buffer_.size() - 1] - min_value_) / (max_value_ - min_value_),
0.0), 1.0);
if (r > 0.3) {
double r2 = (r - 0.3) / 0.7;
fg_color.setRed((max_color_.red() - fg_color_.red()) * r2
+ fg_color_.red());
fg_color.setGreen((max_color_.green() - fg_color_.green()) * r2
+ fg_color_.green());
fg_color.setBlue((max_color_.blue() - fg_color_.blue()) * r2
+ fg_color_.blue());
}
}
{
ScopedPixelBuffer buffer = overlay_->getBuffer();
QImage Hud = buffer.getQImage(*overlay_);
// initilize by the background color
for (int i = 0; i < overlay_->getTextureWidth(); i++) {
for (int j = 0; j < overlay_->getTextureHeight(); j++) {
Hud.setPixel(i, j, bg_color.rgba());
}
}
// paste in HUD speedometer. I resize the image and offset it by 8 pixels from
// the bottom left edge of the render window
QPainter painter( &Hud );
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setPen(QPen(fg_color, line_width_, Qt::SolidLine));
uint16_t w = overlay_->getTextureWidth();
uint16_t h = overlay_->getTextureHeight() - caption_offset_;
double margined_max_value = max_value_ + (max_value_ - min_value_) / 2;
double margined_min_value = min_value_ - (max_value_ - min_value_) / 2;
for (size_t i = 1; i < buffer_length_; i++) {
double v_prev = (margined_max_value - buffer_[i - 1]) / (margined_max_value - margined_min_value);
double v = (margined_max_value - buffer_[i]) / (margined_max_value - margined_min_value);
double u_prev = (i - 1) / (float)buffer_length_;
double u = i / (float)buffer_length_;
// chop within 0 ~ 1
v_prev = std::max(std::min(v_prev, 1.0), 0.0);
u_prev = std::max(std::min(u_prev, 1.0), 0.0);
v = std::max(std::min(v, 1.0), 0.0);
u = std::max(std::min(u, 1.0), 0.0);
uint16_t x_prev = (int)(u_prev * w);
uint16_t x = (int)(u * w);
uint16_t y_prev = (int)(v_prev * h);
uint16_t y = (int)(v * h);
painter.drawLine(x_prev, y_prev, x, y);
}
// draw border
if (show_border_) {
painter.drawLine(0, 0, 0, h);
painter.drawLine(0, h, w, h);
painter.drawLine(w, h, w, 0);
painter.drawLine(w, 0, 0, 0);
}
// draw caption
if (show_caption_) {
QFont font = painter.font();
font.setPointSize(text_size_);
font.setBold(true);
painter.setFont(font);
painter.drawText(0, h, w, caption_offset_,
Qt::AlignCenter | Qt::AlignVCenter,
getName());
}
if (show_value_) {
QFont font = painter.font();
font.setPointSize(w / 4);
font.setBold(true);
painter.setFont(font);
std::ostringstream ss;
ss << std::fixed << std::setprecision(2) << buffer_[buffer_.size() - 1];
painter.drawText(0, 0, w, h,
Qt::AlignCenter | Qt::AlignVCenter,
ss.str().c_str());
}
// done
painter.end();
}
}
