API for module: spikeinterface.widgets

Class: AgreementMatrixWidget
  Docstring:
        Plots sorting comparison agreement matrix.
    
        Parameters
        ----------
        sorting_comparison : GroundTruthComparison or SymmetricSortingComparison
            The sorting comparison object.
            Can optionally be symmetric if given a SymmetricSortingComparison
        ordered : bool, default: True
            Order units with best agreement scores.
            If True, agreement scores can be seen along a diagonal
        count_text : bool, default: True
            If True counts are displayed as text
        unit_ticks : bool, default: True
            If True unit tick labels are displayed
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_comparison, ordered=True, count_text=True, unit_ticks=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: AllAmplitudesDistributionsWidget
  Docstring:
        Plots distributions of amplitudes as violin plot for all or some units.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer
        unit_ids : list
            List of unit ids, default None
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, unit_colors=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: AmplitudesWidget
  Docstring:
        Plots spike amplitudes
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The input waveform extractor
        unit_ids : list or None, default: None
            List of unit ids
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        segment_index : int or None, default: None
            The segment index (or None if mono-segment)
        max_spikes_per_unit : int or None, default: None
            Number of max spikes per unit to display. Use None for all spikes
        y_lim : tuple or None, default: None
            The min and max depth to display, if None (min and max of the amplitudes).
        scatter_decimate : int, default: 1
            If equal to n, each nth spike is kept for plotting.
        hide_unit_selector : bool, default: False
            If True the unit selector is not displayed
            (sortingview backend)
        plot_histogram : bool, default: False
            If True, an histogram of the amplitudes is plotted on the right axis
            (matplotlib backend)
        bins : int or None, default: None
            If plot_histogram is True, the number of bins for the amplitude histogram.
            If None, uses 100 bins.
        plot_legend : bool, default: True
            True includes legend in plot
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, unit_colors=None, segment_index=None, max_spikes_per_unit=None, y_lim=None, scatter_decimate=1, hide_unit_selector=False, plot_histograms=False, bins=None, plot_legend=True, backend=None, **backend_kwargs)
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: AutoCorrelogramsWidget
  Docstring:
        Plots unit cross correlograms.
    
        Parameters
        ----------
        sorting_analyzer_or_sorting : SortingAnalyzer or BaseSorting
            The object to compute/get crosscorrelograms from
        unit_ids  list or None, default: None
            List of unit ids
        min_similarity_for_correlograms : float, default: 0.2
            For sortingview backend. Threshold for computing pair-wise cross-correlograms.
            If template similarity between two units is below this threshold, the cross-correlogram is not displayed.
            For auto-correlograms plot, this is automatically set to None.
        window_ms : float, default: 100.0
            Window for CCGs in ms. If correlograms are already computed (e.g. with SortingAnalyzer),
            this argument is ignored
        bin_ms : float, default: 1.0
            Bin size in ms. If correlograms are already computed (e.g. with SortingAnalyzer),
            this argument is ignored
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        backend: str
        
        * matplotlib
        * sortingview
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, *args, **kargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: ComparisonCollisionBySimilarityWidget
  Docstring:
        Plots CollisionGTComparison pair by pair orderer by cosine_similarity
    
        Parameters
        ----------
        comp : CollisionGTComparison
            The collision ground truth comparison object
        templates : array
            template of units
        mode : "heatmap" or "lines"
            to see collision curves for every pairs ("heatmap") or as lines averaged over pairs.
        similarity_bins : array
            if mode is "lines", the bins used to average the pairs
        cmap : string
            colormap used to show averages if mode is "lines"
        metric : "cosine_similarity"
            metric for ordering
        good_only : True
            keep only the pairs with a non zero accuracy (found templates)
        min_accuracy : float
            If good only, the minimum accuracy every cell should have, individually, to be
            considered in a putative pair
        unit_ids : list
            List of considered units
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, comp, templates, unit_ids=None, metric='cosine_similarity', figure=None, ax=None, mode='heatmap', similarity_bins=array([-4.00000000e-01, -2.00000000e-01, -5.55111512e-17,  2.00000000e-01,
        4.00000000e-01,  6.00000000e-01,  8.00000000e-01,  1.00000000e+00]), cmap='winter', good_only=False, min_accuracy=0.9, show_legend=False, ylim=(0, 1), backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: ConfusionMatrixWidget
  Docstring:
        Plots sorting comparison confusion matrix.
    
        Parameters
        ----------
        gt_comparison : GroundTruthComparison
            The ground truth sorting comparison object
        count_text : bool
            If True counts are displayed as text
        unit_ticks : bool
            If True unit tick labels are displayed
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, gt_comparison, count_text=True, unit_ticks=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: CrossCorrelogramsWidget
  Docstring:
        Plots unit cross correlograms.
    
        Parameters
        ----------
        sorting_analyzer_or_sorting : SortingAnalyzer or BaseSorting
            The object to compute/get crosscorrelograms from
        unit_ids  list or None, default: None
            List of unit ids
        min_similarity_for_correlograms : float, default: 0.2
            For sortingview backend. Threshold for computing pair-wise cross-correlograms.
            If template similarity between two units is below this threshold, the cross-correlogram is not displayed.
            For auto-correlograms plot, this is automatically set to None.
        window_ms : float, default: 100.0
            Window for CCGs in ms. If correlograms are already computed (e.g. with SortingAnalyzer),
            this argument is ignored
        bin_ms : float, default: 1.0
            Bin size in ms. If correlograms are already computed (e.g. with SortingAnalyzer),
            this argument is ignored
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        backend: str
        
        * matplotlib
        * sortingview
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer_or_sorting: 'Union[SortingAnalyzer, BaseSorting]', unit_ids=None, min_similarity_for_correlograms=0.2, window_ms=100.0, bin_ms=1.0, hide_unit_selector=False, unit_colors=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: DriftRasterMapWidget
  Docstring:
        Plot the drift raster map from peaks or a SortingAnalyzer.
        The drift raster map is a scatter plot of the estimated peak depth vs time and it is
        useful to visualize the drift over the course of the recording.
    
        Parameters
        ----------
        peaks : np.array | None, default: None
            The peaks array, with dtype ("sample_index", "channel_index", "amplitude", "segment_index"),
            as returned by the `detect_peaks` or `correct_motion` functions.
        peak_locations : np.array | None, default: None
            The peak locations, with dtype ("x", "y") or ("x", "y", "z"), as returned by the
            `localize_peaks` or `correct_motion` functions.
        sorting_analyzer : SortingAnalyzer | None, default: None
            The sorting analyzer object. To use this function, the `SortingAnalyzer` must have the
            "spike_locations" extension computed.
        direction : "x" or "y", default: "y"
            The direction to display. "y" is the depth direction.
        segment_index : int, default: None
            The segment index to display.
        recording : RecordingExtractor | None, default: None
            The recording extractor object (only used to get "real" times).
        segment_index : int, default: 0
            The segment index to display.
        sampling_frequency : float, default: None
            The sampling frequency (needed if recording is None).
        depth_lim : tuple or None, default: None
            The min and max depth to display, if None (min and max of the recording).
        scatter_decimate : int, default: None
            If equal to n, each nth spike is kept for plotting.
        color_amplitude : bool, default: True
            If True, the color of the scatter points is the amplitude of the peaks.
        cmap : str, default: "inferno"
            The colormap to use for the amplitude.
        color : str, default: "Gray"
            The color of the scatter points if color_amplitude is False.
        clim : tuple or None, default: None
            The min and max amplitude to display, if None (min and max of the amplitudes).
        alpha : float, default: 1
            The alpha of the scatter points.
        backend: str
        
        * matplotlib
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, peaks: 'np.array | None' = None, peak_locations: 'np.array | None' = None, sorting_analyzer: 'SortingAnalyzer | None' = None, direction: 'str' = 'y', recording: 'BaseRecording | None' = None, sampling_frequency: 'float | None' = None, segment_index: 'int | None' = None, depth_lim: 'tuple[float, float] | None' = None, color_amplitude: 'bool' = True, scatter_decimate: 'int | None' = None, cmap: 'str' = 'inferno', color: 'str' = 'Gray', clim: 'tuple[float, float] | None' = None, alpha: 'float' = 1, backend: 'str | None' = None, **backend_kwargs)

