📺 Closer parity with ProUI (#26761)

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>

Author: classicrocker883

Marlin/src/feature/bedlevel/abl/bbl.cpp

@@ -37,12 +37,12 @@
 
 LevelingBilinear bedlevel;
 
-xy_pos_t LevelingBilinear::grid_spacing,
-         LevelingBilinear::grid_start;
 xy_float_t LevelingBilinear::grid_factor;
+xy_pos_t   LevelingBilinear::grid_spacing,
+           LevelingBilinear::grid_start,
+           LevelingBilinear::cached_rel;
+xy_int8_t  LevelingBilinear::cached_g;
 bed_mesh_t LevelingBilinear::z_values;
-xy_pos_t LevelingBilinear::cached_rel;
-xy_int8_t LevelingBilinear::cached_g;
 
 /**
  * Extrapolate a single point from its neighbors
@@ -106,9 +106,17 @@ void LevelingBilinear::reset() {
   }
 }
 
+/**
+ * Set grid spacing and start position
+ */
 void LevelingBilinear::set_grid(const xy_pos_t& _grid_spacing, const xy_pos_t& _grid_start) {
-  grid_spacing = _grid_spacing;
-  grid_start = _grid_start;
+  #if HAS_PROUI_MESH_EDIT
+    grid_spacing.set(MESH_X_DIST, MESH_Y_DIST);
+    grid_start = mesh_min;
+  #else
+    grid_spacing = _grid_spacing;
+    grid_start = _grid_start;
+  #endif
   grid_factor = grid_spacing.reciprocal();
 }
 

Marlin/src/feature/bedlevel/bedlevel.cpp

@@ -46,8 +46,18 @@
   #include "../../lcd/extui/ui_api.h"
 #endif
 
+#if HAS_PROUI_MESH_EDIT
+  #include "../../lcd/dwin/proui/bedlevel_tools.h"
+#endif
+
 bool leveling_is_valid() {
-  return TERN1(HAS_MESH, bedlevel.mesh_is_valid());
+  return (
+    #if HAS_PROUI_MESH_EDIT
+      bedLevelTools.meshValidate()
+    #else
+      TERN1(HAS_MESH, bedlevel.mesh_is_valid())
+    #endif
+  );
 }
 
 /**

Marlin/src/feature/bedlevel/hilbert_curve.cpp

@@ -102,8 +102,8 @@ bool hilbert_curve::search_from(uint8_t x, uint8_t y, hilbert_curve::callback_pt
  */
 bool hilbert_curve::search_from_closest(const xy_pos_t &pos, hilbert_curve::callback_ptr func, void *data) {
   // Find closest grid intersection
-  const uint8_t grid_x = LROUND(constrain(float(pos.x - (MESH_MIN_X)) / (MESH_X_DIST), 0, (GRID_MAX_POINTS_X) - 1));
-  const uint8_t grid_y = LROUND(constrain(float(pos.y - (MESH_MIN_Y)) / (MESH_Y_DIST), 0, (GRID_MAX_POINTS_Y) - 1));
+  const uint8_t grid_x = LROUND(constrain((pos.x - mesh_min.x) / (MESH_X_DIST), 0, (GRID_MAX_POINTS_X) - 1));
+  const uint8_t grid_y = LROUND(constrain((pos.y - mesh_min.y) / (MESH_Y_DIST), 0, (GRID_MAX_POINTS_Y) - 1));
   return search_from(grid_x, grid_y, func, data);
 }
 

Marlin/src/feature/bedlevel/mbl/mesh_bed_leveling.cpp

@@ -39,14 +39,21 @@
         mesh_bed_leveling::index_to_xpos[GRID_MAX_POINTS_X],
         mesh_bed_leveling::index_to_ypos[GRID_MAX_POINTS_Y];
 
-  mesh_bed_leveling::mesh_bed_leveling() {
+  mesh_bed_leveling::mesh_bed_leveling() { initialize(); }
+
+  void mesh_bed_leveling::initialize() {
     for (uint8_t i = 0; i < GRID_MAX_POINTS_X; ++i)
-      index_to_xpos[i] = MESH_MIN_X + i * (MESH_X_DIST);
+      index_to_xpos[i] = mesh_min.x + i * (MESH_X_DIST);
     for (uint8_t i = 0; i < GRID_MAX_POINTS_Y; ++i)
-      index_to_ypos[i] = MESH_MIN_Y + i * (MESH_Y_DIST);
+      index_to_ypos[i] = mesh_min.y + i * (MESH_Y_DIST);
     reset();
   }
 
+  void mesh_bed_leveling::report_mesh() {
+    SERIAL_ECHOLN(F(STRINGIFY(GRID_MAX_POINTS_X) "x" STRINGIFY(GRID_MAX_POINTS_Y) " mesh. Z offset: "), p_float_t(z_offset, 5), F("\nMeasured points:"));
+    print_2d_array(GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y, 5, z_values[0]);
+  }
+
   void mesh_bed_leveling::reset() {
     z_offset = 0;
     ZERO(z_values);
@@ -122,9 +129,4 @@
 
   #endif // IS_CARTESIAN && !SEGMENT_LEVELED_MOVES
 
-  void mesh_bed_leveling::report_mesh() {
-    SERIAL_ECHOLN(F(STRINGIFY(GRID_MAX_POINTS_X) "x" STRINGIFY(GRID_MAX_POINTS_Y) " mesh. Z offset: "), p_float_t(z_offset, 5), F("\nMeasured points:"));
-    print_2d_array(GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y, 5, z_values[0]);
-  }
-
 #endif // MESH_BED_LEVELING

Marlin/src/feature/bedlevel/mbl/mesh_bed_leveling.h

@@ -32,8 +32,7 @@ enum MeshLevelingState : char {
   MeshReset       // G29 S5
 };
 
-#define MESH_X_DIST (float((MESH_MAX_X) - (MESH_MIN_X)) / (GRID_MAX_CELLS_X))
-#define MESH_Y_DIST (float((MESH_MAX_Y) - (MESH_MIN_Y)) / (GRID_MAX_CELLS_Y))
+#include "../../../module/motion.h"
 
 class mesh_bed_leveling {
 public:
@@ -44,10 +43,12 @@ class mesh_bed_leveling {
 
   mesh_bed_leveling();
 
-  static void report_mesh();
-
   static void reset();
 
+  static void initialize();
+
+  static void report_mesh();
+
   FORCE_INLINE static bool has_mesh() {
     GRID_LOOP(x, y) if (z_values[x][y]) return true;
     return false;
@@ -73,11 +74,11 @@ class mesh_bed_leveling {
   static float get_mesh_y(const uint8_t i) { return index_to_ypos[i]; }
 
   static uint8_t cell_index_x(const float x) {
-    int8_t cx = (x - (MESH_MIN_X)) * RECIPROCAL(MESH_X_DIST);
+    const int8_t cx = (x - mesh_min.x) * RECIPROCAL(MESH_X_DIST);
     return constrain(cx, 0, GRID_MAX_CELLS_X - 1);
   }
   static uint8_t cell_index_y(const float y) {
-    int8_t cy = (y - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST);
+    const int8_t cy = (y - mesh_min.y) * RECIPROCAL(MESH_Y_DIST);
     return constrain(cy, 0, GRID_MAX_CELLS_Y - 1);
   }
   static xy_uint8_t cell_indexes(const float x, const float y) {
@@ -86,11 +87,11 @@ class mesh_bed_leveling {
   static xy_uint8_t cell_indexes(const xy_pos_t &xy) { return cell_indexes(xy.x, xy.y); }
 
   static int8_t probe_index_x(const float x) {
-    int8_t px = (x - (MESH_MIN_X) + 0.5f * (MESH_X_DIST)) * RECIPROCAL(MESH_X_DIST);
+    const int8_t px = (x - mesh_min.x + 0.5f * (MESH_X_DIST)) * RECIPROCAL(MESH_X_DIST);
     return WITHIN(px, 0, (GRID_MAX_POINTS_X) - 1) ? px : -1;
   }
   static int8_t probe_index_y(const float y) {
-    int8_t py = (y - (MESH_MIN_Y) + 0.5f * (MESH_Y_DIST)) * RECIPROCAL(MESH_Y_DIST);
+    const int8_t py = (y - mesh_min.y + 0.5f * (MESH_Y_DIST)) * RECIPROCAL(MESH_Y_DIST);
     return WITHIN(py, 0, (GRID_MAX_POINTS_Y) - 1) ? py : -1;
   }
   static xy_int8_t probe_indexes(const float x, const float y) {

Marlin/src/feature/bedlevel/ubl/ubl.cpp

@@ -63,23 +63,25 @@ void unified_bed_leveling::report_state() {
 
 int8_t unified_bed_leveling::storage_slot;
 
-float unified_bed_leveling::z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
-
-#define _GRIDPOS(A,N) (MESH_MIN_##A + N * (MESH_##A##_DIST))
-
-const float
-unified_bed_leveling::_mesh_index_to_xpos[GRID_MAX_POINTS_X] PROGMEM = ARRAY_N(GRID_MAX_POINTS_X,
-  _GRIDPOS(X,  0), _GRIDPOS(X,  1), _GRIDPOS(X,  2), _GRIDPOS(X,  3),
-  _GRIDPOS(X,  4), _GRIDPOS(X,  5), _GRIDPOS(X,  6), _GRIDPOS(X,  7),
-  _GRIDPOS(X,  8), _GRIDPOS(X,  9), _GRIDPOS(X, 10), _GRIDPOS(X, 11),
-  _GRIDPOS(X, 12), _GRIDPOS(X, 13), _GRIDPOS(X, 14), _GRIDPOS(X, 15)
-),
-unified_bed_leveling::_mesh_index_to_ypos[GRID_MAX_POINTS_Y] PROGMEM = ARRAY_N(GRID_MAX_POINTS_Y,
-  _GRIDPOS(Y,  0), _GRIDPOS(Y,  1), _GRIDPOS(Y,  2), _GRIDPOS(Y,  3),
-  _GRIDPOS(Y,  4), _GRIDPOS(Y,  5), _GRIDPOS(Y,  6), _GRIDPOS(Y,  7),
-  _GRIDPOS(Y,  8), _GRIDPOS(Y,  9), _GRIDPOS(Y, 10), _GRIDPOS(Y, 11),
-  _GRIDPOS(Y, 12), _GRIDPOS(Y, 13), _GRIDPOS(Y, 14), _GRIDPOS(Y, 15)
-);
+bed_mesh_t unified_bed_leveling::z_values;
+
+#if !HAS_PROUI_MESH_EDIT
+  #define _GRIDPOS(A,N) (MESH_MIN_##A + N * (MESH_##A##_DIST))
+
+  const float
+  unified_bed_leveling::_mesh_index_to_xpos[GRID_MAX_POINTS_X] PROGMEM = ARRAY_N(GRID_MAX_POINTS_X,
+    _GRIDPOS(X,  0), _GRIDPOS(X,  1), _GRIDPOS(X,  2), _GRIDPOS(X,  3),
+    _GRIDPOS(X,  4), _GRIDPOS(X,  5), _GRIDPOS(X,  6), _GRIDPOS(X,  7),
+    _GRIDPOS(X,  8), _GRIDPOS(X,  9), _GRIDPOS(X, 10), _GRIDPOS(X, 11),
+    _GRIDPOS(X, 12), _GRIDPOS(X, 13), _GRIDPOS(X, 14), _GRIDPOS(X, 15)
+  ),
+  unified_bed_leveling::_mesh_index_to_ypos[GRID_MAX_POINTS_Y] PROGMEM = ARRAY_N(GRID_MAX_POINTS_Y,
+    _GRIDPOS(Y,  0), _GRIDPOS(Y,  1), _GRIDPOS(Y,  2), _GRIDPOS(Y,  3),
+    _GRIDPOS(Y,  4), _GRIDPOS(Y,  5), _GRIDPOS(Y,  6), _GRIDPOS(Y,  7),
+    _GRIDPOS(Y,  8), _GRIDPOS(Y,  9), _GRIDPOS(Y, 10), _GRIDPOS(Y, 11),
+    _GRIDPOS(Y, 12), _GRIDPOS(Y, 13), _GRIDPOS(Y, 14), _GRIDPOS(Y, 15)
+  );
+#endif
 
 volatile int16_t unified_bed_leveling::encoder_diff;
 
@@ -173,8 +175,8 @@ void unified_bed_leveling::display_map(const uint8_t map_type) {
   SERIAL_ECHOPGM("\nBed Topography Report");
   if (human) {
     SERIAL_ECHOLNPGM(":\n");
-    serial_echo_xy(4, MESH_MIN_X, MESH_MAX_Y);
-    serial_echo_xy(twixt, MESH_MAX_X, MESH_MAX_Y);
+    serial_echo_xy(4, mesh_min.x, mesh_max.y);
+    serial_echo_xy(twixt, mesh_max.x, mesh_max.y);
     SERIAL_EOL();
     serial_echo_column_labels(eachsp - 2);
   }
@@ -207,6 +209,7 @@ void unified_bed_leveling::display_map(const uint8_t map_type) {
       const float f = z_values[i][j];
       if (lcd) {
         // TODO: Display on Graphical LCD
+        TERN_(DWIN_LCD_PROUI, dwinMeshViewer());
       }
       else if (isnan(f))
         SERIAL_ECHO(human ? F("  .   ") : F("NAN"));
@@ -231,8 +234,8 @@ void unified_bed_leveling::display_map(const uint8_t map_type) {
   if (human) {
     serial_echo_column_labels(eachsp - 2);
     SERIAL_EOL();
-    serial_echo_xy(4, MESH_MIN_X, MESH_MIN_Y);
-    serial_echo_xy(twixt, MESH_MAX_X, MESH_MIN_Y);
+    serial_echo_xy(4, mesh_min.x, mesh_min.y);
+    serial_echo_xy(twixt, mesh_max.x, mesh_min.y);
     SERIAL_EOL();
     SERIAL_EOL();
   }

Marlin/src/feature/bedlevel/ubl/ubl.h

@@ -38,9 +38,6 @@ enum MeshPointType : char { INVALID, REAL, SET_IN_BITMAP, CLOSEST };
 
 struct mesh_index_pair;
 
-#define MESH_X_DIST (float((MESH_MAX_X) - (MESH_MIN_X)) / (GRID_MAX_CELLS_X))
-#define MESH_Y_DIST (float((MESH_MAX_Y) - (MESH_MIN_Y)) / (GRID_MAX_CELLS_Y))
-
 #if ENABLED(OPTIMIZED_MESH_STORAGE)
   typedef int16_t mesh_store_t[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
 #endif
@@ -116,8 +113,11 @@ class unified_bed_leveling {
     static void set_store_from_mesh(const bed_mesh_t &in_values, mesh_store_t &stored_values);
     static void set_mesh_from_store(const mesh_store_t &stored_values, bed_mesh_t &out_values);
   #endif
-  static const float _mesh_index_to_xpos[GRID_MAX_POINTS_X],
-                     _mesh_index_to_ypos[GRID_MAX_POINTS_Y];
+
+  #if !HAS_PROUI_MESH_EDIT
+    static const float _mesh_index_to_xpos[GRID_MAX_POINTS_X],
+                       _mesh_index_to_ypos[GRID_MAX_POINTS_Y];
+  #endif
 
   #if HAS_MARLINUI_MENU
     static bool lcd_map_control;
@@ -133,11 +133,11 @@ class unified_bed_leveling {
   FORCE_INLINE static void set_z(const int8_t px, const int8_t py, const float z) { z_values[px][py] = z; }
 
   static int8_t cell_index_x_raw(const float x) {
-    return FLOOR((x - (MESH_MIN_X)) * RECIPROCAL(MESH_X_DIST));
+    return FLOOR((x - mesh_min.x) * RECIPROCAL(MESH_X_DIST));
   }
 
   static int8_t cell_index_y_raw(const float y) {
-    return FLOOR((y - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST));
+    return FLOOR((y - mesh_min.y) * RECIPROCAL(MESH_Y_DIST));
   }
 
   static bool cell_index_x_valid(const float x) {
@@ -162,11 +162,11 @@ class unified_bed_leveling {
   static xy_uint8_t cell_indexes(const xy_pos_t &xy) { return cell_indexes(xy.x, xy.y); }
 
   static int8_t closest_x_index(const float x) {
-    const int8_t px = (x - (MESH_MIN_X) + (MESH_X_DIST) * 0.5) * RECIPROCAL(MESH_X_DIST);
+    const int8_t px = (x - mesh_min.x + (MESH_X_DIST) * 0.5) * RECIPROCAL(MESH_X_DIST);
     return WITHIN(px, 0, (GRID_MAX_POINTS_X) - 1) ? px : -1;
   }
   static int8_t closest_y_index(const float y) {
-    const int8_t py = (y - (MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * RECIPROCAL(MESH_Y_DIST);
+    const int8_t py = (y - mesh_min.y + (MESH_Y_DIST) * 0.5) * RECIPROCAL(MESH_Y_DIST);
     return WITHIN(py, 0, (GRID_MAX_POINTS_Y) - 1) ? py : -1;
   }
   static xy_int8_t closest_indexes(const xy_pos_t &xy) {
@@ -259,7 +259,7 @@ class unified_bed_leveling {
      * UBL_Z_RAISE_WHEN_OFF_MESH is specified, that value is returned.
      */
     #ifdef UBL_Z_RAISE_WHEN_OFF_MESH
-      if (!WITHIN(rx0, MESH_MIN_X, MESH_MAX_X) || !WITHIN(ry0, MESH_MIN_Y, MESH_MAX_Y))
+      if (!WITHIN(rx0, mesh_min.x, mesh_max.x) || !WITHIN(ry0, mesh_min.y, mesh_max.y))
         return UBL_Z_RAISE_WHEN_OFF_MESH;
     #endif
 
@@ -287,12 +287,20 @@ class unified_bed_leveling {
 
   static constexpr float get_z_offset() { return 0.0f; }
 
-  static float get_mesh_x(const uint8_t i) {
-    return i < (GRID_MAX_POINTS_X) ? pgm_read_float(&_mesh_index_to_xpos[i]) : MESH_MIN_X + i * (MESH_X_DIST);
-  }
-  static float get_mesh_y(const uint8_t i) {
-    return i < (GRID_MAX_POINTS_Y) ? pgm_read_float(&_mesh_index_to_ypos[i]) : MESH_MIN_Y + i * (MESH_Y_DIST);
-  }
+  static float _get_mesh_x(const uint8_t i) { return mesh_min.x + i * (MESH_X_DIST); }
+  static float _get_mesh_y(const uint8_t i) { return mesh_min.y + i * (MESH_Y_DIST); }
+
+  #if HAS_PROUI_MESH_EDIT
+    static float get_mesh_x(const uint8_t i) { return _get_mesh_x(i); }
+    static float get_mesh_y(const uint8_t i) { return _get_mesh_y(i); }
+  #else
+    static float get_mesh_x(const uint8_t i) {
+      return i < (GRID_MAX_POINTS_X) ? pgm_read_float(&_mesh_index_to_xpos[i]) : _get_mesh_x(i);
+    }
+    static float get_mesh_y(const uint8_t i) {
+      return i < (GRID_MAX_POINTS_Y) ? pgm_read_float(&_mesh_index_to_ypos[i]) : _get_mesh_y(i);
+    }
+  #endif
 
   #if UBL_SEGMENTED
     static bool line_to_destination_segmented(const feedRate_t scaled_fr_mm_s);