Как разработать алгоритм размещения (изменяемого размера) окон на экране, чтобы покрыть как можно больше места?

Я хотел бы написать простую программу, которая принимает набор окон (ширина + высота) и разрешение экрана и выводит расположение этих окон на экране таким образом, чтобы окна занимали больше всего места. Поэтому можно изменить размер окна, сохраняя при этом output size >= initial sizeи соотношение сторон. Поэтому для окна я бы хотел, чтобы алгоритм возвращал кортеж .( х , у , ш я д T ч , ч е я г ч т $i$$(x, y, width, height)$

Я считаю, что это может быть вариация 2D рюкзака. Я пытался просмотреть результаты в Интернете, но в большинстве случаев они имели большой опыт (и не имели реализации), из-за чего мне было трудно следить.

Меня меньше интересует самый быстрый алгоритм, но больше что-то практичное для моих конкретных нужд.

Хотя ваш вопрос не говорит об этом, я предполагаю, что вы не хотите, чтобы окна перекрывались.

Одним из подходов к этой проблеме является использование решателя ограничений, такого как Choco . Один просто записывает ограничения, кодирующие вашу проблему, настраивает решатель так, чтобы он действовал разумно, и затем запускает его. Это означает, что все ваши мысли будут потрачены на поиск хорошего способа кодирования проблемы, а не на разработку алгоритма, а также на программирование и настройку. Вот частичный ответ, чтобы вы начали.

Предположим, что размер экрана равен .$x_{max}\times y_{max}$

Для каждого окна, , у вас будет набор переменных и ограниченийx i , y i , h i , w $W_i$$x_i, y_i, h_i, w_i$

• $x_i,y_i,h_i,w_i\ge 0$
• $x_i + w_i \le x_{max}$
• $y_i + h_i \le y_{max}$
• Возможно также некоторые ограничения на минимальный размер окон, например, и так далее.$h_i\ge 100$
• Аспектные ограничения: Если соотношение сторон 3: 4, ограничение может быть примерно таким: , где - это небольшой ненулевой термин ошибки, который допускает несовершенные размеры окна, так как в противном случае вы бы чрезмерно ограничить проблему.$4h_i - \epsilon \le 3 w_i \le 4 h_i + \epsilon$$\epsilon$

Теперь вам нужно позаботиться о перекрытии окон. Для каждой пары окон, , где , вы будете генерировать ограничения, подобные следующим, которые фиксируют, что ни один угол появляется внутри . Для сгенерируйте ограничение: i ≠ j W j W i ( x , y ) ∈ { ( x j , y j ) , ( x $W_i, W_j$$i\neq j$$W_j$$W_i$$(x,y)\in\{(x_j,y_j), (x_j+w_j,y_j), (x_j,y_j+h_j), (x_j+w_j,y_j+h_j)\}$

• $\neg(x_i \le x\le x_i + w_j \wedge y_i\le y \le y_i+h_j)$ .

Указанные выше ограничения описывают только неперекрывающиеся окна, которые не растекаются по сторонам экрана, удовлетворяют некоторым ограничениям минимального размера и сохраняют соотношение сторон.

Чтобы получить хорошее соответствие, вам нужно указать метрику, которая отражает, что значит быть хорошим макетом. Одна из возможностей - предположить, что вы хотите, чтобы окна были примерно одинаковыми по размеру и / или что вы хотите минимизировать «пустое пространство». Я не думаю, что это может быть указано с помощью Choco, но это может быть возможно с другим решением ограничений (кто-то еще может помочь здесь).

Choco позволяет максимально увеличить целевую функцию, указанную в качестве одной переменной. Основываясь на этой идее, вы можете максимизировать следующее:

• $\sum_i (h_i + w_i)$

написав ограничение и сказав Choco, чтобы максимизировать .c o s $\mathit{cost}=\sum_i (h_i + w_i)$$\mathit{cost}$

Я начал писать прототип для решения «грубой силы», которое, надеюсь, можно будет оптимизировать до такой степени, что оно будет практичным.

Сначала несколько определений: пусть будет множеством всех окон. Каждое окно состоит из для координат x, y, а также ширины и высоты. Окно инициализируется с минимальной шириной и высотой.$W$$w$$x_w, y_w, w_w, h_w$

Вводом алгоритма является экран , который имеет ширину и высоту, а также список окон.$S$

Это работает примерно так:

void fit(W, S, i, n, result)
    if i == n
        if S.score() < result.score()
            result = S
        return

    w = W[i]
    foreach x, y in S.coordinates()
        set w position to (x, y)
        while S.put(w) # check that w doesn't overlap with S's other windows and add it
            fit(W, S, i+1, n, result)
            S.windows.pop()
            w.grow()
        w.restoresize()

Есть несколько вещей, которые должны быть улучшены:

• S.coordinates()сейчас очень медленно Он перебирает все точки S.width x S.heightи проверяет, находится ли каждый из них в одном из окон S.

• S.put()проверяет, перекрывается ли его параметр с остальными окнами S, выполняя тест, упомянутый в ответе Дэйва. Может быть, это можно улучшить с помощью интервальных деревьев ?

• S.score()в настоящее время возвращает который является просто областью всех окон. Нужно учитывать другие переменные, чтобы получить лучшие макеты.$\sum_{w \in S.windows} (h_w \cdot w_w)$

• Вышеупомянутая функция должна попробовать все перестановки чтобы получить наилучший возможный результат.$W$

В настоящее время я пытаюсь выяснить подходящую структуру данных для представления экрана и его окон, он должен поддерживать эти запросы:

• вернуть список координат, где данное окно может быть расположено без наложения на другие
• вставить окно в позиции x, y (уже проверено, что оно не перекрывается)
• вернуть все окна