Implement creator studio and upload updates

app/Services/Images/Detectors/HeuristicSubjectDetector.php

@@ -0,0 +1,409 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\Images\Detectors;
+
+use App\Contracts\Images\SubjectDetectorInterface;
+use App\Data\Images\CropBoxData;
+use App\Data\Images\SubjectDetectionResultData;
+
+final class HeuristicSubjectDetector implements SubjectDetectorInterface
+{
+    public function detect(string $sourcePath, int $sourceWidth, int $sourceHeight, array $context = []): ?SubjectDetectionResultData
+    {
+        if (! function_exists('imagecreatefromstring')) {
+            return null;
+        }
+
+        $binary = @file_get_contents($sourcePath);
+        if (! is_string($binary) || $binary === '') {
+            return null;
+        }
+
+        $source = @imagecreatefromstring($binary);
+        if ($source === false) {
+            return null;
+        }
+
+        try {
+            $sampleMax = max(24, (int) config('uploads.square_thumbnails.saliency.sample_max_dimension', 96));
+            $longest = max(1, max($sourceWidth, $sourceHeight));
+            $scale = min(1.0, $sampleMax / $longest);
+            $sampleWidth = max(8, (int) round($sourceWidth * $scale));
+            $sampleHeight = max(8, (int) round($sourceHeight * $scale));
+
+            $sample = imagecreatetruecolor($sampleWidth, $sampleHeight);
+            if ($sample === false) {
+                return null;
+            }
+
+            try {
+                imagecopyresampled($sample, $source, 0, 0, 0, 0, $sampleWidth, $sampleHeight, $sourceWidth, $sourceHeight);
+                $gray = $this->grayscaleMatrix($sample, $sampleWidth, $sampleHeight);
+                $rarity = $this->colorRarityMatrix($sample, $sampleWidth, $sampleHeight);
+                $vegetation = $this->vegetationMaskMatrix($sample, $sampleWidth, $sampleHeight);
+            } finally {
+                imagedestroy($sample);
+            }
+
+            $energy = $this->energyMatrix($gray, $sampleWidth, $sampleHeight);
+            $saliency = $this->combineSaliency($energy, $rarity, $sampleWidth, $sampleHeight);
+            $prefix = $this->prefixMatrix($saliency, $sampleWidth, $sampleHeight);
+            $vegetationPrefix = $this->prefixMatrix($vegetation, $sampleWidth, $sampleHeight);
+            $totalEnergy = $prefix[$sampleHeight][$sampleWidth] ?? 0.0;
+
+            if ($totalEnergy < (float) config('uploads.square_thumbnails.saliency.min_total_energy', 2400.0)) {
+                return null;
+            }
+
+            $candidate = $this->bestCandidate($prefix, $vegetationPrefix, $sampleWidth, $sampleHeight, $totalEnergy);
+            $rareSubjectCandidate = $this->rareSubjectCandidate($rarity, $vegetation, $sampleWidth, $sampleHeight);
+
+            if ($rareSubjectCandidate !== null && ($candidate === null || $rareSubjectCandidate['score'] > ($candidate['score'] * 0.72))) {
+                $candidate = $rareSubjectCandidate;
+            }
+
+            if ($candidate === null) {
+                return null;
+            }
+
+            $scaleX = $sourceWidth / max(1, $sampleWidth);
+            $scaleY = $sourceHeight / max(1, $sampleHeight);
+            $sideScale = max($scaleX, $scaleY);
+
+            $cropBox = new CropBoxData(
+                x: (int) floor($candidate['x'] * $scaleX),
+                y: (int) floor($candidate['y'] * $scaleY),
+                width: max(1, (int) round($candidate['side'] * $sideScale)),
+                height: max(1, (int) round($candidate['side'] * $sideScale)),
+            );
+
+            $averageDensity = $totalEnergy / max(1, $sampleWidth * $sampleHeight);
+            $confidence = min(1.0, max(0.15, ($candidate['density'] / max(1.0, $averageDensity)) / 4.0));
+
+            return new SubjectDetectionResultData(
+                cropBox: $cropBox->clampToImage($sourceWidth, $sourceHeight),
+                strategy: 'saliency',
+                reason: 'heuristic_saliency',
+                confidence: $confidence,
+                meta: [
+                    'sample_width' => $sampleWidth,
+                    'sample_height' => $sampleHeight,
+                    'score' => $candidate['score'],
+                ],
+            );
+        } finally {
+            imagedestroy($source);
+        }
+    }
+
+    /**
+     * @return array<int, array<int, int>>
+     */
+    private function grayscaleMatrix($sample, int $width, int $height): array
+    {
+        $gray = [];
+
+        for ($y = 0; $y < $height; $y++) {
+            $gray[$y] = [];
+            for ($x = 0; $x < $width; $x++) {
+                $rgb = imagecolorat($sample, $x, $y);
+                $r = ($rgb >> 16) & 0xFF;
+                $g = ($rgb >> 8) & 0xFF;
+                $b = $rgb & 0xFF;
+                $gray[$y][$x] = (int) round($r * 0.299 + $g * 0.587 + $b * 0.114);
+            }
+        }
+
+        return $gray;
+    }
+
+    /**
+     * @param array<int, array<int, int>> $gray
+     * @return array<int, array<int, float>>
+     */
+    private function energyMatrix(array $gray, int $width, int $height): array
+    {
+        $energy = [];
+
+        for ($y = 0; $y < $height; $y++) {
+            $energy[$y] = [];
+            for ($x = 0; $x < $width; $x++) {
+                $center = $gray[$y][$x] ?? 0;
+                $right = $gray[$y][$x + 1] ?? $center;
+                $down = $gray[$y + 1][$x] ?? $center;
+                $diag = $gray[$y + 1][$x + 1] ?? $center;
+
+                $energy[$y][$x] = abs($center - $right)
+                    + abs($center - $down)
+                    + (abs($center - $diag) * 0.5);
+            }
+        }
+
+        return $energy;
+    }
+
+    /**
+     * Build a map that highlights globally uncommon colors, which helps distinguish
+     * a main subject from repetitive foliage or sky textures.
+     *
+     * @return array<int, array<int, float>>
+     */
+    private function colorRarityMatrix($sample, int $width, int $height): array
+    {
+        $counts = [];
+        $pixels = [];
+        $totalPixels = max(1, $width * $height);
+
+        for ($y = 0; $y < $height; $y++) {
+            $pixels[$y] = [];
+
+            for ($x = 0; $x < $width; $x++) {
+                $rgb = imagecolorat($sample, $x, $y);
+                $r = ($rgb >> 16) & 0xFF;
+                $g = ($rgb >> 8) & 0xFF;
+                $b = $rgb & 0xFF;
+
+                $bucket = (($r >> 5) << 6) | (($g >> 5) << 3) | ($b >> 5);
+                $counts[$bucket] = ($counts[$bucket] ?? 0) + 1;
+                $pixels[$y][$x] = [$r, $g, $b, $bucket];
+            }
+        }
+
+        $rarity = [];
+
+        for ($y = 0; $y < $height; $y++) {
+            $rarity[$y] = [];
+
+            for ($x = 0; $x < $width; $x++) {
+                [$r, $g, $b, $bucket] = $pixels[$y][$x];
+                $bucketCount = max(1, (int) ($counts[$bucket] ?? 1));
+                $baseRarity = log(($totalPixels + 1) / $bucketCount);
+                $maxChannel = max($r, $g, $b);
+                $minChannel = min($r, $g, $b);
+                $saturation = $maxChannel - $minChannel;
+                $luma = ($r * 0.299) + ($g * 0.587) + ($b * 0.114);
+
+                $neutralLightBoost = ($luma >= 135 && $saturation <= 95) ? 1.0 : 0.0;
+                $warmBoost = ($r >= 96 && $r >= $b + 10) ? 1.0 : 0.0;
+                $vegetationPenalty = ($g >= 72 && $g >= $r * 1.12 && $g >= $b * 1.08) ? 1.0 : 0.0;
+
+                $rarity[$y][$x] = max(0.0,
+                    ($baseRarity * 32.0)
+                    + ($saturation * 0.10)
+                    + ($neutralLightBoost * 28.0)
+                    + ($warmBoost * 18.0)
+                    - ($vegetationPenalty * 18.0)
+                );
+            }
+        }
+
+        return $rarity;
+    }
+
+    /**
+     * @return array<int, array<int, float>>
+     */
+    private function vegetationMaskMatrix($sample, int $width, int $height): array
+    {
+        $mask = [];
+
+        for ($y = 0; $y < $height; $y++) {
+            $mask[$y] = [];
+
+            for ($x = 0; $x < $width; $x++) {
+                $rgb = imagecolorat($sample, $x, $y);
+                $r = ($rgb >> 16) & 0xFF;
+                $g = ($rgb >> 8) & 0xFF;
+                $b = $rgb & 0xFF;
+
+                $mask[$y][$x] = ($g >= 72 && $g >= $r * 1.12 && $g >= $b * 1.08) ? 1.0 : 0.0;
+            }
+        }
+
+        return $mask;
+    }
+
+    /**
+     * @param array<int, array<int, float>> $energy
+     * @param array<int, array<int, float>> $rarity
+     * @return array<int, array<int, float>>
+     */
+    private function combineSaliency(array $energy, array $rarity, int $width, int $height): array
+    {
+        $combined = [];
+
+        for ($y = 0; $y < $height; $y++) {
+            $combined[$y] = [];
+
+            for ($x = 0; $x < $width; $x++) {
+                $combined[$y][$x] = ($energy[$y][$x] ?? 0.0) + (($rarity[$y][$x] ?? 0.0) * 1.45);
+            }
+        }
+
+        return $combined;
+    }
+
+    /**
+     * @param array<int, array<int, float>> $matrix
+     * @return array<int, array<int, float>>
+     */
+    private function prefixMatrix(array $matrix, int $width, int $height): array
+    {
+        $prefix = array_fill(0, $height + 1, array_fill(0, $width + 1, 0.0));
+
+        for ($y = 1; $y <= $height; $y++) {
+            for ($x = 1; $x <= $width; $x++) {
+                $prefix[$y][$x] = $matrix[$y - 1][$x - 1]
+                    + $prefix[$y - 1][$x]
+                    + $prefix[$y][$x - 1]
+                    - $prefix[$y - 1][$x - 1];
+            }
+        }
+
+        return $prefix;
+    }
+
+    /**
+     * @param array<int, array<int, float>> $prefix
+     * @return array{x: int, y: int, side: int, density: float, score: float}|null
+     */
+    private function bestCandidate(array $prefix, array $vegetationPrefix, int $sampleWidth, int $sampleHeight, float $totalEnergy): ?array
+    {
+        $minDimension = min($sampleWidth, $sampleHeight);
+        $ratios = (array) config('uploads.square_thumbnails.saliency.window_ratios', [0.55, 0.7, 0.82, 1.0]);
+        $best = null;
+
+        foreach ($ratios as $ratio) {
+            $side = max(8, min($minDimension, (int) round($minDimension * (float) $ratio)));
+            $step = max(1, (int) floor($side / 5));
+
+            for ($y = 0; $y <= max(0, $sampleHeight - $side); $y += $step) {
+                for ($x = 0; $x <= max(0, $sampleWidth - $side); $x += $step) {
+                    $sum = $this->sumRegion($prefix, $x, $y, $side, $side);
+                    $density = $sum / max(1, $side * $side);
+                    $centerX = ($x + ($side / 2)) / max(1, $sampleWidth);
+                    $centerY = ($y + ($side / 2)) / max(1, $sampleHeight);
+                    $centerBias = 1.0 - min(1.0, abs($centerX - 0.5) * 1.2 + abs($centerY - 0.42) * 0.9);
+                    $coverage = $side / max(1, $minDimension);
+                    $coverageFit = 1.0 - min(1.0, abs($coverage - 0.72) / 0.45);
+                    $vegetationRatio = $this->sumRegion($vegetationPrefix, $x, $y, $side, $side) / max(1, $side * $side);
+                    $score = $density * (1.0 + max(0.0, $centerBias) * 0.18)
+                        + (($sum / max(1.0, $totalEnergy)) * 4.0)
+                        + (max(0.0, $coverageFit) * 2.5)
+                        - ($vegetationRatio * 68.0);
+
+                    if ($best === null || $score > $best['score']) {
+                        $best = [
+                            'x' => $x,
+                            'y' => $y,
+                            'side' => $side,
+                            'density' => $density,
+                            'score' => $score,
+                        ];
+                    }
+                }
+            }
+        }
+
+        return $best;
+    }
+
+    /**
+     * Build a second candidate from rare, non-foliage pixels so a smooth subject can
+     * still win even when repetitive textured leaves dominate edge energy.
+     *
+     * @param array<int, array<int, float>> $rarity
+     * @param array<int, array<int, float>> $vegetation
+     * @return array{x: int, y: int, side: int, density: float, score: float}|null
+     */
+    private function rareSubjectCandidate(array $rarity, array $vegetation, int $sampleWidth, int $sampleHeight): ?array
+    {
+        $values = [];
+
+        for ($y = 0; $y < $sampleHeight; $y++) {
+            for ($x = 0; $x < $sampleWidth; $x++) {
+                if (($vegetation[$y][$x] ?? 0.0) >= 0.5) {
+                    continue;
+                }
+
+                $values[] = (float) ($rarity[$y][$x] ?? 0.0);
+            }
+        }
+
+        if (count($values) < 24) {
+            return null;
+        }
+
+        sort($values);
+        $thresholdIndex = max(0, (int) floor((count($values) - 1) * 0.88));
+        $threshold = max(48.0, (float) ($values[$thresholdIndex] ?? 0.0));
+
+        $weightSum = 0.0;
+        $weightedX = 0.0;
+        $weightedY = 0.0;
+        $minX = $sampleWidth;
+        $minY = $sampleHeight;
+        $maxX = 0;
+        $maxY = 0;
+        $count = 0;
+
+        for ($y = 0; $y < $sampleHeight; $y++) {
+            for ($x = 0; $x < $sampleWidth; $x++) {
+                if (($vegetation[$y][$x] ?? 0.0) >= 0.5) {
+                    continue;
+                }
+
+                $weight = (float) ($rarity[$y][$x] ?? 0.0);
+                if ($weight < $threshold) {
+                    continue;
+                }
+
+                $weightSum += $weight;
+                $weightedX += ($x + 0.5) * $weight;
+                $weightedY += ($y + 0.5) * $weight;
+                $minX = min($minX, $x);
+                $minY = min($minY, $y);
+                $maxX = max($maxX, $x);
+                $maxY = max($maxY, $y);
+                $count++;
+            }
+        }
+
+        if ($count < 12 || $weightSum <= 0.0) {
+            return null;
+        }
+
+        $meanX = $weightedX / $weightSum;
+        $meanY = $weightedY / $weightSum;
+        $boxWidth = max(8, ($maxX - $minX) + 1);
+        $boxHeight = max(8, ($maxY - $minY) + 1);
+        $minDimension = min($sampleWidth, $sampleHeight);
+        $side = max($boxWidth, $boxHeight);
+        $side = max($side, (int) round($minDimension * 0.42));
+        $side = min($minDimension, (int) round($side * 1.18));
+
+        return [
+            'x' => (int) round($meanX - ($side / 2)),
+            'y' => (int) round($meanY - ($side / 2)),
+            'side' => max(8, $side),
+            'density' => $weightSum / max(1, $count),
+            'score' => ($weightSum / max(1, $count)) + ($count * 0.35),
+        ];
+    }
+
+    /**
+     * @param array<int, array<int, float>> $prefix
+     */
+    private function sumRegion(array $prefix, int $x, int $y, int $width, int $height): float
+    {
+        $x2 = $x + $width;
+        $y2 = $y + $height;
+
+        return ($prefix[$y2][$x2] ?? 0.0)
+            - ($prefix[$y][$x2] ?? 0.0)
+            - ($prefix[$y2][$x] ?? 0.0)
+            + ($prefix[$y][$x] ?? 0.0);
+    }
+}