rio-diff 1.0.0a0__tar.gz → 1.0.dev1__tar.gz

rio_diff-1.0.dev1/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: rio-diff
+Version: 1.0.dev1
+Summary: Raster comparison plugin for rasterio
+Project-URL: Homepage, https://github.com/perminovsi/rio-diff
+Author-email: Sergey Perminov <perminovsi@ya.ru>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: raster,rasterio,rio-plugin
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.11
+Requires-Dist: click>=7.0
+Requires-Dist: numpy>=2.0
+Requires-Dist: rasterio>=1.3
+Description-Content-Type: text/markdown
+
+# rio-diff
+
+A rasterio plugin for comparing two raster files and showing differences between them.

rio_diff-1.0.dev1/README.md

@@ -0,0 +1,3 @@
+# rio-diff
+
+A rasterio plugin for comparing two raster files and showing differences between them.

{rio_diff-1.0.0a0 → rio_diff-1.0.dev1}/rio_diff/__init__.py

@@ -1,5 +1,5 @@
 """rio_diff: Raster comparison plugin for the Rasterio CLI."""
 
-__version__ = "1.0.0a0"
+__version__ = "1.0.dev1"
 
 from .compare import compare_rasters  # noqa

rio_diff-1.0.dev1/rio_diff/compare.py