Class: ISIDistributionWidget
  Docstring:
        Plots spike train ISI distribution.
    
        Parameters
        ----------
        sorting : SortingExtractor
            The sorting extractor object
        unit_ids : list
            List of unit ids
        bins_ms : int
            Bin size in ms
        window_ms : float
            Window size in ms
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting, unit_ids=None, window_ms=100.0, bin_ms=1.0, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: LocationsWidget
  Docstring:
        Plots spike locations as a function of time
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The input sorting analyzer
        unit_ids : list or None, default: None
            List of unit ids
        segment_index : int or None, default: None
            The segment index (or None if mono-segment)
        max_spikes_per_unit : int or None, default: None
            Number of max spikes per unit to display. Use None for all spikes
        plot_histogram : bool, default: False
            If True, an histogram of the locations is plotted on the right axis
            (matplotlib backend)
        bins : int or None, default: None
            If plot_histogram is True, the number of bins for the location histogram.
            If None this is automatically adjusted
        plot_legend : bool, default: True
            True includes legend in plot
        locations_axis : str, default: 'y'
            Which location axis to use when plotting locations.
        backend: str
        
        * matplotlib
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, unit_colors=None, segment_index=None, max_spikes_per_unit=None, plot_histograms=False, bins=None, plot_legend=True, locations_axis='y', backend=None, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: MotionInfoWidget
  Docstring:
        Plot motion information from the motion_info dictionary returned by the `correct_motion()` funciton.
        This widget plots:
            * the motion iself
            * the drift raster map (peak depth vs time) before correction
            * the drift raster map (peak depth vs time) after correction
    
        Parameters
        ----------
        motion_info : dict
            The motion info returned by correct_motion() or loaded back with load_motion_info().
        recording : RecordingExtractor
            The recording extractor object
        segment_index : int, default: None
            The segment index to display.
        sampling_frequency : float, default: None
            The sampling frequency (needed if recording is None).
        depth_lim : tuple or None, default: None
            The min and max depth to display, if None (min and max of the recording).
        motion_lim : tuple or None, default: None
            The min and max motion to display, if None (min and max of the motion).
        scatter_decimate : int, default: None
            If equal to n, each nth spike is kept for plotting.
        color_amplitude : bool, default: False
            If True, the color of the scatter points is the amplitude of the peaks.
        amplitude_cmap : str, default: "inferno"
            The colormap to use for the amplitude.
        amplitude_color : str, default: "Gray"
            The color of the scatter points if color_amplitude is False.
        amplitude_clim : tuple or None, default: None
            The min and max amplitude to display, if None (min and max of the amplitudes).
        amplitude_alpha : float, default: 1
            The alpha of the scatter points.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, motion_info: 'dict', recording: 'BaseRecording', segment_index: 'int | None' = None, depth_lim: 'tuple[float, float] | None' = None, motion_lim: 'tuple[float, float] | None' = None, color_amplitude: 'bool' = False, scatter_decimate: 'int | None' = None, amplitude_cmap: 'str' = 'inferno', amplitude_color: 'str' = 'Gray', amplitude_clim: 'tuple[float, float] | None' = None, amplitude_alpha: 'float' = 1, backend: 'str | None' = None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: MotionWidget
  Docstring:
        Plot the Motion object.
    
        Parameters
        ----------
        motion : Motion
            The motion object.
        segment_index : int | None, default: None
            If Motion is multi segment, the must be not None.
        mode : "auto" | "line" | "map", default: "line"
            How to plot the motion.
            "line" plots estimated motion at different depths as lines.
            "map" plots estimated motion at different depths as a heatmap.
            "auto" makes it automatic depending on the number of motion depths.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, motion: 'Motion', segment_index: 'int | None' = None, mode: 'str' = 'line', motion_lim: 'float | None' = None, backend: 'str | None' = None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: MultiCompAgreementBySorterWidget
  Docstring:
        Plots multi comparison agreement as pie or bar plot.
    
        Parameters
        ----------
        multi_comparison : BaseMultiComparison
            The multi comparison object
        plot_type : "pie" | "bar", default: "pie
            The plot type
        cmap : matplotlib colormap, default: "Reds"
            The colormap to be used for the nodes
        fontsize : int, default: 9
            The text fontsize
        show_legend : bool
            Show the legend in the last axes
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, multi_comparison, plot_type='pie', cmap='YlOrRd', fontsize=9, show_legend=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: MultiCompGlobalAgreementWidget
  Docstring:
        Plots multi comparison agreement as pie or bar plot.
    
        Parameters
        ----------
        multi_comparison : BaseMultiComparison
            The multi comparison object
        plot_type : "pie" | "bar", default: "pie"
            The plot type
        cmap : matplotlib colormap, default: "YlOrRd"
            The colormap to be used for the nodes
        fontsize : int, default: 9
            The text fontsize
        show_legend : bool, default: True
            If True a legend is shown
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, multi_comparison, plot_type='pie', cmap='YlOrRd', fontsize=9, show_legend=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: MultiCompGraphWidget
  Docstring:
        Plots multi comparison graph.
    
        Parameters
        ----------
        multi_comparison : BaseMultiComparison
            The multi comparison object
        draw_labels : bool, default: False
            If True unit labels are shown
        node_cmap : matplotlib colormap, default: "viridis"
            The colormap to be used for the nodes
        edge_cmap : matplotlib colormap, default: "hot"
            The colormap to be used for the edges
        alpha_edges : float, default: 0.5
            Alpha value for edges
        colorbar : bool, default: False
            If True a colorbar for the edges is plotted
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, multi_comparison, draw_labels=False, node_cmap='viridis', edge_cmap='hot', alpha_edges=0.5, colorbar=False, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: PeakActivityMapWidget
  Docstring:
        Plots spike rate (estimated with detect_peaks()) as 2D activity map.
    
        Can be static (bin_duration_s=None) or animated (bin_duration_s=60.)
    
        Parameters
        ----------
        recording : RecordingExtractor
            The recording extractor object.
        peaks : numpy array with peak_dtype
            The pre detected peaks (with the `detect_peaks()` function).
        bin_duration_s : None or float, default: None
            If None then static image
            If not None then it is an animation per bin.
        with_contact_color : bool, default: True
            Plot rates with contact colors
        with_interpolated_map : bool, default: True
            Plot rates with interpolated map
        with_channel_ids : bool, default: False
            Add channel ids text on the probe
        color_range : tuple | list | None, default: None
            Sets the color bar range when animating or plotting.
            When None, uses the min-max of the entire time-series via imshow defaults.
            If tuple/list, the length must be 2 representing the range.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, recording, peaks, bin_duration_s=None, with_contact_color=True, with_interpolated_map=True, with_channel_ids=False, with_color_bar=True, color_range=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: PeaksOnProbeWidget
  Docstring:
        Generate a plot of spike peaks showing their location on a plot
        of the probe. Color scaling represents spike amplitude.
    
        The generated plot overlays the estimated position of a spike peak
        (as a single point for each peak) onto a plot of the probe. The
        dimensions of the plot are x axis: probe width, y axis: probe depth.
    
        Plots of different sets of peaks can be created on subplots, by
        passing a list of peaks and corresponding peak locations.
    
        Parameters
        ----------
        recording : Recording
            A SpikeInterface recording object.
        peaks : np.array | list[np.ndarray]
            SpikeInterface 'peaks' array created with `detect_peaks()`,
            an array of length num_peaks with entries:
                (sample_index, channel_index, amplitude, segment_index)
            To plot different sets of peaks in subplots, pass a list of peaks, each
            with a corresponding entry in a list passed to `peak_locations`.
        peak_locations : np.array | list[np.ndarray]
            A SpikeInterface 'peak_locations' array created with `localize_peaks()`.
            an array of length num_peaks with entries: (x, y)
            To plot multiple peaks in subplots, pass a list of `peak_locations`
            here with each entry having a corresponding `peaks`.
        segment_index : None | int, default: None
            If set, only peaks from this recording segment will be used.
        time_range : None | Tuple, default: None
            The time period over which to include peaks. If `None`, peaks
            across the entire recording will be shown.
        ylim : None | Tuple, default: None
            The y-axis limits (i.e. the probe depth). If `None`, the entire
            probe will be displayed.
        decimate : int, default: 5
            For performance reasons, every nth peak is shown on the plot,
            where n is set by decimate. To plot all peaks, set `decimate=1`.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, recording, peaks, peak_locations, segment_index=None, time_range=None, ylim=None, decimate=5, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: PotentialMergesWidget
  Docstring:
        Plots potential merges
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The input sorting analyzer
        potential_merges : list of lists or tuples
            List of potential merges (see `spikeinterface.curation.get_potential_auto_merges`)
        segment_index : int
            The segment index to display
        max_spike_samples : int or None, default: None
            The maximum number of spikes to display per unit
        backend: str
        
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', potential_merges: 'list', unit_colors: 'list' = None, segment_index: 'int' = 0, max_spikes_per_unit: 'int' = 100, backend=None, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: ProbeMapWidget
  Docstring:
        Plot the probe of a recording.
    
        Parameters
        ----------
        recording : RecordingExtractor
            The recording extractor object
        color_channels : list or matplotlib color
            List of colors to be associated with each channel_id, if only one color is present all channels will take the specified color
        with_channel_ids : bool False default
            Add channel ids text on the probe
        **plot_probe_kwargs : keyword arguments for probeinterface.plotting.plot_probe_group() function
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, recording, color_channels=None, with_channel_ids=False, backend=None, **backend_or_plot_probe_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: QualityMetricsWidget
  Docstring:
        Plots quality metrics distributions.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The object to get quality metrics from
        unit_ids : list or None, default: None
            List of unit ids
        include_metrics : list or None, default: None
            If given, a list of quality metrics to include
        skip_metrics : list or None, default: None
            If given, a list of quality metrics to skip
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, include_metrics=None, skip_metrics=None, unit_colors=None, hide_unit_selector=False, backend=None, **backend_kwargs)

Class: RasterWidget
  Docstring:
        Plots spike train rasters.
    
        Parameters
        ----------
        sorting : SortingExtractor | None, default: None
            A sorting object
        sorting_analyzer : SortingAnalyzer  | None, default: None
            A sorting analyzer object
        segment_index : None or int
            The segment index.
        unit_ids : list
            List of unit ids
        time_range : list
            List with start time and end time
        color : matplotlib color
            The color to be used
        backend: str
        
        * matplotlib
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting=None, sorting_analyzer=None, segment_index=None, unit_ids=None, time_range=None, color='k', backend=None, **backend_kwargs)

