Aquí tienes una función en PHP que compara dos imágenes usando el algoritmo SSIM (Structural Similarity Index). Está hecha con la extensión GD (común en PHP) y calcula el SSIM por bloques usando una ventana Gaussiana, tal como en el paper original. Devuelve un valor entre 0 y 1 (más cercano a 1 significa mayor similitud).

Requisitos: PHP con la extensión GD habilitada.
Rendimiento: Por defecto reescala las imágenes a 512×512 para acelerar el cálculo.

---------------------------------

<?php
/**
 * Calcula el SSIM (Structural Similarity Index) entre dos imágenes.
 * - Utiliza GD.
 * - Convierte a escala de grises y evalúa SSIM por bloques usando un kernel Gaussiano.
 *
 * @param string $pathA Ruta de la primera imagen (jpg/png/webp/etc.)
 * @param string $pathB Ruta de la segunda imagen
 * @param int    $resizeTo Reescalar al tamaño NxN (por defecto 512). Usa null para mantener tamaño original.
 * @param int    $window Tamaño de la ventana (por defecto 8)
 * @param float  $sigma  Sigma del kernel Gaussiano (por defecto 1.5)
 * @return float SSIM en rango [0, 1]. 1 = idénticas (en luminancia), 0 = muy diferentes.
 */
function ssim(string $pathA, string $pathB, int $resizeTo = 512, int $window = 8, float $sigma = 1.5): float
{
    // --- Constantes SSIM ---
    $K1 = 0.01;
    $K2 = 0.03;
    $L  = 255.0;                      // rango dinámico (8 bits)
    $C1 = ($K1 * $L) ** 2;
    $C2 = ($K2 * $L) ** 2;

    // --- Cargar imágenes ---
    $imA = loadImageGD($pathA);
    $imB = loadImageGD($pathB);
    if (!$imA || !$imB) {
        throw new RuntimeException("No se pudo cargar alguna imagen. Verifica rutas y formatos.");
    }

    // --- Igualar tamaños (reescalar para rendimiento) ---
    if ($resizeTo !== null) {
        $imA = resizeGD($imA, $resizeTo, $resizeTo);
        $imB = resizeGD($imB, $resizeTo, $resizeTo);
    } else {
        // Redimensionar B al tamaño de A si difieren
        [$wA, $hA] = [imagesx($imA), imagesy($imA)];
        [$wB, $hB] = [imagesx($imB), imagesy($imB)];
        if ($wA !== $wB || $hA !== $hB) {
            $imB = resizeGD($imB, $wA, $hA);
        }
    }

    $width  = imagesx($imA);
    $height = imagesy($imA);

    // --- Matrices en escala de grises (0..255) ---
    $grayA = toGrayscaleMatrix($imA);
    $grayB = toGrayscaleMatrix($imB);

    // --- Kernel Gaussiano 2D (normalizado) ---
    $kernel = gaussianKernel2D($window, $sigma);

    // --- Recorrer en bloques (no solapados para mayor velocidad) ---
    $stepX = $window;
    $stepY = $window;

    $ssimSum = 0.0;
    $blockCount = 0;

    for ($y = 0; $y + $window <= $height; $y += $stepY) {
        for ($x = 0; $x + $window <= $width; $x += $stepX) {
            // Medias ponderadas
            $muA = 0.0;
            $muB = 0.0;

            for ($j = 0; $j < $window; $j++) {
                for ($i = 0; $i < $window; $i++) {
                    $w = $kernel[$j][$i];
                    $a = $grayA[$y + $j][$x + $i];
                    $b = $grayB[$y + $j][$x + $i];
                    $muA += $w * $a;
                    $muB += $w * $b;
                }
            }

            // Varianzas y covarianza ponderadas
            $sigmaA2 = 0.0;
            $sigmaB2 = 0.0;
            $sigmaAB = 0.0;

            for ($j = 0; $j < $window; $j++) {
                for ($i = 0; $i < $window; $i++) {
                    $w = $kernel[$j][$i];
                    $a = $grayA[$y + $j][$x + $i];
                    $b = $grayB[$y + $j][$x + $i];
                    $da = $a - $muA;
                    $db = $b - $muB;
                    $sigmaA2 += $w * ($da * $da);
                    $sigmaB2 += $w * ($db * $db);
                    $sigmaAB += $w * ($da * $db);
                }
            }

            // Fórmula SSIM
            $num  = (2.0 * $muA * $muB + $C1) * (2.0 * $sigmaAB + $C2);
            $den  = ($muA * $muA + $muB * $muB + $C1) * ($sigmaA2 + $sigmaB2 + $C2);
            $ssim = $den !== 0.0 ? ($num / $den) : 0.0;

            $ssimSum += $ssim;
            $blockCount++;
        }
    }

    // Evitar liberar antes de acabar (por si GD usa referencias)
    imagedestroy($imA);
    imagedestroy($imB);

    return $blockCount > 0 ? max(0.0, min(1.0, $ssimSum / $blockCount)) : 0.0;
}

