go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/experiments/huectl/pkg/hue/color.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package hue

import (
	"fmt"
	"image/color"
	"math"
	"strconv"
)

var (
	// ColorTransparent is a fully transparent color.
	ColorTransparent = Color{}

	// ColorWhite is white.
	ColorWhite = Color{R: 255, G: 255, B: 255, A: 255}

	// ColorBlack is black.
	ColorBlack = Color{R: 0, G: 0, B: 0, A: 255}

	// ColorRed is red.
	ColorRed = Color{R: 255, G: 0, B: 0, A: 255}

	// ColorGreen is green.
	ColorGreen = Color{R: 0, G: 255, B: 0, A: 255}

	// ColorBlue is blue.
	ColorBlue = Color{R: 0, G: 0, B: 255, A: 255}
)

// ColorFromHex returns a color from a css hex code.
//
// An example might be #efefef which would yield a
// color with R=239, G=239, B=239, A=255.
func ColorFromHex(hex string) Color {
	var c Color
	if len(hex) == 3 {
		c.R = parseHex(string(hex[0])) * 0x11
		c.G = parseHex(string(hex[1])) * 0x11
		c.B = parseHex(string(hex[2])) * 0x11
	} else {
		c.R = parseHex(string(hex[0:2]))
		c.G = parseHex(string(hex[2:4]))
		c.B = parseHex(string(hex[4:6]))
	}
	c.A = 255
	return c
}

var (
	_ color.Color = (*Color)(nil)
)

// Color is our internal color type because color.Color is bad.
//
// Each "channel" (i.e. R, G, B, or A) are 0-255 values.
type Color struct {
	R, G, B, A uint8
}

// RGBA returns the color as a pre-alpha mixed color set.
//
// It also returns the alpha channel, though effectively
// the RGB values are modified by it already.
func (c Color) RGBA() (r, g, b, a uint32) {
	fa := float64(c.A) / 255.0
	r = uint32(float64(uint32(c.R)) * fa)
	r |= r << 8
	g = uint32(float64(uint32(c.G)) * fa)
	g |= g << 8
	b = uint32(float64(uint32(c.B)) * fa)
	b |= b << 8
	a = uint32(c.A)
	a |= a << 8
	return
}

// IsZero returns if the color has been set or not.
func (c Color) IsZero() bool {
	return c.R == 0 && c.G == 0 && c.B == 0 && c.A == 0
}

// IsTransparent returns if the colors alpha channel is zero.
func (c Color) IsTransparent() bool {
	return c.A == 0
}

// WithAlpha returns a copy of the color with a given alpha.
func (c Color) WithAlpha(a uint8) Color {
	return Color{
		R: c.R,
		G: c.G,
		B: c.B,
		A: a,
	}
}

// Equals returns true if the color equals another.
func (c Color) Equals(other Color) bool {
	return c.R == other.R &&
		c.G == other.G &&
		c.B == other.B &&
		c.A == other.A
}

// AverageWith averages two colors.
func (c Color) AverageWith(other Color) Color {
	return Color{
		R: (c.R + other.R) >> 1,
		G: (c.G + other.G) >> 1,
		B: (c.B + other.B) >> 1,
		A: c.A,
	}
}

// String returns a css string representation of the color.
func (c Color) String() string {
	fa := float64(c.A) / float64(255)
	return fmt.Sprintf("rgba(%v,%v,%v,%.1f)", c.R, c.G, c.B, fa)
}

func parseHex(hex string) uint8 {
	v, _ := strconv.ParseInt(hex, 16, 16)
	return uint8(v)
}

// XYPoint is a struct of two float64 points.
type XYPoint struct{ X, Y float64 }

// GamutA is a gamut profile.
var GamutA = []XYPoint{
	{0.704, 0.296},
	{0.2151, 0.7106},
	{0.138, 0.08},
}

// GamutB is a gamut profile.
var GamutB = []XYPoint{
	{0.675, 0.322},
	{0.4091, 0.518},
	{0.167, 0.04},
}

// GamutC is a gamut profile.
var GamutC = []XYPoint{
	{0.692, 0.308},
	{0.17, 0.7},
	{0.153, 0.048},
}