Class: SortingSummaryWidget
  Docstring:
        Plots spike sorting summary.
        This is the main viewer to visualize the final result with several sub view.
        This use sortingview (in a web browser) or spikeinterface-gui (with Qt).
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer object
        unit_ids : list or None, default: None
            List of unit ids
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply
            If SortingAnalyzer is already sparse, the argument is ignored
        max_amplitudes_per_unit : int or None, default: None
            Maximum number of spikes per unit for plotting amplitudes.
            If None, all spikes are plotted
        min_similarity_for_correlograms : float, default: 0.2
            Threshold for computing pair-wise cross-correlograms. If template similarity between two units
            is below this threshold, the cross-correlogram is not computed
            (sortingview backend)
        curation : bool, default: False
            If True, manual curation is enabled
            (sortingview backend)
        label_choices : list or None, default: None
            List of labels to be added to the curation table
            (sortingview backend)
        displayed_unit_properties : list or None, default: None
            List of properties to be added to the unit table.
            These may be drawn from the sorting extractor, and, if available,
            the quality_metrics/template_metrics/unit_locations extensions of the SortingAnalyzer.
            See all properties available with sorting.get_property_keys(), and, if available,
            analyzer.get_extension("quality_metrics").get_data().columns and
            analyzer.get_extension("template_metrics").get_data().columns.
        extra_unit_properties : dict or None, default: None
            A dict with extra units properties to display.
            The key is the property name and the value must be a numpy.array.
        curation_dict : dict or None, default: None
            When curation is True, optionaly the viewer can get a previous 'curation_dict'
            to continue/check  previous curations on this analyzer.
            In this case label_definitions must be None beacuse it is already included in the curation_dict.
            (spikeinterface_gui backend)
        label_definitions : dict or None, default: None
            When curation is True, optionaly the user can provide a label_definitions dict.
            This replaces the label_choices in the curation_format.
            (spikeinterface_gui backend)
        backend: str
        
        * sortingview
        * spikeinterface_gui
    
    **backend_kwargs: kwargs
        
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, sparsity=None, max_amplitudes_per_unit=None, min_similarity_for_correlograms=0.2, curation=False, displayed_unit_properties=None, extra_unit_properties=None, label_choices=None, curation_dict=None, label_definitions=None, backend=None, unit_table_properties=None, **backend_kwargs)
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_spikeinterface_gui(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: SpikeLocationsWidget
  Docstring:
        Plots spike locations.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The object to get spike locations from
        unit_ids : list or None, default: None
            List of unit ids
        segment_index : int or None, default: None
            The segment index (or None if mono-segment)
        max_spikes_per_unit : int or None, default: 500
            Number of max spikes per unit to display. Use None for all spikes.
        with_channel_ids : bool, default: False
            Add channel ids text on the probe
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        plot_all_units : bool, default: True
            If True, all units are plotted. The unselected ones (not in unit_ids),
            are plotted in grey (matplotlib backend)
        plot_legend : bool, default: False
            If True, the legend is plotted (matplotlib backend)
        hide_axis : bool, default: False
            If True, the axis is set to off (matplotlib backend)
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, segment_index=None, max_spikes_per_unit=500, with_channel_ids=False, unit_colors=None, hide_unit_selector=False, plot_all_units=True, plot_legend=False, hide_axis=False, backend=None, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: SpikesOnTracesWidget
  Docstring:
        Plots unit spikes/waveforms over traces.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer
        channel_ids : list or None, default: None
            The channel ids to display
        unit_ids : list or None, default: None
            List of unit ids
        order_channel_by_depth : bool, default: False
            If true orders channel by depth
        time_range : list or None, default: None
            List with start time and end time in seconds
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply
            If SortingAnalyzer is already sparse, the argument is ignored
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        mode : "line" | "map" | "auto", default: "auto"
            * "line": classical for low channel count
            * "map": for high channel count use color heat map
            * "auto": auto switch depending on the channel count ("line" if less than 64 channels, "map" otherwise)
        return_scaled : bool, default: False
            If True and the recording has scaled traces, it plots the scaled traces
        cmap : str, default: "RdBu"
            matplotlib colormap used in mode "map"
        show_channel_ids : bool, default: False
            Set yticks with channel ids
        color_groups : bool, default: False
            If True groups are plotted with different colors
        color : str or None, default: None
            The color used to draw the traces
        clim : None, tuple or dict, default: None
            When mode is "map", this argument controls color limits.
            If dict, keys should be the same as recording keys
        scale : float, default: 1
            Scale factor for the traces
        with_colorbar : bool, default: True
            When mode is "map", a colorbar is added
        tile_size : int, default: 512
            For sortingview backend, the size of each tile in the rendered image
        seconds_per_row : float, default: 0.2
            For "map" mode and sortingview backend, seconds to render in each row
        backend: str
        
        * matplotlib
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', segment_index=None, channel_ids=None, unit_ids=None, order_channel_by_depth=False, time_range=None, unit_colors=None, sparsity=None, mode='auto', return_scaled=False, cmap='RdBu', show_channel_ids=False, color_groups=False, color=None, clim=None, tile_size=512, seconds_per_row=0.2, scale=1, spike_width_ms=4, spike_height_um=20, with_colorbar=True, backend=None, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: StudyAgreementMatrix
  Docstring:
        Plot agreement matrix.
    
        Parameters
        ----------
        study : GroundTruthStudy
            A study object.
        case_keys : list or None
            A selection of cases to plot, if None, then all.
        ordered : bool
            Order units with best agreement scores.
            This enable to see agreement on a diagonal.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, ordered=True, case_keys=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: StudyComparisonCollisionBySimilarityWidget
  Docstring:
        Plots CollisionGTComparison pair by pair orderer by cosine_similarity for all
        cases in a study.
    
        Parameters
        ----------
        study : CollisionGTStudy
            The collision study object.
        case_keys : list or None
            A selection of cases to plot, if None, then all.
        metric : "cosine_similarity"
            metric for ordering
        similarity_bins : array
            if mode is "lines", the bins used to average the pairs
        cmap : string
            colormap used to show averages if mode is "lines"
        good_only : False
            keep only the pairs with a non zero accuracy (found templates)
        min_accuracy : float
            If good only, the minimum accuracy every cell should have, individually, to be
            considered in a putative pair
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, case_keys=None, metric='cosine_similarity', similarity_bins=array([-4.00000000e-01, -2.00000000e-01, -5.55111512e-17,  2.00000000e-01,
        4.00000000e-01,  6.00000000e-01,  8.00000000e-01,  1.00000000e+00]), show_legend=False, ylim=(0.5, 1), good_only=False, min_accuracy=0.9, cmap='winter', backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: StudyPerformances
  Docstring:
        Plot performances over case for a study.
    
    
        Parameters
        ----------
        study : GroundTruthStudy
            A study object.
        mode : "ordered" | "snr" | "swarm", default: "ordered"
            Which plot mode to use:
    
            * "ordered": plot performance metrics vs unit indices ordered by decreasing accuracy
            * "snr": plot performance metrics vs snr
            * "swarm": plot performance metrics as a swarm plot (see seaborn.swarmplot for details)
        performance_names : list or tuple, default: ("accuracy", "precision", "recall")
            Which performances to plot ("accuracy", "precision", "recall")
        case_keys : list or None
            A selection of cases to plot, if None, then all.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, mode='ordered', performance_names=('accuracy', 'precision', 'recall'), case_keys=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: StudyRunTimesWidget
  Docstring:
        Plot sorter run times for a SorterStudy.
    
        Parameters
        ----------
        study : SorterStudy
            A study object.
        case_keys : list or None
            A selection of cases to plot, if None, then all.
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, case_keys=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: StudySummary
  Docstring:
        Plot a summary of a ground truth study.
        Internally this plotting function runs:
    
          * plot_study_run_times
          * plot_study_unit_counts
          * plot_study_performances
          * plot_study_agreement_matrix
    
        Parameters
        ----------
        study : GroundTruthStudy
            A study object.
        case_keys : list or None, default: None
            A selection of cases to plot, if None, then all.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, case_keys=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: StudyUnitCountsWidget
  Docstring:
        Plot unit counts for a study: "num_well_detected", "num_false_positive", "num_redundant", "num_overmerged"
    
        Parameters
        ----------
        study : SorterStudy
            A study object.
        case_keys : list or None
            A selection of cases to plot, if None, then all.
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, case_keys=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: TemplateMetricsWidget
  Docstring:
        Plots template metrics distributions.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The object to get quality metrics from
        unit_ids : list or None, default: None
            List of unit ids
        include_metrics : list or None, default: None
            If given list of quality metrics to include
        skip_metrics : list or None or None, default: None
            If given, a list of quality metrics to skip
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, include_metrics=None, skip_metrics=None, unit_colors=None, hide_unit_selector=False, backend=None, **backend_kwargs)

