Autopep8 colormath

Author: lukelbd

proplot/colormath.py

@@ -1,11 +1,12 @@
 #!/usr/bin/env python3
 """
-Tools for converting between various colorspaces. Adapted from
-`seaborn <https://github.com/mwaskom/seaborn/blob/master/seaborn/external/husl.py>`__
-and `hsluv-python <https://github.com/hsluv/hsluv-python/blob/master/hsluv.py>`__.
+Tools for converting between various colorspaces. Adapted from `seaborn
+<https://github.com/mwaskom/seaborn/blob/master/seaborn/external/husl.py>`__
+and `hsluv-python
+<https://github.com/hsluv/hsluv-python/blob/master/hsluv.py>`__.
 For more info on colorspaces see the
-`CIULUV specification <https://en.wikipedia.org/wiki/CIELUV>`__,
-the `CIE 1931 colorspace <https://en.wikipedia.org/wiki/CIE_1931_color_space>`__,
+`CIULUV specification <https://en.wikipedia.org/wiki/CIELUV>`__, the
+`CIE 1931 colorspace <https://en.wikipedia.org/wiki/CIE_1931_color_space>`__,
 the `HCL colorspace <https://en.wikipedia.org/wiki/HCL_color_space>`__,
 and the `HSLuv system <http://www.hsluv.org/implementations/>`__.
 
@@ -36,82 +37,89 @@
     [3.2406, -1.5372, -0.4986],
     [-0.9689, 1.8758, 0.0415],
     [0.0557, -0.2040, 1.0570]
-    ]
+]
 m_inv = [
     [0.4124, 0.3576, 0.1805],
     [0.2126, 0.7152, 0.0722],
     [0.0193, 0.1192, 0.9505]
-    ]
+]
 # Hard-coded D65 illuminant (has to do with expected light intensity and
 # white balance that falls upon the generated color)
 # See: https://en.wikipedia.org/wiki/Illuminant_D65
 # Also: https://github.com/hsluv/hsluv-python/issues/3
-refX  = 0.95047
-refY  = 1.00000
-refZ  = 1.08883
-refU  = 0.19784
-refV  = 0.46834
+refX = 0.95047
+refY = 1.00000
+refZ = 1.08883
+refU = 0.19784
+refV = 0.46834
 lab_e = 0.008856
 lab_k = 903.3
 
-#------------------------------------------------------------------------------#
-# Public API
-#------------------------------------------------------------------------------#
-# Basic conversion
+
 def hsluv_to_rgb(h, s, l):
     return lchuv_to_rgb(*hsluv_to_lchuv([h, s, l]))
 
+
 def hsluv_to_hex(h, s, l):
     return rgb_to_hex(hsluv_to_rgb(h, s, l))
 
+
 def rgb_to_hsluv(r, g, b):
     return lchuv_to_hsluv(rgb_to_lchuv(r, g, b))
 
+
 def hex_to_hsluv(color):
     return rgb_to_hsluv(*hex_to_rgb(color))
 
+
 def hpluv_to_rgb(h, s, l):
     return lchuv_to_rgb(*hpluv_to_lchuv([h, s, l]))
 
+
 def hpluv_to_hex(h, s, l):
     return rgb_to_hex(hpluv_to_rgb(h, s, l))
 
+
 def rgb_to_hpluv(r, g, b):
     return lchuv_to_hpluv(rgb_to_lchuv(r, g, b))
 
+
 def hex_to_hpluv(color):
     return rgb_to_hpluv(*hex_to_rgb(color))
 
+
 def lchuv_to_rgb(l, c, h):
     return CIExyz_to_rgb(CIEluv_to_CIExyz(lchuv_to_CIEluv([l, c, h])))
 
+
 def rgb_to_lchuv(r, g, b):
     return CIEluv_to_lchuv(CIExyz_to_CIEluv(rgb_to_CIExyz([r, g, b])))
 
-# Make ordering of channels consistent with above functions
+
 def hsl_to_rgb(h, s, l):
     h /= 360.0
     s /= 100.0
-    l /= 100.0
-    return  hls_to_rgb(h, l, s)
+    l /= 100.0  # noqa
+    return hls_to_rgb(h, l, s)
+
 
 def rgb_to_hsl(r, g, b):
     h, l, s = rgb_to_hls(r, g, b)
     h *= 360.0
     s *= 100.0
-    l *= 100.0
+    l *= 100.0  # noqa
     return h, s, l
 
+
 def hcl_to_rgb(h, c, l):
     return CIExyz_to_rgb(CIEluv_to_CIExyz(lchuv_to_CIEluv([l, c, h])))
 
+
 def rgb_to_hcl(r, g, b):
     l, c, h = CIEluv_to_lchuv(CIExyz_to_CIEluv(rgb_to_CIExyz([r, g, b])))
     return h, c, l
 
-#------------------------------------------------------------------------------#
-# RGB to HEX conversions
-#------------------------------------------------------------------------------#
+
 def rgb_prepare(triple):
     ret = []
     for ch in triple:
@@ -122,13 +130,16 @@ def rgb_prepare(triple):
             ch = 0
         if ch > 1:
             ch = 1
-        ret.append(int(round(ch * 255 + 0.001, 0))) # the +0.001 fixes rounding error
+        # the +0.001 fixes rounding error
+        ret.append(int(round(ch * 255 + 0.001, 0)))
     return ret
 
+
 def rgb_to_hex(triple):
     [r, g, b] = triple
     return '#%02x%02x%02x' % tuple(rgb_prepare([r, g, b]))
 
+
 def hex_to_rgb(color):
     if color.startswith('#'):
         color = color[1:]
@@ -137,9 +148,7 @@ def hex_to_rgb(color):
     b = int(color[4:6], 16) / 255.0
     return [r, g, b]
 
-#------------------------------------------------------------------------------#
-# Helper functions for fancier conversions
-#------------------------------------------------------------------------------#
+
 def max_chroma(L, H):
     hrad = math.radians(H)
     sinH = (math.sin(hrad))
@@ -162,16 +171,19 @@ def max_chroma(L, H):
     # print('maxima', result)
     return result
 
+
 def hrad_extremum(L):
-    lhs = (math.pow(L, 3.0) + 48.0 * math.pow(L, 2.0) + 768.0 * L + 4096.0) / 1560896.0
+    lhs = (math.pow(L, 3.0) + 48.0 * math.pow(L, 2.0)
+           + 768.0 * L + 4096.0) / 1560896.0
     rhs = 1107.0 / 125000.0
     sub = lhs if lhs > rhs else 10.0 * L / 9033.0
-    chroma = float("inf")
+    chroma = float('inf')
     result = None
     for row in m:
         for limit in (0.0, 1.0):
             [m1, m2, m3] = row
-            top = -3015466475.0 * m3 * sub + 603093295.0 * m2 * sub - 603093295.0 * limit
+            top = -3015466475.0 * m3 * sub + 603093295.0 * m2 * sub \
+                - 603093295.0 * limit
             bottom = 1356959916.0 * m1 * sub - 452319972.0 * m3 * sub
             hrad = math.atan2(top, bottom)
             if limit == 0.0:
@@ -182,13 +194,12 @@ def hrad_extremum(L):
                 result = hrad
     return result
 
+
 def max_chroma_pastel(L):
     H = math.degrees(hrad_extremum(L))
     return max_chroma(L, H)
 
-#------------------------------------------------------------------------------#
-# Converting between the fancy colorspaces
-#------------------------------------------------------------------------------#
+
 def hsluv_to_lchuv(triple):
     H, S, L = triple
     if L > 99.9999999:
@@ -201,6 +212,7 @@ def hsluv_to_lchuv(triple):
     #     raise ValueError(f'HSL color {triple} is outside LCH colorspace.')
     return [L, C, H]
 
+
 def lchuv_to_hsluv(triple):
     L, C, H = triple
     if L > 99.9999999:
@@ -211,6 +223,7 @@ def lchuv_to_hsluv(triple):
     S = 100.0 * C / mx
     return [H, S, L]
 
+
 def hpluv_to_lchuv(triple):
     H, S, L = triple
     if L > 99.9999999:
@@ -223,6 +236,7 @@ def hpluv_to_lchuv(triple):
     #     raise ValueError(f'HPL color {triple} is outside LCH colorspace.')
     return [L, C, H]
 
+
 def lchuv_to_hpluv(triple):
     L, C, H = triple
     if L > 99.9999999:
@@ -233,34 +247,37 @@ def lchuv_to_hpluv(triple):
     S = 100.0 * C / mx
     return [H, S, L]
 
-#------------------------------------------------------------------------------#
-# Converting to CIE official colorspace coordinates
-#------------------------------------------------------------------------------#
+
 def dot_product(a, b):
-    return sum(i*j for i,j in zip(a,b))
+    return sum(i * j for i, j in zip(a, b))
     # return sum(map(operator.mul, a, b))
 
+
 def from_linear(c):
     if c <= 0.0031308:
         return 12.92 * c
     else:
         return (1.055 * math.pow(c, 1.0 / 2.4) - 0.055)
 
+
 def to_linear(c):
     a = 0.055
     if c > 0.04045:
         return (math.pow((c + a) / (1.0 + a), 2.4))
     else:
         return (c / 12.92)
 
+
 def CIExyz_to_rgb(triple):
     CIExyz = map(lambda row: dot_product(row, triple), m)
     return list(map(from_linear, CIExyz))
 
+
 def rgb_to_CIExyz(triple):
     rgbl = list(map(to_linear, triple))
     return list(map(lambda row: dot_product(row, rgbl), m_inv))
 
+
 def CIEluv_to_lchuv(triple):
     L, U, V = triple
     C = (math.pow(math.pow(U, 2) + math.pow(V, 2), (1.0 / 2.0)))
@@ -270,33 +287,34 @@ def CIEluv_to_lchuv(triple):
         H = 360.0 + H
     return [L, C, H]
 
+
 def lchuv_to_CIEluv(triple):
     L, C, H = triple
     Hrad = math.radians(H)
     U = (math.cos(Hrad) * C)
     V = (math.sin(Hrad) * C)
     return [L, U, V]
 
-#------------------------------------------------------------------------------#
-# Converting between different CIE standards
-#------------------------------------------------------------------------------#
+
 # Try setting gamma from: https://en.wikipedia.org/wiki/HCL_color_space
 # The 3.0 used below should be the same; don't mess with it
-gamma = 3.0 # tunable? nah, get weird stuff
+gamma = 3.0  # tunable? nah, get weird stuff
+
 
-# Functiona
 def CIEfunc(t):
     if t > lab_e:
         return (math.pow(t, 1.0 / gamma))
     else:
         return (7.787 * t + 16.0 / 116.0)
 
+
 def CIEfunc_inverse(t):
     if math.pow(t, 3.0) > lab_e:
         return (math.pow(t, gamma))
     else:
         return (116.0 * t - 16.0) / lab_k
 
+
 def CIExyz_to_CIEluv(triple):
     X, Y, Z = triple
     if X == Y == Z == 0.0:
@@ -311,6 +329,7 @@ def CIExyz_to_CIEluv(triple):
     V = 13.0 * L * (varV - refV)
     return [L, U, V]
 
+
 def CIEluv_to_CIExyz(triple):
     L, U, V = triple
     if L == 0:
@@ -322,4 +341,3 @@ def CIEluv_to_CIExyz(triple):
     X = 0.0 - (9.0 * Y * varU) / ((varU - 4.0) * varV - varU * varV)
     Z = (9.0 * Y - (15.0 * varV * Y) - (varV * X)) / (3.0 * varV)
     return [X, Y, Z]
-