Bagaimana merancang algoritma untuk mengatur (resizable) windows pada layar untuk mencakup ruang sebanyak mungkin?

Saya ingin menulis sebuah program sederhana yang menerima satu set jendela (lebar + tinggi) dan resolusi layar dan menampilkan pengaturan dari jendela-jendela tersebut di layar sedemikian rupa sehingga windows mengambil ruang paling besar. Oleh karena itu dimungkinkan untuk mengubah ukuran jendela, sambil mempertahankan output size >= initial sizedan aspek rasio. Jadi untuk jendela , saya ingin algoritma mengembalikan tuple .$i$$(x, y, width, height)$

Saya percaya ini mungkin variasi dari 2D Knapsack. Saya sudah mencoba memeriksa hasil di web tetapi kebanyakan dari mereka memiliki banyak latar belakang (dan tidak ada implementasi) yang menyulitkan saya untuk mengikuti.

Saya kurang tertarik pada algoritma tercepat yang mungkin, tetapi lebih pada sesuatu yang praktis untuk kebutuhan spesifik saya.

Meskipun pertanyaan Anda tidak mengatakannya, saya berasumsi bahwa Anda tidak ingin windows tumpang tindih.

Salah satu pendekatan untuk masalah ini adalah dengan menggunakan pemecah kendala seperti Choco . Seseorang cukup menuliskan batasan-batasan yang menyandikan masalah Anda, menyetel pemecah untuk bertindak dengan cara yang cerdas, dan kemudian membiarkannya berjalan. Ini berarti bahwa semua pemikiran yang perlu Anda lakukan akan dihabiskan untuk menemukan cara pengkodean masalah yang baik, bukan merancang algoritma dan melakukan pemrograman dan penyetelan. Ini jawaban parsial untuk membantu Anda memulai.

Asumsikan bahwa ukuran layar adalah .$x_{max}\times y_{max}$

Untuk setiap jendela, , Anda akan memiliki satu set variabel dan kendalax 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}$
• Mungkin juga beberapa kendala pada ukuran minimal windows, mis. dan sebagainya.$h_i\ge 100$
• Batasan aspek: Jika rasio aspek adalah 3: 4, batasannya bisa kira-kira seperti , di mana ϵ adalah beberapa istilah kesalahan kecil yang tidak nol untuk memungkinkan jendela yang tidak sempurna ukuran, karena kalau tidak Anda akan lebih kendala masalah.$4h_i - \epsilon \le 3 w_i \le 4 h_i + \epsilon$$\epsilon$

Sekarang Anda perlu merawat tumpang tindih jendela. Untuk setiap pasangan windows, , di mana i ≠ j , Anda akan menghasilkan kendala seperti berikut ini, yang menangkap bahwa tidak ada sudut W j muncul dalam W i . Untuk ( 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$ , menghasilkan kendala:$(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)$

Kendala yang ditentukan sejauh ini hanya menggambarkan jendela non-tumpang tindih yang tidak tumpah di sisi layar, yang memenuhi beberapa batasan ukuran minimal, dan yang mempertahankan rasio aspek mereka.

Untuk mendapatkan kecocokan yang baik, Anda perlu menentukan metrik yang menangkap artinya menjadi tata letak yang baik. Satu kemungkinan adalah menganggap bahwa Anda ingin menjaga ukuran jendela kira-kira sama dan / atau bahwa Anda ingin meminimalkan "ruang putih". Saya tidak berpikir bahwa ini dapat dispesifikasikan menggunakan Choco, tetapi dimungkinkan dengan pemecahan kendala lainnya (orang lain mungkin dapat membantu di sini).

Choco memang memungkinkan seseorang untuk memaksimalkan wrt ke fungsi objektif yang ditentukan sebagai variabel tunggal. Berdasarkan ide ini, Anda dapat memaksimalkan hal berikut:

• $\sum_i (h_i + w_i)$

$\mathit{cost}=\sum_i (h_i + w_i)$$\mathit{cost}$

Saya mulai menulis prototipe untuk solusi brute force, yang diharapkan dapat dioptimalkan ke titik di mana itu akan praktis.

$W$$w$$x_w, y_w, w_w, h_w$

$S$

Ini bekerja kira-kira begitu:

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

Ada beberapa hal yang harus diperbaiki:

• S.coordinates()sangat lambat sekarang. Iterates semua poin dalam S.width x S.heightdan memeriksa apakah masing-masing berada di salah satu jendela S.

• S.put()memeriksa apakah parameternya tumpang tindih dengan sisa jendela S dengan melakukan tes yang disebutkan dalam jawaban Dave. Mungkin ini bisa diperbaiki dengan menggunakan pohon interval ?

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

• $W$

Saat ini saya mencoba untuk mencari tahu struktur data yang sesuai untuk mewakili layar dan jendelanya, ia perlu mendukung pertanyaan ini:

• mengembalikan daftar koordinat tempat jendela yang diberikan dapat diposisikan tanpa tumpang tindih dengan yang lain
• masukkan jendela pada posisi x, y (sudah diverifikasi tidak tumpang tindih)
• kembalikan semua jendela