117 lines
2.4 KiB
Go
117 lines
2.4 KiB
Go
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Copyright ©2011-2013 The bíogo Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package palette
|
|
|
|
import (
|
|
"image/color"
|
|
"math"
|
|
)
|
|
|
|
// HSVA represents a Hue/Saturation/Value/Alpha color.
|
|
// H, S, V and A are valid within [0, 1].
|
|
type HSVA struct {
|
|
H, S, V, A float64
|
|
}
|
|
|
|
// HSVAModel converts any color.Color to an HSVA color.
|
|
var HSVAModel = color.ModelFunc(hsvaModel)
|
|
|
|
func hsvaModel(c color.Color) color.Color {
|
|
if _, ok := c.(HSVA); ok {
|
|
return c
|
|
}
|
|
return rgbaToHsva(c.RGBA())
|
|
}
|
|
|
|
// Convert r, g, b, a to HSVA
|
|
func rgbaToHsva(r, g, b, a uint32) HSVA {
|
|
red := float64(r)
|
|
blue := float64(b)
|
|
green := float64(g)
|
|
|
|
max := math.Max(red, green)
|
|
max = math.Max(max, blue)
|
|
min := math.Min(red, green)
|
|
min = math.Min(min, blue)
|
|
chroma := max - min
|
|
|
|
var hue float64
|
|
switch {
|
|
case chroma == 0:
|
|
// This should really be math.NaN() since we have a 0 length vector,
|
|
// but 0 seems to be the convention and it may simplify imports in
|
|
// dependent packages.
|
|
hue = 0
|
|
case max == red:
|
|
hue = math.Mod((green-blue)/chroma, 6)
|
|
case max == green:
|
|
hue = (blue-red)/chroma + 2
|
|
case max == blue:
|
|
hue = (red-green)/chroma + 4
|
|
}
|
|
|
|
hue /= 6
|
|
|
|
var s float64
|
|
if chroma != 0 {
|
|
s = chroma / max
|
|
}
|
|
|
|
return HSVA{
|
|
H: math.Mod(math.Mod(hue, 1)+1, 1),
|
|
S: s,
|
|
V: max / math.MaxUint16,
|
|
A: float64(a) / math.MaxUint16,
|
|
}
|
|
}
|
|
|
|
// RGBA allows HSVAColor to satisfy the color.Color interface.
|
|
func (c HSVA) RGBA() (r, g, b, a uint32) {
|
|
var red, green, blue float64
|
|
|
|
a = uint32(math.MaxUint16 * c.A)
|
|
|
|
if c.V == 0 {
|
|
return
|
|
}
|
|
|
|
if c.S == 0 {
|
|
r, g, b = uint32(math.MaxUint16*c.V), uint32(math.MaxUint16*c.V), uint32(math.MaxUint16*c.V)
|
|
return
|
|
}
|
|
|
|
chroma := c.V * c.S
|
|
m := c.V - chroma
|
|
|
|
if !math.IsNaN(c.H) {
|
|
hue := math.Mod(c.H, 1) * 6
|
|
x := chroma * (1 - math.Abs(math.Mod(hue, 2)-1))
|
|
switch math.Floor(hue) {
|
|
case 0:
|
|
red, green = chroma, x
|
|
case 1:
|
|
red, green = x, chroma
|
|
case 2:
|
|
green, blue = chroma, x
|
|
case 3:
|
|
green, blue = x, chroma
|
|
case 4:
|
|
red, blue = x, chroma
|
|
case 5:
|
|
red, blue = chroma, x
|
|
}
|
|
} else {
|
|
red, green, blue = 0, 0, 0
|
|
}
|
|
|
|
r, g, b = uint32(math.MaxUint16*(red+m)), uint32(math.MaxUint16*(green+m)), uint32(math.MaxUint16*(blue+m))
|
|
|
|
return
|
|
}
|