¿Cómo idear un algoritmo para organizar ventanas (redimensionables) en la pantalla para cubrir la mayor cantidad de espacio posible?

Me gustaría escribir un programa simple que acepte un conjunto de ventanas (ancho + alto) y la resolución de la pantalla y genere una disposición de esas ventanas en la pantalla de modo que las ventanas ocupen más espacio. Por lo tanto, es posible cambiar el tamaño de una ventana, mientras se mantiene output size >= initial sizey la relación de aspecto. Entonces, para la ventana , me gustaría que el algoritmo devuelva una tupla .( x , y , w i d t $i$$(x, y, width, height)$

Creo que esto podría ser una variación de la mochila 2D. Intenté revisar los resultados en la web, pero en su mayoría tenían muchos antecedentes (y ninguna implementación) que me dificultaron seguir.

Estoy menos interesado en el algoritmo más rápido posible, pero más en algo que sea práctico para mi necesidad específica.

Aunque su pregunta no lo dice, supongo que no desea que las ventanas se superpongan.

Un enfoque para este problema es utilizar un solucionador de restricciones como Choco . Uno simplemente escribe las restricciones que codifican su problema, ajusta el solucionador para que actúe de manera inteligente y luego lo deja correr. Esto significa que todo el pensamiento que necesita hacer se gastará en encontrar una buena manera de codificar el problema, no en idear un algoritmo y hacer la programación y el ajuste. Aquí hay una respuesta parcial para comenzar.

Suponga que el tamaño de la pantalla es .$x_{max}\times y_{max}$

Para cada ventana, , tendrá un conjunto de variables x i , y i , h i , w i y restricciones$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}$
• Quizás también algunas restricciones sobre el tamaño mínimo de las ventanas, por ejemplo, y así sucesivamente.$h_i\ge 100$
• Restricciones de aspecto: si la relación de aspecto es 3: 4, la restricción podría ser algo así como , donde ϵ es un pequeño término de error distinto de cero para permitir una ventana no perfecta tamaños, ya que de lo contrario restringiría el problema.$4h_i - \epsilon \le 3 w_i \le 4 h_i + \epsilon$$\epsilon$

Ahora debe ocuparse de la superposición de ventanas. Para cada par de ventanas, , donde i ≠ j , generará restricciones como las siguientes, que capturan que no aparece ninguna esquina de W j dentro de W i . Para ( x , y ) ∈ { ( x j , y j ) , ( x j + w j , y j ) , ( x j , $W_i, W_j$$i\neq j$$W_j$$W_i$ , generar restricción:$(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)$

Las restricciones especificadas hasta ahora solo describen ventanas no superpuestas que no se derraman a los lados de la pantalla, que satisfacen algunas restricciones de tamaño mínimo y que conservan su relación de aspecto.

Para obtener un buen ajuste, debe especificar una métrica que capture lo que significa ser un buen diseño. Una posibilidad es suponer que desea mantener las ventanas aproximadamente del mismo tamaño y / o que desea minimizar el "espacio en blanco". No creo que esto se pueda especificar usando Choco, pero puede ser posible con otra solución de restricción (alguien más podría ayudar aquí).

Choco permite maximizar el wrt a una función objetivo especificada como una sola variable. En base a esta idea, podría maximizar lo siguiente:

• $\sum_i (h_i + w_i)$

escribiendo una restricción y diciéndole a Choco que maximice c o s t .$\mathit{cost}=\sum_i (h_i + w_i)$$\mathit{cost}$

Comencé a escribir un prototipo para una solución de fuerza bruta, que espero pueda optimizarse hasta el punto en que sea práctico.

Primero, algunas definiciones: Sea el conjunto de todas las ventanas. Cada ventana w está compuesta por x w , y w , w w , h w para las coordenadas x, y y el ancho y la altura. Una ventana se inicializa con un ancho y una altura mínimos.$W$$w$$x_w, y_w, w_w, h_w$

La entrada del algoritmo es la pantalla, , que tiene un ancho y alto y una lista de ventanas.$S$

Funciona más o menos así:

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()

Hay algunas cosas que deberían mejorarse:

• S.coordinates()es muy lento en este momento Repite todos los puntos S.width x S.heighty comprueba si cada uno está en una de las ventanas de S.

• S.put()comprueba si su parámetro se superpone con el resto de las ventanas de S haciendo la prueba mencionada en la respuesta de Dave. ¿Quizás esto pueda mejorarse usando árboles de intervalos ?

• S.score()$\sum_{w \in S.windows} (h_w \cdot w_w)$

• $W$

Actualmente estoy tratando de descubrir una estructura de datos adecuada para representar la pantalla y sus ventanas, debe admitir estas consultas:

• devuelve una lista de coordenadas donde se puede colocar una ventana determinada sin superponerse con otras
• insertar ventana en la posición x, y (ya verificado que no se superpone)
• devolver todas las ventanas