/** -------------------- Helpers -------------------- */

/**
 * Carga una imagen con GD desde ruta (auto-detecta mime).
 */
function loadImageGD(string $path)
{
    if (!is_file($path)) return false;
    $data = @file_get_contents($path);
    if ($data === false) return false;
    return @imagecreatefromstring($data);
}

/**
 * Redimensiona un recurso GD a w×h con resampleo bilineal.
 */
function resizeGD($im, int $w, int $h)
{
    $dst = imagecreatetruecolor($w, $h);
    imagealphablending($dst, false);
    imagesavealpha($dst, true);
    imagecopyresampled($dst, $im, 0, 0, 0, 0, $w, $h, imagesx($im), imagesy($im));
    return $dst;
}

/**
 * Convierte imagen GD a matriz [y][x] de luminancia (escala de grises 0..255).
 * Usa la aproximación: Y = 0.299 R + 0.587 G + 0.114 B
 */
function toGrayscaleMatrix($im): array
{
    $w = imagesx($im);
    $h = imagesy($im);
    $mat = array_fill(0, $h, array_fill(0, $w, 0.0));

    for ($y = 0; $y < $h; $y++) {
        for ($x = 0; $x < $w; $x++) {
            $rgb = imagecolorat($im, $x, $y);
            $r = ($rgb >> 16) & 0xFF;
            $g = ($rgb >> 8) & 0xFF;
            $b = $rgb & 0xFF;
            $yLum = 0.299 * $r + 0.587 * $g + 0.114 * $b;
            $mat[$y][$x] = $yLum;
        }
    }
    return $mat;
}

/**
 * Kernel Gaussiano 2D de tamaño n×n con sigma dado. Normalizado (suma = 1).
 */
function gaussianKernel2D(int $n, float $sigma): array
{
    if ($n < 1) $n = 1;
    $kernel = array_fill(0, $n, array_fill(0, $n, 0.0));
    $half = ($n - 1) / 2.0;
    $sum = 0.0;

    for ($j = 0; $j < $n; $j++) {
        for ($i = 0; $i < $n; $i++) {
            $x = $i - $half;
            $y = $j - $half;
            $val = exp(-( ($x*$x + $y*$y) / (2.0 * $sigma * $sigma) ));
            $kernel[$j][$i] = $val;
            $sum += $val;
        }
    }

    // Normalización
    for ($j = 0; $j < $n; $j++) {
        for ($i = 0; $i < $n; $i++) {
            $kernel[$j][$i] /= $sum;
        }
    }
    return $kernel;
}

/** -------------------- Ejemplo de uso -------------------- */
// try {
//     $score = ssim(__DIR__ . '/img1.jpg', __DIR__ . '/img2.jpg', 512, 8, 1.5);
//     echo "SSIM: " . round($score, 6) . PHP_EOL;
//     // Puedes definir un umbral para "similar"
//     $umbral = 0.95;
//     echo ($score >= $umbral) ? "Muy similares" : "Diferentes";
// } catch (Throwable $e) {
//     echo "Error: " . $e->getMessage();
// }

---------------------------------

Cómo usarlo

    Guarda el código en un archivo, por ejemplo: ssim.php.
    Llama a la función pasando las rutas de tus imágenes:

<?php
require 'ssim.php';
$ssim = ssim('fotooriginal.png', 'fotocompresion.png', 512, 8, 1.5);
printf("SSIM = %.5f\n", $ssim);
if ($ssim >= 0.95) {
    echo "Las imágenes son muy similares.\n";
} else {
    echo "Hay diferencias apreciables.\n";
}

Notas y consejos

    Umbral práctico:
        SSIM ≥ 0.98: casi idénticas.
        0.95–0.98: diferencias leves (p. ej., compresión).
        < 0.90: diferencias visibles.
    Rendimiento: si trabajas con imágenes grandes, deja resizeTo=512 o 256 para velocidad sin perder demasiada precisión perceptual.
    Exactitud vs. velocidad:
        Aumentar window (p. ej., 11) y ajustar sigma (≈1.5) se acerca más a implementaciones académicas.
        Usar ventanas solapadas (stride 1) mejora precisión pero es más lento. Si quieres eso, cambia $stepX y $stepY a 1.
    Imagick: si dispones de ImageMagick/Imagick reciente, puedes usar su métrica SSIM nativa (si tu versión la soporta). Aun así, el método anterior es 100% PHP+GD y portable.