Class: TemplateSimilarityWidget
  Docstring:
        Plots unit template similarity.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The object to get template similarity from
        unit_ids : list or None, default: None
            List of unit ids default: None
        display_diagonal_values : bool, default: False
            If False, the diagonal is displayed as zeros.
            If True, the similarity values (all 1s) are displayed
        cmap : matplotlib colormap, default: "viridis"
            The matplotlib colormap
        show_unit_ticks : bool, default: False
            If True, ticks display unit ids
        show_colorbar : bool, default: True
            If True, color bar is displayed
        backend: str
        
        * matplotlib
        * sortingview
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, cmap='viridis', display_diagonal_values=False, show_unit_ticks=False, show_colorbar=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: TracesWidget
  Docstring:
        Plots recording timeseries.
    
        Parameters
        ----------
        recording : RecordingExtractor, dict, or list
            The recording extractor object. If dict (or list) then it is a multi-layer display to compare, for example,
            different processing steps
        segment_index : None or int, default: None
            The segment index (required for multi-segment recordings)
        channel_ids : list or None, default: None
            The channel ids to display
        order_channel_by_depth : bool, default: False
            Reorder channel by depth
        time_range : list, tuple or None, default: None
            List with start time and end time
        mode : "line" | "map" | "auto", default: "auto"
            Three possible modes
            * "line": classical for low channel count
            * "map": for high channel count use color heat map
            * "auto": auto switch depending on the channel count ("line" if less than 64 channels, "map" otherwise)
        return_scaled : bool, default: False
            If True and the recording has scaled traces, it plots the scaled traces
        events : np.array | list[np.narray] or None, default: None
            Events to display as vertical lines.
            The numpy arrays cen either be of dtype float, with event times in seconds,
            or a structured array with the "time" field,
            and optional "duration" and "label" fields.
            For multi-segment recordings, provide a list of numpy array events, one for each segment.
        cmap : matplotlib colormap, default: "RdBu_r"
            matplotlib colormap used in mode "map"
        show_channel_ids : bool, default: False
            Set yticks with channel ids
        color_groups : bool, default: False
            If True groups are plotted with different colors
        color : str or None, default: None
            The color used to draw the traces
        clim : None, tuple or dict, default: None
            When mode is "map", this argument controls color limits.
            If dict, keys should be the same as recording keys
        scale : float, default: 1
            Scale factor for the traces
        vspacing_factor : float, default: 1.5
            Vertical spacing between channels as a multiple of maximum channel amplitude
        with_colorbar : bool, default: True
            When mode is "map", a colorbar is added
        tile_size : int, default: 1500
            For sortingview backend, the size of each tile in the rendered image
        seconds_per_row : float, default: 0.2
            For "map" mode and sortingview backend, seconds to render in each row
        add_legend : bool, default: True
            If True adds legend to figures
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
        * ephyviewer
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, recording, segment_index=None, channel_ids=None, order_channel_by_depth=False, time_range=None, mode='auto', return_scaled=False, cmap='RdBu_r', show_channel_ids=False, events=None, events_color='gray', events_alpha=0.5, color_groups=False, color=None, clim=None, tile_size=1500, seconds_per_row=0.2, scale=1, vspacing_factor=1.5, with_colorbar=True, add_legend=True, backend=None, **backend_kwargs)
  Method: plot_ephyviewer(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: UnitDepthsWidget
  Docstring:
        Plot unit depths
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer object
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        depth_axis : int, default: 1
            The dimension of unit_locations that is depth
        peak_sign : "neg" | "pos" | "both", default: "neg"
            Sign of peak for amplitudes
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer, unit_colors=None, depth_axis=1, peak_sign='neg', backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: UnitLocationsWidget
  Docstring:
        Plots each unit's location.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer that must contains  "unit_locations" extension
        unit_ids : list or None, default: None
            List of unit ids
        with_channel_ids : bool, default: False
            Add channel ids text on the probe
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        hide_unit_selector : bool, default: False
            If True, the unit selector is not displayed (sortingview backend)
        plot_all_units : bool, default: True
            If True, all units are plotted. The unselected ones (not in unit_ids),
            are plotted in grey (matplotlib backend)
        plot_legend : bool, default: False
            If True, the legend is plotted (matplotlib backend)
        hide_axis : bool, default: False
            If True, the axis is set to off (matplotlib backend)
        margin : float, default: 50
            Amount of margin to add to plot, beyond the extremum unit locations.
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids: 'list | None' = None, with_channel_ids: 'bool' = False, unit_colors: 'dict | None' = None, hide_unit_selector: 'bool' = False, plot_all_units: 'bool' = True, plot_legend: 'bool' = False, hide_axis: 'bool' = False, backend: 'str | None' = None, margin: 'float' = 50, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: UnitPresenceWidget
  Docstring:
        Estimates of the probability density function for each unit using Gaussian kernels,
    
        Parameters
        ----------
        sorting : SortingExtractor
            The sorting extractor object
        segment_index : None or int
            The segment index.
        time_range : list or None, default: None
            List with start time and end time
        bin_duration_s : float, default: 0.5
            Bin size (in seconds) for the heat map time axis
        smooth_sigma : float, default: 4.5
            Sigma for the Gaussian kernel (in number of bins)
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting, segment_index=None, time_range=None, bin_duration_s=0.05, smooth_sigma=4.5, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: UnitProbeMapWidget
  Docstring:
        Plots unit map. Amplitude is color coded on probe contact.
    
        Can be static (animated=False) or animated (animated=True)
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
        unit_ids : list
            List of unit ids.
        channel_ids : list
            The channel ids to display
        animated : bool, default: False
            Animation for amplitude on time
        with_channel_ids : bool, default: False
            add channel ids text on the probe
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer, unit_ids=None, channel_ids=None, animated=None, with_channel_ids=False, colorbar=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: UnitSummaryWidget
  Docstring:
        Plot a unit summary.
    
        If amplitudes are alreday computed, they are displayed.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer object
        unit_id : int or str
            The unit id to plot the summary of
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply.
            If SortingAnalyzer is already sparse, the argument is ignored
        subwidget_kwargs : dict or None, default: None
            Parameters for the subwidgets in a nested dictionary
    
                * unit_locations : UnitLocationsWidget (see UnitLocationsWidget for details)
                * unit_waveforms : UnitWaveformsWidget (see UnitWaveformsWidget for details)
                * unit_waveform_density_map : UnitWaveformDensityMapWidget (see UnitWaveformDensityMapWidget for details)
                * autocorrelograms : AutoCorrelogramsWidget (see AutoCorrelogramsWidget for details)
                * amplitudes : AmplitudesWidget (see AmplitudesWidget for details)
    
            Please note that the unit_colors should not be set in subwidget_kwargs, but directly as a parameter of plot_unit_summary.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer, unit_id, unit_colors=None, sparsity=None, subwidget_kwargs=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: UnitTemplatesWidget
  Docstring:
        Plots unit waveforms.
    
        Parameters
        ----------
        sorting_analyzer_or_templates : SortingAnalyzer | Templates
            The SortingAnalyzer or Templates object.
            If Templates is given, the "plot_waveforms" argument is set to False
        channel_ids : list or None, default: None
            The channel ids to display
        unit_ids : list or None, default: None
            List of unit ids
        plot_templates : bool, default: True
            If True, templates are plotted over the waveforms
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply
            If SortingAnalyzer is already sparse, the argument is ignored
        set_title : bool, default: True
            Create a plot title with the unit number if True
        plot_channels : bool, default: False
            Plot channel locations below traces
        unit_selected_waveforms : None or dict, default: None
            A dict key is unit_id and value is the subset of waveforms indices that should be
            be displayed (matplotlib backend)
        max_spikes_per_unit : int or None, default: 50
            If given and unit_selected_waveforms is None, only max_spikes_per_unit random units are
            displayed per waveform, (matplotlib backend)
        scale : float, default: 1
            Scale factor for the waveforms/templates (matplotlib backend)
        widen_narrow_scale : float, default: 1
            Scale factor for the x-axis of the waveforms/templates (matplotlib backend)
        axis_equal : bool, default: False
            Equal aspect ratio for x and y axis, to visualize the array geometry to scale
        lw_waveforms : float, default: 1
            Line width for the waveforms, (matplotlib backend)
        lw_templates : float, default: 2
            Line width for the templates, (matplotlib backend)
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        alpha_waveforms : float, default: 0.5
            Alpha value for waveforms (matplotlib backend)
        alpha_templates : float, default: 1
            Alpha value for templates, (matplotlib backend)
        shade_templates : bool, default: True
            If True, templates are shaded, see templates_percentile_shading argument
        templates_percentile_shading : float, tuple/list of floats, or None, default: (1, 25, 75, 99)
            It controls the shading of the templates.
            If None, the shading is +/- the standard deviation of the templates.
            If float, it controls the percentile of the template values used to shade the templates.
            Note that it is one-sided : if 5 is given, the 5th and 95th percentiles are used to shade
            the templates. If list of floats, it needs to be have an even number of elements which control
            the lower and upper percentile used to shade the templates. The first half of the elements
            are used for the lower bounds, and the second half for the upper bounds.
            Inner elements produce darker shadings. For sortingview backend only 2 or 4 elements are
            supported.
        scalebar : bool, default: False
            Display a scale bar on the waveforms plot (matplotlib backend)
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        same_axis : bool, default: False
            If True, waveforms and templates are displayed on the same axis (matplotlib backend)
        x_offset_units : bool, default: False
            In case same_axis is True, this parameter allow to x-offset the waveforms for different units
            (recommended for a few units) (matlotlib backend)
        plot_legend : bool, default: True
            Display legend (matplotlib backend)
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, *args, **kargs)
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: UnitWaveformDensityMapWidget
  Docstring:
        Plots unit waveforms using heat map density.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer for calculating waveforms
        channel_ids : list or None, default: None
            The channel ids to display
        unit_ids : list or None, default: None
            List of unit ids
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply
            If SortingAnalyzer is already sparse, the argument is ignored
        use_max_channel : bool, default: False
            Use only the max channel
        peak_sign : "neg" | "pos" | "both", default: "neg"
            Used to detect max channel only when use_max_channel=True
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        same_axis : bool, default: False
            If True then all density are plot on the same axis and then channels is the union
            all channel per units
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer, channel_ids=None, unit_ids=None, sparsity=None, same_axis=False, use_max_channel=False, peak_sign='neg', unit_colors=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: UnitWaveformsWidget
  Docstring:
        Plots unit waveforms.
    
        Parameters
        ----------
        sorting_analyzer_or_templates : SortingAnalyzer | Templates
            The SortingAnalyzer or Templates object.
            If Templates is given, the "plot_waveforms" argument is set to False
        channel_ids : list or None, default: None
            The channel ids to display
        unit_ids : list or None, default: None
            List of unit ids
        plot_templates : bool, default: True
            If True, templates are plotted over the waveforms
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply
            If SortingAnalyzer is already sparse, the argument is ignored
        set_title : bool, default: True
            Create a plot title with the unit number if True
        plot_channels : bool, default: False
            Plot channel locations below traces
        unit_selected_waveforms : None or dict, default: None
            A dict key is unit_id and value is the subset of waveforms indices that should be
            be displayed (matplotlib backend)
        max_spikes_per_unit : int or None, default: 50
            If given and unit_selected_waveforms is None, only max_spikes_per_unit random units are
            displayed per waveform, (matplotlib backend)
        scale : float, default: 1
            Scale factor for the waveforms/templates (matplotlib backend)
        widen_narrow_scale : float, default: 1
            Scale factor for the x-axis of the waveforms/templates (matplotlib backend)
        axis_equal : bool, default: False
            Equal aspect ratio for x and y axis, to visualize the array geometry to scale
        lw_waveforms : float, default: 1
            Line width for the waveforms, (matplotlib backend)
        lw_templates : float, default: 2
            Line width for the templates, (matplotlib backend)
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        alpha_waveforms : float, default: 0.5
            Alpha value for waveforms (matplotlib backend)
        alpha_templates : float, default: 1
            Alpha value for templates, (matplotlib backend)
        shade_templates : bool, default: True
            If True, templates are shaded, see templates_percentile_shading argument
        templates_percentile_shading : float, tuple/list of floats, or None, default: (1, 25, 75, 99)
            It controls the shading of the templates.
            If None, the shading is +/- the standard deviation of the templates.
            If float, it controls the percentile of the template values used to shade the templates.
            Note that it is one-sided : if 5 is given, the 5th and 95th percentiles are used to shade
            the templates. If list of floats, it needs to be have an even number of elements which control
            the lower and upper percentile used to shade the templates. The first half of the elements
            are used for the lower bounds, and the second half for the upper bounds.
            Inner elements produce darker shadings. For sortingview backend only 2 or 4 elements are
            supported.
        scalebar : bool, default: False
            Display a scale bar on the waveforms plot (matplotlib backend)
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        same_axis : bool, default: False
            If True, waveforms and templates are displayed on the same axis (matplotlib backend)
        x_offset_units : bool, default: False
            In case same_axis is True, this parameter allow to x-offset the waveforms for different units
            (recommended for a few units) (matlotlib backend)
        plot_legend : bool, default: True
            Display legend (matplotlib backend)
        backend: str
        
        * matplotlib
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer_or_templates: 'SortingAnalyzer | Templates', channel_ids=None, unit_ids=None, plot_waveforms=True, plot_templates=True, plot_channels=False, unit_colors=None, sparsity=None, ncols=5, scale=1, widen_narrow_scale=1, lw_waveforms=1, lw_templates=2, axis_equal=False, unit_selected_waveforms=None, max_spikes_per_unit=50, set_title=True, same_axis=False, shade_templates=True, templates_percentile_shading=(1, 25, 75, 99), scalebar=False, x_offset_units=False, alpha_waveforms=0.5, alpha_templates=1, hide_unit_selector=False, plot_legend=True, backend=None, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Function: array_to_image(data, colormap='RdGy', clim=None, spatial_zoom=(0.75, 1.25), num_timepoints_per_row=30000, row_spacing=0.25, scalebar=False, sampling_frequency=None)
  Docstring:
    Converts a 2D numpy array (width x height) to a
    3D image array (width x height x RGB color).
    
    Useful for visualizing data before/after preprocessing
    
    Parameters
    ----------
    data : np.array
        2D numpy array
    colormap : str
        Identifier for a Matplotlib colormap
    clim : tuple or None
        The color limits. If None, the clim is the range of the traces
    spatial_zoom : tuple
        Tuple specifying width & height scaling
    num_timepoints_per_row : int
        Max number of samples before wrapping
    row_spacing : float
        Ratio of row spacing to overall channel height
    
    Returns
    -------
    output_image : 3D numpy array

Function: get_default_plotter_backend()
  Docstring:
    Return the default backend for spikeinterface widgets.
    The default backend is "matplotlib" at init.
    It can be be globally set with `set_default_plotter_backend(backend)`

Function: get_some_colors(keys, color_engine='auto', map_name='gist_ncar', format='RGBA', shuffle=None, seed=None, margin=None, resample=True)
  Docstring:
    Return a dict of colors for given keys
    
    Parameters
    ----------
    color_engine : "auto" | "matplotlib" | "colorsys" | "distinctipy", default: "auto"
        The engine to generate colors
    map_name : str
        Used for matplotlib
    format: str, default: "RGBA"
        The output formats
    shuffle : bool or None, default: None
        Shuffle or not the colors.
        If None then:
        * set to True for matplotlib and colorsys
        * set to False for distinctipy
    seed: int or None, default: None
        Set the seed
    margin: None or int
        If None, put a margin to remove colors on borders of some colomap of matplotlib.
    resample : bool, dafult True
        For matplotlib, only resample the cmap to the number of keys + eventualy maring
    
    Returns
    -------
    dict_colors: dict
        A dict of colors for given keys.

Function: get_unit_colors(sorting_or_analyzer_or_templates, color_engine='auto', map_name='gist_ncar', format='RGBA', shuffle=None, seed=None)
  Docstring:
    Return a dict colors per units.

