gregor 0.0.1__py3-none-any.whl

gregor/__init__.py

@@ -0,0 +1 @@
+from . import aggregate, disaggregate, raster

gregor/aggregate.py

@@ -0,0 +1,127 @@
+from pathlib import Path
+
+import geopandas as gpd
+import rasterio as rio
+import xarray as xr
+from rasterstats import zonal_stats
+
+
+def aggregate_raster_to_polygon(
+    raster: str | Path | xr.DataArray,
+    polygons: gpd.GeoSeries | gpd.GeoDataFrame,
+    stats: str = "sum",
+) -> gpd.GeoDataFrame:
+    r"""
+    Aggregate raster data to polygons.
+
+    Parameters
+    ----------
+    raster : str | Path | xr.DataArray
+        Path to the raster file or xarray DataArray.
+    polygons : gpd.GeoSeries | gpd.GeoDataFrame
+        GeoSeries or GeoDataFrame with the spatial units.
+    stats : str, optional
+        Statistics to compute, by default "sum".
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        GeoDataFrame containing the original geometries
+        and the aggregated statistics.
+    """
+    if isinstance(raster, (str, Path)):
+        results_gdf = _aggregate_file_to_polygon(raster, polygons, stats)
+    elif isinstance(raster, xr.DataArray):
+        results_gdf = _aggregate_xarray_to_polygon(raster, polygons, stats)
+
+    return results_gdf
+
+
+def _aggregate_file_to_polygon(raster, polygons, stats, nodata=0):
+    with rio.open(raster) as src:
+        affine = src.transform
+        array = src.read(1)
+
+        polygons_projected = polygons.to_crs(src.crs)
+
+        zs = zonal_stats(
+            polygons_projected,
+            array,
+            affine=affine,
+            stats=stats,
+            nodata=nodata,
+            geojson_out=True,
+        )
+
+        results_gdf = gpd.GeoDataFrame.from_features(zs)
+
+        results_gdf = results_gdf.set_crs(src.crs)
+        results_gdf = results_gdf.to_crs(crs=polygons.crs)
+
+    return results_gdf
+
+
+def _aggregate_xarray_to_polygon(raster, polygons, stats, nodata=0):
+    # Project the polygons to the raster coordinate reference system
+    polygons_projected = polygons.to_crs(raster.rio.crs)
+
+    agg_raster_poly = zonal_stats(
+        polygons_projected,
+        raster.values,
+        affine=raster.rio.transform(),
+        stats=stats,
+        nodata=nodata,
+    )
+
+    results_gdf = gpd.GeoDataFrame(
+        agg_raster_poly,
+        index=polygons_projected.index,
+        crs=polygons_projected.crs,
+        geometry=polygons_projected.geometry,
+    )
+
+    results_gdf.index.name = polygons_projected.index.name
+
+    # Project back to the original crs
+    results_gdf = results_gdf.to_crs(crs=polygons.crs)
+
+    return results_gdf
+
+
+def aggregate_point_to_polygon(
+    points: gpd.GeoDataFrame, polygons: gpd.GeoSeries | gpd.GeoDataFrame, aggfunc="sum"
+):
+    r"""
+    Aggregate point data to polygons.
+
+    Parameters
+    ----------
+    points : gpd.GeoDataFrame
+        GeoDataFrame containing data defined on point geometries.
+    polygons : gpd.GeoSeries | gpd.GeoDataFrame
+        GeoSeries or GeoDataFrame of polygon geometries.
+    aggfunc : str, optional
+        Aggregation function, by default "sum".
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        GeoDataFrame containing the original geometries
+        and the aggregated statistics.
+    """
+    if isinstance(polygons, gpd.GeoSeries):
+        _polygons = polygons.to_frame()
+    elif isinstance(polygons, gpd.GeoDataFrame):
+        _polygons = polygons
+    else:
+        raise ValueError("`polygons` should be either a GeoSeries or a GeoDataFrame.")
+
+    joined_data = gpd.sjoin(points, _polygons, how="inner", op="within").drop(
+        columns="geometry"
+    )
+
+    aggregated_data = joined_data.groupby("index_right").agg(aggfunc)
+
+    result = _polygons.join(aggregated_data)
+
+    return result

