ddd

def plot3d_k3d(x, **kwargs):
    """
    Plot3d() helper function to generate k3d 3D plots. This is just to
    improve readability and structure of the code.
    """
    # Lazy import because k3d is not (yet) a hard dependency
    try:
        import k3d
    except ModuleNotFoundError:
        raise ModuleNotFoundError(
            "navis.plot3d() with `k3d` backend requires the k3d library "
            "to be installed:\n  pip3 install k3d -U"
        )

    from .k3d.k3d_objects import neuron2k3d, volume2k3d, scatter2k3d

    settings = K3dSettings().update_settings(**kwargs)

    # Parse objects to plot
    (neurons, volumes, points, visual) = utils.parse_objects(x)

    neuron_cmap, volumes_cmap = prepare_colormap(
        settings.color,
        neurons=neurons,
        volumes=volumes,
        palette=settings.palette,
        color_by=None,
        alpha=settings.alpha,
        color_range=255,
    )

    data = []
    if neurons:
        data += neuron2k3d(neurons, neuron_cmap, settings)
    if volumes:
        data += volume2k3d(volumes, volumes_cmap, settings)
    if points:
        data += scatter2k3d(points, **settings.scatter_kws)

    # If not provided generate a plot
    if not settings.plot:
        plot = k3d.plot(height=settings.height)
        plot.camera_rotate_speed = 5
        plot.camera_zoom_speed = 2
        plot.camera_pan_speed = 1
        plot.grid_visible = False

    # Add data
    for trace in data:
        plot += trace

    if settings.inline and utils.is_jupyter():
        plot.display()
    else:
        logger.info("Use the `.display()` method to show the plot.")
        return plot

def plot3d_octarine(x, **kwargs):
    """Plot3d() helper function to generate octarine 3D plots.

    This is just to improve readability. Its only purpose is to find the
    existing viewer or generate a new one.

    """
    # Lazy import because octarine is not a hard dependency
    try:
        import octarine as oc
    except ModuleNotFoundError:
        raise ModuleNotFoundError(
            "navis.plot3d() with the `octarine` backend requires the `octarine3d` library "
            "to be installed:\n  pip3 install octarine3 octarine-navis-plugin -U"
        )

    if not hasattr(oc.Viewer, "add_neurons"):
        raise ModuleNotFoundError(
            "Looks like the navis plugin for octarine is not installed. "
            "Please install it via pip:\n  pip install octarine-navis-plugin"
        )

    settings = OctarineSettings().update_settings(**kwargs)

    # Parse objects to plot
    (neurons, volumes, points, visuals) = utils.parse_objects(x)

    # Check if any existing viewer has already been closed
    if isinstance(getattr(config, "primary_viewer", None), oc.Viewer):
        try:
            getattr(config, "primary_viewer").canvas.__repr__()
        except RuntimeError:
            config.primary_viewer = None

    if settings.viewer in (None, "new"):
        # If it does not exists yet, initialize a canvas object and make global
        if (
            not isinstance(getattr(config, "primary_viewer", None), oc.Viewer)
            or settings.viewer == "new"
        ):
            viewer = config.primary_viewer = oc.Viewer(
                size=settings.size,
                camera=settings.camera,
                control=settings.control,
                show=False,
                offscreen=settings.offscreen or os.environ.get("NAVIS_HEADLESS", False),
            )
        else:
            viewer = getattr(config, "primary_viewer", None)
    else:
        viewer = settings.pop("viewer", getattr(config, "primary_viewer"))

    # Make sure viewer is visible
    if settings.show:
        viewer.show()

    # We need to pop clear/clear3d to prevent clearing again later
    if settings.clear:
        settings.clear = False  # clear only once
        viewer.clear()

    # Add object (the viewer currently takes care of producing the visuals)
    if neurons:
        # We need to pop viewer-specific settings to prevent errors in plotting functions
        neuron_settings = settings.to_dict()
        for key in settings._viewer_settings:
            neuron_settings.pop(key, None)
        viewer.add_neurons(neurons, center=settings.get("center", True), **neuron_settings)
    if volumes:
        for v in volumes:
            viewer.add_mesh(
                v,
                name=getattr(v, "name", None),
                color=getattr(v, "color", (0.95, 0.95, 0.95, 0.1)),
                alpha=getattr(v, "alpha", None),
                center=settings.center,
            )
    if points:
        for p in points:
            viewer.add_points(p, center=settings.center, **settings.scatter_kws)

    return viewer

