pixel-patrol-image 0.1.0__tar.gz

pixel_patrol_image-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: pixel-patrol-image
+Version: 0.1.0
+Summary: Image prevalidation tool
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pixel-patrol-base>=0.1.0
+Requires-Dist: opencv-python-headless>=4.8

pixel_patrol_image-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "pixel-patrol-image"
+version = "0.1.0"
+description = "Image prevalidation tool"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pixel-patrol-base>=0.1.0",
+    # "opencv-python>=4.11.0.88",
+    "opencv-python-headless>=4.8",
+]
+
+[tool.uv]
+package = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pixel_patrol_image"]
+
+[project.entry-points."pixel_patrol.processor_plugins"]
+pixel_patrol_image_processing_builtins = "pixel_patrol_image.plugin_registry:register_processor_plugins"
+
+[project.entry-points."pixel_patrol.widget_plugins"]
+pixel_patrol_image_widget_builtins = "pixel_patrol_image.plugin_registry:register_widget_plugins"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+    "pytest-mock>=3.14.1",
+]
+
+[tool.uv.sources]
+pixel-patrol-base = { path = "../pixel-patrol-base" }

pixel_patrol_image-0.1.0/setup.cfg

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

pixel_patrol_image-0.1.0/src/pixel_patrol_image/plugin_registry.py

@@ -0,0 +1,14 @@
+from pixel_patrol_image.plugins.processors.quality_metrics_processor import QualityMetricsProcessor
+from pixel_patrol_image.plugins.widgets.image_quality import ImageQualityWidget
+from pixel_patrol_image.plugins.widgets.dynamic_quality_metrics import DynamicQualityMetricsWidget
+
+def register_processor_plugins():
+    return [
+        QualityMetricsProcessor,
+    ]
+
+def register_widget_plugins():
+    return [
+        ImageQualityWidget,
+        DynamicQualityMetricsWidget,
+    ]

pixel_patrol_image-0.1.0/src/pixel_patrol_image/plugins/processors/quality_metrics_processor.py

