resize bboxes

.gitignore

@@ -2,3 +2,6 @@
 packing_*
 build.sh
 *.a
+
+callgrind.out.*
+massif.out.*

README.md

@@ -4,12 +4,15 @@ The subject is available here: [Test Algo](./test_algo.pdf)
 
 ## TODO
 - [ ] document
-- [ ] dumb packing 
+- [X] dumb packing 
+- [ ] skyline
 - [X] add raygui
+- [X] resize box
 - [ ] add box in gui by pressing down
 - [ ] delete box in gui by clicking
 - [ ] wrap stb_rect_pack?
-- [ ] change bbox api to origin + size
+- [X] change bbox api to origin + size
+- [ ] dummy A2
 
 ##  Installation
 

justfile

@@ -3,7 +3,7 @@ exe_cli := "./packing_cli"
 exe_gui := "./packing_gui"
 build_sh := "build.sh"
 
-params := "lenna.png 0 0 64 64 100 100 200 164 80 200 150 420"
+params := "lenna.png 0 0 64 64 100 100 100 64 80 200 70 220"
 
 
 build-raylib:
@@ -33,5 +33,15 @@ generate-build:
 debug: build-cli
 	lldb {{exe_cli}} {{params}}
 
+memcheck: build-cli
+    valgrind --leak-check=yes {{exe_cli}} {{params}}
+
+massif: build-cli
+    valgrind --tool=massif --massif-out-file=pipeline.massif {{exe_cli}} {{params}}
+    ms_print pipeline.massif
+
+callgrind: build-cli
+    valgrind --tool=callgrind {{exe_cli}} {{params}}
+
 archive: generate-build
 	git archive --add-file={{build_sh}} --output={{name}}.zip --prefix={{name}}/ HEAD

src/bounding_box.cpp

@@ -2,21 +2,12 @@
 
 namespace freling {
 
-int BoundingBox::width() const {
-    return right - left;
-}
-
-int BoundingBox::height() const {
-    return bottom - top;
-}
-
 int BoundingBox::area() const {
-    return width() * height();
+    return width * height;
 }
 
 bool BoundingBox::operator==(const BoundingBox& b) const {
-    return left == b.left and top == b.top and right == b.right and
-           bottom == b.bottom;
+    return x == b.x and y == b.y and width == b.width and height == b.height;
 }
 
 }  // namespace freling

src/bounding_box.h

