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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-libphash
-Version: 1.0.3
+Version: 1.1.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), a C library for perceptual image hashing.
+High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash) v1.3.0, 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/)

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

@@ -1,6 +1,6 @@
 # python-libphash
 
-High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash), a C library for perceptual image hashing.
+High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash) v1.3.0, 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/)

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

@@ -2,16 +2,34 @@
 
 A high-performance, portable C library for Perceptual Hashing. Designed for image similarity detection with zero external dependencies (except for the included `stb_image`).
 
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Language Bindings
+
+Official and community-supported wrappers:
+- **Python**: [python-libphash](https://github.com/gudoshnikovn/python-libphash) (`pip install python-libphash`)
+
+---
+
 ## 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.
+- **Comprehensive Algorithm Suite**:
+  - `aHash` (Average Hash): Fast, based on average pixel intensity.
+  - `dHash` (Difference Hash): Extremely fast, resistant to aspect ratio changes.
+  - `pHash` (Perceptual Hash): High precision, uses optimized Discrete Cosine Transform (DCT).
+  - `mHash` (Median Hash): Robust against non-linear image adjustments.
+  - `bmh` (Block Mean Hash): Divides image into blocks for localized analysis.
+  - `wHash` (Wavelet Hash): Frequency-based hashing using Wavelet transform (if implemented).
+- **High Performance**: 
+  - Internal **Bilinear Interpolation** for high-quality image scaling.
+  - **Lazy-loading** grayscale cache to avoid redundant conversions.
+  - Pre-computed trigonometric tables for DCT.
+- **FFI-Friendly**: Clean C API with opaque pointers, optimized for Python (ctypes/cffi), Rust, or Node.js.
+- **Thread-Safe**: No global state (optimized one-time internal initialization).
 - **Cross-Platform**: Compatible with GCC, Clang, and MSVC.
 
+
+
 ## Architecture
 
 The library follows a strict separation between public API and internal implementation:
@@ -32,6 +50,7 @@ make test
 
 # Clean build artifacts
 make clean
+
 ```
 
 ## Usage Example (C)
@@ -46,12 +65,15 @@ int main() {
 
     ph_create(&ctx);
     
+    // Load and compute pHash for first image
     ph_load_from_file(ctx, "image1.jpg");
     ph_compute_phash(ctx, &hash1);
     
+    // Load and compute pHash for second image
     ph_load_from_file(ctx, "image2.jpg");
     ph_compute_phash(ctx, &hash2);
 
+    // Calculate similarity
     int distance = ph_hamming_distance(hash1, hash2);
     printf("Hamming Distance: %d\n", distance);
 
@@ -62,15 +84,17 @@ int main() {
     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`.
+* **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` (PH_SUCCESS) indicates 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.3 → python_libphash-1.1.0}/native/libphash/include/libphash.h

@@ -161,6 +161,7 @@ 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.0.3 → python_libphash-1.1.0}/native/libphash/src/core.c

@@ -28,17 +28,26 @@ PH_API ph_error_t ph_create(ph_context_t **out_ctx) {
     if (!ctx)
         return PH_ERR_ALLOCATION_FAILED;
 
-    // Initialize default gamma (2.2)
+    init_dct_matrix();
+
+    ctx->data = NULL;
+    ctx->gray_data = NULL;
+    ctx->width = 0;
+    ctx->height = 0;
+    ctx->channels = 0;
+    ctx->is_loaded = 0;
+
     ph_context_set_gamma(ctx, 2.2f);
 
     *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);
         free(ctx);
     }
 }

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

@@ -0,0 +1,32 @@
+#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;
+    }
+
+    uint8_t *gray_full = ph_get_gray(ctx);
+    if (!gray_full) {
+        return PH_ERR_ALLOCATION_FAILED;
+    }
+
+    uint8_t tiny[64];
+    ph_resize_bilinear(gray_full, ctx->width, ctx->height, tiny, 8, 8);
+
+    uint64_t total_sum = 0;
+    for (int i = 0; i < 64; i++) {
+        total_sum += tiny[i];
+    }
+    uint8_t avg = (uint8_t)(total_sum / 64);
+
+    uint64_t hash = 0;
+    for (int i = 0; i < 64; i++) {
+        if (tiny[i] >= avg) {
+            hash |= (1ULL << i);
+        }
+    }
+
+    *out_hash = hash;
+    return PH_SUCCESS;
+}

{python_libphash-1.0.3 → python_libphash-1.1.0}/native/libphash/src/hashes/dhash.c

@@ -2,24 +2,27 @@
 #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)
+    if (!ctx || !ctx->is_loaded || !out_hash) {
         return PH_ERR_INVALID_ARGUMENT;
-    uint8_t gray[72]; // 9x8
-    uint8_t *full_gray = malloc(ctx->width * ctx->height);
-    if (!full_gray)
+    }
+
+    uint8_t *gray_full = ph_get_gray(ctx);
+    if (!gray_full) {
         return PH_ERR_ALLOCATION_FAILED;
+    }
 
-    ph_to_grayscale(ctx->data, ctx->width, ctx->height, ctx->channels, full_gray);
-    ph_resize_grayscale(full_gray, ctx->width, ctx->height, gray, 9, 8);
-    free(full_gray);
+    uint8_t tiny[72];
+    ph_resize_bilinear(gray_full, ctx->width, ctx->height, tiny, 9, 8);
 
     uint64_t hash = 0;
     for (int row = 0; row < 8; row++) {
         for (int col = 0; col < 8; col++) {
-            if (gray[row * 9 + col] < gray[row * 9 + col + 1])
+            if (tiny[row * 9 + col] < tiny[row * 9 + col + 1]) {
                 hash |= (1ULL << (row * 8 + col));
+            }
         }
     }
+
     *out_hash = hash;
     return PH_SUCCESS;
 }

python_libphash-1.1.0/native/libphash/src/hashes/phash.c

@@ -0,0 +1,78 @@
+#include "../internal.h"
+#include <math.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+static double dct_matrix[32][32];
+static atomic_bool dct_globally_initialized = false;
+
+void init_dct_matrix(void) {
+    if (atomic_exchange(&dct_globally_initialized, true)) {
+        return;
+    }
+    double c = sqrt(1.0 / 32.0);
+    for (int j = 0; j < 32; j++)
+        dct_matrix[0][j] = c;
+
+    c = sqrt(2.0 / 32.0);
+    for (int i = 1; i < 32; i++) {
+        for (int j = 0; j < 32; j++) {
+            dct_matrix[i][j] = c * cos(M_PI * i * (j + 0.5) / 32.0);
+        }
+    }
+    dct_globally_initialized = true;
+}
+
+PH_API ph_error_t ph_compute_phash(ph_context_t *ctx, uint64_t *out_hash) {
+    if (!ctx || !ctx->is_loaded || !out_hash)
+        return PH_ERR_INVALID_ARGUMENT;
+
+    uint8_t *gray_full = ph_get_gray(ctx);
+    if (!gray_full)
+        return PH_ERR_ALLOCATION_FAILED;
+
+    uint8_t gray32[1024];
+    ph_resize_bilinear(gray_full, ctx->width, ctx->height, gray32, 32, 32);
+
+    double temp[1024], dct_out[1024];
+
+    for (int i = 0; i < 32; i++) {
+        for (int j = 0; j < 32; j++) {
+            double sum = 0;
+            for (int k = 0; k < 32; k++)
+                sum += dct_matrix[j][k] * gray32[i * 32 + k];
+            temp[i * 32 + j] = sum;
+        }
+    }
+    for (int j = 0; j < 32; j++) {
+        for (int i = 0; i < 32; i++) {
+            double sum = 0;
+            for (int k = 0; k < 32; k++)
+                sum += dct_matrix[i][k] * temp[k * 32 + j];
+            dct_out[i * 32 + j] = sum;
+        }
+    }
+
+    double sum_dct = 0;
+    for (int i = 0; i < 8; i++) {
+        for (int j = 0; j < 8; j++) {
+            if (i == 0 && j == 0)
+                continue;
+            sum_dct += dct_out[i * 32 + j];
+        }
+    }
+
+    double avg = sum_dct / 63.0;
+    uint64_t hash = 0;
+    for (int i = 0; i < 8; i++) {
+        for (int j = 0; j < 8; j++) {
+            if (dct_out[i * 32 + j] > avg) {
+                hash |= (1ULL << (i * 8 + j));
+            }
+        }
+    }
+
+    *out_hash = hash;
+    return PH_SUCCESS;
+}

{python_libphash-1.0.3 → python_libphash-1.1.0}/native/libphash/src/image.c

@@ -4,15 +4,54 @@
 #include <stdlib.h>
 #include <string.h>
 
+uint8_t *ph_get_gray(ph_context_t *ctx) {
+    if (!ctx->gray_data && ctx->data) {
+        ctx->gray_data = malloc(ctx->width * ctx->height);
+        if (ctx->gray_data) {
+            ph_to_grayscale(ctx->data, ctx->width, ctx->height, ctx->channels, ctx->gray_data);
+        }
+    }
+    return ctx->gray_data;
+}
+
 void ph_to_grayscale(const uint8_t *src, int w, int h, int channels, uint8_t *dst) {
     for (int i = 0; i < w * h; i++) {
-        uint8_t r = src[i * channels];
-        uint8_t g = src[i * channels + 1];
-        uint8_t b = src[i * channels + 2];
-        dst[i] = (uint8_t)((77 * r + 150 * g + 29 * b) >> 8);
+        uint32_t r = src[i * channels];
+        uint32_t g = src[i * channels + 1];
+        uint32_t b = src[i * channels + 2];
+        dst[i] = (uint8_t)((r * 38 + g * 75 + b * 15) >> 7);
     }
 }
+void ph_resize_bilinear(const uint8_t *src, int sw, int sh, uint8_t *dst, int dw, int dh) {
+    double x_ratio = (dw > 1) ? (double)(sw - 1) / (dw - 1) : 0;
+    double y_ratio = (dh > 1) ? (double)(sh - 1) / (dh - 1) : 0;
+
+    for (int i = 0; i < dh; i++) {
+        for (int j = 0; j < dw; j++) {
+            double x_pos = x_ratio * j;
+            double y_pos = y_ratio * i;
+            int x = (int)x_pos;
+            int y = (int)y_pos;
+
+            double x_diff = x_pos - x;
+            double y_diff = y_pos - y;
 
+            int index = y * sw + x;
+
+            int next_x = (x < sw - 1) ? 1 : 0;
+            int next_y = (y < sh - 1) ? sw : 0;
+
+            uint8_t a = src[index];
+            uint8_t b = src[index + next_x];
+            uint8_t c = src[index + next_y];
+            uint8_t d = src[index + next_y + next_x];
+
+            dst[i * dw + j] =
+                (uint8_t)(a * (1 - x_diff) * (1 - y_diff) + b * (x_diff) * (1 - y_diff) +
+                          c * (y_diff) * (1 - x_diff) + d * (x_diff * y_diff));
+        }
+    }
+}
 void ph_resize_grayscale(const uint8_t *src, int sw, int sh, uint8_t *dst, int dw, int dh) {
     double x_ratio = (double)sw / dw;
     double y_ratio = (double)sh / dh;

{python_libphash-1.0.3 → python_libphash-1.1.0}/native/libphash/src/internal.h

@@ -14,15 +14,20 @@ void ph_to_grayscale(const uint8_t *src, int w, int h, int channels, uint8_t *ds
 /* Resizes a grayscale image */
 void ph_resize_grayscale(const uint8_t *src, int sw, int sh, uint8_t *dst, int dw, int dh);
 
-//* Applies a 3x3 Gaussian Blur to reduce noise */
+/* Applies a 3x3 Gaussian Blur to reduce noise */
 void ph_apply_gaussian_blur(const uint8_t *src, int w, int h, uint8_t *dst);
 
 /* Applies Gamma Correction (gamma=2.2) to normalize brightness */
 void ph_apply_gamma(const ph_context_t *ctx, uint8_t *data, int w, int h);
 
+void ph_resize_bilinear(const uint8_t *src, int sw, int sh, uint8_t *dst, int dw, int dh);
+
+uint8_t *ph_get_gray(ph_context_t *ctx);
+
 /* Internal Context Structure */
 struct ph_context {
     uint8_t *data;
+    uint8_t *gray_data;
     int width;
     int height;
     int channels;

{python_libphash-1.0.3 → python_libphash-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-libphash"
-version = "1.0.3"
+version = "1.1.0"
 description = "High-performance perceptual hashing library (CFFI bindings)"
 readme = "README.md"
 requires-python = ">=3.8"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-libphash
-Version: 1.0.3
+Version: 1.1.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), a C library for perceptual image hashing.
+High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash) v1.3.0, 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/)

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

@@ -1,28 +0,0 @@
-#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;
-    uint8_t gray[64];
-    uint8_t *full_gray = malloc(ctx->width * ctx->height);
-    if (!full_gray)
-        return PH_ERR_ALLOCATION_FAILED;
-
-    ph_to_grayscale(ctx->data, ctx->width, ctx->height, ctx->channels, full_gray);
-    ph_resize_grayscale(full_gray, ctx->width, ctx->height, gray, 8, 8);
-    free(full_gray);
-
-    uint64_t avg = 0;
-    for (int i = 0; i < 64; i++)
-        avg += gray[i];
-    avg /= 64;
-
-    uint64_t hash = 0;
-    for (int i = 0; i < 64; i++) {
-        if (gray[i] >= avg)
-            hash |= (1ULL << i);
-    }
-    *out_hash = hash;
-    return PH_SUCCESS;
-}

python_libphash-1.0.3/native/libphash/src/hashes/phash.c

@@ -1,57 +0,0 @@
-#include "../internal.h"
-#include <math.h>
-#include <stdlib.h>
-
-static void ph_dct_1d(const double *src, double *dst, int size) {
-    for (int i = 0; i < size; i++) {
-        double sum = 0;
-        for (int j = 0; j < size; j++)
-            sum += src[j] * cos(M_PI * i * (j + 0.5) / size);
-        dst[i] = sum * ((i == 0) ? sqrt(1.0 / size) : sqrt(2.0 / size));
-    }
-}
-
-PH_API ph_error_t ph_compute_phash(ph_context_t *ctx, uint64_t *out_hash) {
-    if (!ctx || !ctx->is_loaded || !out_hash)
-        return PH_ERR_INVALID_ARGUMENT;
-    uint8_t gray32[1024];
-    uint8_t *full_gray = malloc(ctx->width * ctx->height);
-    if (!full_gray)
-        return PH_ERR_ALLOCATION_FAILED;
-
-    ph_to_grayscale(ctx->data, ctx->width, ctx->height, ctx->channels, full_gray);
-    ph_resize_grayscale(full_gray, ctx->width, ctx->height, gray32, 32, 32);
-    free(full_gray);
-
-    double dct_in[1024], dct_out[1024], temp[1024];
-    for (int i = 0; i < 1024; i++)
-        dct_in[i] = (double)gray32[i];
-
-    // 2D DCT
-    for (int i = 0; i < 32; i++)
-        ph_dct_1d(&dct_in[i * 32], &temp[i * 32], 32);
-    for (int j = 0; j < 32; j++) {
-        double col_in[32], col_out[32];
-        for (int i = 0; i < 32; i++)
-            col_in[i] = temp[i * 32 + j];
-        ph_dct_1d(col_in, col_out, 32);
-        for (int i = 0; i < 32; i++)
-            dct_out[i * 32 + j] = col_out[i];
-    }
-
-    double sum = 0;
-    for (int i = 0; i < 8; i++)
-        for (int j = 0; j < 8; j++)
-            if (i != 0 || j != 0)
-                sum += dct_out[i * 32 + j];
-
-    double avg = sum / 63.0;
-    uint64_t hash = 0;
-    for (int i = 0; i < 8; i++)
-        for (int j = 0; j < 8; j++)
-            if (dct_out[i * 32 + j] > avg)
-                hash |= (1ULL << (i * 8 + j));
-
-    *out_hash = hash;
-    return PH_SUCCESS;
-}