gregor/cli.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+
+import click
+import geopandas as gpd
+import rioxarray as rxr
+
+import gregor
+
+
+@click.command(help="Aggregate raster data to polygon boundaries.")
+@click.argument("raster", type=click.STRING)
+@click.argument("polygons", type=click.STRING)
+@click.argument("destination", type=click.STRING)
+@click.argument("stats", type=click.STRING, default="sum")
+def agg(raster, polygons, destination, stats):
+    if Path(destination).exists():
+        raise ValueError("Destination file already exists.")
+
+    _raster = rxr.open_rasterio(raster).squeeze()
+    _polygons = gpd.read_file(polygons)
+
+    aggregated = gregor.aggregate.aggregate_raster_to_polygon(_raster, _polygons, stats)
+    aggregated.to_file(destination)
+
+
+@click.command(help="Disaggregate polygon data to raster data using proxy.")
+@click.argument("data", type=click.STRING)
+@click.argument("column", type=click.STRING)
+@click.argument("proxy", type=click.STRING)
+@click.argument("destination", type=click.STRING)
+@click.option("--to-data-crs", default=False, type=click.BOOL)
+def disagg(data, column, proxy, destination, to_data_crs):
+    if Path(destination).exists():
+        raise ValueError("Destination file already exists.")
+
+    _data = gpd.read_file(data)
+    _proxy = rxr.open_rasterio(proxy)
+
+    # Clip proxy to extent of data for better performance
+    minx, miny, maxx, maxy = _data.to_crs(_proxy.rio.crs).total_bounds
+    _proxy = gregor.raster.clip(_proxy, minx, miny, maxx, maxy).squeeze()
+
+    disaggregated = gregor.disaggregate.disaggregate_polygon_to_raster(
+        _data, column, _proxy, to_data_crs
+    )
+    disaggregated.rio.to_raster(destination)
+
+
+@click.group()
+def cli():
+    pass
+
+
+cli.add_command(agg)
+cli.add_command(disagg)

gregor/disaggregate.py

