mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-11-26 01:20:25 +00:00
166 lines
8.3 KiB
C++
166 lines
8.3 KiB
C++
/*
|
|
* Copyright (c) 2022, kleines Filmröllchen <filmroellchen@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "VectorscopeWidget.h"
|
|
#include "Layer.h"
|
|
#include <AK/Math.h>
|
|
#include <AK/Types.h>
|
|
#include <LibGUI/Event.h>
|
|
#include <LibGUI/Painter.h>
|
|
#include <LibGUI/Widget.h>
|
|
#include <LibGfx/AntiAliasingPainter.h>
|
|
#include <LibGfx/Bitmap.h>
|
|
#include <LibGfx/Palette.h>
|
|
#include <LibGfx/SystemTheme.h>
|
|
#include <LibGfx/TextAlignment.h>
|
|
#include <LibGfx/TextElision.h>
|
|
|
|
REGISTER_WIDGET(PixelPaint, VectorscopeWidget);
|
|
|
|
namespace PixelPaint {
|
|
|
|
void VectorscopeWidget::image_changed()
|
|
{
|
|
(void)rebuild_vectorscope_data();
|
|
rebuild_vectorscope_image();
|
|
update();
|
|
}
|
|
|
|
ErrorOr<void> VectorscopeWidget::rebuild_vectorscope_data()
|
|
{
|
|
if (!m_image)
|
|
return {};
|
|
|
|
m_vectorscope_data.fill({});
|
|
VERIFY(AK::abs(m_vectorscope_data[0][0]) < 0.01f);
|
|
auto full_bitmap = TRY(m_image->compose_bitmap(Gfx::BitmapFormat::BGRA8888));
|
|
|
|
for (size_t x = 0; x < static_cast<size_t>(full_bitmap->width()); ++x) {
|
|
for (size_t y = 0; y < static_cast<size_t>(full_bitmap->height()); ++y) {
|
|
auto yuv = full_bitmap->get_pixel(x, y).to_yuv();
|
|
auto u_index = u_v_to_index(yuv.u);
|
|
auto v_index = u_v_to_index(yuv.v);
|
|
m_vectorscope_data[u_index][v_index]++;
|
|
}
|
|
}
|
|
|
|
auto maximum = full_bitmap->width() * full_bitmap->height() * pixel_percentage_for_max_brightness * pixel_percentage_for_max_brightness;
|
|
|
|
for (size_t i = 0; i < m_vectorscope_data.size(); ++i) {
|
|
for (size_t j = 0; j < m_vectorscope_data[i].size(); ++j) {
|
|
m_vectorscope_data[i][j] = AK::sqrt(m_vectorscope_data[i][j]) / maximum;
|
|
}
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
void VectorscopeWidget::rebuild_vectorscope_image()
|
|
{
|
|
m_vectorscope_image = MUST(Gfx::Bitmap::create(Gfx::BitmapFormat::BGRA8888, size()));
|
|
m_vectorscope_image->fill(Color::Transparent);
|
|
|
|
Gfx::Painter base_painter(*m_vectorscope_image);
|
|
Gfx::AntiAliasingPainter painter(base_painter);
|
|
|
|
auto const scope_size = min(height(), width());
|
|
auto const min_scope_size = parent_widget()->min_height().as_int();
|
|
auto const color_vector_scale = scope_size / static_cast<float>(min_scope_size);
|
|
auto const size_1x1 = Gfx::FloatSize { 2.5f, 2.5f } * static_cast<float>(color_vector_scale);
|
|
|
|
base_painter.translate(width() / 2, height() / 2);
|
|
painter.translate(static_cast<float>(width()) / 2.0f, static_cast<float>(height()) / 2.0f);
|
|
for (size_t u_index = 0; u_index < u_v_steps; ++u_index) {
|
|
for (size_t v_index = 0; v_index < u_v_steps; ++v_index) {
|
|
auto const color_vector = ColorVector::from_indices(u_index, v_index);
|
|
auto const brightness = m_vectorscope_data[u_index][v_index];
|
|
if (brightness < 0.0001f)
|
|
continue;
|
|
auto const pseudo_rect = Gfx::FloatRect::centered_at(color_vector.to_vector(scope_size) * 2.0f, size_1x1);
|
|
auto color = Color::from_yuv(0.6f, color_vector.u, color_vector.v);
|
|
color = color.saturated_to(1.0f - min(brightness, 1.0f));
|
|
color.set_alpha(static_cast<u8>(min(AK::sqrt(brightness), alpha_range) * NumericLimits<u8>::max() / alpha_range));
|
|
painter.fill_rect(pseudo_rect, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
void VectorscopeWidget::paint_event(GUI::PaintEvent& event)
|
|
{
|
|
GUI::Painter base_painter(*this);
|
|
Gfx::AntiAliasingPainter painter(base_painter);
|
|
base_painter.add_clip_rect(event.rect());
|
|
// From this point on we're working with 0,0 as the scope center to make things easier.
|
|
base_painter.translate(width() / 2, height() / 2);
|
|
painter.translate(static_cast<float>(width()) / 2.0f, static_cast<float>(height()) / 2.0f);
|
|
|
|
auto const graticule_color = Color::White;
|
|
auto const scope_size = min(height(), width());
|
|
auto const graticule_size = scope_size / 6;
|
|
auto const graticule_thickness = graticule_size / 12;
|
|
auto const entire_scope_rect = Gfx::FloatRect::centered_at({ 0, 0 }, { scope_size, scope_size });
|
|
|
|
painter.fill_ellipse(entire_scope_rect.to_rounded<int>().shrunken(graticule_thickness * 2, graticule_thickness * 2), Color::Black);
|
|
|
|
// Main scope data
|
|
if (m_image) {
|
|
if (m_vectorscope_image->size() != this->size())
|
|
rebuild_vectorscope_image();
|
|
|
|
base_painter.blit({ -width() / 2, -height() / 2 }, *m_vectorscope_image, m_vectorscope_image->rect());
|
|
}
|
|
|
|
// Graticule(s)
|
|
painter.draw_ellipse(entire_scope_rect.to_rounded<int>(), graticule_color, graticule_thickness);
|
|
|
|
// FIXME: Translation calls to the painters don't appear to work correctly, and I figured out a combination of calls through trial and error that do what I want, but I don't know how they do that.
|
|
// Translation does work correctly with things like rectangle and text drawing, so it's very strange.
|
|
painter.translate(-static_cast<float>(width()) / 2.0f, -static_cast<float>(height()) / 2.0f);
|
|
// We intentionally draw the skin tone line much further than the actual color we're using for it.
|
|
painter.draw_line({ 0, 0 }, skin_tone_color.to_vector(scope_size) * 2.0, graticule_color);
|
|
painter.translate(-static_cast<float>(width()) / 2.0f, -static_cast<float>(height()) / 2.0f);
|
|
|
|
for (auto const& primary_color : primary_colors) {
|
|
auto center = primary_color.to_vector(scope_size);
|
|
auto center_rounded = center.to_rounded<int>();
|
|
// Box color
|
|
Gfx::Color corner_color = Gfx::Color::from_yuv(0.5f, primary_color.u, primary_color.v).saturated_to(0.5);
|
|
|
|
// Bracket vertex calculations
|
|
int left_outer_vertex = center_rounded.x() - graticule_size / 2;
|
|
int right_outer_vertex = center_rounded.x() + graticule_size / 2;
|
|
int top_outer_vertex = center_rounded.y() - graticule_size / 2;
|
|
int bottom_outer_vertex = center_rounded.y() + graticule_size / 2;
|
|
int left_inner_vertex = center_rounded.x() - graticule_size / 3;
|
|
int right_inner_vertex = center_rounded.x() + graticule_size / 3;
|
|
int top_inner_vertex = center_rounded.y() - graticule_size / 3;
|
|
int bottom_inner_vertex = center_rounded.y() + graticule_size / 3;
|
|
|
|
// Top Left Corner
|
|
base_painter.draw_line(Gfx::IntPoint(left_outer_vertex, top_outer_vertex), Gfx::IntPoint(left_inner_vertex, top_outer_vertex), corner_color, graticule_thickness);
|
|
base_painter.draw_line(Gfx::IntPoint(left_outer_vertex, top_outer_vertex), Gfx::IntPoint(left_outer_vertex, top_inner_vertex), corner_color, graticule_thickness);
|
|
// Top Right Corner
|
|
base_painter.draw_line(Gfx::IntPoint(right_outer_vertex, top_outer_vertex), Gfx::IntPoint(right_inner_vertex, top_outer_vertex), corner_color, graticule_thickness);
|
|
base_painter.draw_line(Gfx::IntPoint(right_outer_vertex, top_outer_vertex), Gfx::IntPoint(right_outer_vertex, top_inner_vertex), corner_color, graticule_thickness);
|
|
// Bottom Left Corner
|
|
base_painter.draw_line(Gfx::IntPoint(left_outer_vertex, bottom_outer_vertex), Gfx::IntPoint(left_inner_vertex, center_rounded.y() + graticule_size / 2), corner_color, graticule_thickness);
|
|
base_painter.draw_line(Gfx::IntPoint(left_outer_vertex, center_rounded.y() + graticule_size / 2), Gfx::IntPoint(left_outer_vertex, bottom_inner_vertex), corner_color, graticule_thickness);
|
|
// Bottom Right Corner
|
|
base_painter.draw_line(Gfx::IntPoint(right_outer_vertex, center_rounded.y() + graticule_size / 2), Gfx::IntPoint(right_inner_vertex, center_rounded.y() + graticule_size / 2), corner_color, graticule_thickness);
|
|
base_painter.draw_line(Gfx::IntPoint(right_outer_vertex, center_rounded.y() + graticule_size / 2), Gfx::IntPoint(right_outer_vertex, bottom_inner_vertex), corner_color, graticule_thickness);
|
|
|
|
// Add text label to vectorscope
|
|
auto text_rect = Gfx::FloatRect::centered_at(center, { graticule_size, graticule_size }).to_rounded<int>().translated(-(graticule_thickness + 1), -(graticule_thickness + 1));
|
|
base_painter.draw_text(text_rect, StringView { &primary_color.symbol, 1 }, Gfx::TextAlignment::BottomRight, graticule_color);
|
|
}
|
|
|
|
if (m_color_at_mouseposition != Color::Transparent) {
|
|
auto color_vector = ColorVector { m_color_at_mouseposition };
|
|
painter.draw_ellipse(Gfx::FloatRect::centered_at(color_vector.to_vector(scope_size) * 2.0, { graticule_size, graticule_size }).to_rounded<int>(), graticule_color, graticule_thickness);
|
|
}
|
|
}
|
|
|
|
}
|