@@ -0,0 +1,243 @@
+import hashlib
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+import rasterio
+from affine import Affine
+from rasterio.coords import BoundingBox
+from rasterio.crs import CRS
+
+
+@dataclass
+class RasterProps:
+    width: int
+    height: int
+    bands: int
+    dtype: str
+    nodata: float | None
+    bbox: BoundingBox
+    crs: CRS
+    transform: Affine
+    metadata: list[dict[str, Any]]
+    bands_metadata: list
+    stats: list
+
+
+def calc_hash(inp_file: str) -> str:
+    hash = hashlib.md5()
+
+    with open(inp_file, "rb") as file:
+        for chunk in iter(lambda: file.read(4096), b""):
+            hash.update(chunk)
+
+    return hash.hexdigest()
+
+
+def read_raster_props(inp_file: str) -> RasterProps:
+    with rasterio.open(inp_file) as ds:
+        return RasterProps(
+            width=ds.profile["width"],
+            height=ds.profile["height"],
+            bands=ds.profile["count"],
+            dtype=ds.profile["dtype"],
+            nodata=ds.profile["nodata"],  # TODO: проверка для разных каналов
+            bbox=ds.bounds,
+            crs=ds.profile["crs"],
+            transform=ds.profile["transform"],
+            metadata=ds.tags(),
+            bands_metadata=[ds.tags(bidx=bidx) for bidx in range(1, ds.count + 1)],
+            stats=ds.stats(),  # TODO: безопаснее будет считать самому по numpy
+        )
+
+
+def calc_diff(base_raster: str, test_raster: str, *, rtol=0, atol=0, equal_nan=True) -> bool:
+    """Вычитать первый растр из второго для получения diff-a и его последующего анализа
+    Сколько пикселей отличается, насколько они отличаются и т.п.
+    Опционально выводить график (картинку) и возможность сохранения diff-a на диск
+    """
+    with rasterio.open(base_raster) as base, rasterio.open(test_raster) as test:
+        if (
+            base.count != test.count or
+            base.shape != test.shape or
+            base.transform != test.transform or
+            base.crs != test.crs or
+            base.dtypes != test.dtypes
+        ):
+            return False
+
+        for bidx in range(1, base.count + 1):
+            nd_base= base.nodatavals[bidx - 1] if base.nodatavals else base.nodata
+            nd_test = test.nodatavals[bidx - 1] if test.nodatavals else test.nodata
+
+            for _, window in base.block_windows(bidx):
+                arr_base = base.read(bidx, window=window)
+                arr_test = test.read(bidx, window=window)
+
+                if nd_base is not None:
+                    mask_base = arr_base == nd_base
+                    arr_base = arr_base.astype("float64", copy=False)
+                    arr_base[mask_base] = np.nan
+                if nd_test is not None:
+                    mask_test = arr_test == nd_test
+                    arr_test = arr_test.astype("float64", copy=False)
+                    arr_test[mask_test] = np.nan
+
+                if not np.allclose(arr_base, arr_test, rtol=rtol, atol=atol, equal_nan=equal_nan):
+                    return False
+
+        return True
+
+
+def compare_rasters(
+    base_raster: str,
+    test_raster: str,
+    *,
+    ignore_height: bool = False,
+    ignore_width: bool = False,
+    ignore_bands: bool = False,
+    ignore_dtype: bool = False,
+    ignore_nodata: bool = False,
+    ignore_bbox: bool = False,
+    ignore_crs: bool = False,
+    ignore_transform: bool = False,
+    ignore_metadata: bool = False,
+    ignore_stats: bool = False,
+    ignore_pixel_values: bool = False,
+) -> bool:
+    is_equal = True
+    if calc_hash(base_raster) == calc_hash(test_raster):
+        return is_equal
+
+    base_props = read_raster_props(base_raster)
+    test_props = read_raster_props(test_raster)
+
+    if not ignore_height:
+        if base_props.height != test_props.height:
+            print(f"< height: {base_props.height}")
+            print("---")
+            print(f"> height: {test_props.height}")
+            print("")
+            is_equal = False
+
+    if not ignore_width:
+        if base_props.width != test_props.width:
+            print(f"< width: {base_props.width}")
+            print("---")
+            print(f"> width: {test_props.width}")
+            print("")
+            is_equal = False
+
+    if not ignore_bands:
+        if base_props.bands != test_props.bands:
+            print(f"< bands: {base_props.bands}")
+            print("---")
+            print(f"> bands: {test_props.bands}")
+            print("")
+            is_equal = False
+
+    if not ignore_dtype:
+        if base_props.dtype != test_props.dtype:
+            print(f"< dtype: {base_props.dtype}")
+            print("---")
+            print(f"> dtype: {test_props.dtype}")
+            print("")
+            is_equal = False
+
+    if not ignore_nodata:
+        if base_props.nodata != test_props.nodata:
+            print(f"< nodata: {base_props.nodata}")
+            print("---")
+            print(f"> nodata: {test_props.nodata}")
+            print("")
+            is_equal = False
+
+    if not ignore_bbox:
+        if base_props.bbox != test_props.bbox:
+            print(f"< bbox: {base_props.bbox}")
+            print("---")
+            print(f"> bbox: {test_props.bbox}")
+            print("")
+            is_equal = False
+
+    if not ignore_crs:
+        if base_props.crs != test_props.crs:
+            print(f"< crs: {base_props.crs}")
+            print("---")
+            print(f"> crs: {test_props.crs}")
+            print("")
+            is_equal = False
+
+    if not ignore_transform:
+        if base_props.transform != test_props.transform:
+            print(f"< geotransform: {base_props.transform}")
+            print("---")
+            print(f"> geotransform: {test_props.transform}")
+            print("")
+            is_equal = False
+
+    if not ignore_metadata:
+        # TODO: выводить конкретно в чем разница и для какого канала
+        if base_props.metadata != test_props.metadata:
+            print(f"< metadata: {base_props.metadata}")
+            print("---")
+            print(f"> metadata: {test_props.metadata}")
+            print("")
+            is_equal = False
+
+        if base_props.bands_metadata != test_props.bands_metadata:
+            print(f"< bands metadata: {base_props.bands_metadata}")
+            print("---")
+            print(f"> bands metadata: {test_props.bands_metadata}")
+            print("")
+            is_equal = False
+
+    if not ignore_stats:
+        if base_props.stats != test_props.stats:
+            # TODO: выводить детально в каких каналах и в чем различия
+            print(f"< statistics: {base_props.stats}")
+            print("---")
+            print(f"> statistics: {test_props.stats}")
+            print("")
+            is_equal = False
+
+    if not ignore_pixel_values:
+        if calc_diff(base_raster, test_raster) is False:
+            print("< pixel values: ...") # TODO: добавить подробный вывод в чем отличия у пикселей
+            print("---")
+            print("> pixel values: ...")
+            print("")
+            is_equal = False
+
+    return is_equal
+
+
+if __name__ == "__main__":
+    # rs = calc_hash("temp/2025110312/gfs.2025110312.003.cape_180-0.tif")
+
+    # rs = read_raster_props("temp/icon/OLD.icon.2026010200.003.t_2m.tif")
+
+    # rs = calc_diff(
+    #     "temp/icon/OLD.icon.2026010200.003.t_2m.tif",
+    #     # "temp/icon/NEW.icon.2026010200.003.t_2m.tif",
+    #     "temp/icon/OLD.icon.2026010200.003.td_2m.tif",
+    # )
+
+    rs = compare_rasters(
+        "temp/icon/OLD.icon.2026010200.003.t_2m.tif",
+        "temp/icon/NEW.icon.2026010200.003.t_2m.tif",
+        # "temp/icon/OLD.icon.2026010200.003.td_2m.tif",
+        ignore_height=False,
+        ignore_width=False,
+        ignore_bands=False,
+        ignore_dtype=False,
+        ignore_nodata=False,
+        ignore_bbox=False,
+        ignore_crs=False,
+        ignore_transform=False,
+        ignore_metadata=True,
+        ignore_stats=False,
+        ignore_pixel_values=False,
+    )
+
+    print(rs)

{rio_diff-1.0.0a0 → rio_diff-1.0.dev1}/rio_diff/scripts/cli.py

@@ -1,6 +1,6 @@
 import click
 
-from rio_diff import __version__ as plugin_version, render
+from rio_diff import __version__ as plugin_version
 from rio_diff.compare import compare_rasters
 
 
@@ -39,7 +39,7 @@ from rio_diff.compare import compare_rasters
     "--ignore-nodata",
     default=False,
     is_flag=True,