@@ -0,0 +1,136 @@
+import logging
+from typing import Dict, Callable, Any, Optional, List, Tuple
+
+import cv2
+import dask.array as da
+import numpy as np
+
+from pixel_patrol_base.utils.array_utils import calculate_sliced_stats
+from pixel_patrol_base.core.record import Record
+from pixel_patrol_base.core.specs import RecordSpec
+
+logger = logging.getLogger(__name__)
+
+
+def _column_fn_registry() -> Dict[str, Dict[str, Callable]]:
+    return {
+        "laplacian_variance": {"fn": _variance_of_laplacian_2d, "agg": da.mean},
+        "tenengrad": {"fn": _tenengrad_2d, "agg": da.mean},
+        "brenner": {"fn": _brenner_2d, "agg": da.mean},
+        "noise_std": {"fn": _noise_estimation_2d, "agg": da.mean},
+        "blocking_records": {"fn": _check_blocking_records_2d, "agg": da.mean},
+        "ringing_records": {"fn": _check_ringing_records_2d, "agg": da.mean},
+    }
+
+
+def calculate_np_array_stats(array: da.array, dim_order: str) -> Dict[str, float]:
+    registry = _column_fn_registry()
+    all_metrics = {k: v["fn"] for k, v in registry.items()}
+    all_aggregators = {k: v["agg"] for k, v in registry.items() if v["agg"] is not None}
+    return calculate_sliced_stats(array, dim_order, all_metrics, all_aggregators)
+
+
+def _prepare_2d_image(image: np.ndarray) -> Optional[np.ndarray]:
+    if image.ndim != 2 or image.size == 0 or image.dtype == bool:
+        return None
+    return image.astype(np.float32)
+
+
+def _variance_of_laplacian_2d(image: np.ndarray) -> float:
+    image = _prepare_2d_image(image)
+    if image is None:
+        return float(np.nan)
+    lap = cv2.Laplacian(image, cv2.CV_32F)
+    return float(lap.var())
+
+
+def _tenengrad_2d(image: np.ndarray) -> float:
+    image = _prepare_2d_image(image)
+    if image is None or np.all(image == image.flat[0]):
+        return float(np.nan)
+    gx = cv2.Sobel(image, cv2.CV_32F, 1, 0, ksize=3)
+    gy = cv2.Sobel(image, cv2.CV_32F, 0, 1, ksize=3)
+    mag = np.sqrt(gx ** 2 + gy ** 2)
+    return float(np.mean(mag)) if mag.size > 0 else 0.0
+
+
+def _brenner_2d(image: np.ndarray) -> float:
+    image = _prepare_2d_image(image)
+    if image is None:
+        return float(np.nan)
+    diff = image[:, 2:] - image[:, :-2]
+    return float(np.mean(diff ** 2)) if diff.size > 0 else 0.0
+
+
+def _noise_estimation_2d(image: np.ndarray) -> float:
+    image = _prepare_2d_image(image)
+    if image is None:
+        return float(np.nan)
+    median = cv2.medianBlur(image, 3)
+    noise = image - median
+    return float(np.std(noise))
+
+
+def _check_blocking_records_2d(image: np.ndarray) -> float:
+    image = _prepare_2d_image(image)
+    if image is None:
+        return float(np.nan)
+
+    block_size = 8
+    height, width = image.shape
+    blocking_effect = 0.0
+    num_boundaries = 0
+
+    for i in range(block_size, height, block_size):
+        if i < height:
+            blocking_effect += float(np.mean(np.abs(image[i, :] - image[i - 1, :])))
+            num_boundaries += 1
+    for j in range(block_size, width, block_size):
+        if j < width:
+            blocking_effect += float(np.mean(np.abs(image[:, j] - image[:, j - 1])))
+            num_boundaries += 1
+
+    return blocking_effect / num_boundaries if num_boundaries > 0 else 0.0
+
+
+def _check_ringing_records_2d(image: np.ndarray) -> float:
+    image = _prepare_2d_image(image)
+    if image is None:
+        return float(np.nan)
+    normalized_image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+    edges = cv2.Canny(normalized_image, 50, 150)
+    if np.sum(edges) == 0:
+        return 0.0
+
+    kernel = np.ones((3, 3), np.uint8)
+    dilated_edges = cv2.dilate(edges, kernel, iterations=1)
+    edge_neighborhood = dilated_edges - edges
+
+    if np.sum(edge_neighborhood > 0) == 0:
+        return 0.0
+
+    ringing_variance = np.var(image[edge_neighborhood > 0])
+    return float(ringing_variance)
+
+
+class QualityMetricsProcessor:
+    """
+    Extracts image quality metrics (tenengrad, brenner, noise, etc.) from XY slices.
+    """
+
+    # Declarative plugin metadata
+    NAME = "quality-metrics"
+    INPUT = RecordSpec(axes={"X", "Y"}, kinds={"intensity"}, capabilities={"spatial-2d"})
+    OUTPUT = "features"  # or "record" if this produced another image
+
+    # Table schema (static + dynamic)
+    OUTPUT_SCHEMA: Dict[str, Any] = {name: float for name in _column_fn_registry().keys()}
+    # e.g. tenengrad_C0_Z3, brenner_T5, etc.
+    OUTPUT_SCHEMA_PATTERNS: List[Tuple[str, Any]] = [
+        (rf"^(?:{name})_[a-zA-Z]\d+(_[a-zA-Z]\d+)*$", float)
+        for name in _column_fn_registry().keys()
+    ]
+
+    def run(self, art: Record) -> Dict[str, float]:
+        dim_order = art.dim_order
+        return calculate_np_array_stats(art.data, dim_order)

pixel_patrol_image-0.1.0/src/pixel_patrol_image/plugins/widgets/dynamic_quality_metrics.py

@@ -0,0 +1,23 @@
+from typing import List, Set
+
+from pixel_patrol_base.plugins.widgets.base_dynamic_table_widget import BaseDynamicTableWidget
+from pixel_patrol_base.core.feature_schema import patterns_from_processor
+from pixel_patrol_base.report.widget_categories import WidgetCategories
+
+from pixel_patrol_image.plugins.processors.quality_metrics_processor import QualityMetricsProcessor
+
+
+class DynamicQualityMetricsWidget(BaseDynamicTableWidget):
+    NAME: str = "Quality metrics across dimensions"
+    TAB: str = WidgetCategories.DATASET_STATS.value
+
+    # No fixed columns; rely on the processor's dynamic outputs
+    REQUIRES: Set[str] = set()
+    REQUIRES_PATTERNS: List[str] = patterns_from_processor(QualityMetricsProcessor)
+
+    def __init__(self):
+        super().__init__(widget_id="quality-stats")
+
+    def get_supported_metrics(self) -> List[str]:
+        # Base metric names expected in dynamic columns (e.g., "snr", "focus", …)
+        return list(getattr(QualityMetricsProcessor, "OUTPUT_SCHEMA", {}).keys())

pixel_patrol_image-0.1.0/src/pixel_patrol_image/plugins/widgets/image_quality.py

