typo

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

1 files changed, 0 insertions, 275 deletions

diff --git a/examples/comperhensive b/examples/comperhensive
deleted file mode 100644
index 17b67bf..0000000
--- a/examples/comperhensive
+++ /dev/null
@@ -1,275 +0,0 @@
-# -*- 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 termporarly 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
-