@@ -0,0 +1,146 @@
+import geopandas as gpd
+import numpy as np
+import xarray as xr
+from rasterio.features import geometry_mask
+
+
+def disaggregate_polygon_to_raster(
+    data: gpd.GeoDataFrame,
+    column: str,
+    proxy: xr.Dataset,
+    to_data_crs: bool = False,
+) -> xr.Dataset:
+    r"""
+    Disaggregate polygon data to raster data using proxy.
+    Normalization of the proxy happens internally.
+
+    Parameters
+    ----------
+    data : gpd.GeoDataFrame
+        Data to be disaggregated.
+    column : str
+        Column name of the data to be disaggregated.
+    proxy : xr.Dataset
+        Proxy data for disaggregation.
+    to_data_crs : bool, optional
+        Whether to reproject proxy to `data`'s CRS or keep it in `raster`'s CRS. Default is False.
+
+    Returns
+    -------
+    xr.Dataset
+        Disaggregated raster data.
+    """
+    _data = data.copy()
+    index_name = _data.index.name
+    if index_name is None:
+        index_name = "id"
+        _data.index.name = index_name
+
+    if not proxy.rio.crs == data.crs:
+        print(
+            f"CRS of `proxy` ({proxy.rio.crs}) does not match CRS of `data` ({data.crs}). Reprojecting CRS of `data` to `proxy`'s CRS."
+        )
+        _data = _data.to_crs(proxy.rio.crs)
+
+    # Each raster point belongs to one spatial_unit
+    belongs_to = get_belongs_to_matrix(proxy, _data.geometry)
+    _data = _data[[column]].to_xarray()
+    normalization = proxy.groupby(belongs_to).sum().rename(group=index_name)
+
+    # # Remove regions that do not belong to any geometry
+    _data = _data.sel({index_name: normalization.coords[index_name]})
+
+    # Disaggregate data to raster using proxy
+    # raster_{x,y} = 1/normalization_{id} * _data_{id} * belongs_to_{id,x,y} * proxy_{x,y}
+    raster = xr.DataArray(data=0, dims=["y", "x"], coords={"y": proxy.y, "x": proxy.x})
+    for id in normalization.coords[index_name]:
+        raster_id = (
+            1
+            / normalization.sel({index_name: id})
+            * _data.sel({index_name: id})
+            * (belongs_to == id)
+            * proxy
+        )
+        raster = raster + raster_id
+
+    if to_data_crs:
+        print(f"Reprojecting results to `data`'s CRS {data.crs}.")
+        raster = raster.rio.reproject(data.crs)
+
+    return raster
+
+
+def get_uniform_proxy(
+    polygons: gpd.GeoSeries, raster_resolution: tuple[int, int]
+) -> xr.Dataset:
+    r"""
+    Get a uniform proxy which sums to one for each region.
+
+    Parameters
+    ----------
+    polygons : gpd.GeoSeries
+        Polygons to compute the proxy for.
+    raster_resolution : tuple[int, int]
+        Resolution of the desired raster proxy.
+
+    Returns
+    -------
+    xr.Dataset
+        Uniform proxy which sums to 1 in each region.
+    """
+    # get spatial extent of spatial_units
+    x_min, y_min, x_max, y_max = polygons.total_bounds
+
+    # define coords
+    x_coords = np.linspace(x_min, x_max, raster_resolution[0])
+    y_coords = np.linspace(y_min, y_max, raster_resolution[1])
+
+    # create raster Dataset
+    uniform_proxy = xr.Dataset(
+        data_vars={}, coords={"x": ("x", x_coords), "y": ("y", y_coords)}
+    )
+
+    # TODO Set transform and crs
+    # uniform_proxy = uniform_proxy.rio.set_spatial_dims('x', 'y')
+    # uniform_proxy = uniform_proxy.rio.write_transform()
+    uniform_proxy = uniform_proxy.rio.set_crs(polygons.crs)
+
+    return uniform_proxy
+
+
+def get_belongs_to_matrix(raster: xr.Dataset, polygons: gpd.GeoSeries) -> xr.Dataset:
+    r"""
+    Get a matrix which indicates which polygon each raster point belongs to.
+
+    Parameters
+    ----------
+    raster : xr.Dataset
+        Raster data to get the matrix for.
+    polygons : gpd.GeoSeries
+        Polygons to compute the matrix for.
+
+    Returns
+    -------
+    xr.Dataset
+        Matrix which indicates which polygon each raster point belongs to.
+    """
+    assert len(raster.dims) == 2, "Raster data should have 2 dimensions."
+    # create an empty dataarray with the coords matching raster and spatial_units
+    belongs_to_matrix = xr.DataArray(
+        data=None, dims=["y", "x"], coords={"y": raster.y, "x": raster.x}
+    )
+    belongs_to_matrix.attrs["transform"] = raster.rio.transform
+    belongs_to_matrix.attrs["crs"] = raster.rio.crs
+
+    for id, geometry in polygons.items():
+        mask = geometry_mask(
+            [geometry],
+            out_shape=raster.shape,
+            transform=raster.rio.transform(),
+            invert=True,
+        )
+        mask = xr.DataArray(mask, coords=raster.coords, dims=raster.dims)
+        # assert belongs_to_matrix.where(mask).isnull().all(), "Trying to assign to value which is not None. Maybe cause of overlapping geometries."
+        belongs_to_matrix = belongs_to_matrix.where(~mask, id)
+
+    return belongs_to_matrix

gregor/raster.py

@@ -0,0 +1,74 @@
+from pathlib import Path
+
+import geopandas as gpd
+import rasterio as rio
+import xarray as xr
+from shapely.geometry import box
+
+
+# TODO read the docs first
+# https://corteva.github.io/rioxarray/html/examples/clip_geom.html#Clipping-larger-rasters
+# can use from_disk=True
+
+
+def clip(raster: str | Path | xr.DataArray, minx, miny, maxx, maxy, destination=None):
+    r"""
+    Clip raster to bounding box.
+
+    Parameters
+    ----------
+    raster : str | Path | xr.DataArray
+        Path to the raster file or xarray DataArray.
+    minx : float
+        Minimum x-coordinate of the bounding box.
+    miny : float
+        Minimum y-coordinate of the bounding box.
+    maxx : float
+        Maximum x-coordinate of the bounding box.
+    maxy : float
+        Maximum y-coordinate of the bounding box.
+    destination : str | Path, optional
+        Path to save the clipped raster, by default None.
+
+    Returns
+    -------
+    xr.DataArray
+        Clipped raster.
+    """
+    if isinstance(raster, xr.DataArray):
+        return _clip_xarray(raster, minx, miny, maxx, maxy)
+    if isinstance(raster, str) or isinstance(raster, Path):
+        if destination is None:
+            raise ValueError("Destination must be provided when clipping a file.")
+        _clip_file(raster, minx, miny, maxx, maxy, destination)
+
+
+def _clip_xarray(raster, minx, miny, maxx, maxy):
+    return raster.rio.clip_box(minx=minx, miny=miny, maxx=maxx, maxy=maxy)
+
+
+def _clip_file(raster, minx, miny, maxx, maxy, destination):
+    bbox = box(minx, miny, maxx, maxy)
+    bbox = gpd.GeoDataFrame({"geometry": bbox}, index=[0], crs="EPSG:4326")
+
+    with rio.open(raster) as src:
+        # Reproject the bounding box to the raster's CRS
+        bbox = bbox.to_crs(src.crs)
+
+        # Clip raster
+        out_raster, out_transform = rio.mask.mask(src, bbox.geometry, crop=True)
+
+        # Update metadata
+        out_meta = src.meta.copy()
+        out_meta.update(
+            {
+                "driver": "GTiff",
+                "height": out_raster.shape[1],
+                "width": out_raster.shape[2],
+                "transform": out_transform,
+            }
+        )
+
+        # Save the clipped raster to a new file
+        with rio.open(destination, "w", **out_meta) as dest:
+            dest.write(out_raster)

