@pilio/gemini-watermark-remover 1.0.25 → 1.0.26

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pilio/gemini-watermark-remover",
   "description": "Automatically removes watermarks from Gemini AI generated images",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "author": "GargantuaX",
   "sideEffects": false,
   "files": [
@@ -109,6 +109,10 @@
     "visible-residual:goal-audit": "node scripts/create-visible-residual-goal-audit-report.js",
     "visible-residual:cluster-report": "node scripts/create-visible-residual-cluster-report.js",
     "visible-residual:geometry-audit": "node scripts/audit-visible-residual-geometry.js",
+    "review:metric-mismatch": "node scripts/create-metric-mismatch-review-pack.js",
+    "probe:metric-48-alpha-profile": "node scripts/probe-metric-48-96-96-alpha-profile.js",
+    "probe:metric-48-localization": "node scripts/probe-metric-48-96-96-localization.js",
+    "review:metric-48-taxonomy": "node scripts/create-metric-48-96-96-failure-taxonomy.js",
     "scan:sample-watermarks": "node scripts/scan-sample-watermarks.js",
     "render:skipped-crops": "node scripts/render-skipped-candidate-crops.js",
     "render:video-crops": "node scripts/render-video-crop-sheet.js",

package/src/core/candidateSelector.js

@@ -22,6 +22,7 @@ import {
 import {
     buildRankingKey,
     compareRankingKey,
+    scoreBalancedVisualCandidate,
     scoreDamage,
     scoreOriginalEvidence,
     scoreResidual,
@@ -76,6 +77,13 @@ const STANDARD_TEXT_OVERLAP_MIN_GRADIENT_SCORE = 0.18;
 const STANDARD_TEXT_OVERLAP_MIN_IMPROVEMENT = 0.25;
 const STANDARD_TEXT_OVERLAP_MAX_RESIDUAL = 0.1;
 const STANDARD_TEXT_OVERLAP_MIN_GRADIENT_DROP = 0.1;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_ORIGINAL_SPATIAL_SCORE = 0.12;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_ORIGINAL_GRADIENT_SCORE = 0.06;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_IMPROVEMENT = 0.08;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_SPATIAL_RESIDUAL = 0.08;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_GRADIENT_RESIDUAL = 0.08;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_NEAR_BLACK_INCREASE = 0.005;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_TEXTURE = 0.05;
 const STANDARD_VALIDATION_MIN_ORIGINAL_SPATIAL_SCORE = 0.05;
 const STANDARD_VALIDATION_MIN_ORIGINAL_GRADIENT_SCORE = 0.12;
 const STANDARD_CONSERVATIVE_CATALOG_PREFERRED_ALPHA_GAIN = 0.55;
@@ -114,6 +122,14 @@ const STANDARD_STRONG_SIGNAL_NEAR_BLACK_OVERRIDE_MAX_GRADIENT = 0.32;
 const STANDARD_STRONG_SIGNAL_NEAR_BLACK_OVERRIDE_MIN_IMPROVEMENT = 0.7;
 const STANDARD_STRONG_SIGNAL_NEAR_BLACK_OVERRIDE_MIN_GRADIENT_DROP = 0.6;
 const STANDARD_STRONG_SIGNAL_NEAR_BLACK_OVERRIDE_MAX_NEAR_BLACK_INCREASE = 0.4;
+const BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MIN_SPATIAL = 0.35;
+const BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MIN_GRADIENT = 0.16;
+const BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_SPATIAL_ADVANTAGE = 0.18;
+const BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_GRADIENT_ADVANTAGE = 0.12;
+const BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MAX_RESIDUAL_DELTA = 0.08;
+const DARK_POLARITY_CATALOG_MIN_ORIGINAL_SPATIAL = 0.12;
+const DARK_POLARITY_CATALOG_MIN_ORIGINAL_GRADIENT = 0.08;
+const DARK_POLARITY_CATALOG_MAX_TEXTURE_FOR_WEAK_EVIDENCE = 0.25;
 const TEMPLATE_ALIGN_SHIFTS = [-0.5, -0.25, 0, 0.25, 0.5];
 const TEMPLATE_ALIGN_SCALES = [0.99, 1, 1.01];
 const STANDARD_NEARBY_SHIFTS = [-12, -8, -4, 0, 4, 8, 12];
@@ -137,15 +153,16 @@ const PREVIEW_ANCHOR_MIN_SCORE = 0.2;
 const PREVIEW_ANCHOR_LOCAL_DELTAS = [-1, 0, 1];
 const PREVIEW_TEMPLATE_ALIGN_SHIFTS = [-1, -0.5, 0, 0.5, 1];
 const PREVIEW_TEMPLATE_ALIGN_SCALES = [0.985, 1, 1.015];
-const PREVIEW_ANCHOR_GAIN_SKIP_RESIDUAL_THRESHOLD = 0.22;
+const PREVIEW_ANCHOR_GAIN_SKIP_RESIDUAL_THRESHOLD = 0.24;
 const PREVIEW_ANCHOR_GAIN_SKIP_GRADIENT_THRESHOLD = 0.24;
 const CORE_ALPHA_PRIORITY_GAINS = Object.freeze([0.6, 1, 1.1, 1.15, 1.3, 0.45, 0.7, 0.85, 0.55]);
 const CURRENT_LARGE_MARGIN_ULTRA_WEAK_ALPHA_GAINS = Object.freeze([0.25, 0.3, 0.35, 0.4]);
 const STANDARD_ANCHOR_WEAK_ALPHA_RESCUE_GAINS = Object.freeze([0.55, 0.7, 0.85]);
 const STANDARD_ANCHOR_WEAK_RESCUE_MAX_SPATIAL = 0.35;
-const STANDARD_ANCHOR_WEAK_RESCUE_MAX_GRADIENT = 0.18;
+const STANDARD_ANCHOR_WEAK_RESCUE_MAX_GRADIENT = 0.24;
 const STANDARD_ANCHOR_WEAK_RESCUE_MIN_IMPROVEMENT = 0.08;
 const STANDARD_ANCHOR_WEAK_RESCUE_MAX_NEAR_BLACK_INCREASE = 0.02;
+const STANDARD_ANCHOR_WEAK_RESCUE_MIN_BALANCED_ADVANTAGE = 0.03;
 const CURRENT_LARGE_MARGIN_WEAK_RESCUE_MAX_SPATIAL = 0.22;
 const CURRENT_LARGE_MARGIN_WEAK_RESCUE_MAX_GRADIENT = 0.36;
 const CURRENT_LARGE_MARGIN_WEAK_RESCUE_MIN_ORIGINAL_SPATIAL = 0.17;
@@ -595,6 +612,35 @@ function isWeakAlphaRescueCandidate(seed, trial) {
         trial.texturePenalty <= 0.25;
 }
 
+function isStandardTextOverlapWeakAlphaCandidate(seed, trial) {
+    if (!trial?.accepted || trial.alphaGain >= 1 || trial.hardReject === true) {
+        return false;
+    }
+    if (
+        seed?.config?.logoSize !== 96 ||
+        seed.config.marginRight !== 64 ||
+        seed.config.marginBottom !== 64
+    ) {
+        return false;
+    }
+
+    return trial.originalSpatialScore >= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_ORIGINAL_SPATIAL_SCORE &&
+        trial.originalGradientScore >= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_ORIGINAL_GRADIENT_SCORE &&
+        trial.improvement >= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_IMPROVEMENT &&
+        Math.abs(trial.processedSpatialScore) <= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_SPATIAL_RESIDUAL &&
+        Math.max(0, trial.processedGradientScore) <= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_GRADIENT_RESIDUAL &&
+        trial.nearBlackIncrease <= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_NEAR_BLACK_INCREASE &&
+        trial.texturePenalty <= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_TEXTURE;
+}
+
+function tagCandidateSource(candidate, tag) {
+    if (!candidate || String(candidate.source).includes(tag)) return candidate;
+    return {
+        ...candidate,
+        source: `${candidate.source}+${tag}`
+    };
+}
+
 function shouldPreferLargeMarginGradientClearance(currentBest, candidate) {
     if (!isCurrentLargeMarginCatalogCandidate(currentBest) || !isCurrentLargeMarginCatalogCandidate(candidate)) {
         return false;
@@ -640,6 +686,20 @@ function pickBetterWeakAlphaRescueCandidate(seed, currentBest, candidate) {
     return pickBetterCandidate(currentBest, candidate, 0.002);
 }
 
+function shouldPreferWeakAlphaRescueOverAccepted(acceptedTrial, rescueTrial) {
+    if (!acceptedTrial?.accepted || !rescueTrial?.accepted) return false;
+    if (rescueTrial.alphaGain >= 1) return false;
+
+    const acceptedCost = Number(acceptedTrial.validationCost);
+    const rescueCost = Number(rescueTrial.validationCost);
+    if (!Number.isFinite(acceptedCost) || !Number.isFinite(rescueCost)) return false;
+
+    return rescueCost <= acceptedCost - STANDARD_ANCHOR_WEAK_RESCUE_MIN_BALANCED_ADVANTAGE &&
+        Math.abs(rescueTrial.processedSpatialScore) <= Math.abs(acceptedTrial.processedSpatialScore) &&
+        Math.max(0, rescueTrial.processedGradientScore) <= STANDARD_ANCHOR_WEAK_RESCUE_MAX_GRADIENT &&
+        rescueTrial.nearBlackIncrease <= STANDARD_ANCHOR_WEAK_RESCUE_MAX_NEAR_BLACK_INCREASE;
+}
+
 function evaluateStandardTrialForSeed({
     originalImageData,
     seed,
@@ -669,6 +729,13 @@ function evaluateStandardTrialForSeed({
             fallbackTrial = trial;
         }
         if (alphaGain < 1) {
+            if (isStandardTextOverlapWeakAlphaCandidate(seed, trial)) {
+                bestWeakAlphaPriorityTrial = pickBetterCandidate(
+                    bestWeakAlphaPriorityTrial,
+                    tagCandidateSource(trial, 'text-overlap'),
+                    0.002
+                );
+            }
             if (
                 isWeakAlphaPrioritySeed(seed) &&
                 isCleanWeakAlphaPriorityCandidate(trial) &&
@@ -688,7 +755,14 @@ function evaluateStandardTrialForSeed({
 
     return isWeakAlphaPrioritySeed(seed)
         ? bestWeakAlphaPriorityTrial ?? bestWeakAlphaRescueTrial ?? bestAcceptedTrial ?? fallbackTrial
-        : bestWeakAlphaPriorityTrial ?? bestAcceptedTrial ?? bestWeakAlphaRescueTrial ?? fallbackTrial;
+        : bestWeakAlphaPriorityTrial ??
+            (
+                shouldPreferWeakAlphaRescueOverAccepted(bestAcceptedTrial, bestWeakAlphaRescueTrial)
+                    ? bestWeakAlphaRescueTrial
+                    : bestAcceptedTrial
+            ) ??
+            bestWeakAlphaRescueTrial ??
+            fallbackTrial;
 }
 
 export function evaluateRestorationCandidate({
@@ -807,9 +881,16 @@ export function evaluateRestorationCandidate({
         catalogEvidenceGate !== 'medium' ||
         originalScores.spatialScore >= 0.15 ||
         originalScores.gradientScore >= 0.08;
+    const darkPolarityCatalogEvidenceAllowed =
+        provenance?.darkPolarity !== true ||
+        provenance?.catalogVariant !== true ||
+        originalScores.spatialScore >= DARK_POLARITY_CATALOG_MIN_ORIGINAL_SPATIAL ||
+        originalScores.gradientScore >= DARK_POLARITY_CATALOG_MIN_ORIGINAL_GRADIENT ||
+        texturePenalty <= DARK_POLARITY_CATALOG_MAX_TEXTURE_FOR_WEAK_EVIDENCE;
     const accepted =
         originalEvidenceAllowed &&
         catalogEvidenceAllowed &&
+        darkPolarityCatalogEvidenceAllowed &&
         (
             hardRejectAllowed ||
             conservativeCatalogHardRejectAllowed ||
@@ -838,6 +919,13 @@ export function evaluateRestorationCandidate({
         processedGradient: processedScores.gradientScore,
         suppressionGain: improvement
     });
+    const balancedVisual = scoreBalancedVisualCandidate({
+        processedSpatial: processedScores.spatialScore,
+        processedGradient: processedScores.gradientScore,
+        nearBlackIncrease,
+        texturePenalty,
+        gradientIncrease
+    });
     const hardRejectBypassed =
         conservativeCatalogHardRejectAllowed ||
         visibleCatalogHardRejectAllowed ||
@@ -893,13 +981,10 @@ export function evaluateRestorationCandidate({
         originalEvidence,
         residual,
         damage,
-        validationCost:
-            Math.abs(processedScores.spatialScore) +
-            Math.max(0, processedScores.gradientScore) * 0.6 +
-            Math.max(0, nearBlackIncrease) * 3 +
-            texturePenalty
-    };
-}
+        balancedVisual,
+        validationCost: balancedVisual.score
+    };
+}
 
 function pickBestValidatedCandidate(candidates) {
     const accepted = candidates.filter((candidate) => candidate?.accepted);
@@ -1038,6 +1123,12 @@ export function pickBetterCandidate(currentBest, candidate, minCostDelta = 0.005
     if (shouldPreserveCatalogOriginalSignal(currentBest, candidate)) {
         return currentBest;
     }
+    if (shouldPreserveDominantBottomRight48AgainstWeakStandard(currentBest, candidate)) {
+        return currentBest;
+    }
+    if (shouldPreserveDominantBottomRight48AgainstWeakStandard(candidate, currentBest)) {
+        return candidate;
+    }
     if (shouldPreserveStrongCanonical96AgainstWeakCurrentLargeMargin(currentBest, candidate)) {
         return currentBest;
     }
@@ -1164,6 +1255,51 @@ function isCurrentLargeMarginCandidate(candidate) {
         candidate.config.marginBottom === 96;
 }
 
+function isBottomRight48Candidate(candidate) {
+    return candidate?.config?.logoSize === 48 &&
+        candidate.config.marginRight === 32 &&
+        candidate.config.marginBottom === 32 &&
+        candidate?.provenance?.localShift !== true &&
+        candidate?.provenance?.sizeJitter !== true &&
+        candidate?.provenance?.previewAnchor !== true;
+}
+
+function isWeakCompetingStandardAnchor(candidate) {
+    return isStandardCandidateSource(candidate) &&
+        candidate?.provenance?.localShift !== true &&
+        candidate?.provenance?.sizeJitter !== true &&
+        candidate?.provenance?.previewAnchor !== true &&
+        !isBottomRight48Candidate(candidate);
+}
+
+function shouldPreserveDominantBottomRight48AgainstWeakStandard(bottomRightCandidate, competingCandidate) {
+    if (!isBottomRight48Candidate(bottomRightCandidate)) return false;
+    if (!isWeakCompetingStandardAnchor(competingCandidate)) return false;
+
+    const bottomSpatial = Number(bottomRightCandidate.originalSpatialScore);
+    const bottomGradient = Number(bottomRightCandidate.originalGradientScore);
+    const largeSpatial = Number(competingCandidate.originalSpatialScore);
+    const largeGradient = Number(competingCandidate.originalGradientScore);
+    const bottomResidual = Number(bottomRightCandidate.residual?.score);
+    const largeResidual = Number(competingCandidate.residual?.score);
+    if (
+        !Number.isFinite(bottomSpatial) ||
+        !Number.isFinite(bottomGradient) ||
+        !Number.isFinite(largeSpatial) ||
+        !Number.isFinite(largeGradient) ||
+        !Number.isFinite(bottomResidual) ||
+        !Number.isFinite(largeResidual)
+    ) {
+        return false;
+    }
+
+    return bottomSpatial >= BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MIN_SPATIAL &&
+        bottomGradient >= BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MIN_GRADIENT &&
+        bottomSpatial >= largeSpatial + BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_SPATIAL_ADVANTAGE &&
+        bottomGradient >= largeGradient + BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_GRADIENT_ADVANTAGE &&
+        bottomResidual <= largeResidual + BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MAX_RESIDUAL_DELTA;
+}
+
 function isPreviewAnchorCandidate(candidate) {
     return candidate?.provenance?.previewAnchor === true;
 }

package/src/core/restorationMetrics.js

@@ -26,6 +26,24 @@ const RESIDUAL_VISIBILITY_OUTER_MARGIN = 4;
 const RESIDUAL_VISIBILITY_POSITIVE_HALO_LUM_THRESHOLD = 6;
 const RESIDUAL_VISIBILITY_GRADIENT_THRESHOLD = 0.22;
 const RESIDUAL_VISIBILITY_SPATIAL_THRESHOLD = 0.18;
+const FLAT_CLIPPED_METRIC_RISK_NEAR_BLACK_RATIO = 0.92;
+const FLAT_CLIPPED_METRIC_RISK_NEWLY_CLIPPED_RATIO = 0.18;
+const FLAT_CLIPPED_METRIC_RISK_MAX_POSITIVE_HALO_LUM = 2;
+const FLAT_CLIPPED_METRIC_RISK_MIN_NEGATIVE_SPATIAL = 0.18;
+const POSITIVE_SPATIAL_BACKGROUND_COLLISION_MIN_SPATIAL = 0.14;
+const POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_GRADIENT = 0.12;
+const POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_POSITIVE_HALO_LUM = 32;
+const POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_ARTIFACT_COST = 0.12;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_ABS_SPATIAL = 0.14;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_GRADIENT = 0.12;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_POSITIVE_HALO_LUM = 16;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_ARTIFACT_COST = 0.12;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_NEAR_BLACK_RATIO = 0.25;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_NEWLY_CLIPPED_RATIO = 0.02;
+const STRUCTURED_EDGE_BACKGROUND_COLLISION_MIN_GRADIENT = 0.2;
+const STRUCTURED_EDGE_BACKGROUND_COLLISION_MIN_ARTIFACT_COST = 0.2;
+const STRUCTURED_EDGE_BACKGROUND_COLLISION_MAX_NEAR_BLACK_RATIO = 0.1;
+const STRUCTURED_EDGE_BACKGROUND_COLLISION_MAX_NEWLY_CLIPPED_RATIO = 0.01;
 
 function meanAndVariance(values) {
     let sum = 0;
@@ -359,6 +377,123 @@ export function assessWatermarkResidualVisibility({
     };
 }
 
+export function assessCalibratedWatermarkResidualVisibility({
+    imageData,
+    originalImageData = null,
+    position,
+    alphaMap,
+    alphaGain = 1
+}) {
+    const visibility = assessWatermarkResidualVisibility({
+        imageData,
+        position,
+        alphaMap
+    });
+    if (!visibility) return null;
+
+    const scores = scoreRegion(imageData, alphaMap, position);
+    const nearBlackRatio = calculateNearBlackRatio(imageData, position);
+    const artifacts = originalImageData
+        ? assessRemovalDiffArtifacts({
+            originalImageData,
+            candidateImageData: imageData,
+            alphaMap,
+            position,
+            alphaGain
+        })
+        : null;
+    const newlyClippedRatio = artifacts?.newlyClippedRatio ?? 0;
+    const metricRisk = classifyCalibratedResidualMetricRisk({
+        visibility,
+        spatialScore: scores.spatialScore,
+        gradientScore: scores.gradientScore,
+        nearBlackRatio,
+        newlyClippedRatio,
+        visualArtifactCost: artifacts?.visualArtifactCost ?? null,
+        hasOriginalImageData: Boolean(originalImageData)
+    });
+
+    return {
+        ...visibility,
+        rawVisible: visibility.visible,
+        visible: visibility.visible && !metricRisk,
+        calibratedVisible: visibility.visible && !metricRisk,
+        metricRisk,
+        nearBlackRatio,
+        newlyClippedRatio,
+        rawSpatialScore: scores.spatialScore,
+        rawGradientScore: scores.gradientScore
+    };
+}
+
+export function classifyCalibratedResidualMetricRisk({
+    visibility,
+    spatialScore,
+    gradientScore,
+    nearBlackRatio = 0,
+    newlyClippedRatio = 0,
+    visualArtifactCost = null,
+    hasOriginalImageData = false
+}) {
+    if (visibility?.visible !== true) return null;
+
+    if (
+        visibility.visibleSpatialResidual === true &&
+        visibility.visiblePositiveHalo !== true &&
+        spatialScore <= -FLAT_CLIPPED_METRIC_RISK_MIN_NEGATIVE_SPATIAL &&
+        visibility.positiveHaloLum <= FLAT_CLIPPED_METRIC_RISK_MAX_POSITIVE_HALO_LUM &&
+        nearBlackRatio >= FLAT_CLIPPED_METRIC_RISK_NEAR_BLACK_RATIO &&
+        (
+            !hasOriginalImageData ||
+            newlyClippedRatio >= FLAT_CLIPPED_METRIC_RISK_NEWLY_CLIPPED_RATIO
+        )
+    ) {
+        return 'flat-clipped-low-texture-spatial-correlation';
+    }
+
+    if (
+        visibility.visibleGradientResidual !== true &&
+        spatialScore >= POSITIVE_SPATIAL_BACKGROUND_COLLISION_MIN_SPATIAL &&
+        gradientScore < POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_GRADIENT &&
+        visibility.positiveHaloLum <= POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_POSITIVE_HALO_LUM &&
+        visualArtifactCost !== null &&
+        visualArtifactCost <= POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_ARTIFACT_COST
+    ) {
+        return visibility.visiblePositiveHalo === true
+            ? 'positive-halo-background-collision'
+            : 'positive-spatial-background-collision';
+    }
+
+    if (
+        visibility.visiblePositiveHalo === true &&
+        visibility.visibleSpatialResidual !== true &&
+        visibility.visibleGradientResidual !== true &&
+        Math.abs(spatialScore) < WEAK_HALO_BACKGROUND_COLLISION_MAX_ABS_SPATIAL &&
+        gradientScore < WEAK_HALO_BACKGROUND_COLLISION_MAX_GRADIENT &&
+        visibility.positiveHaloLum <= WEAK_HALO_BACKGROUND_COLLISION_MAX_POSITIVE_HALO_LUM &&
+        nearBlackRatio < WEAK_HALO_BACKGROUND_COLLISION_MAX_NEAR_BLACK_RATIO &&
+        newlyClippedRatio <= WEAK_HALO_BACKGROUND_COLLISION_MAX_NEWLY_CLIPPED_RATIO &&
+        visualArtifactCost !== null &&
+        visualArtifactCost <= WEAK_HALO_BACKGROUND_COLLISION_MAX_ARTIFACT_COST
+    ) {
+        return 'weak-halo-background-collision';
+    }
+
+    if (
+        visibility.visiblePositiveHalo === true &&
+        visibility.visibleGradientResidual !== true &&
+        gradientScore >= STRUCTURED_EDGE_BACKGROUND_COLLISION_MIN_GRADIENT &&
+        nearBlackRatio < STRUCTURED_EDGE_BACKGROUND_COLLISION_MAX_NEAR_BLACK_RATIO &&
+        newlyClippedRatio <= STRUCTURED_EDGE_BACKGROUND_COLLISION_MAX_NEWLY_CLIPPED_RATIO &&
+        visualArtifactCost !== null &&
+        visualArtifactCost >= STRUCTURED_EDGE_BACKGROUND_COLLISION_MIN_ARTIFACT_COST
+    ) {
+        return 'structured-edge-background-collision';
+    }
+
+    return null;
+}
+
 function getReferenceRegion(position, imageData) {
     const referenceY = position.y - position.height;
     if (referenceY < 0) return null;