python-libphash 1.1.0__tar.gz → 1.2.0__tar.gz

{python_libphash-1.1.0/src/python_libphash.egg-info → python_libphash-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-libphash
-Version: 1.1.0
+Version: 1.2.0
 Summary: High-performance perceptual hashing library (CFFI bindings)
 Author-email: gudoshnikovn <gudoshnikov-na@yandex.ru>
 License-Expression: MIT
@@ -20,7 +20,7 @@ Dynamic: license-file
 
 # python-libphash
 
-High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash) v1.3.0, a C library for perceptual image hashing.
+High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash) v1.6.1, 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/)
@@ -48,15 +48,30 @@ High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/
 *   A C compiler (GCC/Clang or MSVC)
 *   Python 3.8 or higher
 
+### Install from PyPI
+```bash
+pip install libphash
+# or using uv
+uv add libphash
+```
+
 ### Install from source
 ```bash
 git clone --recursive https://github.com/yourusername/python-libphash.git
 cd python-libphash
 pip install .
+# or using uv
+uv pip install .
 ```
 
 ## Quick Start
 
+### Quick Start (CLI)
+You can quickly compute a hash from the command line after installation:
+```bash
+python -m libphash.utils --path photo.jpg --method phash
+```
+
 ### Basic Usage
 ```python
 from libphash import ImageContext, HashMethod, hamming_distance
@@ -76,6 +91,26 @@ distance = compare_images("image1.jpg", "image2.jpg", method=HashMethod.PHASH)
 print(f"Hamming Distance: {distance}")
 ```
 
+### Advanced Configuration (New in v1.6.1)
+Fine-tune hashing algorithms for specific use cases. Note that hashes generated with different parameters are **not comparable**.
+
+```python
+with ImageContext("photo.jpg") as ctx:
+    # pHash (DCT) resolution
+    ctx.set_phash_params(dct_size=32, reduction_size=8)
+    
+    # Radial Hash precision
+    ctx.set_radial_params(projections=40, samples=128)
+    
+    # Block-based hashes (BMH) grid resolution
+    ctx.set_block_params(block_size=16)
+    
+    # Custom Grayscale weights (R, G, B)
+    ctx.set_gray_weights(38, 75, 15)
+    
+    print(f"Custom pHash: {ctx.phash:016x}")
+```
+
 ### Working with Digests (Advanced Hashes)
 Algorithms like Radial Hash or Color Hash return a `Digest` object instead of a single integer.
 
@@ -101,7 +136,11 @@ with ImageContext("photo_v2.jpg") as ctx2:
 ### `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).
+*   `set_gamma(gamma: float)`: Set gamma correction.
+*   `set_gray_weights(r, g, b)`: Set custom RGB weights for grayscale conversion.
+*   `set_phash_params(dct_size, reduction_size)`: Configure pHash DCT resolution.
+*   `set_radial_params(projections, samples)`: Configure Radial Hash precision.
+*   `set_block_params(block_size)`: Configure BMH/mHash grid resolution.
 *   **Properties**: `ahash`, `dhash`, `phash`, `whash`, `mhash` (returns `int`).
 *   **Properties**: `bmh`, `color_hash`, `radial_hash` (returns `Digest`).
 

{python_libphash-1.1.0 → python_libphash-1.2.0}/README.md

@@ -1,6 +1,6 @@
 # python-libphash
 
-High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash) v1.3.0, a C library for perceptual image hashing.
+High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash) v1.6.1, 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/)
@@ -28,15 +28,30 @@ High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/
 *   A C compiler (GCC/Clang or MSVC)
 *   Python 3.8 or higher
 
+### Install from PyPI
+```bash
+pip install libphash
+# or using uv
+uv add libphash
+```
+
 ### Install from source
 ```bash
 git clone --recursive https://github.com/yourusername/python-libphash.git
 cd python-libphash
 pip install .
+# or using uv
+uv pip install .
 ```
 
 ## Quick Start
 
