# -*- python -*- # This example covers most of what Blueshift offers. For a complete # coverage of Blueshift complement this example with: # backlight, crtc-detection, crtc-searching, logarithmic, # stored-settings, modes, textconf, icc-profile-atoms # However the are features that are only covered by the info manual: # Methods for calculating correlated colour temperature # The `functionise` function # Predefined colour temperatures # This file is dual-licensed under GNU General Public License # version 3 and GNU Free Documentation License version 1.3. # Copyright © 2014 Mattias Andrée (maandree@member.fsf.org) # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # Copyright © 2014 Mattias Andrée (maandree@member.fsf.org) # # Permission is granted to copy, distribute and/or modify this document # under the terms of the GNU Free Documentation License, Version 1.3 # or any later version published by the Free Software Foundation; # with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. # You should have received a copy of the GNU General Public License # along with this software package. If not, see <http://www.gnu.org/licenses/>. import os # Geographical coodinates. # ("Kristall, vertikal accent i glas och stål" (Crystal, vertical accent # in glass and steal) in this example. A glass obelisk, lit from the inside # with adjustable colours and a default colour of 5600 K, in the middle # of a hyperelliptic roundabout.) latitude, longitude = 59.3326, 18.0652 # International Civil Aviation Organization (ICAO) # code of the nearest airport. Used to get weather # report. `None` if you do not want to account for # the weather. # (Stockholm Bromma Airport in this example.) airport = 'ESSB' # Custom dayness by time settings. time_alpha = [['02:00', 0], ['08:00', 1], ['22:00', 1]] def by_time(): ''' Dayness calculation using time ''' global time_alpha 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) # Command used to download a file at an HTTP URL download_command = None # This is what if used if `None` is selected: # download_command = lambda url : ['wget', url, '-O', '-'] # Method for applying colour curves in X. apply_curves_x = randr #apply_curves_x = vidmode # Method for applying colour curves in TTY. apply_curves_tty_ = drm # X's RandR and DRM which is used in TTY, does not # necessarily give the CRTC:s the same indices. # Specifically, RandR reorders them so that the # primary monitor have CRTC 0. Fill in this table # so that the indices give by DRM are mapped to # those given by RandR. In this example, 0 is mapped # to 1 and 1 is mapped to 0, this is how it should # be if your primary monitor is given index 1 by # DRM and you have two monitors. tty_to_x_crtc_mapping = {0 : 1, 1 : 0} def apply_curves_tty(*crtcs, screen = 0, display = None): ''' Wrapping for `apply_curves_tty_` that remaps the CRTC:s indices, to match those in RandR. @param crtcs:*int The CRT controllers to use, all are used if none are specified @param screen:int The graphics card to which the monitors belong, named `screen` for compatibility with `randr` and `vidmode` @param display:str? Dummy parameter for compatibility with `randr` and `vidmode` ''' mapping = tty_to_x_crtc_mapping crtcs_ = [(mapping[c] if c in mapping else c) for c in crtcs] apply_curves_tty_(*crtcs_, screen = screen, display = display) def apply_curves(*crtcs, screen = 0): ''' Applies colour curves This wrapper is used to allow multi-display and multi-server support @param crtcs:*int The CRT controllers to use, all are used if none are specified @param screen:int The screen to which the monitors belong ''' # Single display and single server, variant: (apply_curves_tty if ttymode else apply_curves_x)(*crtcs, screen = screen) # Variant for TTY and all X display: #apply_curves_tty(*crtcs, screen = screen) #for display_socket in os.listdir('/tmp/.X11-unix'): # if display_socket.startswith('X'): # try: # display = ':%i' % int(display_socket[1:]) # apply_curves_x(*crtcs, screen = screen, display = display) # except: # pass # Variant for TTY and selected X displays: #apply_curves_tty(*crtcs, screen = screen) #for display in [None, ':1']: # Current and :1 # apply_curves_x(*crtcs, screen = screen, display = display) # 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 # Dayness modifiers based on weather and sky conditions. weather_modifiers = { 'clear' : 1.00 , 'mostly clear' : 0.95 , 'partly cloudy' : 0.90 , 'mostly cloudy' : 0.85 , 'overcast' : 0.80 , 'obscured' : 0.75 } # The maximum for visibility range for when to # account for the visibility range. `None` if # you do dont want to account for visibility range. visibility_max = 4 # The (zero-based) indices 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. # Sigmoid curve (S-curve) correction for the red, green and blue # components, respectively, for each monitor. `None` means that # no correct is should be applied. `...` means that the value # above should be used. sigmoid_red = [None] sigmoid_green = [...] sigmoid_blue = [...] # ICC profile for video filtering and monitor calibration, respectively. # Replace `None` with the pathname of the profile. It is assume that # the calibration profile is already applied and that you want it to # still be applied on exit. icc_video_filter_profile_day = [None] icc_video_filter_profile_night = [None] icc_calibration_profile = [None] # Function for getting the current the current monitor calibration. # If `None` the the current monitor calibration will be ignored. # `if not panicgate:` is included to ignore monitor calibration if # -p (--panicgate) is used. current_calibration = [None] if not panicgate: if not ttymode: calib_get = None #calib_get = randr_get #calib_get = vidmode_get else: calib_get = None #calib_get = drm_get current_calibration = [calib_get] # These are fun curve manipulator settings that lowers the # colour resolution. `red_x_resolution` is the number of colours # colours there are one encoding axis of the red curve. # `red_y_resolution` is how many colours there are on the # output axis of the red curve. `None` means that the default # resolution should be used, which are `i_size` for *_x_resolution # and `o_size` for *_y_resolution. `...` means that the value # above should be used. red_x_resolution, red_y_resolution = [None], [None] green_x_resolution, green_y_resolution = [...], [...] blue_x_resolution, blue_y_resolution = [...], [...] # Negative image settings. `None` means that negative image # is applied to none of the subpixels. `lambda : negative(True)` # and `negative(True, True, True)` applied negative image to # all subpixels by reversion the colour curves on the encoding # axes. For the three parameter functions, the first parameters # should be `True` to perform negative image on the red subpixel # and do nothing if `False`, and analogously for green on the # second parameter and blue on the third parameter. `rgb_invert` # inverts the curves on the output axes, and `cie_invert` does # the same thing except it calcuates the inversion in the CIE # xyY colour space. negative_image = [None] #negative_image = [lambda : negative(True)] #negative_image = [lambda : negative(True, True, True)] #negative_image = [lambda : rgb_invert(True)] #negative_image = [lambda : rgb_invert(True, True, True)] #negative_image = [lambda : cie_invert(True)] #negative_image = [lambda : cie_invert(True, True, True)] # Loads the current monitor calibrations. m = 0 for i in range(len(current_calibration)): f = current_calibration[i] if f is not None: if not len(monitors) == 0: m = monitors[i % len(monitors)] f = f(m) # Use linear interpolation f = interpolate_function(f, linearly_interpolate_ramp) # Use cubic interpolation #f = interpolate_function(f, cubicly_interpolate_ramp) # Use semitense cubic interpolation #f = interpolate_function(f, lambda *c : cubicly_interpolate_ramp(*c, tension = 0.5)) # Use monotone cubic interpolation #f = interpolate_function(f, monotonicly_cubicly_interpolate_ramp) # Use semitense monotone cubic interpolation #f = interpolate_function(f, lambda *c : monotonicly_cubicly_interpolate_ramp(*c, tension = 0.5)) # Otherwise use nearest-neighbour current_calibration[i] = f monitor_controller = lambda : apply_curves(*monitors) ''' :()→void Function used by Blueshift on exit to apply reset colour curves, if using preimplemented `reset` ''' uses_adhoc_opts = True ''' :bool `True` if the configuration script parses the ad-hoc settings ''' reset_on_error = True ''' :bool Whether to reset the colour curves if the configuration script runs into an exception that it did not handle ''' # Get --reset from Blueshift ad-hoc settigns doreset = parser.opts['--reset'] last_dayness, last_metar = None, None sigmoid_ = list(zip(sigmoid_red, sigmoid_green, sigmoid_blue)) icc_video_filter_profile = [None] * len(icc_video_filter_profile_day) def periodically(year, month, day, hour, minute, second, weekday, fade): ''' 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, 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 ''' global last_dayness, last_metar, wait_period dayness = get_dayness() if airport is not None: # Get weather report. (metar, last_time) = (None, None) if last_metar is None else last_metar now_time = minute if (metar is None) or (now_time < last_time) or (last_time < now_time + 5): metar = weather(airport, download_command) last_metar = (metar, now_time) # Account for weather. if metar is not None: conditions = [metar[0]] + metar[2] for condition in conditions: if condition in weather_modifiers: dayness *= weather_modifiers[condition] if metar[1] is not None: (_bound, visibility) = metar[1] if (visibility_max is not None) and (visibility is not None): if visibility < visibility_max: dayness *= visibility / visibility_max # Do not do unnecessary work. if fade is None: if dayness == last_dayness: return last_dayness = 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 range(max(1, len(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 ICC profile as a video filter. i = m % len(icc_video_filter_profile) if icc_video_filter_profile_day[i] is not None: if icc_video_filter_profile[i] is None: day = load_icc(icc_video_filter_profile_day[i]) night = load_icc(icc_video_filter_profile_night[i]) icc_video_filter_profile[i] = make_icc_interpolation([night, day]) icc_video_filter_profile[i](dayness, 1 if fade is None else abs(fade)) # Apply negative image. f = negative_image[m % len(negative_image)] if f is not None: f() # Apply colour temperature using raw CIE 1964 10 degree CMF data with interpolation. temperature(temperature_, lambda t : clip_whitepoint(divide_by_maximum(cmf_10deg(t)))) # Apply calibration used when started. c = current_calibration[m % len(current_calibration)] if c is not None: c() # 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_) # Apply low colour resolution emulation. rx = red_x_resolution[m % len(red_x_resolution)] ry = red_y_resolution[m % len(red_y_resolution)] gx = green_x_resolution[m % len(green_x_resolution)] gy = green_y_resolution[m % len(green_y_resolution)] bx = blue_x_resolution[m % len(blue_x_resolution)] by = blue_y_resolution[m % len(blue_y_resolution)] lower_resolution(rx, ry, gx, gy, bx, by) # 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_) # Apply sigmoid curve correction to monitor. sigmoid(*(sigmoid_[m % len(sigmoid_)])) # Apply ICC profile as a monitor calibration. i = m % len(icc_calibration_profile) if icc_calibration_profile[i] is not None: if isinstance(icc_calibration_profile[i], str): f = load_icc(icc_calibration_profile[i]) # Use linear interpolation f = interpolate_function(f, linearly_interpolate_ramp) # Use cubic interpolation #f = interpolate_function(f, cubicly_interpolate_ramp) # Use semitense cubic interpolation #f = interpolate_function(f, lambda *c : cubicly_interpolate_ramp(*c, tension = 0.5)) # Use monotone cubic interpolation #f = interpolate_function(f, monotonicly_cubicly_interpolate_ramp) # Use semitense monotone cubic interpolation #f = interpolate_function(f, lambda *c : monotonicly_cubicly_interpolate_ramp(*c, tension = 0.5)) # Otherwise use nearest-neighbour icc_calibration_profile[i] = f icc_calibration_profile[i]() # Flush settings to monitor. if len(monitors) == 0: apply_curves() else: apply_curves(monitors[m % len(monitors)]) # Lets wait only 5 seconds, instead of a minute before running again. wait_period = 5 def reset(): ''' Invoked to reset the displays ''' for m in range(max(1, len(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 calibration used when started. c = current_calibration[m % len(current_calibration)] if c is not None: c() # Apply gamma correction to monitor. gamma(gamma_red_, gamma_green_, gamma_blue_) # Apply ICC profile as a monitor calibration. i = m % len(icc_calibration_profile) if icc_calibration_profile[i] is not None: if isinstance(icc_calibration_profile[i], str): icc_calibration_profile[i] = load_icc(icc_calibration_profile[i]) icc_calibration_profile[i]() # Flush settings to monitor. if len(monitors) == 0: apply_curves() else: apply_curves(monitors[m % len(monitors)]) if (get_dayness is not None) and not doreset: # 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 if 'SIGTERM' not in conf_storage: conf_storage['SIGTERM'] = old_signal_SIGTERM else: old_signal_SIGTERM = conf_storage['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((1 - trans) if doreset else trans) while running: time.sleep(0.1) if trans >= 1: break trans += 0.05 apply((1 - trans) if doreset else trans) if not doreset: apply(None) else: reset() periodically = None