Data Science Python Programming Basics Matplotlib LibraryCursor Widget Usage

Cursor Widget Usage

Master Matplotlib

The Matplotlib Cursor Widget provides a powerful and interactive way to explore data plotted on a graph. It allows users to dynamically track the cursor's position, display coordinate and data values in real-time, and even update plot elements based on user input. This makes it an invaluable tool for in-depth data analysis and visualization.

Matplotlib's widgets module offers flexibility in how you implement and utilize cursor functionalities. You can achieve various levels of interactivity, from simply displaying coordinates to creating sophisticated data manipulation tools.

1. Displaying Cursor Coordinates in the Console

A fundamental use case for cursor interaction is to display the mouse's coordinates as it moves over the plot. This can be achieved by connecting a function to the motion_notify_event.

How it works: When the mouse moves over the plot canvas, Matplotlib triggers a motion_notify_event. By connecting a custom function to this event, you can access the cursor's xdata and ydata and perform actions, such as printing them to the console.

Example:

import matplotlib.pyplot as plt

## Function to handle cursor movement
def on_move(event):
    # Check if the cursor is within the plot axes
    if event.inaxes:
        x, y = event.xdata, event.ydata  # Get cursor's x and y data coordinates
        print(f'Cursor at x={x:.2f}, y={y:.2f}')  # Display coordinates formatted to two decimal places

## Create a simple plot
fig, ax = plt.subplots()
ax.plot([1, 2, 3], [4, 5, 6])

## Connect the 'motion_notify_event' to our custom function
plt.connect('motion_notify_event', on_move)

## Display the plot
plt.show()

Output: As you move your mouse over the plot area, the console will continuously display the current x and y coordinates of the cursor.

2. Customizing Cursor Display Information in the Plot

Instead of displaying information in the console, you can update elements within the plot itself, such as the title, to show cursor data. This provides immediate visual feedback directly on the graph.

Example: Updating Plot Title with Cursor Coordinates

import matplotlib.pyplot as plt
import numpy as np

## Generate sample data
x = np.linspace(0, 10, 100)
y = np.sin(x)

## Create a plot
fig, ax = plt.subplots()
line, = ax.plot(x, y)

## Function to update displayed information (plot title) based on cursor position
def update_cursor_info(event):
    if event.inaxes:
        x_cursor, y_cursor = event.xdata, event.ydata
        ax.set_title(f'Cursor at x={x_cursor:.2f}, y={y_cursor:.2f}')
        fig.canvas.draw_idle() # Redraw the canvas efficiently

## Connect 'motion_notify_event' to update_cursor_info function
plt.connect('motion_notify_event', update_cursor_info)

## Display the plot
plt.show()

Output: The plot's title will dynamically update to show the current x and y coordinates of the cursor as it moves across the plot.

3. Integrating Interactive Widgets for Data Manipulation

Matplotlib's widgets module extends interactivity beyond just displaying information. You can incorporate widgets like text boxes to allow users to directly influence the plot's data or appearance.

Example: Updating a Sine Wave's Frequency with a Text Box

import matplotlib.pyplot as plt
from matplotlib.widgets import TextBox
import numpy as np

## Generate sample data
x = np.linspace(0, 10, 100)
y = np.sin(x)

## Create a plot
fig, ax = plt.subplots()
line, = ax.plot(x, y)

## Function to update the plot based on user input from the text box
def update(text):
    try:
        frequency = float(text)  # Get frequency value from input and convert to float
        new_y = np.sin(frequency * x)  # Generate new y values based on the new frequency
        line.set_ydata(new_y)  # Update the plot's y-data
        ax.set_title(f'Sine Wave with Frequency={frequency:.2f}')  # Update the plot title
        fig.canvas.draw_idle()  # Request a redraw of the canvas
    except ValueError:
        print("Invalid input. Please enter a number for frequency.")

## Create a textbox widget for input.
## The arguments [left, bottom, width, height] define the position and size of the textbox.
text_box_ax = plt.axes([0.1, 0.9, 0.1, 0.075])
text_box = TextBox(text_box_ax, 'Frequency', initial='1')
text_box.on_submit(update)  # Connect the 'on_submit' event to our update function

## Display the plot
plt.show()

Output: A text box will appear on the plot. Entering a numerical value for frequency and pressing Enter will dynamically update the displayed sine wave and its corresponding title.

4. Enhancing Interactivity with Buttons

Buttons can be used to control various aspects of a plot, such as toggling the visibility of plotted elements.

