From 50fdf7d90afadae4f4bc75e7da51e91b838af6d1 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Wed, 19 Feb 2014 01:19:50 +0100 Subject: typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- examples/comperhensive | 275 ------------------------------------------------- examples/comprehensive | 275 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 275 insertions(+), 275 deletions(-) delete mode 100644 examples/comperhensive create mode 100644 examples/comprehensive (limited to 'examples') 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 - 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 + -- cgit v1.2.3-70-g09d2