+### Quick Start (CLI)
+You can quickly compute a hash from the command line after installation:
+```bash
+python -m libphash.utils --path photo.jpg --method phash
+```
+
 ### Basic Usage
 ```python
 from libphash import ImageContext, HashMethod, hamming_distance
@@ -56,6 +71,26 @@ distance = compare_images("image1.jpg", "image2.jpg", method=HashMethod.PHASH)
 print(f"Hamming Distance: {distance}")
 ```
 
+### Advanced Configuration (New in v1.6.1)
+Fine-tune hashing algorithms for specific use cases. Note that hashes generated with different parameters are **not comparable**.
+
+```python
+with ImageContext("photo.jpg") as ctx:
+    # pHash (DCT) resolution
+    ctx.set_phash_params(dct_size=32, reduction_size=8)
+    
+    # Radial Hash precision
+    ctx.set_radial_params(projections=40, samples=128)
+    
+    # Block-based hashes (BMH) grid resolution
+    ctx.set_block_params(block_size=16)
+    
+    # Custom Grayscale weights (R, G, B)
+    ctx.set_gray_weights(38, 75, 15)
+    
+    print(f"Custom pHash: {ctx.phash:016x}")
+```
+
 ### Working with Digests (Advanced Hashes)
 Algorithms like Radial Hash or Color Hash return a `Digest` object instead of a single integer.
 
@@ -81,7 +116,11 @@ with ImageContext("photo_v2.jpg") as ctx2:
 ### `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).
+*   `set_gamma(gamma: float)`: Set gamma correction.
+*   `set_gray_weights(r, g, b)`: Set custom RGB weights for grayscale conversion.
+*   `set_phash_params(dct_size, reduction_size)`: Configure pHash DCT resolution.
+*   `set_radial_params(projections, samples)`: Configure Radial Hash precision.
+*   `set_block_params(block_size)`: Configure BMH/mHash grid resolution.
 *   **Properties**: `ahash`, `dhash`, `phash`, `whash`, `mhash` (returns `int`).
 *   **Properties**: `bmh`, `color_hash`, `radial_hash` (returns `Digest`).
 

{python_libphash-1.1.0 → python_libphash-1.2.0}/native/libphash/Makefile

@@ -46,6 +46,10 @@ test: $(TEST_BINS)
 	@echo "ALL TESTS PASSED"
 
 clean:
-	rm -rf $(OBJ_DIR) *.a test_*
+	rm -rf $(OBJ_DIR) *.a test_* benchmark
 
-.PHONY: all debug test clean format
+benchmark: tests/benchmark.c $(LIB_NAME)
+	$(CC) $(CFLAGS) $< $(LIB_NAME) -o benchmark $(LDFLAGS)
+	./benchmark
+
+.PHONY: all debug test clean format benchmark

{python_libphash-1.1.0 → python_libphash-1.2.0}/native/libphash/README.md

@@ -29,6 +29,17 @@ Official and community-supported wrappers:
 - **Cross-Platform**: Compatible with GCC, Clang, and MSVC.
 
 
+## Configuration & Tuning
+
+libphash allows fine-tuning algorithms for specific use cases via the context API. Note that changing these values will result in hashes that are **not comparable** to those generated with default settings.
+
+| Function | Default | Description |
+| :--- | :--- | :--- |
+| `ph_context_set_gamma` | 2.2 | Adjusts brightness normalization. |
+| `ph_context_set_gray_weights` | 38,75,15 | Custom RGB-to-Grayscale proportions. |
+| `ph_context_set_phash_params` | 32, 8 | DCT size and reduction size. |
+| `ph_context_set_radial_params` | 40, 128 | Projection count and radial samples. |
+| `ph_context_set_block_params` | 16 | Grid resolution for BMH and mHash. |
 
 ## Architecture
 

