From c3ee2910b36737ef0550ce3a3ecfdce84910a323 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Wed, 11 Jan 2023 16:10:08 -0800 Subject: [PATCH 1/8] "rebase" onto latest --- libpysal/weights/contiguity.py | 82 +++++++++++++++++++++++- libpysal/weights/tests/test_perimeter.py | 56 ++++++++++++++++ 2 files changed, 135 insertions(+), 3 deletions(-) create mode 100644 libpysal/weights/tests/test_perimeter.py diff --git a/libpysal/weights/contiguity.py b/libpysal/weights/contiguity.py index 2e009f69c..890ef2815 100644 --- a/libpysal/weights/contiguity.py +++ b/libpysal/weights/contiguity.py @@ -2,16 +2,18 @@ import warnings import numpy +import pandas as pd from ..cg import voronoi_frames from ..io.fileio import FileIO from ._contW_lists import ContiguityWeightsLists +from .raster import da2W, da2WSP from .util import get_ids, get_points_array from .weights import WSP, W -from .raster import da2W, da2WSP try: from shapely.geometry import Point as shapely_point + from ..cg.shapes import Point as pysal_point point_type = (shapely_point, pysal_point) @@ -141,6 +143,7 @@ def from_dataframe( ids=None, id_order=None, use_index=None, + perimeter=False, **kwargs, ): """ @@ -175,6 +178,9 @@ def from_dataframe( use_index : bool use index of `df` as `ids` to index the spatial weights object. Defaults to False but in future will default to True. + perimeter : bool + if True, use the length of the shared boundary between adjacent units as + the weight value See Also -------- @@ -239,9 +245,13 @@ def from_dataframe( if id_order is None: id_order = ids - return cls.from_iterable( + w = cls.from_iterable( df[geom_col].tolist(), ids=ids, id_order=id_order, **kwargs ) + if perimeter: + w = _return_length_weighted_w(w, df) + return w + @classmethod def from_xarray( @@ -427,6 +437,7 @@ def from_dataframe( ids=None, id_order=None, use_index=None, + perimeter=False, **kwargs, ): """ @@ -461,6 +472,9 @@ def from_dataframe( use_index : bool use index of `df` as `ids` to index the spatial weights object. Defaults to False but in future will default to True. + perimeter : bool + if True, use the length of the shared boundary between adjacent units as + the weight value See Also -------- @@ -525,9 +539,13 @@ def from_dataframe( if id_order is None: id_order = ids - return cls.from_iterable( + w = cls.from_iterable( df[geom_col].tolist(), ids=ids, id_order=id_order, **kwargs ) + if perimeter: + w = _return_length_weighted_w(w, df) + return w + @classmethod def from_xarray( @@ -748,3 +766,61 @@ def buildContiguity(polygons, criterion="rook", ids=None): return Queen(polygons, ids=ids) else: raise Exception('Weights criterion "{}" was not found.'.format(criterion)) + + +def _return_length_weighted_w(w, data): + """Return a W object whose value is the length of the common boundary of two areal units that share border. + + Parameters + ---------- + w : libpsal.weights.Rook + data : pandas.DataFrame + + Returns + -------- + w : libpysal.weights.W + weights object with values equal to the shared border of ij + + """ + try: + import geopandas as gpd + except ImportError as e: + raise e('You must have geopandas installed to create perimeter-weighted weights') + adjlist = w.to_adjlist() + islands = pd.DataFrame.from_records( + [{"focal": island, "neighbor": island, "weight": 0} for island in w.islands] + ) + merged = adjlist.merge( + data.geometry.to_frame("geometry"), + left_on="focal", + right_index=True, + how="left", + ).merge( + data.geometry.to_frame("geometry"), + left_on="neighbor", + right_index=True, + how="left", + suffixes=("_focal", "_neighbor"), + ) + # Transforming from pandas to geopandas + merged = gpd.GeoDataFrame(merged, geometry="geometry_focal") + merged["geometry_neighbor"] = gpd.GeoSeries(merged.geometry_neighbor) + + # Getting the shared boundaries + merged["shared_boundary"] = merged.geometry_focal.intersection( + merged.set_geometry("geometry_neighbor") + ) + + # Putting it back to a matrix + merged["weight"] = merged.set_geometry("shared_boundary").length + merged_with_islands = pd.concat((merged, islands)) + length_weighted_w = W.from_adjlist( + merged_with_islands[["focal", "neighbor", "weight"]] + ) + for island in w.islands: + length_weighted_w.neighbors[island] = [] + del length_weighted_w.weights[island] + + length_weighted_w._reset() + + return length_weighted_w diff --git a/libpysal/weights/tests/test_perimeter.py b/libpysal/weights/tests/test_perimeter.py new file mode 100644 index 000000000..9526d6d72 --- /dev/null +++ b/libpysal/weights/tests/test_perimeter.py @@ -0,0 +1,56 @@ +import os +import tempfile + +import unittest +import pytest +import numpy as np +import geopandas as gpd +from ..weights import W, WSP +from ..user import build_lattice_shapefile +from .. import util +from ..contiguity import Rook, _return_length_weighted_w +from ... import examples + +NPTA3E = np.testing.assert_array_almost_equal + + +class TestPerimeter(unittest.TestCase): + def setUp(self): + shp = build_lattice_shapefile(3, 3, "tmp.shp") + gdf = gpd.read_file("tmp.shp") + dv = [0] * 3 + dv.extend(list(range(1, 7))) + gdf["dv"] = dv + gdf = gdf.dissolve(by="dv") + self.w0 = Rook.from_dataframe(gdf, perimeter=True) + self.gdf = gdf + + # us case + usgdf = gpd.read_file(examples.get_path("us48.shp")) + usgdf.set_crs("epsg:4326", inplace=True) + usgdf.to_crs(usgdf.estimate_utm_crs(), inplace=True) + self.usgdf = usgdf + self.wus = Rook.from_dataframe(usgdf, perimeter=True) + + def test_perimeter(self): + NPTA3E(self.w0.pct_nonzero, 40.81632653) + + def test_return_length_weighted(self): + w1 = _return_length_weighted_w(self.w0, self.gdf) + NPTA3E(w1.pct_nonzero, 40.81632653) + self.assertEqual(w1.weights[0], [1, 1, 1]) + self.assertEqual(w1.weights[2], [1, 1, 1, 1]) + + def test_return_length_weighted_us(self): + w1 = _return_length_weighted_w(self.wus, self.usgdf) + self.assertAlmostEqual(w1[0][7], 354625.0684908081) + self.assertAlmostEqual(w1[0][10], 605834.5010118643) + NPTA3E(w1[0][7], w1[7][0]) + w1.transform = "r" + self.assertAlmostEqual(w1[0][7], 0.3692243585791264) + self.assertAlmostEqual(w1[7][0], 0.12891667056448083) + self.assertNotAlmostEquals(w1[0][7], w1[7][0]) + + +if __name__ == "__main__": + unittest.main() From b59bfa02f91791b954c8c0340f3e51fb61bb2ed2 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Wed, 11 Jan 2023 16:25:17 -0800 Subject: [PATCH 2/8] allow scaling in perimeter weights --- libpysal/weights/contiguity.py | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/libpysal/weights/contiguity.py b/libpysal/weights/contiguity.py index 890ef2815..0eb32a693 100644 --- a/libpysal/weights/contiguity.py +++ b/libpysal/weights/contiguity.py @@ -144,6 +144,7 @@ def from_dataframe( id_order=None, use_index=None, perimeter=False, + perim_std=False, **kwargs, ): """ @@ -181,6 +182,9 @@ def from_dataframe( perimeter : bool if True, use the length of the shared boundary between adjacent units as the weight value + perim_std : bool + if True, (and `perimeter==True`), then perimeter weights are set to the + ratio of the shared boudary length to the focal unit's perimeter See Also -------- @@ -249,7 +253,7 @@ def from_dataframe( df[geom_col].tolist(), ids=ids, id_order=id_order, **kwargs ) if perimeter: - w = _return_length_weighted_w(w, df) + w = _return_length_weighted_w(w, df, perim_std) return w @@ -438,6 +442,7 @@ def from_dataframe( id_order=None, use_index=None, perimeter=False, + perim_std=False, **kwargs, ): """ @@ -475,6 +480,9 @@ def from_dataframe( perimeter : bool if True, use the length of the shared boundary between adjacent units as the weight value + perim_std : bool + if True, (and `perimeter==True`), then perimeter weights are set to the + ratio of the shared boudary length to the focal unit's perimeter See Also -------- @@ -543,7 +551,7 @@ def from_dataframe( df[geom_col].tolist(), ids=ids, id_order=id_order, **kwargs ) if perimeter: - w = _return_length_weighted_w(w, df) + w = _return_length_weighted_w(w, df, perim_std) return w @@ -768,7 +776,7 @@ def buildContiguity(polygons, criterion="rook", ids=None): raise Exception('Weights criterion "{}" was not found.'.format(criterion)) -def _return_length_weighted_w(w, data): +def _return_length_weighted_w(w, data, perimeter_standardize=False): """Return a W object whose value is the length of the common boundary of two areal units that share border. Parameters @@ -804,6 +812,7 @@ def _return_length_weighted_w(w, data): ) # Transforming from pandas to geopandas merged = gpd.GeoDataFrame(merged, geometry="geometry_focal") + total_boundary_length = merged.boundary.length merged["geometry_neighbor"] = gpd.GeoSeries(merged.geometry_neighbor) # Getting the shared boundaries @@ -812,7 +821,10 @@ def _return_length_weighted_w(w, data): ) # Putting it back to a matrix - merged["weight"] = merged.set_geometry("shared_boundary").length + if perimeter_standardize: + merged['weight'] = merged.set_geometry("shared_boundary").length / total_boundary_length + else: + merged["weight"] = merged.set_geometry("shared_boundary").length merged_with_islands = pd.concat((merged, islands)) length_weighted_w = W.from_adjlist( merged_with_islands[["focal", "neighbor", "weight"]] From eff3366340619214f61c71c745fef1f38e9f6425 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Wed, 11 Jan 2023 16:28:32 -0800 Subject: [PATCH 3/8] docstring --- libpysal/weights/contiguity.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/libpysal/weights/contiguity.py b/libpysal/weights/contiguity.py index 0eb32a693..4a3435969 100644 --- a/libpysal/weights/contiguity.py +++ b/libpysal/weights/contiguity.py @@ -776,13 +776,16 @@ def buildContiguity(polygons, criterion="rook", ids=None): raise Exception('Weights criterion "{}" was not found.'.format(criterion)) -def _return_length_weighted_w(w, data, perimeter_standardize=False): +def _return_length_weighted_w(w, data, perimeter_standardize): """Return a W object whose value is the length of the common boundary of two areal units that share border. Parameters ---------- w : libpsal.weights.Rook data : pandas.DataFrame + perimeter_standardize: bool + if True, scale the weight value equal to the shared + boundary divided by the total boundary of the focal unit. Returns -------- From c795feab541db7505570c418a9750473b6bf927b Mon Sep 17 00:00:00 2001 From: eli knaap Date: Wed, 11 Jan 2023 16:39:31 -0800 Subject: [PATCH 4/8] update perimeter tests to include perim_std argument --- libpysal/weights/tests/test_perimeter.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/libpysal/weights/tests/test_perimeter.py b/libpysal/weights/tests/test_perimeter.py index 9526d6d72..35245d9eb 100644 --- a/libpysal/weights/tests/test_perimeter.py +++ b/libpysal/weights/tests/test_perimeter.py @@ -22,7 +22,7 @@ def setUp(self): dv.extend(list(range(1, 7))) gdf["dv"] = dv gdf = gdf.dissolve(by="dv") - self.w0 = Rook.from_dataframe(gdf, perimeter=True) + self.w0 = Rook.from_dataframe(gdf, perimeter=True, perim_std=False) self.gdf = gdf # us case @@ -36,13 +36,13 @@ def test_perimeter(self): NPTA3E(self.w0.pct_nonzero, 40.81632653) def test_return_length_weighted(self): - w1 = _return_length_weighted_w(self.w0, self.gdf) + w1 = _return_length_weighted_w(self.w0, self.gdf, False) NPTA3E(w1.pct_nonzero, 40.81632653) self.assertEqual(w1.weights[0], [1, 1, 1]) self.assertEqual(w1.weights[2], [1, 1, 1, 1]) def test_return_length_weighted_us(self): - w1 = _return_length_weighted_w(self.wus, self.usgdf) + w1 = _return_length_weighted_w(self.wus, self.usgdf, False) self.assertAlmostEqual(w1[0][7], 354625.0684908081) self.assertAlmostEqual(w1[0][10], 605834.5010118643) NPTA3E(w1[0][7], w1[7][0]) From a6b80d123f3422b621d52623d77076cfc30fe63e Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 12 Jan 2023 08:26:15 -0800 Subject: [PATCH 5/8] Update libpysal/weights/contiguity.py Co-authored-by: Martin Fleischmann --- libpysal/weights/contiguity.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libpysal/weights/contiguity.py b/libpysal/weights/contiguity.py index 4a3435969..8872213f1 100644 --- a/libpysal/weights/contiguity.py +++ b/libpysal/weights/contiguity.py @@ -820,7 +820,7 @@ def _return_length_weighted_w(w, data, perimeter_standardize): # Getting the shared boundaries merged["shared_boundary"] = merged.geometry_focal.intersection( - merged.set_geometry("geometry_neighbor") + merged["geometry_neighbor"] ) # Putting it back to a matrix From 998dbe86c3349087810b0a020eac5bdeba4c528f Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 12 Jan 2023 08:26:34 -0800 Subject: [PATCH 6/8] Update libpysal/weights/contiguity.py Co-authored-by: Martin Fleischmann --- libpysal/weights/contiguity.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libpysal/weights/contiguity.py b/libpysal/weights/contiguity.py index 8872213f1..e8e79b2cd 100644 --- a/libpysal/weights/contiguity.py +++ b/libpysal/weights/contiguity.py @@ -825,7 +825,7 @@ def _return_length_weighted_w(w, data, perimeter_standardize): # Putting it back to a matrix if perimeter_standardize: - merged['weight'] = merged.set_geometry("shared_boundary").length / total_boundary_length + merged['weight'] = merged["shared_boundary"].length / total_boundary_length else: merged["weight"] = merged.set_geometry("shared_boundary").length merged_with_islands = pd.concat((merged, islands)) From 374e8aa137aa88578dc5b6fa984be358222b2e31 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 12 Jan 2023 08:26:57 -0800 Subject: [PATCH 7/8] Update libpysal/weights/contiguity.py Co-authored-by: Martin Fleischmann --- libpysal/weights/contiguity.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libpysal/weights/contiguity.py b/libpysal/weights/contiguity.py index e8e79b2cd..e71ef594e 100644 --- a/libpysal/weights/contiguity.py +++ b/libpysal/weights/contiguity.py @@ -827,7 +827,7 @@ def _return_length_weighted_w(w, data, perimeter_standardize): if perimeter_standardize: merged['weight'] = merged["shared_boundary"].length / total_boundary_length else: - merged["weight"] = merged.set_geometry("shared_boundary").length + merged["weight"] = merged["shared_boundary"].length merged_with_islands = pd.concat((merged, islands)) length_weighted_w = W.from_adjlist( merged_with_islands[["focal", "neighbor", "weight"]] From 14b41e50d9a58a36956214cbe2cc7d4714d419f1 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Fri, 13 Jan 2023 16:01:34 -0800 Subject: [PATCH 8/8] add example --- notebooks/shared_perimeter_weights.ipynb | 1414 ++++++++++++++++++++++ 1 file changed, 1414 insertions(+) create mode 100644 notebooks/shared_perimeter_weights.ipynb diff --git a/notebooks/shared_perimeter_weights.ipynb b/notebooks/shared_perimeter_weights.ipynb new file mode 100644 index 000000000..582e10d2b --- /dev/null +++ b/notebooks/shared_perimeter_weights.ipynb @@ -0,0 +1,1414 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "11457a53-35ba-4ba3-8906-f19486f4c646", + "metadata": {}, + "source": [ + "# Shared-boundary-weighted `W`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c0b59d7a-0c13-4d78-b21c-9661f3e876cf", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cbd10da8-c965-455b-ba20-4aef6e9165f5", + "metadata": {}, + "outputs": [], + "source": [ + "from libpysal.weights import Rook, Queen, lag_spatial\n", + "from splot.libpysal import plot_spatial_weights" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bbb487d7-d197-4b69-b2e7-464194f938ba", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "120dd0ce-3f70-4b57-970c-d1ee636d5b17", + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas as gpd\n", + "from libpysal import examples" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4b8f15f8-66c5-4784-bd6b-463a262fafa3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'4.7.0+40.gc795feab541d.dirty'" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import libpysal\n", + "libpysal.__version__" + ] + }, + { + "cell_type": "markdown", + "id": "b9046ae4-055a-4753-9706-a215ce49890d", + "metadata": {}, + "source": [ + "Classic contiguity-based spatial weights are typically binary; if two units share an edge (for rook weights) or a edge/vertex (for queen weights), then they are taken as neighbors with an assigned weight value of 1. Then, it is common to row-standardize the weights so that the sum of weight values for unit i equals 1" + ] + }, + { + "cell_type": "markdown", + "id": "246a8a80-81ec-49e7-afdb-f178ee8842dc", + "metadata": {}, + "source": [ + "This approach treats every neighbor equally, which in the case of regular or lattice data, makes perfect sense. Each side in a lattice has the same length, so all neighbors should be treated equally. In irregular data, like states, counties, or tracts, however, the borders between units are variable in length, so it makes sense to relax the assumption of neighbor equality." + ] + }, + { + "cell_type": "markdown", + "id": "73cc1048-ccd1-4255-9aeb-7b1bdacd701e", + "metadata": {}, + "source": [ + "For contiguity weights, one way to accomplish that is by setting the weight value equal to the lengh of the shared boundary between adjacent units. For example, California shares a much larger border with Nevada than it does with Arizona, so it might make sense to increase Nevada's \"neighborliness\" relative to Arizona." + ] + }, + { + "cell_type": "markdown", + "id": "a6465e7f-bc48-4782-9b5a-4dea53bca7a0", + "metadata": {}, + "source": [ + "But the question of standardization now includes an additional consideration. If we row-standardize the weights, following tradition, then the weights are effectively the proportion of the unit's shared boundary with its neighbors--or are they? What about states on the border?\n", + "\n", + "Again, consider the case of California... Some of California touches Mexico and much of it touches the Pacific Ocean. Should the weights be standardized by state's entire border, or just the portion that touches other states?" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "653a5939-9fc4-4a4f-a92f-674eda6bdcd2", + "metadata": {}, + "outputs": [], + "source": [ + "from libpysal.weights import build_lattice_shapefile" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fb944915-5a26-4eef-a8a6-31f9f44598f0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/knaaptime/Dropbox/projects/libpysal/libpysal/cg/shapes.py:1492: FutureWarning: Objects based on the `Geometry` class will deprecated and removed in a future version of libpysal.\n", + " warnings.warn(dep_msg, FutureWarning)\n", + "/Users/knaaptime/Dropbox/projects/libpysal/libpysal/cg/shapes.py:1208: FutureWarning: Objects based on the `Geometry` class will deprecated and removed in a future version of libpysal.\n", + " warnings.warn(dep_msg, FutureWarning)\n", + "/Users/knaaptime/Dropbox/projects/libpysal/libpysal/cg/shapes.py:1923: FutureWarning: Objects based on the `Geometry` class will deprecated and removed in a future version of libpysal.\n", + " warnings.warn(dep_msg, FutureWarning)\n" + ] + } + ], + "source": [ + "build_lattice_shapefile(3, 3, \"tmp.shp\")\n", + "lattice = gpd.read_file(\"tmp.shp\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "283b2bfa-08c9-4cf2-a5ab-9ef3a58cdc98", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 413, + "width": 421 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "lattice.plot(edgecolor='black')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "50445c34-987c-4826-b7a4-4722184fd1fa", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/79/cknfb1sx2pv16rztkpg6wzlw0000gn/T/ipykernel_59576/2966444851.py:2: FutureWarning: `use_index` defaults to False but will default to True in future. Set True/False directly to control this behavior and silence this warning\n", + " w_lattice_rook = Rook.from_dataframe(lattice)\n", + "/var/folders/79/cknfb1sx2pv16rztkpg6wzlw0000gn/T/ipykernel_59576/2966444851.py:5: FutureWarning: `use_index` defaults to False but will default to True in future. Set True/False directly to control this behavior and silence this warning\n", + " w_lattice_perim = Rook.from_dataframe(lattice, perimeter=True)\n", + "/var/folders/79/cknfb1sx2pv16rztkpg6wzlw0000gn/T/ipykernel_59576/2966444851.py:8: FutureWarning: `use_index` defaults to False but will default to True in future. Set True/False directly to control this behavior and silence this warning\n", + " w_lattice_perim_std = Rook.from_dataframe(lattice, perimeter=True, perim_std=True)\n" + ] + } + ], + "source": [ + "\n", + "# traditional contiguity weights\n", + "w_lattice_rook = Rook.from_dataframe(lattice)\n", + "\n", + "# shared-boundary weights\n", + "w_lattice_perim = Rook.from_dataframe(lattice, perimeter=True)\n", + "\n", + "# # shared-boundary weights, normalized by the total *shared border* of each observation\n", + "w_lattice_perim_std = Rook.from_dataframe(lattice, perimeter=True, perim_std=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5c625c51-6fc3-4bfe-ac4b-43f9ca629d34", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 482, + "width": 481 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_spatial_weights(w_lattice_rook, lattice, figsize=(6,6))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "488eec20-e5e3-472b-9c13-05409eef7bce", + "metadata": {}, + "outputs": [], + "source": [ + "# create a dummy variable of 1s\n", + "lattice['dummy'] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "20c3eba2-a164-46fb-a5fe-083c84965279", + "metadata": {}, + "outputs": [], + "source": [ + "# the spatial lag of the dummy variable gives the value of the summed weights\n", + "\n", + "lattice['lag'] = lag_spatial(w_lattice_rook, lattice['dummy'])" + ] + }, + { + "cell_type": "markdown", + "id": "fe574b7c-5efc-434a-8f3f-6adda727c338", + "metadata": {}, + "source": [ + "for un-transformed weights, the lag is the sum of neighbor values" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "794b7db1-4301-4fad-8d54-115a87de024f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IDgeometrydummylag
00POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1....12.0
11POLYGON ((0.00000 1.00000, 0.00000 2.00000, 1....13.0
22POLYGON ((0.00000 2.00000, 0.00000 3.00000, 1....12.0
33POLYGON ((1.00000 0.00000, 1.00000 1.00000, 2....13.0
44POLYGON ((1.00000 1.00000, 1.00000 2.00000, 2....14.0
55POLYGON ((1.00000 2.00000, 1.00000 3.00000, 2....13.0
66POLYGON ((2.00000 0.00000, 2.00000 1.00000, 3....12.0
77POLYGON ((2.00000 1.00000, 2.00000 2.00000, 3....13.0
88POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3....12.0
\n", + "
" + ], + "text/plain": [ + " ID geometry dummy lag\n", + "0 0 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1.... 1 2.0\n", + "1 1 POLYGON ((0.00000 1.00000, 0.00000 2.00000, 1.... 1 3.0\n", + "2 2 POLYGON ((0.00000 2.00000, 0.00000 3.00000, 1.... 1 2.0\n", + "3 3 POLYGON ((1.00000 0.00000, 1.00000 1.00000, 2.... 1 3.0\n", + "4 4 POLYGON ((1.00000 1.00000, 1.00000 2.00000, 2.... 1 4.0\n", + "5 5 POLYGON ((1.00000 2.00000, 1.00000 3.00000, 2.... 1 3.0\n", + "6 6 POLYGON ((2.00000 0.00000, 2.00000 1.00000, 3.... 1 2.0\n", + "7 7 POLYGON ((2.00000 1.00000, 2.00000 2.00000, 3.... 1 3.0\n", + "8 8 POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3.... 1 2.0" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lattice" + ] + }, + { + "cell_type": "markdown", + "id": "98c584d4-3215-46df-9936-91d1f7b89938", + "metadata": {}, + "source": [ + "observation 4 (in the center) shares a boundary of length 1 with four other cells (its rook neighbors, obviously) for a total weights value of 4" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a262df4e-1098-426d-901d-60d8fb7a61d4", + "metadata": {}, + "outputs": [], + "source": [ + "w_lattice_rook.transform = 'r'" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "547123e9-6fb0-4a9c-ad34-6e89fbd2b32b", + "metadata": {}, + "outputs": [], + "source": [ + "lattice['lag_row_std'] = lag_spatial(w_lattice_rook, lattice['dummy'])" + ] + }, + { + "cell_type": "markdown", + "id": "18a080c7-e692-4737-9ebc-d26e9a09d5a3", + "metadata": {}, + "source": [ + "with row-standardized we take the weighted average (rather than the weighted sum) of neighboring values, so our summed weights for each observation is 1 (theres a border of length==1 for each neighbor)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "4b577e34-3f7c-44d7-8589-b9d0f85bf1c1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IDgeometrydummylaglag_row_std
00POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1....12.01.0
11POLYGON ((0.00000 1.00000, 0.00000 2.00000, 1....13.01.0
22POLYGON ((0.00000 2.00000, 0.00000 3.00000, 1....12.01.0
33POLYGON ((1.00000 0.00000, 1.00000 1.00000, 2....13.01.0
44POLYGON ((1.00000 1.00000, 1.00000 2.00000, 2....14.01.0
55POLYGON ((1.00000 2.00000, 1.00000 3.00000, 2....13.01.0
66POLYGON ((2.00000 0.00000, 2.00000 1.00000, 3....12.01.0
77POLYGON ((2.00000 1.00000, 2.00000 2.00000, 3....13.01.0
88POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3....12.01.0
\n", + "
" + ], + "text/plain": [ + " ID geometry dummy lag \\\n", + "0 0 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1.... 1 2.0 \n", + "1 1 POLYGON ((0.00000 1.00000, 0.00000 2.00000, 1.... 1 3.0 \n", + "2 2 POLYGON ((0.00000 2.00000, 0.00000 3.00000, 1.... 1 2.0 \n", + "3 3 POLYGON ((1.00000 0.00000, 1.00000 1.00000, 2.... 1 3.0 \n", + "4 4 POLYGON ((1.00000 1.00000, 1.00000 2.00000, 2.... 1 4.0 \n", + "5 5 POLYGON ((1.00000 2.00000, 1.00000 3.00000, 2.... 1 3.0 \n", + "6 6 POLYGON ((2.00000 0.00000, 2.00000 1.00000, 3.... 1 2.0 \n", + "7 7 POLYGON ((2.00000 1.00000, 2.00000 2.00000, 3.... 1 3.0 \n", + "8 8 POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3.... 1 2.0 \n", + "\n", + " lag_row_std \n", + "0 1.0 \n", + "1 1.0 \n", + "2 1.0 \n", + "3 1.0 \n", + "4 1.0 \n", + "5 1.0 \n", + "6 1.0 \n", + "7 1.0 \n", + "8 1.0 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lattice" + ] + }, + { + "cell_type": "markdown", + "id": "43437957-4c58-4297-8283-ed23b02389d8", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "55ca847a-49bb-4339-bda6-46abc2b26fb9", + "metadata": {}, + "outputs": [], + "source": [ + "lattice['lag_perim_std'] = lag_spatial(w_lattice_perim_std, lattice['dummy'])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "4cf8b72b-7fa7-4514-8d44-ee0401c284f1", + "metadata": {}, + "outputs": [], + "source": [ + "lattice['lag_perim'] = lag_spatial(w_lattice_perim, lattice['dummy'])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "fbfb5f7a-31c0-44fe-80a8-89ff9150ae95", + "metadata": {}, + "outputs": [], + "source": [ + "# now row-standardize the perimeter weights\n", + "w_lattice_perim.transform = 'r'" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "027d4c30-4b36-4bdc-a483-4f9b19fe7f13", + "metadata": {}, + "outputs": [], + "source": [ + "# these weights have been rescaled so their total==1 but their relative importance is different than the simple rook case\n", + "lattice['lag_perim_rowstd'] = lag_spatial(w_lattice_perim, lattice['dummy'])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "e62ebe97-bd7d-4918-aa99-bff8f758655f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IDgeometrydummylaglag_row_stdlag_perim_stdlag_perimlag_perim_rowstd
00POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1....12.01.00.502.01.0
11POLYGON ((0.00000 1.00000, 0.00000 2.00000, 1....13.01.00.753.01.0
22POLYGON ((0.00000 2.00000, 0.00000 3.00000, 1....12.01.00.502.01.0
33POLYGON ((1.00000 0.00000, 1.00000 1.00000, 2....13.01.00.753.01.0
44POLYGON ((1.00000 1.00000, 1.00000 2.00000, 2....14.01.01.004.01.0
55POLYGON ((1.00000 2.00000, 1.00000 3.00000, 2....13.01.00.753.01.0
66POLYGON ((2.00000 0.00000, 2.00000 1.00000, 3....12.01.00.502.01.0
77POLYGON ((2.00000 1.00000, 2.00000 2.00000, 3....13.01.00.753.01.0
88POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3....12.01.00.502.01.0
\n", + "
" + ], + "text/plain": [ + " ID geometry dummy lag \\\n", + "0 0 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1.... 1 2.0 \n", + "1 1 POLYGON ((0.00000 1.00000, 0.00000 2.00000, 1.... 1 3.0 \n", + "2 2 POLYGON ((0.00000 2.00000, 0.00000 3.00000, 1.... 1 2.0 \n", + "3 3 POLYGON ((1.00000 0.00000, 1.00000 1.00000, 2.... 1 3.0 \n", + "4 4 POLYGON ((1.00000 1.00000, 1.00000 2.00000, 2.... 1 4.0 \n", + "5 5 POLYGON ((1.00000 2.00000, 1.00000 3.00000, 2.... 1 3.0 \n", + "6 6 POLYGON ((2.00000 0.00000, 2.00000 1.00000, 3.... 1 2.0 \n", + "7 7 POLYGON ((2.00000 1.00000, 2.00000 2.00000, 3.... 1 3.0 \n", + "8 8 POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3.... 1 2.0 \n", + "\n", + " lag_row_std lag_perim_std lag_perim lag_perim_rowstd \n", + "0 1.0 0.50 2.0 1.0 \n", + "1 1.0 0.75 3.0 1.0 \n", + "2 1.0 0.50 2.0 1.0 \n", + "3 1.0 0.75 3.0 1.0 \n", + "4 1.0 1.00 4.0 1.0 \n", + "5 1.0 0.75 3.0 1.0 \n", + "6 1.0 0.50 2.0 1.0 \n", + "7 1.0 0.75 3.0 1.0 \n", + "8 1.0 0.50 2.0 1.0 " + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lattice" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "1d19195d-42b1-4b59-a616-beeb6df71c14", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 True\n", + "1 True\n", + "2 True\n", + "3 True\n", + "4 True\n", + "5 True\n", + "6 True\n", + "7 True\n", + "8 True\n", + "dtype: bool" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lattice.lag_row_std == lattice.lag_perim_rowstd" + ] + }, + { + "cell_type": "markdown", + "id": "5137170c-7e4e-4e99-9f9c-c950f282d8fb", + "metadata": {}, + "source": [ + "any observation whose summed weights are less than one has a piece of its boundary that does not touch a neighbor. That is, any observation where `lag_perim_std` is less than one should lie on the border of the dataset. Alternatively, any observation whose summed weights equal 1 shares its *entire border* with other observations, thus it must lie somewhere on the interior of the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "1d115f8c-db7f-4cbc-bd49-e37d1cd8e66b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 413, + "width": 421 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "lattice[lattice.lag_perim_std<1].plot()" + ] + }, + { + "cell_type": "markdown", + "id": "754c1ff7-aa80-46f4-af23-044b506516f7", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "id": "4b70eb67-3331-4dd4-996c-2cde0b27b2fb", + "metadata": {}, + "source": [ + "## U.S. Example" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "3acce581-8453-4615-9724-5a0527184fde", + "metadata": {}, + "outputs": [], + "source": [ + "us = gpd.read_file(examples.get_path(\"us48.shp\")).set_crs(4326).to_crs(5070)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "c6ff1f09-7c67-4bf8-8358-2046f055a5b8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/79/cknfb1sx2pv16rztkpg6wzlw0000gn/T/ipykernel_59576/791916487.py:1: FutureWarning: `use_index` defaults to False but will default to True in future. Set True/False directly to control this behavior and silence this warning\n", + " w_us_rook = Rook.from_dataframe(us)\n", + "/var/folders/79/cknfb1sx2pv16rztkpg6wzlw0000gn/T/ipykernel_59576/791916487.py:2: FutureWarning: `use_index` defaults to False but will default to True in future. Set True/False directly to control this behavior and silence this warning\n", + " w_us_perim = Rook.from_dataframe(us.reset_index(), perimeter=True)\n", + "/var/folders/79/cknfb1sx2pv16rztkpg6wzlw0000gn/T/ipykernel_59576/791916487.py:3: FutureWarning: `use_index` defaults to False but will default to True in future. Set True/False directly to control this behavior and silence this warning\n", + " w_us_perim_std = Rook.from_dataframe(us.reset_index(), perimeter=True, perim_std=True)\n" + ] + } + ], + "source": [ + "w_us_rook = Rook.from_dataframe(us)\n", + "w_us_perim = Rook.from_dataframe(us.reset_index(), perimeter=True)\n", + "w_us_perim_std = Rook.from_dataframe(us.reset_index(), perimeter=True, perim_std=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "1d63e973-1654-4a2a-8ae3-edaa790c1dd4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 499, + "width": 794 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_spatial_weights(w_us_rook, us)" + ] + }, + { + "cell_type": "markdown", + "id": "f3f6a447-5a8e-42d5-b470-4e0ff5f15e0c", + "metadata": {}, + "source": [ + "(wait, why are wisconsin and michigan rook neighbors? thanks to the UP, michigan is a multipolygon)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "fb347671-4c06-4fc1-b62e-442293e76347", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AREAPERIMETERSTATE_STATE_IDSTATE_NAMESTATE_FIPSSUB_REGIONSTATE_ABBRgeometry
3428.85923.2573636Arizona04MtnAZPOLYGON ((-1708456.815 1273380.880, -1711763.0...
1028.18724.7871111Oregon41PacificORPOLYGON ((-2068143.002 2388778.610, -2134763.1...
2129.96923.6082222Nevada32MtnNVPOLYGON ((-1982749.369 1951705.269, -1993571.7...
\n", + "
" + ], + "text/plain": [ + " AREA PERIMETER STATE_ STATE_ID STATE_NAME STATE_FIPS SUB_REGION \\\n", + "34 28.859 23.257 36 36 Arizona 04 Mtn \n", + "10 28.187 24.787 11 11 Oregon 41 Pacific \n", + "21 29.969 23.608 22 22 Nevada 32 Mtn \n", + "\n", + " STATE_ABBR geometry \n", + "34 AZ POLYGON ((-1708456.815 1273380.880, -1711763.0... \n", + "10 OR POLYGON ((-2068143.002 2388778.610, -2134763.1... \n", + "21 NV POLYGON ((-1982749.369 1951705.269, -1993571.7... " + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# these are california's neighbors\n", + "\n", + "us.loc[w_us_rook.neighbors[23]]" + ] + }, + { + "cell_type": "markdown", + "id": "bd6d7953-95f6-43a6-8852-5a7d0e675510", + "metadata": {}, + "source": [ + "With a classic rook W, each of california's neighbors get a weight of 1" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "3aab4448-697c-45e7-87dd-769c6f40a630", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1.0, 1.0, 1.0]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w_us_rook.weights[23]" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "08d4d591-8ca6-481f-8bae-9de3312fa1d9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[346621.3071378854, 987071.8076548338, 353461.1203236629]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# with perimeter=True, the weight values are equal to the lengh of the shared border \n", + "# (here in meters, given the CRS)\n", + "w_us_perim.weights[23]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "bc1c4515-93ec-40fd-b577-eee39f660f54", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.08306747657595963, 0.23655084835434284, 0.08470663149775297]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# with perimeter=True and perim_std=True, the weights are equal to the proportion of CA's *total boundary* shared with each state \n", + "w_us_perim_std.weights[23]" + ] + }, + { + "cell_type": "markdown", + "id": "0ba187e9-7a31-45ff-87b0-3ada45289ecf", + "metadata": {}, + "source": [ + "CA shares \n", + "- 8.3% of its border with AZ\n", + "- 23.7% of its border with NV\n", + "- 8.5% of its border with OR\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "52660689-a6d2-4653-b940-4464706385b6", + "metadata": {}, + "outputs": [], + "source": [ + "us['dummy'] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "daa100c3-5c2f-4bc3-aef6-39dfb06cebfb", + "metadata": {}, + "outputs": [], + "source": [ + "us['shared_border_pct'] = lag_spatial(w_us_perim_std, us['dummy']).round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "c52b752b-3bae-4980-b9e3-1987b8d5c512", + "metadata": {}, + "source": [ + "At least 1% of the boundary from these states does not touch another state" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "8a6c15b8-b7ae-4939-9ac3-10f18bce5223", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "us[us['shared_border_pct'].round(2)<1].explore()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0302d53-7e33-4a7b-9ac0-1e1b7157482a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a2cc3fa-a341-485a-9a38-0bbd07a2e17e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:libpysal]", + "language": "python", + "name": "conda-env-libpysal-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}