Pixel HueSaturationMixer::getPixel( const Im::Position& pos, unsigned char val ) const { ColourVector hs; RGBWeight rgb_weights; convert_xy_tone_to_hue_sat ( colours(pos).x(), colours(pos).y(), hs[0], hs[1] ); rgb_weights_from_hue_saturation( hs[0], hs[1], rgb_weights ); return Pixel( val * rgb_weights ); }
void HueSaturationMixer::merge_tone( const Im::Position& pos, float old_data_weight, float new_data_weight ) { assert( colours.contains( pos ) ); if ( old_data_weight < 1E-3 ) { colours(pos) = tone_point; DEBUG("Used tone point " << colours(pos).transpose() << " for new point"); } else { colours(pos) = ( colours(pos) * old_data_weight + tone_point * new_data_weight ) / ( old_data_weight + new_data_weight ); DEBUG("Merged tone point " << colours(pos).transpose() << " from " << tone_point << " for new point"); } }
mesh_object::mesh_object(const std::shared_ptr<mesh_shader>& shader, const glm::vec3* positions, size_t num_positions) : shader_{shader} { std::vector<GLuint> indices(num_positions); std::iota(indices.begin(), indices.end(), 0); ibo.data(indices); geometry_.data(positions, num_positions); { std::vector<float> colours(num_positions, 0.0f); set_pressures(colours.data(), colours.size()); } // init vao const auto s_vao = vao_.get_scoped(); mglu::enable_and_bind_buffer(vao_, geometry_, shader->get_attrib_location_v_position(), 3, GL_FLOAT); mglu::enable_and_bind_buffer(vao_, pressures_, shader->get_attrib_location_v_pressure(), 1, GL_FLOAT); ibo.bind(); }
/************************************************************************* Perform the actual rendering for this Window. *************************************************************************/ void Static::populateRenderCache() { Rect backgroundRect(Point(0,0), getAbsoluteSize()); // draw frame if (d_frameEnabled) { d_frame.draw(d_renderCache); // adjust destination area for backfrop image. backgroundRect.d_left += d_left_width; backgroundRect.d_right -= d_right_width; backgroundRect.d_top += d_top_height; backgroundRect.d_bottom -= d_bottom_height; } // draw backdrop if (d_backgroundEnabled && (d_background != NULL)) { // factor window alpha into colours to use when rendering background ColourRect colours(d_backgroundCols); colours.modulateAlpha(getEffectiveAlpha()); // cache image for drawing d_renderCache.cacheImage(*d_background, backgroundRect, 0, colours); } }
void FalagardCheckButton::drawCheck() { ColourRect colours(d_selectImage.getColours()); colours.setAlpha(getEffectiveAlpha()); d_selectImage.setColours(colours); d_selectImage.draw(d_renderCache); }
void FrameWindow::populateRenderCache() { Rect unclipped_rect = getUnclippedPixelRect(); Rect rect(Point(0.0f, 0.0f), Size(unclipped_rect.getWidth(), unclipped_rect.getHeight())); ColourRect colours(Colour(1.0f, 1.0f, 1.0f, getEffectiveAlpha())); if (d_section_images[TopLeft]) d_renderCache.cacheImage(*d_section_images[TopLeft], Rect(Point(0.0f, 0.0f), Size(d_width_left, d_height_top)), colours); if (d_section_images[TopMiddle]) d_renderCache.cacheImage(*d_section_images[TopMiddle], Rect(Point(d_width_left, 0.0f), Size(d_width_middle, d_height_top)), colours); if (d_section_images[TopRight]) d_renderCache.cacheImage(*d_section_images[TopRight], Rect(Point(d_width_left + d_width_middle, 0.0f), Size(d_width_right, d_height_top)), colours); if (d_section_images[MiddleLeft]) d_renderCache.cacheImage(*d_section_images[MiddleLeft], Rect(Point(0.0f, d_height_top), Size(d_width_left, d_height_middle)), colours); if (d_section_images[MiddleMiddle]) d_renderCache.cacheImage(*d_section_images[MiddleMiddle], Rect(Point(d_width_left, d_height_top), Size(d_width_middle, d_height_middle)), colours); if (d_section_images[MiddleRight]) d_renderCache.cacheImage(*d_section_images[MiddleRight], Rect(Point(d_width_left + d_width_middle, d_height_top), Size(d_width_right, d_height_middle)), colours); if (d_section_images[BottomLeft]) d_renderCache.cacheImage(*d_section_images[BottomLeft], Rect(Point(0.0f, d_height_top + d_height_middle), Size(d_width_left, d_height_bottom)), colours); if (d_section_images[BottomMiddle]) d_renderCache.cacheImage(*d_section_images[BottomMiddle], Rect(Point(d_width_left, d_height_top + d_height_middle), Size(d_width_middle, d_height_bottom)), colours); if (d_section_images[BottomRight]) d_renderCache.cacheImage(*d_section_images[BottomRight], Rect(Point(d_width_left + d_width_middle, d_height_top + d_height_middle), Size(d_width_right, d_height_bottom)), colours); }
void FalagardAnimate::drawNormal(float z) { if( m_bPlay ) { ColourRect colours(d_normalImage.getColours()); colours.setAlpha(getEffectiveAlpha() * m_fAlpha ); d_normalImage.setColours(colours); d_normalImage.draw(d_renderCache); } }
static void prompt(const char *p, struct ship *ship) { static char buf[60]; if (ship != NULL) { printf(buf, p, ship->shipname, colours(ship), sterncolour(ship)); p = buf; } sc_prompt = p; sc_buf = ""; sc_hasprompt = 1; waddstr(scroll_w, p); }
void draw_board(void) { int n; clear(); werase(view_w); werase(slot_w); werase(scroll_w); werase(stat_w); werase(turn_w); sc_line = 0; move(BOX_T, BOX_L); for (n = 0; n < BOX_X; n++) addch('-'); move(BOX_B, BOX_L); for (n = 0; n < BOX_X; n++) addch('-'); for (n = BOX_T+1; n < BOX_B; n++) { mvaddch(n, BOX_L, '|'); mvaddch(n, BOX_R, '|'); } mvaddch(BOX_T, BOX_L, '+'); mvaddch(BOX_T, BOX_R, '+'); mvaddch(BOX_B, BOX_L, '+'); mvaddch(BOX_B, BOX_R, '+'); refresh(); #define WSaIM "Wooden Ships & Iron Men" wmove(view_w, 2, (VIEW_X - sizeof WSaIM - 1) / 2); waddstr(view_w, WSaIM); wmove(view_w, 4, (VIEW_X - strlen(cc->name)) / 2); waddstr(view_w, cc->name); wrefresh(view_w); move(LINE_T, LINE_L); printw("Class %d %s (%d guns) '%s' (%c%c)", mc->class, classname[mc->class], mc->guns, ms->shipname, colours(ms), sterncolour(ms)); refresh(); }
void GMExperiment6_1::displaySmoothData() { // draw Bezier curve bool colourise = true; auto colour = makeVector4f(0, 1.0, 0, 1); vector<Vector4f> colours(smoothData.size()); float min_curv = *std::min_element(curvature.begin(), curvature.end()); float max_curv = *std::max_element(curvature.begin(), curvature.end()); float max_mag = std::max(fabs(min_curv), fabs(max_curv)); max_mag = 10; for(int i = 0; i < smoothData.size(); ++i) colours[i] = colourise ? getColor(curvature[i], -max_mag, max_mag) : colour; displayData(smoothData, colours); }
void Compress( u8 const* rgba, void* block, int flags ) { // fix any bad flags flags = FixFlags( flags ); // get the block locations void* colourBlock = block; void* alphaBock = block; if( ( flags & ( kDxt3 | kDxt5 ) ) != 0 ) colourBlock = reinterpret_cast< u8* >( block ) + 8; // create the minimal point set ColourSet colours( rgba, flags ); // check the compression type and compress colour if( colours.GetCount() == 1 ) { // always do a single colour fit SingleColourFit fit; fit.SetColourSet( &colours, flags ); fit.Compress( colourBlock ); } else if( ( flags & kColourRangeFit ) != 0 ) { // do a range fit RangeFit fit; fit.SetColourSet( &colours, flags ); fit.Compress( colourBlock ); } else { // default to a cluster fit ClusterFit fit; fit.SetColourSet( &colours, flags ); fit.SetMetric( 1.0f, 1.0f, 1.0f ); fit.Compress( colourBlock ); } // compress alpha separately if necessary if( ( flags & kDxt3 ) != 0 ) CompressAlphaDxt3( rgba, alphaBock ); else if( ( flags & kDxt5 ) != 0 ) CompressAlphaDxt5( rgba, alphaBock ); }
cv::Mat Visualize::mapGeneration(cv::Mat image, std::vector <int> label, std::vector <Matrix_double> distances, std::string colourNameFloor, std::string colourNameObstacle) { std::vector<double> floor=colour(colourNameFloor); // obtain colour parameters of input name std::vector<double> obstacle=colour(colourNameObstacle); // obtain colour parameters of input name /* Perform map reconstruction * The system asumes that each pixel of image represents a square of evironment of 5cm width and 5cm height * */ #pragma omp parallel { #pragma omp for shared (image, label) private (i, j) reduction(+: sum) { for (int i=0; i<label.size(); i++) { //If the pixel is located in a safe zone (in a distance between 0 an 40m in absolute value) print the pixel if (distances[i].columns[0]!=-999999 && distances[i].columns[1]!=-999999) { int x_aux1=600-abs(distances[i].columns[1])*100/5; int y_aux1=200+(distances[i].columns[0])*100/5; std::vector <double> colours (3,0); if (label[i]==1) colours=floor; else colours=obstacle; for (int j=x_aux1; j<=x_aux1+40; j++) { image.at<cv::Vec3b>(j,y_aux1)[3] = colours[2]; image.at<cv::Vec3b>(j,y_aux1)[2] = colours[0]; image.at<cv::Vec3b>(j,y_aux1)[1] = colours[1]; } } } } } return image; }
std::vector<Matrix_double> ExtractColour::indexPCD2VectorRGB(pcl::PointCloud<pcl::PointXYZRGBA> cloud, std::vector<int> index) { std::vector <Matrix_double> colours(index.size()); pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr cloudPtr (new pcl::PointCloud<pcl::PointXYZRGBA> (cloud)); #pragma omp parallel { #pragma omp for shared (colours, index) private (i) reduction(+: sum) { for (int i=0; i<index.size(); i++) { colours[i].columns.push_back(cloudPtr->points[index[i]].r); // save R parameter colours[i].columns.push_back(cloudPtr->points[index[i]].g); // save G parameter colours[i].columns.push_back(cloudPtr->points[index[i]].b); // save B parameter } } } return colours; }
void draw_view(void) { struct ship *sp; werase(view_w); foreachship(sp) { if (sp->file->dir && sp->file->row > viewrow && sp->file->row < viewrow + VIEW_Y && sp->file->col > viewcol && sp->file->col < viewcol + VIEW_X) { wmove(view_w, sp->file->row - viewrow, sp->file->col - viewcol); waddch(view_w, colours(sp)); wmove(view_w, sternrow(sp) - viewrow, sterncol(sp) - viewcol); waddch(view_w, sterncolour(sp)); } } wrefresh(view_w); }
std::vector<Matrix_double> ExtractColour::indexPCD2VectorLab(pcl::PointCloud<pcl::PointXYZRGBA> cloud, std::vector<int> index) { std::vector <Matrix_double> colours(3); pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr cloudPtr (new pcl::PointCloud<pcl::PointXYZRGBA> (cloud)); Conversion conversion; #pragma omp parallel { #pragma omp for shared (cloud, index, colours) private (i) reduction(+: sum) { for (int i=0; i<index.size(); i++) { std::vector<int> lab=conversion.rgb2lab(cloudPtr->points[index[i]].r,cloudPtr->points[index[i]].g,cloudPtr->points[index[i]].b); // perform RGB to Lab conversion colours[i].columns.push_back(lab[0]); // save L parameter colours[i].columns.push_back(lab[1]); // save a parameter colours[i].columns.push_back(lab[2]); // save b parameter } } } return colours; }
std::vector <double> Visualize::colour (std::string colour) { std::vector <double> colours(3); // select colour name string and return RGB values if (colour=="black") { colours[0]=0; colours[1]=0; colours[2]=0; } else { if (colour=="white") { colours[0]=255; colours[1]=255; colours[2]=255; } else { if (colour=="red") { colours[0]=255; colours[1]=0; colours[2]=0; } else { if (colour=="green") { colours[0]=0; colours[1]=255; colours[2]=0; } else { if (colour=="blue") { colours[0]=0; colours[1]=0; colours[2]=255; } else { if (colour=="yellow") { colours[0]=255; colours[1]=255; colours[2]=0; } else { if (colour=="cyan") { colours[0]=0; colours[1]=255; colours[2]=255; } else { if (colour=="magenta") { colours[0]=255; colours[1]=0; colours[2]=255; } } } } } } } } return colours; }
bool playlist_view::draw_items(HDC dc, int start_item, int count) { // profiler(draw_items); if (!drawing_enabled) return false; static_api_ptr_t<playlist_manager> playlist_api; HDC hdc_mem = 0; RECT rect, item, item_area, bk, draw/*,text*/; GetClientRect(wnd_playlist, &rect); rect.top += get_header_height(); int item_height = get_item_height(); HBRUSH br = 0; HBITMAP hbm_mem = 0, hbm_old = 0; pfc::array_t<int, pfc::alloc_fast_aggressive> widths; int total_width = get_column_widths(widths); int t = columns.get_count(); const bit_array & p_mask = g_cache.active_get_columns_mask(); item_area.left = rect.left; item_area.right = rect.right; item_area.top = rect.top + (item_height*start_item); item_area.bottom = item_area.top + (item_height*count); item.left = 0 - horizontal_offset; item.right = item.left + total_width; item.top = 0; item.bottom = item.top + item_height; bk.top = 0; bk.left = 0; bk.bottom = item_height*count; bk.right = rect.right - rect.left; /*static */pfc::string8_fast_aggressive temp; temp.prealloc(512); /* edit01 */ hdc_mem = CreateCompatibleDC(dc); COLORREF colourfore = 0xff; hbm_mem = CreateCompatibleBitmap(dc, rect.right - rect.left, item_height*count); hbm_old = (HBITMAP)SelectObject(hdc_mem, hbm_mem); HGDIOBJ font_old = SelectObject(hdc_mem, g_font); cui::colours::helper p_helper(appearance_client_pv_impl::g_guid); //fill entire area with back colour br = CreateSolidBrush(p_helper.get_colour(cui::colours::colour_background)); FillRect(hdc_mem, &bk, br); DeleteObject(br); //need checks here because of filling background { int total = playlist_api->activeplaylist_get_item_count(); if (start_item + count + scroll_item_offset > total) //end item is NOT inclusive { count -= (start_item + count + scroll_item_offset) - total; } } int end_item = start_item + count; //draw each item int n, focus = playlist_api->activeplaylist_get_focus_item(); // static int pcount; t_size playing_index, playing_playlist; playlist_api->get_playing_item_location(&playing_playlist, &playing_index); bool b_playback = static_api_ptr_t<play_control>()->is_playing(); if (g_cache.get_active_playlist() != playing_playlist) playing_index = pfc_infinite; for (n = start_item; n < end_item; n++) { bool sel = playlist_api->activeplaylist_is_item_selected(n + scroll_item_offset); bool b_focused = GetFocus() == wnd_playlist || IsChild(wnd_playlist, GetFocus()); bool b_playing = b_playback && playing_index == (n + scroll_item_offset); //draw each column of each item int theme_state = NULL; if (sel) theme_state = (b_playing ? LISS_HOTSELECTED : (b_focused ? LISS_SELECTED : LISS_SELECTEDNOTFOCUS)); else if (b_playing) theme_state = LISS_HOT; bool b_themed = m_theme && p_helper.get_themed() && IsThemePartDefined(m_theme, LVP_LISTITEM, theme_state); if (b_themed && theme_state) { if (IsThemeBackgroundPartiallyTransparent(m_theme, LVP_LISTITEM, theme_state)) DrawThemeParentBackground(get_wnd(), hdc_mem, &item); DrawThemeBackground(m_theme, hdc_mem, LVP_LISTITEM, theme_state, &item, NULL); } //int total = playlist_api->activeplaylist_get_item_count(); int c, offset = 0, i = 0; for (c = 0; c < t; c++) { if (p_mask[c]) { draw.left = item.left + offset; draw.top = item.top; offset += widths[i]; draw.right = item.left + offset; draw.bottom = item.bottom; { // profiler_debug(draw_item_get_string); g_cache.active_get_display_name(n + scroll_item_offset, i, temp); } colourinfo colours(0x000000, 0x000000, 0xFF, 0xFF, 0, 0xFF); g_cache.active_get_colour(n + scroll_item_offset, i, colours); if (b_themed) { //COLORREF cr_back= get_default_colour(colours::COLOUR_BACK); //colourfore = get_default_colour(colours::COLOUR_TEXT); //GetThemeColor(m_theme, LVP_LISTITEM, sel ? (GetFocus() == wnd_playlist ? LIS_SELECTED : LIS_SELECTEDNOTFOCUS) : LIS_NORMAL, TMT_WINDOWTEXT, &colourfore); colourfore = GetThemeSysColor(m_theme, sel ? COLOR_BTNTEXT : COLOR_WINDOWTEXT); //GetThemeColor(m_theme, LVP_LISTITEM, sel ? (GetFocus() == wnd_playlist ? LIS_SELECTED : LIS_SELECTEDNOTFOCUS) : LIS_NORMAL, TMT_TEXTCOLOR, &colourfore); if (!theme_state) { //GetThemeColor(m_theme, LVP_LISTITEM, LIS_NORMAL, TMT_FILLCOLOR, &colourfore); br = CreateSolidBrush(colours.background_colour); FillRect(hdc_mem, &draw, br); } } else { if (sel) { /* TEST */ if (GetFocus() == wnd_playlist) { colourfore = colours.selected_text_colour; br = CreateSolidBrush(colours.selected_background_colour); } else { colourfore = colours.selected_text_colour_non_focus; br = CreateSolidBrush(colours.selected_background_colour_non_focus); } } else { colourfore = colours.text_colour; br = CreateSolidBrush(colours.background_colour); } //draw cell background //if (!b_themed) FillRect(hdc_mem, &draw, br); } if (br) { DeleteObject(br); br = 0; } //render text //if (b_themed) // DrawThemeText(m_theme, hdc_mem, LVP_LISTITEM, sel ? (GetFocus() == wnd_playlist ? LIS_SELECTED : LIS_SELECTEDNOTFOCUS) : LIS_NORMAL, L"test", 4, 0, 0, &draw); //else ui_helpers::text_out_colours_tab(hdc_mem, temp, temp.length(), 2, 1, &draw, sel, colourfore, TRUE, true, (cfg_ellipsis != 0), (ui_helpers::alignment)columns[c]->align); if (colours.use_frame_left) { HPEN pen = CreatePen(PS_SOLID, 1, colours.frame_left); HPEN pen_old = (HPEN)SelectObject(hdc_mem, pen); MoveToEx(hdc_mem, draw.left, draw.top, 0); LineTo(hdc_mem, draw.left, draw.bottom); SelectObject(hdc_mem, pen_old); DeleteObject(pen); } if (colours.use_frame_top) { HPEN pen = CreatePen(PS_SOLID, 1, colours.frame_top); HPEN pen_old = (HPEN)SelectObject(hdc_mem, pen); MoveToEx(hdc_mem, draw.left, draw.top, 0); LineTo(hdc_mem, draw.right, draw.top); SelectObject(hdc_mem, pen_old); DeleteObject(pen); } if (colours.use_frame_right) { HPEN pen = CreatePen(PS_SOLID, 1, colours.frame_right); HPEN pen_old = (HPEN)SelectObject(hdc_mem, pen); MoveToEx(hdc_mem, draw.right - 1, draw.top, 0); LineTo(hdc_mem, draw.right - 1, draw.bottom); SelectObject(hdc_mem, pen_old); DeleteObject(pen); } if (colours.use_frame_bottom) { HPEN pen = CreatePen(PS_SOLID, 1, colours.frame_bottom); HPEN pen_old = (HPEN)SelectObject(hdc_mem, pen); MoveToEx(hdc_mem, draw.right - 1, draw.bottom - 1, 0); LineTo(hdc_mem, draw.left - 1, draw.bottom - 1); SelectObject(hdc_mem, pen_old); DeleteObject(pen); } i++; } } //draw focus frame if ((n + scroll_item_offset) == focus) { if (m_always_show_focus || (!(SendMessage(get_wnd(), WM_QUERYUISTATE, NULL, NULL) & UISF_HIDEFOCUS) && b_focused)) { RECT rc_focus = item; if (m_theme && p_helper.get_themed() && IsThemePartDefined(m_theme, LVP_LISTITEM, LISS_SELECTED)) InflateRect(&rc_focus, -1, -1); if (!p_helper.get_bool(cui::colours::bool_use_custom_active_item_frame)) { DrawFocusRect(hdc_mem, &rc_focus); } else { br = CreateSolidBrush(p_helper.get_colour(cui::colours::colour_active_item_frame)); FrameRect(hdc_mem, &rc_focus, br); DeleteObject(br); } } } item.top += item_height; item.bottom += item_height; } BitBlt(dc, item_area.left, item_area.top, item_area.right - item_area.left, item_area.bottom - item_area.top, hdc_mem, 0, 0, SRCCOPY); if (font_old) SelectObject(hdc_mem, font_old); SelectObject(hdc_mem, hbm_old); DeleteObject(hbm_mem); DeleteDC(hdc_mem); return true; }