rio-diff 1.0.0a0__py3-none-any.whl

rio_diff/__init__.py

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

rio_diff/compare.py

@@ -0,0 +1,224 @@
+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/models.py

@@ -0,0 +1,96 @@
+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/render.py

@@ -0,0 +1,129 @@
+"""Вывод отчёта сравнения растров в консоль в стиле 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/scripts/cli.py

@@ -0,0 +1,162 @@
+import click
+
+from rio_diff import __version__ as plugin_version, render
+from rio_diff.compare import compare_rasters
+
+
+@click.command("diff", short_help="Compare rasters")
+@click.argument("base_raster", type=click.Path(exists=True))
+@click.argument("test_raster", type=click.Path(exists=True))
+@click.option(
+    "--ignore-height",
+    default=False,
+    is_flag=True,
+    help="The number of height will be ignored.",
+    show_default=True,
+)
+@click.option(
+    "--ignore-width",
+    default=False,
+    is_flag=True,
+    help="The number of width will be ignored.",
+    show_default=True,
+)
+@click.option(
+    "--ignore-bands",
+    default=False,
+    is_flag=True,
+    help="The number of bands will be ignored.",
+    show_default=True,
+)
+@click.option(
+    "--ignore-dtype",
+    default=False,
+    is_flag=True,
+    help="Data type will be ignored.",
+    show_default=True,
+)
+@click.option(
+    "--ignore-nodata",
+    default=False,
+    is_flag=True,
+    help="NoData values will be ignored.",
+    show_default=True,
+)
+@click.option(
+    "--ignore-bbox",
+    default=False,
+    is_flag=True,
+    help="Bounding box will be ignored.",
+    show_default=True,
+)
+@click.option(
+    "--ignore-crs",
+    default=False,
+    is_flag=True,
+    help="Coordinate reference system will be ignored.",
+    show_default=True,
+)
+@click.option(
+    "--ignore-transform",
+    default=False,
+    is_flag=True,
+    help="Affine transform will be ignored.",
+    show_default=True,
+)
+@click.option(
+    "--ignore-metadata",
+    default=False,
+    is_flag=True,
+    help="Metadata will be ignored.",
+    show_default=True,
+)
+@click.option(
+    "--ignore-stats",
+    default=False,
+    is_flag=True,
+    help="Statistics will be ignored.",
+    show_default=True,
+)
+@click.option(
+    "--ignore-pixels",
+    "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(
+    ctx,
+    base_raster,
+    test_raster,
+    ignore_height,
+    ignore_width,
+    ignore_bands,
+    ignore_dtype,
+    ignore_nodata,
+    ignore_bbox,
+    ignore_crs,
+    ignore_transform,
+    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,
+        ignore_stats=ignore_stats,
+    )
+
+    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/utils.py

@@ -0,0 +1,11 @@
+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()

rio_diff-1.0.0a0.dist-info/METADATA

@@ -0,0 +1,145 @@
+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.dist-info/RECORD

@@ -0,0 +1,12 @@
+rio_diff/__init__.py,sha256=zZ75XSqurg7ftuoAjQmYmvUJbxMmpzn8N-_gurMDjg8,134
+rio_diff/compare.py,sha256=xyF46dCdUZV_MEu7XYs0b4wp8TtByk3sZFKyCrCErgg,9454
+rio_diff/models.py,sha256=4aVucjlq4vGd6AiZv7m8R3UxZb0lZRlAveRd4kYYDyY,1447
+rio_diff/render.py,sha256=-X0Ew7LqKaopxQdZgQ3uqIsWulrZVwLhxfqsBJGVFSA,5051
+rio_diff/utils.py,sha256=_VRlUMV9MiWYbuDYf6xTa9Yp2pOEFDqygMQ07y2-isU,236
+rio_diff/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rio_diff/scripts/cli.py,sha256=g8Rk_RQe39MvZSA4n6lvFjR4Xo2rWyMToZoIEDvUiho,4147
+rio_diff-1.0.0a0.dist-info/METADATA,sha256=kCJGwTFda-X9wHpg75vCiPxddXSsHfWvp4wvICqkLSQ,5273
+rio_diff-1.0.0a0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+rio_diff-1.0.0a0.dist-info/entry_points.txt,sha256=pu2fRwCS3z9zldLWmz0SSP_ImAMSKqDVmCF8LjHMJfA,56
+rio_diff-1.0.0a0.dist-info/licenses/LICENSE,sha256=4AoS2X3NFixtLlftb0GTuVAe_NzCCTZq5NaLSP8cQb8,1082
+rio_diff-1.0.0a0.dist-info/RECORD,,

rio_diff-1.0.0a0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

rio_diff-1.0.0a0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[rasterio.rio_plugins]
+diff = rio_diff.scripts.cli:diff

rio_diff-1.0.0a0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Sergey Perminov
+
+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.