rastafari 0.2.3__tar.gz

rastafari-0.2.3/.pre-commit-config.yaml

@@ -0,0 +1,28 @@
+repos:
+  - repo: https://github.com/ambv/black
+    rev: "23.7.0"
+    hooks:
+      - id: black
+  - repo: https://github.com/pycqa/isort
+    rev: "5.12.0"
+    hooks:
+      - id: isort
+  - repo: https://github.com/pycqa/flake8
+    rev: "6.1.0"
+    hooks:
+      - id: flake8
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: "v4.4.0"
+    hooks:
+      - id: check-added-large-files
+        args: ["--enforce-all"]
+      - id: check-merge-conflict
+      - id: check-symlinks
+      - id: check-toml
+      - id: debug-statements
+      - id: end-of-file-fixer
+      - id: fix-encoding-pragma
+        args: [--remove]
+      - id: mixed-line-ending
+        args: [--fix, lf]
+      - id: trailing-whitespace

rastafari-0.2.3/CHANGES.md

@@ -0,0 +1,12 @@
+# Change log
+
+## 0.2.0
+
+- Add support for Python 3.11 (!1).
+- Drop support for Python 3.8 (!1).
+- Add type annotations (!2).
+
+
+## 0.1.0
+
+- Initial release.

rastafari-0.2.3/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2023 David Segersson
+
+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.

rastafari-0.2.3/MANIFEST.in

@@ -0,0 +1,5 @@
+include           CHANGES.md
+include           .pre-commit-config.yaml
+recursive-include src/rastafari *.pyx
+include           test-requirements.txt
+recursive-include tests *.py

rastafari-0.2.3/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.1
+Name: rastafari
+Version: 0.2.3
+Summary: Rasterize vector features to grids
+Home-page: https://gitlab.com/foclair/rastafari
+Author: David Segersson, Eef van Dongen
+Author-email: david.segersson@smhi.se
+License: "see LICENSE file"
+Project-URL: Bug Tracker, https://gitlab.com/foclair/rastafari/-/issues
+Keywords: rasterize,DDA,resample
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: test
+License-File: LICENSE
+
+# Rastafari
+
+Rasterize vector features. This library is built to rasterize emission sources in the CLAIR air quality modelling system. In contrast to most available libraries used to rasterize vector features, this library produces rasters with weights proportional to the fraction of each cell that is covered by a feature.
+
+
+### Features:
+
+* line rasterization using DDA algorithm, producing weights proportional to fraction of line intersected by each cell
+* polygon rasterization using even-odd rule, producing weights proportional to fraction of polygon included in each cell 
+* mass-consistent resampling of a raster using inverse nearest neighbour algorithm, allowing for different projections in source and target
+
+See rastafari/tests for examples.
+
+## Install
+
+Use pip to install Rastafari:
+
+```console
+python -m pip install rastafari
+```
+
+
+## Development
+
+To install Rastafari in a local venv for development, run:
+```console
+git clone https://gitlab.com/foclair/rastafari.git
+cd rastafari
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install -U pip
+python -m pip install cython wheel
+RASTAFARI_USE_CYTHON=1 python -m pip install --no-build-isolation -e .[test]
+```
+
+Rastafari uses [pre-commit][].  Install it and run `pre-commit
+install` to run its checks every time you commit.  Run the checks
+manually with
+
+```console
+pre-commit run -a
+```
+
+[pytest][] is used as a test runner:
+
+```console
+pytest
+```
+
+Rastafari comes fully typed.  Use [mypy][] to check the type annotations:
+
+```console
+mypy .
+```
+
+All these tools will be run in CI in case you forget.
+
+[mypy]: https://www.mypy-lang.org/
+[pre-commit]: https://pre-commit.com/
+[pytest]: https://pytest.org/
+[pip-tools]: https://github.com/jazzband/pip-tools/
+
+
+## Maintenance
+
+This package is maintained by [David Segersson][] at SMHI.
+
+[David Segersson]: mailto:david.segersson@smhi.se

rastafari-0.2.3/README.md