-    help="NoData values will be ignored.",
+    help="No data values will be ignored.",
     show_default=True,
 )
 @click.option(
@@ -78,28 +78,12 @@ from rio_diff.compare import compare_rasters
     show_default=True,
 )
 @click.option(
-    "--ignore-pixels",
-    "ignore_pixel_values",
+    "--ignore-pixel-values",
     default=False,
     is_flag=True,
     help="Pixel values will be ignored.",
     show_default=True,
 )
-@click.option(
-    "--checksum",
-    "check_checksum",
-    default=False,
-    is_flag=True,
-    help="Also compare the whole-file checksum (strict byte-level equality).",
-    show_default=True,
-)
-@click.option(
-    "--save-diff",
-    "save_diff",
-    type=click.Path(),
-    default=None,
-    help="Save the per-pixel difference raster (base - test) to the given path.",
-)
 @click.version_option(version=plugin_version, message="%(version)s")
 @click.pass_context
 def diff(
@@ -117,46 +101,21 @@ def diff(
     ignore_metadata,
     ignore_stats,
     ignore_pixel_values,
-    check_checksum,
-    save_diff,
 ):
     """Rasterio diff plugin.
     """
-    report = compare_rasters(
-        base_raster,
-        test_raster,
-        diff_raster_path=save_diff,
-        ignore_pixel_values=ignore_pixel_values,
+    compare_rasters(
+        base_raster=base_raster,
+        test_raster=test_raster,
+        ignore_height=ignore_height,
+        ignore_width=ignore_width,
+        ignore_bands=ignore_bands,
+        ignore_dtype=ignore_dtype,
+        ignore_nodata=ignore_nodata,
+        ignore_bbox=ignore_bbox,
+        ignore_crs=ignore_crs,
+        ignore_transform=ignore_transform,
+        ignore_metadata=ignore_metadata,
         ignore_stats=ignore_stats,
+        ignore_pixel_values=ignore_pixel_values,
     )
-
-    if report is None:
-        ctx.exit(0)
-
-    checks: list[tuple[str, bool, object, object]] = []
-
-    def add(ignore: bool, diff, label: str) -> None:
-        if not ignore:
-            checks.append((label, diff.equal, diff.base, diff.test))
-
-    add(not check_checksum, report.checksum, "Checksum")
-    add(ignore_width, report.width, "Width")
-    add(ignore_height, report.height, "Height")
-    add(ignore_bands, report.bands, "Bands")
-    add(ignore_dtype, report.dtype, "Data type")
-    add(ignore_nodata, report.nodata, "NoData")
-    add(ignore_bbox, report.bbox, "BBox")
-    add(ignore_crs, report.crs, "CRS")
-    add(ignore_transform, report.transform, "Transform")
-    add(ignore_metadata, report.metadata, "Metadata")
-    # TODO: выводить конкретно в чем разница и для какого канала
-    add(ignore_metadata, report.bands_metadata, "Bands metadata")
-    # TODO: выводить детально в каких каналах и в чем различия
-    add(ignore_stats, report.stats, "Statistics")
-
-    has_diff = render.print_report(
-        checks,
-        report.pixel_values,
-        show_pixel_values=not ignore_pixel_values,
-    )
-    ctx.exit(1 if has_diff else 0)

rio_diff-1.0.0a0/PKG-INFO

@@ -1,145 +0,0 @@
-Metadata-Version: 2.4
-Name: rio-diff
-Version: 1.0.0a0
-Summary: Raster comparison plugin for rasterio
-Project-URL: Homepage, https://github.com/perminovsi/rio-diff
-Author-email: Sergey Perminov <perminovsi@ya.ru>
-License-Expression: MIT
-License-File: LICENSE
-Keywords: raster,rasterio,rio-plugin
-Classifier: Intended Audience :: Information Technology
-Classifier: Intended Audience :: Science/Research
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Scientific/Engineering :: GIS
-Requires-Python: >=3.11
-Requires-Dist: click>=7.0
-Requires-Dist: numpy>=2.0
-Requires-Dist: rasterio>=1.3
-Description-Content-Type: text/markdown
-
-# rio-diff
-
-A rasterio plugin for comparing two raster files and showing differences between them.
-
-## Overview
-
-`rio-diff` is a command-line tool that extends the functionality of [Rasterio](https://github.com/rasterio/rasterio) by providing a way to compare two raster files and highlight their differences. Inspired by the classic Unix `diff` command, this plugin enables users to identify differences in raster properties and pixel values.
-
-## Features
-
-- Compare various raster properties including dimensions, data types, coordinate reference systems, and metadata
-- Calculate pixel-by-pixel differences between compatible rasters
-- Optionally save the per-pixel difference raster (`base - test`) to disk
-- Show statistics on differences including count, percentage, maximum difference, and RMSE
-- Support for ignoring specific properties during comparison
-- Integration with Rasterio's command-line interface
-
-## Installation
-
-Install the package using pip:
-
-```bash
-pip install rio-diff
-```
-
-After installation, the plugin will be available as a subcommand of `rio`.
-
-## Usage
-
-Basic usage to compare two raster files:
-
-```bash
-rio diff base_raster.tif test_raster.tif
-```
-
-### Options
-
-- `--ignore-height`: Ignore the height property during comparison
-- `--ignore-width`: Ignore the width property during comparison
-- `--ignore-bands`: Ignore the number of bands during comparison
-- `--ignore-dtype`: Ignore data type during comparison
-- `--ignore-nodata`: Ignore NoData values during comparison
-- `--ignore-bbox`: Ignore bounding box during comparison
-- `--ignore-crs`: Ignore coordinate reference system during comparison
-- `--ignore-transform`: Ignore affine transform during comparison
-- `--ignore-metadata`: Ignore metadata during comparison
-- `--ignore-stats`: Ignore statistics during comparison
-- `--ignore-pixels`: Ignore pixel values during comparison
-- `--checksum`: Also compare the whole-file checksum (strict byte-level equality; optional, off by default)
-- `--save-diff PATH`: Save the per-pixel difference raster (`base - test`) to the given path. When the rasters are byte-identical, the tool exits early and no diff raster is written.
-- `--version`: Show version information
-
-### Examples
-
-Compare two raster files with default settings:
-
-```bash
-rio diff raster1.tif raster2.tif
-```
-
-Ignore metadata differences when comparing:
-
-```bash
-rio diff raster1.tif raster2.tif --ignore-metadata
-```
-
-Compare rasters but ignore differences in pixel values:
-
-```bash
-rio diff raster1.tif raster2.tif --ignore-pixels
-```
-
-Require strict byte-level equality via the whole-file checksum:
-
-```bash
-rio diff raster1.tif raster2.tif --checksum
-```
-
-Save the per-pixel difference raster to disk:
-
-```bash
-rio diff raster1.tif raster2.tif --save-diff diff.tif
-```
-
-If the rasters are byte-identical, the tool exits early and the diff raster is not written.
-
-## Comparison Details
-
-The tool compares the following raster properties:
-
-- **Checksum**: MD5 hash of the file content (only when `--checksum` is passed).
-- **Dimensions**: Width and height in pixels
-- **Bands**: Number of channels/layers
-- **Data Type**: Bit depth and signed/unsigned nature
-- **NoData Value**: Value representing missing or invalid data
-- **Bounding Box**: Spatial extent in coordinate units
-- **CRS**: Coordinate Reference System
-- **Transform**: Affine transformation matrix
-- **Metadata**: Tags and attributes associated with the raster
-- **Statistics**: Basic statistical information about pixel values
-- **Pixel Values**: Actual pixel-by-pixel comparison (when rasters are compatible)
-
-For compatible rasters, the tool calculates detailed statistics about pixel differences including:
-- Count of different pixels
-- Percentage of different pixels
-- Maximum difference value
-- Root Mean Square Error (RMSE)
-
-## Exit Codes
-
-The command sets its exit code so it can be used in scripts and CI:
-
-- `0`: No differences were found across the compared properties (also returned early when the files are byte-identical).
-- `1`: At least one difference was found.
-- `2`: Usage error (invalid arguments or missing input files).
-
-Ignored properties (`--ignore-*`) do not affect the exit code. The whole-file checksum only affects it when `--checksum` is passed.
-
-## Inspiration
-
-- [Linux diff command](https://man7.org/linux/man-pages/man1/diff.1.html) - Classic Unix utility for comparing files
-- [ArcGIS Raster Compare](https://pro.arcgis.com/en/pro-app/latest/tool-reference/data-management/raster-compare.htm) - Tool for comparing raster datasets
-
-## License
-
-This project is licensed under the MIT License - see the LICENSE file for details.

rio_diff-1.0.0a0/README.md

@@ -1,126 +0,0 @@
-# rio-diff
-
-A rasterio plugin for comparing two raster files and showing differences between them.
-
-## Overview
-
-`rio-diff` is a command-line tool that extends the functionality of [Rasterio](https://github.com/rasterio/rasterio) by providing a way to compare two raster files and highlight their differences. Inspired by the classic Unix `diff` command, this plugin enables users to identify differences in raster properties and pixel values.
-
-## Features
-
-- Compare various raster properties including dimensions, data types, coordinate reference systems, and metadata
-- Calculate pixel-by-pixel differences between compatible rasters
-- Optionally save the per-pixel difference raster (`base - test`) to disk
-- Show statistics on differences including count, percentage, maximum difference, and RMSE
-- Support for ignoring specific properties during comparison
-- Integration with Rasterio's command-line interface
-
-## Installation
-
-Install the package using pip:
-
-```bash
-pip install rio-diff
-```
-
-After installation, the plugin will be available as a subcommand of `rio`.
-
-## Usage
-
-Basic usage to compare two raster files:
-
-```bash
-rio diff base_raster.tif test_raster.tif
-```
-
-### Options
-
-- `--ignore-height`: Ignore the height property during comparison
-- `--ignore-width`: Ignore the width property during comparison
-- `--ignore-bands`: Ignore the number of bands during comparison
-- `--ignore-dtype`: Ignore data type during comparison
-- `--ignore-nodata`: Ignore NoData values during comparison
-- `--ignore-bbox`: Ignore bounding box during comparison
-- `--ignore-crs`: Ignore coordinate reference system during comparison
-- `--ignore-transform`: Ignore affine transform during comparison
-- `--ignore-metadata`: Ignore metadata during comparison
-- `--ignore-stats`: Ignore statistics during comparison
-- `--ignore-pixels`: Ignore pixel values during comparison
-- `--checksum`: Also compare the whole-file checksum (strict byte-level equality; optional, off by default)
-- `--save-diff PATH`: Save the per-pixel difference raster (`base - test`) to the given path. When the rasters are byte-identical, the tool exits early and no diff raster is written.
-- `--version`: Show version information
-
-### Examples
-
-Compare two raster files with default settings:
-
-```bash
-rio diff raster1.tif raster2.tif
-```
-
-Ignore metadata differences when comparing:
-
-```bash
-rio diff raster1.tif raster2.tif --ignore-metadata
-```
-
-Compare rasters but ignore differences in pixel values:
-
-```bash
-rio diff raster1.tif raster2.tif --ignore-pixels
-```
-
-Require strict byte-level equality via the whole-file checksum:
-
-```bash
-rio diff raster1.tif raster2.tif --checksum
-```
-
-Save the per-pixel difference raster to disk:
-
-```bash
-rio diff raster1.tif raster2.tif --save-diff diff.tif
-```
-
-If the rasters are byte-identical, the tool exits early and the diff raster is not written.
-
-## Comparison Details
-
-The tool compares the following raster properties:
-
-- **Checksum**: MD5 hash of the file content (only when `--checksum` is passed).
-- **Dimensions**: Width and height in pixels
-- **Bands**: Number of channels/layers
-- **Data Type**: Bit depth and signed/unsigned nature
-- **NoData Value**: Value representing missing or invalid data
-- **Bounding Box**: Spatial extent in coordinate units
-- **CRS**: Coordinate Reference System
-- **Transform**: Affine transformation matrix
-- **Metadata**: Tags and attributes associated with the raster
-- **Statistics**: Basic statistical information about pixel values
-- **Pixel Values**: Actual pixel-by-pixel comparison (when rasters are compatible)
-
-For compatible rasters, the tool calculates detailed statistics about pixel differences including:
-- Count of different pixels
-- Percentage of different pixels
-- Maximum difference value
-- Root Mean Square Error (RMSE)
-
-## Exit Codes
-
-The command sets its exit code so it can be used in scripts and CI:
-
-- `0`: No differences were found across the compared properties (also returned early when the files are byte-identical).
-- `1`: At least one difference was found.
-- `2`: Usage error (invalid arguments or missing input files).
-
-Ignored properties (`--ignore-*`) do not affect the exit code. The whole-file checksum only affects it when `--checksum` is passed.
-
-## Inspiration
-
-- [Linux diff command](https://man7.org/linux/man-pages/man1/diff.1.html) - Classic Unix utility for comparing files
-- [ArcGIS Raster Compare](https://pro.arcgis.com/en/pro-app/latest/tool-reference/data-management/raster-compare.htm) - Tool for comparing raster datasets
-
-## License
-
-This project is licensed under the MIT License - see the LICENSE file for details.

rio_diff-1.0.0a0/rio_diff/compare.py

@@ -1,224 +0,0 @@
-import warnings
-from pathlib import Path
-
-import numpy as np
-import rasterio
-
-from rio_diff import models, utils
-
-# Ограничение блок-кэша GDAL. По умолчанию GDAL отводит под кэш ~5% ОЗУ, из-за
-# чего сквозной обход всех тайлов растра раздувает потребление памяти до
-# нескольких ГБ. Каждый тайл здесь читается ровно один раз, поэтому кэш
-# бесполезен и его можно держать маленьким.
-GDAL_CACHEMAX_BYTES = 256 * 1024 * 1024
-
-
-def read_raster_props(inp_file: str, *, read_stats: bool = True) -> models.RasterProps:
-    with rasterio.open(inp_file) as ds:
-        return models.RasterProps(
-            width=ds.profile["width"],
-            height=ds.profile["height"],
-            bands=ds.profile["count"],
-            dtype=ds.profile["dtype"],
-            nodata=ds.profile["nodata"],  # TODO: проверка для разных каналов
-            bbox=ds.bounds,
-            crs=ds.profile["crs"],
-            transform=ds.profile["transform"],
-            metadata=ds.tags(),
-            bands_metadata=[ds.tags(bidx=bidx) for bidx in range(1, ds.count + 1)],
-            stats=ds.stats() if read_stats else [],  # TODO: безопаснее будет считать самому по numpy
-        )
-
-
-def is_compatible_rasters(base_raster: str, test_raster: str) -> bool:
-    """Проверить, что растры можно сравнить попиксельно.
-
-    Для попиксельного diff-а массивы должны совпадать по форме, поэтому
-    проверяется только то, без чего вычитание невозможно:
-    - количество ячеек растра (столбцов и строк);
-    - количество каналов.
-
-    Различия в геопривязке (transform) и системе координат (crs) не мешают
-    вычитанию массивов и репортятся отдельно, поэтому здесь не учитываются.
-    """
-    with rasterio.open(base_raster) as base_ds, rasterio.open(test_raster) as test_ds:
-        return base_ds.shape == test_ds.shape and base_ds.count == test_ds.count
-
-
-def calc_diff(
-    base_raster: str,
-    test_raster: str,
-    *,
-    rtol=0,
-    atol=0,
-    equal_nan=True,
-    diff_raster_path: str | None = None,
-) -> list[models.PixelDiffStats]:
-    """Вычитать первый растр из второго для получения diff-a и его последующего анализа
-    Сколько пикселей отличается, насколько они отличаются и т.п.
-    Опционально выводить график (картинку) и возможность сохранения diff-a на диск
-    """
-    with rasterio.Env(GDAL_CACHEMAX=GDAL_CACHEMAX_BYTES), \
-            rasterio.open(base_raster) as base_ds, \
-            rasterio.open(test_raster) as test_ds:
-        count = base_ds.count
-        total_pixels = base_ds.width * base_ds.height
-
-        nd_base = base_ds.nodatavals
-        nd_test = test_ds.nodatavals
-
-        diff_count = np.zeros(count, dtype=np.int64)
-        valid_count = np.zeros(count, dtype=np.int64)
-        max_diff = np.zeros(count, dtype=np.float64)
-        sum_squared_diff = np.zeros(count, dtype=np.float64)
-
-        diff_ds = None
-        if diff_raster_path is not None:
-            diff_profile = base_ds.profile
-            diff_profile.update({
-                "dtype": "float32",
-                "nodata": float("nan"),
-                "compress": "deflate",
-                "predictor": 3,
-                "zlevel": 6,
-            })
-            Path(diff_raster_path).parent.mkdir(parents=True, exist_ok=True)
-            diff_ds = rasterio.open(diff_raster_path, "w", **diff_profile)
-
-        try:
-            # Обрабатываем растр окно за окном (по всем каналам сразу), чтобы не
-            # держать весь diff в памяти и читать каждый блок только один раз.
-            for _, window in base_ds.block_windows(1):
-                arr_base = base_ds.read(window=window).astype("float32")
-                arr_test = test_ds.read(window=window).astype("float32")
-
-                for b in range(count):
-                    if nd_base[b] is not None:
-                        arr_base[b][arr_base[b] == nd_base[b]] = np.nan
-                    if nd_test[b] is not None:
-                        arr_test[b][arr_test[b] == nd_test[b]] = np.nan
-
-                arr_diff = arr_base - arr_test
-                finite_mask = np.isfinite(arr_diff)
-                valid_count += np.count_nonzero(finite_mask, axis=(1, 2))
-
-                if diff_ds is not None:
-                    diff_ds.write(arr_diff, window=window)
-
-                close_mask = np.isclose(arr_base, arr_test, rtol=rtol, atol=atol, equal_nan=equal_nan)
-                diff_count += np.count_nonzero(~close_mask, axis=(1, 2))
-
-                abs_diff = np.abs(arr_diff)
-                with warnings.catch_warnings():
-                    warnings.simplefilter("ignore", RuntimeWarning)  # окно целиком из NaN
-                    band_max = np.nanmax(abs_diff, axis=(1, 2))
-                band_max = np.nan_to_num(band_max, nan=0.0)
-                max_diff = np.maximum(max_diff, band_max)
-
-                sum_squared_diff += np.nansum(arr_diff ** 2, axis=(1, 2))
-        finally:
-            if diff_ds is not None:
-                diff_ds.close()
-
-        return [
-            models.PixelDiffStats(
-                diff_count=int(diff_count[b]),
-                total_count=total_pixels,
-                diff_percent=float((diff_count[b] / total_pixels) * 100),
-                max_diff=float(max_diff[b]),
-                rmse=float(np.sqrt(sum_squared_diff[b] / valid_count[b])) if valid_count[b] else 0.0,
-            )
-            for b in range(count)
-        ]
-
-
-def compare_rasters(
-    base_raster: str,
-    test_raster: str,
-    *,
-    diff_raster_path: str | None = None,
-    ignore_pixel_values: bool = False,
-    ignore_stats: bool = False,
-) -> models.RasterDiff | None:
-    base_md5 = utils.calc_hash(base_raster)
-    test_md5 = utils.calc_hash(test_raster)
-
-    if base_md5 == test_md5:
-        return None
-
-    # Отключаем GDAL PAM, чтобы чтение статистики (ds.stats()) и запись растров
-    # не создавали сайдкар-файлы <растр>.aux.xml рядом с входными данными.
-    with rasterio.Env(GDAL_PAM_ENABLED="NO"):
-        base_props = read_raster_props(base_raster, read_stats=not ignore_stats)
-        test_props = read_raster_props(test_raster, read_stats=not ignore_stats)
-
-        pixel_values = None
-        need_pixel_diff = not ignore_pixel_values or diff_raster_path is not None
-        if need_pixel_diff and is_compatible_rasters(base_raster, test_raster):
-            pixel_values = calc_diff(
-                base_raster, test_raster, diff_raster_path=diff_raster_path
-            )
-
-    return models.RasterDiff(
-        checksum=models.DiffStr(
-            equal=base_md5 == test_md5,
-            base=base_md5,
-            test=test_md5,
-        ),
-        bands=models.DiffInt(
-            equal=base_props.bands == test_props.bands,
-            base=base_props.bands,
-            test=test_props.bands,
-        ),
-        width=models.DiffInt(
-            equal=base_props.width == test_props.width,
-            base=base_props.width,
-            test=test_props.width,
-        ),
-        height=models.DiffInt(
-            equal=base_props.height == test_props.height,
-            base=base_props.height,
-            test=test_props.height,
-        ),
-        dtype=models.DiffStr(
-            equal=base_props.dtype == test_props.dtype,
-            base=base_props.dtype,
-            test=test_props.dtype,
-        ),
-        nodata=models.DiffOptionalFloat(
-            equal=base_props.nodata == test_props.nodata,
-            base=base_props.nodata,
-            test=test_props.nodata,
-        ),
-        bbox=models.DiffBbox(
-            equal=base_props.bbox == test_props.bbox,
-            base=base_props.bbox,
-            test=test_props.bbox,
-        ),
-        crs=models.DiffCRS(
-            equal=base_props.crs == test_props.crs,
-            base=base_props.crs,
-            test=test_props.crs,
-        ),
-        transform=models.DiffTransform(
-            equal=base_props.transform == test_props.transform,
-            base=base_props.transform,
-            test=test_props.transform,
-        ),
-        metadata=models.DiffList(
-            equal=base_props.metadata == test_props.metadata,
-            base=base_props.metadata,
-            test=test_props.metadata,
-        ),
-        bands_metadata=models.DiffList(
-            equal=base_props.bands_metadata == test_props.bands_metadata,
-            base=base_props.bands_metadata,
-            test=test_props.bands_metadata,
-        ),
-        stats=models.DiffList(
-            equal=base_props.stats == test_props.stats,
-            base=base_props.stats,
-            test=test_props.stats,
-        ),
-        pixel_values=pixel_values,
-    )

rio_diff-1.0.0a0/rio_diff/models.py

@@ -1,96 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-from affine import Affine
-from rasterio.coords import BoundingBox
-from rasterio.crs import CRS
-
-
-@dataclass
-class RasterProps:
-    width: int
-    height: int
-    bands: int
-    dtype: str
-    nodata: float | None
-    bbox: BoundingBox
-    crs: CRS
-    transform: Affine
-    metadata: list[dict[str, Any]]
-    bands_metadata: list
-    stats: list
-
-
-@dataclass
-class DiffStr:
-    equal: bool
-    base: str
-    test: str
-
-
-@dataclass
-class DiffInt:
-    equal: bool
-    base: int
-    test: int
-
-
-@dataclass
-class DiffOptionalFloat:
-    equal: bool
-    base: float | None
-    test: float | None
-
-
-@dataclass
-class DiffList:
-    equal: bool
-    base: list
-    test: list
-
-
-@dataclass
-class DiffBbox:
-    equal: bool
-    base: BoundingBox
-    test: BoundingBox
-
-
-@dataclass
-class DiffCRS:
-    equal: bool
-    base: CRS
-    test: CRS
-
-
-@dataclass
-class DiffTransform:
-    equal: bool
-    base: Affine
-    test: Affine
-
-
-@dataclass
-class PixelDiffStats:
-    diff_count: int
-    total_count: int
-    diff_percent: float
-    max_diff: float
-    rmse: float
-
-
-@dataclass
-class RasterDiff:
-    checksum: DiffStr
-    bands: DiffInt
-    width: DiffInt
-    height: DiffInt
-    dtype: DiffStr
-    nodata: DiffOptionalFloat
-    bbox: DiffBbox
-    crs: DiffCRS
-    transform: DiffTransform
-    metadata: DiffList
-    bands_metadata: DiffList
-    stats: DiffList
-    pixel_values: list[PixelDiffStats] | None

rio_diff-1.0.0a0/rio_diff/render.py

@@ -1,129 +0,0 @@
-"""Вывод отчёта сравнения растров в консоль в стиле pytest-diff.
-
-Показываются только различия. Каждое поле выводится единым способом — как
-pytest показывает `assert base == test`: unified-diff по ``pprint``-представлению,
-где строки ``-`` относятся к base (красный), ``+`` — к test (зелёный), а
-неизменившиеся строки служат контекстом.
-"""
-
-import difflib
-import pprint
-
-import click
-from affine import Affine
-
-from rio_diff import models
-
-_STAT_ATTRS = ("min", "max", "mean", "std")
-_TRANSFORM_ATTRS = ("a", "b", "c", "d", "e", "f")
-
-
-def _has_attrs(value, attrs) -> bool:
-    return all(hasattr(value, attr) for attr in attrs)
-
-
-def _prepare(value):
-    """Разложить объекты по полям, чтобы ``pprint`` печатал их построчно.
-
-    Statistics/BBox/Transform и подобные объекты в repr-е выглядят одной
-    строкой, поэтому diff краснит их целиком. Превращаем их в dict по полям
-    (рекурсивно), тогда каждое поле оказывается на своей строке и в diff-е
-    подсвечивается только изменившееся. Ключи внешних dict сортируем, чтобы
-    base и test были выровнены.
-    """
-    if isinstance(value, dict):
-        return {key: _prepare(value[key]) for key in sorted(value, key=str)}
-    if isinstance(value, Affine):
-        return {name: getattr(value, name) for name in _TRANSFORM_ATTRS}
-    if _has_attrs(value, _STAT_ATTRS):
-        return {name: getattr(value, name) for name in _STAT_ATTRS}
-    if hasattr(value, "_fields"):  # namedtuple, напр. BoundingBox
-        return {name: _prepare(getattr(value, name)) for name in value._fields}
-    if isinstance(value, (list, tuple)):
-        return [_prepare(item) for item in value]
-    return value
-
-
-def _lines(value) -> list[str]:
-    """Разбить значение на строки для diff-а.
-
-    Контейнеры раскладываем через ``pprint`` с узкой шириной, чтобы элементы
-    ложились по одному на строку. Скаляры берём через ``str`` — так у объектов
-    с коротким представлением (например, CRS → ``EPSG:32637``) не всплывает
-    громоздкий repr.
-    """
-    prepared = _prepare(value)
-    if isinstance(prepared, (dict, list, tuple)):
-        text = pprint.pformat(prepared, width=1, sort_dicts=False)
-    else:
-        text = str(prepared)
-    return text.splitlines() or [text]
-
-
-def _print_value_diff(base, test) -> None:
-    for line in difflib.ndiff(_lines(base), _lines(test)):
-        tag = line[:2]
-        if tag == "? ":  # подсказки ndiff с ^~+ — пропускаем как шум
-            continue
-        if tag == "- ":
-            click.secho(f"  {line}", fg="red")
-        elif tag == "+ ":
-            click.secho(f"  {line}", fg="green")
-        else:  # "  " — общий контекст
-            click.echo(f"  {line}")
-
-
-def _print_mismatch(label: str, base, test) -> None:
-    click.secho(label, bold=True)
-    _print_value_diff(base, test)
-
-
-def print_report(
-    checks: list[tuple[str, bool, object, object]],
-    pixel_values: list[models.PixelDiffStats] | None,
-    show_pixel_values: bool,
-) -> bool:
-    """Вывести различия. Возвращает True, если найдено хотя бы одно."""
-    printed = 0
-
-    def separate() -> None:
-        nonlocal printed
-        if printed:
-            click.echo()
-        printed += 1
-
-    for label, equal, base, test in checks:
-        if not equal:
-            separate()
-            _print_mismatch(label, base, test)
-
-    if show_pixel_values:
-        if pixel_values is None:
-            separate()
-            click.secho(
-                "Pixel values not compared (incompatible shape or band count)",
-                fg="yellow",
-            )
-        else:
-            diffs = [
-                (bidx, stat)
-                for bidx, stat in enumerate(pixel_values, start=1)
-                if stat.diff_count > 0
-            ]
-            if diffs:
-                separate()
-                click.secho("Pixel values", bold=True)
-                rows = [
-                    {
-                        "band": bidx,
-                        "diff_count": stat.diff_count,
-                        "diff_percent": round(stat.diff_percent, 2),
-                        "max_diff": stat.max_diff,
-                        "rmse": stat.rmse,
-                    }
-                    for bidx, stat in diffs
-                ]
-                for line in _lines(rows):
-                    click.secho(f"  {line}", fg="red")
-
-    return printed > 0

rio_diff-1.0.0a0/rio_diff/utils.py

@@ -1,11 +0,0 @@
-import hashlib
-
-
-def calc_hash(inp_file: str) -> str:
-    hash = hashlib.md5()
-
-    with open(inp_file, "rb") as file:
-        for chunk in iter(lambda: file.read(4096), b""):
-            hash.update(chunk)
-
-    return hash.hexdigest()