def plot3d_plotly(x, **kwargs):
    """
    Plot3d() helper function to generate plotly 3D plots. This is just to
    improve readability and structure of the code.
    """
    # Lazy import because plotly is not a hard dependency
    try:
        import plotly.graph_objs as go
        from .plotly.graph_objs import (
            neuron2plotly,
            volume2plotly,
            scatter2plotly,
            layout2plotly,
        )
    except ModuleNotFoundError:
        raise ModuleNotFoundError(
            "navis.plot3d() with the `plotly` backend requires the `plotly` library "
            "to be installed:\n  pip3 install plotly -U"
        )

    settings = PlotlySettings().update_settings(**kwargs)

    # Parse objects to plot
    (neurons, volumes, points, visual) = utils.parse_objects(x)

    neuron_cmap, volumes_cmap = prepare_colormap(
        settings.color,
        neurons=neurons,
        volumes=volumes,
        palette=settings.palette,
        color_by=None,
        alpha=settings.alpha,
        color_range=255,
    )

    data = []
    if neurons:
        data += neuron2plotly(neurons, neuron_cmap, settings)
    if volumes:
        data += volume2plotly(volumes, volumes_cmap, settings)
    if points:
        data += scatter2plotly(points, **settings.scatter_kws)

    layout = layout2plotly(**settings.to_dict())

    # If not provided generate a figure dictionary
    fig = settings.fig if settings.fig else go.Figure(layout=layout)
    if not isinstance(fig, (dict, go.Figure)):
        raise TypeError(
            "`fig` must be plotly.graph_objects.Figure or dict, got " f"{type(fig)}"
        )

    # Add data
    for trace in data:
        fig.add_trace(trace)

    if settings.inline and utils.is_jupyter():
        fig.show()
    else:
        logger.info("Use the `.show()` method to plot the figure.")
        return fig

def plot3d_vispy(x, **kwargs):
    """Plot3d() helper function to generate vispy 3D plots.

    This is just to improve readability. Its only purpose is to find the
    existing viewer or generate a new one.

    """
    from .vispy.viewer import Viewer

    # If this likely the first invoke, warn the user that vispy is deprecated
    if not hasattr(config, "primary_viewer"):
        warnings.warn(
            (
                "The `vispy` backend is depcrecated and will be removed in a future version of navis. "
                "We recommend to use the `octarine` backend instead. If that is for some reason not possible, "
                "please let us know via the issue tracker at https://github.com/navis-org/navis/issues asap."
            ),
            DeprecationWarning,
            stacklevel=2,
        )

    settings = VispySettings().update_settings(**kwargs)

    # Parse objects to plot
    (neurons, volumes, points, visuals) = utils.parse_objects(x)

    if settings.viewer in (None, "new"):
        # If does not exists yet, initialise a canvas object and make global
        if (
            not isinstance(getattr(config, "primary_viewer", None), Viewer)
            or settings.viewer == "new"
        ):
            viewer = config.primary_viewer = Viewer(size=settings.size)
        else:
            viewer = getattr(config, "primary_viewer", None)
    else:
        viewer = settings.viewer

    # Make sure viewer is visible
    if settings.show:
        viewer.show()

    # We need to pop clear/clear3d to prevent clearing again later
    if settings.clear:
        settings.clear = False
        viewer.clear()

    # Add objects (the viewer currently takes care of producing the visuals)
    if neurons:
        viewer.add(neurons, **settings.to_dict())
    if volumes:
        viewer.add(volumes, **settings.to_dict())
    if points:
        viewer.add(points, scatter_kws=settings.scatter_kws)

    return viewer