@@ -0,0 +1,68 @@
+# Rastafari
+
+Rasterize vector features. This library is built to rasterize emission sources in the CLAIR air quality modelling system. In contrast to most available libraries used to rasterize vector features, this library produces rasters with weights proportional to the fraction of each cell that is covered by a feature.
+
+
+### Features:
+
+* line rasterization using DDA algorithm, producing weights proportional to fraction of line intersected by each cell
+* polygon rasterization using even-odd rule, producing weights proportional to fraction of polygon included in each cell 
+* mass-consistent resampling of a raster using inverse nearest neighbour algorithm, allowing for different projections in source and target
+
+See rastafari/tests for examples.
+
+## Install
+
+Use pip to install Rastafari:
+
+```console
+python -m pip install rastafari
+```
+
+
+## Development
+
+To install Rastafari in a local venv for development, run:
+```console
+git clone https://gitlab.com/foclair/rastafari.git
+cd rastafari
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install -U pip
+python -m pip install cython wheel
+RASTAFARI_USE_CYTHON=1 python -m pip install --no-build-isolation -e .[test]
+```
+
+Rastafari uses [pre-commit][].  Install it and run `pre-commit
+install` to run its checks every time you commit.  Run the checks
+manually with
+
+```console
+pre-commit run -a
+```
+
+[pytest][] is used as a test runner:
+
+```console
+pytest
+```
+
+Rastafari comes fully typed.  Use [mypy][] to check the type annotations:
+
+```console
+mypy .
+```
+
+All these tools will be run in CI in case you forget.
+
+[mypy]: https://www.mypy-lang.org/
+[pre-commit]: https://pre-commit.com/
+[pytest]: https://pytest.org/
+[pip-tools]: https://github.com/jazzband/pip-tools/
+
+
+## Maintenance
+
+This package is maintained by [David Segersson][] at SMHI.
+
+[David Segersson]: mailto:david.segersson@smhi.se

rastafari-0.2.3/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0", "Cython", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.check-manifest]
+ignore = [
+  ".gitlab-ci.yml",
+  "src/rastafari/*.c",
+]
+
+[tool.coverage.run]
+source = ["rastafari"]
+branch = true
+
+[tool.mypy]
+strict = true
+exclude = ['^setup\.py$']
+
+[tool.pytest.ini_options]
+filterwarnings = ["error"]

rastafari-0.2.3/setup.cfg

@@ -0,0 +1,57 @@
+[metadata]
+name = rastafari
+version = attr: rastafari.__version__
+author = David Segersson, Eef van Dongen
+author_email = david.segersson@smhi.se
+description = Rasterize vector features to grids
+long_description = file: README.md
+long_description_content_type = text/markdown
+keywords = rasterize, DDA, resample
+classifiers = 
+	License :: OSI Approved :: MIT License
+	Programming Language :: Python :: 3
+license = "see LICENSE file"
+url = https://gitlab.com/foclair/rastafari
+project_urls = 
+	Bug Tracker = https://gitlab.com/foclair/rastafari/-/issues
+
+[options]
+package_dir = 
+	= src
+packages = find:
+python_requires = >=3.9
+zip_safe = False
+install_requires = 
+	numpy
+	pyproj
+
+[options.extras_require]
+test = 
+	mypy
+	pytest
+	pytest-cov
+
+[options.packages.find]
+where = src
+
+[options.package_data]
+rastafari = 
+	core.pyi
+	py.typed
+
+[flake8]
+exclude = 
+	.direnv,
+	.venv
+extend-ignore = E203
+max-line-length = 88
+
+[black]
+exclude = 
+	.direnv,
+	.venv
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

rastafari-0.2.3/setup.py

@@ -0,0 +1,17 @@
+"""Build and install Rastafari."""
+
+import os
+
+from setuptools import Extension, setup
+USE_CYTHON = os.environ.get("RASTAFARI_USE_CYTHON", False)
+print(f"USE_CYTHON: {USE_CYTHON}")
+ext = "pyx" if USE_CYTHON else "c"
+extensions = [
+    Extension("rastafari.core", [f"src/rastafari/core.{ext}"]),
+]
+if USE_CYTHON:
+    from Cython.Build import cythonize
+
+    extensions = cythonize(extensions, compiler_directives={"language_level": "3"})
+
+setup(ext_modules=extensions)

rastafari-0.2.3/src/rastafari/__init__.py

