dd

def color_to_cmap(color):
    """Convert single color to color palette."""
    color = mcl.to_rgb(color)

    colors = [[color[0], color[1], color[2], 0], [color[0], color[1], color[2], 1]]

    return mcl.LinearSegmentedColormap.from_list("Palette", colors, N=256)

def proj_points(points, M):
    """Project points using a projection matrix.

    This was previously done using the analagous function
    mpl_toolkits.mplot3d.proj3d.proj_points but that is deprecated.
    """
    xs, ys, zs = zip(*points)
    vec = np.array([xs, ys, zs, np.ones_like(xs)])

    vecw = np.dot(M, vec)
    w = vecw[3]
    # clip here..
    txs, tys, tzs = vecw[0] / w, vecw[1] / w, vecw[2] / w

    return np.column_stack((txs, tys, tzs))

def segments_to_coords(
    x: core.TreeNeuron,
    modifier: Optional[Tuple[float, float, float]] = (1, 1, 1),
    node_colors: Optional[np.ndarray] = None,
) -> List[np.ndarray]:
    """Turn lists of node IDs into coordinates.

    Will use navis-fastcore if available.

    Parameters
    ----------
    x :             TreeNeuron
                    Must contain the nodes
    node_colors :   numpy.ndarray, optional
                    A color for each node in `x.nodes`. If provided, will
                    also return a list of colors sorted to match coordinates.
    modifier :      ints, optional
                    Use e.g. to modify/invert x/y/z axes.

    Returns
    -------
    coords :        list of tuples
                    [(x, y, z), (x, y, z), ... ]
    colors :        list of colors
                    If `node_colors` provided will return a copy of it sorted
                    to match `coords`.

    """
    colors = None

    if utils.fastcore is not None:
        if node_colors is None:
            coords = utils.fastcore.segment_coords(
                x.nodes.node_id.values,
                x.nodes.parent_id.values,
                x.nodes[["x", "y", "z"]].values,
            )
        else:
            coords, colors = utils.fastcore.segment_coords(
                x.nodes.node_id.values,
                x.nodes.parent_id.values,
                x.nodes[["x", "y", "z"]].values,
                node_colors=node_colors,
            )
    else:
        # Using a dictionary here is orders of manitude faster than .loc[]!
        locs: Dict[int, Tuple[float, float, float]]
        # Oddly, this is also the fastest way to generate the dictionary
        nodes = x.nodes
        locs = {
            i: (x, y, z)
            for i, x, y, z in zip(
                nodes.node_id.values, nodes.x.values, nodes.y.values, nodes.z.values
            )
        }  # type: ignore
        # locs = {r.node_id: (r.x, r.y, r.z) for r in x.nodes.itertuples()}  # type: ignore
        coords = [np.array([locs[tn] for tn in s]) for s in x.segments]

        if not isinstance(node_colors, type(None)):
            ilocs = dict(zip(x.nodes.node_id.values, np.arange(x.nodes.shape[0])))
            colors = [node_colors[[ilocs[tn] for tn in s]] for s in x.segments]

    modifier = np.asarray(modifier)
    if (modifier != 1).any():
        for seg in coords:
            np.multiply(seg, modifier, out=seg)

    if colors is not None:
        return coords, colors

    return coords

def tn_pairs_to_coords(
    x: core.TreeNeuron, modifier: Optional[Tuple[float, float, float]] = (1, 1, 1)
) -> np.ndarray:
    """Return pairs of child->parent node coordinates.

    Parameters
    ----------
    x :         TreeNeuron
                Must contain the nodes.
    modifier :  ints, optional
                Use to modify/invert x/y/z axes.

    Returns
    -------
    coords :    np.array
                `[[[x1, y1, z1], [x2, y2, z2]], [[x3, y3, y4], [x4, y4, z4]]]`

    """
    if not isinstance(modifier, np.ndarray):
        modifier = np.array(modifier)

    nodes = x.nodes[x.nodes.parent_id >= 0]

    tn_co = nodes.loc[:, ["x", "y", "z"]].values
    parent_co = (
        x.nodes.set_index("node_id").loc[nodes.parent_id.values, ["x", "y", "z"]].values
    )

    coords = np.append(tn_co, parent_co, axis=1)

    if any(modifier != 1):
        coords *= modifier

    return coords.reshape((coords.shape[0], 2, 3))

def update_axes3d_bounds(ax):
    """Update axis bounds and remove default points (0,0,0) and (1,1,1)."""
    # Collect data points present in the figure
    points = []
    for c in ax.collections:
        if isinstance(c, Line3DCollection):
            for s in c._segments3d:
                points.append(s)
        elif isinstance(c, Poly3DCollection):
            points.append(c._vec[:3, :].T)
        elif isinstance(c, (Path3DCollection, Patch3DCollection)):
            points.append(np.array(c._offsets3d).T)

    if not len(points):
        return

    points = np.vstack(points)

    # If this is the first set of points, we need to overwrite the defaults
    # That should happen automatically but for some reason doesn't for 3d axes
    if not getattr(ax, "had_data", False):
        mn = points.min(axis=0)
        mx = points.max(axis=0)
        new_xybounds = np.array([[mn[0], mn[1]], [mx[0], mx[1]]])
        new_zzbounds = np.array([[mn[2], mn[2]], [mx[2], mx[2]]])
        ax.xy_dataLim.set_points(new_xybounds)
        ax.zz_dataLim.set_points(new_zzbounds)
        ax.xy_viewLim.set_points(new_xybounds)
        ax.zz_viewLim.set_points(new_zzbounds)
        ax.had_data = True
    else:
        ax.auto_scale_xyz(
            points[:, 0].tolist(),
            points[:, 1].tolist(),
            points[:, 2].tolist(),
            had_data=True,
        )