@@ -5,13 +5,11 @@
 namespace freling {
 
 struct BoundingBox {
-    uint32_t left;
-    uint32_t top;
-    uint32_t right;
-    uint32_t bottom;
+    int32_t x;
+    int32_t y;
+    uint32_t width;
+    uint32_t height;
 
-    int width() const;
-    int height() const;
     int area() const;
 
     bool operator==(const BoundingBox& b) const;

src/main_cli.cpp

@@ -14,8 +14,8 @@ int main(int argc, const char* argv[]) {
     if (argc < 6 or (argc - 2) % 4 != 0) {
         std::cerr
             << "Usage: " << argv[0] << " path/to/image"
-            << " x1 y1 x2 y2 [...]\n"
-            << "x/y points must be grouped by 4 to define bounding boxes\n";
+            << " [x y width height ...]\n"
+            << "x/y/w/h points must be grouped by 4 to define bounding boxes\n";
         return 1;
     }
 
@@ -35,15 +35,16 @@ int main(int argc, const char* argv[]) {
     std::vector<freling::BoundingBox> bboxes;
     bboxes.reserve((argc - 2) / 4);
     while (i < argc) {
-        const uint32_t x1 = atoi(argv[i]);
-        const uint32_t y1 = atoi(argv[i + 1]);
-        const uint32_t x2 = atoi(argv[i + 2]);
-        const uint32_t y2 = atoi(argv[i + 3]);
-        bboxes.push_back(freling::BoundingBox({x1, y1, x2, y2}));
+        const int32_t x = atoi(argv[i]);
+        const int32_t y = atoi(argv[i + 1]);
+        const uint32_t w = atoi(argv[i + 2]);
+        const uint32_t h = atoi(argv[i + 3]);
+        bboxes.push_back(freling::BoundingBox({x, y, w, h}));
         i += 4;
     }
 
-    std::optional<Frame> regions = pack(*in_frame, bboxes);
+    std::vector<freling::BoundingBox> packed_bboxes;
+    std::optional<Frame> regions = pack(*in_frame, bboxes, packed_bboxes);
 
     return 0;
 }

src/main_gui.cpp

@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <cstdlib>
 #include <cstring>
 #include <filesystem>
@@ -19,33 +20,27 @@
 
 namespace fs = std::filesystem;
 
-struct Button {
-    Rectangle rect;
-    std::string text;
-    bool hover = false;
+constexpr int resize_handle = 20;
 
-    bool pressed() {
-        hover = CheckCollisionPointRec(GetMousePosition(), rect);
-        return hover and IsMouseButtonReleased(MOUSE_BUTTON_LEFT);
-    };
-
-    void draw() const {
-        DrawRectangleRec(rect, LIGHTGRAY);
-        DrawRectangleLines(rect.x, rect.y, rect.width, rect.height, BLUE);
-        DrawText(text.c_str(),
-                 (rect.x + rect.width / 2 - MeasureText(text.c_str(), 10) / 2),
-                 rect.y + 11, 10, DARKBLUE);
-    };
-};
+Rectangle rect_from_bbox(const freling::BoundingBox& box,
+                         const Vector2& offset) {
+    const Rectangle rect = {offset.x + box.x, offset.y + box.y,
+                            static_cast<float>(box.width),
+                            static_cast<float>(box.height)};
+    return rect;
+}
 
 void draw(const freling::BoundingBox& box,
           const Vector2& offset,
           const Color& color) {
-    const Rectangle rect = {offset.x + box.left, offset.y + box.top,
-                            static_cast<float>(box.right - box.left),
-                            static_cast<float>(box.bottom - box.top)};
+    const Rectangle rect = rect_from_bbox(box, offset);
     DrawRectangleRec(rect, ColorAlpha(color, 0.3));
     DrawRectangleLinesEx(rect, 3, color);
+    DrawTriangle(
+        (Vector2){rect.x + rect.width - resize_handle, rect.y + rect.height},
+        (Vector2){rect.x + rect.width, rect.y + rect.height},
+        (Vector2){rect.x + rect.width, rect.y + rect.height - resize_handle},
+        color);
 }
 
 Image image_from_frame(const Frame& frame) {
@@ -69,8 +64,8 @@ int main(int argc, const char* argv[]) {
     if (argc < 2 or (argc - 2) % 4 != 0) {
         std::cerr
             << "Usage: " << argv[0] << " path/to/image"
-            << " [x1 y1 x2 y2 ...]\n"
-            << "x/y points must be grouped by 4 to define bounding boxes\n";
+            << " [x y width height ...]\n"
+            << "x/y/w/h points must be grouped by 4 to define bounding boxes\n";
         return 1;
     }
 
@@ -90,14 +85,15 @@ int main(int argc, const char* argv[]) {
     bboxes.reserve((argc - 2) / 4);
     int i = 2;
     while (i < argc) {
-        const uint32_t x1 = atoi(argv[i]);
-        const uint32_t y1 = atoi(argv[i + 1]);
-        const uint32_t x2 = atoi(argv[i + 2]);
-        const uint32_t y2 = atoi(argv[i + 3]);
-        bboxes.push_back(freling::BoundingBox({x1, y1, x2, y2}));
+        const int32_t x = atoi(argv[i]);
+        const int32_t y = atoi(argv[i + 1]);
+        const uint32_t w = atoi(argv[i + 2]);
+        const uint32_t h = atoi(argv[i + 3]);
+        bboxes.push_back(freling::BoundingBox({x, y, w, h}));
         i += 4;
     }
-    const std::vector<Color> bbox_colors = {RED, GREEN, BLUE};
+    const std::vector<Color> bbox_colors = {RED,    GREEN,  BLUE,
+                                            YELLOW, ORANGE, PURPLE};
     std::vector<freling::BoundingBox> packed_bboxes;
 
     Vector2 win_size = {800, 450};
@@ -121,8 +117,53 @@ int main(int argc, const char* argv[]) {
     SetWindowSize(win_size.x, win_size.y);
 
     const Vector2 b_size = {150, 30};
+    Vector2 mouse_pos = {0};
+    Vector2 mouse_delta = {0};
+    int b_moving_idx = -1;
+    int b_resize_idx = -1;
 
     while (!WindowShouldClose()) {
+        //
+        // Update
+        //
+        mouse_pos = GetMousePosition();
+        mouse_delta = GetMouseDelta();
+        for (int b = 0, size = bboxes.size(); b < size; ++b) {
+            const auto& box = bboxes[b];
+            const Rectangle rect = rect_from_bbox(box, in_offset);
+            if (CheckCollisionPointRec(mouse_pos, rect) and
+                IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
+                const Rectangle handle_area = {
+                    rect.x + rect.width - resize_handle,
+                    rect.y + rect.height - resize_handle, resize_handle,
+                    resize_handle};
+                if (CheckCollisionPointRec(mouse_pos, handle_area)) {
+                    b_resize_idx = b;
+                } else {
+                    b_moving_idx = b;
+                }
+            }
+        }
+        if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) {
+            b_moving_idx = -1;
+            b_resize_idx = -1;
+        }
+        if (b_moving_idx != -1) {
+            auto& box = bboxes[b_moving_idx];
+            box.x += mouse_delta.x;
+            box.y += mouse_delta.y;
+        }
+        if (b_resize_idx != -1) {
+            auto& box = bboxes[b_resize_idx];
+            box.width = std::max(static_cast<int>(box.width + mouse_delta.x),
+                                 resize_handle);
+            box.height = std::max(static_cast<int>(box.height + mouse_delta.y),
+                                  resize_handle);
+        }
+
+        //
+        // Draw
+        //
         BeginDrawing();
         ClearBackground(RAYWHITE);
 
@@ -169,7 +210,7 @@ int main(int argc, const char* argv[]) {
 
         int c = 0;
         for (const auto& b : bboxes) {
-            const auto& color = bbox_colors[c % bboxes.size()];
+            const auto& color = bbox_colors[c % bbox_colors.size()];
             draw(b, in_offset, color);
             ++c;
         };
@@ -186,7 +227,7 @@ int main(int argc, const char* argv[]) {
 
             int c = 0;
             for (const auto& b : packed_bboxes) {
-                const auto& color = bbox_colors[c % bboxes.size()];
+                const auto& color = bbox_colors[c % bbox_colors.size()];
                 draw(b, pack_offset, color);
                 ++c;
             };

src/pack.cpp

@@ -12,16 +12,16 @@ void blit(const Frame& in_frame,
           const BoundingBox& in_box,
           Frame& out_frame,
           const BoundingBox& out_box) {
-    assert(in_box.width() == out_box.width());
-    assert(in_box.height() == out_box.height());
+    assert(in_box.width == out_box.width);
+    assert(in_box.height == out_box.height);
 
-    const int data_width = in_box.width() * sizeof(Pixel);
+    const int data_width = in_box.width * sizeof(Pixel);
     const int in_row_size = in_frame.width;
     const int out_row_size = out_frame.width;
 
-    for (unsigned int i = 0; i < in_box.height(); ++i) {
-        const int in_offset = in_box.left + (i + in_box.top) * in_row_size;
-        const int out_offset = out_box.left + (i + out_box.top) * out_row_size;
+    for (unsigned int i = 0; i < in_box.height; ++i) {
+        const int in_offset = in_box.x + (i + in_box.y) * in_row_size;
+        const int out_offset = out_box.x + (i + out_box.y) * out_row_size;
 
         memcpy(out_frame.data + out_offset, in_frame.data + in_offset,
                data_width);
@@ -35,10 +35,10 @@ std::optional<Frame> pack(const Frame& in_frame,
         std::cerr << "No bounding box, cannot pack.\n";
         return {};
     }
-    // We sort the bounding boxes by maximum area
+    // We sort the bounding boxes by height
     std::vector<BoundingBox> sorted_bboxes = bboxes;
     std::sort(sorted_bboxes.begin(), sorted_bboxes.end(),
-              [](const auto& a, const auto& b) { return a.area() > b.area(); });
+              [](const auto& a, const auto& b) { return a.height > b.height; });
 
     // We keep a mapping between the sorted bounding boxes and the original
     // order
@@ -61,22 +61,73 @@ std::optional<Frame> pack(const Frame& in_frame,
         max_area += area;
     }
     std::cout << "max area: " << max_area << "\n";
-    int min_dim = int(ceil(std::sqrt(max_area)));
-    std::cout << "optimal image dimention: " << min_dim << " x " << min_dim
+    int optimal_size = int(ceil(std::sqrt(max_area)));
+    std::cout << "optimal image dimention: " << optimal_size << " x "
+              << optimal_size << "\n";
+
+    // cf. subject: D < min(M, N )
+    const int max_size = std::min(in_frame.width, in_frame.height) - 1;
+    std::cout << "maximum image dimention: " << max_size << " x " << max_size
               << "\n";
-    const int in_min_dim = std::min(in_frame.width, in_frame.height);
-    std::cout << "maximum image dimention: " << in_min_dim << " x "
-              << in_min_dim << "\n";
 
-    const auto& largest = sorted_bboxes[0];
-    BoundingBox out_largest = {0, 0, static_cast<uint32_t>(largest.width()),
-                               static_cast<uint32_t>(largest.height())};
-    packed_bboxes.clear();
-    packed_bboxes.push_back(out_largest);
+    // We will try to fit all the rectangles in a given square of size S.
+    // optimal_size <= S <= max_size (smallest dimension of input frame)
+    // To find S, we will generate N candidates and try to fit everything.
+    const int nb_candidates = 5;
+    const int size_increment = (max_size - optimal_size) / nb_candidates;
+    for (int size = optimal_size; size <= max_size; size += size_increment) {
+        int x = 0;
+        int y = 0;
+        int next_row = 0;
+        bool room_left = true;
 
-    Frame packed_frame(largest.width(), largest.height());
-    blit(in_frame, largest, packed_frame, out_largest);
-    return packed_frame;
+        for (int box_i = 0, box_max = bboxes.size();
+             room_left and box_i < box_max; ++box_i) {
+            auto& box = sorted_bboxes[box_i];
+
+            // If we don't have room in either dimension, we won't be able to
+            // pack within this size candidate.
+            if (x + box.width >= size or y + box.height >= size) {
+                room_left = false;
+                continue;
+            }
+
+            // If we cannot fit the rect on the right, we fit it below.
+            if (x + box.width >= size) {
+                x = 0;
+                y = next_row;
+            }
+
+            // If we add a box in a new row, we bump the next row index.
+            // Because we previously sorted the rectangles by height, we
+            // know the next ones won't cross this line.
+            if (x == 0) {
+                next_row = box.height;
+            }
+
+            box.x = x;
+            box.y = y;
+            x += box.width;
+        }
+
+        if (room_left) {
+            Frame packed_frame(size, size);
+            packed_frame.fill(0);
+
+            packed_bboxes.resize(bboxes.size());
+            for (int i = 0; i < mapping.size(); ++i) {
+                int box_index = mapping[i];
+                packed_bboxes[box_index] = sorted_bboxes[i];
+                blit(in_frame, bboxes[box_index], packed_frame,
+                     sorted_bboxes[i]);
+            }
+
+            return packed_frame;
+        }
+    }
+
+    std::cerr << "Cannot pack rectangles.\n";
+    return {};
 }
 
 }  // namespace freling