コード例 #1
0
def test_init_from_edges():
    g = PointDirectedGraph.init_from_edges(
        points,
        np.array([[1, 0], [2, 0], [1, 2], [2, 1], [1, 3], [2, 4], [3, 4],
                  [3, 5]]))
    assert (pg_directed.adjacency_matrix - g.adjacency_matrix).nnz == 0
    g = PointUndirectedGraph.init_from_edges(
        points,
        np.array([[0, 1], [0, 2], [1, 2], [1, 3], [2, 4], [3, 4], [3, 5]]))
    assert (pg_undirected.adjacency_matrix - g.adjacency_matrix).nnz == 0
    g = PointUndirectedGraph.init_from_edges(
        points,
        np.array([[0, 1], [1, 0], [0, 2], [2, 0], [1, 2], [2, 1], [1, 3],
                  [3, 1], [2, 4], [4, 2], [3, 4], [4, 3], [3, 5], [5, 3]]))
    assert (pg_undirected.adjacency_matrix - g.adjacency_matrix).nnz == 0
    g = PointTree.init_from_edges(points2,
                                  np.array([[0, 1], [0, 2], [1, 3], [1, 4],
                                            [2, 5], [3, 6], [4, 7], [5, 8]]),
                                  root_vertex=0)
    assert (pg_tree.adjacency_matrix - g.adjacency_matrix).nnz == 0
    g = PointUndirectedGraph.init_from_edges(
        points, np.array([[0, 2], [2, 4], [3, 4]]))
    assert (pg_isolated.adjacency_matrix - g.adjacency_matrix).nnz == 0
    g = PointDirectedGraph.init_from_edges(point, np.array([]))
    assert (pg_single.adjacency_matrix - g.adjacency_matrix).nnz == 0
コード例 #2
0
ファイル: base.py プロジェクト: walkoncross/menpofit
    def instance(self, shape_weights=None, scale_index=-1, as_graph=False):
        r"""
        Generates an instance of the shape model.

        Parameters
        ----------
        shape_weights : ``(n_weights,)`` `ndarray` or `list` or ``None``, optional
            The weights of the shape model that will be used to create a novel
            shape instance. If ``None``, the weights are assumed to be zero,
            thus the mean shape is used.
        scale_index : `int`, optional
            The scale to be used.
        as_graph : `bool`, optional
            If ``True``, then the instance will be returned as a
            `menpo.shape.PointTree` or a `menpo.shape.PointDirectedGraph`,
            depending on the type of the deformation graph.
        """
        if shape_weights is None:
            shape_weights = [0]
        sm = self.shape_models[scale_index].model
        shape_instance = sm.instance(shape_weights, normalized_weights=True)
        if as_graph:
            if isinstance(self.deformation_graph[scale_index], Tree):
                shape_instance = PointTree(
                    shape_instance.points,
                    self.deformation_graph[scale_index].adjacency_matrix,
                    self.deformation_graph[scale_index].root_vertex)
            else:
                shape_instance = PointDirectedGraph(
                    shape_instance.points,
                    self.deformation_graph[scale_index].adjacency_matrix)
        return shape_instance
コード例 #3
0
ファイル: test_graph.py プロジェクト: eosulliv/menpo
def test_init_2d_grid():
    g = PointTree.init_2d_grid((5, 5))
    assert g.adjacency_matrix.nnz == 24
    assert g.n_points == 25
    g = PointUndirectedGraph.init_2d_grid((5, 5))
    assert g.adjacency_matrix.nnz == 80
    assert g.n_points == 25
    g = PointDirectedGraph.init_2d_grid((5, 5))
    assert g.adjacency_matrix.nnz == 80
    assert g.n_points == 25
コード例 #4
0
def test_init_2d_grid():
    g = PointTree.init_2d_grid((5, 5))
    assert g.adjacency_matrix.nnz == 24
    assert g.n_points == 25
    g = PointUndirectedGraph.init_2d_grid((5, 5))
    assert g.adjacency_matrix.nnz == 80
    assert g.n_points == 25
    g = PointDirectedGraph.init_2d_grid((5, 5))
    assert g.adjacency_matrix.nnz == 80
    assert g.n_points == 25
