diff --git a/src/libslic3r/Measure.cpp b/src/libslic3r/Measure.cpp
index 852e9268c..ea6850325 100644
--- a/src/libslic3r/Measure.cpp
+++ b/src/libslic3r/Measure.cpp
@@ -708,7 +708,45 @@ MeasurementResult get_measurement(const SurfaceFeature& a, const SurfaceFeature&
             result.distance_infinite = std::make_optional(DistAndPoints{it->dist, it->from, it->to});
     ///////////////////////////////////////////////////////////////////////////
         } else if (f2.get_type() == SurfaceFeatureType::Plane) {
-            result.distance_infinite = std::make_optional(DistAndPoints{0., Vec3d::Zero(), Vec3d::Zero()}); // TODO
+            assert(measuring != nullptr);
+
+            const auto [from, to] = f1.get_edge();
+            const auto [idx, normal, origin] = f2.get_plane();
+
+            const Vec3d edge_unit = (to - from).normalized();
+            if (are_perpendicular(edge_unit, normal)) {
+                std::vector<DistAndPoints> distances;
+                const Eigen::Hyperplane<double, 3> plane(normal, origin);
+                distances.push_back(DistAndPoints{ plane.absDistance(from), from, plane.projection(from) });
+                distances.push_back(DistAndPoints{ plane.absDistance(to), to, plane.projection(to) });
+                auto it = std::min_element(distances.begin(), distances.end(),
+                    [](const DistAndPoints& item1, const DistAndPoints& item2) {
+                        return item1.dist < item2.dist;
+                    });
+                result.distance_infinite = std::make_optional(DistAndPoints{ it->dist, it->from, it->to });
+            }
+            else {
+                const std::vector<SurfaceFeature>& plane_features = measuring->get_plane_features(idx);
+                std::vector<DistAndPoints> distances;
+                for (const SurfaceFeature& sf : plane_features) {
+                    if (sf.get_type() == SurfaceFeatureType::Edge) {
+                        const auto m = get_measurement(sf, f1);
+                        if (!m.distance_infinite.has_value()) {
+                            distances.clear();
+                            break;
+                        }
+                        else
+                            distances.push_back(*m.distance_infinite);
+                    }
+                }
+                if (!distances.empty()) {
+                    auto it = std::min_element(distances.begin(), distances.end(),
+                        [](const DistAndPoints& item1, const DistAndPoints& item2) {
+                            return item1.dist < item2.dist;
+                        });
+                    result.distance_infinite = std::make_optional(DistAndPoints{ it->dist, it->from, it->to });
+                }
+            }
             result.angle = angle_edge_plane(f1.get_edge(), f2.get_plane());
         }
     ///////////////////////////////////////////////////////////////////////////
