Rework 3d coordinates mouse hover, now displays coordinate of underlying view pane

scottshambaugh · scottshambaugh · commit a0b665d77dd3 · 2023-02-05T16:57:20.000-07:00
diff --git a/lib/mpl_toolkits/mplot3d/axes3d.py b/lib/mpl_toolkits/mplot3d/axes3d.py
@@ -1036,45 +1036,75 @@ def format_zdata(self, z):
             val = func(z)
             return val
 
-    def format_coord(self, xd, yd):
+    def format_coord(self, xd, yd, renderer=None):
         """
         Given the 2D view coordinates attempt to guess a 3D coordinate.
         Looks for the nearest edge to the point and then assumes that
         the point is at the same z location as the nearest point on the edge.
         """
-
         if self.M is None:
-            return ''
+            coords = ''
 
-        if self.button_pressed in self._rotate_btn:
+        elif self.button_pressed in self._rotate_btn:
             # ignore xd and yd and display angles instead
             norm_elev = art3d._norm_angle(self.elev)
             norm_azim = art3d._norm_angle(self.azim)
             norm_roll = art3d._norm_angle(self.roll)
-            return (f"elevation={norm_elev:.0f}\N{DEGREE SIGN}, "
-                    f"azimuth={norm_azim:.0f}\N{DEGREE SIGN}, "
-                    f"roll={norm_roll:.0f}\N{DEGREE SIGN}"
-                    ).replace("-", "\N{MINUS SIGN}")
-
-        # nearest edge
-        p0, p1 = min(self._tunit_edges(),
-                     key=lambda edge: proj3d._line2d_seg_dist(
-                         (xd, yd), edge[0][:2], edge[1][:2]))
-
-        # scale the z value to match
-        x0, y0, z0 = p0
-        x1, y1, z1 = p1
-        d0 = np.hypot(x0-xd, y0-yd)
-        d1 = np.hypot(x1-xd, y1-yd)
-        dt = d0+d1
-        z = d1/dt * z0 + d0/dt * z1
-
-        x, y, z = proj3d.inv_transform(xd, yd, z, self.M)
-
-        xs = self.format_xdata(x)
-        ys = self.format_ydata(y)
-        zs = self.format_zdata(z)
-        return f'x={xs}, y={ys}, z={zs}'
+            coords = (f"elevation={norm_elev:.0f}\N{DEGREE SIGN}, "
+                      f"azimuth={norm_azim:.0f}\N{DEGREE SIGN}, "
+                      f"roll={norm_roll:.0f}\N{DEGREE SIGN}"
+                      ).replace("-", "\N{MINUS SIGN}")
+
+        else:
+            p1 = self._calc_coord(xd, yd, renderer)
+            xs = self.format_xdata(p1[0])
+            ys = self.format_ydata(p1[1])
+            zs = self.format_zdata(p1[2])
+            coords = f'x={xs}, y={ys}, z={zs}'
+
+        return coords
+
+    def _get_camera_loc(self):
+        """
+        Returns the current camera location in data coordinates.
+        """
+        cx, cy, cz, dx, dy, dz = self._get_w_centers_ranges()
+        c = np.array([cx, cy, cz])
+        r = np.array([dx, dy, dz])
+        eye = c + self._view_w * self._dist * r / self._box_aspect
+        return eye
+
+    def _calc_coord(self, xd, yd, renderer=None):
+        """
+        Given the 2D view coordinates, find the point on the nearest axis pane
+        that lies directly below those coordinates.
+        """
+        # convert to data coordinates
+        p1 = np.array(proj3d.inv_transform(xd, yd, -1, self.M))
+
+        vec = self._get_camera_loc() - p1
+
+        if self._focal_length == np.inf:
+            vec = self._view_w
+
+        # Get the pane locations for each of the axes
+        pane_locs = []
+        for axis in self._axis_map.values():
+            xys, loc = axis.active_pane(renderer)
+            pane_locs.append(loc)
+
+        # Find the distance to the nearest pane
+        scales = np.zeros(3)
+        for i in range(3):
+            if vec[i] == 0:
+                scales[i] = np.inf
+            else:
+                scales[i] = (p1[i] - pane_locs[i]) / vec[i]
+        scale = scales[np.argmin(abs(scales))]
+
+        # Calculate the point on the closest pane
+        p2 = p1 - scale*vec
+        return p2
 
     def _on_move(self, event):
         """
@@ -1296,21 +1326,27 @@ def _scale_axis_limits(self, scale_x, scale_y, scale_z):
         scale_z : float
             Scale factor for the z data axis.
         """
-        # Get the axis limits and centers
+        # Get the axis centers and ranges
+        cx, cy, cz, dx, dy, dz = self._get_w_centers_ranges()
+
+        # Set the scaled axis limits
+        self.set_xlim3d(cx - dx*scale_x/2, cx + dx*scale_x/2)
+        self.set_ylim3d(cy - dy*scale_y/2, cy + dy*scale_y/2)
+        self.set_zlim3d(cz - dz*scale_z/2, cz + dz*scale_z/2)
+
+    def _get_w_centers_ranges(self):
+        """Get 3D world centers and axis ranges."""
+        # Calculate center of axis limits
         minx, maxx, miny, maxy, minz, maxz = self.get_w_lims()
         cx = (maxx + minx)/2
         cy = (maxy + miny)/2
         cz = (maxz + minz)/2
 
