python-libphash 1.0.0__tar.gz

python_libphash-1.0.0/LICENSE

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

python_libphash-1.0.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+recursive-include native/libphash *
+recursive-exclude native/libphash/.git *

python_libphash-1.0.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: python-libphash
+Version: 1.0.0
+Summary: High-performance perceptual hashing library (CFFI bindings)
+Author-email: gudoshnikovn <gudoshnikov-na@yandex.ru>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gudoshnikovn/python-libphash
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cffi>=1.15.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# python-libphash
+
+High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash), a C library for perceptual image hashing.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+## Overview
+
+`libphash` provides multiple algorithms to generate "perceptual hashes" of images. Unlike cryptographic hashes (like MD5 or SHA256), perceptual hashes change only slightly if the image is resized, compressed, or has minor color adjustments. This makes them ideal for finding duplicate or similar images.
+
+### Supported Algorithms
+
+*   **64-bit Hashes (uint64):**
+    *   `ahash`: Average Hash
+    *   `dhash`: Difference Hash
+    *   `phash`: Perceptual Hash (DCT based)
+    *   `whash`: Wavelet Hash
+    *   `mhash`: Median Hash
+*   **Digest Hashes (Multi-byte):**
+    *   `bmh`: Block Mean Hash
+    *   `color_hash`: Color Moment Hash
+    *   `radial_hash`: Radial Variance Hash
+
+## Installation
+
+### Prerequisites
+*   A C compiler (GCC/Clang or MSVC)
+*   Python 3.8 or higher
+
+### Install from source
+```bash
+git clone --recursive https://github.com/yourusername/python-libphash.git
+cd python-libphash
+pip install .
+```
+
+## Quick Start
+
+### Basic Usage
+```python
+from libphash import ImageContext, HashMethod, hamming_distance
+
+# Use the context manager for automatic memory management
+with ImageContext("photo.jpg") as ctx:
+    # Get standard 64-bit hashes
+    phash_val = ctx.phash
+    dhash_val = ctx.dhash
+    
+    print(f"pHash: {phash_val:016x}")
+    print(f"dHash: {dhash_val:016x}")
+
+# Compare two images
+from libphash import compare_images
+distance = compare_images("image1.jpg", "image2.jpg", method=HashMethod.PHASH)
+print(f"Hamming Distance: {distance}")
+```
+
+### Working with Digests (Advanced Hashes)
+Algorithms like Radial Hash or Color Hash return a `Digest` object instead of a single integer.
+
+```python
+with ImageContext("photo.jpg") as ctx:
+    digest = ctx.radial_hash
+    print(f"Digest size: {digest.size} bytes")
+    print(f"Raw data: {digest.data.hex()}")
+
+# Comparing digests
+with ImageContext("photo_v2.jpg") as ctx2:
+    digest2 = ctx2.radial_hash
+    
+    # Hamming distance for bit-wise comparison
+    h_dist = digest.distance_hamming(digest2)
+    
+    # L2 (Euclidean) distance for similarity
+    l2_dist = digest.distance_l2(digest2)
+```
+
+## API Reference
+
+### `ImageContext`
+The main class for loading images and computing hashes.
+*   `__init__(path=None, bytes_data=None)`: Load an image from a file path or memory.
+*   `set_gamma(gamma: float)`: Set gamma correction (useful for Radial Hash).
+*   **Properties**: `ahash`, `dhash`, `phash`, `whash`, `mhash` (returns `int`).
+*   **Properties**: `bmh`, `color_hash`, `radial_hash` (returns `Digest`).
+
+### `Digest`
+*   `data`: The raw `bytes` of the hash.
+*   `size`: Length of the hash in bytes.
+*   `distance_hamming(other)`: Calculates bit-wise distance.
+*   `distance_l2(other)`: Calculates Euclidean distance.
+
+### Utilities
+*   `hamming_distance(h1: int, h2: int)`: Returns the number of differing bits between two 64-bit integers.
+*   `get_hash(path, method)`: Quick way to get a hash without manual context management.
+*   `compare_images(path1, path2, method)`: Returns the Hamming distance between two image files.
+
+## Performance
+Since the core logic is implemented in C and uses `stb_image` for decoding, `libphash` is significantly faster than pure-Python alternatives. It also uses CFFI's "out-of-line" mode for minimal overhead.
+
+## License
+This project is licensed under the MIT License - see the LICENSE file for details.
+

python_libphash-1.0.0/README.md