@@ -729,14 +767,23 @@ MeasurementResult get_measurement(const SurfaceFeature& a, const SurfaceFeature&
                 const std::vector<SurfaceFeature>& plane_features = measuring->get_plane_features(idx2);
                 std::vector<DistAndPoints> distances;
                 for (const SurfaceFeature& sf : plane_features) {
-                    if (sf.get_type() == SurfaceFeatureType::Edge)
-                        distances.push_back(*get_measurement(sf, f1).distance_infinite);
+                    if (sf.get_type() == SurfaceFeatureType::Edge) {
+                        const auto m = get_measurement(sf, f1);
+                        if (!m.distance_infinite.has_value()) {
+                            distances.clear();
+                            break;
+                        }
+                        else
+                            distances.push_back(*m.distance_infinite);
+                    }
+                }
+                if (!distances.empty()) {
+                    auto it = std::min_element(distances.begin(), distances.end(),
+                        [](const DistAndPoints& item1, const DistAndPoints& item2) {
+                            return item1.dist < item2.dist;
+                        });
+                    result.distance_infinite = std::make_optional(DistAndPoints{ it->dist, it->from, it->to });
                 }
-                auto it = std::min_element(distances.begin(), distances.end(),
-                    [](const DistAndPoints& item1, const DistAndPoints& item2) {
-                        return item1.dist < item2.dist;
-                    });
-                result.distance_infinite = std::make_optional(DistAndPoints{ it->dist, it->from, it->to });
             }
         }
     ///////////////////////////////////////////////////////////////////////////
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoMeasure.cpp b/src/slic3r/GUI/Gizmos/GLGizmoMeasure.cpp
index 31ce08fa7..051a7ee40 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoMeasure.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoMeasure.cpp
@@ -891,13 +891,15 @@ void GLGizmoMeasure::render_dimensioning()
 
     auto arc_edge_edge = [this, shader](const Measure::SurfaceFeature& f1, const Measure::SurfaceFeature& f2, double radius = 0.0) {
         assert(f1.get_type() == Measure::SurfaceFeatureType::Edge && f2.get_type() == Measure::SurfaceFeatureType::Edge);
-        const Measure::MeasurementResult res = Measure::get_measurement(f1, f2);
-        const double angle    = res.angle->angle;
-        const Vec3d  center   = res.angle->center;
-        const std::pair<Vec3d, Vec3d> e1 = res.angle->e1;
-        const std::pair<Vec3d, Vec3d> e2 = res.angle->e2;
-        const double calc_radius = res.angle->radius;
-        const bool   coplanar = res.angle->coplanar;
+        if (!m_measurement_result.angle.has_value())
+            return;
+
+        const double angle = m_measurement_result.angle->angle;
+        const Vec3d  center = m_measurement_result.angle->center;
+        const std::pair<Vec3d, Vec3d> e1 = m_measurement_result.angle->e1;
+        const std::pair<Vec3d, Vec3d> e2 = m_measurement_result.angle->e2;
+        const double calc_radius = m_measurement_result.angle->radius;
+        const bool   coplanar = m_measurement_result.angle->coplanar;
 
         if (std::abs(angle) < EPSILON || std::abs(calc_radius) < EPSILON)
             return;
@@ -993,12 +995,15 @@ void GLGizmoMeasure::render_dimensioning()
         ImGui::PopStyleVar();
     };
 
-    auto arc_edge_plane = [arc_edge_edge](const Measure::SurfaceFeature& f1, const Measure::SurfaceFeature& f2) {
+    auto arc_edge_plane = [this, arc_edge_edge](const Measure::SurfaceFeature& f1, const Measure::SurfaceFeature& f2) {
         assert(f1.get_type() == Measure::SurfaceFeatureType::Edge && f2.get_type() == Measure::SurfaceFeatureType::Plane);
-        const Measure::MeasurementResult res = Measure::get_measurement(f1, f2);
-        const std::pair<Vec3d, Vec3d> e1 = res.angle->e1;
-        const std::pair<Vec3d, Vec3d> e2 = res.angle->e2;
-        const double calc_radius = res.angle->radius;
+        if (!m_measurement_result.angle.has_value())
+            return;
+
+        const std::pair<Vec3d, Vec3d> e1 = m_measurement_result.angle->e1;
+        const std::pair<Vec3d, Vec3d> e2 = m_measurement_result.angle->e2;
+        const double calc_radius = m_measurement_result.angle->radius;
+
         if (calc_radius == 0.0)
             return;
 
@@ -1006,12 +1011,12 @@ void GLGizmoMeasure::render_dimensioning()
             Measure::SurfaceFeature(Measure::SurfaceFeatureType::Edge, e2.first, e2.second), calc_radius);
     };
 
-    auto arc_plane_plane = [arc_edge_edge](const Measure::SurfaceFeature& f1, const Measure::SurfaceFeature& f2) {
+    auto arc_plane_plane = [this, arc_edge_edge](const Measure::SurfaceFeature& f1, const Measure::SurfaceFeature& f2) {
         assert(f1.get_type() == Measure::SurfaceFeatureType::Plane && f2.get_type() == Measure::SurfaceFeatureType::Plane);
-        const Measure::MeasurementResult res = Measure::get_measurement(f1, f2);
-        const std::pair<Vec3d, Vec3d> e1 = res.angle->e1;
-        const std::pair<Vec3d, Vec3d> e2 = res.angle->e2;
-        const double calc_radius = res.angle->radius;
+        const std::pair<Vec3d, Vec3d> e1 = m_measurement_result.angle->e1;
+        const std::pair<Vec3d, Vec3d> e2 = m_measurement_result.angle->e2;
+        const double calc_radius = m_measurement_result.angle->radius;
+
         if (calc_radius == 0.0)
             return;