{python_libphash-1.1.0 → python_libphash-1.2.0}/native/libphash/include/libphash.h

@@ -112,6 +112,34 @@ PH_API void ph_free(ph_context_t *ctx);
  */
 PH_API void ph_context_set_gamma(ph_context_t *ctx, float gamma);
 
+/**
+ * @brief Sets custom RGB-to-Grayscale weights.
+ *
+ * Input values are automatically normalized to sum to 128 for optimized internal processing.
+ * Default is PH_GRAY_R=38, PH_GRAY_G=75, PH_GRAY_B=15.
+ */
+PH_API void ph_context_set_gray_weights(ph_context_t *ctx, int r, int g, int b);
+
+/**
+ * @brief Sets pHash parameters.
+ * @param dct_size Size of the DCT matrix (default 32).
+ * @param reduction_size Size of the low-frequency coefficients to keep (default 8).
+ */
+PH_API void ph_context_set_phash_params(ph_context_t *ctx, int dct_size, int reduction_size);
+
+/**
+ * @brief Sets Radial Hash parameters.
+ * @param projections Number of angular projections (default 40).
+ * @param samples Number of radial samples (default 128).
+ */
+PH_API void ph_context_set_radial_params(ph_context_t *ctx, int projections, int samples);
+
+/**
+ * @brief Sets Block-based hash parameters (BMH/mHash).
+ * @param block_size Resolution of the grid (default 16).
+ */
+PH_API void ph_context_set_block_params(ph_context_t *ctx, int block_size);
+
 // --- Loading ---
 
 /**
@@ -161,7 +189,6 @@ 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);
 
-void init_dct_matrix(void);
 #ifdef __cplusplus
 }
 #endif

python_libphash-1.2.0/native/libphash/src/core.c

@@ -0,0 +1,154 @@
+#include "internal.h"
+#include <math.h>
+#include <stdlib.h>
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "../vendor/stb_image.h"
+
+PH_API const char *ph_version(void) { return "1.5.0"; }
+
+PH_API void ph_context_set_gamma(ph_context_t *ctx, float gamma) {
+    if (!ctx || gamma <= PH_GAMMA_EPSILON)
+        return;
+
+    ctx->gamma = gamma;
+    // Precompute LUT for O(1) access during processing
+    for (int i = 0; i < 256; i++) {
+        double val = i / 255.0;
+        // Standard gamma correction: value^(1/gamma)
+        double res = pow(val, 1.0 / (double)gamma) * 255.0;
+        ctx->gamma_lut[i] = (uint8_t)(res > 255.0 ? 255.0 : res);
+    }
+}
+
+PH_API void ph_context_set_gray_weights(ph_context_t *ctx, int r, int g, int b) {
+    if (!ctx)
+        return;
+
+    int sum = r + g + b;
+    if (sum <= 0) {
+        // Fallback to defaults if invalid
+        ctx->gray_r = PH_GRAY_R;
+        ctx->gray_g = PH_GRAY_G;
+        ctx->gray_b = PH_GRAY_B;
+        return;
+    }
+
+    // Normalize to sum 128 for the >> 7 shift
+    ctx->gray_r = (r * 128) / sum;
+    ctx->gray_g = (g * 128) / sum;
+    ctx->gray_b = 128 - ctx->gray_r - ctx->gray_g;
+}
+
+PH_API void ph_context_set_phash_params(ph_context_t *ctx, int dct_size, int reduction_size) {
+    if (!ctx || dct_size <= 0 || reduction_size <= 0 || reduction_size > dct_size)
+        return;
+    ctx->phash_dct_size = dct_size;
+    ctx->phash_reduction_size = reduction_size;
+}
+
+PH_API void ph_context_set_radial_params(ph_context_t *ctx, int projections, int samples) {
+    if (!ctx || projections <= 0 || samples <= 0)
+        return;
+    ctx->radial_projections = projections;
+    ctx->radial_samples = samples;
+}
+
+PH_API void ph_context_set_block_params(ph_context_t *ctx, int block_size) {
+    if (!ctx || block_size <= 0)
+        return;
+    ctx->block_size = block_size;
+}
+
+PH_API ph_error_t ph_create(ph_context_t **out_ctx) {
+    if (!out_ctx)
+        return PH_ERR_INVALID_ARGUMENT;
+
+    ph_context_t *ctx = (ph_context_t *)calloc(1, sizeof(ph_context_t));
+    if (!ctx)
+        return PH_ERR_ALLOCATION_FAILED;
+
+    ctx->data = NULL;
+    ctx->gray_data = NULL;
+    ctx->width = 0;
+    ctx->height = 0;
+    ctx->channels = 0;
+    ctx->is_loaded = 0;
+
+    /* Defaults */
+    ctx->gray_r = PH_GRAY_R;
+    ctx->gray_g = PH_GRAY_G;
+    ctx->gray_b = PH_GRAY_B;
+    ctx->phash_dct_size = PH_DCT_SIZE;
+    ctx->phash_reduction_size = PH_DCT_REDUCTION_SIZE;
+    ctx->radial_projections = PH_RADIAL_PROJECTIONS;
+    ctx->radial_samples = PH_RADIAL_SAMPLES;
+    ctx->block_size = PH_BLOCK_SIZE;
+
+    ph_context_set_gamma(ctx, PH_DEFAULT_GAMMA);
+
+    *out_ctx = ctx;
+    return PH_SUCCESS;
+}
+PH_API void ph_free(ph_context_t *ctx) {
+    if (ctx) {
+        if (ctx->data)
+            stbi_image_free(ctx->data);
+        if (ctx->gray_data)
+            free(ctx->gray_data);
+        if (ctx->scratchpad)
+            free(ctx->scratchpad);
+        free(ctx);
+    }
+}
+
+uint8_t *ph_get_scratchpad(ph_context_t *ctx, size_t size) {
+    if (!ctx || size == 0)
+        return NULL;
+
+    if (ctx->scratchpad_size < size) {
+        uint8_t *new_ptr = (uint8_t *)realloc(ctx->scratchpad, size);
+        if (!new_ptr)
+            return NULL;
+        ctx->scratchpad = new_ptr;
+        ctx->scratchpad_size = size;
+    }
+    return ctx->scratchpad;
+}
+
+PH_API ph_error_t ph_load_from_file(ph_context_t *ctx, const char *filepath) {
+    if (!ctx || !filepath)
+        return PH_ERR_INVALID_ARGUMENT;
+    if (ctx->data)
+        stbi_image_free(ctx->data);
+    if (ctx->gray_data) {
+        free(ctx->gray_data);
+        ctx->gray_data = NULL;
+    }
+
+    ctx->data = stbi_load(filepath, &ctx->width, &ctx->height, &ctx->channels, 0);
+    if (!ctx->data)
+        return PH_ERR_DECODE_FAILED;
+
+    ctx->is_loaded = 1;
+    return PH_SUCCESS;
+}
+
+PH_API ph_error_t ph_load_from_memory(ph_context_t *ctx, const uint8_t *buffer, size_t length) {
+    if (!ctx || !buffer || length == 0)
+        return PH_ERR_INVALID_ARGUMENT;
+    if (ctx->data)
+        stbi_image_free(ctx->data);
+    if (ctx->gray_data) {
+        free(ctx->gray_data);
+        ctx->gray_data = NULL;
+    }
+
+    ctx->data =
+        stbi_load_from_memory(buffer, (int)length, &ctx->width, &ctx->height, &ctx->channels, 0);
+    if (!ctx->data)
+        return PH_ERR_DECODE_FAILED;
+
+    ctx->is_loaded = 1;
+    return PH_SUCCESS;
+}