コード例 #5
0
    def view_deformation_graph_widget(self, scale_index=-1,
                                      figure_size=(7, 7)):
        r"""
        Visualize the deformation graph using an interactive widget.

        Parameters
        ----------
        scale_index : `int`, optional
            The scale to be used.
        figure_size : (`int`, `int`), optional
            The size of the rendered figure.
        """
        if isinstance(self.deformation_graph[scale_index], Tree):
            dg = PointTree(self.shape_models[scale_index].model.mean().points,
                           self.deformation_graph[scale_index].adjacency_matrix,
                           self.deformation_graph[scale_index].root_vertex)
        else:
            dg = PointDirectedGraph(
                self.shape_models[scale_index].model.mean().points,
                self.deformation_graph[scale_index].adjacency_matrix)
        dg.view_widget(figure_size=figure_size)
コード例 #6
0
ファイル: test_graph.py プロジェクト: eosulliv/menpo
def test_init_2d_grid_custom_adjacency():
    tree_adj = np.array([[0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 0, 0], [0, 0, 1, 0]])
    g = PointTree.init_2d_grid((2, 2), root_vertex=0, adjacency_matrix=tree_adj)
    assert g.adjacency_matrix.nnz == 3
    assert g.n_points == 4
    single_edge = lil_matrix((25, 25))
    single_edge[[0, 1], [1, 0]] = 1
    single_edge = single_edge.tocsr()
    g = PointUndirectedGraph.init_2d_grid((5, 5), adjacency_matrix=single_edge)
    assert g.adjacency_matrix.nnz == 2
    assert g.n_points == 25
    g = PointDirectedGraph.init_2d_grid((5, 5), adjacency_matrix=single_edge)
    assert g.adjacency_matrix.nnz == 2
    assert g.n_points == 25
コード例 #7
0
ファイル: test_graph.py プロジェクト: eosulliv/menpo
def test_init_from_depth_image():
    fake_z = np.random.uniform(size=(10, 10))
    g = PointTree.init_from_depth_image(Image(fake_z))
    assert g.n_dims == 3
    assert g.root_vertex == 55
    assert g.adjacency_matrix.nnz == 99
    assert g.n_points == 100
    g = PointUndirectedGraph.init_from_depth_image(Image(fake_z))
    assert g.n_dims == 3
    assert g.adjacency_matrix.nnz == 360
    assert g.n_points == 100
    g = PointDirectedGraph.init_from_depth_image(Image(fake_z))
    assert g.n_dims == 3
    assert g.adjacency_matrix.nnz == 360
    assert g.n_points == 100
コード例 #8
0
def test_init_from_depth_image():
    fake_z = np.random.uniform(size=(10, 10))
    g = PointTree.init_from_depth_image(Image(fake_z))
    assert g.n_dims == 3
    assert g.root_vertex == 55
    assert g.adjacency_matrix.nnz == 99
    assert g.n_points == 100
    g = PointUndirectedGraph.init_from_depth_image(Image(fake_z))
    assert g.n_dims == 3
    assert g.adjacency_matrix.nnz == 360
    assert g.n_points == 100
    g = PointDirectedGraph.init_from_depth_image(Image(fake_z))
    assert g.n_dims == 3
    assert g.adjacency_matrix.nnz == 360
    assert g.n_points == 100
コード例 #9
0
def test_init_from_depth_image_masked():
    fake_z = np.random.uniform(size=(10, 10))
    mask = np.zeros(fake_z.shape, dtype=np.bool)
    mask[2:6, 2:6] = True
    im = MaskedImage(fake_z, mask=mask)
    g = PointTree.init_from_depth_image(im)
    assert g.n_dims == 3
    assert g.root_vertex == 0
    assert g.adjacency_matrix.nnz == 15
    assert g.n_points == 16
    g = PointUndirectedGraph.init_from_depth_image(im)
    assert g.n_dims == 3
    assert g.adjacency_matrix.nnz == 48
    assert g.n_points == 16
    g = PointDirectedGraph.init_from_depth_image(im)
    assert g.n_dims == 3
    assert g.adjacency_matrix.nnz == 48
    assert g.n_points == 16
