130 lines
2.5 KiB
Python
Executable File
130 lines
2.5 KiB
Python
Executable File
#! /usr/gitea.inhome.blapointe.com/local/bin/python3
|
|
|
|
def main(args) :
|
|
print("args", args)
|
|
for i in args :
|
|
rotate(i)
|
|
|
|
def rotate(x) :
|
|
print("input: {}", x)
|
|
rgb = hex_to_rgb(x)
|
|
print("rgb: {}", rgb)
|
|
hsl = rgb_to_hsl(rgb)
|
|
print("hsl: {}", hsl)
|
|
import os
|
|
env = os.environ
|
|
if "DEG" in env :
|
|
deg = int(env["DEG"])
|
|
else :
|
|
deg = 110
|
|
hsl = rotate_hsl(hsl, deg)
|
|
print("hsl': {}", hsl)
|
|
rgb = hsl_to_rgb(hsl)
|
|
print("rgb': {}", rgb)
|
|
print(rgb_to_hex(rgb))
|
|
|
|
def hex_to_rgb(x) :
|
|
if x.startswith("#") :
|
|
x = x[1:]
|
|
r = x[0:2]
|
|
g = x[2:4]
|
|
b = x[4:6]
|
|
return (
|
|
hex_to_dec(r),
|
|
hex_to_dec(g),
|
|
hex_to_dec(b),
|
|
)
|
|
|
|
def hex_to_dec(x) :
|
|
s = 0
|
|
mul = 1
|
|
for i in range(len(x)):
|
|
c = x[len(x)-i-1]
|
|
c = c.upper()
|
|
digit = ord(c) - ord('0')
|
|
if not c.isdigit() :
|
|
digit = ord(c) - ord('A') + 10
|
|
s += mul * digit
|
|
mul *= 16
|
|
return s
|
|
|
|
def rgb_to_hsl(rgb) :
|
|
return (
|
|
compute_h(rgb),
|
|
compute_s(rgb),
|
|
compute_l(rgb),
|
|
)
|
|
|
|
def compute_h(rgb) :
|
|
r, g, b, cmax, cmin, delta = compute_hsl_const(rgb)
|
|
if delta == 0 :
|
|
return 0
|
|
if r == cmax :
|
|
return 60 * ( ( (g - b)/delta ) % 6)
|
|
if g == cmax :
|
|
return 60 * ( ( (b - r)/delta ) + 2)
|
|
if b == cmax :
|
|
return 60 * ( ( (r - g)/delta ) + 4)
|
|
|
|
def compute_s(rgb) :
|
|
r, g, b, cmax, cmin, delta = compute_hsl_const(rgb)
|
|
if delta == 0 :
|
|
return 0
|
|
return delta / ( 1 - (abs(2*compute_l(rgb)-1)) )
|
|
|
|
def compute_l(rgb) :
|
|
r, g, b, cmax, cmin, delta = compute_hsl_const(rgb)
|
|
return (cmax + cmin) / 2
|
|
|
|
def compute_hsl_const(rgb) :
|
|
rgb = [ i/255.0 for i in rgb ]
|
|
return rgb[:] + [max(rgb), min(rgb), max(rgb)-min(rgb)]
|
|
|
|
def rotate_hsl(hsl, deg) :
|
|
return (
|
|
(hsl[0] + deg) % 360,
|
|
hsl[1],
|
|
hsl[2],
|
|
)
|
|
|
|
def hsl_to_rgb(hsl) :
|
|
h = hsl[0]
|
|
s = hsl[1]
|
|
l = hsl[2]
|
|
|
|
c = s * (1 - abs(2 * l))
|
|
x = c * (1 - abs((h / 60) % 2 - 1))
|
|
m = l - (c / 2)
|
|
|
|
rgbp = ()
|
|
if h < 60 :
|
|
rgbp = (c, x, 0)
|
|
if h < 120 :
|
|
rgbp = (x, c, 0)
|
|
if h < 180 :
|
|
rgbp = (0, c, x)
|
|
if h < 240 :
|
|
rgbp = (0, x, c)
|
|
if h < 300 :
|
|
rgbp = (x, 0, c)
|
|
else:
|
|
rgbp = (c, 0, x)
|
|
|
|
r = rgbp[0]
|
|
g = rgbp[1]
|
|
b = rgbp[2]
|
|
return (
|
|
(r+m)*255,
|
|
(g+m)*255,
|
|
(b+m)*255,
|
|
)
|
|
|
|
def rgb_to_hex(rgb) :
|
|
r = min(max(int(rgb[0]), 0), 255)
|
|
g = min(max(int(rgb[1]), 0), 255)
|
|
b = min(max(int(rgb[2]), 0), 255)
|
|
return "#{:02x}{:02x}{:02x}".format(r, g, b)
|
|
|
|
from sys import argv
|
|
main(argv[1:])
|