python_libphash-1.2.0/native/libphash/src/hashes/ahash.c

@@ -0,0 +1,35 @@
+#include "../internal.h"
+#include <stdlib.h>
+
+PH_API ph_error_t ph_compute_ahash(ph_context_t *ctx, uint64_t *out_hash) {
+    if (!ctx || !ctx->is_loaded || !out_hash) {
+        return PH_ERR_INVALID_ARGUMENT;
+    }
+
+    size_t gray_size = (size_t)ctx->width * ctx->height;
+    uint8_t *gray_full = ph_get_scratchpad(ctx, gray_size);
+    if (!gray_full) {
+        return PH_ERR_ALLOCATION_FAILED;
+    }
+    ph_to_grayscale(ctx, ctx->data, ctx->width, ctx->height, ctx->channels, gray_full);
+
+    uint8_t hash_input[PH_CORE_HASH_SIZE * PH_CORE_HASH_SIZE];
+    ph_resize_bilinear(gray_full, ctx->width, ctx->height, hash_input, PH_CORE_HASH_SIZE, PH_CORE_HASH_SIZE);
+
+    uint64_t total_sum = 0;
+    int num_pixels = PH_CORE_HASH_SIZE * PH_CORE_HASH_SIZE;
+    for (int i = 0; i < num_pixels; i++) {
+        total_sum += hash_input[i];
+    }
+    uint8_t avg = (uint8_t)(total_sum / num_pixels);
+
+    uint64_t hash = 0;
+    for (int i = 0; i < num_pixels; i++) {
+        if (hash_input[i] >= avg) {
+            hash |= (1ULL << i);
+        }
+    }
+
+    *out_hash = hash;
+    return PH_SUCCESS;
+}