Example: Toggling Visibility of a Sine Wave

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.widgets import Button

## Generate sample data
x = np.linspace(0, 10, 100)
y = np.sin(x)

## Create a plot
fig, ax = plt.subplots()
line, = ax.plot(x, y, label='Sine Wave')
ax.legend() # Show the legend to demonstrate visibility toggle

## Function to toggle visibility of the sine wave and its legend
def toggle_visibility(event):
    current_visibility = line.get_visible()
    line.set_visible(not current_visibility)
    if ax.get_legend(): # Check if a legend exists before trying to toggle it
        ax.get_legend().set_visible(not current_visibility)
    fig.canvas.draw_idle()

## Create a button widget
## The arguments [left, bottom, width, height] define the position and size of the button.
button_ax = plt.axes([0.8, 0.025, 0.1, 0.04])
toggle_button = Button(button_ax, 'Toggle Visibility')
toggle_button.on_clicked(toggle_visibility) # Connect the 'on_clicked' event to our toggle function

## Display the plot
plt.show()

Output: A button labeled "Toggle Visibility" will appear on the plot. Clicking this button will hide or show the sine wave and its legend.

5. Tracking Data Points on a Curve with a Custom Cursor

For more precise data point tracking on a curve, you can create a custom cursor class that visually highlights the closest data point to the mouse cursor.

Example: Custom Cursor for a Sine Curve

import matplotlib.pyplot as plt
import numpy as np

plt.rcParams["figure.figsize"] = [7.50, 3.50]
plt.rcParams["figure.autolayout"] = True

class CustomCursor(object):
    def __init__(self, ax, x_data, y_data):
        self.ax = ax
        # Create a vertical line that will follow the cursor's x-position
        self.ly, = ax.plot([0, 0], [-1, 1], color='yellow', alpha=0.5, linestyle='--')
        # Create a marker to highlight the data point
        self.marker, = ax.plot([0], [0], marker="o", color="red", markersize=8, zorder=3)
        self.x_data = x_data
        self.y_data = y_data
        # Create a text object to display data point information
        self.txt = ax.text(0.05, 0.9, '', transform=ax.transAxes) # Position relative to axes

    def mouse_event(self, event):
        if event.inaxes:
            x, y = event.xdata, event.ydata
            # Find the index of the nearest data point to the cursor's x-position
            indx = np.searchsorted(self.x_data, [x])[0]
            # Ensure the index is within the bounds of the data arrays
            indx = min(indx, len(self.x_data) - 1)

            closest_x = self.x_data[indx]
            closest_y = self.y_data[indx]

            # Update the vertical line and marker positions
            self.ly.set_xdata([closest_x, closest_x])
            self.marker.set_data([closest_x], [closest_y])
            # Update the text to show the data point's coordinates
            self.txt.set_text(f'x={closest_x:.2f}, y={closest_y:.2f}')
            self.txt.set_position((closest_x, closest_y)) # Set text position to the data point

            self.ax.figure.canvas.draw_idle() # Redraw the canvas

## Generate sample data for a sine wave
t = np.arange(0.0, 1.0, 0.01)
s = np.sin(4 * np.pi * t) # Frequency of 2 Hz

fig, ax = plt.subplots()

## Create an instance of our custom cursor
cursor = CustomCursor(ax, t, s)
## Connect the 'motion_notify_event' to the cursor's mouse_event method
cid = plt.connect('motion_notify_event', cursor.mouse_event)

ax.plot(t, s, lw=2, color='green', label='Sine Wave')
ax.set_ylim(-1.1, 1.1) # Set y-axis limits for better visualization
ax.legend()

plt.title("Sine Wave with Custom Data Point Cursor")
plt.show()

Output: As you move the cursor over the sine wave, a vertical dashed yellow line will appear at the cursor's x-position, and a red circle marker will highlight the closest data point on the curve. The coordinates of this highlighted point will be displayed near it.

Conclusion

Matplotlib's cursor capabilities, whether through simple event connections or custom widget classes, significantly enhance the interactivity and analytical power of your plots. They empower users to:

Dynamically track cursor positions for precise data reading.
Display coordinates and data values directly on the plot or in the console.
Modify plot parameters and data using interactive widgets like text boxes.
Control plot elements such as visibility with buttons.
Visually pinpoint and inspect specific data points on curves with custom cursor implementations.

By leveraging these features, you can create more engaging and informative visualizations that facilitate deeper data exploration and understanding.