コード例 #10
0
ファイル: test_graph.py プロジェクト: eosulliv/menpo
def test_init_from_depth_image_masked():
    fake_z = np.random.uniform(size=(10, 10))
    mask = np.zeros(fake_z.shape, dtype=np.bool)
    mask[2:6, 2:6] = True
    im = MaskedImage(fake_z, mask=mask)
    g = PointTree.init_from_depth_image(im)
    assert g.n_dims == 3
    assert g.root_vertex == 0
    assert g.adjacency_matrix.nnz == 15
    assert g.n_points == 16
    g = PointUndirectedGraph.init_from_depth_image(im)
    assert g.n_dims == 3
    assert g.adjacency_matrix.nnz == 48
    assert g.n_points == 16
    g = PointDirectedGraph.init_from_depth_image(im)
    assert g.n_dims == 3
    assert g.adjacency_matrix.nnz == 48
    assert g.n_points == 16
コード例 #11
0
def test_init_2d_grid_custom_adjacency():
    tree_adj = np.array([[0, 1, 0, 0],
                         [0, 0, 0, 1],
                         [0, 0, 0, 0],
                         [0, 0, 1, 0]])
    g = PointTree.init_2d_grid((2, 2), root_vertex=0, adjacency_matrix=tree_adj)
    assert g.adjacency_matrix.nnz == 3
    assert g.n_points == 4
    single_edge = lil_matrix((25, 25))
    single_edge[[0, 1], [1, 0]] = 1
    single_edge = single_edge.tocsr()
    g = PointUndirectedGraph.init_2d_grid(
        (5, 5), adjacency_matrix=single_edge)
    assert g.adjacency_matrix.nnz == 2
    assert g.n_points == 25
    g = PointDirectedGraph.init_2d_grid(
        (5, 5), adjacency_matrix=single_edge)
    assert g.adjacency_matrix.nnz == 2
    assert g.n_points == 25
コード例 #12
0
ファイル: base.py プロジェクト: nontas/antonakoscvpr2015
    def random_instance(self, level=-1, as_graph=False):
        r"""
        """
        sm = self.shape_models[level]

        shape_weights = (np.random.randn(sm.n_active_components) *
                         sm.eigenvalues[:sm.n_active_components]**0.5)
        shape_instance = sm.instance(shape_weights)
        if as_graph:
            if isinstance(self.graph_deformation, Tree):
                shape_instance = PointTree(
                    shape_instance.points,
                    self.graph_deformation.adjacency_array,
                    self.graph_deformation.root_vertex)
            else:
                shape_instance = PointDirectedGraph(
                    shape_instance.points,
                    self.graph_deformation.adjacency_array)

        return shape_instance
コード例 #13
0
ファイル: base.py プロジェクト: nontas/antonakoscvpr2015
    def instance(self, shape_weights=None, level=-1, as_graph=False):
        r"""
        """
        sm = self.shape_models[level]

        if shape_weights is None:
            shape_weights = [0]
        n_shape_weights = len(shape_weights)
        shape_weights *= sm.eigenvalues[:n_shape_weights] ** 0.5
        shape_instance = sm.instance(shape_weights)
        if as_graph:
            if isinstance(self.graph_deformation, Tree):
                shape_instance = PointTree(
                    shape_instance.points,
                    self.graph_deformation.adjacency_array,
                    self.graph_deformation.root_vertex)
            else:
                shape_instance = PointDirectedGraph(
                    shape_instance.points,
                    self.graph_deformation.adjacency_array)

        return shape_instance
コード例 #14
0
ファイル: base.py プロジェクト: nontas/antonakoscvpr2015
def _get_relative_locations(shapes, graph, level_str, verbose):
    r"""
    returns numpy.array of size 2 x n_images x n_edges
    """
    # convert given shapes to point graphs
    if isinstance(graph, Tree):
        point_graphs = [
            PointTree(shape.points, graph.adjacency_array, graph.root_vertex)
            for shape in shapes
        ]
    else:
        point_graphs = [
            PointDirectedGraph(shape.points, graph.adjacency_array)
            for shape in shapes
        ]

    # initialize an output numpy array
    rel_loc_array = np.empty((2, graph.n_edges, len(point_graphs)))

    # get relative locations
    for c, pt in enumerate(point_graphs):
        # print progress
        if verbose:
            print_dynamic('{}Computing relative locations from '
                          'shapes - {}'.format(
                              level_str,
                              progress_bar_str(float(c + 1) /
                                               len(point_graphs),
                                               show_bar=False)))

        # get relative locations from this shape
        rl = pt.relative_locations()

        # store
        rel_loc_array[..., c] = rl.T

    # rollaxis and return
    return np.rollaxis(rel_loc_array, 2, 1)