python_libphash-1.2.0/native/libphash/src/hashes/bmh.c

@@ -0,0 +1,51 @@
+#include "../internal.h"
+#include <stdlib.h>
+#include <string.h>
+
+PH_API ph_error_t ph_compute_bmh(ph_context_t *ctx, ph_digest_t *out_digest) {
+    if (!ctx || !ctx->is_loaded || !out_digest) {
+        return PH_ERR_INVALID_ARGUMENT;
+    }
+
+    int block_size = ctx->block_size;
+    int total_pixels = block_size * block_size;
+
+    // Clear digest and set size
+    memset(out_digest, 0, sizeof(ph_digest_t));
+    out_digest->size = (uint8_t)((total_pixels + 7) / 8);
+    if (out_digest->size > PH_DIGEST_MAX_BYTES)
+        out_digest->size = PH_DIGEST_MAX_BYTES;
+
+    size_t gray_size = (size_t)ctx->width * ctx->height;
+    if (!PH_SAFE_ALLOC_SIZE(ctx->width, ctx->height))
+        return PH_ERR_ALLOCATION_FAILED;
+
+    /* Scratchpad:
+     * 1. gray_full: img_size
+     * 2. block_data: total_pixels
+     */
+    uint8_t *scratch = ph_get_scratchpad(ctx, gray_size + total_pixels);
+    if (!scratch)
+        return PH_ERR_ALLOCATION_FAILED;
+
+    uint8_t *full_gray = scratch;
+    uint8_t *block_data = scratch + gray_size;
+
+    ph_to_grayscale(ctx, ctx->data, ctx->width, ctx->height, ctx->channels, full_gray);
+    ph_resize_box(full_gray, ctx->width, ctx->height, block_data, block_size, block_size);
+
+    uint64_t total_sum = 0;
+    for (int i = 0; i < total_pixels; i++) {
+        total_sum += block_data[i];
+    }
+    uint8_t avg = (uint8_t)(total_sum / total_pixels);
+
+    int max_bits = out_digest->size * 8;
+    for (int i = 0; i < total_pixels && i < max_bits; i++) {
+        if (block_data[i] >= avg) {
+            out_digest->data[i / 8] |= (1 << (i % 8));
+        }
+    }
+
+    return PH_SUCCESS;
+}

