From d436a8627469cb08a2dc5fcc45051079da51fb5f Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Wed, 19 Feb 2014 00:01:12 +0100 Subject: misc fixes + comperhensive example currently without option support MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- examples/comperhensive_example | 277 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 277 insertions(+) create mode 100644 examples/comperhensive_example (limited to 'examples') diff --git a/examples/comperhensive_example b/examples/comperhensive_example new file mode 100644 index 0000000..7a86472 --- /dev/null +++ b/examples/comperhensive_example @@ -0,0 +1,277 @@ +# -*- 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. + +import datetime + + +# 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 + -- cgit v1.2.3-70-g09d2