Improved aspect ratio calculation

Author: stevenewald

source/graphics/aspect_ratio/aspect_ratio.cpp

@@ -1,8 +1,10 @@
 #include "aspect_ratio.hpp"
 
+#include "units/display_domain.hpp"
+
 namespace fractal {
 
-display_coordinate calculate_rectangle_end_point(
+DisplayDomain calculate_rectangle_end_points(
     display_coordinate start, display_coordinate current, float target_aspect_ratio
 )
 {
@@ -19,18 +21,30 @@ display_coordinate calculate_rectangle_end_point(
         height = width / target_aspect_ratio;
     }
 
-    auto new_x = static_cast<float>(std::min(current.x, start.x));
-    auto new_y = static_cast<float>(std::min(current.y, start.y));
+    auto x_pos1 = static_cast<float>(start.x);
+    auto y_pos1 = static_cast<float>(start.y);
+    auto x_pos2 = x_pos1 + width;
+    auto y_pos2 = y_pos1 + height;
+
+    bool flipped_horizontal = start.x > current.x;
+    bool flipped_vertical = start.y > current.y;
 
-    // Adjust the top-left corner based on new dimensions
-    if (current.x < start.x) {
-        new_x = static_cast<float>(start.x) - width;
+    if (flipped_vertical) {
+        y_pos1 -= height;
+        y_pos2 -= height;
     }
-    if (current.y < start.y) {
-        new_y = static_cast<float>(start.y) - height;
+    if (flipped_horizontal) {
+        x_pos1 -= width;
+        x_pos2 -= width;
     }
 
-    // Return the top-left and bottom-right corners as a pair of sf::Vector2f
-    return {new_x + width, new_y + height};
+    display_coordinate top_left{
+        static_cast<uint16_t>(x_pos1), static_cast<uint16_t>(y_pos1)
+    };
+    display_coordinate bottom_right{
+        static_cast<uint16_t>(x_pos2), static_cast<uint16_t>(y_pos2)
+    };
+
+    return {top_left, bottom_right};
 }
 } // namespace fractal

source/graphics/aspect_ratio/aspect_ratio.hpp

@@ -2,9 +2,10 @@
 
 #include "config.hpp"
 #include "units/coordinates.hpp"
+#include "units/display_domain.hpp"
 
 namespace fractal {
-display_coordinate calculate_rectangle_end_point(
+DisplayDomain calculate_rectangle_end_points(
     display_coordinate start, display_coordinate current,
     float target_aspect_ratio = static_cast<float>(WINDOW_WIDTH) / WINDOW_HEIGHT
 );

source/graphics/selection_window/selection_window.cpp

@@ -33,15 +33,16 @@ std::optional<std::unique_ptr<sf::Drawable>> SelectionWindow::get_drawable()
 {
     if (!left_mouse_down_)
         return std::nullopt;
-    display_coordinate end_point = calculate_rectangle_end_point(
+    DisplayDomain new_selection = calculate_rectangle_end_points(
         {selection_start_x_, selection_start_y_}, {current_mouse_x_, current_mouse_y_}
     );
 
     auto rectangle = std::make_unique<sf::RectangleShape>(sf::Vector2f{
-        static_cast<float>(end_point.x) - selection_start_x_,
-        static_cast<float>(end_point.y) - selection_start_y_
+        static_cast<float>(new_selection.width()),
+        static_cast<float>(new_selection.height())
     });
-    rectangle->setPosition(selection_start_x_, selection_start_y_);
+    auto [x, y] = new_selection.get_start_coordinate();
+    rectangle->setPosition(x, y);
     rectangle->setFillColor(sf::Color(255, 0, 0, 127));
     return rectangle;
 }

source/mandelbrot/window.hpp

@@ -5,6 +5,7 @@
 #include "graphics/display_event_observer.hpp"
 #include "mandelbrot/mandelbrot_window.hpp"
 #include "units/coordinates.hpp"
+#include "units/display_domain.hpp"
 #include "units/units.hpp"
 
 #include <SFML/Graphics/Image.hpp>
@@ -56,16 +57,10 @@ class Window : public DisplayEventObserver {
 
     void on_mouse_button_released(const sf::Event::MouseButtonEvent& event) override
     {
-        auto ends = calculate_rectangle_end_point(
+        DisplayDomain ends = calculate_rectangle_end_points(
             {selection_start_x_, selection_start_y_}, {event.x, event.y}
         );
-        auto res = mandelbrot_.calculate_(
-            DISPLAY_DOMAIN,
-            {
-                {selection_start_x_, selection_start_y_},
-                ends
-        }
-        );
+        auto res = mandelbrot_.calculate_(DISPLAY_DOMAIN, ends);
         for (display_coordinate pos : DISPLAY_DOMAIN) {
             set_pixel_color(pos, res[pos.x][pos.y]);
         }

source/units/coordinates.cpp

@@ -5,14 +5,14 @@ uint32_t
 decay_2d_coordinate(const display_coordinate& coordinate, uint32_t display_width)
 {
     return static_cast<uint32_t>(coordinate.x)
-           + static_cast<uint32_t>(coordinate.y) * display_width;
+           + static_cast<uint32_t>(coordinate.y) * (display_width - 1u);
 }
 
 display_coordinate generate_1d_coordinate(uint32_t coordinate, uint32_t display_width)
 {
     return {
-        coordinate % (display_width + 1),
-        (coordinate - (coordinate % (display_width + 1))) / display_width
+        coordinate % display_width,
+        (coordinate - (coordinate % display_width)) / display_width
     };
 }
 } // namespace fractal

source/units/display_domain.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "coordinates.hpp"
+#include "util.hpp"
 
 #include <iterator>
 
@@ -13,7 +14,10 @@ class DisplayDomain {
 public:
     DisplayDomain(display_coordinate start, display_coordinate end) :
         START_COORDINATE{start}, END_COORDINATE{end}
-    {}
+    {
+        assert_true(start.x <= end.x);
+        assert_true(start.y <= end.y);
+    }
 
     const display_coordinate& get_start_coordinate() const { return START_COORDINATE; }
 
@@ -31,7 +35,7 @@ class DisplayDomain {
         using reference = display_coordinate&;
 
         explicit DisplayCoordinateIterator(const DisplayDomain& domain) :
-            GRID_WIDTH{domain.get_end_coordinate().x},
+            GRID_WIDTH{domain.get_end_coordinate().x + 1u},
             current_coordinate_{
                 decay_2d_coordinate(domain.get_start_coordinate(), GRID_WIDTH)
             }
@@ -77,6 +81,10 @@ class DisplayDomain {
         bool operator==(const DisplayCoordinateIterator&) const = default;
     };
 
+    uint32_t width() const { return END_COORDINATE.x - START_COORDINATE.x; }
+
+    uint32_t height() const { return END_COORDINATE.y - START_COORDINATE.y; }
+
     DisplayCoordinateIterator begin() const { return DisplayCoordinateIterator{*this}; }
 
     DisplayCoordinateIterator end() const