Class: plot_agreement_matrix
  Docstring:
        Plots sorting comparison agreement matrix.
    
        Parameters
        ----------
        sorting_comparison : GroundTruthComparison or SymmetricSortingComparison
            The sorting comparison object.
            Can optionally be symmetric if given a SymmetricSortingComparison
        ordered : bool, default: True
            Order units with best agreement scores.
            If True, agreement scores can be seen along a diagonal
        count_text : bool, default: True
            If True counts are displayed as text
        unit_ticks : bool, default: True
            If True unit tick labels are displayed
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_comparison, ordered=True, count_text=True, unit_ticks=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_all_amplitudes_distributions
  Docstring:
        Plots distributions of amplitudes as violin plot for all or some units.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer
        unit_ids : list
            List of unit ids, default None
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, unit_colors=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_amplitudes
  Docstring:
        Plots spike amplitudes
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The input waveform extractor
        unit_ids : list or None, default: None
            List of unit ids
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        segment_index : int or None, default: None
            The segment index (or None if mono-segment)
        max_spikes_per_unit : int or None, default: None
            Number of max spikes per unit to display. Use None for all spikes
        y_lim : tuple or None, default: None
            The min and max depth to display, if None (min and max of the amplitudes).
        scatter_decimate : int, default: 1
            If equal to n, each nth spike is kept for plotting.
        hide_unit_selector : bool, default: False
            If True the unit selector is not displayed
            (sortingview backend)
        plot_histogram : bool, default: False
            If True, an histogram of the amplitudes is plotted on the right axis
            (matplotlib backend)
        bins : int or None, default: None
            If plot_histogram is True, the number of bins for the amplitude histogram.
            If None, uses 100 bins.
        plot_legend : bool, default: True
            True includes legend in plot
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, unit_colors=None, segment_index=None, max_spikes_per_unit=None, y_lim=None, scatter_decimate=1, hide_unit_selector=False, plot_histograms=False, bins=None, plot_legend=True, backend=None, **backend_kwargs)
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_autocorrelograms
  Docstring:
        Plots unit cross correlograms.
    
        Parameters
        ----------
        sorting_analyzer_or_sorting : SortingAnalyzer or BaseSorting
            The object to compute/get crosscorrelograms from
        unit_ids  list or None, default: None
            List of unit ids
        min_similarity_for_correlograms : float, default: 0.2
            For sortingview backend. Threshold for computing pair-wise cross-correlograms.
            If template similarity between two units is below this threshold, the cross-correlogram is not displayed.
            For auto-correlograms plot, this is automatically set to None.
        window_ms : float, default: 100.0
            Window for CCGs in ms. If correlograms are already computed (e.g. with SortingAnalyzer),
            this argument is ignored
        bin_ms : float, default: 1.0
            Bin size in ms. If correlograms are already computed (e.g. with SortingAnalyzer),
            this argument is ignored
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        backend: str
        
        * matplotlib
        * sortingview
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, *args, **kargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_comparison_collision_by_similarity
  Docstring:
        Plots CollisionGTComparison pair by pair orderer by cosine_similarity
    
        Parameters
        ----------
        comp : CollisionGTComparison
            The collision ground truth comparison object
        templates : array
            template of units
        mode : "heatmap" or "lines"
            to see collision curves for every pairs ("heatmap") or as lines averaged over pairs.
        similarity_bins : array
            if mode is "lines", the bins used to average the pairs
        cmap : string
            colormap used to show averages if mode is "lines"
        metric : "cosine_similarity"
            metric for ordering
        good_only : True
            keep only the pairs with a non zero accuracy (found templates)
        min_accuracy : float
            If good only, the minimum accuracy every cell should have, individually, to be
            considered in a putative pair
        unit_ids : list
            List of considered units
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, comp, templates, unit_ids=None, metric='cosine_similarity', figure=None, ax=None, mode='heatmap', similarity_bins=array([-4.00000000e-01, -2.00000000e-01, -5.55111512e-17,  2.00000000e-01,
        4.00000000e-01,  6.00000000e-01,  8.00000000e-01,  1.00000000e+00]), cmap='winter', good_only=False, min_accuracy=0.9, show_legend=False, ylim=(0, 1), backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_confusion_matrix
  Docstring:
        Plots sorting comparison confusion matrix.
    
        Parameters
        ----------
        gt_comparison : GroundTruthComparison
            The ground truth sorting comparison object
        count_text : bool
            If True counts are displayed as text
        unit_ticks : bool
            If True unit tick labels are displayed
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, gt_comparison, count_text=True, unit_ticks=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_crosscorrelograms
  Docstring:
        Plots unit cross correlograms.
    
        Parameters
        ----------
        sorting_analyzer_or_sorting : SortingAnalyzer or BaseSorting
            The object to compute/get crosscorrelograms from
        unit_ids  list or None, default: None
            List of unit ids
        min_similarity_for_correlograms : float, default: 0.2
            For sortingview backend. Threshold for computing pair-wise cross-correlograms.
            If template similarity between two units is below this threshold, the cross-correlogram is not displayed.
            For auto-correlograms plot, this is automatically set to None.
        window_ms : float, default: 100.0
            Window for CCGs in ms. If correlograms are already computed (e.g. with SortingAnalyzer),
            this argument is ignored
        bin_ms : float, default: 1.0
            Bin size in ms. If correlograms are already computed (e.g. with SortingAnalyzer),
            this argument is ignored
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        backend: str
        
        * matplotlib
        * sortingview
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer_or_sorting: 'Union[SortingAnalyzer, BaseSorting]', unit_ids=None, min_similarity_for_correlograms=0.2, window_ms=100.0, bin_ms=1.0, hide_unit_selector=False, unit_colors=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_drift_raster_map
  Docstring:
        Plot the drift raster map from peaks or a SortingAnalyzer.
        The drift raster map is a scatter plot of the estimated peak depth vs time and it is
        useful to visualize the drift over the course of the recording.
    
        Parameters
        ----------
        peaks : np.array | None, default: None
            The peaks array, with dtype ("sample_index", "channel_index", "amplitude", "segment_index"),
            as returned by the `detect_peaks` or `correct_motion` functions.
        peak_locations : np.array | None, default: None
            The peak locations, with dtype ("x", "y") or ("x", "y", "z"), as returned by the
            `localize_peaks` or `correct_motion` functions.
        sorting_analyzer : SortingAnalyzer | None, default: None
            The sorting analyzer object. To use this function, the `SortingAnalyzer` must have the
            "spike_locations" extension computed.
        direction : "x" or "y", default: "y"
            The direction to display. "y" is the depth direction.
        segment_index : int, default: None
            The segment index to display.
        recording : RecordingExtractor | None, default: None
            The recording extractor object (only used to get "real" times).
        segment_index : int, default: 0
            The segment index to display.
        sampling_frequency : float, default: None
            The sampling frequency (needed if recording is None).
        depth_lim : tuple or None, default: None
            The min and max depth to display, if None (min and max of the recording).
        scatter_decimate : int, default: None
            If equal to n, each nth spike is kept for plotting.
        color_amplitude : bool, default: True
            If True, the color of the scatter points is the amplitude of the peaks.
        cmap : str, default: "inferno"
            The colormap to use for the amplitude.
        color : str, default: "Gray"
            The color of the scatter points if color_amplitude is False.
        clim : tuple or None, default: None
            The min and max amplitude to display, if None (min and max of the amplitudes).
        alpha : float, default: 1
            The alpha of the scatter points.
        backend: str
        
        * matplotlib
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, peaks: 'np.array | None' = None, peak_locations: 'np.array | None' = None, sorting_analyzer: 'SortingAnalyzer | None' = None, direction: 'str' = 'y', recording: 'BaseRecording | None' = None, sampling_frequency: 'float | None' = None, segment_index: 'int | None' = None, depth_lim: 'tuple[float, float] | None' = None, color_amplitude: 'bool' = True, scatter_decimate: 'int | None' = None, cmap: 'str' = 'inferno', color: 'str' = 'Gray', clim: 'tuple[float, float] | None' = None, alpha: 'float' = 1, backend: 'str | None' = None, **backend_kwargs)