コード例 #15
0
def test_init_from_edges():
    g = PointDirectedGraph.init_from_edges(
        points, np.array([[1, 0], [2, 0], [1, 2], [2, 1], [1, 3], [2, 4],
                          [3, 4], [3, 5]]))
    assert (pg_directed.adjacency_matrix - g.adjacency_matrix).nnz == 0
    g = PointUndirectedGraph.init_from_edges(
        points, np.array([[0, 1], [0, 2], [1, 2], [1, 3], [2, 4], [3, 4],
                          [3, 5]]))
    assert (pg_undirected.adjacency_matrix - g.adjacency_matrix).nnz == 0
    g = PointUndirectedGraph.init_from_edges(
        points, np.array([[0, 1], [1, 0], [0, 2], [2, 0], [1, 2], [2, 1],
                          [1, 3], [3, 1], [2, 4], [4, 2], [3, 4], [4, 3],
                          [3, 5], [5, 3]]))
    assert (pg_undirected.adjacency_matrix - g.adjacency_matrix).nnz == 0
    g = PointTree.init_from_edges(
        points2, np.array([[0, 1], [0, 2], [1, 3], [1, 4], [2, 5], [3, 6],
                           [4, 7], [5, 8]]), root_vertex=0)
    assert (pg_tree.adjacency_matrix - g.adjacency_matrix).nnz == 0
    g = PointUndirectedGraph.init_from_edges(
        points, np.array([[0, 2], [2, 4], [3, 4]]))
    assert (pg_isolated.adjacency_matrix - g.adjacency_matrix).nnz == 0
    g = PointDirectedGraph.init_from_edges(point, np.array([]))
    assert (pg_single.adjacency_matrix - g.adjacency_matrix).nnz == 0
コード例 #16
0
ファイル: base.py プロジェクト: nontas/antonakoscvpr2015
def plot_deformation_model(aps, level, n_std):
    mean_shape = aps.shape_models[level].mean().points
    for e in range(aps.graph_deformation.n_edges):
        # find vertices
        parent = aps.graph_deformation.adjacency_array[e, 0]
        child = aps.graph_deformation.adjacency_array[e, 1]

        # relative location mean
        rel_loc_mean = mean_shape[child, :] - mean_shape[parent, :]

        # relative location cov
        n_points = aps.deformation_models[0].shape[0] / 2
        s1 = -aps.deformation_models[level][2 * child, 2 * parent]
        s2 = -aps.deformation_models[level][2 * child + 1, 2 * parent + 1]
        s3 = -aps.deformation_models[level][2 * child, 2 * parent + 1]
        cov_mat = np.linalg.inv(np.array([[s1, s3], [s3, s2]]))

        # plot ellipse
        plot_gaussian_ellipse(cov_mat,
                              mean_shape[parent, :] + rel_loc_mean,
                              n_std=n_std,
                              facecolor='none',
                              edgecolor='r')

    # plot mean shape points
    plt.scatter(aps.shape_models[level].mean().points[:, 0],
                aps.shape_models[level].mean().points[:, 1])
    #aps.shape_models[level].mean().pointsview_on(plt.gcf().number)

    # create and plot edge connections
    if isinstance(aps.graph_deformation, Tree):
        PointTree(mean_shape, aps.graph_deformation.adjacency_array,
                  aps.graph_deformation.root_vertex).view_on(plt.gcf().number)
    else:
        PointDirectedGraph(mean_shape,
                           aps.graph_deformation.adjacency_array).view_on(
                               plt.gcf().number)
