image-hash-native 1.0.0

package/src/index.hpp

@@ -0,0 +1,246 @@
+#ifndef IMG_HASH_H
+#define IMG_HASH_H
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <immintrin.h>
+#include <vector>
+
+#if defined(_MSC_VER)
+#define FORCE_INLINE __forceinline
+#else
+#define FORCE_INLINE __attribute__((always_inline)) inline
+#endif
+
+namespace img_hash {
+
+static constexpr uint16_t WR = 77;
+static constexpr uint16_t WG = 150;
+static constexpr uint16_t WB = 29;
+
+FORCE_INLINE void accumulate_row_simd(const uint8_t *row, size_t count,
+                                      uint64_t &r, uint64_t &g, uint64_t &b) {
+  size_t i = 0;
+  uint64_t tr = 0, tg = 0, tb = 0;
+
+  for (; i + 4 <= count; i += 4) {
+    const uint8_t *px = row + i * 3;
+    tr += px[0] + px[3] + px[6] + px[9];
+    tg += px[1] + px[4] + px[7] + px[10];
+    tb += px[2] + px[5] + px[8] + px[11];
+  }
+
+  for (; i < count; ++i) {
+    const uint8_t *px = row + i * 3;
+    tr += px[0];
+    tg += px[1];
+    tb += px[2];
+  }
+  r += tr;
+  g += tg;
+  b += tb;
+}
+
+template <size_t N_WIDTH, size_t N_HEIGHT>
+static void resize_fixed(const uint8_t *src, size_t sw, size_t sh, size_t st,
+                         uint8_t *dst) {
+
+  uint32_t x_starts[N_WIDTH];
+  uint32_t x_ends[N_WIDTH];
+
+  for (size_t x = 0; x < N_WIDTH; ++x) {
+    x_starts[x] = x * sw / N_WIDTH;
+    x_ends[x] = std::min((x + 1) * sw / N_WIDTH, sw);
+  }
+
+  for (size_t y = 0; y < N_HEIGHT; ++y) {
+    size_t ys = y * sh / N_HEIGHT;
+    size_t ye = std::min((y + 1) * sh / N_HEIGHT, sh);
+
+    for (size_t x = 0; x < N_WIDTH; ++x) {
+      size_t xs = x_starts[x];
+      size_t xe = x_ends[x];
+
+      uint64_t sum_r = 0, sum_g = 0, sum_b = 0;
+      size_t count = 0;
+
+      for (size_t sy = ys; sy < ye; ++sy) {
+        const uint8_t *row_ptr = src + (sy * st) + (xs * 3);
+        size_t row_width = xe - xs;
+        accumulate_row_simd(row_ptr, row_width, sum_r, sum_g, sum_b);
+        count += row_width;
+      }
+
+      if (count > 0) {
+
+        dst[y * N_WIDTH + x] =
+            static_cast<uint8_t>((WR * (sum_r / count) + WG * (sum_g / count) +
+                                  WB * (sum_b / count)) >>
+                                 8);
+      } else {
+        dst[y * N_WIDTH + x] = 0;
+      }
+    }
+  }
+}
+
+static inline uint64_t aHash(const uint8_t *img, size_t w, size_t h, size_t s) {
+  constexpr size_t N = 8;
+  uint8_t buf[N * N];
+  resize_fixed<N, N>(img, w, h, s, buf);
+
+  uint32_t total = 0;
+  for (int i = 0; i < N * N; ++i)
+    total += buf[i];
+
+  uint8_t avg = static_cast<uint8_t>(total / (N * N));
+  uint64_t hash = 0;
+
+  for (int i = 0; i < N * N; ++i) {
+    if (buf[i] >= avg)
+      hash |= (1ULL << i);
+  }
+  return hash;
+}
+
+static inline uint64_t dHash(const uint8_t *img, size_t w, size_t h, size_t s) {
+  constexpr size_t W = 9, H = 8;
+  uint8_t buf[W * H];
+  resize_fixed<W, H>(img, w, h, s, buf);
+
+  uint64_t hash = 0;
+  size_t bit = 0;
+  for (size_t y = 0; y < H; ++y) {
+    const uint8_t *row = &buf[y * W];
+    for (size_t x = 0; x < H; ++x) {
+      if (row[x] > row[x + 1])
+        hash |= (1ULL << bit);
+      bit++;
+    }
+  }
+  return hash;
+}
+
+static inline uint64_t pHash(const uint8_t *img, size_t w, size_t h, size_t s) {
+  constexpr size_t S = 32;
+  constexpr size_t F = 8;
+
+  alignas(32) uint8_t buf[S * S];
+  resize_fixed<S, S>(img, w, h, s, buf);
+
+  static const auto dct_mat = []() {
+    alignas(32) std::array<float, F * S> mat;
+    constexpr float pi = 3.14159265358979323846f;
+    constexpr float invS = 1.0f / (2.0f * S);
+
+    for (size_t u = 0; u < F; ++u) {
+      float a = (u == 0) ? (1.0f / std::sqrt(2.0f)) : 1.0f;
+      for (size_t x = 0; x < S; ++x)
+        mat[u * S + x] = a * std::cos(((2 * x + 1) * u * pi) * invS);
+    }
+    return mat;
+  }();
+
+  alignas(32) float tmp[F * S];
+
+  for (size_t y = 0; y < S; ++y) {
+    const uint8_t *img_row = &buf[y * S];
+
+    for (size_t u = 0; u < F; ++u) {
+      const float *c = &dct_mat[u * S];
+
+      __m256 sum_vec = _mm256_setzero_ps();
+
+      for (size_t x = 0; x < S; x += 8) {
+
+        __m128i pixels_u8 = _mm_loadl_epi64((const __m128i *)(img_row + x));
+
+        __m256i pixels_i32 = _mm256_cvtepu8_epi32(pixels_u8);
+
+        __m256 pixels_f = _mm256_cvtepi32_ps(pixels_i32);
+
+        __m256 coeffs = _mm256_load_ps(c + x);
+
+        sum_vec = _mm256_fmadd_ps(pixels_f, coeffs, sum_vec);
+      }
+
+      __m128 lo = _mm256_extractf128_ps(sum_vec, 0);
+      __m128 hi = _mm256_extractf128_ps(sum_vec, 1);
+      __m128 sum128 = _mm_add_ps(lo, hi);
+      sum128 = _mm_hadd_ps(sum128, sum128);
+      sum128 = _mm_hadd_ps(sum128, sum128);
+
+      tmp[u * S + y] = _mm_cvtss_f32(sum128);
+    }
+  }
+
+  alignas(32) float dct[F * F];
+
+  for (size_t u = 0; u < F; ++u) {
+    for (size_t v = 0; v < F; ++v) {
+      const float *c = &dct_mat[v * S];
+      const float *t = &tmp[u * S];
+
+      __m256 sum_vec = _mm256_setzero_ps();
+
+      for (size_t k = 0; k < S; k += 8) {
+        __m256 t_vals = _mm256_load_ps(t + k);
+        __m256 c_vals = _mm256_load_ps(c + k);
+        sum_vec = _mm256_fmadd_ps(t_vals, c_vals, sum_vec);
+      }
+
+      __m128 lo = _mm256_extractf128_ps(sum_vec, 0);
+      __m128 hi = _mm256_extractf128_ps(sum_vec, 1);
+      __m128 sum128 = _mm_add_ps(lo, hi);
+      sum128 = _mm_hadd_ps(sum128, sum128);
+      sum128 = _mm_hadd_ps(sum128, sum128);
+
+      dct[u * F + v] = _mm_cvtss_f32(sum128) * 0.25f;
+    }
+  }
+
+  float total = 0.0f;
+
+  for (size_t i = 1; i < F * F; ++i)
+    total += dct[i];
+
+  float avg = total / float(F * F - 1);
+
+  uint64_t hash = 0;
+  size_t bit = 0;
+  for (size_t u = 0; u < F; ++u) {
+    for (size_t v = 0; v < F; ++v) {
+      if (u == 0 && v == 0)
+        continue;
+      if (dct[u * F + v] >= avg)
+        hash |= (1ULL << bit);
+      ++bit;
+    }
+  }
+
+  return hash;
+}
+
+static inline int hamming(uint64_t a, uint64_t b) {
+#if defined(__GNUC__) || defined(__clang__)
+  return __builtin_popcountll(a ^ b);
+#elif defined(_MSC_VER)
+  return static_cast<int>(__popcnt64(a ^ b));
+#else
+
+  uint64_t diff = a ^ b;
+  int count = 0;
+  while (diff) {
+    diff &= (diff - 1);
+    count++;
+  }
+  return count;
+#endif
+}
+
+} // namespace img_hash
+
+#endif

package/test.js

@@ -0,0 +1,20 @@
+const { aHash, dHash, pHash, hamming } = require('./index.js');
+
+const width = 100;
+const height = 100;
+const buffer = Buffer.alloc(width * height * 3);
+
+for (let i = 0; i < buffer.length; i++) {
+  buffer[i] = Math.floor(Math.random() * 256);
+}
+
+const hash1 = aHash(buffer, width, height);
+const hash2 = dHash(buffer, width, height);
+const hash3 = pHash(buffer, width, height);
+
+console.log('aHash:', hash1);
+console.log('dHash:', hash2);
+console.log('pHash:', hash3);
+
+const distance = hamming(hash1, hash2);
+console.log('Hamming distance:', distance);