@@ -0,0 +1,137 @@
+"""Rasterize vector features to grids."""
+
+import math
+
+import numpy as np
+import numpy.typing as npt
+import pyproj
+
+from .core import ddaf_line_subpixel, even_odd_polygon_fill
+
+__all__ = [
+    "ddaf_line_subpixel",
+    "even_odd_polygon_fill",
+    "resample_band",
+]
+
+__version__ = "0.2.3"
+
+ExtentType = tuple[float, float, float, float]
+WeightsDict = dict[tuple[int, int], float]
+
+
+def resample_band(
+    source_grid: npt.NDArray[np.float_],
+    source_extent: ExtentType,
+    source_nodata: float,
+    target_extent: ExtentType,
+    target_nx: int,
+    target_ny: int,
+    source_srid: int,
+    target_srid: int,
+    subgridcells: int = 2,
+) -> tuple[tuple[npt.NDArray[np.intp], ...], npt.NDArray[np.float_]]:
+    """Resample raster using inverse nearest neighbour algorithm.
+
+    The original raster is refined and each pixel is sorted into the
+    target grid.
+
+    args:
+        source_grid: original raster as a numpy array ((X, Y))
+        source_extent: extent of the original raster
+        source_nodata: nodata value of source raster
+        target_extent: target extent coordinates as (x1, y1, x2, y2)
+        target_nx: number of cells in x-direction of target grid
+        target_ny: number of cells in y-direction of target grid
+        source_srid: srid of source raster as integer
+        target_srid: srid of target raster as integer
+    kwargs:
+        subgridcells: divide each cell side by this factor to
+          increase accuracy in resampling
+    """
+    # target extent
+    tx0, ty0, tx1, ty1 = target_extent
+
+    # source extent
+    sx0, sy0, sx1, sy1 = source_extent
+
+    sny = source_grid.shape[0]
+    snx = source_grid.shape[1]
+
+    # calculate grid cell-size
+    target_dy = (ty1 - ty0) / target_ny
+    target_dx = (tx1 - tx0) / target_nx
+
+    source_dy = (sy1 - sy0) / sny
+    source_dx = (sx1 - sx0) / snx
+
+    # refinement factor < 0 means sorting into a coarser target grid
+    refinement_factor = max(
+        source_dx * subgridcells / target_dx, source_dy * subgridcells / target_dy
+    )
+
+    target_grid = np.zeros((target_ny, target_nx), dtype=float)
+
+    # set nodata values to zero (if added by ST_Clip in emission query)
+    source_grid[source_grid == source_nodata] = 0
+    # upsample the source grid for improved accuracy
+    if refinement_factor > 1 and subgridcells > 1:
+        refinement_factor = math.ceil(refinement_factor)
+        # values are divided to maintain raster sum after upsampling
+        source_grid = (
+            (source_grid / (refinement_factor * refinement_factor))
+            .repeat(refinement_factor, axis=0)
+            .repeat(refinement_factor, axis=1)
+        )
+
+        # adjust cell size to upsampled grid
+        source_dx /= refinement_factor
+        source_dy /= refinement_factor
+
+    # get row and col indices of nonzero cells
+    source_rows, source_cols = np.nonzero(source_grid)
+
+    # get cell centre coordinates of non-zero cells
+    ccx = sx0 + (source_cols + 0.5) * source_dx
+    ccy = sy1 - (source_rows + 0.5) * source_dy
+    cell_centers = np.vstack((ccx, ccy)).T
+    if cell_centers.size == 0:
+        # all cells are zero in source grid
+        return ((), np.array([]))
+
+    # if target srid is different from source srid,
+    # transform cell centers to target srid
+    if source_srid != target_srid:
+        transformer = pyproj.Transformer.from_crs(
+            source_srid, target_srid, always_xy=True
+        )
+        transformer.transform(cell_centers[:, 0], cell_centers[:, 1], inplace=True)
+
+    # get indices within output bounds
+    target_cols = ((cell_centers[:, 0] - tx0) / target_dx).astype(int)
+    target_rows = target_ny - (np.ceil((cell_centers[:, 1] - ty0) / target_dy)).astype(
+        int
+    )
+    # handle edge case (row or col = ny or ny)
+    target_cols = np.clip(target_cols, 0, target_nx - 1, target_cols)
+    target_rows = np.clip(target_rows, 0, target_ny - 1, target_rows)
+
+    # create mask array for cells within target extent
+    cells_within_target_extent = (
+        (cell_centers[:, 0] >= tx0)
+        & (cell_centers[:, 0] < tx1)
+        & (cell_centers[:, 1] >= ty0)
+        & (cell_centers[:, 1] < ty1)
+    )
+    np.add.at(
+        target_grid,
+        (
+            target_rows[cells_within_target_extent],
+            target_cols[cells_within_target_extent],
+        ),
+        source_grid[
+            source_rows[cells_within_target_extent],
+            source_cols[cells_within_target_extent],
+        ],
+    )
+    return (target_grid.nonzero(), target_grid[target_grid > 0].ravel())