コード例 #17
0
ファイル: base.py プロジェクト: walkoncross/menpofit
    def view_deformation_model(self,
                               scale_index=-1,
                               n_std=2,
                               render_colour_bar=False,
                               colour_map='jet',
                               image_view=True,
                               figure_id=None,
                               new_figure=False,
                               render_graph_lines=True,
                               graph_line_colour='b',
                               graph_line_style='-',
                               graph_line_width=1.,
                               ellipse_line_colour='r',
                               ellipse_line_style='-',
                               ellipse_line_width=1.,
                               render_markers=True,
                               marker_style='o',
                               marker_size=5,
                               marker_face_colour='k',
                               marker_edge_colour='k',
                               marker_edge_width=1.,
                               render_axes=False,
                               axes_font_name='sans-serif',
                               axes_font_size=10,
                               axes_font_style='normal',
                               axes_font_weight='normal',
                               crop_proportion=0.1,
                               figure_size=(10, 8)):
        r"""
        Visualize the deformation model by plotting a Gaussian ellipsis per
        graph edge.

        Parameters
        ----------
        scale_index : `int`, optional
            The scale to be used.
        n_std : `float`, optional
            This defines the size of the ellipses in terms of number of standard
            deviations.
        render_colour_bar : `bool`, optional
            If ``True``, then the ellipses will be coloured based on their
            normalized standard deviations and a colour bar will also appear on
            the side. If ``False``, then all the ellipses will have the same
            colour.
        colour_map : `str`, optional
            A valid Matplotlib colour map. For more info, please refer to
            `matplotlib.cm`.
        image_view : `bool`, optional
            If ``True`` the ellipses will be rendered in the image coordinates
            system.
        figure_id : `object`, optional
            The id of the figure to be used.
        new_figure : `bool`, optional
            If ``True``, a new figure is created.
        render_graph_lines : `bool`, optional
            Defines whether to plot the graph's edges.
        graph_line_colour : See Below, optional
            The colour of the lines of the graph's edges.
            Example options::

                {r, g, b, c, m, k, w}
                or
                (3, ) ndarray

        graph_line_style : ``{-, --, -., :}``, optional
            The style of the lines of the graph's edges.
        graph_line_width : `float`, optional
            The width of the lines of the graph's edges.
        ellipse_line_colour : See Below, optional
            The colour of the lines of the ellipses.
            Example options::

                {r, g, b, c, m, k, w}
                or
                (3, ) ndarray

        ellipse_line_style : ``{-, --, -., :}``, optional
            The style of the lines of the ellipses.
        ellipse_line_width : `float`, optional
            The width of the lines of the ellipses.
        render_markers : `bool`, optional
            If ``True``, the centers of the ellipses will be rendered.
        marker_style : See Below, optional
            The style of the centers of the ellipses. Example options ::

                {., ,, o, v, ^, <, >, +, x, D, d, s, p, *, h, H, 1, 2, 3, 4, 8}

        marker_size : `int`, optional
            The size of the centers of the ellipses in points.
        marker_face_colour : See Below, optional
            The face (filling) colour of the centers of the ellipses.
            Example options ::

                {r, g, b, c, m, k, w}
                or
                (3, ) ndarray

        marker_edge_colour : See Below, optional
            The edge colour of the centers of the ellipses.
            Example options ::

                {r, g, b, c, m, k, w}
                or
                (3, ) ndarray

        marker_edge_width : `float`, optional
            The edge width of the centers of the ellipses.
        render_axes : `bool`, optional
            If ``True``, the axes will be rendered.
        axes_font_name : See Below, optional
            The font of the axes. Example options ::

                {serif, sans-serif, cursive, fantasy, monospace}

        axes_font_size : `int`, optional
            The font size of the axes.
        axes_font_style : ``{normal, italic, oblique}``, optional
            The font style of the axes.
        axes_font_weight : See Below, optional
            The font weight of the axes.
            Example options ::

                {ultralight, light, normal, regular, book, medium, roman,
                 semibold,demibold, demi, bold, heavy, extra bold, black}

        crop_proportion : `float`, optional
            The proportion to be left around the centers' pointcloud.
        figure_size : (`float`, `float`) `tuple` or ``None`` optional
            The size of the figure in inches.
        """
        from menpo.visualize import plot_gaussian_ellipses

        mean_shape = self.shape_models[scale_index].model.mean().points
        deformation_graph = self.deformation_graph[scale_index]

        # get covariance matrices
        covariances = []
        means = []
        for e in range(deformation_graph.n_edges):
            # find vertices
            parent = deformation_graph.edges[e, 0]
            child = deformation_graph.edges[e, 1]

            # relative location mean
            means.append(mean_shape[child, :])

            # relative location cov
            s1 = -self.deformation_models[scale_index].precision[2 * child,
                                                                 2 * parent]
            s2 = -self.deformation_models[scale_index].precision[2 * child + 1,
                                                                 2 * parent +
                                                                 1]
            s3 = -self.deformation_models[scale_index].precision[2 * child, 2 *
                                                                 parent + 1]
            covariances.append(np.linalg.inv(np.array([[s1, s3], [s3, s2]])))

        # plot deformation graph
        if isinstance(deformation_graph, Tree):
            renderer = PointTree(mean_shape,
                                 deformation_graph.adjacency_matrix,
                                 deformation_graph.root_vertex).view(
                                     figure_id=figure_id,
                                     new_figure=new_figure,
                                     image_view=image_view,
                                     render_lines=render_graph_lines,
                                     line_colour=graph_line_colour,
                                     line_style=graph_line_style,
                                     line_width=graph_line_width,
                                     render_markers=render_markers,
                                     marker_style=marker_style,
                                     marker_size=marker_size,
                                     marker_face_colour=marker_face_colour,
                                     marker_edge_colour=marker_edge_colour,
                                     marker_edge_width=marker_edge_width,
                                     render_axes=render_axes,
                                     axes_font_name=axes_font_name,
                                     axes_font_size=axes_font_size,
                                     axes_font_style=axes_font_style,
                                     axes_font_weight=axes_font_weight,
                                     figure_size=figure_size)
        else:
            renderer = PointDirectedGraph(
                mean_shape, deformation_graph.adjacency_matrix).view(
                    figure_id=figure_id,
                    new_figure=new_figure,
                    image_view=image_view,
                    render_lines=render_graph_lines,
                    line_colour=graph_line_colour,
                    line_style=graph_line_style,
                    line_width=graph_line_width,
                    render_markers=render_markers,
                    marker_style=marker_style,
                    marker_size=marker_size,
                    marker_face_colour=marker_face_colour,
                    marker_edge_colour=marker_edge_colour,
                    marker_edge_width=marker_edge_width,
                    render_axes=render_axes,
                    axes_font_name=axes_font_name,
                    axes_font_size=axes_font_size,
                    axes_font_style=axes_font_style,
                    axes_font_weight=axes_font_weight,
                    figure_size=figure_size)

        # plot ellipses
        renderer = plot_gaussian_ellipses(
            covariances,
            means,
            n_std=n_std,
            render_colour_bar=render_colour_bar,
            colour_bar_label='Normalized Standard Deviation',
            colour_map=colour_map,
            figure_id=renderer.figure_id,
            new_figure=False,
            image_view=image_view,
            line_colour=ellipse_line_colour,
            line_style=ellipse_line_style,
            line_width=ellipse_line_width,
            render_markers=render_markers,
            marker_edge_colour=marker_edge_colour,
            marker_face_colour=marker_face_colour,
            marker_edge_width=marker_edge_width,
            marker_size=marker_size,
            marker_style=marker_style,
            render_axes=render_axes,
            axes_font_name=axes_font_name,
            axes_font_size=axes_font_size,
            axes_font_style=axes_font_style,
            axes_font_weight=axes_font_weight,
            crop_proportion=crop_proportion,
            figure_size=figure_size)

        return renderer
コード例 #18
0
ファイル: test_graph.py プロジェクト: eosulliv/menpo
# Define tree and pointtree
adj_tree = np.array(
    [
        [0, 1, 1, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 1, 1, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 1, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 1, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 1, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 1],
        [0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0],
    ]
)
g_tree = Tree(adj_tree, 0)
pg_tree = PointTree(points2, adj_tree, 0)

# Define undirected graph and pointgraph with isolated vertices
adj_isolated = csr_matrix(
    ([1] * 6, ([0, 2, 2, 4, 3, 4], [2, 0, 4, 2, 4, 3])), shape=(6, 6)
)
g_isolated = UndirectedGraph(adj_isolated)
pg_isolated = PointUndirectedGraph(points, adj_isolated)

# Define undirected graph and pointgraph with a single vertex
adj_single = np.array([[0]])
g_single = DirectedGraph(adj_single)
pg_single = PointDirectedGraph(point, adj_single)


def test_create_graph_exception():