Drop canonical-hue ANSI fallback in auto-extract

Author: bjarneo

internal/extraction/analysis.go

@@ -255,39 +255,6 @@ func SortColorsByLightness(colors []string) []ColorLightnessInfo {
 	return result
 }
 
-// SynthesizeAnsiColor synthesizes an ANSI color when no good match exists in the image.
-// Uses the average chroma and lightness of already-assigned colors (in OKLCH) to create
-// a color that fits the palette's visual mood.
-func SynthesizeAnsiColor(targetHue float64, existingColors []string) string {
-	var totalC, totalL float64
-	count := 0
-
-	for _, c := range existingColors {
-		if c == "" {
-			continue
-		}
-		lch := color.HexToOKLCH(c)
-		if lch.C >= MinChromaForAnsiMatch {
-			totalC += lch.C
-			totalL += lch.L
-			count++
-		}
-	}
-
-	avgC := 0.10 // Default chroma for synthesis
-	avgL := 0.60 // Default lightness
-	if count > 0 {
-		avgC = totalC / float64(count)
-		avgL = totalL / float64(count)
-	}
-
-	// Clamp to sane ranges
-	synC := math.Max(0.06, math.Min(0.18, avgC))
-	synL := math.Max(0.40, math.Min(0.75, avgL))
-
-	return color.OKLCHToHex(color.OKLCH{L: synL, C: synC, H: targetHue})
-}
-
 // AnsiAssignment represents the assignment of a pool color to an ANSI slot.
 type AnsiAssignment struct {
 	PoolIndex int

internal/extraction/constants.go

@@ -2,7 +2,7 @@ package extraction
 
 const (
 	ANSIPaletteSize   = 16
-	CacheVersion      = 7 // Bumped: mono bg synthesis + relaxed thresholds
+	CacheVersion      = 8 // Bumped: auto-extract no longer synthesizes canonical-hue fallbacks
 	ImageScaleSize    = 400
 	MinPixelsToSample = 1000
 	MaxPixelsToSample = 50000
@@ -26,13 +26,12 @@ const (
 	MonochromeTintStrength = 0.15
 
 	// OKLCH scoring thresholds
-	MinChromaForAnsiMatch   = 0.035 // Minimum OKLCH chroma for a valid ANSI color match
-	LowChromaThreshold      = 0.05  // Low but visible chroma (mild penalty in scoring)
-	IdealChromaMin          = 0.06  // Sweet spot for ANSI colors
-	IdealChromaMax          = 0.20
-	TooDarkLightness        = 0.25 // OKLab L below this is too dark for ANSI colors
-	TooBrightLightness      = 0.87 // OKLab L above this is too bright
-	SynthesisScoreThreshold = 150.0
+	MinChromaForAnsiMatch = 0.035 // Minimum OKLCH chroma for a valid ANSI color match
+	LowChromaThreshold    = 0.05  // Low but visible chroma (mild penalty in scoring)
+	IdealChromaMin        = 0.06  // Sweet spot for ANSI colors
+	IdealChromaMax        = 0.20
+	TooDarkLightness      = 0.25 // OKLab L below this is too dark for ANSI colors
+	TooBrightLightness    = 0.87 // OKLab L above this is too bright
 
 	// Contrast thresholds
 	MinContrastRatio     = 4.5 // WCAG AA minimum for normal text

internal/extraction/palette_chromatic.go

@@ -10,6 +10,9 @@ import (
 // colors. Slots 8 and 9-15 are left empty — pass through finalizePalette to fill them.
 // Mode transforms call this directly when they intend to overwrite bg/fg/ANSI in OKLCH,
 // avoiding wasted slot 8/9-15 generation that the full chromatic pipeline would do.
+//
+// Slot 1-6 hues are taken verbatim from the image's best matches (no synthesis at
+// canonical sRGB primary hues). NormalizeBrightness handles AA contrast downstream.
 func extractChromaticHues(dominantColors []string, lightMode bool) [16]string {
 	topCount := 12
 	if len(dominantColors) < topCount {
@@ -34,40 +37,36 @@ func extractChromaticHues(dominantColors []string, lightMode bool) [16]string {
 
 	assignments := FindOptimalAnsiAssignment(dominantColors, usedIndices, lightMode)
 
-	var matchedColors []string
-	synthesizedSlots := [6]bool{}
 	for i := 0; i < 6; i++ {
 		assignment := assignments[i]
-		if assignment != nil && assignment.Score < SynthesisScoreThreshold {
-			lch := color.HexToOKLCH(dominantColors[assignment.PoolIndex])
-			if lch.C >= MinChromaForAnsiMatch {
-				palette[i+1] = dominantColors[assignment.PoolIndex]
-				matchedColors = append(matchedColors, palette[i+1])
-				usedIndices[assignment.PoolIndex] = true
-				continue
-			}
-		}
-		synthesizedSlots[i] = true
-	}
-
-	// Stagger synthesized slots so they don't all share the same lightness — without
-	// stagger, multiple synthesized slots end up at avgL with only hue differing,
-	// which is hard to distinguish at low chroma.
-	synthStagger := [6]float64{-0.06, +0.02, +0.07, -0.04, -0.02, +0.04}
-	for i := 0; i < 6; i++ {
-		if !synthesizedSlots[i] {
+		if assignment != nil {
+			palette[i+1] = dominantColors[assignment.PoolIndex]
+			usedIndices[assignment.PoolIndex] = true
 			continue
 		}
-		base := SynthesizeAnsiColor(OKLCHAnsiHues[i], matchedColors)
-		lch := color.HexToOKLCH(base)
-		lch.L = math.Max(0.30, math.Min(0.85, lch.L+synthStagger[i]))
-		palette[i+1] = color.OKLCHToHex(lch)
-		matchedColors = append(matchedColors, palette[i+1])
+		// Pool exhausted — the optimal-assignment loop ran out of unused colors.
+		// Fall back to the next available pool entry rather than synthesizing a
+		// canonical-hue color that isn't in the image.
+		palette[i+1] = nextUnusedColor(dominantColors, usedIndices)
 	}
 
 	return palette
 }
 
+// nextUnusedColor returns the first dominant color not yet claimed by another slot,
+// marking it used. Returns the first pool entry as a last resort when the pool is
+// fully consumed (extremely degenerate — len(dominantColors) is bounded ≥ 8 by
+// ExtractColors).
+func nextUnusedColor(dominantColors []string, usedIndices map[int]bool) string {
+	for i, c := range dominantColors {
+		if !usedIndices[i] {
+			usedIndices[i] = true
+			return c
+		}
+	}
+	return dominantColors[0]
+}
+
 // synthesizeBgIfTooMid replaces a mid-lightness image bg with a synthesized OKLCH
 // color at a sane bg lightness, preserving hue. Without this, images with no truly
 // dark/light pixels (e.g. a sunset photo or a Nord-themed wallpaper) produce muddy
@@ -87,8 +86,11 @@ func synthesizeBgIfTooMid(bgColor string, lightMode bool) string {
 }
 
 // GenerateChromaticPalette: vibrant chromatic palette from image-derived hues.
-// OKLCH-based optimal assignment for slots 1-6, contrast-aware bg/fg, synthesized
-// missing hues. finalizePalette derives slots 8/9-15 and enforces AA contrast.
+// OKLCH-based optimal assignment for slots 1-6, contrast-aware bg/fg. Slots 1-6
+// always come from the image — the pipeline does not synthesize canonical-hue
+// fallbacks, so wallpapers without a strong red/green/etc. produce palettes
+// faithful to the source rather than to ANSI conventions.
+// finalizePalette derives slots 8/9-15 and enforces AA contrast.
 func GenerateChromaticPalette(dominantColors []string, lightMode bool) [16]string {
 	palette := extractChromaticHues(dominantColors, lightMode)
 	finalizePalette(&palette)