degurba 0.1__tar.gz

degurba-0.1/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.2
+Name: degurba
+Version: 0.1
+Summary: Urban Boundary Extraction Software Based on Degree of Urbanization
+Home-page: https://github.com/djw-easy/degurba
+Author: Your Name
+Author-email: djw@lreis.ac.cn
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: rasterio
+Requires-Dist: scipy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Urban Boundary Extraction Software Based on Degree of Urbanization
+
+## Project Introduction
+
+This project aims to provide a tool for urban boundary extraction based on the Degree of Urbanization (DEGURBA) algorithm. By integrating multi-source geospatial data, it offers a fast, flexible, and efficient method for extracting urban boundaries at specific times and locations, providing technical support and data for researchers.
+
+![example](./figs/bj_result.jpg)
+<center>
+(a) Gridded population of Beijing in 2020.
+(b) Grid cell level classification result by DEGURBA. 
+(c) Local unit classification result by DEGURBA.
+</center>
+
+## Features
+
+- **Multi-source Data Support**: Supports downloading WorldPOP and GPWV4 grid population data.
+- **Grid Cell Classification**: Classifies grid cells into urban centers, urban clusters, and rural grid units based on population density, continuity, and scale.
+- **Local Unit Classification**: Overlays the grid cell classification results onto local spatial units and further classifies them into urban areas, semi-dense areas, and rural areas.
+- **Flexible and Efficient**: Users can generate urban boundary data with different time, location, and classification accuracy requirements.
+
+## Installation
+
+### Install using QGIS
+
+#### 1. Install QGIS
+- Download and install QGIS, version 3.20 or higher.
+
+#### 2. Install rasterio
+- In the QGIS QSGeo4W Shell, run `pip install rasterio`.
+
+#### 3. Configure Plugin
+- Place the project code folder into the QGIS plugin directory.
+- Open QGIS, click on "Manage Plugins" and install the "DEGURBA" plugin.
+- Open the Processing Toolbar and select the appropriate tools for operation.
+
+### Install using Python
+
+You can install the package using pip:
+
+~~~
+pip install degurba
+~~~
+
+## Usages with QGIS
+
+1. **Download Population Data**:
+   - Use the "download worldpop grid data" or "download gpwv4 grid data" tool to select the desired dataset, country, year, and clipping area (optional).
+
+2. **Grid Cell Classification**:
+   - Use the "Grid Cell Classification" tool, input the population grid data, and output raster data.
+
+3. **Local Unit Classification**:
+   - Use the "Local Units Classification" tool, input the grid cell classification result data, and output local unit data (vector data).
+
+## Example
+
+Using Beijing's data for the year 2020 as an example:
+
+1. Download the WorldPOP population grid data for Beijing, setting the MASK layer to Beijing's vector boundary.
+
+![download window](./figs/download_1.png)
+
+![download result](./figs/download_2.png)
+
+2. Perform grid cell classification on the downloaded population grid data.
+
+![grid cell classification](./figs/grid_cell_classification_1.png)
+
+![grid cell classification result](./figs/grid_cell_classification_2.png)
+
+3. Overlay the classification results onto Beijing's local spatial units (such as districts) to complete the local unit classification.
+
+![local unit classification](./figs/local_unit_classification_1.png)
+
+![local unit classification result](./figs/local_unit_classification_2.png)
+
+## Notes
+
+- Ensure compatibility between QGIS version and the plugin.
+- When downloading data, pay attention to selecting the correct dataset and parameters.
+- When performing local unit classification, ensure that the input grid cell classification result data is complete and accurate.

degurba-0.1/README.md

@@ -0,0 +1,81 @@
+# Urban Boundary Extraction Software Based on Degree of Urbanization
+
+## Project Introduction
+
+This project aims to provide a tool for urban boundary extraction based on the Degree of Urbanization (DEGURBA) algorithm. By integrating multi-source geospatial data, it offers a fast, flexible, and efficient method for extracting urban boundaries at specific times and locations, providing technical support and data for researchers.
+
+![example](./figs/bj_result.jpg)
+<center>
+(a) Gridded population of Beijing in 2020.
+(b) Grid cell level classification result by DEGURBA. 
+(c) Local unit classification result by DEGURBA.
+</center>
+
+## Features
+
+- **Multi-source Data Support**: Supports downloading WorldPOP and GPWV4 grid population data.
+- **Grid Cell Classification**: Classifies grid cells into urban centers, urban clusters, and rural grid units based on population density, continuity, and scale.
+- **Local Unit Classification**: Overlays the grid cell classification results onto local spatial units and further classifies them into urban areas, semi-dense areas, and rural areas.
+- **Flexible and Efficient**: Users can generate urban boundary data with different time, location, and classification accuracy requirements.
+
+## Installation
+
+### Install using QGIS
+
+#### 1. Install QGIS
+- Download and install QGIS, version 3.20 or higher.
+
+#### 2. Install rasterio
+- In the QGIS QSGeo4W Shell, run `pip install rasterio`.
+
+#### 3. Configure Plugin
+- Place the project code folder into the QGIS plugin directory.
+- Open QGIS, click on "Manage Plugins" and install the "DEGURBA" plugin.
+- Open the Processing Toolbar and select the appropriate tools for operation.
+
+### Install using Python
+
+You can install the package using pip:
+
+~~~
+pip install degurba
+~~~
+
+## Usages with QGIS
+
+1. **Download Population Data**:
+   - Use the "download worldpop grid data" or "download gpwv4 grid data" tool to select the desired dataset, country, year, and clipping area (optional).
+
+2. **Grid Cell Classification**:
+   - Use the "Grid Cell Classification" tool, input the population grid data, and output raster data.
+
+3. **Local Unit Classification**:
+   - Use the "Local Units Classification" tool, input the grid cell classification result data, and output local unit data (vector data).
+
+## Example
+
+Using Beijing's data for the year 2020 as an example:
+
+1. Download the WorldPOP population grid data for Beijing, setting the MASK layer to Beijing's vector boundary.
+
+![download window](./figs/download_1.png)
+
+![download result](./figs/download_2.png)
+
+2. Perform grid cell classification on the downloaded population grid data.
+
+![grid cell classification](./figs/grid_cell_classification_1.png)
+
+![grid cell classification result](./figs/grid_cell_classification_2.png)
+
+3. Overlay the classification results onto Beijing's local spatial units (such as districts) to complete the local unit classification.
+
+![local unit classification](./figs/local_unit_classification_1.png)
+
+![local unit classification result](./figs/local_unit_classification_2.png)
+
+## Notes
+
+- Ensure compatibility between QGIS version and the plugin.
+- When downloading data, pay attention to selecting the correct dataset and parameters.
+- When performing local unit classification, ensure that the input grid cell classification result data is complete and accurate.

