photo-stack-finder 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

photo_compare/histogram_methods.py

@@ -1,118 +1,118 @@
-"""Histogram-based similarity methods with caching support."""
-
-from __future__ import annotations
-
-from abc import abstractmethod
-
-import cv2 as cv
-import numpy as np
-import numpy.typing as npt
-from PIL import Image
-
-from .base import ComparisonMethodName, SimilarityMethod
-
-
-class HistogramMethodBase(SimilarityMethod[npt.NDArray[np.float32]]):
-    """Base class for histogram-based similarity methods."""
-
-    def __init__(self, method_name: ComparisonMethodName, comparison_method: str) -> None:
-        super().__init__(method_name)
-        self.comparison_method = comparison_method
-
-    @abstractmethod
-    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
-        """Implement the actual histogram preparation logic.
-
-        Args:
-            pixels: RGB pixel array with shape (height, width, 3), dtype uint8.
-                    EXIF orientation already applied. Full resolution.
-
-        Returns:
-            Normalized histogram as float32 array
-        """
-        ...
-
-    def _compare_histograms(self, hist1: npt.NDArray[np.float32], hist2: npt.NDArray[np.float32]) -> float:
-        """Compare histograms using OpenCV methods."""
-        methods: dict[str, int] = {
-            "correlation": cv.HISTCMP_CORREL,
-            "chi_square": cv.HISTCMP_CHISQR,
-            "intersection": cv.HISTCMP_INTERSECT,
-            "bhattacharyya": cv.HISTCMP_BHATTACHARYYA,
-        }
-
-        method: int = methods.get(self.comparison_method, cv.HISTCMP_CORREL)
-        similarity: float = cv.compareHist(hist1.astype(np.float32), hist2.astype(np.float32), method)
-
-        # Normalize to 0-1 scale where higher is more similar
-        if self.comparison_method == "chi_square":
-            return float(1.0 / (1.0 + similarity))
-        if self.comparison_method == "bhattacharyya":
-            return float(1.0 - similarity)
-        return float(max(0.0, similarity))
-
-
-class ColorHistogramMethod(HistogramMethodBase):
-    """RGB colour histogram method for colour-based similarity."""
-
-    def __init__(self, bins: int, comparison_method: str) -> None:
-        super().__init__("colour_histogram", comparison_method)
-        self.bins = bins
-
-    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
-        """Prepare RGB color histograms for the image."""
-        img = Image.fromarray(pixels, mode="RGB")
-        img = img.resize((256, 256), Image.Resampling.LANCZOS)
-        arr = np.array(img)
-
-        hist_r: npt.NDArray[np.float32] = cv.calcHist([arr], [0], None, [self.bins], [0, 256]).flatten()
-        hist_g: npt.NDArray[np.float32] = cv.calcHist([arr], [1], None, [self.bins], [0, 256]).flatten()
-        hist_b: npt.NDArray[np.float32] = cv.calcHist([arr], [2], None, [self.bins], [0, 256]).flatten()
-
-        # Normalize
-        hist_r = hist_r / (hist_r.sum() + 1e-10)
-        hist_g = hist_g / (hist_g.sum() + 1e-10)
-        hist_b = hist_b / (hist_b.sum() + 1e-10)
-
-        # Concatenate into single array for consistent interface
-        return np.concatenate([hist_r, hist_g, hist_b])
-
-    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
-        """Compare RGB histograms by averaging across channels."""
-        # Split back into R, G, B channels
-        bins: int = len(prep1) // 3
-        r1: npt.NDArray[np.float32] = prep1[:bins]
-        g1: npt.NDArray[np.float32] = prep1[bins : 2 * bins]
-        b1: npt.NDArray[np.float32] = prep1[2 * bins :]
-        r2: npt.NDArray[np.float32] = prep2[:bins]
-        g2: npt.NDArray[np.float32] = prep2[bins : 2 * bins]
-        b2: npt.NDArray[np.float32] = prep2[2 * bins :]
-
-        r_sim: float = self._compare_histograms(r1, r2)
-        g_sim: float = self._compare_histograms(g1, g2)
-        b_sim: float = self._compare_histograms(b1, b2)
-        return (r_sim + g_sim + b_sim) / 3.0
-
-
-class HSVHistogramMethod(HistogramMethodBase):
-    """HSV colour histogram method - often better than RGB for colour similarity."""
-
-    def __init__(self, bins: tuple[int, int, int], comparison_method: str) -> None:
-        super().__init__("hsv_histogram", comparison_method)
-        self.bins = bins
-
-    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
-        """Prepare HSV color histogram for the image."""
-        img = Image.fromarray(pixels, mode="RGB")
-        img = img.resize((256, 256), Image.Resampling.LANCZOS)
-        arr = np.array(img)
-        hsv = cv.cvtColor(arr, cv.COLOR_RGB2HSV)
-
-        hist: npt.NDArray[np.float32] = cv.calcHist([hsv], [0, 1, 2], None, list(self.bins), [0, 180, 0, 256, 0, 256])
-        hist = hist.flatten()
-        normalized: npt.NDArray[np.float32] = (hist / (hist.sum() + 1e-10)).astype(np.float32)
-        return normalized
-
-    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
-        """Compare HSV histograms using specified method."""
-        return self._compare_histograms(prep1, prep2)
+"""Histogram-based similarity methods with caching support."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+
+import cv2 as cv
+import numpy as np
+import numpy.typing as npt
+from PIL import Image
+
+from .base import ComparisonMethodName, SimilarityMethod
+
+
+class HistogramMethodBase(SimilarityMethod[npt.NDArray[np.float32]]):
+    """Base class for histogram-based similarity methods."""
+
+    def __init__(self, method_name: ComparisonMethodName, comparison_method: str) -> None:
+        super().__init__(method_name)
+        self.comparison_method = comparison_method
+
+    @abstractmethod
+    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
+        """Implement the actual histogram preparation logic.
+
+        Args:
+            pixels: RGB pixel array with shape (height, width, 3), dtype uint8.
+                    EXIF orientation already applied. Full resolution.
+
+        Returns:
+            Normalized histogram as float32 array
+        """
+        ...
+
+    def _compare_histograms(self, hist1: npt.NDArray[np.float32], hist2: npt.NDArray[np.float32]) -> float:
+        """Compare histograms using OpenCV methods."""
+        methods: dict[str, int] = {
+            "correlation": cv.HISTCMP_CORREL,
+            "chi_square": cv.HISTCMP_CHISQR,
+            "intersection": cv.HISTCMP_INTERSECT,
+            "bhattacharyya": cv.HISTCMP_BHATTACHARYYA,
+        }
+
+        method: int = methods.get(self.comparison_method, cv.HISTCMP_CORREL)
+        similarity: float = cv.compareHist(hist1.astype(np.float32), hist2.astype(np.float32), method)
+
+        # Normalize to 0-1 scale where higher is more similar
+        if self.comparison_method == "chi_square":
+            return float(1.0 / (1.0 + similarity))
+        if self.comparison_method == "bhattacharyya":
+            return float(1.0 - similarity)
+        return float(max(0.0, similarity))
+
+
+class ColorHistogramMethod(HistogramMethodBase):
+    """RGB colour histogram method for colour-based similarity."""
+
+    def __init__(self, bins: int, comparison_method: str) -> None:
+        super().__init__("colour_histogram", comparison_method)
+        self.bins = bins
+
+    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
+        """Prepare RGB color histograms for the image."""
+        img = Image.fromarray(pixels, mode="RGB")
+        img = img.resize((256, 256), Image.Resampling.LANCZOS)
+        arr = np.array(img)
+
+        hist_r: npt.NDArray[np.float32] = cv.calcHist([arr], [0], None, [self.bins], [0, 256]).flatten()
+        hist_g: npt.NDArray[np.float32] = cv.calcHist([arr], [1], None, [self.bins], [0, 256]).flatten()
+        hist_b: npt.NDArray[np.float32] = cv.calcHist([arr], [2], None, [self.bins], [0, 256]).flatten()
+
+        # Normalize
+        hist_r = hist_r / (hist_r.sum() + 1e-10)
+        hist_g = hist_g / (hist_g.sum() + 1e-10)
+        hist_b = hist_b / (hist_b.sum() + 1e-10)
+
+        # Concatenate into single array for consistent interface
+        return np.concatenate([hist_r, hist_g, hist_b])
+
+    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
+        """Compare RGB histograms by averaging across channels."""
+        # Split back into R, G, B channels
+        bins: int = len(prep1) // 3
+        r1: npt.NDArray[np.float32] = prep1[:bins]
+        g1: npt.NDArray[np.float32] = prep1[bins : 2 * bins]
+        b1: npt.NDArray[np.float32] = prep1[2 * bins :]
+        r2: npt.NDArray[np.float32] = prep2[:bins]
+        g2: npt.NDArray[np.float32] = prep2[bins : 2 * bins]
+        b2: npt.NDArray[np.float32] = prep2[2 * bins :]
+
+        r_sim: float = self._compare_histograms(r1, r2)
+        g_sim: float = self._compare_histograms(g1, g2)
+        b_sim: float = self._compare_histograms(b1, b2)
+        return (r_sim + g_sim + b_sim) / 3.0
+
+
+class HSVHistogramMethod(HistogramMethodBase):
+    """HSV colour histogram method - often better than RGB for colour similarity."""
+
+    def __init__(self, bins: tuple[int, int, int], comparison_method: str) -> None:
+        super().__init__("hsv_histogram", comparison_method)
+        self.bins = bins
+
+    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
+        """Prepare HSV color histogram for the image."""
+        img = Image.fromarray(pixels, mode="RGB")
+        img = img.resize((256, 256), Image.Resampling.LANCZOS)
+        arr = np.array(img)
+        hsv = cv.cvtColor(arr, cv.COLOR_RGB2HSV)
+
+        hist: npt.NDArray[np.float32] = cv.calcHist([hsv], [0, 1, 2], None, list(self.bins), [0, 180, 0, 256, 0, 256])
+        hist = hist.flatten()
+        normalized: npt.NDArray[np.float32] = (hist / (hist.sum() + 1e-10)).astype(np.float32)
+        return normalized
+
+    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
+        """Compare HSV histograms using specified method."""
+        return self._compare_histograms(prep1, prep2)

photo_compare/pixel_methods.py

@@ -1,58 +1,58 @@
-"""Pixel-based similarity methods with caching support."""
-
-from __future__ import annotations
-
-import numpy as np
-import numpy.typing as npt
-from PIL import Image
-
-from .base import SimilarityMethod
-
-
-class MSEMethod(SimilarityMethod[npt.NDArray[np.float32]]):
-    """Mean Squared Error method for pixel-level comparison."""
-
-    def __init__(self, image_size: int) -> None:
-        super().__init__("mse")
-        self.image_size = image_size
-
-    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
-        """Prepare standardized image for MSE comparison."""
-        img = Image.fromarray(pixels, mode="RGB")
-        img = img.convert("L")
-        img = img.resize((self.image_size, self.image_size), Image.Resampling.LANCZOS)
-        return np.array(img, dtype=np.float32)
-
-    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
-        """Compare images using MSE converted to similarity score."""
-        mse = float(np.mean((prep1 - prep2) ** 2))
-        # Convert MSE to similarity score using exponential decay
-        return float(np.exp(-mse / 1000.0))
-
-
-class PSNRMethod(SimilarityMethod[npt.NDArray[np.float32]]):
-    """Peak Signal-to-Noise Ratio method for image quality comparison."""
-
-    def __init__(self, image_size: int, max_value: float) -> None:
-        super().__init__("psnr")
-        self.image_size = image_size
-        self.max_value = max_value
-
-    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
-        """Prepare standardized image for PSNR comparison."""
-        img = Image.fromarray(pixels, mode="RGB")
-        img = img.convert("L")
-        img = img.resize((self.image_size, self.image_size), Image.Resampling.LANCZOS)
-        return np.array(img, dtype=np.float32)
-
-    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
-        """Compare images using PSNR converted to similarity score."""
-        mse = float(np.mean((prep1 - prep2) ** 2))
-
-        if mse == 0:
-            return 1.0  # Perfect similarity
-
-        psnr = 20 * np.log10(self.max_value / np.sqrt(mse))
-        # Convert PSNR to similarity score (0-1)
-        # PSNR typically ranges from ~10 (poor) to ~50+ (excellent)
-        return float(min(1.0, max(0.0, (psnr - 10.0) / 40.0)))
+"""Pixel-based similarity methods with caching support."""
+
+from __future__ import annotations
+
+import numpy as np
+import numpy.typing as npt
+from PIL import Image
+
+from .base import SimilarityMethod
+
+
+class MSEMethod(SimilarityMethod[npt.NDArray[np.float32]]):
+    """Mean Squared Error method for pixel-level comparison."""
+
+    def __init__(self, image_size: int) -> None:
+        super().__init__("mse")
+        self.image_size = image_size
+
+    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
+        """Prepare standardized image for MSE comparison."""
+        img = Image.fromarray(pixels, mode="RGB")
+        img = img.convert("L")
+        img = img.resize((self.image_size, self.image_size), Image.Resampling.LANCZOS)
+        return np.array(img, dtype=np.float32)
+
+    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
+        """Compare images using MSE converted to similarity score."""
+        mse = float(np.mean((prep1 - prep2) ** 2))
+        # Convert MSE to similarity score using exponential decay
+        return float(np.exp(-mse / 1000.0))
+
+
+class PSNRMethod(SimilarityMethod[npt.NDArray[np.float32]]):
+    """Peak Signal-to-Noise Ratio method for image quality comparison."""
+
+    def __init__(self, image_size: int, max_value: float) -> None:
+        super().__init__("psnr")
+        self.image_size = image_size
+        self.max_value = max_value
+
+    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
+        """Prepare standardized image for PSNR comparison."""
+        img = Image.fromarray(pixels, mode="RGB")
+        img = img.convert("L")
+        img = img.resize((self.image_size, self.image_size), Image.Resampling.LANCZOS)
+        return np.array(img, dtype=np.float32)
+
+    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
+        """Compare images using PSNR converted to similarity score."""
+        mse = float(np.mean((prep1 - prep2) ** 2))
+
+        if mse == 0:
+            return 1.0  # Perfect similarity
+
+        psnr = 20 * np.log10(self.max_value / np.sqrt(mse))
+        # Convert PSNR to similarity score (0-1)
+        # PSNR typically ranges from ~10 (poor) to ~50+ (excellent)
+        return float(min(1.0, max(0.0, (psnr - 10.0) / 40.0)))

photo_compare/structural_methods.py

@@ -1,104 +1,104 @@
-"""Structural similarity methods with caching support."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-
-import cv2 as cv
-import numpy as np
-import numpy.typing as npt
-from PIL import Image
-from skimage.feature import hog
-from skimage.metrics import structural_similarity as ssim
-
-from .base import SimilarityMethod
-
-
-class SSIMMethod(SimilarityMethod[npt.NDArray[np.float32]]):
-    """SSIM (Structural Similarity Index) method using scikit-image."""
-
-    def __init__(self, image_size: int) -> None:
-        super().__init__("ssim")
-        self.image_size = image_size
-
-    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
-        """Prepare image for SSIM comparison."""
-        img = Image.fromarray(pixels, mode="RGB")
-        img = img.convert("L")
-        img = img.resize((self.image_size, self.image_size), Image.Resampling.LANCZOS)
-        return np.array(img, dtype=np.float32) / 255.0
-
-    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
-        """Compare prepared images using SSIM."""
-        return float(ssim(prep1, prep2, data_range=1.0))
-
-
-class MultiScaleSSIMMethod(SimilarityMethod[npt.NDArray[np.float32]]):
-    """Multi-scale SSIM method for more robust comparison."""
-
-    def __init__(self, image_size: int, scales: Sequence[float]) -> None:
-        super().__init__("ms_ssim")
-        self.image_size = image_size
-        self.scales = scales
-
-    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
-        """Prepare image for multi-scale SSIM comparison."""
-        img = Image.fromarray(pixels, mode="RGB")
-        img = img.convert("L")
-        img = img.resize((self.image_size, self.image_size), Image.Resampling.LANCZOS)
-        return np.array(img, dtype=np.float32) / 255.0
-
-    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
-        """Compare prepared images using multi-scale SSIM."""
-        scores: list[float] = []
-        for scale in self.scales:
-            if scale == 1.0:
-                score: float = float(ssim(prep1, prep2, data_range=1.0))
-            else:
-                h: int
-                w: int
-                h, w = prep1.shape
-                new_h: int = max(1, int(h * scale))
-                new_w: int = max(1, int(w * scale))
-                prep1_scaled: npt.NDArray[np.float32] = cv.resize(prep1, (new_w, new_h), interpolation=cv.INTER_AREA)
-                prep2_scaled: npt.NDArray[np.float32] = cv.resize(prep2, (new_w, new_h), interpolation=cv.INTER_AREA)
-                score = float(ssim(prep1_scaled, prep2_scaled, data_range=1.0))
-            scores.append(score)
-        return float(np.mean(scores))
-
-
-class HOGMethod(SimilarityMethod[npt.NDArray[np.float32]]):
-    """HOG (Histogram of Oriented Gradients) feature method using scikit-image."""
-
-    def __init__(self, orientations: int, pixels_per_cell: tuple[int, int]) -> None:
-        super().__init__("hog")
-        self.orientations = orientations
-        self.pixels_per_cell = pixels_per_cell
-
-    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
-        """Prepare HOG features for the image."""
-        img = Image.fromarray(pixels, mode="RGB")
-        img = img.convert("L")
-        img = img.resize((128, 128), Image.Resampling.LANCZOS)
-        img_array: npt.NDArray[np.float32] = np.array(img, dtype=np.float32) / 255.0
-
-        features: npt.NDArray[np.float32] = hog(
-            img_array,
-            orientations=self.orientations,
-            pixels_per_cell=self.pixels_per_cell,
-            cells_per_block=(2, 2),
-            block_norm="L2-Hys",
-            feature_vector=True,
-        )
-        return features.astype(np.float32)
-
-    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
-        """Compare HOG features using cosine similarity."""
-        dot_product = float(np.dot(prep1, prep2))
-        norm_a = float(np.linalg.norm(prep1))
-        norm_b = float(np.linalg.norm(prep2))
-
-        if norm_a == 0.0 or norm_b == 0.0:
-            return 0.0
-
-        return dot_product / (norm_a * norm_b)
+"""Structural similarity methods with caching support."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import cv2 as cv
+import numpy as np
+import numpy.typing as npt
+from PIL import Image
+from skimage.feature import hog
+from skimage.metrics import structural_similarity as ssim
+
+from .base import SimilarityMethod
+
+
+class SSIMMethod(SimilarityMethod[npt.NDArray[np.float32]]):
+    """SSIM (Structural Similarity Index) method using scikit-image."""
+
+    def __init__(self, image_size: int) -> None:
+        super().__init__("ssim")
+        self.image_size = image_size
+
+    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
+        """Prepare image for SSIM comparison."""
+        img = Image.fromarray(pixels, mode="RGB")
+        img = img.convert("L")
+        img = img.resize((self.image_size, self.image_size), Image.Resampling.LANCZOS)
+        return np.array(img, dtype=np.float32) / 255.0
+
+    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
+        """Compare prepared images using SSIM."""
+        return float(ssim(prep1, prep2, data_range=1.0))
+
+
+class MultiScaleSSIMMethod(SimilarityMethod[npt.NDArray[np.float32]]):
+    """Multi-scale SSIM method for more robust comparison."""
+
+    def __init__(self, image_size: int, scales: Sequence[float]) -> None:
+        super().__init__("ms_ssim")
+        self.image_size = image_size
+        self.scales = scales
+
+    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
+        """Prepare image for multi-scale SSIM comparison."""
+        img = Image.fromarray(pixels, mode="RGB")
+        img = img.convert("L")
+        img = img.resize((self.image_size, self.image_size), Image.Resampling.LANCZOS)
+        return np.array(img, dtype=np.float32) / 255.0
+
+    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
+        """Compare prepared images using multi-scale SSIM."""
+        scores: list[float] = []
+        for scale in self.scales:
+            if scale == 1.0:
+                score: float = float(ssim(prep1, prep2, data_range=1.0))
+            else:
+                h: int
+                w: int
+                h, w = prep1.shape
+                new_h: int = max(1, int(h * scale))
+                new_w: int = max(1, int(w * scale))
+                prep1_scaled: npt.NDArray[np.float32] = cv.resize(prep1, (new_w, new_h), interpolation=cv.INTER_AREA)
+                prep2_scaled: npt.NDArray[np.float32] = cv.resize(prep2, (new_w, new_h), interpolation=cv.INTER_AREA)
+                score = float(ssim(prep1_scaled, prep2_scaled, data_range=1.0))
+            scores.append(score)
+        return float(np.mean(scores))
+
+
+class HOGMethod(SimilarityMethod[npt.NDArray[np.float32]]):
+    """HOG (Histogram of Oriented Gradients) feature method using scikit-image."""
+
+    def __init__(self, orientations: int, pixels_per_cell: tuple[int, int]) -> None:
+        super().__init__("hog")
+        self.orientations = orientations
+        self.pixels_per_cell = pixels_per_cell
+
+    def _prepare_single(self, pixels: npt.NDArray[np.uint8]) -> npt.NDArray[np.float32]:
+        """Prepare HOG features for the image."""
+        img = Image.fromarray(pixels, mode="RGB")
+        img = img.convert("L")
+        img = img.resize((128, 128), Image.Resampling.LANCZOS)
+        img_array: npt.NDArray[np.float32] = np.array(img, dtype=np.float32) / 255.0
+
+        features: npt.NDArray[np.float32] = hog(
+            img_array,
+            orientations=self.orientations,
+            pixels_per_cell=self.pixels_per_cell,
+            cells_per_block=(2, 2),
+            block_norm="L2-Hys",
+            feature_vector=True,
+        )
+        return features.astype(np.float32)
+
+    def _compare_prepared(self, prep1: npt.NDArray[np.float32], prep2: npt.NDArray[np.float32]) -> float:
+        """Compare HOG features using cosine similarity."""
+        dot_product = float(np.dot(prep1, prep2))
+        norm_a = float(np.linalg.norm(prep1))
+        norm_b = float(np.linalg.norm(prep2))
+
+        if norm_a == 0.0 or norm_b == 0.0:
+            return 0.0
+
+        return dot_product / (norm_a * norm_b)

photo_compare/types.py

@@ -1,28 +1,28 @@
-"""Type aliases for photo comparison arrays.
-
-This module defines common numpy array type aliases used throughout the
-photo comparison subsystem. Using these aliases makes type signatures
-more readable while maintaining strict type safety.
-"""
-
-import numpy as np
-import numpy.typing as npt
-
-# Image arrays (H, W, C) - typically uint8 RGB images
-ImageArray = npt.NDArray[np.uint8]
-
-# Grayscale images (H, W) - typically uint8 single channel
-GrayscaleArray = npt.NDArray[np.uint8]
-
-# Histogram arrays (1D) - typically float64 normalized histograms
-HistogramArray = npt.NDArray[np.float64]
-
-# Feature descriptor arrays (N, D) - typically float32 feature vectors
-# where N is the number of keypoints and D is the descriptor dimension
-DescriptorArray = npt.NDArray[np.float32]
-
-# Hash arrays - boolean arrays representing perceptual hashes
-HashArray = npt.NDArray[np.bool_]
-
-# Structural comparison arrays (H, W) - float64 SSIM maps
-StructuralArray = npt.NDArray[np.float64]
+"""Type aliases for photo comparison arrays.
+
+This module defines common numpy array type aliases used throughout the
+photo comparison subsystem. Using these aliases makes type signatures
+more readable while maintaining strict type safety.
+"""
+
+import numpy as np
+import numpy.typing as npt
+
+# Image arrays (H, W, C) - typically uint8 RGB images
+ImageArray = npt.NDArray[np.uint8]
+
+# Grayscale images (H, W) - typically uint8 single channel
+GrayscaleArray = npt.NDArray[np.uint8]
+
+# Histogram arrays (1D) - typically float64 normalized histograms
+HistogramArray = npt.NDArray[np.float64]
+
+# Feature descriptor arrays (N, D) - typically float32 feature vectors
+# where N is the number of keypoints and D is the descriptor dimension
+DescriptorArray = npt.NDArray[np.float32]
+
+# Hash arrays - boolean arrays representing perceptual hashes
+HashArray = npt.NDArray[np.bool_]
+
+# Structural comparison arrays (H, W) - float64 SSIM maps
+StructuralArray = npt.NDArray[np.float64]