gregor-0.0.1.dist-info/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright 2024 Jann Launer
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

gregor-0.0.1.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.1
+Name: gregor
+Version: 0.0.1
+Summary: A library for spatial aggregation and disaggregation
+Author-email: Jann Launer <j.a.c.launer@tudelft.nl>
+Project-URL: changelog, https://github.com/jnnr/gregor/blob/main/CHANGELOG.md
+Project-URL: homepage, https://gregor.readthedocs.io/en/latest/
+Project-URL: repository, https://github.com/jnnr/gregor.git
+Keywords: gis
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: <4,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: pandas >=1.2
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: geopandas
+Requires-Dist: xarray
+Requires-Dist: rasterio
+Requires-Dist: rioxarray
+Requires-Dist: rasterstats
+Requires-Dist: click
+
+# Gregor: Aggregation and disaggregation of spatial data
+
+Gregor is a tool that makes your life easier when aggregating and dis-aggregating spatial data. It has been developed in the context of preparing data for energy system modeling, but can be applied in any situation involving spatial data.
+
+## Installation
+
+Install the latest release from pypi using conda.
+
+    conda install gregor
+
+Or, using pip.
+
+    pip install gregor
+
+Alternatively, install an editable local version in an environment by cloning the repository and running:
+
+    pip install -e <path-to-repo>
+
+## Usage
+
+Please have a look at the examples presented in the [documentation](https://gregor.readthedocs.io/en/latest/). 
+
+## Development
+
+If you encounter a bug, consider opening an issue on [GitHub](https://github.com/jnnr/gregor/issues).

gregor-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+gregor/__init__.py,sha256=wdAMuMvxGyJ5zqOJ0wxGfqYslw54F0UMzGXwWkHYqiE,46
+gregor/aggregate.py,sha256=1yPDt5EUJhpRXkvSBDoIqUKT61gv1Pajs3KsZldbHsA,3542
+gregor/cli.py,sha256=HV1XE_zdt-DQ_bwOU0kX_0TkXM-vSUX3sdIDvJGlDWw,1738
+gregor/disaggregate.py,sha256=gh0Znm3FfbNVlBKFaTrt4XIo1br86o8bUES5MJoMrxQ,4714
+gregor/raster.py,sha256=UamcoJpjTUXt3mhVYEkPelssqtRO8OzyYJNm6_5uvS0,2283
+gregor-0.0.1.dist-info/LICENSE.txt,sha256=DiSkTik3mrx7H70-KVdfpcQA99Z1B020afGwIVqQrqk,1082
+gregor-0.0.1.dist-info/METADATA,sha256=kIBjXqz1uSGkg6MhL40hZA_EjV__Ynum94D5rzxqGd4,1709
+gregor-0.0.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+gregor-0.0.1.dist-info/entry_points.txt,sha256=xcbxY9eHnsM1tk0V70JOMfeEHF9RBBl-zb3BAmRZENE,42
+gregor-0.0.1.dist-info/top_level.txt,sha256=SABPp7uleCLafjHIZ7ap6XlYNzsK5gIpG12BsNX8RnM,7
+gregor-0.0.1.dist-info/RECORD,,

gregor-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gregor-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gregor = gregor.cli:cli

gregor-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+gregor