Class: plot_isi_distribution
  Docstring:
        Plots spike train ISI distribution.
    
        Parameters
        ----------
        sorting : SortingExtractor
            The sorting extractor object
        unit_ids : list
            List of unit ids
        bins_ms : int
            Bin size in ms
        window_ms : float
            Window size in ms
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting, unit_ids=None, window_ms=100.0, bin_ms=1.0, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_locations
  Docstring:
        Plots spike locations as a function of time
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The input sorting analyzer
        unit_ids : list or None, default: None
            List of unit ids
        segment_index : int or None, default: None
            The segment index (or None if mono-segment)
        max_spikes_per_unit : int or None, default: None
            Number of max spikes per unit to display. Use None for all spikes
        plot_histogram : bool, default: False
            If True, an histogram of the locations is plotted on the right axis
            (matplotlib backend)
        bins : int or None, default: None
            If plot_histogram is True, the number of bins for the location histogram.
            If None this is automatically adjusted
        plot_legend : bool, default: True
            True includes legend in plot
        locations_axis : str, default: 'y'
            Which location axis to use when plotting locations.
        backend: str
        
        * matplotlib
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, unit_colors=None, segment_index=None, max_spikes_per_unit=None, plot_histograms=False, bins=None, plot_legend=True, locations_axis='y', backend=None, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_motion
  Docstring:
        Plot the Motion object.
    
        Parameters
        ----------
        motion : Motion
            The motion object.
        segment_index : int | None, default: None
            If Motion is multi segment, the must be not None.
        mode : "auto" | "line" | "map", default: "line"
            How to plot the motion.
            "line" plots estimated motion at different depths as lines.
            "map" plots estimated motion at different depths as a heatmap.
            "auto" makes it automatic depending on the number of motion depths.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, motion: 'Motion', segment_index: 'int | None' = None, mode: 'str' = 'line', motion_lim: 'float | None' = None, backend: 'str | None' = None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_motion_info
  Docstring:
        Plot motion information from the motion_info dictionary returned by the `correct_motion()` funciton.
        This widget plots:
            * the motion iself
            * the drift raster map (peak depth vs time) before correction
            * the drift raster map (peak depth vs time) after correction
    
        Parameters
        ----------
        motion_info : dict
            The motion info returned by correct_motion() or loaded back with load_motion_info().
        recording : RecordingExtractor
            The recording extractor object
        segment_index : int, default: None
            The segment index to display.
        sampling_frequency : float, default: None
            The sampling frequency (needed if recording is None).
        depth_lim : tuple or None, default: None
            The min and max depth to display, if None (min and max of the recording).
        motion_lim : tuple or None, default: None
            The min and max motion to display, if None (min and max of the motion).
        scatter_decimate : int, default: None
            If equal to n, each nth spike is kept for plotting.
        color_amplitude : bool, default: False
            If True, the color of the scatter points is the amplitude of the peaks.
        amplitude_cmap : str, default: "inferno"
            The colormap to use for the amplitude.
        amplitude_color : str, default: "Gray"
            The color of the scatter points if color_amplitude is False.
        amplitude_clim : tuple or None, default: None
            The min and max amplitude to display, if None (min and max of the amplitudes).
        amplitude_alpha : float, default: 1
            The alpha of the scatter points.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, motion_info: 'dict', recording: 'BaseRecording', segment_index: 'int | None' = None, depth_lim: 'tuple[float, float] | None' = None, motion_lim: 'tuple[float, float] | None' = None, color_amplitude: 'bool' = False, scatter_decimate: 'int | None' = None, amplitude_cmap: 'str' = 'inferno', amplitude_color: 'str' = 'Gray', amplitude_clim: 'tuple[float, float] | None' = None, amplitude_alpha: 'float' = 1, backend: 'str | None' = None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_multicomparison_agreement
  Docstring:
        Plots multi comparison agreement as pie or bar plot.
    
        Parameters
        ----------
        multi_comparison : BaseMultiComparison
            The multi comparison object
        plot_type : "pie" | "bar", default: "pie"
            The plot type
        cmap : matplotlib colormap, default: "YlOrRd"
            The colormap to be used for the nodes
        fontsize : int, default: 9
            The text fontsize
        show_legend : bool, default: True
            If True a legend is shown
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, multi_comparison, plot_type='pie', cmap='YlOrRd', fontsize=9, show_legend=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_multicomparison_agreement_by_sorter
  Docstring:
        Plots multi comparison agreement as pie or bar plot.
    
        Parameters
        ----------
        multi_comparison : BaseMultiComparison
            The multi comparison object
        plot_type : "pie" | "bar", default: "pie
            The plot type
        cmap : matplotlib colormap, default: "Reds"
            The colormap to be used for the nodes
        fontsize : int, default: 9
            The text fontsize
        show_legend : bool
            Show the legend in the last axes
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, multi_comparison, plot_type='pie', cmap='YlOrRd', fontsize=9, show_legend=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_multicomparison_graph
  Docstring:
        Plots multi comparison graph.
    
        Parameters
        ----------
        multi_comparison : BaseMultiComparison
            The multi comparison object
        draw_labels : bool, default: False
            If True unit labels are shown
        node_cmap : matplotlib colormap, default: "viridis"
            The colormap to be used for the nodes
        edge_cmap : matplotlib colormap, default: "hot"
            The colormap to be used for the edges
        alpha_edges : float, default: 0.5
            Alpha value for edges
        colorbar : bool, default: False
            If True a colorbar for the edges is plotted
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, multi_comparison, draw_labels=False, node_cmap='viridis', edge_cmap='hot', alpha_edges=0.5, colorbar=False, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_peak_activity
  Docstring:
        Plots spike rate (estimated with detect_peaks()) as 2D activity map.
    
        Can be static (bin_duration_s=None) or animated (bin_duration_s=60.)
    
        Parameters
        ----------
        recording : RecordingExtractor
            The recording extractor object.
        peaks : numpy array with peak_dtype
            The pre detected peaks (with the `detect_peaks()` function).
        bin_duration_s : None or float, default: None
            If None then static image
            If not None then it is an animation per bin.
        with_contact_color : bool, default: True
            Plot rates with contact colors
        with_interpolated_map : bool, default: True
            Plot rates with interpolated map
        with_channel_ids : bool, default: False
            Add channel ids text on the probe
        color_range : tuple | list | None, default: None
            Sets the color bar range when animating or plotting.
            When None, uses the min-max of the entire time-series via imshow defaults.
            If tuple/list, the length must be 2 representing the range.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, recording, peaks, bin_duration_s=None, with_contact_color=True, with_interpolated_map=True, with_channel_ids=False, with_color_bar=True, color_range=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_peaks_on_probe
  Docstring:
        Generate a plot of spike peaks showing their location on a plot
        of the probe. Color scaling represents spike amplitude.
    
        The generated plot overlays the estimated position of a spike peak
        (as a single point for each peak) onto a plot of the probe. The
        dimensions of the plot are x axis: probe width, y axis: probe depth.
    
        Plots of different sets of peaks can be created on subplots, by
        passing a list of peaks and corresponding peak locations.
    
        Parameters
        ----------
        recording : Recording
            A SpikeInterface recording object.
        peaks : np.array | list[np.ndarray]
            SpikeInterface 'peaks' array created with `detect_peaks()`,
            an array of length num_peaks with entries:
                (sample_index, channel_index, amplitude, segment_index)
            To plot different sets of peaks in subplots, pass a list of peaks, each
            with a corresponding entry in a list passed to `peak_locations`.
        peak_locations : np.array | list[np.ndarray]
            A SpikeInterface 'peak_locations' array created with `localize_peaks()`.
            an array of length num_peaks with entries: (x, y)
            To plot multiple peaks in subplots, pass a list of `peak_locations`
            here with each entry having a corresponding `peaks`.
        segment_index : None | int, default: None
            If set, only peaks from this recording segment will be used.
        time_range : None | Tuple, default: None
            The time period over which to include peaks. If `None`, peaks
            across the entire recording will be shown.
        ylim : None | Tuple, default: None
            The y-axis limits (i.e. the probe depth). If `None`, the entire
            probe will be displayed.
        decimate : int, default: 5
            For performance reasons, every nth peak is shown on the plot,
            where n is set by decimate. To plot all peaks, set `decimate=1`.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, recording, peaks, peak_locations, segment_index=None, time_range=None, ylim=None, decimate=5, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_potential_merges
  Docstring:
        Plots potential merges
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The input sorting analyzer
        potential_merges : list of lists or tuples
            List of potential merges (see `spikeinterface.curation.get_potential_auto_merges`)
        segment_index : int
            The segment index to display
        max_spike_samples : int or None, default: None
            The maximum number of spikes to display per unit
        backend: str
        
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', potential_merges: 'list', unit_colors: 'list' = None, segment_index: 'int' = 0, max_spikes_per_unit: 'int' = 100, backend=None, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_probe_map
  Docstring:
        Plot the probe of a recording.
    
        Parameters
        ----------
        recording : RecordingExtractor
            The recording extractor object
        color_channels : list or matplotlib color
            List of colors to be associated with each channel_id, if only one color is present all channels will take the specified color
        with_channel_ids : bool False default
            Add channel ids text on the probe
        **plot_probe_kwargs : keyword arguments for probeinterface.plotting.plot_probe_group() function
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, recording, color_channels=None, with_channel_ids=False, backend=None, **backend_or_plot_probe_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_quality_metrics
  Docstring:
        Plots quality metrics distributions.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The object to get quality metrics from
        unit_ids : list or None, default: None
            List of unit ids
        include_metrics : list or None, default: None
            If given, a list of quality metrics to include
        skip_metrics : list or None, default: None
            If given, a list of quality metrics to skip
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, include_metrics=None, skip_metrics=None, unit_colors=None, hide_unit_selector=False, backend=None, **backend_kwargs)

Class: plot_rasters
  Docstring:
        Plots spike train rasters.
    
        Parameters
        ----------
        sorting : SortingExtractor | None, default: None
            A sorting object
        sorting_analyzer : SortingAnalyzer  | None, default: None
            A sorting analyzer object
        segment_index : None or int
            The segment index.
        unit_ids : list
            List of unit ids
        time_range : list
            List with start time and end time
        color : matplotlib color
            The color to be used
        backend: str
        
        * matplotlib
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting=None, sorting_analyzer=None, segment_index=None, unit_ids=None, time_range=None, color='k', backend=None, **backend_kwargs)

