# libpysal.weights.Delaunay

class libpysal.weights.Delaunay(coordinates, **kwargs)

  Constructor of the Delaunay graph of a set of input points. Relies on scipy.spatial.Delaunay and numba to quickly construct a graph from the input set of points. Will be slower without numba, and will warn if this is missing.

  Parameters:
    coordinates `array` `of` `points`, (N,2)

      numpy array of coordinates containing locations to compute the delaunay triangulation

    **kwargs `keyword` `argument` `python:list`

      keyword arguments passed directly to weights.W

  Notes

  The Delaunay triangulation can result in quite a few non-local links among spatial coordinates. For a more useful graph, consider the weights.Voronoi constructor or the Gabriel graph.

  The weights.Voronoi class builds a voronoi diagram among the points, clips the Voronoi cells, and then constructs an adjacency graph among the clipped cells. This graph among the clipped Voronoi cells generally represents the structure of local adjacencies better than the “raw” Delaunay graph.

  The weights.gabriel.Gabriel graph constructs a Delaunay graph, but only includes the “short” links in the Delaunay graph.

  However, if the unresricted Delaunay triangulation is needed, this class will compute it much more quickly than Voronoi(coordinates, clip=None).

  __init__(coordinates, **kwargs)

  Methods

  `__init__`(coordinates, **kwargs) |
  `asymmetry`([intrinsic]) | Asymmetry check.
  `from_WSP`(WSP[, silence_warnings]) | Create a pysal W from a pysal WSP object (thin weights matrix).
  `from_adjlist`(adjlist[, focal_col, ...]) | Return an adjacency list representation of a weights object.
  `from_dataframe`(df[, geom_col, ids, use_index]) | Construct a Delaunay triangulation from a geopandas GeoDataFrame.
  `from_file`([path, format]) | Read a weights file into a W object.
  `from_networkx`(graph[, weight_col]) | Convert a `networkx` graph to a PySAL `W` object.
  `from_shapefile`(*args, **kwargs) |
  `from_sparse`(sparse) | Convert a `scipy.sparse` array to a PySAL `W` object.
  `full`() | Generate a full `numpy.ndarray`.
  `get_transform`() | Getter for transform property.
  `plot`(gdf[, indexed_on, ax, color, node_kws, ...]) | Plot spatial weights objects.
  `remap_ids`(new_ids) | In place modification throughout `W` of id values from `w.id_order` to `new_ids` in all.
  `set_shapefile`(shapefile[, idVariable, full]) | Adding metadata for writing headers of `.gal` and `.gwt` files.
  `set_transform`([value]) | Transformations of weights.
  `symmetrize`([inplace]) | Construct a symmetric KNN weight.
  `to_WSP`() | Generate a `WSP` object.
  `to_adjlist`([remove_symmetric, drop_islands, ...]) | Compute an adjacency list representation of a weights object.
  `to_file`([path, format]) | Write a weights to a file.
  `to_networkx`() | Convert a weights object to a `networkx` graph.
  `to_sparse`([fmt]) | Generate a `scipy.sparse` array object from a pysal W.

  Attributes

  `asymmetries` | List of id pairs with asymmetric weights sorted in ascending index location order.
  `cardinalities` | Number of neighbors for each observation.
  `component_labels` | Store the graph component in which each observation falls.
  `diagW2` | Diagonal of \(WW\).
  `diagWtW` | Diagonal of \(W^{'}W\).
  `diagWtW_WW` | Diagonal of \(W^{'}W + WW\).
  `histogram` | Cardinality histogram as a dictionary where key is the id and value is the number of neighbors for that unit.
  `id2i` | Dictionary where the key is an ID and the value is that ID's index in `W.id_order`.
  `id_order` | Returns the ids for the observations in the order in which they would be encountered if iterating over the weights.
  `id_order_set` | Returns `True` if user has set `id_order`, `False` if not.
  `islands` | List of ids without any neighbors.
  `max_neighbors` | Largest number of neighbors.
  `mean_neighbors` | Average number of neighbors.
  `min_neighbors` | Minimum number of neighbors.
  `n` | Number of units.
  `n_components` | Store whether the adjacency matrix is fully connected.
  `neighbor_offsets` | Given the current `id_order`, `neighbor_offsets[id]` is the offsets of the id's neighbors in `id_order`.
  `nonzero` | Number of nonzero weights.
  `pct_nonzero` | Percentage of nonzero weights.
  `s0` | `s0` is defined as
  `s1` | `s1` is defined as
  `s2` | `s2` is defined as
  `s2array` | Individual elements comprising `s2`.
  `sd` | Standard deviation of number of neighbors.
  `sparse` | Sparse matrix object.
  `transform` | Getter for transform property.
  `trcW2` | Trace of \(WW\).
  `trcWtW` | Trace of \(W^{'}W\).
  `trcWtW_WW` | Trace of \(W^{'}W + WW\).

  classmethod from_dataframe(df, geom_col=None, ids=None, use_index=None, **kwargs)

    Construct a Delaunay triangulation from a geopandas GeoDataFrame. Not that the input geometries in the dataframe must be Points. Polygons or lines must be converted to points (e.g. using df.geometry.centroid).

    Parameters:
      df `geopandas.GeoDataFrame`

        GeoDataFrame containing points to construct the Delaunay Triangulation.

      geom_col `python:str`

        the name of the column in df that contains the geometries. Defaults to active geometry column.

      ids list-like, `python:str`

        a list-like of ids to use to index the spatial weights object or the name of the column to use as IDs. If nothing is provided, the dataframe index is used if use_index=True or a positional index is used if use_index=False. Order of the resulting W is not respected from this list.

      use_index bool

        use index of df as ids to index the spatial weights object.

      **kwargs `keyword` `arguments`

        Keyword arguments that are passed downwards to the weights.W constructor.