@@ -0,0 +1,104 @@
+# python-libphash
+
+High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash), a C library for perceptual image hashing.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+## Overview
+
+`libphash` provides multiple algorithms to generate "perceptual hashes" of images. Unlike cryptographic hashes (like MD5 or SHA256), perceptual hashes change only slightly if the image is resized, compressed, or has minor color adjustments. This makes them ideal for finding duplicate or similar images.
+
+### Supported Algorithms
+
+*   **64-bit Hashes (uint64):**
+    *   `ahash`: Average Hash
+    *   `dhash`: Difference Hash
+    *   `phash`: Perceptual Hash (DCT based)
+    *   `whash`: Wavelet Hash
+    *   `mhash`: Median Hash
+*   **Digest Hashes (Multi-byte):**
+    *   `bmh`: Block Mean Hash
+    *   `color_hash`: Color Moment Hash
+    *   `radial_hash`: Radial Variance Hash
+
+## Installation
+
+### Prerequisites
+*   A C compiler (GCC/Clang or MSVC)
+*   Python 3.8 or higher
+
+### Install from source
+```bash
+git clone --recursive https://github.com/yourusername/python-libphash.git
+cd python-libphash
+pip install .
+```
+
+## Quick Start
+
+### Basic Usage
+```python
+from libphash import ImageContext, HashMethod, hamming_distance
+
+# Use the context manager for automatic memory management
+with ImageContext("photo.jpg") as ctx:
+    # Get standard 64-bit hashes
+    phash_val = ctx.phash
+    dhash_val = ctx.dhash
+    
+    print(f"pHash: {phash_val:016x}")
+    print(f"dHash: {dhash_val:016x}")
+
+# Compare two images
+from libphash import compare_images
+distance = compare_images("image1.jpg", "image2.jpg", method=HashMethod.PHASH)
+print(f"Hamming Distance: {distance}")
+```
+
+### Working with Digests (Advanced Hashes)
+Algorithms like Radial Hash or Color Hash return a `Digest` object instead of a single integer.
+
+```python
+with ImageContext("photo.jpg") as ctx:
+    digest = ctx.radial_hash
+    print(f"Digest size: {digest.size} bytes")
+    print(f"Raw data: {digest.data.hex()}")
+
+# Comparing digests
+with ImageContext("photo_v2.jpg") as ctx2:
+    digest2 = ctx2.radial_hash
+    
+    # Hamming distance for bit-wise comparison
+    h_dist = digest.distance_hamming(digest2)
+    
+    # L2 (Euclidean) distance for similarity
+    l2_dist = digest.distance_l2(digest2)
+```
+
+## API Reference
+
+### `ImageContext`
+The main class for loading images and computing hashes.
+*   `__init__(path=None, bytes_data=None)`: Load an image from a file path or memory.
+*   `set_gamma(gamma: float)`: Set gamma correction (useful for Radial Hash).
+*   **Properties**: `ahash`, `dhash`, `phash`, `whash`, `mhash` (returns `int`).
+*   **Properties**: `bmh`, `color_hash`, `radial_hash` (returns `Digest`).
+
+### `Digest`
+*   `data`: The raw `bytes` of the hash.
+*   `size`: Length of the hash in bytes.
+*   `distance_hamming(other)`: Calculates bit-wise distance.
+*   `distance_l2(other)`: Calculates Euclidean distance.
+
+### Utilities
+*   `hamming_distance(h1: int, h2: int)`: Returns the number of differing bits between two 64-bit integers.
+*   `get_hash(path, method)`: Quick way to get a hash without manual context management.
+*   `compare_images(path1, path2, method)`: Returns the Hamming distance between two image files.
+
+## Performance
+Since the core logic is implemented in C and uses `stb_image` for decoding, `libphash` is significantly faster than pure-Python alternatives. It also uses CFFI's "out-of-line" mode for minimal overhead.
+
+## License
+This project is licensed under the MIT License - see the LICENSE file for details.
+

python_libphash-1.0.0/native/libphash/.clang-format

@@ -0,0 +1,18 @@
+---
+BasedOnStyle: LLVM
+IndentWidth: 4
+ColumnLimit: 100
+UseTab: Never
+BreakBeforeBraces: Attach
+AllowShortIfStatementsOnASingleLine: false
+IndentCaseLabels: true
+AlignAfterOpenBracket: Align
+AlwaysBreakAfterReturnType: None
+PointerAlignment: Right
+SpaceAfterCStyleCast: false
+SpaceBeforeParens: ControlStatements
+Cpp11BracedListStyle: true
+SortIncludes: true
+MaxEmptyLinesToKeep: 1
+---
+