Class: plot_sorting_summary
  Docstring:
        Plots spike sorting summary.
        This is the main viewer to visualize the final result with several sub view.
        This use sortingview (in a web browser) or spikeinterface-gui (with Qt).
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer object
        unit_ids : list or None, default: None
            List of unit ids
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply
            If SortingAnalyzer is already sparse, the argument is ignored
        max_amplitudes_per_unit : int or None, default: None
            Maximum number of spikes per unit for plotting amplitudes.
            If None, all spikes are plotted
        min_similarity_for_correlograms : float, default: 0.2
            Threshold for computing pair-wise cross-correlograms. If template similarity between two units
            is below this threshold, the cross-correlogram is not computed
            (sortingview backend)
        curation : bool, default: False
            If True, manual curation is enabled
            (sortingview backend)
        label_choices : list or None, default: None
            List of labels to be added to the curation table
            (sortingview backend)
        displayed_unit_properties : list or None, default: None
            List of properties to be added to the unit table.
            These may be drawn from the sorting extractor, and, if available,
            the quality_metrics/template_metrics/unit_locations extensions of the SortingAnalyzer.
            See all properties available with sorting.get_property_keys(), and, if available,
            analyzer.get_extension("quality_metrics").get_data().columns and
            analyzer.get_extension("template_metrics").get_data().columns.
        extra_unit_properties : dict or None, default: None
            A dict with extra units properties to display.
            The key is the property name and the value must be a numpy.array.
        curation_dict : dict or None, default: None
            When curation is True, optionaly the viewer can get a previous 'curation_dict'
            to continue/check  previous curations on this analyzer.
            In this case label_definitions must be None beacuse it is already included in the curation_dict.
            (spikeinterface_gui backend)
        label_definitions : dict or None, default: None
            When curation is True, optionaly the user can provide a label_definitions dict.
            This replaces the label_choices in the curation_format.
            (spikeinterface_gui backend)
        backend: str
        
        * sortingview
        * spikeinterface_gui
    
    **backend_kwargs: kwargs
        
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, sparsity=None, max_amplitudes_per_unit=None, min_similarity_for_correlograms=0.2, curation=False, displayed_unit_properties=None, extra_unit_properties=None, label_choices=None, curation_dict=None, label_definitions=None, backend=None, unit_table_properties=None, **backend_kwargs)
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_spikeinterface_gui(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_spike_locations
  Docstring:
        Plots spike locations.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The object to get spike locations from
        unit_ids : list or None, default: None
            List of unit ids
        segment_index : int or None, default: None
            The segment index (or None if mono-segment)
        max_spikes_per_unit : int or None, default: 500
            Number of max spikes per unit to display. Use None for all spikes.
        with_channel_ids : bool, default: False
            Add channel ids text on the probe
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        plot_all_units : bool, default: True
            If True, all units are plotted. The unselected ones (not in unit_ids),
            are plotted in grey (matplotlib backend)
        plot_legend : bool, default: False
            If True, the legend is plotted (matplotlib backend)
        hide_axis : bool, default: False
            If True, the axis is set to off (matplotlib backend)
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, segment_index=None, max_spikes_per_unit=500, with_channel_ids=False, unit_colors=None, hide_unit_selector=False, plot_all_units=True, plot_legend=False, hide_axis=False, backend=None, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_spikes_on_traces
  Docstring:
        Plots unit spikes/waveforms over traces.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer
        channel_ids : list or None, default: None
            The channel ids to display
        unit_ids : list or None, default: None
            List of unit ids
        order_channel_by_depth : bool, default: False
            If true orders channel by depth
        time_range : list or None, default: None
            List with start time and end time in seconds
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply
            If SortingAnalyzer is already sparse, the argument is ignored
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        mode : "line" | "map" | "auto", default: "auto"
            * "line": classical for low channel count
            * "map": for high channel count use color heat map
            * "auto": auto switch depending on the channel count ("line" if less than 64 channels, "map" otherwise)
        return_scaled : bool, default: False
            If True and the recording has scaled traces, it plots the scaled traces
        cmap : str, default: "RdBu"
            matplotlib colormap used in mode "map"
        show_channel_ids : bool, default: False
            Set yticks with channel ids
        color_groups : bool, default: False
            If True groups are plotted with different colors
        color : str or None, default: None
            The color used to draw the traces
        clim : None, tuple or dict, default: None
            When mode is "map", this argument controls color limits.
            If dict, keys should be the same as recording keys
        scale : float, default: 1
            Scale factor for the traces
        with_colorbar : bool, default: True
            When mode is "map", a colorbar is added
        tile_size : int, default: 512
            For sortingview backend, the size of each tile in the rendered image
        seconds_per_row : float, default: 0.2
            For "map" mode and sortingview backend, seconds to render in each row
        backend: str
        
        * matplotlib
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', segment_index=None, channel_ids=None, unit_ids=None, order_channel_by_depth=False, time_range=None, unit_colors=None, sparsity=None, mode='auto', return_scaled=False, cmap='RdBu', show_channel_ids=False, color_groups=False, color=None, clim=None, tile_size=512, seconds_per_row=0.2, scale=1, spike_width_ms=4, spike_height_um=20, with_colorbar=True, backend=None, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_study_agreement_matrix
  Docstring:
        Plot agreement matrix.
    
        Parameters
        ----------
        study : GroundTruthStudy
            A study object.
        case_keys : list or None
            A selection of cases to plot, if None, then all.
        ordered : bool
            Order units with best agreement scores.
            This enable to see agreement on a diagonal.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, ordered=True, case_keys=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_study_comparison_collision_by_similarity
  Docstring:
        Plots CollisionGTComparison pair by pair orderer by cosine_similarity for all
        cases in a study.
    
        Parameters
        ----------
        study : CollisionGTStudy
            The collision study object.
        case_keys : list or None
            A selection of cases to plot, if None, then all.
        metric : "cosine_similarity"
            metric for ordering
        similarity_bins : array
            if mode is "lines", the bins used to average the pairs
        cmap : string
            colormap used to show averages if mode is "lines"
        good_only : False
            keep only the pairs with a non zero accuracy (found templates)
        min_accuracy : float
            If good only, the minimum accuracy every cell should have, individually, to be
            considered in a putative pair
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, case_keys=None, metric='cosine_similarity', similarity_bins=array([-4.00000000e-01, -2.00000000e-01, -5.55111512e-17,  2.00000000e-01,
        4.00000000e-01,  6.00000000e-01,  8.00000000e-01,  1.00000000e+00]), show_legend=False, ylim=(0.5, 1), good_only=False, min_accuracy=0.9, cmap='winter', backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_study_performances
  Docstring:
        Plot performances over case for a study.
    
    
        Parameters
        ----------
        study : GroundTruthStudy
            A study object.
        mode : "ordered" | "snr" | "swarm", default: "ordered"
            Which plot mode to use:
    
            * "ordered": plot performance metrics vs unit indices ordered by decreasing accuracy
            * "snr": plot performance metrics vs snr
            * "swarm": plot performance metrics as a swarm plot (see seaborn.swarmplot for details)
        performance_names : list or tuple, default: ("accuracy", "precision", "recall")
            Which performances to plot ("accuracy", "precision", "recall")
        case_keys : list or None
            A selection of cases to plot, if None, then all.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, mode='ordered', performance_names=('accuracy', 'precision', 'recall'), case_keys=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_study_run_times
  Docstring:
        Plot sorter run times for a SorterStudy.
    
        Parameters
        ----------
        study : SorterStudy
            A study object.
        case_keys : list or None
            A selection of cases to plot, if None, then all.
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, case_keys=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_study_summary
  Docstring:
        Plot a summary of a ground truth study.
        Internally this plotting function runs:
    
          * plot_study_run_times
          * plot_study_unit_counts
          * plot_study_performances
          * plot_study_agreement_matrix
    
        Parameters
        ----------
        study : GroundTruthStudy
            A study object.
        case_keys : list or None, default: None
            A selection of cases to plot, if None, then all.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, case_keys=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_study_unit_counts
  Docstring:
        Plot unit counts for a study: "num_well_detected", "num_false_positive", "num_redundant", "num_overmerged"
    
        Parameters
        ----------
        study : SorterStudy
            A study object.
        case_keys : list or None
            A selection of cases to plot, if None, then all.
    
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, case_keys=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_template_metrics
  Docstring:
        Plots template metrics distributions.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The object to get quality metrics from
        unit_ids : list or None, default: None
            List of unit ids
        include_metrics : list or None, default: None
            If given list of quality metrics to include
        skip_metrics : list or None or None, default: None
            If given, a list of quality metrics to skip
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, include_metrics=None, skip_metrics=None, unit_colors=None, hide_unit_selector=False, backend=None, **backend_kwargs)

Class: plot_template_similarity
  Docstring:
        Plots unit template similarity.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The object to get template similarity from
        unit_ids : list or None, default: None
            List of unit ids default: None
        display_diagonal_values : bool, default: False
            If False, the diagonal is displayed as zeros.
            If True, the similarity values (all 1s) are displayed
        cmap : matplotlib colormap, default: "viridis"
            The matplotlib colormap
        show_unit_ticks : bool, default: False
            If True, ticks display unit ids
        show_colorbar : bool, default: True
            If True, color bar is displayed
        backend: str
        
        * matplotlib
        * sortingview
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids=None, cmap='viridis', display_diagonal_values=False, show_unit_ticks=False, show_colorbar=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Function: plot_timeseries(*args, **kwargs)
  Docstring:
    None