{python_libphash-1.1.0 → python_libphash-1.2.0}/native/libphash/src/hashes/color_hash.c

@@ -8,48 +8,47 @@ PH_API ph_error_t ph_compute_color_hash(ph_context_t *ctx, ph_digest_t *out_dige
         return PH_ERR_INVALID_ARGUMENT;
     }
 
-    /* We calculate 3 color moments for 3 channels (R, G, B) = 9 values total.
-     * Each value is stored as 1 byte (9 bytes required).
+    /* We calculate color moments for RGB channels. 
+     * Moments are stored as bytes: [MeanR, StdDevR, SkewR, MeanG, ...]
      */
     memset(out_digest, 0, sizeof(ph_digest_t));
-    out_digest->size = 9; // Set the actual size in bytes.
+    out_digest->size = PH_COLOR_CHANNELS * PH_COLOR_MOMENTS;
 
-    double mean[3] = {0}, std_dev[3] = {0}, skew[3] = {0};
+    double mean[PH_COLOR_CHANNELS] = {0}, std_dev[PH_COLOR_CHANNELS] = {0}, skew[PH_COLOR_CHANNELS] = {0};
     int num_pixels = ctx->width * ctx->height;
 
     /* Step 1: Calculate the Arithmetic Mean */
     for (int i = 0; i < num_pixels; i++) {
-        for (int c = 0; c < 3; c++) {
+        for (int c = 0; c < PH_COLOR_CHANNELS; c++) {
             mean[c] += ctx->data[i * ctx->channels + c];
         }
     }
-    for (int c = 0; c < 3; c++) {
+    for (int c = 0; c < PH_COLOR_CHANNELS; c++) {
         mean[c] /= num_pixels;
     }
 
-    /* Step 2: Calculate Standard Deviation (2nd moment) and Skewness (3rd moment)
-     */
+    /* Step 2: Calculate Standard Deviation (2nd moment) and Skewness (3rd moment) */
     for (int i = 0; i < num_pixels; i++) {
-        for (int c = 0; c < 3; c++) {
+        for (int c = 0; c < PH_COLOR_CHANNELS; c++) {
             double diff = ctx->data[i * ctx->channels + c] - mean[c];
             std_dev[c] += diff * diff;
             skew[c] += diff * diff * diff;
         }
     }
 
-    for (int c = 0; c < 3; c++) {
+    for (int c = 0; c < PH_COLOR_CHANNELS; c++) {
         /* Standard deviation normalization */
         std_dev[c] = sqrt(std_dev[c] / num_pixels);
 
         /* Cube root for skewness normalization */
         skew[c] = cbrt(skew[c] / num_pixels);
 
-        /* * Step 3: Write to digest.
+        /* Step 3: Write to digest.
          * Moments are mapped to 0-255 range and stored as bytes.
          */
-        out_digest->data[c * 3 + 0] = (uint8_t)mean[c];
-        out_digest->data[c * 3 + 1] = (uint8_t)fmin(255.0, std_dev[c]);
-        out_digest->data[c * 3 + 2] = (uint8_t)fmin(255.0, fabs(skew[c]));
+        out_digest->data[c * PH_COLOR_MOMENTS + 0] = (uint8_t)mean[c];
+        out_digest->data[c * PH_COLOR_MOMENTS + 1] = (uint8_t)fmin(255.0, std_dev[c]);
+        out_digest->data[c * PH_COLOR_MOMENTS + 2] = (uint8_t)fmin(255.0, fabs(skew[c]));
     }
 
     return PH_SUCCESS;

python_libphash-1.2.0/native/libphash/src/hashes/dhash.c

@@ -0,0 +1,32 @@
+#include "../internal.h"
+#include <stdlib.h>
+
+PH_API ph_error_t ph_compute_dhash(ph_context_t *ctx, uint64_t *out_hash) {
+    if (!ctx || !ctx->is_loaded || !out_hash) {
+        return PH_ERR_INVALID_ARGUMENT;
+    }
+
+    size_t gray_size = (size_t)ctx->width * ctx->height;
+    uint8_t *gray_full = ph_get_scratchpad(ctx, gray_size);
+    if (!gray_full) {
+        return PH_ERR_ALLOCATION_FAILED;
+    }
+    ph_to_grayscale(ctx, ctx->data, ctx->width, ctx->height, ctx->channels, gray_full);
+
+    uint8_t hash_input[(PH_CORE_HASH_SIZE + 1) * PH_CORE_HASH_SIZE];
+    ph_resize_bilinear(gray_full, ctx->width, ctx->height, hash_input, PH_CORE_HASH_SIZE + 1,
+                       PH_CORE_HASH_SIZE);
+
+    uint64_t hash = 0;
+    for (int row = 0; row < PH_CORE_HASH_SIZE; row++) {
+        for (int col = 0; col < PH_CORE_HASH_SIZE; col++) {
+            if (hash_input[row * (PH_CORE_HASH_SIZE + 1) + col] <
+                hash_input[row * (PH_CORE_HASH_SIZE + 1) + col + 1]) {
+                hash |= (1ULL << (row * PH_CORE_HASH_SIZE + col));
+            }
+        }
+    }
+
+    *out_hash = hash;
+    return PH_SUCCESS;
+}

python_libphash-1.2.0/native/libphash/src/hashes/mhash.c

@@ -0,0 +1,47 @@
+#include "../internal.h"
+#include <stdlib.h>
+
+PH_API ph_error_t ph_compute_mhash(ph_context_t *ctx, uint64_t *out_hash) {
+    if (!ctx || !ctx->is_loaded || !out_hash)
+        return PH_ERR_INVALID_ARGUMENT;
+
+    int block_size = ctx->block_size;
+    size_t gray_size = (size_t)ctx->width * ctx->height;
+    if (!PH_SAFE_ALLOC_SIZE(ctx->width, ctx->height))
+        return PH_ERR_ALLOCATION_FAILED;
+
+    /* Use scratchpad for:
+     * 1. full_gray: img_size
+     * 2. block_data: block_size * block_size
+     */
+    uint8_t *scratch = ph_get_scratchpad(ctx, gray_size + (size_t)block_size * block_size);
+    if (!scratch)
+        return PH_ERR_ALLOCATION_FAILED;
+
+    uint8_t *full_gray = scratch;
+    uint8_t *block_data = scratch + gray_size;
+
+    ph_to_grayscale(ctx, ctx->data, ctx->width, ctx->height, ctx->channels, full_gray);
+    ph_resize_box(full_gray, ctx->width, ctx->height, block_data, block_size, block_size);
+
+    // 2. Simple 3x3 Laplacian Kernel for edge detection
+    uint64_t hash = 0;
+    int bit_idx = 0;
+    
+    /* We sample the edges. For 16x16 block, we had a 7x7 grid (step=2).
+     * To fit into uint64_t, we need at most 64 bits (8x8).
+     */
+    int step = (block_size > 8) ? 2 : 1;
+    for (int y = 1; y < block_size - 1 && bit_idx < 64; y += step) {
+        for (int x = 1; x < block_size - 1 && bit_idx < 64; x += step) {
+            int center = block_data[y * block_size + x] * 4;
+            int neighbors = block_data[(y - 1) * block_size + x] + block_data[(y + 1) * block_size + x] +
+                            block_data[y * block_size + (x - 1)] + block_data[y * block_size + (x + 1)];
+            if (center - neighbors > 0)
+                hash |= (1ULL << bit_idx);
+            bit_idx++;
+        }
+    }
+    *out_hash = hash;
+    return PH_SUCCESS;
+}