// GetGamutForModelID returns the gamut for a given model id.
func GetGamutForModelID(modelID string) []XYPoint {
	switch modelID {
	case "LST001", "LLC005", "LLC006", "LLC007", "LLC010", "LLC011", "LLC012", "LLC013", "LLC014":
		return GamutA
	case "LCT001", "LCT007", "LCT002", "LCT003", "LLM001":
		return GamutB
	case "LCT010", "LCT011", "LCT012", "LCT014", "LCT015", "LCT016", "LLC020", "LST002":
		return GamutC
	default:
		return GamutC
	}
}

// XY converts a given RGB color to the xy color in a given gamut.
func (c Color) XY(gamut []XYPoint) []float32 {
	red := float64(c.R) / 255.0
	green := float64(c.G) / 255.0
	blue := float64(c.B) / 255.0

	var r, g, b float64
	if red > 0.04045 {
		r = math.Pow((red+0.055)/(1.0+0.055), 2.4)
	} else {
		r = (red / 12.92)
	}
	if green > 0.04045 {
		g = math.Pow((green+0.055)/(1.0+0.055), 2.4)
	} else {
		g = green / 12.92
	}
	if blue > 0.04045 {
		b = math.Pow((blue+0.055)/(1.0+0.055), 2.4)
	} else {
		b = blue / 12.92
	}

	X := r*0.664511 + g*0.154324 + b*0.162028
	Y := r*0.283881 + g*0.668433 + b*0.047685
	Z := r*0.000088 + g*0.072310 + b*0.986039

	cx := X / (X + Y + Z)
	cy := Y / (X + Y + Z)

	// check if the given XY value is within the colourreach of our lamps.
	xyPoint := XYPoint{cx, cy}
	if !GamutContains(gamut, xyPoint) {
		xyPoint = GamutPoint(gamut, xyPoint)
	}
	return []float32{float32(xyPoint.X), float32(xyPoint.Y)}
}

// CrossProduct returns the cross product of two given points.
func CrossProduct(p1, p2 XYPoint) float64 {
	return (p1.X*p2.Y - p1.Y*p2.X)
}

// GamutContains returns if a given point exists in a given gamut.
func GamutContains(gamut []XYPoint, p XYPoint) bool {
	v1 := XYPoint{gamut[1].X - gamut[0].X, gamut[1].Y - gamut[0].Y}
	v2 := XYPoint{gamut[2].X - gamut[0].X, gamut[2].Y - gamut[0].Y}
	q := XYPoint{p.X - gamut[0].X, p.Y - gamut[0].Y}
	s := CrossProduct(q, v2) / CrossProduct(v1, v2)
	t := CrossProduct(v1, q) / CrossProduct(v1, v2)
	return (s >= 0.0) && (t >= 0.0) && (s+t <= 1.0)
}

// GetClosestPointToLine returns the closest point to a given line.
func GetClosestPointToLine(a, b, p XYPoint) XYPoint {
	ap := XYPoint{p.X - a.X, p.Y - a.Y}
	ab := XYPoint{p.X - a.X, b.Y - a.Y}
	ab2 := ab.X*ab.X + ab.Y*ab.Y
	apab := ap.X*ab.X + ap.Y*ab.Y
	t := apab / ab2
	if t < 0.0 {
		t = 0.0
	} else if t > 1.0 {
		t = 1.0
	}
	return XYPoint{a.X + ab.X*t, a.Y + ab.Y*t}
}

// GetDistance gets the distance between two points.
func GetDistance(one, two XYPoint) float64 {
	dx := one.X - two.X
	dy := one.Y - two.Y
	return math.Sqrt(dx*dx + dy*dy)
}

// GamutPoint returns the closest point in a gamut to a given point.
func GamutPoint(gamut []XYPoint, p XYPoint) XYPoint {
	pAB := GetClosestPointToLine(gamut[0], gamut[1], p)
	pAC := GetClosestPointToLine(gamut[2], gamut[0], p)
	pBC := GetClosestPointToLine(gamut[1], gamut[2], p)

	// get the distances per point and see which point is closer to our Point
	dAB := GetDistance(p, pAB)
	dAC := GetDistance(p, pAC)
	dBC := GetDistance(p, pBC)

	lowest := dAB
	closestPoint := pAB
	if dAC < lowest {
		lowest = dAC
		closestPoint = pAC
	}
	if dBC < lowest {
		closestPoint = pBC
	}
	return closestPoint
}