deprecate get_plot_axes (with legacy testing)

murrayrm · murrayrm · commit 4f4746dd89a9 · 2024-08-08T14:54:49.000-07:00
diff --git a/control/ctrlplot.py b/control/ctrlplot.py
@@ -148,7 +148,8 @@ class ControlPlot(object):
     def __init__(self, lines, axes=None, figure=None, legend=None):
         self.lines = lines
         if axes is None:
-            axes = get_plot_axes(lines)
+            _get_axes = np.vectorize(lambda lines: lines[0].axes)
+            axes = _get_axes(lines)
         self.axes = np.atleast_2d(axes)
         if figure is None:
             figure = self.axes[0, 0].figure
@@ -240,6 +241,7 @@ def get_plot_axes(line_array):
     Only the first element of each array entry is used to determine the axes.
 
     """
+    warnings.warn("get_plot_axes is deprecated; use cplt.axes", FutureWarning)
     _get_axes = np.vectorize(lambda lines: lines[0].axes)
     if isinstance(line_array, ControlPlot):
         return _get_axes(line_array.lines)
diff --git a/control/tests/ctrlplot_test.py b/control/tests/ctrlplot_test.py
@@ -89,9 +89,10 @@ def test_plot_ax_processing(resp_fcn, plot_fcn):
     get_line_color = lambda cplt: cplt.lines.reshape(-1)[0][0].get_color()
     match resp_fcn, plot_fcn:
         case ct.describing_function_response, _:
+            sys = ct.tf([1], [1, 2, 2, 1])
             F = ct.descfcn.saturation_nonlinearity(1)
             amp = np.linspace(1, 4, 10)
-            args = (sys1, F, amp)
+            args = (sys, F, amp)
             resp_kwargs = plot_kwargs = {'refine': False}
 
         case ct.gangof4_response, _:
@@ -224,6 +225,8 @@ def test_plot_label_processing(resp_fcn, plot_fcn):
     expected_labels = ["sys1_", "sys2_"]
     match resp_fcn, plot_fcn:
         case ct.describing_function_response, _:
+            sys1 = ct.tf([1], [1, 2, 2, 1], name="sys[1]")
+            sys2 = ct.tf([1.1], [1, 2, 2, 1], name="sys[2]")
             F = ct.descfcn.saturation_nonlinearity(1)
             amp = np.linspace(1, 4, 10)
             args1 = (sys1, F, amp)
@@ -332,6 +335,8 @@ def test_siso_plot_legend_processing(resp_fcn, plot_fcn):
     default_labels = ["sys[1]", "sys[2]"]
     match resp_fcn, plot_fcn:
         case ct.describing_function_response, _:
+            sys1 = ct.tf([1], [1, 2, 2, 1], name="sys[1]")
+            sys2 = ct.tf([1.1], [1, 2, 2, 1], name="sys[2]")
             F = ct.descfcn.saturation_nonlinearity(1)
             amp = np.linspace(1, 4, 10)
             args1 = (sys1, F, amp)
@@ -488,6 +493,8 @@ def test_plot_title_processing(resp_fcn, plot_fcn):
     expected_title = "sys1_, sys2_"
     match resp_fcn, plot_fcn:
         case ct.describing_function_response, _:
+            sys1 = ct.tf([1], [1, 2, 2, 1], name="sys[1]")
+            sys2 = ct.tf([1.1], [1, 2, 2, 1], name="sys[2]")
             F = ct.descfcn.saturation_nonlinearity(1)
             amp = np.linspace(1, 4, 10)
             args1 = (sys1, F, amp)
@@ -617,6 +624,8 @@ def test_rcParams(resp_fcn, plot_fcn):
     expected_title = "sys1_, sys2_"
     match resp_fcn, plot_fcn:
         case ct.describing_function_response, _:
+            sys1 = ct.tf([1], [1, 2, 2, 1], name="sys[1]")
+            sys2 = ct.tf([1], [1, 2, 2, 1], name="sys[2]")
             F = ct.descfcn.saturation_nonlinearity(1)
             amp = np.linspace(1, 4, 10)
             args1 = (sys1, F, amp)
@@ -747,8 +756,29 @@ def test_rcParams(resp_fcn, plot_fcn):
         assert ct.ctrlplot.rcParams[key] != my_rcParams[key]
 
 
-def test_deprecation_warning():
+def test_deprecation_warnings():
     sys = ct.rss(2, 2, 2)
     lines = ct.step_response(sys).plot(overlay_traces=True)
     with pytest.warns(FutureWarning, match="deprecated"):
         assert len(lines[0, 0]) == 2
+
+    cplt = ct.step_response(sys).plot()
+    with pytest.warns(FutureWarning, match="deprecated"):
+        axs = ct.get_plot_axes(cplt)
+        assert np.all(axs == cplt.axes)
+
+    with pytest.warns(FutureWarning, match="deprecated"):
+        axs = ct.get_plot_axes(cplt.lines)
+        assert np.all(axs == cplt.axes)
+
+
+def test_ControlPlot_init():
+    sys = ct.rss(2, 2, 2)
+    cplt = ct.step_response(sys).plot()
+
+    # Create a ControlPlot from data, without the axes or figure
+    cplt_raw = ct.ControlPlot(cplt.lines)
+    assert np.all(cplt_raw.lines == cplt.lines)
+    assert np.all(cplt_raw.axes == cplt.axes)
+    assert cplt_raw.figure == cplt.figure
+
diff --git a/control/tests/freqplot_test.py b/control/tests/freqplot_test.py
@@ -142,7 +142,7 @@ def test_response_plots(
 def test_manual_response_limits():
     # Default response: limits should be the same across rows
     cplt = manual_response.plot()
-    axs = ct.get_plot_axes(cplt)        # legacy usage OK
+    axs = cplt.axes
     for i in range(manual_response.noutputs):
         for j in range(1, manual_response.ninputs):
             # Everything in the same row should have the same limits
@@ -305,8 +305,8 @@ def test_bode_share_options():
     ct.set_defaults('freqplot', title_frame='figure')
 
     # Default sharing should share along rows and cols for mag and phase
-    lines = ct.bode_plot(manual_response)
-    axs = ct.get_plot_axes(lines)
+    cplt = ct.bode_plot(manual_response)
+    axs = cplt.axes
     for i in range(axs.shape[0]):
         for j in range(axs.shape[1]):
             # Share y limits along rows
@@ -317,8 +317,8 @@ def test_bode_share_options():
 
     # Sharing along y axis for mag but not phase
     plt.figure()
-    lines = ct.bode_plot(manual_response, share_phase='none')
-    axs = ct.get_plot_axes(lines)
+    cplt = ct.bode_plot(manual_response, share_phase='none')
+    axs = cplt.axes
     for i in range(int(axs.shape[0] / 2)):
         for j in range(axs.shape[1]):
             if i != 0:
@@ -330,8 +330,8 @@ def test_bode_share_options():
 
     # Turn off sharing for magnitude and phase
     plt.figure()
-    lines = ct.bode_plot(manual_response, sharey='none')
-    axs = ct.get_plot_axes(lines)
+    cplt = ct.bode_plot(manual_response, sharey='none')
+    axs = cplt.axes
     for i in range(int(axs.shape[0] / 2)):
         for j in range(axs.shape[1]):
             if i != 0:
@@ -345,7 +345,7 @@ def test_bode_share_options():
 
     # Turn off sharing in x axes
     plt.figure()
-    lines = ct.bode_plot(manual_response, sharex='none')
+    cplt = ct.bode_plot(manual_response, sharex='none')
     # TODO: figure out what to check
 
 
@@ -355,11 +355,11 @@ def test_freqplot_plot_type(plot_type):
         response = ct.singular_values_response(ct.rss(2, 1, 1))
     else:
         response = ct.frequency_response(ct.rss(2, 1, 1))
-    lines = response.plot(plot_type=plot_type)
+    cplt = response.plot(plot_type=plot_type)
     if plot_type == 'bode':
-        assert lines.shape == (2, 1)
+        assert cplt.lines.shape == (2, 1)
     else:
-        assert lines.shape == (1, )
+        assert cplt.lines.shape == (1, )
 
 @pytest.mark.parametrize("plt_fcn", [ct.bode_plot, ct.singular_values_plot])
 @pytest.mark.usefixtures("editsdefaults")
@@ -379,14 +379,14 @@ def _get_visible_limits(ax):
         ct.tf([1], [1, 2, 1]), np.logspace(-1, 1))
 
     # Generate a plot without overridding the limits
-    lines = plt_fcn(response)
-    ax = ct.get_plot_axes(lines)
+    cplt = plt_fcn(response)
+    ax = cplt.axes
     np.testing.assert_allclose(
         _get_visible_limits(ax.reshape(-1)[0]), np.array([0.1, 10]))
 
     # Now reset the limits
-    lines = plt_fcn(response, omega_limits=(1, 100))
-    ax = ct.get_plot_axes(lines)
+    cplt = plt_fcn(response, omega_limits=(1, 100))
+    ax = cplt.axes
     np.testing.assert_allclose(
         _get_visible_limits(ax.reshape(-1)[0]), np.array([1, 100]))
 
@@ -400,7 +400,7 @@ def test_gangof4_trace_labels():
     # Make sure default labels are as expected
     cplt = ct.gangof4_response(P1, C1).plot()
     cplt = ct.gangof4_response(P2, C2).plot()
-    axs = ct.get_plot_axes(cplt)        # legacy usage OK
+    axs = cplt.axes
     legend = axs[0, 1].get_legend().get_texts()
     assert legend[0].get_text() == 'P=P1, C=C1'
     assert legend[1].get_text() == 'P=P2, C=C2'
@@ -409,7 +409,7 @@ def test_gangof4_trace_labels():
     # Suffix truncation
     cplt = ct.gangof4_response(P1, C1).plot()
     cplt = ct.gangof4_response(P2, C1).plot()
-    axs = ct.get_plot_axes(cplt)        # legacy usage OK
+    axs = cplt.axes
     legend = axs[0, 1].get_legend().get_texts()
     assert legend[0].get_text() == 'P=P1'
     assert legend[1].get_text() == 'P=P2'
@@ -418,7 +418,7 @@ def test_gangof4_trace_labels():
     # Prefix turncation
     cplt = ct.gangof4_response(P1, C1).plot()
     cplt = ct.gangof4_response(P1, C2).plot()
-    axs = ct.get_plot_axes(cplt)        # legacy usage OK
+    axs = cplt.axes
     legend = axs[0, 1].get_legend().get_texts()
     assert legend[0].get_text() == 'C=C1'
     assert legend[1].get_text() == 'C=C2'
@@ -427,7 +427,7 @@ def test_gangof4_trace_labels():
     # Override labels
     cplt = ct.gangof4_response(P1, C1).plot(label='xxx, line1, yyy')
     cplt = ct.gangof4_response(P2, C2).plot(label='xxx, line2, yyy')
-    axs = ct.get_plot_axes(cplt)        # legacy usage OK
+    axs = cplt.axes
     legend = axs[0, 1].get_legend().get_texts()
     assert legend[0].get_text() == 'xxx, line1, yyy'
     assert legend[1].get_text() == 'xxx, line2, yyy'
@@ -446,7 +446,7 @@ def test_freqplot_line_labels(plt_fcn):
 
     # Make sure default labels are as expected
     cplt = plt_fcn([sys1, sys2])
-    axs = ct.get_plot_axes(cplt)        # legacy usage OK
+    axs = cplt.axes
     if axs.ndim == 1:
         legend = axs[0].get_legend().get_texts()
     else:
@@ -457,7 +457,7 @@ def test_freqplot_line_labels(plt_fcn):
 
     # Override labels all at once
     cplt = plt_fcn([sys1, sys2], label=['line1', 'line2'])
-    axs = ct.get_plot_axes(cplt)        # legacy usage OK
+    axs = cplt.axes
     if axs.ndim == 1:
         legend = axs[0].get_legend().get_texts()
     else:
@@ -469,7 +469,7 @@ def test_freqplot_line_labels(plt_fcn):
     # Override labels one at a time
     cplt = plt_fcn(sys1, label='line1')
     cplt = plt_fcn(sys2, label='line2')
-    axs = ct.get_plot_axes(cplt)        # legacy usage OK
+    axs = cplt.axes
     if axs.ndim == 1:
         legend = axs[0].get_legend().get_texts()
     else:
@@ -495,7 +495,7 @@ def test_line_labels_bode(kwargs, labels):
         ct.bode_plot([sys1, sys2], label=['line1'])
 
     cplt = ct.bode_plot([sys1, sys2], label=labels, **kwargs)
-    axs = ct.get_plot_axes(cplt)        # legacy usage OK
+    axs = cplt.axes
     legend_texts = axs[0, -1].get_legend().get_texts()
     for i, legend in enumerate(legend_texts):
         assert legend.get_text() == labels[i]
@@ -524,7 +524,7 @@ def test_freqplot_ax_keyword(plt_fcn, ninputs, noutputs):
     cplt1 = plt_fcn(sys)
 
     # Draw again on the same figure, using array
-    axs = ct.get_plot_axes(cplt1)       # legacy usage OK
+    axs = cplt1.axes
     cplt2 = plt_fcn(sys, ax=axs)
     np.testing.assert_equal(cplt1.axes, cplt2.axes)
 
diff --git a/control/tests/timeplot_test.py b/control/tests/timeplot_test.py
@@ -194,8 +194,6 @@ def test_response_plots(
 
 @pytest.mark.usefixtures('mplcleanup')
 def test_axes_setup():
-    get_plot_axes = ct.get_plot_axes
-
     sys_2x3 = ct.rss(4, 2, 3)
     sys_2x3b = ct.rss(4, 2, 3)
     sys_3x2 = ct.rss(4, 3, 2)
@@ -204,30 +202,30 @@ def test_axes_setup():
     # Two plots of the same size leaves axes unchanged
     cplt1 = ct.step_response(sys_2x3).plot()
     cplt2 = ct.step_response(sys_2x3b).plot()
-    np.testing.assert_equal(get_plot_axes(cplt1), get_plot_axes(cplt2))
+    np.testing.assert_equal(cplt1.axes, cplt2.axes)
     plt.close()
 
     # Two plots of same net size leaves axes unchanged (unfortunately)
     cplt1 = ct.step_response(sys_2x3).plot()
     cplt2 = ct.step_response(sys_3x2).plot()
     np.testing.assert_equal(
-        get_plot_axes(cplt1).reshape(-1), get_plot_axes(cplt2).reshape(-1))
+        cplt1.axes.reshape(-1), cplt2.axes.reshape(-1))
     plt.close()
 
     # Plots of different shapes generate new plots
     cplt1 = ct.step_response(sys_2x3).plot()
     cplt2 = ct.step_response(sys_3x1).plot()
-    ax1_list = get_plot_axes(cplt1).reshape(-1).tolist()
-    ax2_list = get_plot_axes(cplt2).reshape(-1).tolist()
+    ax1_list = cplt1.axes.reshape(-1).tolist()
+    ax2_list = cplt2.axes.reshape(-1).tolist()
     for ax in ax1_list:
         assert ax not in ax2_list
     plt.close()
 
     # Passing a list of axes preserves those axes
     cplt1 = ct.step_response(sys_2x3).plot()
     cplt2 = ct.step_response(sys_3x1).plot()
-    cplt3 = ct.step_response(sys_2x3b).plot(ax=get_plot_axes(cplt1))
-    np.testing.assert_equal(get_plot_axes(cplt1), get_plot_axes(cplt3))
+    cplt3 = ct.step_response(sys_2x3b).plot(ax=cplt1.axes)
+    np.testing.assert_equal(cplt1.axes, cplt3.axes)
     plt.close()
 
     # Sending an axes array of the wrong size raises exception
@@ -433,7 +431,7 @@ def test_timeplot_trace_labels(resp_fcn):
 
     # Make sure default labels are as expected
     cplt = resp_fcn([sys1, sys2], **kwargs).plot()
-    axs = ct.get_plot_axes(cplt.lines)
+    axs = cplt.axes
     if axs.ndim == 1:
         legend = axs[0].get_legend().get_texts()
     else:
@@ -444,7 +442,7 @@ def test_timeplot_trace_labels(resp_fcn):
 
     # Override labels all at once
     cplt = resp_fcn([sys1, sys2], **kwargs).plot(label=['line1', 'line2'])
-    axs = ct.get_plot_axes(cplt.lines)
+    axs = cplt.axes
     if axs.ndim == 1:
         legend = axs[0].get_legend().get_texts()
     else:
@@ -456,7 +454,7 @@ def test_timeplot_trace_labels(resp_fcn):
     # Override labels one at a time
     cplt = resp_fcn(sys1, **kwargs).plot(label='line1')
     cplt = resp_fcn(sys2, **kwargs).plot(label='line2')
-    axs = ct.get_plot_axes(cplt.lines)
+    axs = cplt.axes
     if axs.ndim == 1:
         legend = axs[0].get_legend().get_texts()
     else:
@@ -489,7 +487,7 @@ def test_full_label_override():
     cplt = ct.step_response([sys1, sys2]).plot(
         overlay_signals=True, overlay_traces=True, plot_inputs=True,
         label=labels_4d)
-    axs = ct.get_plot_axes(cplt.lines)
+    axs = cplt.axes
     assert axs.shape == (2, 1)
     legend_text = axs[0, 0].get_legend().get_texts()
     for i, label in enumerate(labels_2d[0]):
@@ -502,7 +500,7 @@ def test_full_label_override():
     cplt = ct.step_response([sys1, sys2]).plot(
         overlay_signals=True, overlay_traces=True, plot_inputs=True,
         label=labels_2d)
-    axs = ct.get_plot_axes(cplt.lines)
+    axs = cplt.axes
     assert axs.shape == (2, 1)
     legend_text = axs[0, 0].get_legend().get_texts()
     for i, label in enumerate(labels_2d[0]):
@@ -522,7 +520,7 @@ def test_relabel():
 
     # Generate a new plot, which overwrites labels
     cplt = ct.step_response(sys2).plot()
-    ax = ct.get_plot_axes(cplt.lines)
+    ax = cplt.axes
     assert ax[0, 0].get_ylabel() == 'y[0]'
 
     # Regenerate the first plot
@@ -570,23 +568,23 @@ def test_legend_customization():
 
     # Generic input/output plot
     cplt = resp.plot(overlay_signals=True)
-    axs = ct.get_plot_axes(cplt.lines)
+    axs = cplt.axes
     assert axs[0, 0].get_legend()._loc == 7                 # center right
     assert len(axs[0, 0].get_legend().get_texts()) == 2
     assert axs[1, 0].get_legend() == None
     plt.close()
 
     # Hide legend
     cplt = resp.plot(overlay_signals=True, show_legend=False)
-    axs = ct.get_plot_axes(cplt.lines)
+    axs = cplt.axes
     assert axs[0, 0].get_legend() == None
     assert axs[1, 0].get_legend() == None
     plt.close()
 
     # Put legend in both axes
     cplt = resp.plot(
         overlay_signals=True, legend_map=[['center left'], ['center right']])
-    axs = ct.get_plot_axes(cplt.lines)
+    axs = cplt.axes
     assert axs[0, 0].get_legend()._loc == 6                 # center left
     assert len(axs[0, 0].get_legend().get_texts()) == 2
     assert axs[1, 0].get_legend()._loc == 7                 # center right