python_libphash-1.0.0/native/libphash/.git

@@ -0,0 +1 @@
+gitdir: ../../.git/modules/native/libphash

python_libphash-1.0.0/native/libphash/.gitignore

@@ -0,0 +1,25 @@
+# Object files and libraries
+*.o
+*.a
+*.so
+*.dylib
+*.dll
+obj/
+
+# Executables (Tests)
+test_*
+!tests/test_*.c
+
+# IDEs and Editors
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+
+# Build artifacts
+dist/
+build/
+
+# Test images (if generated)
+tests/output_*.jpeg

python_libphash-1.0.0/native/libphash/CMakeLists.txt

@@ -0,0 +1,48 @@
+cmake_minimum_required(VERSION 3.10)
+project(libphash VERSION 1.2.0 LANGUAGES C)
+
+# --- Options ---
+option(PHASH_BUILD_TESTS "Build tests" ON)
+option(PHASH_BUILD_SHARED "Build shared library" OFF)
+
+# --- Compiler Flags ---
+if(MSVC)
+    add_compile_options(/W3 /O2)
+else()
+    add_compile_options(-Wall -Wextra -O3 -fPIC)
+    # Architecture specific optimizations
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64")
+        add_compile_options(-msse4.2)
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64")
+        add_compile_options(-march=armv8-a+simd)
+    endif()
+endif()
+
+# --- Library ---
+file(GLOB_RECURSE SOURCES "src/*.c")
+
+if(PHASH_BUILD_SHARED)
+    add_library(phash SHARED ${SOURCES})
+    target_compile_definitions(phash PRIVATE LIBPHASH_EXPORTS)
+else()
+    add_library(phash STATIC ${SOURCES})
+endif()
+
+target_include_directories(phash PUBLIC 
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+
+target_link_libraries(phash PRIVATE m) # Link math library
+
+# --- Tests ---
+if(PHASH_BUILD_TESTS)
+    enable_testing()
+    file(GLOB TEST_SOURCES "tests/test_*.c")
+    foreach(test_src ${TEST_SOURCES})
+        get_filename_component(test_name ${test_src} NAME_WE)
+        add_executable(${test_name} ${test_src})
+        target_link_libraries(${test_name} PRIVATE phash)
+        add_test(NAME ${test_name} COMMAND ${test_name})
+    endforeach()
+endif()

python_libphash-1.0.0/native/libphash/LICENSE

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

python_libphash-1.0.0/native/libphash/Makefile

@@ -0,0 +1,51 @@
+CC = gcc
+CFLAGS = -I./include -O3 -Wall -Wextra -fPIC
+LDFLAGS = -lm
+
+UNAME_M := $(shell uname -m)
+ifeq ($(UNAME_M),x86_64)
+    CFLAGS += -msse4.2
+endif
+ifeq ($(UNAME_M),arm64)
+    CFLAGS += -march=armv8-a+simd
+endif
+
+LIB_NAME = libphash.a
+OBJ_DIR = obj
+SRC_DIR = src
+HASH_DIR = $(SRC_DIR)/hashes
+TEST_DIR = tests
+INC_DIR = include
+
+SRCS = $(wildcard $(SRC_DIR)/*.c) $(wildcard $(HASH_DIR)/*.c)
+OBJS = $(SRCS:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o)
+
+TEST_SRCS = $(wildcard $(TEST_DIR)/test_*.c)
+TEST_BINS = $(TEST_SRCS:$(TEST_DIR)/%.c=%)
+
+all: $(LIB_NAME) $(TEST_BINS)
+
+format:
+	find $(SRC_DIR) $(TEST_DIR) $(INC_DIR) -name "*.c" -o -name "*.h" | xargs clang-format -i
+
+debug: CFLAGS = -I./include -g -O0 -fsanitize=address,undefined -Wall -Wextra -fPIC
+debug: clean all
+
+$(LIB_NAME): $(OBJS)
+	ar rcs $@ $^
+
+$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
+	@mkdir -p $(dir $@)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+test_%: $(TEST_DIR)/test_%.c $(LIB_NAME)
+	$(CC) $(CFLAGS) $< $(LIB_NAME) -o $@ $(LDFLAGS)
+
+test: $(TEST_BINS)
+	@for test in $(TEST_BINS); do ./$$test || exit 1; done
+	@echo "ALL TESTS PASSED"
+
+clean:
+	rm -rf $(OBJ_DIR) *.a test_*
+
+.PHONY: all debug test clean format

python_libphash-1.0.0/native/libphash/README.md

@@ -0,0 +1,76 @@
+# libphash
+
+A high-performance, portable C library for Perceptual Hashing. Designed for image similarity detection with zero external dependencies (except for the included `stb_image`).
+
+## Features
+
+- **Multiple Algorithms**:
+  - `aHash` (Average Hash): Fast, based on average intensity.
+  - `dHash` (Difference Hash): Fast, resistant to aspect ratio changes.
+  - `pHash` (Perceptual Hash): Robust, uses Discrete Cosine Transform (DCT).
+- **FFI-Friendly**: Clean C API with opaque pointers, making it easy to wrap in Python (ctypes/cffi), Rust, or Node.js.
+- **Thread-Safe**: No global state.
+- **Cross-Platform**: Compatible with GCC, Clang, and MSVC.
+
+## Architecture
+
+The library follows a strict separation between public API and internal implementation:
+- `include/libphash.h`: Public interface and error codes.
+- `src/internal.h`: Internal structures and image processing helpers.
+- `src/hashes/`: Core hash algorithm implementations.
+
+## Building
+
+To build the static library and run tests, you only need `make` and a C compiler:
+
+```bash
+# Build the library (libphash.a)
+make
+
+# Run all tests
+make test
+
+# Clean build artifacts
+make clean
+```
+
+## Usage Example (C)
+
+```c
+#include <libphash.h>
+#include <stdio.h>
+
+int main() {
+    ph_context_t *ctx = NULL;
+    uint64_t hash1, hash2;
+
+    ph_create(&ctx);
+    
+    ph_load_from_file(ctx, "image1.jpg");
+    ph_compute_phash(ctx, &hash1);
+    
+    ph_load_from_file(ctx, "image2.jpg");
+    ph_compute_phash(ctx, &hash2);
+
+    int distance = ph_hamming_distance(hash1, hash2);
+    printf("Hamming Distance: %d\n", distance);
+
+    if (distance < 5) {
+        printf("Images are very similar!\n");
+    }
+
+    ph_free(ctx);
+    return 0;
+}
+```
+
+## FFI Integration Notes
+
+- **Opaque Pointer**: `ph_context_t` is an opaque struct. In high-level languages, treat it as a `void*` or `uintptr_t`.
+- **Memory Management**: Always call `ph_free()` to release image data and context memory allocated on the C heap.
+- **Error Handling**: Functions return `ph_error_t` (int). `0` always indicates `PH_SUCCESS`.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+Includes `stb_image` by Sean Barrett (Public Domain/MIT).

python_libphash-1.0.0/native/libphash/include/libphash.h

@@ -0,0 +1,168 @@
+#ifndef LIBPHASH_H
+#define LIBPHASH_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * @file libphash.h
+ * @brief High-performance, thread-safe perceptual hashing library.
+ *
+ * Designed for easy FFI integration (Python, Rust, Node.js).
+ * All functions are thread-safe provided they operate on different contexts.
+ */
+
+// --- Platform & Export Macros ---
+#ifndef PH_API
+#if defined(_WIN32) || defined(__CYGWIN__)
+#ifdef LIBPHASH_EXPORTS
+#define PH_API __declspec(dllexport)
+#else
+#define PH_API __declspec(dllimport)
+#endif
+#else
+#if __GNUC__ >= 4
+#define PH_API __attribute__((visibility("default")))
+#else
+#define PH_API
+#endif
+#endif
+#endif
+
+#ifndef PH_NODISCARD
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
+#define PH_NODISCARD [[nodiscard]]
+#elif defined(__GNUC__) || defined(__clang__)
+#define PH_NODISCARD __attribute__((warn_unused_result))
+#elif defined(_MSC_VER) && _MSC_VER >= 1700
+#define PH_NODISCARD _Check_return_
+#else
+#define PH_NODISCARD
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// --- Constants ---
+
+/** Maximum size in bytes for any digest supported by the library (64 bytes =
+ * 512 bits). */
+#define PH_DIGEST_MAX_BYTES 64
+
+// --- Error Codes ---
+
+typedef enum {
+    PH_SUCCESS = 0,
+    PH_ERR_ALLOCATION_FAILED = -1,
+    PH_ERR_DECODE_FAILED = -2,
+    PH_ERR_INVALID_ARGUMENT = -3,
+    PH_ERR_NOT_IMPLEMENTED = -4,
+    PH_ERR_EMPTY_IMAGE = -5,
+} ph_error_t;
+
+// --- Types ---
+
+/**
+ * @brief Opaque context structure holding image data and configuration.
+ * Treat this as a void* in FFI.
+ */
+typedef struct ph_context ph_context_t;
+
+/**
+ * @brief A flat structure representing a hash digest.
+ *
+ * @note This structure is FFI-safe and can be allocated on the stack.
+ * It does not own any heap memory.
+ */
+typedef struct {
+    uint8_t data[PH_DIGEST_MAX_BYTES]; ///< The raw hash bytes.
+    uint8_t size;                      ///< Number of valid bytes in 'data'.
+    uint8_t reserved[7];               ///< Padding for 64-bit alignment.
+} ph_digest_t;
+
+// --- Lifecycle & Configuration ---
+
+/**
+ * @brief Returns the library version string (e.g., "1.2.0").
+ */
+PH_API const char *ph_version(void);
+
+/**
+ * @brief Allocates a new context with default settings (Gamma 2.2).
+ * @param[out] out_ctx Pointer to the created context.
+ */
+PH_API PH_NODISCARD ph_error_t ph_create(ph_context_t **out_ctx);
+
+/**
+ * @brief Frees the context and all associated image memory.
+ * @param ctx The context to free. Safe to pass NULL.
+ */
+PH_API void ph_free(ph_context_t *ctx);
+
+/**
+ * @brief Sets the gamma correction value for the context.
+ *
+ * Recomputes the internal lookup table (LUT).
+ * Default value is 2.2.
+ *
+ * @param ctx The context.
+ * @param gamma The gamma value (e.g., 2.2). Must be > 0.
+ */
+PH_API void ph_context_set_gamma(ph_context_t *ctx, float gamma);
+
+// --- Loading ---
+
+/**
+ * @brief Loads an image from a file path.
+ * @param ctx The context.
+ * @param filepath Path to the image file.
+ */
+PH_API PH_NODISCARD ph_error_t ph_load_from_file(ph_context_t *ctx, const char *filepath);
+
+/**
+ * @brief Loads an image from a memory buffer.
+ * @param ctx The context.
+ * @param buffer Pointer to the raw file data (e.g., JPEG bytes).
+ * @param length Size of the buffer.
+ */
+PH_API PH_NODISCARD ph_error_t ph_load_from_memory(ph_context_t *ctx, const uint8_t *buffer,
+                                                   size_t length);
+
+// --- uint64_t Hash Algorithms ---
+
+PH_API PH_NODISCARD ph_error_t ph_compute_ahash(ph_context_t *ctx, uint64_t *out_hash);
+PH_API PH_NODISCARD ph_error_t ph_compute_dhash(ph_context_t *ctx, uint64_t *out_hash);
+PH_API PH_NODISCARD ph_error_t ph_compute_phash(ph_context_t *ctx, uint64_t *out_hash);
+PH_API PH_NODISCARD ph_error_t ph_compute_whash(ph_context_t *ctx, uint64_t *out_hash);
+PH_API PH_NODISCARD ph_error_t ph_compute_mhash(ph_context_t *ctx, uint64_t *out_hash);
+
+// --- Digest Hash Algorithms ---
+
+/**
+ * @brief Computes Block Mean Hash (BMH). Returns a 256-bit (32-byte) digest.
+ */
+PH_API PH_NODISCARD ph_error_t ph_compute_bmh(ph_context_t *ctx, ph_digest_t *out_digest);
+
+/**
+ * @brief Computes Color Hash. Returns a digest representing color distribution.
+ */
+PH_API PH_NODISCARD ph_error_t ph_compute_color_hash(ph_context_t *ctx, ph_digest_t *out_digest);
+
+/**
+ * @brief Computes Radial Hash. Robust against rotation. Uses context Gamma.
+ */
+PH_API PH_NODISCARD ph_error_t ph_compute_radial_hash(ph_context_t *ctx, ph_digest_t *out_digest);
+
+// --- Comparison Functions ---
+
+PH_API int ph_hamming_distance(uint64_t hash1, uint64_t hash2);
+PH_API int ph_hamming_distance_digest(const ph_digest_t *a, const ph_digest_t *b);
+PH_API double ph_l2_distance(const ph_digest_t *a, const ph_digest_t *b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // LIBPHASH_H