-        # Scale the data range
-        dx = (maxx - minx)*scale_x
-        dy = (maxy - miny)*scale_y
-        dz = (maxz - minz)*scale_z
-
-        # Set the scaled axis limits
-        self.set_xlim3d(cx - dx/2, cx + dx/2)
-        self.set_ylim3d(cy - dy/2, cy + dy/2)
-        self.set_zlim3d(cz - dz/2, cz + dz/2)
+        # Calculate range of axis limits
+        dx = (maxx - minx)
+        dy = (maxy - miny)
+        dz = (maxz - minz)
+        return cx, cy, cz, dx, dy, dz
 
     def set_zlabel(self, zlabel, fontdict=None, labelpad=None, **kwargs):
         """
diff --git a/lib/mpl_toolkits/mplot3d/axis3d.py b/lib/mpl_toolkits/mplot3d/axis3d.py
@@ -321,6 +321,20 @@ def _get_tickdir(self):
         tickdir = np.roll(info_i, -j)[np.roll(tickdirs_base, j)][i]
         return tickdir
 
+    def active_pane(self, renderer):
+        mins, maxs, centers, deltas, tc, highs = self._get_coord_info(renderer)
+        info = self._axinfo
+        index = info['i']
+        if not highs[index]:
+            loc = mins[index]
+            plane = self._PLANES[2 * index]
+        else:
+            loc = maxs[index]
+            plane = self._PLANES[2 * index + 1]
+        xys = [tc[p] for p in plane]
+        self._set_pane_pos(xys)
+        return xys, loc
+
     def draw_pane(self, renderer):
         """
         Draw pane.
@@ -330,19 +344,9 @@ def draw_pane(self, renderer):
         renderer : `~matplotlib.backend_bases.RendererBase` subclass
         """
         renderer.open_group('pane3d', gid=self.get_gid())
-
-        mins, maxs, centers, deltas, tc, highs = self._get_coord_info(renderer)
-
-        info = self._axinfo
-        index = info['i']
-        if not highs[index]:
-            plane = self._PLANES[2 * index]
-        else:
-            plane = self._PLANES[2 * index + 1]
-        xys = [tc[p] for p in plane]
+        xys, loc = self.active_pane(renderer)
         self._set_pane_pos(xys)
         self.pane.draw(renderer)
-
         renderer.close_group('pane3d')
 
     @artist.allow_rasterization
diff --git a/lib/mpl_toolkits/mplot3d/proj3d.py b/lib/mpl_toolkits/mplot3d/proj3d.py
@@ -8,29 +8,6 @@
 from matplotlib import _api
 
 
-def _line2d_seg_dist(p, s0, s1):
-    """
-    Return the distance(s) from point(s) *p* to segment(s) (*s0*, *s1*).
-
-    Parameters
-    ----------
-    p : (ndim,) or (N, ndim) array-like
-        The points from which the distances are computed.
-    s0, s1 : (ndim,) or (N, ndim) array-like
-        The xy(z...) coordinates of the segment endpoints.
-    """
-    s0 = np.asarray(s0)
-    s01 = s1 - s0  # shape (ndim,) or (N, ndim)
-    s0p = p - s0  # shape (ndim,) or (N, ndim)
-    l2 = s01 @ s01  # squared segment length
-    # Avoid div. by zero for degenerate segments (for them, s01 = (0, 0, ...)
-    # so the value of l2 doesn't matter; this just replaces 0/0 by 0/1).
-    l2 = np.where(l2, l2, 1)
-    # Project onto segment, without going past segment ends.
-    p1 = s0 + np.multiply.outer(np.clip(s0p @ s01 / l2, 0, 1), s01)
-    return ((p - p1) ** 2).sum(axis=-1) ** (1/2)
-
-
 def world_transformation(xmin, xmax,
                          ymin, ymax,
                          zmin, zmax, pb_aspect=None):
@@ -220,10 +197,8 @@ def inv_transform(xs, ys, zs, M):
     iM = linalg.inv(M)
     vec = _vec_pad_ones(xs, ys, zs)
     vecr = np.dot(iM, vec)
-    try:
+    if vecr[3] != 0:
         vecr = vecr / vecr[3]
-    except OverflowError:
-        pass
     return vecr[0], vecr[1], vecr[2]
 
 
diff --git a/lib/mpl_toolkits/mplot3d/tests/baseline_images/test_axes3d/proj3d_lines_dists.png b/lib/mpl_toolkits/mplot3d/tests/baseline_images/test_axes3d/proj3d_lines_dists.png
diff --git a/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py b/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py
@@ -1116,39 +1116,6 @@ def test_world():
                                 [0, 0, 0, 1]])
 
 
-@mpl3d_image_comparison(['proj3d_lines_dists.png'])
-def test_lines_dists():
-    fig, ax = plt.subplots(figsize=(4, 6), subplot_kw=dict(aspect='equal'))
-
-    xs = (0, 30)
-    ys = (20, 150)
-    ax.plot(xs, ys)
-    p0, p1 = zip(xs, ys)
-
-    xs = (0, 0, 20, 30)
-    ys = (100, 150, 30, 200)
-    ax.scatter(xs, ys)
-
-    dist0 = proj3d._line2d_seg_dist((xs[0], ys[0]), p0, p1)
-    dist = proj3d._line2d_seg_dist(np.array((xs, ys)).T, p0, p1)
-    assert dist0 == dist[0]
-
-    for x, y, d in zip(xs, ys, dist):
-        c = Circle((x, y), d, fill=0)
-        ax.add_patch(c)
-
-    ax.set_xlim(-50, 150)
-    ax.set_ylim(0, 300)
-
-
-def test_lines_dists_nowarning():
-    # No RuntimeWarning must be emitted for degenerate segments, see GH#22624.
-    s0 = (10, 30, 50)
-    p = (20, 150, 180)
-    proj3d._line2d_seg_dist(p, s0, s0)
-    proj3d._line2d_seg_dist(np.array(p), s0, s0)
-
-
 def test_autoscale():
     fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
     assert ax.get_zscale() == 'linear'
