typo

Signed-off-by: Mattias Andrée <maandree@operamail.com>

1 files changed, 275 insertions, 0 deletions

diff --git a/examples/comprehensive b/examples/comprehensive
new file mode 100644
index 0000000..653cd8b
--- /dev/null
+++ b/examples/comprehensive
@@ -0,0 +1,275 @@
+# -*- python -*-
+
+# This example is complete with exceptions for less normal colour
+# curve modifiers: nothing else than CIE 1964 10 degree CMF for
+# colour temperature, not use of temporarly linear RGB curves,
+# negative image, sigmoid correction, or free function modifier.
+
+
+# Geographical coodinates.
+# (KTH computer laboratories in this example.)
+latitude, longitude = 59.3472, 18.0728
+
+# Custom dayness by time settings
+time_alpha = [['02:00', 0], ['08:00', 1], ['22:00', 1]]
+
+
+def by_time():
+    '''
+    Dayness calculation using time
+    '''
+    if isinstance(time_alpha[0][0], str):
+        for i in range(len(time_alpha)):
+            hh = [float(x) for x in time_alpha[i][0].split(':')]
+            hh = sum([hh[j] / 60 ** j for j in range(len(hh))])
+            time_alpha[i][0] = hh
+    now = datetime.datetime.now()
+    hh = now.hour + now.minute / 60 + now.second / 60 ** 2
+    for i in range(len(time_alpha)):
+        (a, av) = time_alpha[i]
+        (b, bv) = time_alpha[(i + 1) % len(time_alpha)]
+        if a < hh:  a += 24
+        if b < hh:  b += 24
+        if a <= hh <= b:
+            hh = (hh - a) / (b - a)
+            return av * (1 - hh) + bv * hh
+    return 1 # Error in `time_alpha` (probably)
+
+
+# Keep uncomment to use solar position
+get_dayness = lambda : sun(latitude, longitude)
+# Uncomment to use time of day
+#get_dayness = by_time
+# Uncomment if you do not want continuous mode, high night values are used
+#get_dayness = None
+
+
+# The (zero-based) index of the monitors (CRTC:s) to apply
+# settings to. An empty list means that all monitors are used,
+# but all monitors will have the same settings.
+monitors = []
+
+
+# The following settings are lists. This is to allow you to
+# use different settings on different monitors. For example,
+# `gamma_red_day = [1]`, this means that during high day, the
+# red gamma is 1 on all monitors. But if we change this to
+# `gamma_red_day = [1.0, 1.1]`, the first monitor will have
+# the red gamma set to 1,0 and the second monitor will have
+# the red gamma set to 1,1. If you have more monitors than
+# used in the settings modulo division will be used. For
+# instance, if you have four monitors, the third monitor will
+# have the same settings as the first monitor, and the fourth
+# monitor will have the same settings as the second monitor.
+
+
+# Colour temperature at high day and high night, respectively.
+temperature_day, temperature_night = [6500], [3700]
+
+
+# Colour brightness at high day and high night, respectively.
+# This setting uses the CIE xyY colour space for calculating values.
+brightness_day, brightness_night = [1], [1]
+
+# Colour brightness of the red, green and blue components,
+# respectively, at high day and high night, respectively.
+# This settings uses the sRGB colour space for calculating values.
+brightness_red_day, brightness_red_night = [1], [1]
+brightness_green_day, brightness_green_night = [1], [1]
+brightness_blue_day, brightness_blue_night = [1], [1]
+
+
+# Colour contrast at high day and high night, respectively.
+# This setting uses the CIE xyY colour space for calculating values.
+contrast_day, contrast_night = [1], [1]
+
+# Colour contrast of the red, green and blue components,
+# respectively, at high day and high night, respectively.
+# This settings uses the sRGB colour space for calculating values.
+contrast_red_day, contrast_red_night = [1], [1]
+contrast_green_day, contrast_green_night = [1], [1]
+contrast_blue_day, contrast_blue_night = [1], [1]
+
+
+# Note: brightness and contrast is not intended for colour
+# calibration, it should be calibrated on the monitors'
+# control panels.
+
+
+# Gamma correction for the red, green and blue components, respectively,
+# at high day, high night and monitor default, respectively.
+# This settings uses the sRGB colour space for calculating values.
+gamma_red_day, gamma_red_night, gamma_red_default = [1], [1], [1]
+gamma_green_day, gamma_green_night, gamma_green_default = [1], [1], [1]
+gamma_blue_day, gamma_blue_night, gamma_blue_default = [1], [1], [1]
+
+
+# Note: gamma is supposted to be static, it purpose is to
+# correct the colours on the monitors the monitor's gamma
+# is exactly 2,2 and the colours look correct in relation
+# too each other. It is supported to have different settings
+# at day and night because there are no technical limitings
+# and it can presumable increase readability on text when
+# the colour temperature is low.
+
+
+monitor_controller = lambda : randr(*monitors)
+'''
+:()→void  Function used by Blueshift on exit to apply reset colour curves, if using preimplemented `reset`
+'''
+
+
+def periodically(year, month, day, hour, minute, second, weekday, fade):
+    '''
+    :(int, int, int, int, int, int, int, float?)?→void  Place holder for periodically invoked function
+    
+    Invoked periodically
+    
+    If you want to control at what to invoke this function next time
+    you can set the value of the global variable `wait_period` to the
+    number of seconds to wait before invoking this function again.
+    The value does not need to be an integer.
+    
+    @param   year:int     The year
+    @param   month:int    The month, 1 = January, 12 = December
+    @param   day:int      The day, minimum value is 1, probable maximum value is 31 (*)
+    @param   hour:int     The hour, minimum value is 0, maximum value is 23
+    @param   minute:int   The minute, minimum value is 0, maximum value is 59
+    @param   second:int   The second, minimum value is 0, probable maximum value is 60 (**)
+    @param   weekday:int  The weekday, 1 = Monday, 7 = Sunday
+    @param   fade:float?  Blueshift can use this function to fade into a state when it start
+                          or exits. `fade` can either be negative, zero or positive or `None`,
+                          but the magnitude of value cannot exceed 1. When Blueshift starts,
+                          the this function will be invoked multiple with the time parameters
+                          of the time it is invoked and each time `fade` will increase towards
+                          1, starting at 0, when the value is 1, the settings should be applied
+                          to 100 %. After this this function will be invoked once again with
+                         `fade` being `None`. When Blueshift exits the same behaviour is used
+                          except, `fade` decrease towards -1 but start slightly below 0, when
+                          -1 is reached all settings should be normal. Then Blueshift will NOT
+                          invoke this function with `fade` being `None`, instead it will by
+                          itself revert all settings and quit.
+    
+    (*)  Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
+    (**) See https://en.wikipedia.org/wiki/Leap_second
+    '''
+    dayness = get_dayness()
+    
+    # Help functions for colour interpolation
+    interpol = lambda _day, _night : _day[m % len(_day)] * dayness + _night[m % len(_night)] * (1 - dayness)
+    purify = lambda current, pure : current * alpha + pure * (1 - alpha)
+    
+    for m in [0] if len(monitors) == 0 else monitors:
+        temperature_      = interpol(temperature_day,      temperature_night)
+        brightness_       = interpol(brightness_day,       brightness_night)
+        brightness_red_   = interpol(brightness_red_day,   brightness_red_night)
+        brightness_green_ = interpol(brightness_green_day, brightness_green_night)
+        brightness_blue_  = interpol(brightness_blue_day,  brightness_blue_night)
+        contrast_         = interpol(contrast_day,         contrast_night)
+        contrast_red_     = interpol(contrast_red_day,     contrast_red_night)
+        contrast_green_   = interpol(contrast_green_day,   contrast_green_night)
+        contrast_blue_    = interpol(contrast_blue_day,    contrast_blue_night)
+        gamma_red_        = interpol(gamma_red_day,        gamma_red_night)
+        gamma_green_      = interpol(gamma_green_day,      gamma_green_night)
+        gamma_blue_       = interpol(gamma_blue_day,       gamma_blue_night)
+        if fade is not None:
+            alpha = abs(fade)
+            temperature_      = purify(temperature_,      6500)
+            brightness_       = purify(brightness_,       1)
+            brightness_red_   = purify(brightness_red_,   1)
+            brightness_green_ = purify(brightness_green_, 1)
+            brightness_blue_  = purify(brightness_blue_,  1)
+            contrast_         = purify(contrast_,         1)
+            contrast_red_     = purify(contrast_red_,     1)
+            contrast_green_   = purify(contrast_green_,   1)
+            contrast_blue_    = purify(contrast_blue_,    1)
+            gamma_red_        = purify(gamma_red_,        gamma_red_default  [m % len(gamma_red_default)])
+            gamma_green_      = purify(gamma_green_,      gamma_green_default[m % len(gamma_green_default)])
+            gamma_blue_       = purify(gamma_blue_,       gamma_blue_default [m % len(gamma_blue_default)])
+        
+        # Remove settings from last run.
+        start_over()
+        
+        # Apply colour temperature using raw CIE 1964 10 degree CMF data with interpolation.
+        temperature(temperature_, lambda t : divide_by_maximum(cmf_10deg(t)))
+        
+        # Apply colour brightness using the CIE xyY colour space.
+        cie_brightness(brightness_)
+        # Apply colour brightness using the sRGB colour space.
+        # If we only used one parameter, it would be applied to all colour components.
+        rgb_brightness(brightness_red_, brightness_green_, brightness_blue_)
+        
+        # Apply colour contrast using the CIE xyY colour space.
+        cie_contrast(contrast_)
+        # Apply colour contrast using the sRGB colour space.
+        # If we only used one parameter, it would be applied to all colour components.
+        rgb_contrast(contrast_red_, contrast_green_, contrast_blue_)
+        
+        # Clip colour curves to fit [0, 1] to avoid errors by complex numbers.
+        clip()
+        
+        # Apply gamma correction to monitor.
+        gamma(gamma_red_, gamma_green_, gamma_blue_)
+        
+        # Flush settings to monitor.
+        if len(monitors) == 0:
+            randr()
+        else:
+            randr(m)
+
+
+def reset():
+    '''
+    Invoked to reset the displays
+    '''
+    for m in [0] if len(monitors) == 0 else monitors:
+        gamma_red_   = gamma_red_default  [m % len(gamma_red_default)]
+        gamma_green_ = gamma_green_default[m % len(gamma_green_default)]
+        gamma_blue_  = gamma_blue_default [m % len(gamma_blue_default)]
+        
+        # Remove settings from last run.
+        start_over()
+        
+        # Apply gamma correction to monitor.
+        gamma(gamma_red_, gamma_green_, gamma_blue_)
+        
+        # Flush settings to monitor.
+        if len(monitors) == 0:
+            randr()
+        else:
+            randr(m)
+
+
+if get_dayness is not None:
+    # Set transition time, 0 on high day and 5 seconds on high night
+    fadein_time = 5 * (1 - get_dayness())
+    # Do 10 changes per second
+    fadein_steps = fadein_time * 10
+    
+    # Transition on exit in the same way, calculated on exit
+    old_signal_SIGTERM = signal_SIGTERM
+    def signal_SIGTERM(signum, frame):
+        global fadeout_time, fadeout_steps
+        fadeout_time = 5 * (1 - get_dayness())
+        fadeout_steps = fadeout_time * 10
+        old_signal_SIGTERM(signum, frame)
+else:
+    # Do not use continuous mode
+    get_dayness = lambda : 0
+    def apply(fade):
+        t = datetime.datetime.now()
+        wd = t.isocalendar()[2]
+        periodically(t.year, t.month, t.day, t.hour, t.minute, t.second, wd, fade)
+    if not panicgate:
+        signal.signal(signal.SIGTERM, signal_SIGTERM)
+        trans = 0
+        apply(trans)
+        while running:
+            time.sleep(0.1)
+            if trans >= 1:
+                break
+            trans += 0.05
+            apply(trans)
+    apply(None)
+    periodically = None
+