/* * WiVRn VR streaming * Copyright (C) 2024 Guillaume Meunier * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "rectangle_partitionner.h" #include #include #include #include #include #include #include #include #include #include #include namespace { const double split_edge_threshold = 0.05; const double move_edge_threshold = 0.02; const double magnetism_threshold = 0.05; const int num_subdiv = 20; const double epsilon = 1.0 / (2 * num_subdiv); enum class side { top, bottom, left, right }; struct edge { side edge_side; int rectangle_index; bool operator==(const edge & other) const noexcept { return edge_side == other.edge_side and rectangle_index == other.rectangle_index; } double position = 0; double min = std::numeric_limits::max(); double max = std::numeric_limits::lowest(); }; } // namespace struct rectangle_partitionner_private { std::vector selection; std::vector hovered; double min_drag_position; double max_drag_position; QLine split_line; enum class mouse_event_type { move, press, release }; }; namespace { int hovered_rectangle(QPointF position, std::vector rectangles) { int n = 0; for (const QRectF & i: rectangles) { if (i.contains(position)) return n; n++; } return -1; } Qt::CursorShape get_cursor_shape(QPointF position, std::vector rectangles) { for (QRectF & i: rectangles) { if (i.contains(position)) { QPointF rel_pos = position - i.topLeft(); double dx = std::min(rel_pos.x(), i.width() - rel_pos.x()); double dy = std::min(rel_pos.y(), i.height() - rel_pos.y()); if (dx < move_edge_threshold and position.x() >= epsilon and position.x() <= 1 - epsilon) return Qt::SizeHorCursor; else if (dy < move_edge_threshold and position.y() >= epsilon and position.y() <= 1 - epsilon) return Qt::SizeVerCursor; else if (dx < split_edge_threshold and position.y() >= epsilon and position.y() <= 1 - epsilon) return Qt::SplitVCursor; else if (dy < split_edge_threshold and position.x() >= epsilon and position.x() <= 1 - epsilon) return Qt::SplitHCursor; else return Qt::ArrowCursor; break; } } return Qt::ArrowCursor; } std::vector horizontal_edges(std::vector rectangles) { std::vector edges; for (int i = 0, n = rectangles.size(); i < n; i++) { if (rectangles[i].top() > epsilon) { edges.emplace_back(side::top, i, rectangles[i].top(), rectangles[i].left(), rectangles[i].right()); } if (rectangles[i].bottom() < 1 - epsilon) { edges.emplace_back(side::bottom, i, rectangles[i].bottom(), rectangles[i].left(), rectangles[i].right()); } } return edges; } std::vector vertical_edges(std::vector rectangles) { std::vector edges; for (int i = 0, n = rectangles.size(); i < n; i++) { if (rectangles[i].left() > epsilon) { edges.emplace_back(side::left, i, rectangles[i].left(), rectangles[i].top(), rectangles[i].bottom()); } if (rectangles[i].right() < 1 - epsilon) { edges.emplace_back(side::right, i, rectangles[i].right(), rectangles[i].top(), rectangles[i].bottom()); } } return edges; } std::vector> partition_edges(std::vector edges) { auto comp = [](const edge & a, const edge & b) { if (a.position < b.position) return true; if (a.position > b.position) return false; if (a.min < b.min) return true; if (a.min > b.min) return false; if (a.max < b.max) return true; return false; }; std::ranges::sort(edges, comp); std::vector> partitionned; double current_position = std::numeric_limits::lowest(); double current_max = 0; for (auto & e: edges) { if (e.position != current_position) { current_position = e.position; current_max = e.max; partitionned.push_back({e}); } else { if (e.min >= current_max) { // All the following edges will be after the last partition current_max = e.max; partitionned.push_back({e}); } else { // Add the edge to the current partition current_max = std::max(current_max, e.max); partitionned.back().push_back(e); } } } return partitionned; } std::vector hovered_edges(QPointF position, const std::vector> & partitionned_edges, bool horizontal) { if (horizontal) position = position.transposed(); for (const auto & edge_list: partitionned_edges) { for (const auto & edge: edge_list) { if (std::abs(position.x() - edge.position) < move_edge_threshold and position.y() >= edge.min and position.y() <= edge.max) { return edge_list; } } } return {}; } bool assert_rectangle_list_is_partition(const std::vector & rectangles) { return true; bool ok = true; QRectF bounding_box{0, 0, 1, 1}; for (const auto & i: rectangles) { if (i.width() < 0 or i.height() < 0) { qDebug() << "Invalid rectangle" << i; ok = false; } } std::vector rectangle_y_boundaries; for (auto & i: rectangles) { rectangle_y_boundaries.push_back(i.top()); rectangle_y_boundaries.push_back(i.bottom()); } // for (int y = bounding_box.top(); y < bounding_box.bottom(); ++y) for (double y: rectangle_y_boundaries) { if (y < bounding_box.top()) continue; if (y >= bounding_box.bottom()) continue; qDebug() << "Checking line" << y; std::vector> horizontal_segments; for (const auto & i: rectangles) { if (y >= i.top() and y < i.bottom()) { horizontal_segments.emplace_back(i.left(), i.right()); qDebug() << " Adding segment" << i.left() << "-" << i.right(); } } std::ranges::sort(horizontal_segments); if (horizontal_segments.empty()) { qDebug() << "Line" << y << "empty"; ok = false; } if (horizontal_segments.front().first != bounding_box.left()) { qDebug() << "Line" << y << "does not start at the left of the bounding box" << (horizontal_segments.front().first - bounding_box.left()); ok = false; } if (horizontal_segments.back().second != bounding_box.right()) { qDebug() << "Last rectangle of line" << y << "does not end at the right of the bounding box" << (horizontal_segments.back().second - bounding_box.right()); ok = false; } for (int i = 1; i < horizontal_segments.size(); ++i) { if (horizontal_segments[i - 1].second < horizontal_segments[i].first) { qDebug() << "Overlap in line" << y << (horizontal_segments[i - 1].second - horizontal_segments[i].first); ok = false; } else if (horizontal_segments[i - 1].second > horizontal_segments[i].first) { qDebug() << "Gap in line" << y << (horizontal_segments[i - 1].second - horizontal_segments[i].first); ok = false; } } } if (!ok) { qDebug() << "Bounding box:" << bounding_box; int n = 1; for (auto & i: rectangles) { qDebug() << "Rectangle" << (n++) << ":" << i.topLeft() << "-" << i.bottomRight(); } } return ok; } } // namespace rectangle_partitionner::rectangle_partitionner(QWidget * parent) : QFrame(parent) { p = new rectangle_partitionner_private; setMouseTracking(true); std::vector encoders; encoders.push_back(QRectF{0, 0, 1, 1}); set_rectangles(encoders); m_paint = [](QPainter & painter, QRect rect, const QVariant & data, int index, bool selected) { if (selected) { painter.fillRect(rect.adjusted(1, 1, 0, 0), QColorConstants::Cyan); } QString text = QString("%1").arg(index + 1); painter.drawText(rect, Qt::AlignCenter, text); }; } rectangle_partitionner::~rectangle_partitionner() { delete p; } void rectangle_partitionner::paintEvent(QPaintEvent * event) { QFrame::paintEvent(event); QPainter painter(this); auto positions = rectangles_position(); { QList lines; for (int i = 1; i < num_subdiv; i++) { QPoint p1 = to_position({0, double(i) / num_subdiv}); QPoint p2 = to_position({1, double(i) / num_subdiv}); lines.emplace_back(p1, p2); QPoint p3 = to_position({double(i) / num_subdiv, 0}); QPoint p4 = to_position({double(i) / num_subdiv, 1}); lines.emplace_back(p3, p4); } QPen pen = painter.pen(); painter.setPen(QPen(Qt::lightGray, 1, Qt::SolidLine)); painter.drawLines(lines); painter.setPen(pen); } if (m_paint) { int n = 0; for (QRect & i: positions) { painter.drawRect(i); bool is_selected = n == m_selected_index and isEnabled(); m_paint(painter, i, m_rectangles_data.at(n), n, is_selected); n++; } } if (not p->hovered.empty() and p->selection.empty()) { painter.setPen(QPen(Qt::blue, 3, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin)); auto r = frameRect(); r.adjust(frameWidth(), frameWidth(), -2 * frameWidth(), -2 * frameWidth()); QList lines; lines.reserve(p->hovered.size()); for (const edge & i: p->hovered) { QLineF line; switch (i.edge_side) { case side::top: case side::bottom: line = QLineF(i.min, i.position, i.max, i.position); break; case side::left: case side::right: line = QLineF(i.position, i.min, i.position, i.max); break; } int x1 = std::round(r.x() + line.x1() * (r.width() - 1)); int x2 = std::round(r.x() + line.x2() * (r.width() - 1)); int y1 = std::round(r.y() + line.y1() * (r.height() - 1)); int y2 = std::round(r.y() + line.y2() * (r.height() - 1)); lines.emplace_back(x1, y1, x2, y2); } painter.drawLines(lines); auto horz_partitionned = partition_edges(horizontal_edges(m_rectangles)); auto vert_partitionned = partition_edges(vertical_edges(m_rectangles)); } else if ((cursor() == Qt::SplitHCursor or cursor() == Qt::SplitVCursor) and not p->split_line.isNull()) { auto now = std::chrono::duration_cast>(std::chrono::steady_clock::now().time_since_epoch()).count(); QPen pen(Qt::black, 2, Qt::DashLine, Qt::RoundCap, Qt::RoundJoin); pen.setDashPattern({5, 5}); pen.setDashOffset(-now * 15); painter.setPen(pen); painter.drawLine(p->split_line); update(); } } void rectangle_partitionner::mouseMoveEvent(QMouseEvent * event) { assert(m_rectangles.size() == m_rectangles_data.size()); auto r = frameRect(); r.adjust(frameWidth(), frameWidth(), -2 * frameWidth(), -2 * frameWidth()); if (not p->selection.empty()) { double position; if (p->selection.front().edge_side == side::top or p->selection.front().edge_side == side::bottom) position = from_position(event->pos()).y(); else position = from_position(event->pos()).x(); position = std::clamp(position, p->min_drag_position, p->max_drag_position); position = std::round(position * num_subdiv) / num_subdiv; // magnetism for (edge & e: p->selection) { switch (e.edge_side) { case side::top: m_rectangles[e.rectangle_index].setTop(position); break; case side::bottom: m_rectangles[e.rectangle_index].setBottom(position); break; case side::left: m_rectangles[e.rectangle_index].setLeft(position); break; case side::right: m_rectangles[e.rectangle_index].setRight(position); break; } } // if (not assert_rectangle_list_is_partition(m_rectangles)) // { // abort(); // } update(); rectangles_change(m_rectangles); } else { p->hovered.clear(); if (auto horz_edges = hovered_edges(from_position(event->pos()), partition_edges(horizontal_edges(m_rectangles)), true); not horz_edges.empty()) { p->hovered = std::move(horz_edges); update(); } else if (auto vert_edges = hovered_edges(from_position(event->pos()), partition_edges(vertical_edges(m_rectangles)), false); not vert_edges.empty()) { p->hovered = std::move(vert_edges); update(); } else { int n = hovered_rectangle(from_position(event->pos()), m_rectangles); } auto new_cursor = get_cursor_shape(from_position(event->pos()), m_rectangles); if (new_cursor != cursor()) { update(); setCursor(new_cursor); } } if (cursor() == Qt::SplitHCursor) { int n = hovered_rectangle(from_position(event->pos()), m_rectangles); double x = std::round(from_position(event->pos()).x() * num_subdiv) / num_subdiv; // magnetism int px = to_position({x, 0}).x(); p->split_line = {px, rectangles_position()[n].top(), px, rectangles_position()[n].bottom()}; update(); } else if (cursor() == Qt::SplitVCursor) { int n = hovered_rectangle(from_position(event->pos()), m_rectangles); double y = std::round(from_position(event->pos()).y() * num_subdiv) / num_subdiv; // magnetism int py = to_position({0, y}).y(); p->split_line = {rectangles_position()[n].left(), py, rectangles_position()[n].right(), py}; update(); } else { p->split_line = {0, 0, 0, 0}; } } void rectangle_partitionner::mousePressEvent(QMouseEvent * event) { assert(m_rectangles.size() == m_rectangles_data.size()); auto r = frameRect(); r.adjust(frameWidth(), frameWidth(), -2 * frameWidth(), -2 * frameWidth()); p->selection.clear(); p->split_line = {0, 0, 0, 0}; if (auto horz_edges = hovered_edges(from_position(event->pos()), partition_edges(horizontal_edges(m_rectangles)), true); not horz_edges.empty()) { p->selection = std::move(horz_edges); } else if (auto vert_edges = hovered_edges(from_position(event->pos()), partition_edges(vertical_edges(m_rectangles)), false); not vert_edges.empty()) { p->selection = std::move(vert_edges); } else if (int n = hovered_rectangle(from_position(event->pos()), m_rectangles); n >= 0) { QRectF & hovered = m_rectangles[n]; // Compute distance to edges auto pos = from_position(event->pos()); double dx = std::min(pos.x() - hovered.left(), hovered.right() - pos.x()); double dy = std::min(pos.y() - hovered.top(), hovered.bottom() - pos.y()); if (dx < split_edge_threshold) { double y = std::round(pos.y() * num_subdiv) / num_subdiv; // magnetism // Split vertically QRectF new_rectangle = hovered; hovered.setBottom(y); new_rectangle.setTop(hovered.bottom()); m_rectangles.push_back(new_rectangle); m_rectangles_data.push_back(m_rectangles_data[n]); update(); rectangles_change(m_rectangles); if (not assert_rectangle_list_is_partition(m_rectangles)) abort(); } else if (dy < split_edge_threshold) { double x = std::round(pos.x() * num_subdiv) / num_subdiv; // magnetism // Split horizontally QRectF new_rectangle = hovered; hovered.setRight(x); new_rectangle.setLeft(hovered.right()); m_rectangles.push_back(new_rectangle); m_rectangles_data.push_back(m_rectangles_data[n]); update(); rectangles_change(m_rectangles); if (not assert_rectangle_list_is_partition(m_rectangles)) abort(); } else { set_selected_index(n); } } if (not p->selection.empty()) { p->hovered.clear(); p->min_drag_position = std::numeric_limits::lowest(); p->max_drag_position = std::numeric_limits::max(); for (auto & e: p->selection) { switch (e.edge_side) { case side::top: p->max_drag_position = std::min(p->max_drag_position, m_rectangles[e.rectangle_index].bottom()); break; case side::bottom: p->min_drag_position = std::max(p->min_drag_position, m_rectangles[e.rectangle_index].top()); break; case side::left: p->max_drag_position = std::min(p->max_drag_position, m_rectangles[e.rectangle_index].right()); break; case side::right: p->min_drag_position = std::max(p->min_drag_position, m_rectangles[e.rectangle_index].left()); break; } } } assert(m_rectangles.size() == m_rectangles_data.size()); } void rectangle_partitionner::mouseReleaseEvent(QMouseEvent * event) { assert(m_rectangles.size() == m_rectangles_data.size()); p->selection.clear(); // Delete empty rectangles assert(m_rectangles.size() == m_rectangles_data.size()); bool changed = false; for (int i = 0; i < m_rectangles.size();) { if (m_rectangles[i].width() <= 0.0001 or m_rectangles[i].height() <= 0.0001) // TODO configurable thresholds { m_rectangles.erase(m_rectangles.begin() + i); m_rectangles_data.erase(m_rectangles_data.begin() + i); changed = true; if (m_selected_index > i) m_selected_index--; else if (m_selected_index == i) { m_selected_index = -1; } } else { ++i; } } assert(m_rectangles.size() == m_rectangles_data.size()); if (changed) { if (not assert_rectangle_list_is_partition(m_rectangles)) abort(); rectangles_change(m_rectangles); selected_index_change(m_selected_index); update(); } } void rectangle_partitionner::leaveEvent(QEvent * event) { p->split_line = {0, 0, 0, 0}; } void rectangle_partitionner::keyPressEvent(QKeyEvent * event) { auto r = frameRect(); r.adjust(frameWidth(), frameWidth(), -2 * frameWidth(), -2 * frameWidth()); qDebug() << "Bounding box:" << r; int n = 1; for (auto & i: m_rectangles) { qDebug() << "Rectangle" << (n++) << ":" << i.topLeft() << "-" << i.bottomRight(); } } void rectangle_partitionner::set_rectangles(rectangle_list value) { assert(m_rectangles.size() == m_rectangles_data.size()); auto old_value = std::move(m_rectangles); m_rectangles = std::move(value); for (auto & i: m_rectangles) { i.setBottom(std::round(i.bottom() * num_subdiv) / num_subdiv); i.setTop(std::round(i.top() * num_subdiv) / num_subdiv); i.setLeft(std::round(i.left() * num_subdiv) / num_subdiv); i.setRight(std::round(i.right() * num_subdiv) / num_subdiv); } if (not assert_rectangle_list_is_partition(m_rectangles)) { m_rectangles = std::move(old_value); throw std::runtime_error("Invalid partitionning"); } m_rectangles_data.resize(m_rectangles.size()); if (m_selected_index >= m_rectangles.size()) set_selected_index(m_rectangles.size() - 1); update(); rectangles_change(m_rectangles); assert(m_rectangles.size() == m_rectangles_data.size()); } void rectangle_partitionner::set_selected_index(int new_index) { new_index = std::clamp(new_index, -1, m_rectangles.size()); if (new_index != m_selected_index) { m_selected_index = new_index; update(); selected_index_change(new_index); } } void rectangle_partitionner::set_rectangles_data(const data_list & value) { assert(m_rectangles.size() == m_rectangles_data.size()); m_rectangles_data = value; m_rectangles_data.resize(m_rectangles.size()); assert(m_rectangles.size() == m_rectangles_data.size()); update(); } void rectangle_partitionner::set_rectangles_data(int index, QVariant value) { assert(m_rectangles.size() == m_rectangles_data.size()); assert(index < m_rectangles_data.size() and index >= 0); m_rectangles_data.at(index) = value; assert(m_rectangles.size() == m_rectangles_data.size()); update(); } void rectangle_partitionner::set_paint(paint_function paint) { m_paint = paint; update(); } std::vector rectangle_partitionner::rectangles_position() { std::vector positions; positions.reserve(m_rectangles.size()); auto r = frameRect(); r.adjust(frameWidth(), frameWidth(), -2 * frameWidth(), -2 * frameWidth()); for (QRectF & i: m_rectangles) { int x1 = std::round(r.x() + i.x() * (r.width() - 1)); int x2 = std::round(r.x() + (i.x() + i.width()) * (r.width() - 1)); int y1 = std::round(r.y() + i.y() * (r.height() - 1)); int y2 = std::round(r.y() + (i.y() + i.height()) * (r.height() - 1)); positions.emplace_back(x1, y1, x2 - x1 + 1, y2 - y1 + 1); } assert(m_rectangles.size() == positions.size()); return positions; } QPointF rectangle_partitionner::from_position(QPoint position) { auto r = frameRect(); r.adjust(frameWidth(), frameWidth(), -2 * frameWidth(), -2 * frameWidth()); return QPointF{ std::clamp(double(position.x() - r.x()) / (r.width() - 1), 0., 1.), std::clamp(double(position.y() - r.y()) / (r.height() - 1), 0., 1.), }; } QPoint rectangle_partitionner::to_position(QPointF position) { auto r = frameRect(); r.adjust(frameWidth(), frameWidth(), -2 * frameWidth(), -2 * frameWidth()); return QPoint( std::round(r.x() + position.x() * (r.width() - 1)), std::round(r.y() + position.y() * (r.height() - 1))); } #include "moc_rectangle_partitionner.cpp"