Class: plot_traces
  Docstring:
        Plots recording timeseries.
    
        Parameters
        ----------
        recording : RecordingExtractor, dict, or list
            The recording extractor object. If dict (or list) then it is a multi-layer display to compare, for example,
            different processing steps
        segment_index : None or int, default: None
            The segment index (required for multi-segment recordings)
        channel_ids : list or None, default: None
            The channel ids to display
        order_channel_by_depth : bool, default: False
            Reorder channel by depth
        time_range : list, tuple or None, default: None
            List with start time and end time
        mode : "line" | "map" | "auto", default: "auto"
            Three possible modes
            * "line": classical for low channel count
            * "map": for high channel count use color heat map
            * "auto": auto switch depending on the channel count ("line" if less than 64 channels, "map" otherwise)
        return_scaled : bool, default: False
            If True and the recording has scaled traces, it plots the scaled traces
        events : np.array | list[np.narray] or None, default: None
            Events to display as vertical lines.
            The numpy arrays cen either be of dtype float, with event times in seconds,
            or a structured array with the "time" field,
            and optional "duration" and "label" fields.
            For multi-segment recordings, provide a list of numpy array events, one for each segment.
        cmap : matplotlib colormap, default: "RdBu_r"
            matplotlib colormap used in mode "map"
        show_channel_ids : bool, default: False
            Set yticks with channel ids
        color_groups : bool, default: False
            If True groups are plotted with different colors
        color : str or None, default: None
            The color used to draw the traces
        clim : None, tuple or dict, default: None
            When mode is "map", this argument controls color limits.
            If dict, keys should be the same as recording keys
        scale : float, default: 1
            Scale factor for the traces
        vspacing_factor : float, default: 1.5
            Vertical spacing between channels as a multiple of maximum channel amplitude
        with_colorbar : bool, default: True
            When mode is "map", a colorbar is added
        tile_size : int, default: 1500
            For sortingview backend, the size of each tile in the rendered image
        seconds_per_row : float, default: 0.2
            For "map" mode and sortingview backend, seconds to render in each row
        add_legend : bool, default: True
            If True adds legend to figures
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
        * ephyviewer
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, recording, segment_index=None, channel_ids=None, order_channel_by_depth=False, time_range=None, mode='auto', return_scaled=False, cmap='RdBu_r', show_channel_ids=False, events=None, events_color='gray', events_alpha=0.5, color_groups=False, color=None, clim=None, tile_size=1500, seconds_per_row=0.2, scale=1, vspacing_factor=1.5, with_colorbar=True, add_legend=True, backend=None, **backend_kwargs)
  Method: plot_ephyviewer(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_unit_depths
  Docstring:
        Plot unit depths
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer object
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        depth_axis : int, default: 1
            The dimension of unit_locations that is depth
        peak_sign : "neg" | "pos" | "both", default: "neg"
            Sign of peak for amplitudes
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer, unit_colors=None, depth_axis=1, peak_sign='neg', backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_unit_locations
  Docstring:
        Plots each unit's location.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer that must contains  "unit_locations" extension
        unit_ids : list or None, default: None
            List of unit ids
        with_channel_ids : bool, default: False
            Add channel ids text on the probe
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        hide_unit_selector : bool, default: False
            If True, the unit selector is not displayed (sortingview backend)
        plot_all_units : bool, default: True
            If True, all units are plotted. The unselected ones (not in unit_ids),
            are plotted in grey (matplotlib backend)
        plot_legend : bool, default: False
            If True, the legend is plotted (matplotlib backend)
        hide_axis : bool, default: False
            If True, the axis is set to off (matplotlib backend)
        margin : float, default: 50
            Amount of margin to add to plot, beyond the extremum unit locations.
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer: 'SortingAnalyzer', unit_ids: 'list | None' = None, with_channel_ids: 'bool' = False, unit_colors: 'dict | None' = None, hide_unit_selector: 'bool' = False, plot_all_units: 'bool' = True, plot_legend: 'bool' = False, hide_axis: 'bool' = False, backend: 'str | None' = None, margin: 'float' = 50, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_unit_presence
  Docstring:
        Estimates of the probability density function for each unit using Gaussian kernels,
    
        Parameters
        ----------
        sorting : SortingExtractor
            The sorting extractor object
        segment_index : None or int
            The segment index.
        time_range : list or None, default: None
            List with start time and end time
        bin_duration_s : float, default: 0.5
            Bin size (in seconds) for the heat map time axis
        smooth_sigma : float, default: 4.5
            Sigma for the Gaussian kernel (in number of bins)
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting, segment_index=None, time_range=None, bin_duration_s=0.05, smooth_sigma=4.5, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_unit_probe_map
  Docstring:
        Plots unit map. Amplitude is color coded on probe contact.
    
        Can be static (animated=False) or animated (animated=True)
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
        unit_ids : list
            List of unit ids.
        channel_ids : list
            The channel ids to display
        animated : bool, default: False
            Animation for amplitude on time
        with_channel_ids : bool, default: False
            add channel ids text on the probe
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer, unit_ids=None, channel_ids=None, animated=None, with_channel_ids=False, colorbar=True, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_unit_summary
  Docstring:
        Plot a unit summary.
    
        If amplitudes are alreday computed, they are displayed.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer object
        unit_id : int or str
            The unit id to plot the summary of
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply.
            If SortingAnalyzer is already sparse, the argument is ignored
        subwidget_kwargs : dict or None, default: None
            Parameters for the subwidgets in a nested dictionary
    
                * unit_locations : UnitLocationsWidget (see UnitLocationsWidget for details)
                * unit_waveforms : UnitWaveformsWidget (see UnitWaveformsWidget for details)
                * unit_waveform_density_map : UnitWaveformDensityMapWidget (see UnitWaveformDensityMapWidget for details)
                * autocorrelograms : AutoCorrelogramsWidget (see AutoCorrelogramsWidget for details)
                * amplitudes : AmplitudesWidget (see AmplitudesWidget for details)
    
            Please note that the unit_colors should not be set in subwidget_kwargs, but directly as a parameter of plot_unit_summary.
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer, unit_id, unit_colors=None, sparsity=None, subwidget_kwargs=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_unit_templates
  Docstring:
        Plots unit waveforms.
    
        Parameters
        ----------
        sorting_analyzer_or_templates : SortingAnalyzer | Templates
            The SortingAnalyzer or Templates object.
            If Templates is given, the "plot_waveforms" argument is set to False
        channel_ids : list or None, default: None
            The channel ids to display
        unit_ids : list or None, default: None
            List of unit ids
        plot_templates : bool, default: True
            If True, templates are plotted over the waveforms
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply
            If SortingAnalyzer is already sparse, the argument is ignored
        set_title : bool, default: True
            Create a plot title with the unit number if True
        plot_channels : bool, default: False
            Plot channel locations below traces
        unit_selected_waveforms : None or dict, default: None
            A dict key is unit_id and value is the subset of waveforms indices that should be
            be displayed (matplotlib backend)
        max_spikes_per_unit : int or None, default: 50
            If given and unit_selected_waveforms is None, only max_spikes_per_unit random units are
            displayed per waveform, (matplotlib backend)
        scale : float, default: 1
            Scale factor for the waveforms/templates (matplotlib backend)
        widen_narrow_scale : float, default: 1
            Scale factor for the x-axis of the waveforms/templates (matplotlib backend)
        axis_equal : bool, default: False
            Equal aspect ratio for x and y axis, to visualize the array geometry to scale
        lw_waveforms : float, default: 1
            Line width for the waveforms, (matplotlib backend)
        lw_templates : float, default: 2
            Line width for the templates, (matplotlib backend)
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        alpha_waveforms : float, default: 0.5
            Alpha value for waveforms (matplotlib backend)
        alpha_templates : float, default: 1
            Alpha value for templates, (matplotlib backend)
        shade_templates : bool, default: True
            If True, templates are shaded, see templates_percentile_shading argument
        templates_percentile_shading : float, tuple/list of floats, or None, default: (1, 25, 75, 99)
            It controls the shading of the templates.
            If None, the shading is +/- the standard deviation of the templates.
            If float, it controls the percentile of the template values used to shade the templates.
            Note that it is one-sided : if 5 is given, the 5th and 95th percentiles are used to shade
            the templates. If list of floats, it needs to be have an even number of elements which control
            the lower and upper percentile used to shade the templates. The first half of the elements
            are used for the lower bounds, and the second half for the upper bounds.
            Inner elements produce darker shadings. For sortingview backend only 2 or 4 elements are
            supported.
        scalebar : bool, default: False
            Display a scale bar on the waveforms plot (matplotlib backend)
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        same_axis : bool, default: False
            If True, waveforms and templates are displayed on the same axis (matplotlib backend)
        x_offset_units : bool, default: False
            In case same_axis is True, this parameter allow to x-offset the waveforms for different units
            (recommended for a few units) (matlotlib backend)
        plot_legend : bool, default: True
            Display legend (matplotlib backend)
        backend: str
        
        * matplotlib
        * sortingview
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * sortingview:
    
            * generate_url: If True, the figurl URL is generated and printed, default: True
            * display: If True and in jupyter notebook/lab, the widget is displayed in the cell, default: True.
            * figlabel: The figurl figure label, default: None
            * height: The height of the sortingview View in jupyter, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, *args, **kargs)
  Method: plot_sortingview(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_unit_waveforms
  Docstring:
        Plots unit waveforms.
    
        Parameters
        ----------
        sorting_analyzer_or_templates : SortingAnalyzer | Templates
            The SortingAnalyzer or Templates object.
            If Templates is given, the "plot_waveforms" argument is set to False
        channel_ids : list or None, default: None
            The channel ids to display
        unit_ids : list or None, default: None
            List of unit ids
        plot_templates : bool, default: True
            If True, templates are plotted over the waveforms
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply
            If SortingAnalyzer is already sparse, the argument is ignored
        set_title : bool, default: True
            Create a plot title with the unit number if True
        plot_channels : bool, default: False
            Plot channel locations below traces
        unit_selected_waveforms : None or dict, default: None
            A dict key is unit_id and value is the subset of waveforms indices that should be
            be displayed (matplotlib backend)
        max_spikes_per_unit : int or None, default: 50
            If given and unit_selected_waveforms is None, only max_spikes_per_unit random units are
            displayed per waveform, (matplotlib backend)
        scale : float, default: 1
            Scale factor for the waveforms/templates (matplotlib backend)
        widen_narrow_scale : float, default: 1
            Scale factor for the x-axis of the waveforms/templates (matplotlib backend)
        axis_equal : bool, default: False
            Equal aspect ratio for x and y axis, to visualize the array geometry to scale
        lw_waveforms : float, default: 1
            Line width for the waveforms, (matplotlib backend)
        lw_templates : float, default: 2
            Line width for the templates, (matplotlib backend)
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        alpha_waveforms : float, default: 0.5
            Alpha value for waveforms (matplotlib backend)
        alpha_templates : float, default: 1
            Alpha value for templates, (matplotlib backend)
        shade_templates : bool, default: True
            If True, templates are shaded, see templates_percentile_shading argument
        templates_percentile_shading : float, tuple/list of floats, or None, default: (1, 25, 75, 99)
            It controls the shading of the templates.
            If None, the shading is +/- the standard deviation of the templates.
            If float, it controls the percentile of the template values used to shade the templates.
            Note that it is one-sided : if 5 is given, the 5th and 95th percentiles are used to shade
            the templates. If list of floats, it needs to be have an even number of elements which control
            the lower and upper percentile used to shade the templates. The first half of the elements
            are used for the lower bounds, and the second half for the upper bounds.
            Inner elements produce darker shadings. For sortingview backend only 2 or 4 elements are
            supported.
        scalebar : bool, default: False
            Display a scale bar on the waveforms plot (matplotlib backend)
        hide_unit_selector : bool, default: False
            For sortingview backend, if True the unit selector is not displayed
        same_axis : bool, default: False
            If True, waveforms and templates are displayed on the same axis (matplotlib backend)
        x_offset_units : bool, default: False
            In case same_axis is True, this parameter allow to x-offset the waveforms for different units
            (recommended for a few units) (matlotlib backend)
        plot_legend : bool, default: True
            Display legend (matplotlib backend)
        backend: str
        
        * matplotlib
        * ipywidgets
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
        * ipywidgets:
    
            * width_cm: Width of the figure in cm, default: 10
            * height_cm: Height of the figure in cm, default 6
            * display: If True, widgets are immediately displayed, default: True
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer_or_templates: 'SortingAnalyzer | Templates', channel_ids=None, unit_ids=None, plot_waveforms=True, plot_templates=True, plot_channels=False, unit_colors=None, sparsity=None, ncols=5, scale=1, widen_narrow_scale=1, lw_waveforms=1, lw_templates=2, axis_equal=False, unit_selected_waveforms=None, max_spikes_per_unit=50, set_title=True, same_axis=False, shade_templates=True, templates_percentile_shading=(1, 25, 75, 99), scalebar=False, x_offset_units=False, alpha_waveforms=0.5, alpha_templates=1, hide_unit_selector=False, plot_legend=True, backend=None, **backend_kwargs)
  Method: plot_ipywidgets(self, data_plot, **backend_kwargs)
    Docstring:
      None
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Class: plot_unit_waveforms_density_map
  Docstring:
        Plots unit waveforms using heat map density.
    
        Parameters
        ----------
        sorting_analyzer : SortingAnalyzer
            The SortingAnalyzer for calculating waveforms
        channel_ids : list or None, default: None
            The channel ids to display
        unit_ids : list or None, default: None
            List of unit ids
        sparsity : ChannelSparsity or None, default: None
            Optional ChannelSparsity to apply
            If SortingAnalyzer is already sparse, the argument is ignored
        use_max_channel : bool, default: False
            Use only the max channel
        peak_sign : "neg" | "pos" | "both", default: "neg"
            Used to detect max channel only when use_max_channel=True
        unit_colors : dict | None, default: None
            Dict of colors with unit ids as keys and colors as values. Colors can be any type accepted
            by matplotlib. If None, default colors are chosen using the `get_some_colors` function.
        same_axis : bool, default: False
            If True then all density are plot on the same axis and then channels is the union
            all channel per units
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, sorting_analyzer, channel_ids=None, unit_ids=None, sparsity=None, same_axis=False, use_max_channel=False, peak_sign='neg', unit_colors=None, backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None

Function: set_default_plotter_backend(backend)
  Docstring:
    None

Class: wcls
  Docstring:
        Plots CollisionGTComparison pair by pair orderer by cosine_similarity for all
        cases in a study.
    
        Parameters
        ----------
        study : CollisionGTStudy
            The collision study object.
        case_keys : list or None
            A selection of cases to plot, if None, then all.
        metric : "cosine_similarity"
            metric for ordering
        similarity_bins : array
            if mode is "lines", the bins used to average the pairs
        cmap : string
            colormap used to show averages if mode is "lines"
        good_only : False
            keep only the pairs with a non zero accuracy (found templates)
        min_accuracy : float
            If good only, the minimum accuracy every cell should have, individually, to be
            considered in a putative pair
        backend: str
        
        * matplotlib
    
    **backend_kwargs: kwargs
        
        * matplotlib:
    
            * figure: Matplotlib figure. When None, it is created, default: None
            * ax: Single matplotlib axis. When None, it is created, default: None
            * axes: Multiple matplotlib axes. When None, they is created, default: None
            * ncols: Number of columns to create in subplots, default: 5
            * figsize: Size of matplotlib figure, default: None
            * figtitle: The figure title, default: None
    
    
    Returns
    -------
    w : BaseWidget
        The output widget object.
    
    Notes
    -----
    When using the matplotlib backend, the returned `BaseWidget` contains the matplotlib fig and axis objects. This allows
    customization of plots using matplotlib machinery e.g. `returned_widget.ax.set_xlim((0,100))`.
        
  __init__(self, study, case_keys=None, metric='cosine_similarity', similarity_bins=array([-4.00000000e-01, -2.00000000e-01, -5.55111512e-17,  2.00000000e-01,
        4.00000000e-01,  6.00000000e-01,  8.00000000e-01,  1.00000000e+00]), show_legend=False, ylim=(0.5, 1), good_only=False, min_accuracy=0.9, cmap='winter', backend=None, **backend_kwargs)
  Method: plot_matplotlib(self, data_plot, **backend_kwargs)
    Docstring:
      None