@@ -0,0 +1,81 @@
+from typing import List, Dict, Set
+
+import polars as pl
+from dash import html, Input, Output
+
+from pixel_patrol_image.plugins.processors.quality_metrics_processor import QualityMetricsProcessor
+from pixel_patrol_base.core.feature_schema import patterns_from_processor
+from pixel_patrol_base.report.utils import generate_column_violin_plots
+from pixel_patrol_base.report.widget_categories import WidgetCategories
+
+
+class ImageQualityWidget:
+    # ---- Declarative spec ----
+    NAME: str = "Image Quality"
+    TAB: str = WidgetCategories.DATASET_STATS.value
+    # Grouping by folder is typical for these plots; require the label column.
+    REQUIRES: Set[str] = {"imported_path_short"}
+    # Dynamic metric columns come from the processor (regex patterns).
+    REQUIRES_PATTERNS: List[str] = patterns_from_processor(QualityMetricsProcessor)
+
+    # Component IDs
+    CONTAINER_ID = "image-quality-container"
+
+    def get_descriptions(self) -> Dict[str, str]:
+        """Descriptions of image quality metrics shown below."""
+        return {
+            "laplacian_variance": (
+                "Measures sharpness via the variance of the Laplacian (edges). "
+                "Higher values indicate sharper images."
+            ),
+            "tenengrad": (
+                "Edge strength from Sobel gradients. Higher values often mean better focus."
+            ),
+            "brenner": (
+                "Intensity differences between neighboring pixels; higher suggests more fine detail."
+            ),
+            "noise_std": (
+                "Estimated random noise level; higher noise reduces clarity."
+            ),
+            # "wavelet_energy": "High-frequency detail via wavelet energy.",
+            "blocking_records": (
+                "Compression blockiness (e.g., JPEG); higher indicates stronger blocking records."
+            ),
+            "ringing_records": (
+                "Edge ghosting/oscillations from compression; higher indicates stronger ringing."
+            ),
+        }
+
+    def layout(self) -> List:
+        """Static description + a single container populated by the callback."""
+        description_items = [
+            html.Li([html.Strong(f"{k.replace('_', ' ').title()}: "), v])
+            for k, v in self.get_descriptions().items()
+        ]
+        return [
+            html.Div(
+                className="markdown-content",
+                children=[
+                    html.H4("Image Quality Metric Descriptions"),
+                    html.P(
+                        "The following metrics assess various aspects of image quality, such as sharpness, noise, "
+                        "and compression records. Each plot shows the distribution of a quality score for images "
+                        "in the selected folders."
+                    ),
+                    html.Ul(description_items),
+                ],
+            ),
+            html.Hr(),
+            html.Div(id=self.CONTAINER_ID),
+        ]
+
+    def register(self, app, df_global: pl.DataFrame):
+        """One callback that renders all violin plots."""
+
+        @app.callback(
+            Output(self.CONTAINER_ID, "children"),
+            Input("color-map-store", "data"),
+        )
+        def update_image_quality_layout(color_map: Dict[str, str]):
+            metric_cols = list(self.get_descriptions().keys())
+            return generate_column_violin_plots(df_global, color_map or {}, metric_cols)

pixel_patrol_image-0.1.0/src/pixel_patrol_image.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: pixel-patrol-image
+Version: 0.1.0
+Summary: Image prevalidation tool
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pixel-patrol-base>=0.1.0
+Requires-Dist: opencv-python-headless>=4.8

pixel_patrol_image-0.1.0/src/pixel_patrol_image.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+pyproject.toml
+src/pixel_patrol_image/plugin_registry.py
+src/pixel_patrol_image.egg-info/PKG-INFO
+src/pixel_patrol_image.egg-info/SOURCES.txt
+src/pixel_patrol_image.egg-info/dependency_links.txt
+src/pixel_patrol_image.egg-info/entry_points.txt
+src/pixel_patrol_image.egg-info/requires.txt
+src/pixel_patrol_image.egg-info/top_level.txt
+src/pixel_patrol_image/plugins/processors/quality_metrics_processor.py
+src/pixel_patrol_image/plugins/widgets/dynamic_quality_metrics.py
+src/pixel_patrol_image/plugins/widgets/image_quality.py

pixel_patrol_image-0.1.0/src/pixel_patrol_image.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pixel_patrol_image-0.1.0/src/pixel_patrol_image.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[pixel_patrol.processor_plugins]
+pixel_patrol_image_processing_builtins = pixel_patrol_image.plugin_registry:register_processor_plugins
+
+[pixel_patrol.widget_plugins]
+pixel_patrol_image_widget_builtins = pixel_patrol_image.plugin_registry:register_widget_plugins

pixel_patrol_image-0.1.0/src/pixel_patrol_image.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pixel-patrol-base>=0.1.0
+opencv-python-headless>=4.8

pixel_patrol_image-0.1.0/src/pixel_patrol_image.egg-info/top_level.txt

@@ -0,0 +1 @@
+pixel_patrol_image