degurba-0.1/degurba/__init__.py

@@ -0,0 +1,3 @@
+from .main import DEGURBA
+
+__all__ = [DEGURBA]

degurba-0.1/degurba/io.py

@@ -0,0 +1,491 @@
+import os
+import json
+import math
+import numpy as np
+import rasterio as rio
+from rasterio import crs
+from affine import Affine
+from osgeo import gdal, ogr
+from rasterio import features
+from rasterio.windows import Window
+from rasterio.transform import guard_transform
+from rasterio.warp import calculate_default_transform, reproject
+
+
+def clip_raster(in_raster,
+                cutline_shp,
+                out_raster,
+                srcSRS=None, dstSRS=None,
+                srcNodata=None, dstNodata=None,
+                **kwargs):
+    """Clip raster with shapefile. 
+        Args:
+            in_raster: 
+            cutline_shp: 
+            out_raster: 
+            srcSRS, dstSRS: 
+            srcNodata, dstNodata: 
+    """
+    ds = gdal.Open(in_raster)
+    band = ds.GetRasterBand(1)
+    if srcSRS == None:
+        srcSRS = ds.GetProjection()
+    if dstSRS == None:
+        dstSRS = srcSRS
+    if srcNodata == None:
+        srcNodata = band.GetNoDataValue()
+    if dstNodata == None:
+        dstNodata = srcNodata
+    clip_options = gdal.WarpOptions(format='GTiff',
+                                    cutlineDSName=cutline_shp,
+                                    cropToCutline=True,
+                                    srcSRS=srcSRS, dstSRS=dstSRS,
+                                    srcNodata=srcNodata, dstNodata=dstNodata,
+                                    **kwargs)
+    ds_clip = gdal.Warp(out_raster, ds, options=clip_options)
+    ds = band = ds_clip = None
+
+
+def rowcol(x, y, affine, op=math.floor):
+    """ Get row/col for a x/y
+    """
+    r = int(op((y - affine.f) / affine.e))
+    c = int(op((x - affine.c) / affine.a))
+    return r, c
+
+
+def bounds_window(bounds, affine):
+    """Create a full cover rasterio-style window
+    """
+    w, s, e, n = bounds
+    row_start, col_start = rowcol(w, n, affine)
+    row_stop, col_stop = rowcol(e, s, affine, op=math.ceil)
+    return (row_start, row_stop), (col_start, col_stop)
+
+
+def window_bounds(window, affine):
+    (row_start, row_stop), (col_start, col_stop) = window
+    w, s = affine * (col_start, row_stop)
+    e, n = affine * (col_stop, row_start)
+    return w, s, e, n
+
+
+def beyond_extent(window, shape):
+    """Checks if window references pixels beyond the raster extent"""
+    (wr_start, wr_stop), (wc_start, wc_stop) = window
+    return wr_start < 0 or wc_start < 0 or wr_stop > shape[0] or wc_stop > shape[1]
+
+
+def geometry_bounds(geometry):
+    """Return a (left, bottom, right, top) bounding box.
+    Parameters
+    ----------
+    geometry: GeoJSON-like feature (implements __geo_interface__),
+              feature collection, or geometry.
+
+    Returns
+    -------
+    tuple
+        Bounding box: (left, bottom, right, top)
+    """
+    geom_types = {'Polygon', 'MultiPolygon'}
+
+    geom = getattr(geometry, '__geo_interface__', None) or geometry
+
+    try:
+        geom_type = geom["type"]
+        if geom_type not in geom_types.union({'GeometryCollection'}):
+            return False
+
+    except (KeyError, TypeError):
+        return False
+
+    if 'bbox' in geom:
+        return tuple(geom['bbox'])
+
+    geom = geom.get('geometry') or geom
+
+    # geometry must be a geometry, GeometryCollection, or FeatureCollection
+    if not ('coordinates' in geom or 'geometries' in geom or 'features' in geom):
+        raise ValueError(
+            "geometry must be a GeoJSON-like geometry, GeometryCollection, "
+            "or FeatureCollection"
+        )
+    
+    if geom_type == 'Polygon':
+        coords = np.vstack(geom['coordinates'])
+        left, right = np.min(coords[:, 0]), np.max(coords[:, 0])
+        bottom, top = np.min(coords[:, 1]), np.max(coords[:, 1])
+        return (left, bottom, right, top)
+
+    if geom_type == 'MultiPolygon':
+        # Muti polygons must have at least one Polygon
+        coords = []
+        for c in geom['coordinates']:
+            coords.append(np.vstack(c))
+        coords = np.vstack(coords)
+        left, right = np.min(coords[:, 0]), np.max(coords[:, 0])
+        bottom, top = np.min(coords[:, 1]), np.max(coords[:, 1])
+        return (left, bottom, right, top)
+
+
+def geometries_bounds(geometries):
+    """Return a (left, bottom, right, top) bounding box.
+    Parameters
+    ----------
+    geometries : iterable over geometries (GeoJSON-like objects)
+
+    Returns
+    -------
+    tuple
+        Bounding box: (left, bottom, right, top)
+    """
+    bounds = []
+    for geometry in geometries:
+        bounds.append(geometry_bounds(geometry))
+    bounds = np.array(bounds)
+    left, right = np.min(bounds[:, 0]), np.max(bounds[:, 2])
+    bottom, top = np.min(bounds[:, 1]), np.max(bounds[:, 3])
+    return (left, bottom, right, top)
+
+
+def geometry_window(geometry, affine):
+    bounds = geometry_bounds(geometry)
+    window = bounds_window(bounds, affine)
+    return window
+
+
+def overlap(shape, win):
+    height, weight = shape
+    (r_start, r_stop), (c_start, c_stop) = win
+
+    # Calculate overlap
+    or_start = max(min(r_start, height), 0)
+    or_stop = max(min(r_stop, height), 0)
+    oc_start = max(min(c_start, weight), 0)
+    oc_stop = max(min(c_stop, weight), 0)
+
+    return (or_start, or_stop), (oc_start, oc_stop)
+
+
+def boundless_array(arr, window):
+    """Return a numpy masked array by the window of arr
+    Parameters
+    ----------
+    arr: numpy array, 2D or 3D
+        if arr is a 3D numpy array, it's shape must be (channels, height, weight)
+    """
+
+    dim3 = False
+    if len(arr.shape) == 3:
+        dim3 = True
+        channels, height, weight = arr.shape
+    elif len(arr.shape) != 2:
+        raise ValueError("Must be a 2D or 3D array")
+    else:
+        height, weight = arr.shape
+
+    # unpack for readability
+    (wr_start, wr_stop), (wc_start, wc_stop) = window
+
+    # Calculate overlap
+    (olr_start, olr_stop), (olc_start, olc_stop) = overlap((height, weight), window)
+
+    # Calc dimensions
+    overlap_shape = (olr_stop - olr_start, olc_stop - olc_start)
+    if dim3:
+        window_shape = (channels, wr_stop - wr_start, wc_stop - wc_start)
+    else:
+        window_shape = (wr_stop - wr_start, wc_stop - wc_start)
+
+    # create an array of nodata values
+    out = np.ma.MaskedArray(
+                np.zeros(shape=window_shape, dtype=arr.dtype), 
+                mask=True)
+
+    # Fill with data where overlapping
+    nr_start = olr_start - wr_start
+    nr_stop = nr_start + overlap_shape[0]
+    nc_start = olc_start - wc_start
+    nc_stop = nc_start + overlap_shape[1]
+    if dim3:
+        out[:, nr_start:nr_stop, nc_start:nc_stop] = \
+            arr[:, olr_start:olr_stop, olc_start:olc_stop]
+    else:
+        out[nr_start:nr_stop, nc_start:nc_stop] = \
+            arr[olr_start:olr_stop, olc_start:olc_stop]
+
+    return out
+
+
+class Vector(object):
+
+    def __init__(self, path, layer=0):
+        if not os.path.isabs(path):
+            path = os.path.abspath(path)
+        if not os.path.exists(path):
+            raise ValueError("The path {} is not exist.".format(path))
+        self.ds = ogr.Open(path, update=1)
+        self.layer = self.ds.GetLayer(layer)
+        self.layer_def = self.layer.GetLayerDefn()
+        self.columns = []
+        for i in range(self.layer_def.GetFieldCount()):
+            field_def = self.layer_def.GetFieldDefn(i)
+            self.columns.append(field_def.GetName())
+
+    def __getitem__(self, column):
+        """
+        """
+        if (column != 'geometry' and
+                column not in self.columns):
+            raise KeyError("The column {} is not exist. ".format(column))
+
+        values = []
+        feature_count = self.layer.GetFeatureCount()
+        if not feature_count:
+            return values
+
+        for i in range(feature_count):
+            feature = self.layer.GetFeature(i)
+            if column == 'geometry':
+                geom = feature.GetGeometryRef()
+                geom = json.loads(geom.ExportToJson())
+                value = geom
+                # value = shape(geom.ExportToJson())
+            else:
+                value = feature.GetField(self.columns.index(column))
+            values.append(value)
+
+        return values
+
+    @property
+    def geometry(self):
+        return self.__getitem__('geometry')
+
+    def _type_convert(self, type):
+        type_convert = {'int': ogr.OFTInteger64,
+                        'float': ogr.OFTReal,
+                        'string': ogr.OFTString}
+        return type_convert[type]
+
+    def create_field(self, name, type,
+                     width=50,
+                     values=None):
+        if values != None:
+            length = len(values)
+            feature_count = self.layer.GetFeatureCount()
+            if length != feature_count:
+                raise ValueError(
+                    'The length of input value must be {}. '.format(feature_count))
+
+        type = self._type_convert(type)
+        field_def = ogr.FieldDefn(name, type)
+        field_def.SetWidth(width)
+        self.layer.CreateField(field_def)
+        # self.layer_def.AddFieldDefn(field_def)
+
+        for i in range(feature_count):
+            feature = self.layer.GetFeature(i)
+            if values == None:
+                feature.SetFieldNull(name)
+            value = values[i]
+            feature.SetField(name, value)
+            self.layer.SetFeature(feature)
+
+        self.columns.append(name)
+
+    def close(self):
+        self.ds.Destroy()
+
+    def __del__(self):
+        self.close()
+
+
+class Raster(object):
+    """Return a numpy masked array by the window of arr
+    Parameters
+    ----------
+    raster: numpy array or a path to an raster source
+        If raster is a numpy array, it's shape should be 2D or 3D. 
+        If raster is a 3D numpy array, it's shape must be (channels, height, weight)
+    """
+
+    def __init__(self, raster, affine=None, crs=None, nodata=None, band=1) -> None:
+        self.nodata = nodata
+        self.affine = affine
+        self.crs = crs
+        self.band = band
+        if isinstance(raster, np.ndarray):
+            if affine is None or crs is None:
+                raise ValueError(
+                    "Specify affine transform and crs for numpy arrays")
+            self.array = raster
+        elif isinstance(raster, str):
+            if not os.path.isabs(raster):
+                raster = os.path.abspath(raster)
+            src = rio.open(raster, 'r')
+            self.affine = guard_transform(src.transform)
+            self.crs = src.crs
+            self.array = src.read(self.band, masked=True)
+        # create a mask array by nodata value
+        if self.nodata != None:
+            self.array = np.ma.masked_array(self.array,
+                                            self.array == self.nodata)
+        # add nan mask (if necessary)
+        if np.issubdtype(self.array.dtype, np.floating):
+            self.array = np.ma.masked_array(self.array,
+                                            np.isnan(self.array))
+        else:
+            self.array = np.ma.masked_array(self.array, None)
+        self.shape = self.array.shape
+
+    def read(self,
+             bounds=None,
+             window=None,
+             boundless=True,
+             only_array=False):
+        """ Performs a read against the underlying array source
+
+        Parameters
+        ----------
+        bounds: bounding box
+            in w, s, e, n order, iterable, optional
+        window: rasterio-style window, optional
+            bounds OR window are required,
+            specifying both or neither will raise exception
+        boundless: boolean
+            allow window/bounds that extend beyond the dataset’s extent, default: True
+            partially or completely filled arrays will be returned as appropriate.
+        only_array: boolean
+            return a masked numpy array, default: False
+            bounds OR window are required, specifying both or neither will raise exception
+        Returns
+        -------
+        Raster object with update affine and array info
+        """
+        # Calculate the window
+        if bounds and window:
+            raise ValueError("Specify either bounds or window")
+
+        if bounds:
+            win = bounds_window(bounds, self.affine)
+        elif window:
+            win = window
+        else:
+            raise ValueError("Specify either bounds or window")
+
+        if not boundless and beyond_extent(win, self.shape):
+            raise ValueError(
+                "Window/bounds is outside dataset extent and boundless reads are disabled")
+
+        out = boundless_array(self.array, window=win)
+
+        if only_array:
+            return out
+
+        c, _, _, f = window_bounds(win, self.affine)  # c ~ west, f ~ north
+        a, b, _, d, e, _, _, _, _ = tuple(self.affine)
+        new_affine = Affine(a, b, c, d, e, f)
+
+        return Raster(out, new_affine, self.crs)
+
+    def read_from_geometry(self, geometries, boundless=True, all_touched=False):
+        """
+        Parameters
+        ----------
+        geometries : iterable over geometries (GeoJSON-like objects)
+        all_touched : boolean, optional
+            If True, all pixels touched by geometries will be burned in.  If
+            false, only pixels whose center is within the polygon or that
+            are selected by Bresenham's line algorithm will be burned in.
+        Returns
+        -------
+        Raster object with update affine and array info
+        """
+        if not isinstance(geometries, (tuple, list)):
+            geometries = [geometries]
+        bounds = geometries_bounds(geometries)
+        window = bounds_window(bounds, self.affine)
+
+        clip_raster = self.read(window=window, boundless=boundless)
+        geometry_mask = features.geometry_mask(
+            geometries=geometries,
+            out_shape=clip_raster.shape,
+            transform=clip_raster.affine,
+            all_touched=all_touched,
+            invert=True)
+        array = np.ma.masked_array(clip_raster.array, ~geometry_mask)
+
+        return Raster(array, clip_raster.affine, clip_raster.crs)
+
+    def xy(self, row, col):
+        y = self.affine.f + (row + 0.5) * self.affine.e
+        x = self.affine.c + (col + 0.5) * self.affine.a
+        return (x, y)
+
+    def index(self, x, y):
+        col = int((x - self.affine.c) // self.affine.a)
+        row = int((self.affine.f - y) // abs(self.affine.e))
+
+    def reproject(self, epsg):
+        dst_crs = crs.CRS.from_epsg(epsg)
+        height, width = self.shape
+        left = self.affine.c
+        top = self.affine.f
+        right = self.affine.c + self.affine.a * width
+        bottom = self.affine.f + self.affine.e * height
+        dst_transform, dst_width, dst_height = calculate_default_transform(
+            src_crs=self.crs,
+            dst_crs=dst_crs,
+            width=width,
+            height=height,
+            left=left,
+            bottom=bottom,
+            right=right,
+            top=top
+        )
+        # Determine the nodata value
+        if self.nodata is None:
+            if np.issubdtype(self.array.dtype, np.floating):
+                dst_nodata = np.nan
+            else:
+                dst_nodata = np.iinfo(self.array.dtype).max
+        else:
+            dst_nodata = self.nodata
+        dst_array = np.empty((dst_height, dst_width), dtype=self.array.dtype)
+        # 重投影
+        reproject(
+            # 源文件参数
+            source=self.array,
+            src_crs=self.crs,
+            src_transform=self.affine,
+            # 目标文件参数
+            destination=dst_array,
+            dst_transform=dst_transform,
+            dst_crs=dst_crs,
+            dst_nodata=dst_nodata,
+            num_threads=4)
+        return Raster(dst_array, dst_transform, dst_crs, dst_nodata)
+
+    def save(self, path, nodata=None):
+        # Determine the nodata value
+        if nodata == None:
+            if self.nodata == None:
+                if np.issubdtype(self.array.dtype, np.floating):
+                    nodata = np.nan
+                else:
+                    nodata = np.iinfo(self.array.dtype).max
+            else:
+                nodata = self.nodata
+        arr = self.array.filled(nodata)
+        with rio.open(path, 'w',
+                      driver='GTiff',
+                      nodata=nodata,
+                      height=self.shape[0],
+                      width=self.shape[1],
+                      count=1,
+                      dtype=self.array.dtype,
+                      crs=self.crs,
+                      transform=self.affine,
+                      compress='lzw') as src:
+            src.write(arr, 1)

degurba-0.1/degurba/load_data.py

@@ -0,0 +1,162 @@
+import os
+import zipfile
+import tempfile
+import urllib.request
+from glob import glob
+from .io import Raster, Vector
+
+
+gpw_v4_unadjusted_1km = {
+    "name": "Gridded Population of the World (GPW), v4  ( 30 arc-second )",
+    "base_url": "https://sedac.ciesin.columbia.edu/downloads/data/gpw-v4/gpw-v4-population-count-rev11/gpw-v4-population-count-rev11_{year}_30_sec_tif.zip",
+}
+
+gpw_v4_adjusted_1km = {
+    "name": "Gridded Population of the World (GPW), v4  ( 30 arc-second )",
+    "base_url": "https://sedac.ciesin.columbia.edu/downloads/data/gpw-v4/gpw-v4-population-count-adjusted-to-2015-unwpp-country-totals-rev11/gpw-v4-population-count-adjusted-to-2015-unwpp-country-totals-rev11_2000_30_sec_tif.zip",
+}
+
+gpw_datasets = {
+    'gpw_v4_unadjusted_1km': gpw_v4_unadjusted_1km,
+    'gpw_v4_adjusted_1km': gpw_v4_adjusted_1km,
+    "valid_years": [2000, 2005, 2010, 2015, 2020]
+}
+
+worldPop_unadjusted_1km = {
+    "name": "Unconstrained individual countries 2000-2020  ( 1km resolution )",
+    "base_url": "https://data.worldpop.org/GIS/Population/Global_2000_2020_1km/{year}/{country_upper}/{country_lower}_ppp_{year}_1km_Aggregated.tif"
+}
+
+worldPop_adjusted_1km = {
+    "name": "Unconstrained individual countries 2000-2020 UN adjusted  ( 1km resolution )",
+    "base_url": "https://data.worldpop.org/GIS/Population/Global_2000_2020_1km_UNadj/{year}/{country_upper}/{country_lower}_ppp_{year}_1km_Aggregated_UNadj.tif"
+}
+
+wp_datasets = {
+    'worldPop_unadjusted_1km': worldPop_unadjusted_1km,
+    'worldPop_adjusted_1km': worldPop_adjusted_1km,
+    "valid_years": list(range(2000, 2021))
+}
+
+wp_info = {"Algeria": "dza", "Angola": "ago", "Benin": "ben", "Botswana": "bwa", "Burkina Faso": "bfa", "Burundi": "bdi", "Cameroon": "cmr", "Cape Verde": "cpv",
+           "Central African Republic": "caf", "Chad": "tcd", "Comoros": "com", "Congo": "cog", "Cote d'Ivoire": "civ", "Democratic Republic of the Congo": "cod",
+           "Djibouti": "dji", "Egypt": "egy", "Equatorial Guinea": "gnq", "Eritrea": "eri", "Ethiopia": "eth", "Gabon": "gab", "Gambia": "gmb", "Ghana": "gha",
+           "Guinea": "gin", "Guinea-Bissau": "gnb", "Kenya": "ken", "Lesotho": "lso", "Liberia": "lbr", "Libya": "lby", "Madagascar": "mdg", "Malawi": "mwi", "Mali": "mli",
+           "Mauritania": "mrt", "Mauritius": "mus", "Mayotte": "myt", "Morocco": "mar", "Mozambique": "moz", "Namibia": "nam", "Niger": "ner", "Nigeria": "nga", "Réunion": "reu",
+           "Rwanda": "rwa", "Saint Helena, Ascension and Tristan da Cunha": "shn", "Sao Tome and Principe": "stp", "Senegal": "sen", "Seychelles": "syc", "Sierra Leone": "sle",
+           "Somalia": "som", "South Africa": "zaf", "South Sudan": "ssd", "Sudan": "sdn", "Swaziland": "swz", "Tanzania": "tza", "Togo": "tgo", "Tunisia": "tun", "Uganda": "uga",
+           "Western Sahara": "esh", "Zambia": "zmb", "Zimbabwe": "zwe", "Anguilla": "aia", "Antigua and Barbuda": "atg", "Argentina": "arg", "Aruba": "abw", "Bahamas": "bhs",
+           "Barbados": "brb", "Belize": "blz", "Bermuda": "bmu", "Bolivia": "bol", "Bonaire, Sint Eustatius and Saba": "bes", "Brazil": "bra", "British Virgin Islands": "vgb",
+           "Canada": "can", "Cayman Islands": "cym", "Chile": "chl", "Colombia": "col", "Costa Rica": "cri", "Cuba": "cub", "Curaçao": "cuw", "Dominica": "dma", "Dominican Republic": "dom",
+           "Ecuador": "ecu", "El Salvador": "slv", "Falkland Islands (Malvinas)": "flk", "French Guiana": "guf", "Greenland": "grl", "Grenada": "grd", "Guadeloupe": "glp", "Guatemala": "gtm",
+           "Guyana": "guy", "Haiti": "hti", "Honduras": "hnd", "Jamaica": "jam", "Martinique": "mtq", "Mexico": "mex", "Montserrat": "msr", "Nicaragua": "nic", "Panama": "pan", "Paraguay": "pry",
+           "Peru": "per", "Puerto Rico": "pri", "Saint Barthélemy": "blm", "Saint Kitts and Nevis": "kna", "Saint Lucia": "lca", "Saint Martin": "maf", "Saint Pierre and Miquelon": "spm",
+           "Saint Vincent and the Grenadines": "vct", "Sint Maarten (Dutch part)": "sxm", "Suriname": "sur", "Trinidad and Tobago": "tto", "Turks and Caicos Islands": "tca", "United States of America": "50",
+           "United States Virgin Islands": "vir", "Uruguay": "ury", "Venezuela": "ven", "Afghanistan": "afg", "Armenia": "arm", "Azerbaijan": "aze", "Bahrain": "bhr", "Bangladesh": "bgd", "Bhutan": "btn",
+           "Brunei Darussalam": "brn", "Cambodia": "khm", "China": "chn", "Cyprus": "cyp", "Georgia": "geo", "Hong Kong": "hkg", "India": "ind", "Indonesia": "idn", "Iran": "irn", "Iraq": "irq",
+           "Israel": "isr", "Japan": "jpn", "Jordan": "jor", "Kazakhstan": "kaz", "Kuwait": "kwt", "Kyrgyz Republic": "kgz", "Lao People's Democratic Republic": "lao", "Lebanon": "lbn", "Macao": "mac",
+           "Malaysia": "mys", "Maldives": "mdv", "Mongolia": "mng", "Myanmar": "mmr", "Nepal": "npl", "North Korea": "prk", "Oman": "omn", "Pakistan": "pak", "Palestinian Territory": "pse", "Philippines": "phl",
+           "Qatar": "qat", "Saudi Arabia": "sau", "Singapore": "sgp", "South Korea": "kor", "Sri Lanka": "lka", "Syrian Arab Republic": "syr", "Taiwan": "twn", "Tajikistan": "tjk", "Thailand": "tha", "Timor-Leste": "tls",
+           "Turkey": "tur", "Turkmenistan": "tkm", "United Arab Emirates": "are", "Uzbekistan": "uzb", "Vietnam": "vnm", "Yemen": "yem", "Albania": "alb", "Andorra": "and", "Austria": "aut", "Belarus": "blr",
+           "Belgium": "bel", "Bosnia and Herzegovina": "bih", "Bulgaria": "bgr", "Croatia": "hrv", "Czech Republic": "cze", "Denmark": "dnk", "Estonia": "est", "Faroe Islands": "fro", "Finland": "fin", "France": "fra",
+           "Germany": "deu", "Gibraltar": "gib", "Greece": "grc", "Holy See (Vatican City State)": "vat", "Hungary": "hun", "Iceland": "isl", "Ireland": "irl", "Isle of Man": "imn", "Italy": "ita", "Latvia": "lva",
+           "Liechtenstein": "lie", "Lithuania": "ltu", "Luxembourg": "lux", "Macedonia": "mkd", "Malta": "mlt", "Moldova": "mda", "Monaco": "mco", "Montenegro": "mne", "Netherlands": "nld", "Norway": "nor", "Poland": "pol",
+           "Portugal": "prt", "Romania": "rou", "Russian Federation": "rus", "San Marino": "smr", "Serbia": "srb", "Slovakia (Slovak Republic)": "svk", "Slovenia": "svn", "Spain": "esp", "Sweden": "swe", "Switzerland": "che",
+           "Ukraine": "ukr", "United Kingdom of Great Britain & Northern Ireland": "gbr", "American Samoa": "asm", "Australia": "aus", "Cook Islands": "cok", "Fiji": "fji", "French Polynesia": "pyf", "Guam": "gum",
+           "Kiribati": "kir", "Marshall Islands": "mhl", "Micronesia": "fsm", "Nauru": "nru", "New Caledonia": "ncl", "New Zealand": "nzl", "Niue": "niu", "Northern Mariana Islands": "mnp", "Palau": "plw",
+           "Papua New Guinea": "png", "Samoa": "wsm", "Solomon Islands": "slb", "Tokelau": "tkl", "Tonga": "ton", "Tuvalu": "tuv", "Vanuatu": "vut", "Wallis and Futuna": "wlf"}
+
+
+class Dataset:
+    _datasets = {
+        'gpw_v4_unadjusted_1km',
+        'gpw_v4_adjusted_1km',
+        'worldPop_unadjusted_1km',
+        'worldPop_adjusted_1km'
+    }
+
+    def __init__(
+            self,
+            ) -> None:
+        pass
+
+    def _find_url(self, dataset, year, country):
+        country_upper, country_lower = None, None
+
+        if dataset.startswith('worldPop'):
+            country_lower = wp_info[country]
+            print("The country that will be downloaded is {}".format(
+                country))
+            country_upper = country_lower.upper()
+            if year not in wp_datasets['valid_years']:
+                raise ValueError(
+                    "The dataset {} in {} is not avaliable. ".format(dataset, year))
+
+        if dataset.startswith('worldPop'):
+            self.dataset = wp_datasets[dataset]
+            self.url = self.dataset['base_url'].format(year=year, country_upper=country_upper,
+                                                       country_lower=country_lower)
+        elif dataset.startswith('gpw_v4'):
+            self.dataset = gpw_datasets[dataset]
+            self.url = self.dataset['base_url'].format(year=year)
+
+    def _download(self, dataset) -> None:
+        if dataset.startswith('worldPop'):
+            try:
+                urllib.request.urlretrieve(self.url, self.file_path)
+            except urllib.error.ContentTooShortError:
+                self._download()
+        else:
+            try:
+                urllib.request.urlretrieve(self.url, self.fp.name)
+            except urllib.error.ContentTooShortError:
+                self._download()
+
+    def download(
+            self, 
+            dataset,
+            year,
+            country=None,
+            file_path=None
+            ) -> None:
+        """Download and load Population Counts Dataset.
+            Args:
+                dataset (string): dataset name to download.
+                year: year of dataset to download.
+                country: country of dataset to download, only needed when the dataset is worldpop.
+        """
+        year = int(year)
+        if dataset not in self._datasets:
+            raise ValueError(
+                "The dataset {} is not avaliable. ".format(dataset))
+
+        self._find_url(dataset=dataset, year=year, country=country)
+
+        if not os.path.isabs(file_path):
+            file_path = os.path.abspath(file_path)
+
+        if not os.path.exists(file_path):
+            self.file_path = file_path
+        else:
+            raise ValueError("The path {} is not exist. ".format(file_path))
+
+        if dataset.startswith('gpw_v4'):
+            self.fp = tempfile.NamedTemporaryFile(suffix='.zip', mode='w', delete=False)
+
+        print("Downloading " + os.path.basename(self.file_path) + " ... ")
+        self._download(dataset)
+        if dataset.startswith('gpw_v4'):
+            z = zipfile.ZipFile(self.fp.name, 'r')
+            target_dir = os.path.dirname(self.file_path)
+            z.extract(path=target_dir)
+            z.close()
+            tif_path = glob(os.path.join(target_dir, '*.tif'))[0]
+            os.rename(tif_path, self.file_path)
+            self.fp.close()
+        print('Done')
+
+    def mask(self, shp: str):
+        vector = Vector(shp)
+        raster = Raster(self.file_path)
+        raster = raster.read_from_geometry(vector.geometry)
+        raster.save(self.file_path)

degurba-0.1/degurba/main.py

@@ -0,0 +1,193 @@
+import numpy as np
+from scipy import ndimage
+from .io import Raster
+from .utils import zonal_stats
+
+
+class DEGURBA:
+
+    grid_cells_l1_cla = {
+        'urban_centres': 1,
+        'urban_clusters': 2,
+        'rural_grid_cells': 3
+    }
+    local_units_l1_cla = {
+        'cities': 1,
+        'towns_semi_dense_areas': 2,
+        'rural_areas': 3
+    }
+    grid_cells_l2_cla = {
+        'urban_centre': 11,
+        'dense_urban_cluster': 21,
+        'semi_dense_urban_cluster': 22,
+        'suburban_peri_urban_grid_cells': 23,
+        'rural_cluster': 31,
+        'low_density_rural_grid_cells': 32,
+        'very_low_density_rural_grid_cells': 33
+    }
+    local_units_l2_cal = {
+        'city': 11,
+        'dense_town': 21,
+        'semi_dense_town': 22,
+        'suburban_peri_urban_area': 23,
+        'village': 31,
+        'dispersed_rural_area': 32,
+        'mostly_uninhabited_area': 33
+    }
+
+    def __init__(self, 
+                 pn=None,
+                 affine=None,
+                 crs=None,
+                 nodata=None,
+                 band=1) -> None:
+        if not isinstance(pn, type(None)):
+            self.pn = Raster(pn, affine=affine, crs=crs, nodata=nodata, band=band)
+
+    def _get_urban_centres(self, pn):
+        '''Identify the urban centres (high-density clusters), it is done in four steps.
+            Args:
+                pn (numpy array): population counts array.
+        '''
+        # First step, identify cells with at least 1500 inhabitants
+        urban_centres_mask = pn >= 1500
+        if isinstance(urban_centres_mask, np.ma.masked_array):
+            urban_centres_mask = urban_centres_mask.data
+        urban_centres_mask = urban_centres_mask.astype(np.byte)
+        # Second, identify groups of contiguous cells using the "four-point contiguity" method
+        s = np.array(
+            [
+                [0, 1, 0],
+                [1, 1, 1],
+                [0, 1, 0]
+            ]
+        )
+        label, num_features = ndimage.label(urban_centres_mask, structure=s)
+        # Third step, remove group whose total number of inhabitants less than 50000
+        for i in range(1, num_features+1):
+            mask = label == i
+            if np.sum(pn[mask]) < 50000:
+                urban_centres_mask[mask] = 0
+        # Fouth step, fill gaps and smooth borders by using iterative ‘majority rule’
+        w = np.array(
+            [
+                [1, 1, 1],
+                [1, 0, 1],
+                [1, 1, 1]
+            ]
+        )
+        for i in range(1, num_features+1):
+            mask = label == i
+            mask = mask.astype(np.byte)
+            while True:
+                mask = ndimage.convolve(
+                    mask, weights=w, mode='constant', cval=0)
+                mask = np.logical_and(mask >= 5, urban_centres_mask == 0)
+                if 0 == np.count_nonzero(mask):
+                    break
+                urban_centres_mask[mask] = 1
+        return urban_centres_mask.astype(np.bool_)
+
+    def _get_urban_clusters(self, pn, urban_centres_mask):
+        """Identify the urban clusters (moderate-density clusters), it is done in four steps.
+            Args:
+                pn (numpy array): population counts array.
+                urban_centres (numpy array): urban centres. 
+        """
+        # First step, identify cells with at least 300 inhabitants
+        urban_clusters_mask = pn >= 300
+        if isinstance(urban_clusters_mask, np.ma.masked_array):
+            urban_clusters_mask = urban_clusters_mask.data
+        urban_clusters_mask = urban_clusters_mask.astype(np.byte)
+        # Second, identify groups of contiguous cells using the "eight-point contiguity" method
+        s = np.array(
+            [
+                [1, 1, 1],
+                [1, 1, 1],
+                [1, 1, 1]
+            ]
+        )
+        label, num_features = ndimage.label(urban_clusters_mask, structure=s)
+        # Third step, remove group whose total number of inhabitants less than 5000
+        for i in range(1, num_features+1):
+            mask = label == i
+            if np.sum(pn[mask]) < 5000:
+                urban_clusters_mask[mask] = 0
+        # Fouth step, overlay the urban centres on urban clusters to identify final urban clusters
+        urban_clusters_mask = np.logical_and(urban_clusters_mask,
+                                             urban_centres_mask == 0)
+        urban_clusters_mask = urban_clusters_mask.astype(np.byte)
+        return urban_clusters_mask.astype(np.bool_)
+
+    def _get_rural_grid_cells(self, pn, urban_centres_mask, urban_clusters_mask):
+        """Identify the rural grid cells  (mostly low density cells) that are not identified as urban centres or as urban clusters.
+            Args:
+                pn (numpy array): population counts array.
+                urban_centres_mask (numpy array): urban centres.
+                urban_clusters_mask (numpy array): urban clusters. 
+        """
+        rural_grid_cells_mask = pn >= 0
+        if isinstance(rural_grid_cells_mask, np.ma.masked_array):
+            rural_grid_cells_mask = rural_grid_cells_mask.data
+        rural_grid_cells_mask = np.logical_and(rural_grid_cells_mask,
+                                               urban_centres_mask == False)
+        rural_grid_cells_mask = np.logical_and(rural_grid_cells_mask,
+                                               urban_clusters_mask == False)
+        rural_grid_cells_mask = rural_grid_cells_mask.astype(np.byte)
+        return rural_grid_cells_mask.astype(np.bool_)
+
+    def classify_grid_cells_l1(self):
+        pn_array = self.pn.array
+        urban_centres = self._get_urban_centres(pn_array)
+        urban_clusters = self._get_urban_clusters(
+            pn_array, urban_centres)
+        rural_grid_cells = self._get_rural_grid_cells(
+            pn_array, urban_centres, urban_clusters)
+        grid_cells_clas = [urban_centres,
+                           urban_clusters, rural_grid_cells]
+        grid_cells_l1 = np.zeros(
+            shape=urban_centres.shape, dtype=np.int8)
+        for grid_cells_cla, index in zip(grid_cells_clas,
+                                         self.grid_cells_l1_cla.values()):
+            grid_cells_l1[grid_cells_cla] = index
+        grid_cells_l1 = Raster(
+            grid_cells_l1, affine=self.pn.affine, crs=self.pn.crs, nodata=0)
+
+        return grid_cells_l1
+
+    def classify_local_units_l1(self, local_units, field=None, 
+                                grid_cells_l1=None, all_touched=False):
+        """
+        Parameters:
+        -----------
+        local_units: path to an vector source or io.Vector object or ndarray
+        grid_cells_l1: the result of classify_grid_cells_l1
+        """
+        if grid_cells_l1 == None:
+            grid_cells_l1 = self.classify_grid_cells_l1()
+
+        def classify(grid_cells):
+            total_count = grid_cells.count()
+            if not total_count:
+                return 0
+            urban_centres = self.grid_cells_l1_cla['urban_centres']
+            urban_centres_cells_r = np.count_nonzero(
+                grid_cells == urban_centres) / total_count
+
+            if urban_centres_cells_r >= 0.5:
+                return self.local_units_l1_cla['cities']
+
+            rural_grid_cells = self.grid_cells_l1_cla['rural_grid_cells']
+            rural_grid_cells_r = np.count_nonzero(
+                grid_cells == rural_grid_cells) / total_count
+
+            if urban_centres_cells_r < 0.5 and rural_grid_cells_r < 0.5:
+                return self.local_units_l1_cla['towns_semi_dense_areas']
+
+            if rural_grid_cells_r >= 0.5:
+                return self.local_units_l1_cla['rural_areas']
+
+        local_units = zonal_stats(
+            local_units, grid_cells_l1, field=field, 
+            zone_func=classify, all_touched=all_touched)
+        return local_units

degurba-0.1/degurba/utils.py

@@ -0,0 +1,102 @@
+import numpy as np
+import os
+from .io import Raster, Vector, geometry_window, overlap
+from .io import geometry_bounds
+
+
+def stat_func(array, stat):
+    """
+    Parameters
+    ----------
+    array: numpy masked array
+    """
+    stats = {'min': np.ma.min, 'max': np.ma.max,
+             'mean': np.ma.mean, 'sum': np.ma.sum,
+             'count': np.ma.count, 'std': np.ma.std,
+             'median': np.ma.median,
+             'range': lambda x: np.ma.max(x) - np.ma.min(x)}
+    return stats[stat](array)
+
+
+def zonal_stats(vector, 
+                raster,
+                field, 
+                affine=None,
+                crs=None,
+                nodata=None,
+                stat=None,
+                zone_func=None,
+                all_touched=False
+                ):
+    """
+    Parameters
+    ----------
+    vector: path to an vector source or io.Vector object or ndarray
+    raster: path to an raster source or io.Raster object
+    field: str, optional
+        field in the vector
+        defaults to None
+    affine: Affine instance
+        required only for ndarrays, otherwise it is read from src
+    crs: str, dict, or CRS; optional
+        Coordinate reference systems defines how a dataset’s pixels map to locations on, 
+        for example, a globe or the Earth.
+    nodata: int or float, optional
+    stat: str 
+        Which statistics to calculate for each zone. 
+        The optional parameters are min, max, mean, sum, count, std, median, range
+    zone_func: callable
+        function to apply to zone ndarray prior to computing stats
+    all_touched: bool, optional
+        Whether to include every raster cell touched by a geometry, or only
+        those having a center point within the polygon.
+        defaults to `False`
+    """
+    if stat and zone_func:
+        raise ValueError("Specify either stat or zone_func")
+
+    if isinstance(vector, str):
+        if not os.path.exists(vector):
+            raise ValueError("The vector {} is not exist.".format(vector))
+        else:
+            vector = Vector(vector)
+
+    if isinstance(raster, str):
+        if not os.path.exists(raster):
+            raise ValueError("The vector {} is not exist.".format(raster))
+        else:
+            raster = Raster(raster, affine=affine, crs=crs, nodata=nodata)
+
+    values = []
+    for geometry in vector['geometry']:
+        clip_raster = raster.read_from_geometry([geometry], all_touched=all_touched)
+        array = clip_raster.array
+        geometry_mask = ~array.mask
+        if not np.any(geometry_mask):
+            left, bottom, right, top = geometry_bounds(geometry)
+            center_x, center_y = (left + right) / 2, (bottom + top) / 2
+            center_row, center_col = raster.index(center_x, center_y)
+            value = raster.array[center_row, center_col]
+            values.append(int(value))
+            continue
+
+        if stat != None:
+            value = stat_func(array, stat)
+            values.append(int(value))
+            continue
+
+        # execute zone_func on masked zone ndarray
+        if zone_func is not None:
+            if not callable(zone_func):
+                raise TypeError(('zone_func must be a callable '
+                                 'which accepts function a '
+                                 'single `zone_array` arg.'))
+            value = zone_func(array)
+            values.append(int(value))
+            continue
+
+    if field != None:
+        vector.create_field(name=field, type='float', values=values)
+        return vector
+
+

degurba-0.1/degurba.egg-info/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.2
+Name: degurba
+Version: 0.1
+Summary: Urban Boundary Extraction Software Based on Degree of Urbanization
+Home-page: https://github.com/djw-easy/degurba
+Author: Your Name
+Author-email: djw@lreis.ac.cn
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: rasterio
+Requires-Dist: scipy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Urban Boundary Extraction Software Based on Degree of Urbanization
+
+## Project Introduction
+
+This project aims to provide a tool for urban boundary extraction based on the Degree of Urbanization (DEGURBA) algorithm. By integrating multi-source geospatial data, it offers a fast, flexible, and efficient method for extracting urban boundaries at specific times and locations, providing technical support and data for researchers.
+
+![example](./figs/bj_result.jpg)
+<center>
+(a) Gridded population of Beijing in 2020.
+(b) Grid cell level classification result by DEGURBA. 
+(c) Local unit classification result by DEGURBA.
+</center>
+
+## Features
+
+- **Multi-source Data Support**: Supports downloading WorldPOP and GPWV4 grid population data.
+- **Grid Cell Classification**: Classifies grid cells into urban centers, urban clusters, and rural grid units based on population density, continuity, and scale.
+- **Local Unit Classification**: Overlays the grid cell classification results onto local spatial units and further classifies them into urban areas, semi-dense areas, and rural areas.
+- **Flexible and Efficient**: Users can generate urban boundary data with different time, location, and classification accuracy requirements.
+
+## Installation
+
+### Install using QGIS
+
+#### 1. Install QGIS
+- Download and install QGIS, version 3.20 or higher.
+
+#### 2. Install rasterio
+- In the QGIS QSGeo4W Shell, run `pip install rasterio`.
+
+#### 3. Configure Plugin
+- Place the project code folder into the QGIS plugin directory.
+- Open QGIS, click on "Manage Plugins" and install the "DEGURBA" plugin.
+- Open the Processing Toolbar and select the appropriate tools for operation.
+
+### Install using Python
+
+You can install the package using pip:
+
+~~~
+pip install degurba
+~~~
+
+## Usages with QGIS
+
+1. **Download Population Data**:
+   - Use the "download worldpop grid data" or "download gpwv4 grid data" tool to select the desired dataset, country, year, and clipping area (optional).
+
+2. **Grid Cell Classification**:
+   - Use the "Grid Cell Classification" tool, input the population grid data, and output raster data.
+
+3. **Local Unit Classification**:
+   - Use the "Local Units Classification" tool, input the grid cell classification result data, and output local unit data (vector data).
+
+## Example
+
+Using Beijing's data for the year 2020 as an example:
+
+1. Download the WorldPOP population grid data for Beijing, setting the MASK layer to Beijing's vector boundary.
+
+![download window](./figs/download_1.png)
+
+![download result](./figs/download_2.png)
+
+2. Perform grid cell classification on the downloaded population grid data.
+
+![grid cell classification](./figs/grid_cell_classification_1.png)
+
+![grid cell classification result](./figs/grid_cell_classification_2.png)
+
+3. Overlay the classification results onto Beijing's local spatial units (such as districts) to complete the local unit classification.
+
+![local unit classification](./figs/local_unit_classification_1.png)
+
+![local unit classification result](./figs/local_unit_classification_2.png)
+
+## Notes
+
+- Ensure compatibility between QGIS version and the plugin.
+- When downloading data, pay attention to selecting the correct dataset and parameters.
+- When performing local unit classification, ensure that the input grid cell classification result data is complete and accurate.

degurba-0.1/degurba.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+degurba/__init__.py
+degurba/io.py
+degurba/load_data.py
+degurba/main.py
+degurba/utils.py
+degurba.egg-info/PKG-INFO
+degurba.egg-info/SOURCES.txt
+degurba.egg-info/dependency_links.txt
+degurba.egg-info/requires.txt
+degurba.egg-info/top_level.txt

degurba-0.1/degurba.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

degurba-0.1/degurba.egg-info/requires.txt

@@ -0,0 +1,2 @@
+rasterio
+scipy

degurba-0.1/degurba.egg-info/top_level.txt

@@ -0,0 +1 @@
+degurba

degurba-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

degurba-0.1/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='degurba',
+    version='0.1',
+    author='Your Name',
+    author_email='djw@lreis.ac.cn',
+    description='Urban Boundary Extraction Software Based on Degree of Urbanization',
+    long_description=open('README.md', 'r', encoding='utf-8').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/djw-easy/degurba',
+    packages=find_packages(),
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.7',
+    install_requires=[
+        'rasterio',
+        'scipy'
+    ],
+)