# -*- coding: utf-8 -*- # stdlib import codecs from binascii import hexlify import atexit import ctypes import datetime import getpass import http.client import math import mimetypes import os from io import BytesIO from pathlib import Path import distro import platform import re import socket import shutil import string import struct import subprocess as sp import sys import tempfile import textwrap import threading import traceback import urllib.request import urllib.parse import urllib.error import warnings import zipfile import zlib from collections import UserString from hashlib import md5, sha256 from threading import currentThread from time import sleep, strftime, time from send2trash import send2trash if sys.platform == "darwin": from platform import mac_ver from _thread import start_new_thread elif sys.platform == "win32": from ctypes import windll else: import grp # 3rd party if sys.platform == "win32": from win32com.shell import shell as win32com_shell import pythoncom import win32api import win32con import win32event import pywintypes import winerror # custom from DisplayCAL.cgats import ( CGATS, CGATSError, CGATSInvalidError, CGATSInvalidOperationError, CGATSKeyError, CGATSTypeError, CGATSValueError, rpad, stable_sort_by_L, sort_by_rec709_luma, sort_by_RGB, sort_by_RGB_sum, ) from DisplayCAL import audio from DisplayCAL import colormath from DisplayCAL import config from DisplayCAL import defaultpaths from DisplayCAL import imfile from DisplayCAL import localization as lang from DisplayCAL import wexpect from DisplayCAL.argyll import ( check_argyll_bin, check_set_argyll_bin, get_argyll_instrument_config, get_argyll_util, get_argyll_utilname, get_argyll_version_string, make_argyll_compatible_path, parse_argyll_version_string, ) from DisplayCAL.argyll_cgats import ( add_dispcal_options_to_cal, add_options_to_ti3, cal_to_fake_profile, cal_to_vcgt, extract_cal_from_profile, extract_cal_from_ti3, extract_device_gray_primaries, extract_fix_copy_cal, ti3_to_ti1, verify_cgats, verify_ti1_rgb_xyz, ) from DisplayCAL.argyll_instruments import ( get_canonical_instrument_name, instruments as all_instruments, ) from DisplayCAL.argyll_names import ( viewconds, intents, observers, ) from DisplayCAL.colormath import VidRGB_to_eeColor, eeColor_to_VidRGB from DisplayCAL.config import ( autostart, autostart_home, script_ext, defaults, enc, exe, exedir, exe_ext, fs_enc, getcfg, geticon, get_data_path, get_total_patches, isapp, is_ccxx_testchart, profile_ext, pydir, setcfg, setcfg_cond, split_display_name, writecfg, appbasename, ) from DisplayCAL.debughelpers import ( Error, DownloadError, Info, UnloggedError, UnloggedInfo, UnloggedWarning, UntracedError, Warn, handle_error, ) from DisplayCAL.defaultpaths import ( cache, iccprofiles_home, iccprofiles_display_home, appdata, ) from DisplayCAL.edid import WMIError, get_edid from DisplayCAL.icc_profile import ( _mp_apply, chromaticAdaptionTag, ChromaticityType, create_RGB_A2B_XYZ, create_synthetic_hdr_clut_profile, CRInterpolation, CurveType, DictType, ICCProfile, ICCProfileInvalidError, ICCProfileTag, GAMUT_VOLUME_SRGB, get_display_profile, LUT16Type, MultiLocalizedUnicodeType, ProfileSequenceDescType, s15Fixed16Number, s15Fixed16Number_tohex, set_display_profile, Text, TextDescriptionType, TextType, VideoCardGammaTableType, VideoCardGammaType, XYZType, ) from DisplayCAL.log import DummyLogger, LogFile, get_file_logger, log from DisplayCAL import madvr from DisplayCAL.meta import VERSION, VERSION_BASE, DOMAIN, name as appname, version from DisplayCAL.multiprocess import cpu_count, pool_slice from DisplayCAL.options import ( always_fail_download, debug, eecolor65, experimental, test, test_badssl, test_require_sensor_cal, verbose, ) from DisplayCAL.network import LoggingHTTPRedirectHandler, NoHTTPRedirectHandler from DisplayCAL.patterngenerators import ( PrismaPatternGeneratorClient, ResolveLSPatternGeneratorServer, ResolveCMPatternGeneratorServer, WebWinHTTPPatternGeneratorServer, ) from DisplayCAL.util_decimal import stripzeros from DisplayCAL.util_dict import dict_sort from DisplayCAL.util_http import encode_multipart_formdata from DisplayCAL.util_io import ( EncodedWriter, Files, GzipFileProper, LineBufferedStream, LineCache, StringIOu as StringIO, TarFileProper, ) from DisplayCAL.util_list import intlist, natsort if sys.platform == "darwin": from DisplayCAL.util_mac import ( mac_app_activate, mac_terminal_do_script, mac_terminal_set_colors, osascript, get_model_id, ) elif sys.platform == "win32": from DisplayCAL import util_win from DisplayCAL.util_win import run_as_admin, shell_exec, win_ver try: import wmi except Exception as exception: print("Error - could not import WMI:", exception) wmi = None else: # Linux from DisplayCAL.defaultpaths import xdg_data_home try: from DisplayCAL.util_dbus import ( DBusObject, DBusException, DBusObjectError, BUSTYPE_SESSION, dbus_session, dbus_system, ) except ImportError: dbus_session = None dbus_system = None from DisplayCAL import colord from DisplayCAL.util_os import ( dlopen, getenvu, is_superuser, launch_file, make_win32_compatible_long_path, mksfile, mkstemp_bypath, quote_args, safe_glob, which, ) if sys.platform not in ("darwin", "win32"): from DisplayCAL.util_os import getgroups if sys.platform == "win32" and sys.getwindowsversion() >= (6,): from DisplayCAL.util_os import win64_disable_file_system_redirection from DisplayCAL.util_str import ( make_filename_safe, safe_basestring, safe_asciize, safe_str, strtr, universal_newlines, ) from DisplayCAL.worker_base import ( MP_Xicclu, WorkerBase, Xicclu, _mp_generate_B2A_clut, _mp_xicclu, printcmdline, ) from DisplayCAL.wxaddons import BetterCallLater, BetterWindowDisabler, wx from DisplayCAL.wxwindows import ( ConfirmDialog, HtmlInfoDialog, InfoDialog, ProgressDialog, SimpleTerminal, show_result_dialog, ) from DisplayCAL.wxDisplayAdjustmentFrame import DisplayAdjustmentFrame from DisplayCAL.wxDisplayUniformityFrame import DisplayUniformityFrame from DisplayCAL.wxUntetheredFrame import UntetheredFrame RDSMM = None if sys.platform not in ("darwin", "win32"): try: from DisplayCAL import RealDisplaySizeMM as RDSMM except ImportError as exception: warnings.warn(str(exception), ImportWarning) import wx.lib.delayedresult as delayedresult INST_CAL_MSGS = [ "Do a reflective white calibration", "Do a transmissive white calibration", "Do a transmissive dark calibration", "Place the instrument on its reflective white reference", "Click the instrument on its reflective white reference", "Place the instrument in the dark", "Place cap on the instrument", # i1 Pro/SpyderX "Place ambient adapter and cap on the instrument", "Set instrument sensor to calibration position", # ColorMunki "Place the instrument on its transmissive white source", "Use the appropriate tramissive blocking", "Change filter on instrument to", ] USE_WPOPEN = 0 keycodes = { wx.WXK_NUMPAD0: ord("0"), wx.WXK_NUMPAD1: ord("1"), wx.WXK_NUMPAD2: ord("2"), wx.WXK_NUMPAD3: ord("3"), wx.WXK_NUMPAD4: ord("4"), wx.WXK_NUMPAD5: ord("5"), wx.WXK_NUMPAD6: ord("6"), wx.WXK_NUMPAD7: ord("7"), wx.WXK_NUMPAD8: ord("8"), wx.WXK_NUMPAD9: ord("9"), wx.WXK_NUMPAD_ADD: ord("+"), wx.WXK_NUMPAD_ENTER: ord("\n"), wx.WXK_NUMPAD_EQUAL: ord("="), wx.WXK_NUMPAD_DIVIDE: ord("/"), wx.WXK_NUMPAD_MULTIPLY: ord("*"), wx.WXK_NUMPAD_SUBTRACT: ord("-"), } workers = [] WAIT_FILE_TEMPLATE = """# coding=utf-8 import os, sys, time if sys.platform != "win32": print(*(["\\nCurrent RGB"] + sys.argv[1:])) abortfilename = os.path.join(r"{script_dir}", ".abort") okfilename = os.path.join(r"{script_dir}", ".ok") while True: if os.path.isfile(abortfilename): break if os.path.isfile(okfilename): try: os.remove(okfilename) except OSError as e: pass else: break time.sleep(0.001) """ def add_keywords_to_cgats(cgats, keywords): """Add keywords to CGATS""" if not isinstance(cgats, CGATS): cgats = CGATS(cgats) for keyword in keywords: value = keywords[keyword] cgats[0].add_keyword(keyword, value) return cgats def check_create_dir(path): """Try to create a directory and show an error message on failure.""" if not os.path.exists(path): try: os.makedirs(path) except Exception as exception: return Error(f"{lang.getstr('error.dir_creation', path)}\n\n{exception}") if not os.path.isdir(path): return Error(lang.getstr("error.dir_notdir", path)) return True def check_cal_isfile(cal=None, missing_msg=None, notfile_msg=None, silent=False): """Check if a calibration file exists and show an error message if not.""" if not silent: if not missing_msg: missing_msg = lang.getstr("error.calibration.file_missing", cal) if not notfile_msg: notfile_msg = lang.getstr("file_notfile", cal) return check_file_isfile(cal, missing_msg, notfile_msg, silent) def check_profile_isfile( profile_path=None, missing_msg=None, notfile_msg=None, silent=False ): """Check if a profile exists and show an error message if not.""" if not silent: if not missing_msg: missing_msg = lang.getstr("error.profile.file_missing", profile_path) if not notfile_msg: notfile_msg = lang.getstr("file_notfile", profile_path) return check_file_isfile(profile_path, missing_msg, notfile_msg, silent) def check_file_isfile(filename, missing_msg=None, notfile_msg=None, silent=False): """Check if a file exists and show an error message if not.""" if not os.path.exists(filename): if not silent: if not missing_msg: missing_msg = lang.getstr("file.missing", filename) return Error(missing_msg) return False if not os.path.isfile(filename): if not silent: if not notfile_msg: notfile_msg = lang.getstr("file.notfile", filename) return Error(notfile_msg) return False return True def check_ti3_criteria1( RGB, XYZ, black_XYZ, white_XYZ, delta_to_sRGB_threshold_E=10, delta_to_sRGB_threshold_L=10, delta_to_sRGB_threshold_C=75, delta_to_sRGB_threshold_H=75, print_debuginfo=True, ): sRGBLab = colormath.RGB2Lab( RGB[0] / 100.0, RGB[1] / 100.0, RGB[2] / 100.0, noadapt=not white_XYZ ) if white_XYZ: if black_XYZ: black_Lab = colormath.XYZ2Lab( *colormath.adapt(black_XYZ[0], black_XYZ[1], black_XYZ[2], white_XYZ) ) black_C = math.sqrt(math.pow(black_Lab[1], 2) + math.pow(black_Lab[2], 2)) if black_Lab[0] < 3 and black_C < 3: # Sanity check: Is this color reasonably dark and achromatic? # Then do BPC so we can compare better to perfect black sRGB XYZ = colormath.blend_blackpoint( XYZ[0], XYZ[1], XYZ[2], black_XYZ, None, white_XYZ ) XYZ = colormath.adapt(XYZ[0], XYZ[1], XYZ[2], white_XYZ) Lab = colormath.XYZ2Lab(*XYZ) delta_to_sRGB = colormath.delta(*sRGBLab + Lab + (2000,)) # Depending on how (a)chromatic the sRGB color is, scale the thresholds # Use math derived from DE2000 formula to get chroma and hue angle L, a, b = sRGBLab b_pow = math.pow(b, 2) C = math.sqrt(math.pow(a, 2) + b_pow) C_pow = math.pow(C, 7) G = 0.5 * (1 - math.sqrt(C_pow / (C_pow + math.pow(25, 7)))) a = (1 + G) * a C = math.sqrt(math.pow(a, 2) + b_pow) h = ( 0 if a == 0 and b == 0 else math.degrees(math.atan2(b, a)) + (0 if b >= 0 else 360.0) ) # C and h scaling factors C_scale = C / 100.0 h_scale = h / 360.0 # RGB hue, saturation and value scaling factors H, S, V = colormath.RGB2HSV(*[v / 100.0 for v in RGB]) SV_scale = S * V # Scale the thresholds delta_to_sRGB_threshold_E += delta_to_sRGB_threshold_E * max(C_scale, SV_scale) delta_to_sRGB_threshold_L += delta_to_sRGB_threshold_L * max(C_scale, SV_scale) # Allow higher chroma errors as luminance of reference decreases L_scale = max(1 - (1 * C_scale) + (100.0 - L) / 100.0, 1) delta_to_sRGB_threshold_C = ( delta_to_sRGB_threshold_C * max(C_scale, SV_scale) + 2 ) * L_scale delta_to_sRGB_threshold_H = ( delta_to_sRGB_threshold_H * max(C_scale, h_scale, H, SV_scale) + 2 ) * L_scale criteria1 = delta_to_sRGB["E"] > delta_to_sRGB_threshold_E and ( abs(delta_to_sRGB["L"]) > delta_to_sRGB_threshold_L or abs(delta_to_sRGB["C"]) > delta_to_sRGB_threshold_C or abs(delta_to_sRGB["H"]) > delta_to_sRGB_threshold_H ) # This patch has an unusually high delta 00 to its sRGB equivalent delta_to_sRGB["E_ok"] = delta_to_sRGB["E"] <= delta_to_sRGB_threshold_E delta_to_sRGB["L_ok"] = abs(delta_to_sRGB["L"]) <= delta_to_sRGB_threshold_L delta_to_sRGB["C_ok"] = abs(delta_to_sRGB["C"]) <= delta_to_sRGB_threshold_C delta_to_sRGB["H_ok"] = abs(delta_to_sRGB["H"]) <= delta_to_sRGB_threshold_H delta_to_sRGB["ok"] = ( delta_to_sRGB["E_ok"] and delta_to_sRGB["L_ok"] and delta_to_sRGB["C_ok"] and delta_to_sRGB["H_ok"] ) debuginfo = ( f"RGB: {RGB[0]:6.2f} {RGB[1]:6.2f} {RGB[2]:6.2f} " f"RGB(sRGB)->Lab(D50): {sRGBLab[0]:6.2f} {sRGBLab[1]:6.2f} {sRGBLab[2]:6.2f} " f"L_scale: {L_scale:5.3f} C: {C:5.2f} C_scale: {C_scale:5.3f} h: {h:5.2f} " f"h_scale: {h_scale:5.3f} H: {H * 360:5.2f} H_scale: {H:5.3f} S: {S:5.2f} " f"V: {V:5.2f} SV_scale: {SV_scale:5.3f} " f"Thresholds: E {delta_to_sRGB_threshold_E:5.2f} " f"L {delta_to_sRGB_threshold_L:5.2f} C {delta_to_sRGB_threshold_C:5.2f} " f"H {delta_to_sRGB_threshold_H:5.2f} " f"XYZ->Lab(D50): {Lab[0]:6.2f} {Lab[1]:6.2f} {Lab[2]:6.2f} " f"delta RGB(sRGB)->Lab(D50) to XYZ->Lab(D50): dE {delta_to_sRGB['E']:5.2f} " f"dL {delta_to_sRGB['L']:5.2f} dC {delta_to_sRGB['C']:5.2f} " f"dH {delta_to_sRGB['H']:5.2f}" ) if print_debuginfo: print(debuginfo) return sRGBLab, Lab, delta_to_sRGB, criteria1, debuginfo def check_ti3_criteria2( prev_Lab, Lab, prev_sRGBLab, sRGBLab, prev_RGB, RGB, sRGB_delta_E_scale_factor=0.5 ): delta = colormath.delta(*prev_Lab + Lab + (2000,)) sRGB_delta = colormath.delta(*prev_sRGBLab + sRGBLab + (2000,)) sRGB_delta["E"] *= sRGB_delta_E_scale_factor criteria2 = delta["E"] < sRGB_delta["E"] # These two patches have different RGB values # but suspiciously low delta E 76. if criteria2 and ( prev_RGB[0] == prev_RGB[1] == prev_RGB[2] and RGB[0] == RGB[1] == RGB[2] ): # If RGB gray, check if the Y difference makes sense criteria2 = (RGB[0] > prev_RGB[0] and Lab[0] <= prev_Lab[0]) or ( RGB[0] < prev_RGB[0] and Lab[0] >= prev_Lab[0] ) delta["L_ok"] = not criteria2 delta["E_ok"] = True else: delta["E_ok"] = not criteria2 delta["L_ok"] = True return delta, sRGB_delta, criteria2 def check_ti3(ti3, print_debuginfo=True): """Check subsequent patches' expected vs real deltaE and collect patches with different RGB values, but suspiciously low delta E Used as a means to find misreads. The expected dE is calculated by converting from a patches RGB values (assuming sRGB) to Lab and comparing the values. """ if not isinstance(ti3, CGATS): ti3 = CGATS(ti3) data = ti3.queryv1("DATA") datalen = len(data) black = data.queryi1({"RGB_R": 0, "RGB_G": 0, "RGB_B": 0}) if black: black = black["XYZ_X"], black["XYZ_Y"], black["XYZ_Z"] elif print_debuginfo: print("Warning - no black patch found in CGATS") white = data.queryi1({"RGB_R": 100, "RGB_G": 100, "RGB_B": 100}) if white: white = white["XYZ_X"], white["XYZ_Y"], white["XYZ_Z"] elif print_debuginfo: print("Warning - no white patch found in CGATS") suspicious = [] prev = {} delta = {} for index in data: item = data[index] (sRGBLab, Lab, delta_to_sRGB, criteria1, debuginfo) = check_ti3_criteria1( (item["RGB_R"], item["RGB_G"], item["RGB_B"]), (item["XYZ_X"], item["XYZ_Y"], item["XYZ_Z"]), black, white, print_debuginfo=False, ) if criteria1 or ( prev and ( max(prev["item"]["RGB_R"], item["RGB_R"]) - min(prev["item"]["RGB_R"], item["RGB_R"]) > 1.0 / 2.55 or max(prev["item"]["RGB_G"], item["RGB_G"]) - min(prev["item"]["RGB_G"], item["RGB_G"]) > 1.0 / 2.55 or max(prev["item"]["RGB_B"], item["RGB_B"]) - min(prev["item"]["RGB_B"], item["RGB_B"]) > 1.0 / 2.55 ) ): if prev: (delta, sRGB_delta, criteria2) = check_ti3_criteria2( prev["Lab"], Lab, prev["sRGBLab"], sRGBLab, ( prev["item"]["RGB_R"], prev["item"]["RGB_G"], prev["item"]["RGB_B"], ), (item["RGB_R"], item["RGB_G"], item["RGB_B"]), ) else: criteria2 = False if criteria1 or criteria2: if print_debuginfo: if criteria2: debuginfo = ( f"{debuginfo} dE to previous XYZ->Lab(D50): " f"{delta['E']:5.3f} dE_OK: {delta['E_ok']} " f"L_OK: {delta['L_ok']} " "0.5 dE RGB(sRGB)->Lab(D50) to previous " f"RGB(sRGB)->Lab(D50): {sRGB_delta['E']:5.3f}" ) sample_id = f"Patch #{{:.0{len(str(datalen)):d}f}}" print(sample_id.format(item.SAMPLE_ID), debuginfo) suspicious.append( ( prev["item"] if criteria2 else None, item, delta if criteria2 else None, sRGB_delta if criteria2 else None, prev["delta_to_sRGB"] if criteria2 else None, delta_to_sRGB, ) ) prev["item"] = item prev["sRGBLab"] = sRGBLab prev["Lab"] = Lab prev["delta_to_sRGB"] = delta_to_sRGB return suspicious def create_shaper_curves( RGB_XYZ, bwd_mtx, single_curve=False, bpc=True, logfn=None, slope_limit=False, profile=None, options_dispcal=None, optimize=False, cat="Bradford", ): """Create input (device to PCS) shaper curves""" RGB_XYZ = dict_sort(RGB_XYZ) R_R = [] G_G = [] B_B = [] R_X = [] G_Y = [] B_Z = [] XYZbp = None XYZwp = None for R, G, B in RGB_XYZ: X, Y, Z = RGB_XYZ[(R, G, B)] X, Y, Z = colormath.adapt(X, Y, Z, RGB_XYZ[(100, 100, 100)], cat=cat) if 100 > R > 0 and min(X, Y, Z) < 100.0 / 65535: # Skip non-black/non-white gray values not encodable in 16-bit continue if 100 > R > 0 and G_Y and (Y < G_Y[-1] * 100 or Y > 100): # Skip values with negative Y increments, # or Y above 100 with RGB < 100 if logfn: logfn( f"Warning: Skipping RGB {R:.2f} {G:.2f} {B:.2f} " f"XYZ {X:.6f} {Y:.6f} {Z:.6f}", "because Y is not monotonically increasing", ) continue R_R.append(R / 100.0) G_G.append(G / 100.0) B_B.append(B / 100.0) R_X.append(X / 100.0) G_Y.append(Y / 100.0) B_Z.append(Z / 100.0) if R == G == B == 0: XYZbp = [v / 100.0 for v in (X, Y, Z)] elif R == G == B == 100: XYZwp = [v / 100.0 for v in (X, Y, Z)] numvalues = len(R_R) if numvalues <= 2 or XYZbp[1] >= XYZwp[1] * 0.9: # Botched measurements raise UntracedError(lang.getstr("error.luminance.not_monotonically_increasing")) if XYZwp[1] <= 0 or math.isnan(XYZwp[1]): raise UntracedError(lang.getstr("error.luminance.invalid")) # Scale black to zero for i in range(numvalues): if bwd_mtx * [1, 1, 1] == [1, 1, 1]: (R_X[i], G_Y[i], B_Z[i]) = colormath.apply_bpc( R_X[i], G_Y[i], B_Z[i], XYZbp, (0, 0, 0), XYZwp ) else: (R_X[i], G_Y[i], B_Z[i]) = colormath.blend_blackpoint( R_X[i], G_Y[i], B_Z[i], XYZbp ) # Interpolate TRC use_individual_channel_gammas = True gammas = [[], [], []] for j, gamma in enumerate(gammas): values = [] for i, v in enumerate((R_R, G_G, B_B)[j]): channel = (R_X, G_Y, B_Z)[j] vv = colormath.convert_range( channel[i], channel[0], XYZwp[j], channel[0], 1 ) if use_individual_channel_gammas: channel[i] = vv values.append((v, vv)) gamma[:] = colormath.get_gamma(values, average=False) gamma.insert(0, gamma[0]) gamma.append(gamma[-1]) if bwd_mtx * [1, 1, 1] == [1, 1, 1]: # cLUT profile final = 2049 else: # Shaper + matrix profile final = 256 if all(len(gamma) == numvalues for gamma in gammas): # Follow curvature by using gamma as hint # This can be used to fill in 'missing' values with the right slope # E.g. suppose we have measured at signal levels 0%, 25%, 50%, 75%, 100% # Linearly interpolating between those (or even using polynomials) # will yield unacceptable results especially near black due to not # following the typical curvature of additive displays. Using this # method, a sensible curvature is maintained. numentries = numvalues while numentries < 2**12 + 1: numentries = (numentries - 1) * 2 + 1 RGB = (R_R, G_G, B_B) gammas_resized = [ gamma and colormath.interp_fill( RGB[j], gamma, (numvalues - 1) * 2 + 1, # numentries, True, ) for j, gamma in enumerate(gammas) ] for gamma in gammas_resized: gamma[1:-1] = colormath.smooth_avg(gamma[1:-1], 1) gammas_resized = [ gamma and colormath.interp_resize(gamma, numentries, True) for gamma in gammas_resized ] for i in range(1, numvalues - 1): X, Y, Z = R_X[i], G_Y[i], B_Z[i] if use_individual_channel_gammas: R_X[i], G_Y[i], B_Z[i] = ( v ** (1.0 / gammas[j][i]) for j, v in enumerate((X, Y, Z)) ) else: if Y < 0: # This should NOT happen - is this check needed? if logfn: logfn("Warning: Y is negative - clamping to zero") Y = 0 if Y: Y2 = Y ** (1.0 / gammas[1][i]) R_X[i], G_Y[i], B_Z[i] = (v / Y * Y2 for v in (X, Y, Z)) for j, values in enumerate((R_X, G_Y, B_Z)): values[:] = colormath.interp_fill(RGB[j], values, numentries, True) for i in range(1, numentries - 1): X, Y, Z = R_X[i], G_Y[i], B_Z[i] if use_individual_channel_gammas: X, Y, Z = ( colormath.convert_range( v ** gammas_resized[j][i], (R_X, G_Y, B_Z)[j][0], 1, (R_X, G_Y, B_Z)[j][0], XYZwp[j], ) for j, v in enumerate((X, Y, Z)) ) R_X[i], G_Y[i], B_Z[i] = X, Y, Z else: if Y: Y2 = Y ** gammas_resized[1][i] R_X[i], G_Y[i], B_Z[i] = (v / Y * Y2 for v in (X, Y, Z)) for values in RGB: values[:] = colormath.interp_fill(values, values, numentries, True) # for i in range(numentries): # print(i, R_R[i], G_G[i], B_B[i], gammas_resized[0][i], # gammas_resized[1][i], gammas_resized[2][i], R_X[i], # G_Y[i], B_Z[i]) numentries = final else: # Hmm. Can this happen? Use old (pre 3.8.9.2) interpolation numentries = 33 rinterp = colormath.Interp(R_R, R_X, use_numpy=True) ginterp = colormath.Interp(G_G, G_Y, use_numpy=True) binterp = colormath.Interp(B_B, B_Z, use_numpy=True) curves = [] for i in range(3): curves.append([]) maxval = numentries - 1.0 powinterp = { "r": colormath.Interp([], []), "g": colormath.Interp([], []), "b": colormath.Interp([], []), } RGBwp = bwd_mtx * XYZwp for n in range(numentries): n /= maxval if numentries < final: # Apply slight power to input value so we sample near # black more accurately n **= 1.2 Y = ginterp(n) X = rinterp(n) Z = binterp(n) if Y >= 1: # Fix Y >= 1 to whitepoint. Mainly for HDR with PQ clipping, # where input gray < 1 can result in >= white Y X, Y, Z = XYZwp elif single_curve: X, Y, Z = [v * Y for v in XYZwp] RGB = bwd_mtx * (X, Y, Z) for i, channel in enumerate("rgb"): v = RGB[i] v = min(max(v, 0), 1) if slope_limit: v = max(v, n / 64.25) if numentries < final: powinterp[channel].xp.append(n) powinterp[channel].fp.append(v) else: curves[i].append(v) if numentries < final: for n in range(numentries): for i, channel in enumerate("rgb"): v = powinterp[channel](n / maxval) curves[i].append(v) for curve in curves: # Ensure monotonically increasing curve[:] = colormath.make_monotonically_increasing(curve) if numentries < final: # Interpolate to final resolution # Spline interpolation to larger size x = (i / (final - 1.0) * (len(curve) - 1) for i in range(final)) spline = CRInterpolation(curve) curve[:] = (min(max(spline(v), 0), 1) for v in x) # Ensure still monotonically increasing curve[:] = colormath.make_monotonically_increasing(curve) if optimize: curves = _create_optimized_shaper_curves( bwd_mtx, bpc, single_curve, curves, profile, options_dispcal, XYZbp, logfn ) return curves def _create_optimized_shaper_curves( bwd_mtx, bpc, single_curve, curves, profile, options_dispcal, XYZbp=None, logfn=None ): # Get black and white luminance if isinstance(profile.tags.get("lumi"), XYZType): white_cdm2 = profile.tags.lumi.Y else: white_cdm2 = 100.0 black_Y = XYZbp and XYZbp[1] or 0 black_cdm2 = black_Y * white_cdm2 # Calibration gamma defaults gamma_type = None calgamma = 0 outoffset = None # Get actual calibration gamma (if any) calgarg = get_arg("g", options_dispcal) if not calgarg: calgarg = get_arg("G", options_dispcal) if ( calgarg and isinstance(profile.tags.get("vcgt"), VideoCardGammaType) and not profile.tags.vcgt.is_linear() ): calgamma = {"l": -3.0, "s": -2.4, "709": -709, "240": -240}.get( calgarg[1][1:], calgamma ) if not calgamma: try: calgamma = float(calgarg[1][1:]) except ValueError: # Not a gamma value pass if calgamma: gamma_type = calgarg[1][0] outoffset = defaults["calibration.black_output_offset"] calfarg = get_arg("f", options_dispcal) if calfarg: try: outoffset = float(calfarg[1][1:]) except ValueError: pass caltrc = CurveType(profile=profile) if calgamma > 0: caltrc.set_bt1886_trc(black_Y, outoffset, calgamma, gamma_type) else: caltrc.set_trc(calgamma) caltf = caltrc.get_transfer_function(True, (0, 1), black_Y, outoffset) logfn and logfn(f"Black relative luminance = {round(black_Y, 6):.6f}") if outoffset is not None: logfn and logfn(f"Black output offset = {round(outoffset, 2):.2f}") if calgamma > 0: logfn and logfn( "Calibration gamma = {:.2f} {}".format( round(calgamma, 2), {"g": "relative", "G": "absolute"}.get(gamma_type) ) ) if calgamma: logfn and logfn( "Calibration overall transfer function ≈ {} (Δ {:.2f}%)".format( caltf[0][0], 100 - caltf[1] * 100 ) ) if calgamma > 0 and black_Y: # Calculate effective gamma midpoint = colormath.interp( (len(caltrc) - 1) / 2.0, list(range(len(caltrc))), caltrc ) gamma = colormath.get_gamma([(0.5, midpoint / 65535.0)]) logfn and logfn(f"Calibration effective gamma = {gamma:.2f}") tfs = [] for i, channel in enumerate("rgb"): trc = CurveType(profile=profile) trc[:] = [v / float(curves[i][-1]) * 65535 for v in curves[i]] # Get transfer function and see if we have a good match # to a standard. If we do, use the standard transfer # function instead of our measurement based one. # This avoids artifacts when processing is done in # limited (e.g. 8 bit) precision by a color managed # application and the source profile uses the same # standard transfer function. tf = trc.get_transfer_function(True, (0, 1), black_Y, outoffset) label = ["Transfer function", channel.upper()] label.append("≈ {} (Δ {:.2f}%)".format(tf[0][0], 100 - tf[1] * 100)) logfn and logfn(" ".join(label)) gamma = tf[0][1] if gamma > 0 and black_Y: # Calculate effective gamma gamma = colormath.get_gamma([(0.5, 0.5**gamma)], vmin=-black_Y) logfn and logfn("Effective gamma = {:.2f}".format(round(gamma, 2))) # Only use standard transfer function if we got a good match if tf[1] >= 0.98: # Good match logfn and logfn("Got good match (+-2%)") if ( single_curve and calgamma and round(tf[0][1], 1) == round(caltf[0][1], 1) ): # Use calibration gamma tf = caltf logfn and logfn("Using calibration transfer function") tfs.append((tf, trc)) if len(tfs) == 3: # Only use standard transfer function if we got a good # identical match for all three channels. optcurves = [] for i, channel in enumerate("rgb"): tf, trc = tfs[i] gamma = tf[0][1] if gamma > 0 and black_Y: # Calculate effective gamma egamma = colormath.get_gamma([(0.5, 0.5**gamma)], vmin=-black_Y) else: egamma = gamma if outoffset is None: outoffset = tf[0][2] if ( gamma > 0 and bpc and (outoffset == 1.0 or not black_Y) and bwd_mtx * [1, 1, 1] != [1, 1, 1] ): # Single gamma value, BPC, all output offset or # zero black luminance if gamma_type == "g": gamma = egamma trc.set_trc(gamma, 1) else: # Complex or gamma with offset if gamma == -1023: # DICOM is a special case trc.set_dicom_trc(black_cdm2, white_cdm2) elif gamma == -1886: # BT.1886 is a special case trc.set_bt1886_trc(black_Y) elif gamma == -2084: # SMPTE 2084 is a special case trc.set_smpte2084_trc(black_cdm2, white_cdm2) elif gamma > 0 and black_Y: # BT.1886-like or power law with offset if bpc and gamma_type == "g": # Use effective gamma needed to # achieve target effective gamma # after accounting for BPC eegamma = colormath.get_gamma( [(0.5, 0.5**egamma)], vmin=-black_Y ) else: eegamma = egamma trc.set_bt1886_trc(black_Y, outoffset, eegamma, "g") else: # L*, sRGB, Rec. 709, SMPTE 240M, or # power law without offset if bpc and gamma_type == "g": # Use effective gamma gamma = egamma trc.set_trc(gamma) trc.apply_bpc() tf = trc.get_transfer_function(True, (0, 1), black_Y, outoffset) logfn and logfn( "Using transfer function for {}: {}".format(channel.upper(), tf[0][0]) ) gamma = tf[0][1] if gamma > 0 and black_Y: # Calculate effective gamma gamma = colormath.get_gamma([(0.5, 0.5**gamma)], vmin=-black_Y) logfn and logfn("Effective gamma = {:.2f}".format(round(gamma, 2))) optcurves.append([v / 65535.0 * curves[i][-1] for v in trc]) curves = optcurves return curves def _applycal_bug_workaround(profile): # Argyll applycal can't deal with single gamma TRC tags # or TRC tags with less than 256 entries for channel in "rgb": trc_tag = profile.tags.get(channel + "TRC") if isinstance(trc_tag, CurveType) and len(trc_tag) < 256: num_entries = len(trc_tag) if num_entries <= 1: # Single gamma if num_entries: gamma = trc_tag[0] else: gamma = 1.0 trc_tag.set_trc(gamma, 256) else: # Interpolate to 256 entries entry_max = num_entries - 1.0 interp = colormath.Interp( [i / entry_max for i in range(num_entries)], trc_tag[:] ) trc_tag[:] = [interp(i / 255.0) for i in range(256)] def get_current_profile_path( include_display_profile=True, save_profile_if_no_path=False ): profile = None profile_path = getcfg("calibration.file", False) if profile_path: filename, ext = os.path.splitext(profile_path) if ext.lower() in (".icc", ".icm"): try: profile = ICCProfile(profile_path) except Exception as exception: print("ICCProfile({}):".format(profile_path), exception) elif include_display_profile: profile = config.get_display_profile() if profile and not profile.fileName and save_profile_if_no_path: if profile.ID == "\0" * 16: profile.calculateID() profile_cache_path = os.path.join(cache, "icc") if check_create_dir(profile_cache_path) is True: profile.fileName = os.path.join( profile_cache_path, "id=" + hexlify(profile.ID).decode() + profile_ext, ) if not os.path.isfile(profile.fileName): profile.write() if profile: return profile.fileName def parse_argument_string(args): """Parses an argument string and returns a list of arguments.""" return [ re.sub(r'^["\']|["\']$', "", arg) for arg in re.findall( r'(?:^|\s+)(-[^\s"\']+|"[^"]+?"|\'[^\']+?\'|[^\s"\']+)', args ) ] def get_cfg_option_from_args(option_name, argmatch, args, whole=False): """Parse args and return option (if found), otherwise return default.""" option = defaults[option_name] iarg = get_arg(argmatch, args, whole) if iarg: if len(iarg[1]) == len(argmatch): # Option value is the next argument if len(args) > iarg[0] + 1: option = args[iarg[0] + 1] else: # Option value follows argument directly option = iarg[1][len(argmatch) :] return option def get_options_from_args(dispcal_args=None, colprof_args=None) -> ([str], [str]): """Extract options used for dispcal and colprof from argument strings.""" re_options_dispcal = [ r"[moupHVFE]", r"d(?:\d+(?:,\d+)?|madvr|web)", r"[cv]\d+", r"q(?:{})".format("|".join(config.valid_values["calibration.quality"])), r"y(?:{})".format( "|".join([_f for _f in config.valid_values["measurement_mode"] if _f]) ), r"[tT](?:\d+(?:\.\d+)?)?", r"w\d+(?:\.\d+)?,\d+(?:\.\d+)?", r"[bfakAB]\d+(?:\.\d+)?", r"(?:g(?:240|709|l|s)|[gG]\d+(?:\.\d+)?)", r"[pP]\d+(?:\.\d+)?,\d+(?:\.\d+)?,\d+(?:\.\d+)?", r'X(?:\s*\d+|\s+["\'][^"\']+?["\'])', # Argyll >= 1.3.0 colorimeter correction matrix / Argyll >= 1.3.4 calibration spectral sample r"I[bw]{,2}", # Argyll >= 1.3.0 drift compensation r"YA", # Argyll >= 1.5.0 disable adaptive mode r"Q\w+", ] re_options_colprof = [ r"q[lmh]", r"b[lmh]", # B2A quality r"a(?:{})".format("|".join(config.valid_values["profile.type"])), r'[sSMA]\s+["\'][^"\']+?["\']', r"[cd](?:{})(?=\W|$)".format("|".join(viewconds)), r"[tT](?:{})(?=\W|$)".format("|".join(intents)), ] options_dispcal = [] options_colprof = [] if dispcal_args: if isinstance(dispcal_args, bytes): dispcal_args = dispcal_args.decode("UTF-8") options_dispcal = re.findall( r" -({})".format("|".join(re_options_dispcal)), f" {dispcal_args}" ) if colprof_args: if isinstance(colprof_args, bytes): colprof_args = colprof_args.decode("UTF-8") options_colprof = re.findall( r" -(" + "|".join(re_options_colprof) + ")", " " + colprof_args ) return options_dispcal, options_colprof def get_options_from_cprt(cprt): """Extract options used for dispcal and colprof from profile copyright.""" if not isinstance(cprt, str): if isinstance(cprt, (TextDescriptionType, MultiLocalizedUnicodeType)): cprt = str(cprt) else: cprt = str(cprt, fs_enc, "replace") dispcal_args = cprt.split(" dispcal ") colprof_args = None if len(dispcal_args) > 1: dispcal_args[1] = dispcal_args[1].split(" colprof ") if len(dispcal_args[1]) > 1: colprof_args = dispcal_args[1][1] dispcal_args = dispcal_args[1][0] else: dispcal_args = None colprof_args = cprt.split(" colprof ") if len(colprof_args) > 1: colprof_args = colprof_args[1] else: colprof_args = None return dispcal_args, colprof_args def get_options_from_cal(cal) -> ([str], [str]): if not isinstance(cal, CGATS): cal = CGATS(cal) if 0 in cal: cal = cal[0] if not cal or "ARGYLL_DISPCAL_ARGS" not in cal or not cal.ARGYLL_DISPCAL_ARGS: return [], [] dispcal_args = cal.ARGYLL_DISPCAL_ARGS[0] return get_options_from_args(dispcal_args) def get_options_from_profile(profile): """Try and get options from profile. First, try the 'targ' tag and look for the special DisplayCAL sections 'ARGYLL_DISPCAL_ARGS' and 'ARGYLL_COLPROF_ARGS'. If either does not exist, fall back to the copyright tag (DisplayCAL < 0.4.0.2)""" if not isinstance(profile, ICCProfile): profile = ICCProfile(profile) dispcal_args = None colprof_args = None if "targ" in profile.tags: ti3 = CGATS(profile.tags.targ) if 1 in ti3 and "ARGYLL_DISPCAL_ARGS" in ti3[1] and ti3[1].ARGYLL_DISPCAL_ARGS: dispcal_args = ti3[1].ARGYLL_DISPCAL_ARGS[0] if 0 in ti3 and "ARGYLL_COLPROF_ARGS" in ti3[0] and ti3[0].ARGYLL_COLPROF_ARGS: colprof_args = ti3[0].ARGYLL_COLPROF_ARGS[0] if not dispcal_args and "cprt" in profile.tags: dispcal_args = get_options_from_cprt(profile.getCopyright())[0] if not colprof_args and "cprt" in profile.tags: colprof_args = get_options_from_cprt(profile.getCopyright())[1] return get_options_from_args(dispcal_args, colprof_args) def get_options_from_ti3(ti3): """Try and get options from TI3 file by looking for the special DisplayCAL sections 'ARGYLL_DISPCAL_ARGS' and 'ARGYLL_COLPROF_ARGS'. """ if not isinstance(ti3, CGATS): ti3 = CGATS(ti3) dispcal_args = None colprof_args = None if 1 in ti3 and "ARGYLL_DISPCAL_ARGS" in ti3[1] and ti3[1].ARGYLL_DISPCAL_ARGS: dispcal_args = ti3[1].ARGYLL_DISPCAL_ARGS[0] if 0 in ti3 and "ARGYLL_COLPROF_ARGS" in ti3[0] and ti3[0].ARGYLL_COLPROF_ARGS: colprof_args = ti3[0].ARGYLL_COLPROF_ARGS[0] return get_options_from_args(dispcal_args, colprof_args) def get_pattern_geometry(): """Return pattern geometry for pattern generator""" x, y, size = [float(v) for v in getcfg("dimensions.measureframe").split(",")] if os.getenv("XDG_SESSION_TYPE") == "wayland": # No way to get coordinates under Wayland, default to center x = y = 0.5 size = size * defaults["size.measureframe"] match = re.search(r"@ -?\d+, -?\d+, (\d+)x(\d+)", getcfg("displays", raw=True)) if match: display_size = [int(item) for item in match.groups()] else: display_size = 1920, 1080 w, h = [min(size / v, 1.0) for v in display_size] if config.get_display_name(None, True) == "Prisma": w = h x = (display_size[0] - w * display_size[0]) * x / display_size[0] y = (display_size[1] - h * display_size[1]) * y / display_size[1] x, y, w, h = [max(v, 0) for v in (x, y, w, h)] size = w * h return x, y, w, h, size def get_python_and_pythonpath(): """Return (system) python and pythonpath""" # Determine the path of python, and python module search paths # If we are running 'frozen', expect python.exe in the same directory # as the packed executable. # py2exe: The python executable can be included via setup script by # adding it to 'data_files' pythonpath = list(sys.path) dirname = os.path.dirname(sys.executable) if sys.platform == "win32": if getattr(sys, "frozen", False): pythonpath = [dirname] # If we are running 'frozen', add library.zip and lib\library.zip # to sys.path # py2exe: Needs appropriate 'zipfile' option in setup script and # 'bundle_files' 3 pythonpath.append(os.path.join(dirname, "library.zip")) pythonpath.append(os.path.join(dirname, "library.zip", appname)) if os.path.isdir(os.path.join(dirname, "lib")): dirname = os.path.join(dirname, "lib") pythonpath.append(os.path.join(dirname, "library.zip")) pythonpath.append(os.path.join(dirname, "library.zip", appname)) python = os.path.join(dirname, "python.exe") else: # Linux / Mac OS X if isapp: python = os.path.join(dirname, "python") else: paths = os.defpath.split(os.pathsep) python = ( which("python3.7", paths) or which("python3.6", paths) or "/usr/bin/env python" ) return (python, pythonpath) def get_arg(argmatch, args, whole=False): """Return first found entry beginning with the argmatch string or None""" for i, arg in enumerate(args): if (whole and arg == argmatch) or (not whole and arg.startswith(argmatch)): return i, arg def get_default_headers(): """Get default headers for HTTP request""" if sys.platform == "darwin": # Python's platform.platform output is useless under Mac OS X # (e.g. 'Darwin-15.0.0-x86_64-i386-64bit' for Mac OS X 10.11 El Capitan) oscpu = "Mac OS X {}; {}".format(mac_ver()[0], mac_ver()[-1]) elif sys.platform == "win32": machine = platform.machine() oscpu = "{}; {}".format( safe_str(" ".join([v for v in win_ver() if v]), "ASCII", "asciize"), {"AMD64": "x86_64"}.get(machine, machine), ) else: # Linux oscpu = "{}; {}".format( " ".join([distro.id(), distro.version(), distro.codename()]), platform.machine(), ) return { "User-Agent": f"{appname}/{version} ({oscpu})", "Accept-Language": f"{lang.getcode()},*;q=0.5", } def http_request( parent=None, domain=None, request_type="GET", path="", params=None, files=None, headers=None, charset="UTF-8", failure_msg="", silent=False, ): """HTTP request wrapper""" if params is None: params = {} if files: content_type, params = encode_multipart_formdata(iter(params.items()), files) else: for key in params: params[key] = safe_str(params[key], charset) params = urllib.parse.urlencode(params) if headers is None: headers = get_default_headers() if request_type == "GET": path += "?" + params params = None else: if files: headers.update( {"Content-Type": content_type, "Content-Length": str(len(params))} ) else: headers.update( { "Content-Type": "application/x-www-form-urlencoded", "Accept": "text/plain", } ) conn = http.client.HTTPConnection(domain) try: conn.request(request_type, path, params, headers) resp = conn.getresponse() except (socket.error, http.client.HTTPException) as exception: msg = " ".join( [ failure_msg, lang.getstr( "connection.fail", " ".join([str(arg) for arg in exception.args]) ), ] ).strip() print(msg) if not silent: wx.CallAfter( InfoDialog, parent, msg=msg, ok=lang.getstr("ok"), bitmap=geticon(32, "dialog-error"), log=False, ) return False if resp.status >= 400: uri = "http://" + domain + path msg = ( " ".join( [ failure_msg, lang.getstr( "connection.fail.http", " ".join([str(resp.status), resp.reason]), ), ] ).strip() + "\n" + uri ) print(msg) html = universal_newlines(resp.read().strip()) html = re.sub( re.compile(r"", re.I | re.S), "", html, ) html = re.sub( re.compile(r"", re.I | re.S), "", html, ) print(html) if not silent: wx.CallAfter( HtmlInfoDialog, parent, msg=msg, html=html, ok=lang.getstr("ok"), bitmap=geticon(32, "dialog-error"), log=False, ) return False return resp def insert_ti_patches_omitting_RGB_duplicates(cgats1, cgats2_path, logfn=print): """Insert patches from first TI file after first patch of second TI, ignoring RGB duplicates. Return second TI as CGATS instance. """ cgats2 = CGATS(cgats2_path) cgats1_data = cgats1.queryv1("DATA") data = cgats2.queryv1("DATA") data_format = cgats2.queryv1("DATA_FORMAT") # Get only RGB data data.parent.DATA_FORMAT = CGATS() data.parent.DATA_FORMAT.key = "DATA_FORMAT" data.parent.DATA_FORMAT.parent = data data.parent.DATA_FORMAT.root = data.root data.parent.DATA_FORMAT.type = b"DATA_FORMAT" for i, label in enumerate(("RGB_R", "RGB_G", "RGB_B")): data.parent.DATA_FORMAT[i] = label cgats1_data.parent.DATA_FORMAT = data.parent.DATA_FORMAT rgbdata = str(data) # Restore DATA_FORMAT data.parent.DATA_FORMAT = data_format # Collect all preconditioning point datasets not in data cgats1_data.vmaxlen = data.vmaxlen cgats1_datasets = [] for i in cgats1_data: dataset = cgats1_data[i] if str(dataset) not in rgbdata: # Not a duplicate cgats1_datasets.append(dataset) if cgats1_datasets: # Insert preconditioned point datasets after first patch if logfn: logfn( "{}: Adding {:d} fixed points to {}".format( appname, len(cgats1_datasets), cgats2_path ) ) data.moveby1(1, len(cgats1_datasets)) for i, dataset in enumerate(cgats1_datasets): dataset.key = i + 1 dataset.parent = data dataset.root = data.root data[dataset.key] = dataset return cgats2 class EvalFalse: """Evaluate to False in boolean comparisons.""" def __init__(self, wrapped_object): self._wrapped_object = wrapped_object def __getattribute__(self, name): return getattr(object.__getattribute__(self, "_wrapped_object"), name) def __bool__(self): return False class DummyDialog: def __init__(self, *args, **kwargs): self.is_shown_on_screen = True def Close(self, force=False): pass def Destroy(self): pass def EndModal(self, id=-1): return id def Hide(self): pass def IsShownOnScreen(self): return self.is_shown_on_screen def Show(self, show=True): self.is_shown_on_screen = show def ShowModal(self): pass class FilteredStream: """Wrap a stream and filter all lines written to it.""" # Discard the whole line if it is empty after replacing patterns discard = "" # If one of the triggers is contained in a line, skip the whole line triggers = [ "Place instrument on test window", "key to continue", "key to retry", "key to take a reading", "] to read", "' to set", "' to report", "' to toggle", " or Q to ", "place on the white calibration reference", "or place on the calibration reference", "read failed due to the sensor being in the wrong position", "Ambient filter should be removed", "The instrument can be removed from the screen", ] + INST_CAL_MSGS substitutions = { r"\^\[": "", # ESC key on Linux/OSX "patch ": "Patch ", re.compile(r"Point \d+", re.I): "", } # Strip these patterns from input before writing. Note that this only works # on full lines (ending with linesep_in) prestrip = "" def __init__( self, stream, data_encoding=None, file_encoding=None, errors="replace", discard=None, linesep_in="\r\n", linesep_out="\n", substitutions=None, triggers=None, prestrip=None, ): self.stream = stream self.data_encoding = data_encoding self.file_encoding = file_encoding self.errors = errors if discard is not None: self.discard = discard self.linesep_in = linesep_in self.linesep_out = linesep_out if substitutions is not None: self.substitutions = substitutions if triggers is not None: self.triggers = triggers if prestrip is not None: self.prestrip = prestrip self._buffer = "" def __getattr__(self, name): return getattr(self.stream, name) def write(self, data): """Write data to stream, stripping all unwanted output. Incoming lines are expected to be delimited by linesep_in. """ if not data: return if isinstance(data, bytes): data = data.decode() if self.prestrip and (re.search(self.prestrip, data) or self._buffer): if not data.endswith(self.linesep_in): # Buffer all data until we see a line ending self._buffer += data return elif self._buffer: # Assemble the full line from the buffer data = self._buffer + data self._buffer = "" data = re.sub(self.prestrip, "", data) lines = [] for line in data.split(self.linesep_in): if line and not re.sub(self.discard, "", line): line = "" write = True for trigger in self.triggers: if trigger.lower() in line.lower(): write = False break if write: if self.data_encoding and not isinstance(line, str): line = line.decode(self.data_encoding, self.errors) for search in self.substitutions: sub = self.substitutions[search] line = re.sub(search, sub, line) if self.file_encoding: line = line.encode(self.file_encoding, self.errors) lines.append(line) if lines: self.stream.write(self.linesep_out.join(lines)) class Producer: """Generic producer.""" def __init__(self, worker, producer, continue_next=False): self.worker = worker self.producer = producer self.continue_next = continue_next def __call__(self, *args, **kwargs): try: result = self.producer(*args, **kwargs) except Exception as exception: if debug: messages = traceback.format_exception(exception) print( "[D] Worker raised an unhandled exception: \n" + "\n".join(messages) ) raise if not self.continue_next and self.worker._progress_wnd: if hasattr( self.worker.progress_wnd, "animbmp" ) and self.worker.progress_wnd.progress_type in (0, 2): # Allow time for animation fadeout wx.CallAfter(self.worker.progress_wnd.stop_timer, False) if self.worker.progress_wnd.progress_type == 0: sleep(4) else: sleep(1) return result class StringWithLengthOverride(UserString): """Allow defined behavior in comparisons and when evaluating length.""" def __init__(self, seq, length=None): UserString.__init__(self, seq) if length is None: length = len(seq) self.length = length def __len__(self): return self.length class Sudo: """Determine if a command can be run via sudo""" def __init__(self): self.availoptions = {} self.sudo = which("sudo") if self.sudo: # Determine available sudo options man = which("man") if man: manproc = sp.Popen([man, "sudo"], stdout=sp.PIPE, stderr=sp.PIPE) # Strip formatting stdout = re.sub(b".\x08", b"", manproc.communicate()[0]) self.availoptions = { "E": bool(re.search(rb"-E\W", stdout)), "l [command]": bool(re.search(rb"-l\W(?:.*?\W)?command\W", stdout)), "K": bool(re.search(rb"-K\W", stdout)), "k": bool(re.search(rb"-k\W", stdout)), } if debug: print( "[D] Available sudo options:", ", ".join( [ option for option in list(self.availoptions.keys()) if self.availoptions[option] ] ), ) def __len__(self): return int(bool(self.sudo)) def __str__(self): return str(self.sudo or "") def _expect_timeout(self, patterns, timeout=-1, child_timeout=1): """wexpect.spawn.expect with better timeout handling. The default expect can block up to timeout seconds if the child is already dead. To prevent this, we run expect in a loop until a pattern is matched, timeout is reached or an exception occurs. The max time an expect call will block if the child is already dead can be set with the child_timeout parameter. """ if timeout == -1: timeout = self.subprocess.timeout patterns = list(patterns) if wexpect.TIMEOUT not in patterns: patterns.append(wexpect.TIMEOUT) start = time() while True: result = self.subprocess.expect(patterns, timeout=child_timeout) if ( self.subprocess.after is not wexpect.TIMEOUT or time() - start >= timeout ): break return result def _terminate(self): """Terminate running sudo subprocess.""" self.subprocess.sendcontrol("C") self._expect_timeout([wexpect.EOF], 10) if self.subprocess.after is wexpect.TIMEOUT: print("Warning: sudo timed out") if not self.subprocess.terminate(force=True): print("Warning: Couldn't terminate timed-out sudo subprocess") else: subprocess_before = self.subprocess.before.strip() if isinstance(subprocess_before, bytes): subprocess_before = subprocess_before.decode(enc, "replace") print(subprocess_before) def authenticate(self, args, title, parent=None): """Authenticate for a given command The return value will be a tuple (auth_successful, password). auth_successful will be a custom class that will always have length 0 if authentication was not successful or the command is not allowed (even if the actual string length is non-zero), thus allowing for easy boolean comparisons. """ # Authentication using sudo is pretty convoluted if dealing with # platform and configuration differences. Ask for a password by first # clearing any cached credentials (sudo -K) so that sudo is guaranteed # to ask for a password if a command is run through it, then we spawn # sudo true (with true being the standard GNU utility that always # has an exit status of 0) and expect the password prompt. The user # is then given the opportunity to enter a password, which is then fed # to sudo. If sudo exits with a status of 0, the password must have # been accepted, but we still don't know for sure if our command is # allowed, so we run sudo -l to determine if it is # indeed allowed. pwd = "" dlg = ConfirmDialog( parent, title=title, msg=lang.getstr("dialog.enter_password"), ok=lang.getstr("ok"), cancel=lang.getstr("cancel"), bitmap=geticon(32, "lock"), ) dlg.pwd_txt_ctrl = wx.TextCtrl( dlg, -1, pwd, size=(320, -1), style=wx.TE_PASSWORD | wx.TE_PROCESS_ENTER ) dlg.pwd_txt_ctrl.Bind(wx.EVT_TEXT_ENTER, lambda event: dlg.EndModal(wx.ID_OK)) dlg.sizer3.Add( dlg.pwd_txt_ctrl, 1, # flag=wx.TOP | wx.ALIGN_LEFT, border=12) flag=wx.TOP, border=12, ) dlg.ok.SetDefault() dlg.sizer0.SetSizeHints(dlg) dlg.sizer0.Layout() # Remove cached credentials self.kill() sudo_args = ["-p", "Password:", "true"] try: p = self.subprocess = wexpect.spawn(safe_str(self.sudo), sudo_args) except Exception as exception: return ( StringWithLengthOverride( "Could not run {} {}: {}".format( self.sudo, " ".join(sudo_args), exception ), 0, ), pwd, ) self._expect_timeout(["Password:", wexpect.EOF], 10) # We need to call isalive() to set the exitstatus while p.isalive() and p.after == "Password:": # Ask for password dlg.pwd_txt_ctrl.SetFocus() result = dlg.ShowModal() pwd = dlg.pwd_txt_ctrl.GetValue() if result != wx.ID_OK: self._terminate() return False, pwd p.send(pwd + os.linesep) self._expect_timeout(["Password:", wexpect.EOF], 10) if p.after == "Password:": msg = lang.getstr("dialog.enter_password") errstr = p.before.strip() if errstr: print(errstr) msg = "\n\n".join([errstr, msg]) dlg.message.SetLabel(msg) dlg.message.Wrap(dlg.GetSize()[0] - 32 - 12 * 2) dlg.pwd_txt_ctrl.SetValue("") dlg.sizer0.SetSizeHints(dlg) dlg.sizer0.Layout() dlg.Destroy() if p.after is wexpect.TIMEOUT: print("Error: sudo timed out") if not p.terminate(force=True): print("Warning: Couldn't terminate timed-out sudo subprocess") return StringWithLengthOverride("sudo timed out", 0), pwd if p.exitstatus != 0: return ( StringWithLengthOverride( p.before.strip().decode(enc, "replace") or (f"sudo exited prematurely with status {p.exitstatus}"), 0, ), pwd, ) # Password was accepted, check if command is allowed return self.is_allowed(args, pwd), pwd def is_allowed(self, args=None, pwd=""): """Check if a command is allowed via sudo. Return either a string listing allowed and forbidden commands, or the fully-qualified path of the command along with any arguments, or an error message in case the command is not allowed, or False if the password was not accepted. The returned error is a custom class that will always have length 0 if the command is not allowed (even if the actual string length is non-zero), thus allowing for easy boolean comparisons. """ sudo_args = ["-p", "Password:", "-l"] # Set sudo args based on available options if self.availoptions.get("l [command]") and args: sudo_args += args try: p = self.subprocess = wexpect.spawn(safe_str(self.sudo), sudo_args) except Exception as exception: return StringWithLengthOverride( "Could not run {} {}: {}".format( self.sudo, " ".join(sudo_args), exception ), 0, ) self._expect_timeout(["Password:", wexpect.EOF], 10) # We need to call isalive() to set the exitstatus while p.isalive() and p.after == "Password:": p.send(pwd + os.linesep) self._expect_timeout(["Password:", wexpect.EOF], 10) if p.after == "Password:": # Password was not accepted self._terminate() return StringWithLengthOverride(p.before.strip(), 0) if p.after is wexpect.TIMEOUT: print("Error: sudo timed out") if not p.terminate(force=True): print("Warning: Couldn't terminate timed-out sudo subprocess") return StringWithLengthOverride("sudo timed out", 0) if p.exitstatus != 0: return StringWithLengthOverride( p.before.strip() or (f"sudo exited prematurely with status {p.exitstatus}"), 0, ) return p.before.strip() def kill(self): """Remove cached credentials""" kill_arg = None if self.availoptions.get("K"): kill_arg = "-K" elif self.availoptions.get("k"): kill_arg = "-k" if kill_arg: sp.call([safe_str(self.sudo), kill_arg]) class WPopen(sp.Popen): def __init__(self, *args, **kwargs): sp.Popen.__init__(self, *args, **kwargs) self._seekpos = 0 self._stdout = kwargs["stdout"] self.after = None self.before = None self.exitstatus = None self.logfile_read = None self.match = None self.maxlen = 80 self.timeout = 30 def isalive(self): self.exitstatus = self.poll() return self.exitstatus is None def expect(self, patterns, timeout=-1): if not isinstance(patterns, list): patterns = [patterns] if timeout == -1: timeout = self.timeout if timeout is not None: end = time() + timeout while timeout is None or time() < end: self._stdout.seek(self._seekpos) buf = self._stdout.read() self._seekpos += len(buf) if not buf and not self.isalive(): self.match = wexpect.EOF( "End Of File (EOF) in expect() - dead child process" ) if wexpect.EOF in patterns: return self.match raise self.match if buf and self.logfile_read: self.logfile_read.write(buf) for pattern in patterns: if isinstance(pattern, str) and pattern in buf: offset = buf.find(pattern) self.after = buf[offset:] self.before = buf[:offset] self.match = buf[offset : offset + len(pattern)] return self.match sleep(0.01) if timeout is not None: self.match = wexpect.TIMEOUT("Timeout exceeded in expect()") if wexpect.TIMEOUT in patterns: return self.match raise self.match def send(self, s): self.stdin.write(s) self._stdout.seek(self._seekpos) buf = self._stdout.read() self._seekpos += len(buf) if buf and self.logfile_read: self.logfile_read.write(buf) def terminate(self, force=False): sp.Popen.terminate(self) class Worker(WorkerBase): def __init__(self, owner=None): """Create and return a new worker instance.""" WorkerBase.__init__(self) self.argyll_bin_dir = None self.argyll_version = [0, 0, 0] self.argyll_version_string = "0.0.0" self._displays = [] self.display_edid = [] self.display_manufacturers = [] self.display_names = [] self.display_rects = [] self.displays = [] self.instruments = [] self.lut_access = [] self.paused = False self._patterngenerator_wait = False self.send_buffer = None self.partial_data = "" self.owner = owner # owner should be a wxFrame or similar if sys.platform == "win32": self.pty_encoding = f"cp{windll.kernel32.GetACP():d}" else: self.pty_encoding = enc self.cmdrun = False self.dispcal_create_fast_matrix_shaper = False self.dispread_after_dispcal = False self.finished = True self.instrument_on_screen = False self.interactive = False self.spotread_just_do_instrument_calibration = False self.lastcmdname = None # Filter out warnings from OS components (e.g. shared libraries) # E.g.: # Nov 26 16:28:16 dispcal[1006] : void CGSUpdateManager::log() const: conn 0x1ec57 token 0x3ffffffffffd0a prestrip = re.compile( r"\D+\s+\d+\s+\d+:\d+:\d+\s+\w+\[\d+]\s+:[\S\s]*" ) discard = [r"[\*\.]+|Current (?:RGB|XYZ)(?: +.*)?"] self.lastmsg_discard = re.compile(r"|".join(discard)) self._init_sounds(dummy=True) self.options_colprof = [] self.options_dispcal = [] self.options_dispread = [] self.options_targen = [] self.pauseable = False discard = [ r"^Display type is .+", r"^Doing (?:some initial|check) measurements", r"^Adjust .+? Press space when done\.\s*", r"^\s*(?:[/\\]\s+)?(?:Adjusted )?(Current", r"Initial", r"[Tt]arget) (?:Br(?:ightness)?", r"50% Level", r"white", r"(?:Near )?[Bb]lack", r"(?:advertised )?gamma", r"RGB", r"\d(?:\.\d+)?).*", r"^Gamma curve .+", r"^Display adjustment menu:", r"^Press", r"^\d\).+", r"^(?:1%|Black|Red|Green|Blue|White|Grey)\s+=.+", r"^\s*patch \d+ of \d+.*", r"^\s*point \d+.*", r"^\s*Added \d+/\d+", # These need to be last because they're very generic! r"[\*\.]+", r"\s*\d*%?", ] self.recent_discard = re.compile(r"|".join(discard), re.I) self.resume = False self.sudo = None self.auth_timestamp = 0 self.sessionlogfiles = {} self.triggers = ["Password:"] self.recent = FilteredStream( LineCache(maxlines=3), self.pty_encoding, discard=self.recent_discard, triggers=self.triggers + ["stopped at user request"], prestrip=prestrip, ) self.lastmsg = FilteredStream( LineCache(), self.pty_encoding, discard=self.lastmsg_discard, triggers=self.triggers, prestrip=prestrip, ) self.clear_argyll_info() self.set_argyll_version_from_string(getcfg("argyll.version"), False) self.clear_cmd_output() self._detecting_video_levels = False self._detected_output_levels = False self._patterngenerators = {} self._progress_dlgs = {} self._progress_wnd = None self._pwdstr = "" workers.append(self) def _init_sounds(self, dummy=False): if dummy: self.measurement_sound = audio.DummySound() self.commit_sound = audio.DummySound() else: # Sounds when measuring # Needs to be stereo! self.measurement_sound = audio.Sound(get_data_path("beep.wav")) self.commit_sound = audio.Sound(get_data_path("camera_shutter.wav")) def add_measurement_features( self, args, display=True, ignore_display_name=False, allow_nondefault_observer=False, ambient=False, allow_video_levels=True, quantize=False, cmd=None, ): """Add common options and to dispcal, dispread and spotread arguments""" if display and not get_arg("-d", args): args.append("-d" + self.get_display()) if display and allow_video_levels: self.add_video_levels_arg(args) if ( display and quantize and not get_arg("-Z", args) and getcfg("patterngenerator.quantize_bits") ): # dispread only args.append("-Z{:d}".format(getcfg("patterngenerator.quantize_bits"))) if not get_arg("-c", args): args.append("-c{}".format(getcfg("comport.number"))) instrument_name = self.get_instrument_name() measurement_mode = getcfg("measurement_mode") if measurement_mode == "auto": # Make changes in DisplayCAL.MainFrame.set_ccxx_measurement_mode too! if instrument_name == "ColorHug": measurement_mode = "R" elif instrument_name == "ColorHug2": measurement_mode = "F" else: measurement_mode = "l" instrument_features = self.get_instrument_features() if ( not ambient and measurement_mode and not get_arg("-y", args) and instrument_name != "specbos 1201" ): # Always specify -y for colorimeters (won't be read from cal # when updating) # The specbos 1201 (unlike 1211) doesn't support measurement # mode selection if self.argyll_version >= [1, 5, 0]: measurement_mode_map = instrument_features.get( "measurement_mode_map", {} ) measurement_mode = measurement_mode_map.get( measurement_mode[0], measurement_mode ) args.append("-y" + measurement_mode[0]) if ( getcfg("measurement_mode.projector") and instrument_features.get("projector_mode") and self.argyll_version >= [1, 1, 0] and not get_arg("-p", args) ): # Projector mode, Argyll >= 1.1.0 Beta args.append("-p") if instrument_features.get("adaptive_mode"): if getcfg("measurement_mode.adaptive"): if ( ( self.argyll_version[0:3] > [1, 1, 0] or ( self.argyll_version[0:3] == [1, 1, 0] and "Beta" not in self.argyll_version_string and "RC1" not in self.argyll_version_string and "RC2" not in self.argyll_version_string ) ) and self.argyll_version[0:3] < [1, 5, 0] and not get_arg("-V", args, True) ): # Adaptive measurement mode, Argyll >= 1.1.0 RC3 args.append("-V") else: if self.argyll_version[0:3] >= [1, 5, 0]: # Disable adaptive measurement mode args.append("-YA") if ( instrument_name in ("Spyder4", "Spyder5") and self.argyll_version == [1, 7, 0] and measurement_mode in ("f", "e") and not get_arg("-YR:", args) ): # Prevent 'Warning - Spyder: measuring refresh rate failed' args.append("-YR:60") non_argyll_prisma = ( config.get_display_name() == "Prisma" and not defaults["patterngenerator.prisma.argyll"] ) if display and not (get_arg("-dweb", args) or get_arg("-dmadvr", args)): if ( (self.argyll_version <= [1, 0, 4] and not get_arg("-p", args)) or (self.argyll_version > [1, 0, 4] and not get_arg("-P", args)) and f"-d{self.argyll_virtual_display}" not in args ): if ( config.get_display_name() == "Resolve" or non_argyll_prisma ) and not ignore_display_name: # Move Argyll test window to lower right corner and make it # very small dimensions_measureframe = "1,1,0.01" else: if os.getenv("XDG_SESSION_TYPE") == "wayland": # The following is a workaround for Wayland not exposing the # absolute screen positions of a window. dimensions_measureframe = "0.5,0.5,1.5" else: dimensions_measureframe = getcfg("dimensions.measureframe") if get_arg("-dcc", args): # Rescale for Chromecast default patch size of 10% dimensions_measureframe = config.get_measureframe_dimensions( dimensions_measureframe, 10 ) args.append(f"-P{dimensions_measureframe}") farg = get_arg("-F", args, True) if ( config.get_display_name() == "Resolve" or non_argyll_prisma ) and not ignore_display_name: if farg: # Remove -F (darken background) as we relay colors to # pattern generator args = args[: farg[0]] + args[farg[0] + 1 :] elif getcfg("measure.darken_background") and not farg: args.append("-F") if ( getcfg("measurement_mode.highres") and instrument_features.get("highres_mode") and not get_arg("-H", args, True) ): args.append("-H") if ( allow_nondefault_observer and self.instrument_can_use_nondefault_observer() and getcfg("observer") != defaults["observer"] and not get_arg("-Q", args) ): args.append("-Q" + getcfg("observer")) if ( not ambient and self.instrument_can_use_ccxx() and not is_ccxx_testchart() and not get_arg("-X", args) ): # Use colorimeter correction? ccmx = getcfg("colorimeter_correction_matrix_file").split(":", 1) if len(ccmx) > 1 and ccmx[1]: ccmx = ccmx[1] else: ccmx = None if ccmx and ( not ccmx.lower().endswith(".ccss") or self.instrument_supports_ccss() ): result = check_file_isfile(ccmx) if isinstance(result, Exception): return result try: cgats = CGATS(ccmx) except (IOError, CGATSError) as exception: return exception else: ccxx_instrument_from_cgats = cgats.queryv1("INSTRUMENT") or b"" ccxx_instrument = get_canonical_instrument_name( ccxx_instrument_from_cgats, { "DTP94-LCD mode": "DTP94", "eye-one display": "i1 Display", "Spyder 2 LCD": "Spyder2", "Spyder 3": "Spyder3", }, ) if isinstance(ccxx_instrument, bytes): ccxx_instrument = ccxx_instrument.decode("utf-8") if ( ccxx_instrument and instrument_name.lower().replace(" ", "") in ccxx_instrument.lower().replace(" ", "") ) or ccmx.lower().endswith(".ccss"): tempdir = self.create_tempdir() if isinstance(tempdir, Exception): return tempdir ccmxcopy = os.path.join(tempdir, os.path.basename(ccmx)) if not os.path.isfile(ccmxcopy): if 0 in cgats and cgats[0].type.strip() == b"CCMX": # Add display base ID if missing cbid_added = self.check_add_display_type_base_id(cgats) else: cbid_added = False try: # Copy ccmx to profile dir if cbid_added: # Write updated CCMX cgats.write(ccmxcopy) else: # Copy original shutil.copyfile(ccmx, ccmxcopy) except Exception as exception: return Error( lang.getstr("error.copy_failed", (ccmx, ccmxcopy)) + "\n\n" + str(exception) ) result = check_file_isfile(ccmxcopy) if isinstance(result, Exception): return result args.append("-X") args.append(os.path.basename(ccmxcopy)) if ( display and ( getcfg("drift_compensation.blacklevel") or getcfg("drift_compensation.whitelevel") ) and self.argyll_version >= [1, 3, 0] and not get_arg("-I", args) ): args.append("-I") if getcfg("drift_compensation.blacklevel"): args[-1] += "b" if getcfg("drift_compensation.whitelevel"): args[-1] += "w" # TTBD/FIXME: Skipping of sensor calibration can't be done in # emissive mode (see Argyll source spectro/ss.c, around line 40) # (is this still the case though?) # Note we implicitly skip sensor calibration if already done during # output levels detection or if using spotread, but only for colorimeters if ( ( getcfg("allow_skip_sensor_cal") or ( not instrument_features.get("spectral") and ( self._detected_output_levels or (self.dispread_after_dispcal and self.resume) or cmd == get_argyll_util("spotread") ) and not self._detecting_video_levels ) ) and instrument_features.get("skip_sensor_cal") and self.argyll_version >= [1, 1, 0] and not get_arg("-N", args, True) and not self.spotread_just_do_instrument_calibration ): args.append("-N") return True def add_video_levels_arg(self, args): if ( config.get_display_name() not in ("madVR", "Resolve", "Prisma") and getcfg("patterngenerator.use_video_levels") and self.argyll_version >= [1, 6] and self.get_display() != self.argyll_virtual_display ): # For madVR and dummy display, -E is invalid args.append("-E") def authenticate(self, cmd, title=appname, parent=None): """Athenticate (using sudo) for a given command The return value will either be True (authentication successful and command allowed), False (in case of the user cancelling the password dialog), None (Windows or running as root) or an error. """ if sys.platform == "win32" or os.geteuid() == 0: return self.auth_timestamp = 0 ocmd = cmd if cmd and not os.path.isabs(cmd): cmd = get_argyll_util(ocmd) if not cmd: cmd = which(ocmd) if not cmd or not os.path.isfile(cmd): return Error(lang.getstr("file.missing", ocmd)) _disabler = BetterWindowDisabler() result = True if not self.sudo: self.sudo = Sudo() if not self.sudo: result = Error(lang.getstr("file.missing", "sudo")) if result is True: pwd = self.pwd args = [cmd, "-?"] if not pwd or not self.sudo.is_allowed(args, pwd): # If no password was previously available, or if the requested # command cannot be run via sudo regardless of password (we check # this with sudo -l ), we ask for a password. print(lang.getstr("auth")) progress_dlg = self._progress_wnd or getattr( wx.GetApp(), "progress_dlg", None ) if parent is None: if progress_dlg and progress_dlg.IsShownOnScreen(): parent = progress_dlg else: parent = self.owner result, pwd = self.sudo.authenticate(args, title, parent) if result: self.pwd = pwd result = True elif result is False: print(lang.getstr("aborted")) else: result = Error(result) if result is True: self.auth_timestamp = time() del _disabler return result def blend_profile_blackpoint( self, profile1, profile2, XYZbp=None, outoffset=0.0, gamma=2.4, gamma_type="B", size=None, apply_trc=True, white_cdm2=100, minmll=0, maxmll=10000, use_alternate_master_white_clip=True, ambient_cdm2=5, content_rgb_space="DCI P3", hdr_chroma_compression=False, hdr_sat=0.5, hdr_hue=0.5, hdr_target_profile=None, ): """Apply BT.1886-like tone response to profile1 using profile2 blackpoint. profile1 has to be a matrix profile """ odata = self.xicclu(profile2, (0, 0, 0), pcs="x") if len(odata) != 1 or len(odata[0]) != 3: raise ValueError(f"Blackpoint is invalid: {odata}") oXYZbp = odata[0] if not XYZbp: XYZbp = oXYZbp smpte2084 = gamma in ("smpte2084.hardclip", "smpte2084.rolloffclip") hlg = gamma == "hlg" hdr = smpte2084 or hlg lumi = profile2.tags.get("lumi", XYZType()) if not lumi.Y: lumi.Y = 100.0 profile_black_cdm2 = XYZbp[1] * lumi.Y if smpte2084: # SMPTE ST.2084 (PQ) if gamma != "smpte2084.rolloffclip": maxmll = white_cdm2 self.log( os.path.basename(profile1.fileName) + " → " + lang.getstr("trc." + gamma) + ( " {:0.0f} cd/m² (mastering {}-{:0.0f} cd/m²)".format( white_cdm2, stripzeros(f"{minmll:.4f}"), maxmll ) ) ) elif hlg: # Hybrid Log-Gamma (HLG) outoffset = 1.0 self.log( os.path.basename(profile1.fileName) + " → " + lang.getstr("trc." + gamma) + ( " {:0.0f} cd/m² (ambient {} cd/m²)".format( lumi.Y, stripzeros(f"{ambient_cdm2:.2f}") ) ) ) elif apply_trc: self.log( "Applying BT.1886-like TRC to " + os.path.basename(profile1.fileName) ) else: self.log( "Applying BT.1886-like black offset to " + os.path.basename(profile1.fileName) ) self.log( "Black XYZ (normalized 0..100) = {:.6f} {:.6f} {:.6f}".format( *[v * 100 for v in XYZbp] ) ) self.log( "Black Lab = {:.6f} {:.6f} {:.6f}".format( *colormath.XYZ2Lab(*[v * 100 for v in XYZbp]) ) ) self.log("Output offset = {:.2f}%".format(outoffset * 100)) if hdr: odesc = profile1.getDescription() desc = re.sub( r"\s*(?:color profile|primaries with \S+ transfer function)$", "", odesc ) if smpte2084: # SMPTE ST.2084 (PQ) black_cdm2 = profile_black_cdm2 * (1 - outoffset) if XYZbp[1]: XYZbp_cdm2 = [v / XYZbp[1] * black_cdm2 for v in XYZbp] else: XYZbp_cdm2 = [0, 0, 0] profile1.set_smpte2084_trc( XYZbp_cdm2, white_cdm2, minmll, maxmll, use_alternate_master_white_clip, rolloff=True, blend_blackpoint=False, ) desc += ( " " + lang.getstr("trc." + gamma) + ( " {}-{:0.0f} cd/m² (mastering {}-{:0.0f} cd/m²)".format( stripzeros(f"{profile_black_cdm2:.4f}"), white_cdm2, stripzeros(f"{minmll:.4f}"), maxmll, ) ) ) elif hlg: # Hybrid Log-Gamma (HLG) black_cdm2 = 0 # Black offset will be applied separate for HLG white_cdm2 = lumi.Y profile1.set_hlg_trc((0, 0, 0), white_cdm2, 1.2, ambient_cdm2) desc += ( " " + lang.getstr("trc." + gamma) + ( " {}-{:0.0f} cd/m² (ambient {} cd/m²)".format( stripzeros(f"{profile_black_cdm2:.4f}"), white_cdm2, stripzeros(f"{ambient_cdm2:.2f}"), ) ) ) profile1.setDescription(desc) if gamma == "smpte2084.rolloffclip" or hlg: rgb_space = profile1.get_rgb_space() if not rgb_space: raise Error( odesc + ": " + lang.getstr( "profile.unsupported", (lang.getstr("unknown"), profile1.colorSpace), ) ) rgb_space[0] = 1.0 # Set gamma to 1.0 (not actually used) rgb_space = colormath.get_rgb_space(rgb_space) self.recent.write(desc + "\n") linebuffered_logfiles = [] if sys.stdout and hasattr(sys.stdout, "isatty") and sys.stdout.isatty(): linebuffered_logfiles.append(print) else: linebuffered_logfiles.append(log) if self.sessionlogfile: linebuffered_logfiles.append(self.sessionlogfile) logfiles = Files( [ LineBufferedStream( FilteredStream( Files(linebuffered_logfiles), enc, discard="", linesep_in="\n", triggers=[], ) ), self.recent, self.lastmsg, ] ) if hdr_chroma_compression: xf = Xicclu( hdr_target_profile, "r", direction="f", pcs="x", worker=self ) xb = MP_Xicclu( hdr_target_profile, "r", direction="if", pcs="x", use_cam_clipping=True, worker=self, logfile=logfiles, ) if content_rgb_space: content_rgb_space = colormath.get_rgb_space(content_rgb_space) for i, color in enumerate(("white", "red", "green", "blue")): if i == 0: xyY = colormath.XYZ2xyY(*content_rgb_space[1]) else: xyY = content_rgb_space[2:][i - 1] for j, coord in enumerate("xy"): v = xyY[j] self.log( "{} {} {} {:6.4f}".format( lang.getstr("3dlut.content.colorspace"), lang.getstr(color), coord, v, ) ) else: xf = None xb = None if smpte2084: hdr_format = "PQ" elif hlg: hdr_format = "HLG" cat = profile1.guess_cat() or "Bradford" self.log("Using chromatic adaptation transform matrix:", cat) profile = create_synthetic_hdr_clut_profile( hdr_format, rgb_space, desc, black_cdm2, white_cdm2, minmll, # Not used for HLG maxmll, # Not used for HLG use_alternate_master_white_clip, # Not used for HLG system_gamma=1.2, # Not used for PQ ambient_cdm2=ambient_cdm2, # Not used for PQ maxsignal=1.0, # Not used for PQ content_rgb_space=content_rgb_space, sat=hdr_sat, hue=hdr_hue, forward_xicclu=xf, backward_xicclu=xb, worker=self, logfile=logfiles, cat=cat, ) profile1.tags.A2B0 = profile.tags.A2B0 profile1.tags.DBG0 = profile.tags.DBG0 profile1.tags.DBG1 = profile.tags.DBG1 profile1.tags.DBG2 = profile.tags.DBG2 profile1.tags.kTRC = profile.tags.kTRC elif apply_trc: # Apply BT.1886-like TRC if gamma_type in ("b", "g"): # Get technical gamma needed to achieve effective gamma self.log(f"Effective gamma = {gamma:.2f}") tgamma = colormath.xicc_tech_gamma(gamma, XYZbp[1], outoffset) else: tgamma = gamma self.log(f"Technical gamma = {tgamma:.2f}") profile1.set_bt1886_trc(XYZbp, outoffset, gamma, gamma_type, size) if not apply_trc or hdr or XYZbp is not oXYZbp: # Apply black offset logfiles = self.get_logfiles() logfiles.write( "Applying black offset (normalized 0..100) " "{:.6f} {:.6f} {:.6f}...\n".format(*[v * 100 for v in oXYZbp]) ) profile1.apply_black_offset( oXYZbp, logfiles=logfiles, thread_abort=self.thread_abort, abortmessage=lang.getstr("aborted"), ) def calibrate_instrument_producer(self): cmd, args = get_argyll_util("spotread"), ["-v", "-e"] if cmd: self.spotread_just_do_instrument_calibration = True result = self.add_measurement_features(args, display=False) if isinstance(result, Exception): self.spotread_just_do_instrument_calibration = False return result result = self.exec_cmd(cmd, args, skip_scripts=True) self.spotread_just_do_instrument_calibration = False return result else: return Error(lang.getstr("argyll.util.not_found", "spotread")) def instrument_can_use_ccxx( self, check_measurement_mode=True, instrument_name=None ): """Return boolean whether the instrument in its current measurement mode can use a CCMX or CCSS colorimeter correction """ # Special cases: # Spectrometer (not needed), # ColorHug (only sensible in factory or raw measurement mode), # ColorMunki Smile (only generic LCD CCFL measurement mode), # Colorimétre HCFR (only raw measurement mode), # DTP94 (only LCD, refresh and generic measurement modes) # Spyder4/5 (only generic LCD and refresh measurement modes) # K-10 (only factory measurement mode) # IMPORTANT: Make changes aswell in the following locations: # - DisplayCAL.MainFrame.create_colorimeter_correction_handler # - DisplayCAL.MainFrame.get_ccxx_measurement_modes # - DisplayCAL.MainFrame.set_ccxx_measurement_mode # - DisplayCAL.MainFrame.update_colorimeter_correction_matrix_ctrl_items # - worker.Worker.check_add_display_type_base_id if not instrument_name: instrument_name = self.get_instrument_name() return ( self.argyll_version >= [1, 3, 0] and bool(instrument_name) and not self.get_instrument_features(instrument_name).get("spectral") and ( not check_measurement_mode or getcfg("measurement_mode") == "auto" or ( ( instrument_name not in ("ColorHug", "ColorHug2") or getcfg("measurement_mode") in ("F", "R") ) and ( instrument_name != "ColorMunki Smile" or getcfg("measurement_mode") == "f" ) and ( instrument_name != "Colorimtre HCFR" or getcfg("measurement_mode") == "R" # Missing é is NOT a typo ) and ( instrument_name != "DTP94" or getcfg("measurement_mode") in ("l", "c", "g") ) and ( instrument_name not in ("Spyder4", "Spyder5") or getcfg("measurement_mode") in ("l", "c") ) and ( instrument_name != "SpyderX" or getcfg("measurement_mode") == "l" ) and (instrument_name != "K-10" or getcfg("measurement_mode") == "F") ) ) ) def instrument_can_use_nondefault_observer(self, instrument_name=None): if not instrument_name: instrument_name = self.get_instrument_name() return bool( self.get_instrument_features(instrument_name).get("spectral") or self.instrument_supports_ccss(instrument_name) ) @property def progress_wnd(self): if not self._progress_wnd: if ( getattr(self, "progress_start_timer", None) and self.progress_start_timer.IsRunning() ): if currentThread().__class__.__name__ != "_MainThread": raise RuntimeError("GUI access in non-main thread!") # Instantiate the progress dialog instantly on access self.progress_start_timer.Notify() self.progress_start_timer.Stop() return self._progress_wnd @progress_wnd.setter def progress_wnd(self, progress_wnd): self._progress_wnd = progress_wnd @property def progress_wnds(self): progress_wnds = list(self._progress_dlgs.values()) if hasattr(self, "terminal"): progress_wnds.append(self.terminal) return progress_wnds @property def pwd(self): return codecs.decode( self._pwdstr[10:] .ljust(int(math.ceil(len(self._pwdstr[10:]) / 4.0) * 4), "=") .encode(), "base64", ).decode("utf-8") @pwd.setter def pwd(self, pwd): encoded_user_name = codecs.encode( md5(getpass.getuser().encode()).hexdigest().encode(), "base64" )[:5].decode("utf-8") encoded_pwd = ( codecs.encode(pwd.encode(), "base64").decode("utf-8").rstrip("=\n") ) self._pwdstr = f"/tmp/{encoded_user_name}{encoded_pwd}" def check_add_display_type_base_id(self, cgats, cfgname="measurement_mode"): """Add DISPLAY_TYPE_BASE_ID to CCMX""" if not cgats.queryv1("DISPLAY_TYPE_BASE_ID"): # c, l (most colorimeters) # R (ColorHug and Colorimétre HCFR) # F (ColorHug) # f (ColorMunki Smile) # g (DTP94) # IMPORTANT: Make changes aswell in the following locations: # - DisplayCAL.MainFrame.create_colorimeter_correction_handler # - DisplayCAL.MainFrame.get_ccxx_measurement_modes # - DisplayCAL.MainFrame.set_ccxx_measurement_modes # - DisplayCAL.MainFrame.update_colorimeter_correction_matrix_ctrl_items # - worker.Worker.instrument_can_use_ccxx cgats[0].add_keyword( "DISPLAY_TYPE_BASE_ID", {"c": 2, "l": 1, "R": 2, "F": 1, "f": 1, "g": 3}.get( getcfg(cfgname), 1 ), ) print( "Added DISPLAY_TYPE_BASE_ID {}".format( repr(cgats[0].DISPLAY_TYPE_BASE_ID) ) ) return True def check_display_conf_oy_compat(self, display_no): """Check the screen configuration for oyranos-monitor compatibility oyranos-monitor works off screen coordinates, so it will not handle overlapping screens (like separate X screens, which will usually have the same x, y coordinates)! So, oyranos-monitor can only be used if: - The wx.Display count is > 1 which means NOT separate X screens OR if we use the 1st screen - The screens don't overlap """ oyranos = False if wx.Display.GetCount() > 1 or display_no == 1: oyranos = True for display_rect_1 in self.display_rects: for display_rect_2 in self.display_rects: if display_rect_1 is not display_rect_2: if display_rect_1.Intersects(display_rect_2): oyranos = False break if not oyranos: break return oyranos def check_is_single_measurement(self, txt): if ( "ambient light measuring" in txt.lower() or "Will use emissive mode instead" in txt ) and not getattr(self, "is_ambient_measurement", False): self.is_ambient_measurement = True self.is_single_measurement = True if ( getattr(self, "is_single_measurement", False) and self.instrument_place_on_spot_msg ): self.is_single_measurement = False self.do_single_measurement() self.is_ambient_measurement = False def do_single_measurement(self): if getattr(self, "subprocess_abort", False) or getattr( self, "thread_abort", False ): # If we are aborting, ignore request return self.progress_wnd.Pulse(" " * 4) if self.is_ambient_measurement: self.is_ambient_measurement = False dlg = ConfirmDialog( self.progress_wnd, msg=lang.getstr("instrument.measure_ambient"), ok=lang.getstr("ok"), cancel=lang.getstr("cancel"), bitmap=geticon(32, "dialog-information"), ) self.progress_wnd.dlg = dlg dlg_result = dlg.ShowModal() dlg.Destroy() if self.finished: return if dlg_result != wx.ID_OK: self.abort_subprocess() return False if self.safe_send(" "): self.progress_wnd.Pulse(lang.getstr("please_wait")) def check_instrument_calibration(self, txt): """Check if current instrument needs sensor calibration by looking at Argyll CMS command output""" if not self.instrument_calibration_complete: if "calibration complete" in txt.lower(): self.log(f"{appname}: Detected instrument calibration complete message") self.instrument_calibration_complete = True else: for calmsg in INST_CAL_MSGS: if calmsg in txt or "calibration failed" in txt.lower(): self.log(f"{appname}: Detected instrument calibration message") self.do_instrument_calibration( "calibration failed" in txt.lower() ) break def check_instrument_calibration_file(self): # XXX: Check instrument calibration for SpyderX. For some reason, # users tend to leave the instrument on screen despite being told # otherwise... if self._detected_instrument and "SpyderX" in self._detected_instrument: if sys.platform == "win32": cachepath = os.path.join(appdata, "Cache") else: cachepath = cache spydx_cal_fn = os.path.join( cachepath, "ArgyllCMS", f".spydX_{self._detected_instrument_serial}.cal", ) if os.path.isfile(spydx_cal_fn): # Argyll sensor cal file format offsets and lengths depend on # the size of various C data types as seen by Argyll. # We can determine the needed offset and length of the cal info # (C 'int') by subtracting the length of the NULL-terminated # serial string and size of time_t from the file size, then # dividing by the number of C 'int's in the file. # File structure for SpyderX cal: # Argyll version (C 'int') # Size of spydX (2x C 'int') # NULL-terminated serial string (variable length) # Black cal done (C 'int') # Date & time (time_t) # Calibration info (3x C 'int') # Checksum (C 'int') serial0 = self._detected_instrument_serial + "\0" numints = 8 spydx_cal_size = os.stat(spydx_cal_fn).st_size spydx_cal_int_bytes = 4 # C 'int' # time_t might be 8 or 4 bytes, 0 is sentinel for time_t_size in (8, 4, 0): if ( spydx_cal_size - len(serial0) - time_t_size ) == spydx_cal_int_bytes * numints: break if not time_t_size: self.log( f"{appname}: Warning - could not determine SpyderX " "sensor cal file format" ) self.exec_cmd_returnvalue = Error( "Could not determine SpyderX sensor cal file format" ) self.abort_subprocess() return False self.log(f"{appname}: SpyderX cal time_t size =", time_t_size) try: with open(spydx_cal_fn, "rb") as spydx_cal: # Seek to cal entries offset spydx_cal.seek( spydx_cal_int_bytes * 4 + len(serial0) + time_t_size ) # Read three entries black cal spydx_bcal = spydx_cal.read(spydx_cal_int_bytes * 3) except EnvironmentError as exception: self.log( f"{appname}: Warning - could not read SpyderX sensor cal:", exception, ) self.exec_cmd_returnvalue = Error( "Could not read SpyderX sensor cal: {}".format( safe_str(exception) ) ) self.abort_subprocess() return False else: if len(spydx_bcal) < spydx_cal_int_bytes * 3: self.log( f"{appname}: Warning - SpyderX " "sensor cal has unexpected length: " f"{len(spydx_bcal)} != {spydx_cal_int_bytes * 3:d}" ) self.exec_cmd_returnvalue = Error( "SpyderX sensor cal " "has unexpected " f"length: {len(spydx_bcal)} != {spydx_cal_int_bytes * 3:d}" ) self.abort_subprocess() return False else: fmt = {2: " 15: # Black cal offsets too high - user error? self.exec_cmd_returnvalue = Error( lang.getstr("error.spyderx.black_cal_offsets_too_high") ) self.abort_subprocess() # Nuke the cal file try: os.remove(spydx_cal_fn) except OSError: self.log( f"{appname}: Warning - Could not remove " "SpyderX sensor cal file", spydx_cal_fn, ) return False return True def check_instrument_place_on_screen(self, txt): """Check if instrument should be placed on screen by looking at Argyll CMS command output""" self.instrument_place_on_spot_msg = False if "place instrument on test window" in txt.lower(): self.instrument_place_on_screen_msg = True elif "place instrument on spot" in txt.lower(): self.instrument_place_on_spot_msg = True if self.instrument_place_on_screen_msg or self.instrument_place_on_spot_msg: if not self.check_instrument_calibration_file(): return if ( self.instrument_place_on_screen_msg and "key to continue" in txt.lower() ) or ( self.instrument_calibration_complete and self.instrument_place_on_spot_msg and self.progress_wnd is getattr(self, "terminal", None) ): self.log(f"{appname}: Detected instrument placement (screen/spot) message") self.instrument_place_on_screen_msg = False if ( self.cmdname == get_argyll_utilname("dispcal") and sys.platform == "darwin" ): # On the Mac dispcal's test window # hides the cursor and steals focus start_new_thread(mac_app_activate, (1, wx.GetApp().AppName)) # IMPORTANT: When making changes to the instrument on screen # detection, also apply them to appropriate part in Worker.exec_cmd if self.instrument_calibration_complete or ( ( config.is_untethered_display() or getcfg("measure.darken_background") or self.madtpg_fullscreen is False ) and ( not self.dispread_after_dispcal or self.cmdname == get_argyll_utilname("dispcal") or self._detecting_video_levels ) and not self.instrument_on_screen ): # Show a dialog asking user to place the instrument on the # screen if the instrument calibration was completed, # or if we measure a remote ("Web") display, # or if we use a black background during measurements, # but in case of the latter two only if dispread is not # run directly after dispcal self.instrument_calibration_complete = False self.instrument_place_on_screen() else: if self.isalive(): # Delay to work-around a problem with i1D2 and Argyll 1.7 # to 1.8.3 under Mac OS X 10.11 El Capitan where skipping # interactive display adjustment would botch the first # reading (black) wx.CallLater(1500, self.instrument_on_screen_continue) elif self.instrument_place_on_spot_msg: self.log(f"{appname}: Assuming instrument on screen") self.instrument_on_screen = True def instrument_on_screen_continue(self): self.log(f"{appname}: Skipping place instrument on screen message...") self.safe_send(" ") self.pauseable_now = True self.instrument_on_screen = True def check_instrument_sensor_position(self, txt): """Check instrument sensor position by looking at Argyll CMS command output""" if "read failed due to the sensor being in the wrong position" in txt.lower(): self.instrument_sensor_position_msg = True if self.instrument_sensor_position_msg and " or q to " in txt.lower(): self.log(f"{appname}: Detected read failed due to wrong sensor position") self.instrument_sensor_position_msg = False self.instrument_reposition_sensor() def check_retry_measurement(self, txt): if ( "key to retry:" in txt and "read stopped at user request!" not in self.recent.read() and ( "Sample read failed due to misread" in self.recent.read() or "Sample read failed due to communication problem" in self.recent.read() ) and not self.subprocess_abort ): self.retrycount += 1 self.log(f"{appname}: Retrying ({self.retrycount})...") self.recent.write(f"\r\n{appname}: Retrying ({self.retrycount})...") self.safe_send(" ") def check_spotread_result(self, txt): """Check if spotread returned a result""" if ( self.cmdname == get_argyll_utilname("spotread") and ( self.progress_wnd is not getattr(self, "terminal", None) or getattr(self.terminal, "Name", None) == "VisualWhitepointEditor" ) and ( "Result is XYZ:" in txt or "Result is Y:" in txt or ( self.instrument_calibration_complete and self.spotread_just_do_instrument_calibration ) ) ): # Single spotread reading, we are done wx.CallLater(1000, self.quit_terminate_cmd) def get_skip_video_levels_detection(self): """Should we skip video levels detection?""" return ( self._detected_output_levels or not getcfg("patterngenerator.detect_video_levels") or config.get_display_name() == "Untethered" or is_ccxx_testchart() ) def detect_video_levels(self): """Detect wether we need video (16..235) or data (0..255) levels""" if self.get_skip_video_levels_detection(): return True self._detecting_video_levels = True try: while True: result = self._detect_video_levels() if result is not None: return result finally: self._detecting_video_levels = False def _detect_video_levels(self): """Detect black clipping due to incorrect levels""" self.log("Detecting output levels range...") tempdir = self.create_tempdir() if isinstance(tempdir, Exception): return tempdir ti1_path = os.path.join(tempdir, "0_16.ti1") try: with open(ti1_path, "wb") as ti1: ti1.write( """CTI1 DESCRIPTOR "Argyll Calibration Target chart information 1" ORIGINATOR "Argyll targen" CREATED "Thu Apr 20 12:22:05 2017" APPROX_WHITE_POINT "95.045781 100.000003 108.905751" COLOR_REP "RGB" NUMBER_OF_FIELDS 7 BEGIN_DATA_FORMAT SAMPLE_ID RGB_R RGB_G RGB_B XYZ_X XYZ_Y XYZ_Z END_DATA_FORMAT NUMBER_OF_SETS 3 BEGIN_DATA 1 100.00 100.00 100.00 95.046 100.00 108.91 2 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 3 6.2500 6.2500 6.2500 0.2132 0.2241 0.2443 END_DATA """.encode() ) except Exception as exception: return exception setcfg("patterngenerator.use_video_levels", 0) result = self.measure_ti1( ti1_path, get_data_path("linear.cal"), allow_video_levels=False ) if result is None: return False if isinstance(result, Exception) or not result: return result ti3_path = os.path.join(tempdir, "0_16.ti3") try: ti3 = CGATS(ti3_path) except (IOError, CGATSError) as exception: return exception try: verify_ti1_rgb_xyz(ti3) except CGATSError as exception: return exception luminance_XYZ_cdm2 = ti3.queryv1("LUMINANCE_XYZ_CDM2") if not luminance_XYZ_cdm2: return Error( lang.getstr( "error.testchart.missing_fields", (ti3_path, "LUMINANCE_XYZ_CDM2") ) ) try: Y_cdm2 = float(luminance_XYZ_cdm2.split()[1]) except (IndexError, ValueError): return Error(lang.getstr("error.testchart.invalid", ti3_path)) if Y_cdm2 <= 0 or math.isnan(Y_cdm2): return Error(lang.getstr("error.luminance.invalid")) black_0 = ti3[0].DATA[1] black_16 = ti3[0].DATA[2] if black_0 and black_16: self.log( "RGB level 0 is {:.6f} cd/m2".format(black_0["XYZ_Y"] / 100.0 * Y_cdm2) ) self.log( "RGB level 16 is {:.6f} cd/m2".format( black_16["XYZ_Y"] / 100.0 * Y_cdm2 ) ) # Check delta cd/m2 to determine if data or video levels # We need to take the display white luminance into account threshold = 0.02 / Y_cdm2 * 100 # Threshold 0.02 cd/m2 assume_video_levels = black_16["XYZ_Y"] - black_0["XYZ_Y"] < threshold if assume_video_levels: if config.get_display_name() == "madVR": # This is an error return Error(lang.getstr("madvr.wrong_levels_detected")) if not config.is_virtual_display(): # Could be a misconfiguration of display or graphics driver. # Make the user aware. self._detected_levels_issue_confirm_wait = True wx.CallAfter(self.detected_levels_issue_confirm) # Wait for call to return while ( self._detected_levels_issue_confirm_wait and not self.subprocess_abort ): sleep(0.05) if self._use_detected_video_levels is False: return False elif self._use_detected_video_levels is None: # Retry return self.log("Using limited range output levels") else: self.log("Assuming full range output levels") setcfg("patterngenerator.use_video_levels", int(assume_video_levels)) if not config.is_patterngenerator() and sys.platform == "darwin": # macOS video levels encoding seems to only work right on # some machines if not using videoLUT to do the scaling setcfg_cond(assume_video_levels, "calibration.use_video_lut", 0) self._detected_output_levels = True else: return Error( lang.getstr( "error.testchart.missing_fields", (ti3_path, ", ".join(list(black_0.keys()))), ) ) return True def detected_levels_issue_confirm(self): dlg = ConfirmDialog( None, msg=lang.getstr("display.levels_issue_detected"), ok=lang.getstr("retry"), alt=lang.getstr("fix_output_levels_using_vcgt"), wrap=100, ) result = dlg.ShowModal() dlg.Destroy() if result == wx.ID_OK: # Retry self._use_detected_video_levels = None elif result == wx.ID_CANCEL: self._use_detected_video_levels = False else: # Fix output levels using calibration self._use_detected_video_levels = True self._detected_levels_issue_confirm_wait = False def do_instrument_calibration(self, failed=False): """Ask user to initiate sensor calibration and execute. Give an option to cancel.""" if getattr(self, "subprocess_abort", False) or getattr( self, "thread_abort", False ): # If we are aborting, ignore request return self.instrument_on_screen = False self.log(f"{appname}: Prompting to calibrate instrument") self.progress_wnd.Pulse(" " * 4) if failed: msg = lang.getstr("failure") elif self.get_instrument_name() == "ColorMunki": msg = lang.getstr("instrument.calibrate.colormunki") else: # Detect type of calibration (emissive dark or reflective) # by looking for serial number of calibration tile # Argyll up to 1.8.3: 'Serial no.' # Argyll 1.9.x: 'S/N' serial = re.search(r"(?:Serial no.|S/N) (\S+)", self.recent.read(), re.I) if serial: # Reflective calibration, white reference tile required # (e.g. i1 Pro hires mode) msg = lang.getstr("instrument.calibrate.reflective", serial.group(1)) elif self._detected_instrument and "SpyderX" in self._detected_instrument: msg = lang.getstr("instrument.calibrate.spyderx") else: # Emissive dark calibration msg = lang.getstr("instrument.calibrate") if self.use_madvr: fullscreen = self.madtpg.is_fullscreen() self.madtpg_show_osd( msg, sys.platform == "win32" and self.single_real_display() ) dlg = ConfirmDialog( self.progress_wnd, msg="{}\n\n{}".format( msg, ( self._detected_instrument and "{}{}".format( self._detected_instrument, self._detected_instrument_serial and " ({} {})".format( lang.getstr("serial_number"), self._detected_instrument_serial, ) or "", ) or self.get_instrument_name() ), ), ok=lang.getstr("ok"), cancel=lang.getstr("cancel"), bitmap=geticon(32, "dialog-information"), ) self.progress_wnd.dlg = dlg dlg_result = dlg.ShowModal() dlg.Destroy() if self.finished: self.log( f"{appname}: Ignoring instrument calibration prompt (worker " "thread finished)" ) return if dlg_result != wx.ID_OK: self.log(f"{appname}: Canceled instrument calibration prompt") self.abort_subprocess() return False self.log(f"{appname}: About to calibrate instrument") self.progress_wnd.Pulse(lang.getstr("please_wait")) if self.safe_send(" "): self.progress_wnd.Pulse(lang.getstr("instrument.calibrating")) if self.use_madvr: if sys.platform == "win32": self.madtpg.set_osd_text("\u25b6") # "Play" symbol self.madtpg_restore_settings(False, fullscreen) def abort_all(self, confirm=False): aborted = False for worker in workers: if not getattr(worker, "finished", True): worker.abort_subprocess(confirm) aborted = True return aborted def abort_subprocess(self, confirm=False): """Abort the current subprocess or thread""" if getattr(self, "abort_requested", False): return self.abort_requested = True if confirm and getattr(self, "progress_wnd", None): prev_dlg = getattr(self.progress_wnd, "dlg", None) if ( prev_dlg and prev_dlg.IsShownOnScreen() and not isinstance(prev_dlg, DummyDialog) ): self.abort_requested = False return pause = not getattr(self.progress_wnd, "paused", False) and hasattr( self.progress_wnd, "pause_continue_handler" ) if pause: self.progress_wnd.pause_continue_handler(True) self.pause_continue() dlg = ConfirmDialog( self.progress_wnd, msg=lang.getstr("dialog.confirm_cancel"), ok=lang.getstr("yes"), cancel=lang.getstr("no"), bitmap=geticon(32, "dialog-warning"), ) self.progress_wnd.dlg = dlg dlg_result = dlg.ShowModal() if isinstance(prev_dlg, DummyDialog): self.progress_wnd.dlg = prev_dlg dlg.Destroy() if dlg_result != wx.ID_OK: if pause: self.progress_wnd.Resume() else: self.progress_wnd.keepGoing = True if hasattr(self.progress_wnd, "cancel"): self.progress_wnd.cancel.Enable() self.abort_requested = False return self.patch_count = 0 self.subprocess_abort = True self.thread_abort = True if self.use_patterngenerator or self.use_madnet_tpg: abortfilename = os.path.join(self.tempdir, ".abort") open(abortfilename, "w").close() delayedresult.startWorker(self.quit_terminate_consumer, self.quit_terminate_cmd) def quit_terminate_consumer(self, delayedResult): try: result = delayedResult.get() except Exception as exception: if hasattr(exception, "originalTraceback"): self.log(exception.originalTraceback, fn=log) else: self.log(traceback.format_exc(), fn=log) result = UnloggedError(safe_str(exception)) if isinstance(result, Exception): show_result_dialog(result, getattr(self, "progress_wnd", None)) result = False self.subprocess_abort = False if not result: self.thread_abort = False self.abort_requested = False if getattr(self, "progress_wnd", None): self.progress_wnd.Resume() def instrument_place_on_screen(self): """Show a dialog asking user to place the instrument on the screen and give an option to cancel""" if getattr(self, "subprocess_abort", False) or getattr( self, "thread_abort", False ): # If we are aborting, ignore request return self.log(f"{appname}: Prompting to place instrument on screen") self.progress_wnd.Pulse(" " * 4) if self.use_madvr: fullscreen = self.madtpg.is_fullscreen() self.madtpg_show_osd( lang.getstr("instrument.place_on_screen"), sys.platform == "win32" and self.single_real_display(), ) dlg = ConfirmDialog( self.progress_wnd, msg="{}\n\n{}".format( lang.getstr("instrument.place_on_screen"), ( self._detected_instrument and "{}{}".format( self._detected_instrument, self._detected_instrument_serial and " ({} {})".format( lang.getstr("serial_number"), self._detected_instrument_serial, ) or "", ) or self.get_instrument_name() ), ), ok=lang.getstr("ok"), cancel=lang.getstr("cancel"), bitmap=geticon(32, "dialog-information"), ) self.progress_wnd.dlg = dlg dlg_result = dlg.ShowModal() dlg.Destroy() if self.finished: self.log( f"{appname}: Ignoring instrument placement prompt (worker thread " "finished)" ) return if dlg_result != wx.ID_OK: self.log(f"{appname}: Canceled instrument placement prompt") self.abort_subprocess() return False self.instrument_on_screen = True self.log(f"{appname}: Instrument on screen") if not isinstance(self.progress_wnd, (UntetheredFrame, DisplayUniformityFrame)): self.safe_send(" ") self.pauseable_now = True if self.use_madvr: if sys.platform == "win32": self.madtpg.set_osd_text("\u25b6") # "Play" symbol self.madtpg_restore_settings(False, fullscreen) def instrument_reposition_sensor(self): if getattr(self, "subprocess_abort", False) or getattr( self, "thread_abort", False ): # If we are aborting, ignore request return self.log(f"{appname}: Prompting to reposition instrument sensor") self.progress_wnd.Pulse(" " * 4) fullscreen = False if self.use_madvr: fullscreen = self.madtpg.is_fullscreen() self.madtpg_show_osd( lang.getstr("instrument.reposition_sensor"), sys.platform == "win32" and self.single_real_display(), ) dlg = ConfirmDialog( self.progress_wnd, msg=lang.getstr("instrument.reposition_sensor"), ok=lang.getstr("ok"), cancel=lang.getstr("cancel"), bitmap=geticon(32, "dialog-warning"), ) self.progress_wnd.dlg = dlg dlg_result = dlg.ShowModal() dlg.Destroy() if self.finished: self.log( f"{appname}: Ignoring instrument sensor repositioning prompt (worker " "thread finished)" ) return if dlg_result != wx.ID_OK: self.log(f"{appname}: Canceled instrument sensor repositioning prompt") self.abort_subprocess() return False self.safe_send(" ") if self.use_madvr: if sys.platform == "win32": self.madtpg.set_osd_text("\u25b6") # "Play" symbol self.madtpg_restore_settings(False, fullscreen) def clear_argyll_info(self): """Clear Argyll CMS version, detected displays and instruments.""" self.argyll_bin_dir = None self.argyll_version = [0, 0, 0] self.argyll_version_string = "0.0.0" self._displays = [] self.display_edid = [] self.display_manufacturers = [] self.display_names = [] self.display_rects = [] self.displays = [] self.instruments = [] self.lut_access = [] self.reset_argyll_enum() def reset_argyll_enum(self): """Reset auto-detected (during display/instrument enumeration) properties""" self.measurement_modes = {} self.argyll_virtual_display = None def clear_cmd_output(self): """Clear any output from the last run command.""" self.cmd = None self.cmdname = None self.retcode = -1 self.output = [] self.errors = [] self.recent.clear() self.retrycount = 0 self.lastmsg.clear() self.repeat = False self.send_buffer = None # Log interaction with Argyll tools if not hasattr(self, "logger") or ( isinstance(self.logger, DummyLogger) and self.owner and self.owner.Name == "mainframe" ): if not self.owner or self.owner.Name != "mainframe": self.logger = DummyLogger() else: self.logger = get_file_logger("interact") if hasattr(self, "thread") and self.thread.is_alive() and self.interactive: self.logger.info("-" * 80) self.sessionlogfile = None self.madtpg_bw_lvl = None self.madtpg_fullscreen = None self.use_madvr = False self.use_madnet_tpg = False self.use_patterngenerator = False self.patch_sequence = False self.patch_count = 0 self.patterngenerator_sent_count = 0 self.exec_cmd_returnvalue = None self.tmpfiles = {} self.buffer = [] self._detected_instrument = None self._detected_instrument_serial = None def lut3d_get_filename( self, path=None, include_input_profile=True, include_ext=True ): # 3D LUT filename with crcr32 hash before extension - up to DCG 2.9.0.7 profile_save_path = os.path.splitext( path or getcfg("calibration.file") or defaults["calibration.file"] )[0] lut3d = [ getcfg("3dlut.gamap.use_b2a") and "gg" or "G", "i{}".format(getcfg("3dlut.rendering_intent")), "r{:d}".format(getcfg("3dlut.size")), "e{}".format(getcfg("3dlut.encoding.input")), "E{}".format(getcfg("3dlut.encoding.output")), "I{}:{}:{}".format( getcfg("3dlut.trc_gamma_type"), getcfg("3dlut.trc_output_offset"), getcfg("3dlut.trc_gamma"), ), ] if getcfg("3dlut.format") == "3dl": lut3d.append(str(getcfg("3dlut.bitdepth.input"))) if getcfg("3dlut.format") in ("3dl", "png", "ReShade"): lut3d.append(str(getcfg("3dlut.bitdepth.output"))) if include_ext: lut3d_ext = getcfg("3dlut.format") if lut3d_ext == "eeColor": lut3d_ext = "txt" elif lut3d_ext == "madVR": lut3d_ext = "3dlut" elif lut3d_ext == "ReShade": lut3d_ext = "png" elif lut3d_ext == "icc": lut3d_ext = profile_ext[1:] else: lut3d_ext = "" if include_input_profile: input_profname = os.path.splitext( os.path.basename(getcfg("3dlut.input.profile")) )[0] else: input_profname = "" lut3d_path = ".".join( [ _f for _f in [ profile_save_path, input_profname, "{:X}".format(zlib.crc32("-".join(lut3d).encode()) & 0xFFFFFFFF), lut3d_ext, ] if _f ] ) if not include_input_profile or not os.path.isfile(lut3d_path): # 3D LUT filename with plain options before extension - DCG 2.9.0.8+ enc_in = lut3d[3][1:] enc_out = lut3d[4][1:] encoding = enc_in if enc_in != enc_out: encoding += enc_out if getcfg("3dlut.output.profile.apply_cal"): cal_exclude = "" else: cal_exclude = "e" if getcfg("3dlut.trc").startswith("smpte2084"): lut3dp = [str(getcfg("3dlut.trc_output_offset")) + ",2084"] if ( getcfg("3dlut.hdr_peak_luminance") < 10000 or getcfg("3dlut.trc") == "smpte2084.rolloffclip" or getcfg("3dlut.hdr_minmll") or getcfg("3dlut.hdr_maxmll") < 10000 ): lut3dp.append("@{:0.0f}".format(getcfg("3dlut.hdr_peak_luminance"))) if getcfg("3dlut.trc") == "smpte2084.hardclip": lut3dp.append("h") else: lut3dp.append("s") # Alternate clip - softer if getcfg("3dlut.hdr_maxmll_alt_clip"): lut3dp.append("s") if getcfg("3dlut.hdr_minmll"): lut3dp.append("{:.4f}".format(getcfg("3dlut.hdr_minmll"))) if ( getcfg("3dlut.hdr_minmll") and getcfg("3dlut.hdr_maxmll") < 10000 ): lut3dp.append("-") if getcfg("3dlut.hdr_maxmll") < 10000: lut3dp.append("{:0.0f}".format(getcfg("3dlut.hdr_maxmll"))) if getcfg("3dlut.trc") == "smpte2084.rolloffclip": # Hue and chroma preservation if getcfg("3dlut.hdr_sat") != 0.5: lut3dp.append("s{:.1f}".format(getcfg("3dlut.hdr_sat"))) if getcfg("3dlut.hdr_hue") != 1.0: lut3dp.append("h{:.1f}".format(getcfg("3dlut.hdr_hue"))) elif getcfg("3dlut.trc") == "hlg": lut3dp = ["HLG"] if getcfg("3dlut.hdr_ambient_luminance") != 5: ambient = stripzeros(getcfg("3dlut.hdr_ambient_luminance")) lut3dp.append(f"@{ambient}") elif getcfg("3dlut.apply_trc"): lut3dp = [ lut3d[5][1].replace("b", "bb") + lut3d[5][3:].replace(":", ",") ] # TRC else: # Use src profile TRC unmodified lut3dp = [] lut3dp.extend( [ cal_exclude, lut3d[0], # Gamut mapping mode lut3d[1][1:], # Rendering intent encoding, lut3d[2][1:], ] ) # Resolution bitdepth_in = None bitdepth_out = None if len(lut3d) > 6: bitdepth_in = lut3d[6] # Input bitdepth if len(lut3d) > 7: bitdepth_out = lut3d[7] # Output bitdepth if bitdepth_in or bitdepth_out: bitdepth = bitdepth_in if bitdepth_out and bitdepth_in != bitdepth_out: bitdepth += bitdepth_out lut3dp.append(bitdepth) lut3d_path = ".".join( [ _f for _f in [ profile_save_path, input_profname, "".join(lut3dp), lut3d_ext, ] if _f ] ) return lut3d_path def create_3dlut( self, profile_in, path, profile_abst=None, profile_out=None, apply_cal=True, intent="r", format="cube", size=17, input_bits=10, output_bits=12, maxval=None, input_encoding="n", output_encoding="n", trc_gamma=None, trc_gamma_type="B", trc_output_offset=0.0, save_link_icc=True, apply_black_offset=True, use_b2a=False, white_cdm2=100, minmll=0, maxmll=10000, use_alternate_master_white_clip=True, hdr_sat=0.5, hdr_hue=0.5, ambient_cdm2=5, content_rgb_space="DCI P3", hdr_display=False, XYZwp=None, ): """Create a 3D LUT from one (device link) or two (device) profiles, optionally incorporating an abstract profile.""" # .cube: http://doc.iridas.com/index.php?title=LUT_Formats # .3dl: http://www.kodak.com/US/plugins/acrobat/en/motion/products/look/UserGuide.pdf # http://download.autodesk.com/us/systemdocs/pdf/lustre_color_management_user_guide.pdf # .spi3d: https://github.com/imageworks/OpenColorIO/blob/master/src/core/FileFormatSpi3D.cpp # .mga: http://pogle.pandora-int.com/download/manual/lut3d_format.html print("-" * 80) print(lang.getstr("3dlut.create")) for profile in (profile_in, profile_out): if ( profile.profileClass not in (b"mntr", b"link", b"scnr", b"spac") or profile.colorSpace != b"RGB" ): raise NotImplementedError( lang.getstr( "profile.unsupported", (profile.profileClass, profile.colorSpace), ) ) if profile_in.profileClass == b"link": break # Setup temp dir cwd = self.create_tempdir() if isinstance(cwd, Exception): raise cwd result = None path = os.path.split(path) path = os.path.join(path[0], make_argyll_compatible_path(path[1])) filename, ext = os.path.splitext(path) name = os.path.basename(filename) if profile_in.profileClass == b"link": link_basename = os.path.basename(profile_in.fileName) link_filename = os.path.join(cwd, link_basename) profile_in.write(link_filename) else: collink = get_argyll_util("collink") if not collink: raise Error(lang.getstr("argyll.util.not_found", "collink")) extra_args = parse_argument_string(getcfg("extra_args.collink")) smpte2084 = trc_gamma in ("smpte2084.hardclip", "smpte2084.rolloffclip") hlg = trc_gamma == "hlg" hdr = smpte2084 or hlg profile_in_basename = make_argyll_compatible_path( os.path.basename(profile_in.fileName) ) # XXX: collink creates dark blotch in yellow with perceptual intent # when using HDR PQ tonemapping - force to colorimetric and rely on # our own perceptual mapping if hdr and not hlg: if intent == "p": intent = "r" elif intent == "pa": intent = "aw" hdr_use_src_gamut = ( hdr and profile_in_basename == "Rec2020.icm" and intent in ("la", "lp", "p", "pa", "ms", "s", "aa") and not get_arg("-G", extra_args) and not get_arg("-g", extra_args) ) if hdr and not hdr_use_src_gamut and not use_b2a: # Always use B2A instead of inverse forward table (faster and # better result if B2A table has enough effective resolution) # for HDR with colorimetric intents # Check B2A resolution and regenerate on-the-fly if too low # and created by ArgyllCMS b2a = profile_out.tags.get("B2A1", profile_out.tags.get("B2A0")) a2b = profile_out.tags.get("A2B1", profile_out.tags.get("A2B0")) if ( not b2a or ( isinstance(b2a, LUT16Type) and b2a.clut_grid_steps < 17 and profile_out.creator == "argl" ) ) and a2b: clutres = getcfg("profile.b2a.hires.size") b2aresult = self.update_profile_B2A(profile_out, clutres=clutres) if isinstance(b2aresult, Exception): raise b2aresult profile_out.write() if "B2A1" in profile_out.tags or "B2A0" in profile_out.tags: use_b2a = True # Argyll applycal can't deal with single gamma TRC tags # or TRC tags with less than 256 entries _applycal_bug_workaround(profile_out) # Prepare building a device link link_basename = name + profile_ext link_filename = os.path.join(cwd, link_basename) profile_out_basename = make_argyll_compatible_path( os.path.basename(profile_out.fileName) ) if profile_in_basename == profile_out_basename: (profile_out_filename, profile_out_ext) = os.path.splitext( profile_out_basename ) profile_out_basename = "{} (2){}".format( profile_out_filename, profile_out_ext, ) profile_out.fileName = os.path.join(cwd, profile_out_basename) profile_out.write() profile_out_cal_path = os.path.splitext(profile_out.fileName)[0] + ".cal" manufacturer = profile_out.getDeviceManufacturerDescription() model = profile_out.getDeviceModelDescription() device_manufacturer = profile_out.device["manufacturer"] device_model = profile_out.device["model"] mmod = profile_out.tags.get("mmod") self.set_sessionlogfile(None, name, cwd) collink_version_string = get_argyll_version_string("collink") collink_version = parse_argyll_version_string(collink_version_string) use_collink_bt1886 = trc_gamma and not hdr # The display profile may not reflect the measured black point. # Get it from the embedded TI3 instead if zero from lookup. odata = self.xicclu(profile_out, (0, 0, 0), pcs="x") if len(odata) != 1 or len(odata[0]) != 3: raise ValueError(f"Blackpoint is invalid: {odata}") XYZbp = odata[0] if not XYZbp[1] and isinstance(profile_out.tags.get("targ"), Text): XYZbp = profile_out.get_chardata_bkpt() if XYZbp: XYZbp = [ v * XYZbp[1] for v in list(profile_out.tags.wtpt.pcs.values()) ] self.log( "Using black Y from destination profile " "characterization data (normalized 0..100): " "{:.6f}".format(XYZbp[1] * 100) ) use_collink_bt1886 = False elif XYZbp[1]: # Use display profile blackpoint XYZbp = None # Using xicclu instead of collink is more accurate on and near # the gray axis (in some cases, i.e. HDR and cLUT res < 65, # significantly so) use_xicclu = ( (experimental or hdr) and not profile_abst and intent in ("a", "aw", "r") and input_encoding in ("n", "t", "T") and output_encoding in ("n", "t") ) # Apply calibration? if apply_cal: extract_cal_from_profile(profile_out, profile_out_cal_path) if self.argyll_version < [1, 6] or use_xicclu: # Can't apply the calibration with old collink versions - # apply the calibration to the 'out' profile prior to # device linking instead applycal = get_argyll_util("applycal") if not applycal: raise Error(lang.getstr("argyll.util.not_found", "applycal")) self.log(lang.getstr("apply_cal")) result = self.exec_cmd( applycal, [ "-v", profile_out_cal_path, profile_out_basename, profile_out.fileName, ], capture_output=True, skip_scripts=True, sessionlogfile=self.sessionlogfile, ) if isinstance(result, Exception) and not getcfg("dry_run"): raise result elif not result: raise Error( "\n\n".join( [lang.getstr("apply_cal.error"), "\n".join(self.errors)] ) ) profile_out = ICCProfile(profile_out.fileName) in_rgb_space = profile_in.get_rgb_space() if in_rgb_space: in_colors = colormath.get_rgb_space_primaries_wp_xy(in_rgb_space) if format == "madVR": # Use a D65 white for the 3D LUT Input_Primaries as # madVR can only deal correctly with D65 # Use the same D65 xy values as written by madVR # 3D LUT install API (ASTM E308-01) in_colors[6:] = [0.31273, 0.32902] else: in_colors = [] if hdr_use_src_gamut: content_rgb_space = colormath.get_rgb_space(content_rgb_space) # Always force content RGB space whitepoint to D65 so # default RGB to ICtCp matrix gives Ct=Cp=0 for R=G=B # when tone mapping content_rgb_space = list(content_rgb_space) content_rgb_space[1] = colormath.get_whitepoint("D65") content_colors = colormath.get_rgb_space_primaries_wp_xy( content_rgb_space ) if hdr_use_src_gamut and content_colors[:6] != in_colors[:6]: # Use source gamut to preserve more saturation. # Assume content colorspace (i.e. DCI P3) encoded within # container colorspace (i.e. Rec. 2020) # Get source profile crx, cry = content_rgb_space[2:][0][:2] cgx, cgy = content_rgb_space[2:][1][:2] cbx, cby = content_rgb_space[2:][2][:2] cwx, cwy = colormath.XYZ2xyY(*content_rgb_space[1])[:2] rgb_space_name = ( colormath.find_primaries_wp_xy_rgb_space_name(content_colors) or "Custom" ) cat = profile_in.guess_cat() or "Bradford" self.log( "Using chromatic adaptation transform matrix from " "input profile for content colorspace:", cat, ) profile_src = ICCProfile.from_chromaticities( crx, cry, cgx, cgy, cbx, cby, cwx, cwy, 2.2, rgb_space_name, "", cat=cat, ) fd, profile_src.fileName = tempfile.mkstemp( profile_ext, f"{rgb_space_name}-", dir=cwd ) stream = os.fdopen(fd, "wb") profile_src.write(stream) stream.close() else: profile_src = profile_out # Deal with applying TRC if trc_gamma: if ( use_collink_bt1886 and not use_xicclu and (collink_version >= [1, 7] or not trc_output_offset) ): # Make sure the profile has the expected Rec. 709 TRC # for BT.1886 self.log( f"{appname}: Applying Rec. 709 TRC to " f"{os.path.basename(profile_in.fileName)}" ) for i, channel in enumerate(("r", "g", "b")): if channel + "TRC" in profile_in.tags: profile_in.tags[channel + "TRC"].set_trc(-709) else: # For HDR or Argyll < 1.7 beta, alter profile TRC # Argyll CMS prior to 1.7 beta development code 2014-07-10 # does not support output offset, alter the source profile # instead (note that accuracy is limited due to 16-bit # encoding used in ICC profile, collink 1.7 can use full # floating point processing and will be more precise) self.blend_profile_blackpoint( profile_in, profile_out, XYZbp, trc_output_offset, trc_gamma, trc_gamma_type, white_cdm2=white_cdm2, minmll=minmll, maxmll=maxmll, use_alternate_master_white_clip=use_alternate_master_white_clip, ambient_cdm2=ambient_cdm2, content_rgb_space=content_rgb_space, hdr_chroma_compression=not hdr_use_src_gamut or content_colors[:6] != in_colors[:6], hdr_sat=hdr_sat, hdr_hue=hdr_hue, hdr_target_profile=profile_src, ) elif apply_black_offset: # Apply only the black point blending portion of BT.1886 mapping self.blend_profile_blackpoint( profile_in, profile_out, XYZbp, 1.0, apply_trc=False ) # Deal with whitepoint profile_in_wtpt_XYZ = list(profile_in.tags.wtpt.ir.values()) if XYZwp: # Quantize to ICC s15Fixed16Number encoding XYZwp = [ s15Fixed16Number(s15Fixed16Number_tohex(v)) for v in XYZwp ] else: XYZwp = profile_in_wtpt_XYZ if XYZwp != profile_in_wtpt_XYZ: self.log( "Using whitepoint chromaticity {:.4f} {:.4f} for input".format( *colormath.XYZ2xyY(*XYZwp)[:2] ) ) ( profile_in.tags.wtpt.X, profile_in.tags.wtpt.Y, profile_in.tags.wtpt.Z, ) = XYZwp profile_in.fileName = os.path.join(cwd, profile_in_basename) profile_in.write() if hdr_use_src_gamut and content_colors[:6] != in_colors[:6] and False: # XXX: Old code - could be removed? # Use source gamut to preserve more saturation. # Assume content colorspace (i.e. DCI P3) encoded within # container colorspace (i.e. Rec. 2020) tools = {} for toolname in ( # "iccgamut", # "timage", "cctiff", "tiffgamut", ): tools[toolname] = get_argyll_util(toolname) if not tools[toolname]: raise Error(lang.getstr("argyll.util.not_found", toolname)) # Apply HDR TRC to source self.blend_profile_blackpoint( profile_src, profile_out, XYZbp, trc_output_offset, trc_gamma, trc_gamma_type, white_cdm2=white_cdm2, minmll=minmll, maxmll=maxmll, use_alternate_master_white_clip=use_alternate_master_white_clip, ambient_cdm2=ambient_cdm2, hdr_chroma_compression=False, hdr_sat=hdr_sat, hdr_hue=hdr_hue, ) profile_src.write() # Create link from source to destination profile gam_link_filename = tempfile.mktemp(profile_ext, "gam-link-", dir=cwd) result = self.exec_cmd( collink, [ "-v", "-G", "-ir", profile_src.fileName, profile_in_basename, gam_link_filename, ], capture_output=True, skip_scripts=True, sessionlogfile=self.sessionlogfile, ) if isinstance(result, Exception) and not getcfg("dry_run"): raise result elif not result: raise Error( "\n".join(self.errors) or "{} {}".format(collink, lang.getstr("error")) ) # Create RGB image # gam_in_tiff = tempfile.mktemp(".tif", "gam-in-", dir=cwd) # result = self.exec_cmd(tools["timage"], ["-x", gam_in_tiff], # capture_output=True, # skip_scripts=True, # sessionlogfile=self.sessionlogfile) # if isinstance(result, Exception) and not getcfg("dry_run"): # raise result # elif not result: # raise Error("\n".join(self.errors) or lang.getstr("error")) fd, gam_in_tiff = tempfile.mkstemp(".tif", "gam-in-", dir=cwd) stream = os.fdopen(fd, "wb") imfile.write_rgb_clut(stream, 65, format="TIFF") stream.close() # Convert RGB image from source to destination to get source # encoded within destination. gam_out_tiff = tempfile.mktemp(".tif", "gam-out-", dir=cwd) result = self.exec_cmd( tools["cctiff"], ["-p", gam_link_filename, gam_in_tiff, gam_out_tiff], capture_output=True, skip_scripts=True, sessionlogfile=self.sessionlogfile, ) if isinstance(result, Exception) and not getcfg("dry_run"): raise result elif not result: raise Error( "\n".join(self.errors) or "{} {}".format(tools["cctiff"], lang.getstr("error")) ) # Create gamut surface from image # gam_filename = os.path.splitext(profile_src.fileName)[0] + ".gam" # result = self.exec_cmd(tools["iccgamut"], ["-ir", "-pj", # profile_src.fileName], # capture_output=True, # skip_scripts=True, # sessionlogfile=self.sessionlogfile) gam_filename = os.path.splitext(gam_out_tiff)[0] + ".gam" result = self.exec_cmd( tools["tiffgamut"], ["-ir", "-pj", profile_in.fileName, gam_out_tiff], capture_output=True, skip_scripts=True, sessionlogfile=self.sessionlogfile, ) if isinstance(result, Exception) and not getcfg("dry_run"): raise result elif not result: raise Error( "\n".join(self.errors) or "{} {}".format(tools["tiffgamut"], lang.getstr("error")) ) else: gam_filename = None # Now build the device link args = [ "-v", "-qh", "-g" if use_b2a else "-G", f"-i{intent}", f"-r{size:d}", "-n", ] if gam_filename: # Use source gamut args.insert(3, gam_filename) if profile_abst: profile_abst.write(os.path.join(cwd, "abstract.icc")) args.extend(["-p", "abstract.icc"]) if self.argyll_version >= [1, 6]: if format == "madVR": args.append("-3m") elif format == "eeColor" and not test: args.append("-3e") elif format == "cube" and collink_version >= [1, 7] and not test: args.append("-3c") args.append(f"-e{input_encoding}") args.append(f"-E{output_encoding}") if collink_version >= [1, 7]: args.append("-b") # Use RGB->RGB forced black point hack if use_collink_bt1886 and trc_gamma_type in ("b", "B"): if collink_version >= [1, 7]: args.append( f"-I{trc_gamma_type}:{trc_output_offset}:{trc_gamma}" ) elif not trc_output_offset: args.append(f"-I{trc_gamma_type}:{trc_gamma}") if apply_cal: # Apply the calibration when building our device link # i.e. use collink -a parameter (apply calibration curves # to link output and append linear) args.extend(["-a", os.path.basename(profile_out_cal_path)]) if extra_args: args += extra_args # cLUT Input value tweaks to make Video encoded black land on # 65 res grid nodes, which should help 33 and 17 res cLUTs too def cLUT65_to_VidRGB(v): if size not in (17, 33, 65): return v return colormath.cLUT65_to_VidRGB(v) def VidRGB_to_cLUT65(v): if size not in (17, 33, 65): return v return colormath.VidRGB_to_cLUT65(v) logfiles = self.get_logfiles() xts = time() if use_xicclu: # Create device link using xicclu is_argyll_lut_format = format == "icc" def clipVidRGB(RGB, black_hack=True): """Clip a value to the RGB Video range 16..235 RGB. Clip the incoming value RGB[] in place. Return a bit mask of the channels that have/would clip, scale all non-black values to avoid positive clipping and return the restoring scale factor (> 1.0) if this has occured, return the full value in the clip direction in full[], and return the uncliped value in unclipped[]. """ clipmask = 0 scale = 1.0 full = [None] * 3 unclipped = list(RGB) # Locate the channel with the largest value mx = max(RGB) # One channel positively clipping if mx > 235.0 / 255.0: scale = ((235.0 - 16.0) / 255.0) / (mx - (16.0 / 255.0)) # Scale all non-black value down towards black, to avoid clipping for i, v in enumerate(RGB): # Note if channel would clip in itself if v > 235.0 / 255.0: full[i] = 1.0 clipmask |= 1 << i if v > 16.0 / 255.0: RGB[i] = (v - 16.0 / 255.0) * scale + 16.0 / 255.0 # See if any values negatively clip for i, v in enumerate(RGB): if black_hack: cond = v <= 16.0 / 255.0 else: cond = v < 16.0 / 255.0 if cond: RGB[i] = 16.0 / 255.0 full[i] = 0.0 clipmask |= 1 << i scale = 1.0 / scale return clipmask, scale, full, unclipped, RGB logfiles.write("Generating input values...\n") clip = {} seen = {} # Seen RGB input values seenkeys = {} RGB_src_in = [] maxind = size - 1.0 level_16 = VidRGB_to_cLUT65(16.0 / 255) * maxind level_235 = VidRGB_to_cLUT65(235.0 / 255) * maxind prevperc = 0 cliphack = False # Clip TV levels BtB/WtW in for full range out? for a in range(size): for b in range(size): for c in range(size): if self.thread_abort: raise Info(lang.getstr("aborted")) abc = (a, b, c) RGB = [v / maxind for v in abc] if input_encoding in ("t", "T"): # TV levels in if ( cliphack and output_encoding == "n" and ( min(abc) < level_16 or max(abc) > math.ceil(level_235) ) ): # Don't lookup out of range values continue else: RGB = [cLUT65_to_VidRGB(v) for v in RGB] clip[abc] = clipVidRGB(RGB) if a == b == c and a in ( math.ceil(level_16), math.ceil(level_235), ): self.log( "Input RGB (0..255) {:f} {:f} {:f}".format( *[v * 255 for v in RGB] ) ) # Convert 16..235 to 0..255 for xicclu RGB = [ colormath.convert_range( v, 16.0 / 255, 235.0 / 255, 0, 1 ) for v in RGB ] RGB = [min(max(v, 0), 1) * 255 for v in RGB] seenkey = tuple(int(round(v * 257)) for v in RGB) seenkeys[abc] = seenkey if seenkey in seen: continue seen[seenkey] = True RGB_src_in.append(RGB) perc = round( ((a + 1) * (b + 1) * (c + 1)) / float(size**3) * 100 ) if perc > prevperc: logfiles.write(f"\r{perc:0.0f}%") prevperc = perc logfiles.write("\n") self.log("Skipped", size**3 - len(seen), "duplicate input values") # Forward lookup input RGB through source profile logfiles.write("Looking up input values through source profile...\n") XYZ_src_out = self.xicclu( profile_in, RGB_src_in, intent[0], pcs="x", scale=255, logfile=logfiles, ) del RGB_src_in if intent == "aw": XYZw = self.xicclu(profile_in, [[1, 1, 1]], intent[0], pcs="x")[0] # Lookup scaled down white XYZ logfiles.write("Looking for solution...\n") for n in range(9): XYZscaled = [] for i in range(2001): XYZscaled.append( [v * (1 - (n * 2001 + i) / 20000.0) for v in XYZw] ) RGBscaled = self.xicclu( profile_out, XYZscaled, "a", "b" if use_b2a else "if", pcs="x", get_clip=True, ) # Find point at which it no longer clips XYZwscaled = None for i, RGBclip in enumerate(RGBscaled): if self.thread_abort: raise Info(lang.getstr("aborted")) if RGBclip[3] is True or max(RGBclip[:3]) > 1: # Clipped, skip continue # Found XYZwscaled = XYZscaled[i] logfiles.write( "Solution found at index {:d} " "(step size {:f})\n".format(i, 1 / 2000.0) ) logfiles.write( "RGB white {:6.4f} {:6.4f} {:6.4f}\n".format( *RGBclip[:3] ) ) logfiles.write( "XYZ white {:6.4f} {:6.4f} {:6.4f}, CCT {:.1f} K\n".format( *(XYZscaled[i] + [colormath.XYZ2CCT(*XYZwscaled)]) ) ) break else: if n == 8: break if XYZwscaled: # Found solution break if not XYZwscaled: raise Error( "No solution found in {:d} iterations with {:d} steps".format( n, i ) ) for i, XYZ in enumerate(XYZ_src_out): XYZ[:] = [v / XYZw[1] * XYZwscaled[1] for v in XYZ] del RGBscaled # Inverse forward lookup source profile output XYZ through # destination profile num_cpus = cpu_count() num_workers = min(max(num_cpus, 1), size) if "A2B0" in profile_out.tags and not use_b2a: if num_cpus > 2: num_workers = int(num_workers * 0.75) num_batches = size // 9 else: if num_cpus > 2: num_workers = 2 num_batches = 1 if use_b2a: direction = "backward" else: direction = "inverse forward" logfiles.write( "Creating device link from {} lookup ({:d} workers)...\n".format( direction, num_workers ) ) RGB_dst_out = [] for slices in pool_slice( _mp_xicclu, XYZ_src_out, (profile_out.fileName, intent[0], "b" if use_b2a else "if"), { "pcs": "x", "use_cam_clipping": True, "abortmessage": lang.getstr("aborted"), }, num_workers, self.thread_abort, logfiles, num_batches=num_batches, ): RGB_dst_out.extend(slices) del XYZ_src_out logfiles.write("\n") logfiles.write("Filling cLUT...\n") profile_link = ICCProfile() profile_link.profileClass = b"link" profile_link.connectionColorSpace = b"RGB" profile_link.setDescription(name) profile_link.setCopyright(getcfg("copyright")) profile_link.tags.pseq = ProfileSequenceDescType( profile=profile_link ) profile_link.tags.pseq.add(profile_in) profile_link.tags.pseq.add(profile_out) profile_link.tags.A2B0 = A2B0 = LUT16Type( None, "A2B0", profile_link ) A2B0.matrix = colormath.Matrix3x3([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) if input_encoding in ("t", "T"): A2B0.input = [[]] * 3 for i in range(2048): A2B0.input[0].append(VidRGB_to_cLUT65(i / 2047.0) * 65535) else: A2B0.input = [[0, 65535]] * 3 A2B0.output = [[0, 65535]] * 3 A2B0.clut = [] clut = {} n = 0 for a in range(size): for b in range(size): for c in range(size): abc = (a, b, c) if ( cliphack and input_encoding in ("t", "T") and output_encoding == "n" and ( min(abc) < level_16 or max(abc) > math.ceil(level_235) ) ): # TV levels in, no value from lookup, full # range out continue seenkey = seenkeys[abc] if seenkey in seen and seen[seenkey] is not True: RGB = seen[seenkey] else: if input_encoding in ("t", "T"): cond = min(abc) <= level_16 and min(abc) == max(abc) else: cond = max(abc) == 0 if cond: # Black hack self.log( "Black hack - forcing output RGB {:0.0f} {:0.0f} {:0.0f}".format( *[ cLUT65_to_VidRGB(v / maxind) * 255 for v in abc ] ) ) RGB = [0] * 3 else: RGB = RGB_dst_out[n] seen[seenkey] = RGB n += 1 clut[abc] = RGB del seen del seenkeys del RGB_dst_out preserve_sync = getcfg("3dlut.preserve_sync") prevperc = 0 for a in range(size): for b in range(size): A2B0.clut.append([]) for c in range(size): abc = (a, b, c) if ( cliphack and input_encoding in ("t", "T") and output_encoding == "n" and ( min(abc) < level_16 or max(abc) > math.ceil(level_235) ) ): # TV levels in, no value from lookup, full # range out key = tuple( min( max(v, math.ceil(level_16)), math.ceil(level_235), ) for v in abc ) RGB = clut[key] else: # Got value from lookup RGB = clut[abc] del clut[abc] if output_encoding == "t": # TV levels out # Convert 0..255 to 16..235 RGB = [ colormath.convert_range( v, 0, 1, 16.0 / 255, 235.0 / 255 ) for v in RGB ] if input_encoding in ("t", "T"): # TV levels in, scale/extrapolate clip clipmask, scale, full, uci, cin = clip[abc] del clip[abc] for j, v in enumerate(RGB): if clipmask: if input_encoding != "T" and scale > 1: # We got +ve clipping # Re-scale all non-black values if v > 16.0 / 255.0: v = ( v - 16.0 / 255.0 ) * scale + 16.0 / 255.0 # Deal with -ve clipping and sync if clipmask & (1 << j): if full[j] == 0.0: # Only extrapolate in black direction ifull = ( 1.0 - full[j] ) # Opposite limit to full # Do simple extrapolation (Not perfect though) v = ifull + (v - ifull) * ( uci[j] - ifull ) / (cin[j] - ifull) # Clip or pass sync through if ( v < 0.0 or v > 1.0 or ( preserve_sync and abs(uci[j] - full[j]) < 1e-6 ) ): v = full[j] RGB[j] = v RGB = [min(max(v, 0), 1) * 65535 for v in RGB] A2B0.clut[-1].append(RGB) perc = round(len(A2B0.clut) / float(size**2) * 100) if perc > prevperc: logfiles.write(f"\r{perc:0.0f}%") prevperc = perc logfiles.write("\n") profile_link.write(link_filename) self.log("Finished creating device link in", time() - xts, "seconds") result = True del clip del clut del A2B0 else: # Create device link (and 3D LUT, if applicable) using collink is_argyll_lut_format = ( self.argyll_version >= [1, 6] and ( ( ( format == "eeColor" or (format == "cube" and collink_version >= [1, 7]) ) and not test ) or format == "madVR" ) or format == "icc" ) result = self.exec_cmd( collink, args + [profile_in_basename, profile_out_basename, link_filename], capture_output=True, skip_scripts=True, ) if result and not isinstance(result, Exception): self.log("Finished creating 3D LUT in", time() - xts, "seconds") if ( result and not isinstance(result, Exception) and save_link_icc and os.path.isfile(link_filename) ): profile_link = ICCProfile(link_filename) profile_link.setDescription(name) profile_link.setCopyright(getcfg("copyright")) if manufacturer: profile_link.setDeviceManufacturerDescription(manufacturer) if model: profile_link.setDeviceModelDescription(model) profile_link.device["manufacturer"] = device_manufacturer profile_link.device["model"] = device_model if mmod: profile_link.tags.mmod = mmod profile_link.tags.meta = DictType() profile_link.tags.meta.update( [ ("CMF_product", appname), ("CMF_binary", appname), ("CMF_version", version), ( "collink.args", sp.list2cmdline( args + [ profile_in_basename, profile_out_basename, link_basename, ] ), ), ("collink.version", collink_version_string), ("encoding.input", input_encoding), ("encoding.output", output_encoding), ] ) profile_link.calculateID() profile_link.write(f"{filename}{profile_ext}") profile_link.tags.A2B0.clut_writepng(f"{filename}.A2B0.CLUT.png") del profile_link if use_xicclu and format == "madVR": # We need to up-interpolate the device link ourself # Call this in a separate process so I/O congestion # doesn't interfere with UI updates and audio # madvr.icc_device_link_to_madvr(link_filename, # rgb_space=profile_in.get_rgb_space(), # hdr=smpte2084 + hdr_display, # logfile=logfiles, # convert_video_rgb_to_clut65=True) interp_args = [] if os.path.basename(exe).lower().startswith("python"): if os.path.basename(exe).lower().startswith("pythonw"): cmd = os.path.join( exedir, "python" + os.path.basename(exe)[7:] ) else: cmd = exe py = os.path.normpath( os.path.join( pydir, "..", f"{appname}-eeColor-to-madVR-converter.py" ) ) if os.path.exists(py): # Running from source or 0install # If parent is running from 0install, the child # will inherit the correct environment (PYTHONPATH) # so no need to run child through 0install # Need to run unbuffered so we can grab # progress interp_args.append("-u") interp_args.append(py) else: # Regular install # Need to run unbuffered so we can grab # progress interp_args.append("-u") if sys.platform in ("win32", "darwin"): interp_args.append( get_data_path( os.path.join( "scripts", f"{appname.lower()}-eecolor-to-madvr-converter", ) ) ) else: # Linux interp_args.append( which( f"{appname.lower()}-eecolor-to-madvr-converter" ) ) elif isapp: cmd = os.path.join(exedir, "python") interp_args.extend( [ "-c", "import sys;sys.path.insert(0, {});execfile({})".format( os.path.join( pydir.encode(fs_enc), "lib", "python{}{}".format(*sys.version_info[:2]), "site-packages.zip", ), os.path.join( pydir.encode(fs_enc), f"{appname.lower()}-eecolor-to-madvr-converter", ), ), ] ) else: cmd = os.path.join( pydir, f"{appname}-eeColor-to-madVR-converter{exe_ext}" ) if in_colors: interp_args.append( "--colorspace={}".format( ",".join([str(v) for v in in_colors]) ) ) interp_args.append("--hdr={:0.0f}".format(smpte2084 + hdr_display)) interp_args.append("--convert-video-rgb-to-clut65") interp_args.append("--append-linear-cal") interp_args.append("--batch") interp_args.append(link_filename) result = self.exec_cmd( cmd, interp_args, capture_output=True, skip_scripts=True, use_pty=True, ) if debug: h3d = madvr.H3DLUT(os.path.join(cwd, name + ".3dlut")) h3d.write_devicelink(filename + ".3dlut" + profile_ext) if result and not isinstance(result, Exception): if format == "madVR" and is_argyll_lut_format: # We need to update Input_Primaries, otherwise the # madVR 3D LUT won't work correctly! (collink fills # Input_Primaries from a lookup through the input # profile, which won't work correctly if the input # profile is cLUT-based. Also, we want to use a D65 # white as madVR can only deal correctly with D65 h3d = madvr.H3DLUT(os.path.join(cwd, name + ".3dlut")) input_primaries = h3d.parametersData.get("Input_Primaries") if input_primaries: if in_colors: h3d.parametersData["Input_Primaries"] = in_colors if smpte2084: h3d.parametersData["Input_Transfer_Function"] = "PQ" if hdr_display: h3d.parametersData["Output_Transfer_Function"] = "PQ" h3d.write() else: raise Error("madVR 3D LUT doesn't contain Input_Primaries") if hdr or not use_collink_bt1886 or XYZwp: if not hdr and XYZwp != profile_in_wtpt_XYZ: # Update profile description profile_in.setDescription( "{} {}x {}y".format( profile_in.getDescription(), *[ stripzeros(f"{v:.4f}") for v in colormath.XYZ2xyY(*XYZwp)[:2] ], ) ) # Save source profile in_name, in_ext = os.path.splitext(profile_in_basename) profile_in.fileName = os.path.join( os.path.dirname(path), self.lut3d_get_filename(profile_in_basename, False, False) + in_ext, ) profile_in.write() if isinstance(profile_in.tags.get("A2B0"), LUT16Type): # Write diagnostic PNG profile_in.tags.A2B0.clut_writepng( "{}.A2B0.CLUT.png".format( os.path.splitext(profile_in.fileName)[0] ) ) if isinstance(profile_in.tags.get("DBG0"), LUT16Type): # HDR RGB profile_in.tags.DBG0.clut_writepng( "{}.DBG0.CLUT.png".format( os.path.splitext(profile_in.fileName)[0] ) ) if isinstance(profile_in.tags.get("DBG1"), LUT16Type): # Display RGB profile_in.tags.DBG1.clut_writepng( "{}.DBG1.CLUT.png".format( os.path.splitext(profile_in.fileName)[0] ) ) if isinstance(profile_in.tags.get("DBG2"), LUT16Type): # Display XYZ profile_in.tags.DBG2.clut_writepng( "{}.DBG2.CLUT.png".format( os.path.splitext(profile_in.fileName)[0] ) ) if is_argyll_lut_format or (use_xicclu and format == "madVR"): # Collink has already written the 3DLUT for us, # or we have written the madVR 3D LUT if format == "cube": if maxval is None: maxval = 1.0 # Strip any leading whitespace from each line (although # leading/trailing spaces are allowed according to the spec). # Also, Argyll does not write (optional) DOMAIN_MIN/MAX # keywords. Add them after the fact. cube_filename = os.path.join(cwd, f"{name}.cube") if os.path.isfile(cube_filename): add_domain = True cube_data = [] with open(cube_filename, "rb") as cube_file: for line in cube_file: # Strip any leading whitespace line = line.lstrip() if line.startswith(b"DOMAIN_"): # Account for the possibility that a # future Argyll version might write # DOMAIN_MIN/MAX keywords. add_domain = False elif line.startswith(b"0.") and add_domain: # 1st cube data entry marks end of keywords. # Add DOMAIN_MIN/MAX keywords cube_data.append(b"DOMAIN_MIN 0.0 0.0 0.0\n") fp_offset = str(maxval).find(".") domain_max = b"DOMAIN_MAX %s %s %s\n" % ( (b"%%.%if" % len(str(maxval)[fp_offset + 1 :]),) * 3 ) cube_data.append(domain_max % ((maxval,) * 3)) cube_data.append(b"\n") add_domain = False cube_data.append(line) # Write updated cube with open(cube_filename, "wb") as cube_file: cube_file.write(b"".join(cube_data)) result2 = self.wrapup( not isinstance(result, UnloggedInfo) and result, dst_path=path, ext_filter=[".3dlut", ".cube", ".log", ".png", ".txt", ".wrl"], ) if not result: result = UnloggedError(lang.getstr("aborted")) if isinstance(result2, Exception): if isinstance(result, Exception): result = Error(f"{result}\n\n{result2}") else: result = result2 if not isinstance(result, Exception): return if isinstance(result, Exception): raise result elif not result: raise UnloggedError(lang.getstr("aborted")) # We have to create the 3DLUT ourselves logfiles.write(f"Generating {format} 3D LUT...\n") # Create input RGB values RGB_oin = [] RGB_in = [] RGB_indexes = [] seen = {} if format == "eeColor": # Fixed size size = 65 elif format == "ReShade": format = "png" if format == "3dl": if maxval is None: maxval = 1023 if output_bits is None: output_bits = math.log(maxval + 1) / math.log(2) if input_bits is None: input_bits = output_bits # Note: We only round up for the input values, output values # are rounded to nearest integer quantizer = lambda v: int(math.ceil(v * (2**input_bits - 1))) scale = quantizer(1.0) else: quantizer = lambda v: v scale = 1.0 step = 1.0 / (size - 1) RGB_triplet = [0.0, 0.0, 0.0] RGB_index = [0, 0, 0] # Set the fastest and slowest changing columns, from right to left if format in ("3dl", "mga", "spi3d") or ( format == "png" and getcfg("3dlut.image.order") == "bgr" ): columns = (0, 1, 2) elif format == "eeColor": columns = (2, 0, 1) else: columns = (2, 1, 0) for i in range(0, size): # Red if format == "eeColor" and not eecolor65 and i == size - 1: # Last cLUT entry is fixed to 1.0 for eeColor and unchangeable continue RGB_triplet[columns[0]] = quantizer(step * i) RGB_index[columns[0]] = i for j in range(0, size): # Green if format == "eeColor" and not eecolor65 and j == size - 1: # Last cLUT entry is fixed to 1.0 for eeColor and unchangeable continue RGB_triplet[columns[1]] = quantizer(step * j) RGB_index[columns[1]] = j for k in range(0, size): # Blue if self.thread_abort: raise Info(lang.getstr("aborted")) if format == "eeColor" and not eecolor65 and k == size - 1: # Last cLUT entry is fixed to 1.0 for eeColor and unchangeable continue RGB_triplet[columns[2]] = quantizer(step * k) RGB_oin.append(list(RGB_triplet)) RGB_copy = list(RGB_triplet) if format == "eeColor": for l in range(3): RGB_copy[l] = eeColor_to_VidRGB(RGB_copy[l]) if input_encoding in ("t", "T"): RGB_copy[l] = VidRGB_to_cLUT65(RGB_copy[l]) RGB_index[columns[2]] = k RGB_in.append(RGB_copy) RGB_indexes.append(list(RGB_index)) # Lookup RGB -> RGB values through devicelink profile using icclu # (Using icclu instead of xicclu because xicclu in versions # prior to Argyll CMS 1.6.0 could not deal with devicelink profiles) RGB_out = self.xicclu( link_filename, RGB_in, scale=scale, use_icclu=True, logfile=logfiles ) if format == "eeColor" and output_encoding == "n": RGBw = self.xicclu(link_filename, [[1, 1, 1]], use_icclu=True)[0] # Remove temporary files, move log file result2 = self.wrapup(dst_path=path, ext_filter=[".log"]) if isinstance(result, Exception): raise result valsep = " " if format not in ("dcl", "png"): lut = [[f"# Created with {appname} {version}"]] linesep = "\n" if format in ("3dl", "dcl"): maxval = math.pow(2, output_bits) - 1 if format == "3dl": lut.append([f"# INPUT RANGE: {input_bits:d}"]) lut.append([f"# OUTPUT RANGE: {output_bits:d}"]) lut.append([]) for i in range(0, size): lut[-1].append("{:d}".format(quantizer(i * step))) else: # dcl lut = [["# DeviceControl-LG 3D"]] linesep = "\r\n" for RGB_triplet in RGB_out: lut.append([]) for component in (0, 1, 2): lut[-1].append( "{:d}".format( int(round(RGB_triplet[component] / scale * maxval)) ) ) elif format == "cube": if maxval is None: maxval = 1.0 lut.append([f"LUT_3D_SIZE {size:d}"]) lut.append(["DOMAIN_MIN 0.0 0.0 0.0"]) fp_offset = str(maxval).find(".") domain_max = "DOMAIN_MAX {} {} {}".format( ("{{:.{:d}f}}".format(len(str(maxval)[fp_offset + 1 :])),) * 3 ) lut.append([domain_max.format((maxval,) * 3)]) lut.append([]) for RGB_triplet in RGB_out: lut.append([]) for component in (0, 1, 2): lut[-1].append("{:.6f}".format(RGB_triplet[component] * maxval)) elif format == "spi3d": if maxval is None: maxval = 1.0 lut = [["SPILUT 1.0"]] lut.append(["3 3"]) lut.append(["{:d} {:d} {:d}".format(*([size] * 3))]) for i, RGB_triplet in enumerate(RGB_out): lut.append([str(index) for index in RGB_indexes[i]]) for component in (0, 1, 2): lut[-1].append("{:.6f}".format(RGB_triplet[component] * maxval)) elif format == "eeColor": if maxval is None: maxval = 1.0 lut = [] for i, RGB_triplet in enumerate(RGB_out): lut.append( ["{:.6f}".format(component * maxval) for component in RGB_oin[i]] ) for component in (0, 1, 2): v = RGB_triplet[component] * maxval if output_encoding == "n": # For eeColor and full range RGB, make sure that the cLUT # output maps to 1.0 # The output curve will correct this v /= RGBw[component] v = min(v, 1) v = VidRGB_to_eeColor(v) lut[-1].append(f"{v:.6f}") linesep = "\r\n" elif format == "mga": lut = [ ["#HEADER"], ["#filename: {}".format(os.path.basename(path))], ["#type: 3D cube file"], ["#format: 1.00"], ["#created: {}".format(strftime("%d %B %Y"))], [f"#owner: {getpass.getuser()}"], ["#title: {}".format(os.path.splitext(os.path.basename(path))[0])], ["#END"], ] lut.append([]) lut.append(["channel 3d"]) lut.append(["in {:d}".format(size**3)]) maxval = 2**output_bits - 1 lut.append(["out {:d}".format(maxval + 1)]) lut.append([""]) lut.append(["format lut"]) lut.append([""]) lut.append(["values\tred\tgreen\tblue"]) for i, RGB_triplet in enumerate(RGB_out): lut.append([f"{i:d}"]) for component in (0, 1, 2): lut[-1].append( ("{}".format(int(round(RGB_triplet[component] * maxval)))) ) valsep = "\t" elif format == "png": lut = [[]] if output_bits > 8: # PNG only supports 8 and 16 bit output_bits = 16 maxval = 2**output_bits - 1 for RGB_triplet in RGB_out: if len(lut[-1]) == size: # Append new scanline lut.append([]) lut[-1].append([int(round(v * maxval)) for v in RGB_triplet]) # Current layout is vertical if getcfg("3dlut.image.layout") == "h": # Change layout to horizontal lutv = lut lut = [[]] for i in range(size): if len(lut[-1]) == size**2: # Append new scanline lut.append([]) for j in range(size): lut[-1].extend(lutv[i + size * j]) if format != "png": lut.append([]) for i, line in enumerate(lut): lut[i] = valsep.join(line) result = linesep.join(lut) # Write 3DLUT lut_file = open(path, "wb") if format != "png": lut_file.write(result.encode()) else: im = imfile.Image(lut, output_bits) im.write(lut_file) lut_file.close() if format == "eeColor": # Write eeColor 1D LUTs for i, color in enumerate(["red", "green", "blue"]): for count, inout in [(1024, "first"), (8192, "second")]: with open(f"{filename}-{inout}1d{color}.txt", "wb") as lut1d: for j in range(count): v = j / (count - 1.0) if inout == "second" and output_encoding == "n": # For eeColor and Full range RGB, unmap the # cLUT output maps from 1.0 v *= RGBw[i] n_v = f"{v:.6f}\n" lut1d.write(n_v.encode()) if isinstance(result2, Exception): raise result2 def enumerate_displays_and_ports( self, silent=False, check_lut_access=True, enumerate_ports=True, include_network_devices=True, ): """Enumerate the available displays and ports. Also sets Argyll version number, availability of certain options like black point rate, and checks LUT access for each display. """ if (silent and check_argyll_bin()) or (not silent and check_set_argyll_bin()): displays = [] xrandr_names = {} lut_access = [] if verbose >= 1: print(lang.getstr("enumerating_displays_and_comports")) instruments = [] current_display_name = config.get_display_name() cfg_instruments = getcfg("instruments") current_instrument = config.get_instrument_name() if enumerate_ports: cmd = get_argyll_util("dispcal") else: cmd = get_argyll_util("dispwin") for instrument in cfg_instruments: # Names are canonical from 1.1.4.7 onwards, but we may have # verbose names from an old configuration instrument = get_canonical_instrument_name(instrument) if instrument.strip(): instruments.append(instrument) args = [] if include_network_devices: args.append("-dcc:?") args.append("-?") argyll_bin_dir = os.path.dirname(cmd) if argyll_bin_dir != self.argyll_bin_dir: self.argyll_bin_dir = argyll_bin_dir print(self.argyll_bin_dir) result = self.exec_cmd( cmd, args, capture_output=True, skip_scripts=True, silent=True, log_output=False, ) if isinstance(result, Exception): print(result) arg = None defaults["calibration.black_point_hack"] = 0 defaults["calibration.black_point_rate.enabled"] = 0 defaults["patterngenerator.prisma.argyll"] = 0 n = -1 self.display_rects = [] non_standard_display_args = ("-dweb[:port]", "-dmadvr") if test: # Add dummy Chromecasts self.output.append(" -dcc[:n]") self.output.append(" 100 = '\xd4\xc7\xf3 Test A'") self.output.append(" 101 = '\xd4\xc7\xf3 Test B'") argyll_version_string = None self.reset_argyll_enum() for line in self.output: if isinstance(line, str): n += 1 line = line.strip() if argyll_version_string is None and "version" in line.lower(): argyll_version_string = line[line.lower().find("version") + 8 :] if argyll_version_string != self.argyll_version_string: self.set_argyll_version_from_string(argyll_version_string) print(f"ArgyllCMS {self.argyll_version_string}") defaults["copyright"] = ( f"No copyright. Created with {appname} {version} and " f"Argyll CMS {argyll_version_string}" ) if self.argyll_version > [1, 0, 4]: # Rate of blending from neutral to black point. defaults["calibration.black_point_rate.enabled"] = 1 if ( self.argyll_version >= [1, 7] and "Beta" not in self.argyll_version_string ): # Forced black point hack available # (Argyll CMS 1.7) defaults["calibration.black_point_hack"] = 1 if self.argyll_version >= [1, 9, 4]: # Add CIE 2012 observers valid_observers = natsort(observers + ["2012_2", "2012_10"]) else: valid_observers = observers for key in [ "{}", "colorimeter_correction.{}", "colorimeter_correction.{}.reference", ]: key = key.format("observer") config.valid_values[key] = valid_observers continue line = line.split(None, 1) if len(line) and line[0][0] == "-": arg = line[0] value = line[-1].split(None, 1)[0] if arg == "-d" and not value.startswith("n"): # Argyll 2.0.2 started listing -d madvr and -d dummy # instead of -dmadvr and -ddummy # Use the non-space-delimited as the canonical form arg += value if arg == "-A": # Rate of blending from neutral to black point. defaults["calibration.black_point_rate.enabled"] = 1 elif arg in non_standard_display_args: displays.append(arg) elif arg == "-b" and not line[-1].startswith("bright"): # Forced black point hack available # (Argyll CMS 1.7b 2014-12-22) defaults["calibration.black_point_hack"] = 1 elif arg == "-dprisma[:host]": defaults["patterngenerator.prisma.argyll"] = 1 elif arg in ("-dvirtual", "-ddummy"): # Custom modified Argyll V2.0.2 (-dvirtual) # or Argyll >= 2.0.2 (-d dummy) self.argyll_virtual_display = arg[2:] print("Argyll has virtual display support") elif len(line) > 1 and line[1][0] == "=": value = line[1].strip(" ='") if arg == "-d": # Standard displays match = re.findall( r"(.+?),? at (-?\d+), (-?\d+), width (\d+), height (\d+)", value, ) if len(match): xrandr_name = re.search(r", Output (.+)", match[0][0]) if xrandr_name: xrandr_names[len(displays)] = xrandr_name.group(1) display = "{} @ {}, {}, {}x{}".format(*match[0]) if " ".join(value.split()[-2:]) == "(Primary Display)": display += " [PRIMARY]" displays.append(display) self.display_rects.append( wx.Rect(*[int(item) for item in match[0][1:]]) ) elif arg == "-dcc[:n]": # Chromecast if value: # Note the Chromecast name may be mangled due # to being UTF-8 encoded, but commandline output # will always be decoded to Unicode using the # stdout encoding, which may not be UTF-8 # (e.g. under Windows). We can recover characters # valid in both UTF-8 and stdout encoding # by a re-encode/decode step displays.append( "Chromecast {}: {}".format( line[0], safe_str(value, enc) ) ) elif arg == "-dprisma[:host]": # Prisma (via Argyll CMS) # : @ # 141550000000: prisma-0000 @ 172.31.31.162 match = re.findall(r".+?: (.+) @ (.+)", value) if len(match): displays.append( "Prisma {}: {} @ {}".format( line[0], safe_str(match[0][0], enc), match[0][1], ) ) elif arg == "-c" and enumerate_ports: if ( re.match(r"/dev(?:/[\w.\-]+)*$", value) or re.match(r"COM\d+$", value) ) and getcfg("skip_legacy_serial_ports"): # Skip all legacy serial ports (this means we # deliberately don't support DTP92 and # Spectrolino, although they may work when # used with a serial to USB adaptor) continue value = value.split(None, 1) if len(value) > 1: value = value[1].split("'", 1)[0].strip("()") else: value = value[0] value = get_canonical_instrument_name(value) instruments.append(value) if test: inames = list(all_instruments.keys()) inames.sort() for iname in inames: iname = get_canonical_instrument_name(iname) if iname not in instruments: instruments.append(iname) if verbose >= 1: print(lang.getstr("success")) if instruments != self.instruments: self.instruments = instruments setcfg("instruments", instruments) if ( current_instrument != self.get_instrument_name() and current_instrument in instruments ): setcfg("comport.number", instruments.index(current_instrument) + 1) if displays != self._displays: self._displays = list(displays) setcfg("displays", displays) if RDSMM: # Sync with Argyll - needed under Linux to map EDID RDSMM.enumerate_displays() displays = [ display for display in displays if display not in non_standard_display_args ] self.display_edid = [] self.display_manufacturers = [] self.display_names = [] if sys.platform == "win32": # The ordering will work as long # as Argyll continues using # EnumDisplayMonitors try: monitors = util_win.get_real_display_devices_info() except Exception as exception: if not isinstance(exception, pywintypes.error): print(traceback.format_exc()) monitors = [] for i, display in enumerate(displays): if display.startswith("Chromecast ") or display.startswith( "Prisma " ): self.display_edid.append({}) if display.startswith("Prisma "): display_manufacturer = "Q, Inc" else: display_manufacturer = "Google" self.display_manufacturers.append(display_manufacturer) self.display_names.append(display.split(":", 1)[1].strip()) continue display_name = split_display_name(display) # Make sure we have nice descriptions desc = [] if sys.platform == "win32" and i < len(monitors): # Get monitor description using win32api device = util_win.get_active_display_device( monitors[i]["Device"] ) if device: desc.append(device.DeviceString) # Deal with HiDPI - update monitor rect m_left, m_top, m_right, m_bottom = monitors[i]["Monitor"] m_width = m_right - m_left m_height = m_bottom - m_top self.display_rects[i] = wx.Rect( m_left, m_top, m_width, m_height ) is_primary = " [PRIMARY]" in display display = " @ ".join( [ display_name, "{:d}, {:d}, {:d}x{:d}".format( m_left, m_top, m_width, m_height ), ] ) if is_primary: display += " [PRIMARY]" # Get monitor descriptions from EDID try: # Important: display_name must be given for get_edid # under Mac OS X, but it doesn't hurt to always # include it edid = get_edid(i, display_name) except Exception as exception: suppress_errors = (SystemError, TypeError, ValueError, WMIError) if sys.platform == "win32": suppress_errors += (pywintypes.error,) if isinstance(exception, EnvironmentError): print(exception) elif not isinstance(exception, suppress_errors): print(traceback.format_exc()) edid = {} self.display_edid.append(edid) if edid: manufacturer = edid.get("manufacturer", "").split() monitor = edid.get( "monitor_name", edid.get("ascii", str(edid["product_id"] or "")), ) if ( monitor in ("Color LCD", "iMac") and edid["manufacturer_id"] == "APP" and sys.platform == "darwin" ): # Get mac model if internal display model_id = get_model_id() if model_id: # Override monitor name monitor = model_id # Override EDID edid["monitor_name"] = monitor if monitor and monitor not in "".join(desc): desc = [monitor] else: manufacturer = [] if desc and desc[-1] not in display: # Only replace the description if it not already # contains the monitor model display = " @".join([" ".join(desc), display.split("@")[-1]]) displays[i] = display self.display_manufacturers.append(" ".join(manufacturer)) self.display_names.append(split_display_name(display)) if self.argyll_version >= [1, 4, 0]: displays.append("Web @ localhost") self.display_edid.append({}) self.display_manufacturers.append("") self.display_names.append("Web") if self.argyll_version >= [1, 6, 0]: displays.append("madVR") self.display_edid.append({}) self.display_manufacturers.append("") self.display_names.append("madVR") # Prisma (via DisplayCAL) displays.append("Prisma") self.display_edid.append({}) self.display_manufacturers.append("Q, Inc") self.display_names.append("Prisma") # Resolve displays.append("Resolve") self.display_edid.append({}) self.display_manufacturers.append("DaVinci") self.display_names.append("Resolve") # Untethered displays.append("Untethered") self.display_edid.append({}) self.display_manufacturers.append("") self.display_names.append("Untethered") # self.displays = displays setcfg("displays", displays) if ( current_display_name != config.get_display_name() and current_display_name in self.display_names ): setcfg( "display.number", self.display_names.index(current_display_name) + 1, ) # Filter out Prisma (via DisplayCAL), Resolve and Untethered # IMPORTANT: Also make changes to display filtering in # worker.Worker.has_separate_lut_access displays = displays[:-3] if self.argyll_version >= [1, 6, 0]: # Filter out madVR displays = displays[:-1] if self.argyll_version >= [1, 4, 0]: # Filter out Web @ localhost displays = displays[:-1] if check_lut_access: dispwin = get_argyll_util("dispwin") test_cal = get_data_path("test.cal") if not test_cal: print(lang.getstr("file.missing", "test.cal")) tmp = self.create_tempdir() if isinstance(tmp, Exception): print(tmp) tmp = None for i, disp in enumerate(displays): if ( disp.startswith("Chromecast ") or disp.startswith("Prisma ") or not test_cal ): lut_access.append(None) continue if sys.platform == "darwin": # There's no easy way to check LUT access under # Mac OS X because loading a LUT isn't persistent # unless you run as root. Just assume we have # access to all displays. lut_access.append(True) continue if verbose >= 1: print(lang.getstr("checking_lut_access", (i + 1))) # Save current calibration? if tmp: current_cal = os.path.join(tmp, "current.cal") tmp_cal = current_cal result = self.save_current_video_lut( i + 1, current_cal, silent=True ) # Load test.cal result = self.exec_cmd( dispwin, [f"-d{i + 1}", "-c", test_cal], capture_output=True, skip_scripts=True, silent=True, ) if isinstance(result, Exception): print(result) elif result is None: lut_access.append(None) continue # Check if LUT == test.cal result = self.exec_cmd( dispwin, [f"-d{(i + 1)}", "-V", test_cal], capture_output=True, skip_scripts=True, silent=True, ) if isinstance(result, Exception): print(result) elif result is None: lut_access.append(None) continue retcode = -1 for line in self.output: if line.find("IS loaded") >= 0: retcode = 0 break # Reset LUT & (re-)load previous cal (if any) if not tmp or not os.path.isfile(current_cal): current_cal = self.get_dispwin_display_profile_argument(i) result = self.exec_cmd( dispwin, [f"-d{i + 1}", "-c", current_cal], capture_output=True, skip_scripts=True, silent=True, ) if isinstance(result, Exception): print(result) if tmp and os.path.isfile(tmp_cal): try: os.remove(tmp_cal) except EnvironmentError as exception: print(exception) lut_access.append(retcode == 0) if verbose >= 1: if retcode == 0: print(lang.getstr("success")) else: print(lang.getstr("failure")) else: lut_access.extend([None] * len(displays)) if self.argyll_version >= [1, 4, 0]: # Web @ localhost lut_access.append(False) if self.argyll_version >= [1, 6, 0]: # madVR lut_access.append(True) # Prisma (via DisplayCAL) lut_access.append(False) # Resolve lut_access.append(False) # Untethered lut_access.append(False) self.lut_access = lut_access elif silent or not check_argyll_bin(): self.clear_argyll_info() def exec_cmd( self, cmd, args=None, capture_output=False, display_output=False, low_contrast=True, skip_scripts=False, silent=False, parent=None, asroot=False, log_output=True, title=appname, shell=False, working_dir=None, dry_run=None, sessionlogfile=None, use_pty=False, ): """Execute a command. Return value is either True (succeed), False (failed), None (canceled) or an exception. Args: cmd (str): the full path of the command. args (List[str]): The arguments, if any. capture_output (bool): If True, swallows any output from the command and sets the 'output' and 'errors' properties of the Worker instance. display_output (bool): Shows the log after the command. low_contrast (bool): If True sets low contrast shell colors while the command is run. skip_scripts (bool): If True, skips the creation of shell scripts that allow re-running the command. Note that this is also controlled by a global config option and scripts will only be created if it evaluates to False. silent (bool): If True, skips most output and also most error dialogs (except unexpected failures). parent (): Sets the parent window for auth dialog (if asroot is True). asroot (bool): If True, on Linux runs the command using sudo. log_output (bool): If True, logs any output if capture_output is also set. title (str): Title for auth dialog (if asroot is True). working_dir (str): Working directory. If None, will be determined from absulte path of last argument and last argument will be set to only the basename. If False, no working dir will be used and file arguments not changed. """ if args is None: args = [] # convert all args to str if any are bytes for i, arg in enumerate(args): if isinstance(arg, bytes): args[i] = arg.decode("utf-8") # If dry_run is explicitly set to False, ignore dry_run config value dry_run = dry_run is not False and (dry_run or getcfg("dry_run")) if not capture_output: capture_output = False if sys.stdout and hasattr(sys.stdout, "isatty") and not sys.stdout.isatty(): capture_output = True self.clear_cmd_output() if None in [cmd, args]: if verbose >= 1 and not silent: print(lang.getstr("aborted")) return False self.cmd = cmd cmdname = os.path.splitext(os.path.basename(cmd))[0] self.cmdname = cmdname if "-?" not in args and cmdname == get_argyll_utilname("dispwin"): if "-I" in args or "-U" in args: if "-Sl" in args or "-Sn" in args: # Root is required if installing a profile to a system # location asroot = True elif "-s" not in args and not self.calibration_loading_generally_supported: # Loading/clearing calibration not supported # Don't actually do it, pretend we were successful if "-V" in args: self.output.append("IS loaded") self.retcode = 0 return True if asroot: silent = False measure_cmds = ( get_argyll_utilname("dispcal"), get_argyll_utilname("dispread"), get_argyll_utilname("spotread"), ) process_cmds = ( get_argyll_utilname("collink"), get_argyll_utilname("colprof"), get_argyll_utilname("targen"), ) # Run commands through wexpect.spawn instead of subprocess.Popen if # any of these conditions apply use_pty = ( args and "-?" not in args and (use_pty or cmdname in measure_cmds + process_cmds) ) self.measure_cmd = "-?" not in args and cmdname in measure_cmds report_current_cal = cmdname == get_argyll_utilname("dispcal") and ( "-r" in args or "-z" in args ) if self.measure_cmd and not dry_run and sys.platform not in ("darwin", "win32"): # Inhibit session to prevent screensaver/powersaving etc. # Useful commands to figure out list of DBus interfaces: # dbus-send [--session|--system] \ # --dest=org.freedesktop.DBus \ # --type=method_call \ # --print-reply \ # /org/freedesktop/DBus \ # org.freedesktop.DBus.ListNames if dbus_session: desktop = os.getenv("XDG_CURRENT_DESKTOP", "").split(":") inhibit_reason = "Display device measurements" gnome_sm = "org.gnome.SessionManager" gnome_sm_xid = 0 # GNOME SessionManager.Inhibit flags: # 1 Inhibit logging out # 2 Inhibit user switching # 4 Inhibit suspending # 8 Inhibit idle gnome_sm_flags = 1 | 2 | 4 | 8 ifaces = getattr(self, "dbus_ifaces", None) if not ifaces: ifaces = dict( [ ( gnome_sm, { "args": ( gnome_sm_xid, inhibit_reason, gnome_sm_flags, ), "uninhibit": "uninhibit", }, ), ("org.freedesktop.ScreenSaver", {"precedence": [gnome_sm]}), ( "org.freedesktop.PowerManagement.Inhibit", {"precedence": [gnome_sm]}, ), ] ) self.dbus_ifaces = ifaces for bus_name in ifaces: iface_dict = ifaces[bus_name] if bus_name.startswith("org.freedesktop."): skip = False for precedence in iface_dict.get("precedence", []): if ifaces[precedence].get("cookie"): # Already took care of inhibit skip = True break if skip: continue else: iface_domain = bus_name.split(".")[1] if iface_domain.upper() not in desktop: # Not current desktop environment continue object_path = "/" + bus_name.replace(".", "/") other_path = iface_dict.get("path") if other_path: if other_path.startswith("/"): object_path = other_path else: object_path += "/" + other_path if iface_dict.get("cookie"): continue try: iface = iface_dict.get("iface") if not iface: iface = DBusObject(BUSTYPE_SESSION, bus_name, object_path) cookie = iface.inhibit( appname, *iface_dict.get("args", (inhibit_reason,)) ) except DBusException as exception: # The user might be running a minimal Wayland environment # without a screensaver or power management daemon self.log( f"{appname}: Warning - could not inhibit " f"{bus_name}: {exception}" ) continue # Skip to the next interface iface_dict["iface"] = iface iface_dict["cookie"] = cookie self.log(f"{appname}: Inhibited {bus_name}") else: self.log( f"{appname}: Warning - no D-Bus session bus - " "cannot inhibit session, screensaver/powersaving may " "still be active!" ) profiling_inhibit = False display_profile = None if ( sys.platform not in ("darwin", "win32") and self.measure_cmd and self._use_patternwindow and not dry_run and not report_current_cal ): # Preliminary Wayland support. This still needs a lot # of work as Argyll doesn't support Wayland natively yet, # so we use virtual display to drive our own patch window. # We need to make sure videoLUT is linear. Only way to # achieve this currently under Wayland is by using colord. # Inhibit display device to reset videoLUT to linear and profile # to none device_id = self.get_device_id(query=True) object_path = None if device_id: try: object_path = colord.get_object_path(device_id, "device") except colord.CDError as exception: self.log(exception) else: self.log( f"{appname}: Warning - couldn't get display device ID - " "cannot inhibit display device!" ) if dbus_system and object_path: # Use DBus interface to call ProfilingInhibit() try: cd_device = colord.Device(object_path) cd_device.profiling_inhibit() except (colord.CDError, DBusException) as exception: self.log(f"{appname}: Warning - Handled exception: {exception}") else: profiling_inhibit = True self.log(f"{appname}: Inhibited display device", object_path) elif object_path: self.log( f"{appname}: Warning - no D-Bus system bus - " "cannot inhibit display device!" ) if not profiling_inhibit: # Fallback - install linear cal sRGB profile self.log(f"{appname}: Temporarily installing sRGB profile...") display_profile = config.get_display_profile() self.srgb = srgb = ICCProfile.from_named_rgb_space("sRGB") # Date should not change so the ID stays the same. srgb.dateTime = datetime.datetime(2003, 0o1, 23, 0, 0, 0) srgb.tags.vcgt = VideoCardGammaTableType("", "vcgt") srgb.tags.vcgt.update( { "channels": 3, "entryCount": 256, "entrySize": 1, "data": [ list(range(0, 256)), list(range(0, 256)), list(range(0, 256)), ], } ) srgb.setDescription(f"{appname} Linear Calibration sRGB Profile") srgb.calculateID() srgb.write( os.path.join( self.tempdir, f"{appname} Linear Calibration sRGB Profile.icc" ) ) cdinstall = self._attempt_install_profile_colord(srgb) if not cdinstall: return Error(lang.getstr("calibration.reset_error")) elif isinstance(cdinstall, Exception): return UnloggedError(safe_str(cdinstall)) self.log(f"{appname}: Successfully assigned sRGB profile") self.use_patterngenerator = ( self.measure_cmd and cmdname != get_argyll_utilname("spotread") and ( config.get_display_name() == "Resolve" or ( config.get_display_name() == "Prisma" and not defaults["patterngenerator.prisma.argyll"] ) or self._use_patternwindow ) ) use_3dlut_override = ( ( ( self.use_patterngenerator and config.get_display_name(None, True) == "Prisma" ) or ( config.get_display_name(None, True) == "madVR" and (sys.platform != "win32" or not getcfg("madtpg.native")) ) ) and cmdname == get_argyll_utilname("dispread") and "-V" in args ) if use_3dlut_override: args.remove("-V") working_basename = None if args and args[-1].find(os.path.sep) > -1: working_basename = os.path.basename(args[-1]) if cmdname not in ( get_argyll_utilname("dispcal"), get_argyll_utilname("dispread"), get_argyll_utilname("colprof"), get_argyll_utilname("targen"), get_argyll_utilname("txt2ti3"), ): # Last arg is with extension working_basename = os.path.splitext(working_basename)[0] if working_dir is None: working_dir = os.path.dirname(args[-1]) if working_dir is None: if self.use_patterngenerator: working_dir = self.create_tempdir() else: working_dir = self.tempdir if working_dir and not os.path.isdir(working_dir): working_dir = None if working_dir and working_dir == self.tempdir: # Get a list of files in the temp directory and their modification # times so we can determine later if anything has changed and we # should keep the files in case of errors for filename in os.listdir(working_dir): self.tmpfiles[filename] = os.stat( os.path.join(working_dir, filename) ).st_mtime if ( working_basename and working_dir == self.tempdir and not silent and log_output and not dry_run ): self.set_sessionlogfile(sessionlogfile, working_basename, working_dir) if not silent or verbose >= 3: self.log("-" * 80) if self.sessionlogfile: print("Session log:", self.sessionlogfile.filename) print("") use_madvr = ( cmdname in ( get_argyll_utilname("dispcal"), get_argyll_utilname("dispread"), get_argyll_utilname("dispwin"), ) and get_arg("-dmadvr", args) and madvr ) self.use_madvr = use_madvr madvr_use_virtual_display = ( use_madvr and self.argyll_virtual_display and (sys.platform != "win32" or getcfg("patterngenerator.ffp_insertion")) ) if use_madvr: # Try to connect to running madTPG or launch a new instance try: if self.madtpg_connect(): # Connected if ( isinstance(self.madtpg, madvr.MadTPG_Net) or madvr_use_virtual_display ): # Need to handle calibration clearing/loading/saving # for madVR net-protocol pure python implementation cal = None calfilename = None profile = None ramp = False if cmdname == get_argyll_utilname("dispwin"): if "-c" in args: # Clear calibration self.log("MadTPG_Net clear calibration") ramp = None if "-L" in args: # NOTE: Hmm, profile will be None. It's not # functionality we currently use though. profile = config.get_display_profile() if "-s" in args: # Save calibration. Get from madTPG self.log("MadTPG_Net save calibration:", args[-1]) ramp = self.madtpg.get_device_gamma_ramp() if not ramp: self.madtpg_disconnect(False) return Error("madVR_GetDeviceGammaRamp failed") cal = """CAL KEYWORD "DEVICE_CLASS" DEVICE_CLASS "DISPLAY" KEYWORD "COLOR_REP" COLOR_REP "RGB" BEGIN_DATA_FORMAT RGB_I RGB_R RGB_G RGB_B END_DATA_FORMAT NUMBER_OF_SETS 256 BEGIN_DATA """ # Convert ushort_Array_256_Array_3 to dictionary RGB = {} for j in range(3): for i in range(256): if i not in RGB: RGB[i] = [] RGB[i].append(ramp[j][i] / 65535.0) # Get RGB from dictionary for i in RGB: R, G, B = RGB[i] cal += "{:f} {:f} {:f} {:f}\n".format( i / 255.0, R, G, B ) cal += "END_DATA" # Write out .cal file try: with open(args[-1], "w") as calfile: calfile.write(cal) except OSError as exception: self.madtpg_disconnect(False) return exception cal = None ramp = False elif working_basename: # .cal/.icc/.icm file to load calfilename = args[-1] elif cmdname == get_argyll_utilname("dispread"): # Check for .cal file to load # NOTE this isn't normally used as we use -K # for madTPG, but is overridable by the user k_arg = get_arg("-k", args, True) if k_arg: calfilename = args[k_arg[0] + 1] else: ramp = None else: # dispcal ramp = None if calfilename: # Load calibration from cal file or ICC profile self.log("MadTPG_Net load calibration:", calfilename) result = check_file_isfile(calfilename) if isinstance(result, Exception): self.madtpg_disconnect(False) return result if calfilename.lower().endswith(".cal"): # .cal file try: cal = CGATS(calfilename) except (IOError, CGATSError) as exception: self.madtpg_disconnect(False) return exception else: # ICC profile try: profile = ICCProfile(calfilename) except ( IOError, ICCProfileInvalidError, ) as exception: self.madtpg_disconnect(False) return exception if profile: # Load calibration from ICC profile (if present) cal = extract_cal_from_profile(profile, None, False) if not cal: # Linear ramp = None if cal: # Check calibration we're going to load try: cal = verify_cgats(cal, ("RGB_R", "RGB_G", "RGB_B")) if len(cal.DATA) != 256: # Needs to have 256 entries raise CGATSError( "{}: {} != 256".format( lang.getstr("calibration"), lang.getstr("number_of_entries"), ) ) except CGATSError as exception: self.madtpg_disconnect(False) return exception # Convert calibration to ushort_Array_256_Array_3 ramp = ((ctypes.c_ushort * 256) * 3)() for i in range(256): for j, channel in enumerate("RGB"): ramp[j][i] = int( round(cal.DATA[i]["RGB_" + channel] * 65535) ) else: ramp = None if ramp is not False and not self.madtpg.set_device_gamma_ramp( ramp ): self.madtpg_disconnect(False) return Error("madVR_SetDeviceGammaRamp failed") if ( isinstance(self.madtpg, madvr.MadTPG_Net) or madvr_use_virtual_display ) and cmdname == get_argyll_utilname("dispwin"): # For madVR net-protocol pure python implementation # we are now done if "-s" not in args: # Only disconnect if we didn't save calibration (as # part of a follow-up measurement) self.madtpg_disconnect(False) return True if "-V" not in args and not use_3dlut_override: endis = "disable" else: endis = "enable" if not getattr(self.madtpg, endis + "_3dlut")(): self.madtpg_disconnect(False) return Error("madVR_{}3dlut failed".format(endis.capitalize())) fullscreen = self.madtpg.is_use_fullscreen_button_pressed() if sys.platform == "win32": # Make sure interactive display adjustment window isn't # concealed by temporarily disabling fullscreen if # needed. This is only a problem in single display # configurations. if self.single_real_display(): # We only have one "real" display connected if cmdname == get_argyll_utilname("dispcal") or ( self.dispread_after_dispcal and cmdname == get_argyll_utilname("dispread") and self._detecting_video_levels ): if ( getcfg("calibration.interactive_display_adjustment") and not getcfg("calibration.update") and fullscreen ): # Disable fullscreen if self.madtpg.set_use_fullscreen_button(False): self.log( "Temporarily leaving madTPG fullscreen" ) self.madtpg_previous_fullscreen = fullscreen else: self.log( "Warning - couldn't " "temporarily leave madTPG " "fullscreen" ) elif ( getattr(self, "madtpg_previous_fullscreen", None) and cmdname == get_argyll_utilname("dispread") and self.dispread_after_dispcal ): # Restore fullscreen if self.madtpg.set_use_fullscreen_button(True): self.log("Restored madTPG fullscreen") self.madtpg_previous_fullscreen = None else: self.log( "Warning - couldn't restore madTPG fullscreen" ) self.madtpg_fullscreen = ( self.madtpg.is_use_fullscreen_button_pressed() ) # IMPORTANT: When making changes to the instrument on screen # detection, also apply them to appropriate part in # Worker.check_instrument_place_on_screen if ( ( not ( cmdname == get_argyll_utilname("dispwin") or self.dispread_after_dispcal ) or ( cmdname == get_argyll_utilname("dispcal") and ("-m" in args or "-u" in args) ) or self._detecting_video_levels ) and self.madtpg_fullscreen and not self.instrument_on_screen ): # Show place instrument on screen message with countdown countdown = 15 # We need to show the progress bar to make OSD visible if not self.madtpg.show_progress_bar(countdown): self.madtpg_disconnect() return Error("madVR_ShowProgressBar failed") self.madtpg_osd = ( not self.madtpg.is_disable_osd_button_pressed() ) if not self.madtpg_osd: # Enable OSD if disabled if self.madtpg.set_disable_osd_button(False): self.log( "Temporarily enabled madTPG OSD for " "instrument placement countdown" ) else: self.log( "Warning - couldn't temporarily enable madTPG OSD" ) for i in range(countdown): if self.subprocess_abort: break if not self.madtpg.set_osd_text( lang.getstr( "instrument.place_on_screen.madvr", (countdown - i, self.get_instrument_name()), ) ): self.madtpg_disconnect() return Error("madVR_SetOsdText failed") ts = time() if i % 2 == 0: # Flash test area red self.madtpg.show_rgb(0.25, 0.10, 0.10) else: self.madtpg.show_rgb(0.15, 0.15, 0.15) delay = time() - ts if delay < 1: sleep(1 - delay) self.instrument_on_screen = True if not self.madtpg_osd: # Disable OSD if self.madtpg.set_disable_osd_button(True): self.log("Restored madTPG 'Disable OSD' button state") self.madtpg_osd = None else: self.log( "Warning - could not restore madTPG " "'Disable OSD' button state" ) self.madtpg.set_osd_text("\u25b6") # "Play" symbol self.madtpg.show_rgb(0.5, 0.5, 0.5) # Get black and white level self.madtpg_bw_lvl = self.madtpg.get_black_and_white_level() if not self.madtpg_bw_lvl: self.log("madVR_GetBlackAndWhiteLevel failed") else: self.log("Output levels: {}-{}".format(self.madtpg_bw_lvl)) # Get pattern config patternconfig = self.madtpg.get_pattern_config() if ( not patternconfig or not isinstance(patternconfig, tuple) or len(patternconfig) != 4 ): self.madtpg_disconnect() return Error("madVR_GetPatternConfig failed") self.log("Pattern area: {:d}%".format(patternconfig[0])) self.log("Background level: {:d}%".format(patternconfig[1])) self.log( "Background mode: {}".format( {0: "Constant", 1: "APL gamma", 2: "APL linear"}.get( patternconfig[2], patternconfig[2] ) ) ) self.log("Border width: {:d} pixels".format(patternconfig[3])) if ( isinstance(self.madtpg, madvr.MadTPG_Net) or madvr_use_virtual_display ): dindex = args.index("-dmadvr") args.remove("-dmadvr") if madvr_use_virtual_display: args.insert( dindex, "-d{}".format(self.argyll_virtual_display) ) else: args.insert(0, "-P1,1,0.01") else: # Only if using native madTPG implementation! if not get_arg("-P", args): # Setup patch size to match pattern config args.insert( 0, "-P0.5,0.5,{:f}".format(math.sqrt(patternconfig[0])) ) if not patternconfig[1] and self.argyll_version >= [1, 7]: # Setup black background if background level is zero. # Only do this for Argyll >= 1.7 to prevent messing # with pattern area when Argyll 1.6.x is used args.insert(0, "-F") self.log("") else: return Error(lang.getstr("madtpg.launch.failure")) except Exception as exception: if isinstance(getattr(self, "madtpg", None), madvr.MadTPG_Net) or ( getattr(self, "madtpg", None) and madvr_use_virtual_display ): self.madtpg_disconnect() return exception # Use mad* net protocol pure python implementation use_madnet = use_madvr and ( isinstance(self.madtpg, madvr.MadTPG_Net) or madvr_use_virtual_display ) # Use mad* net protocol pure python implementation as pattern generator self.use_madnet_tpg = use_madnet and cmdname != get_argyll_utilname("dispwin") if self.use_patterngenerator or self.use_madnet_tpg: # Run a dummy command so we can grab the RGB numbers for # the pattern generator from the output carg = get_arg("-C", args, True) if carg: index = min(carg[0] + 1, len(args) - 1) args[index] += " && " else: args.insert(0, "-C") args.insert(1, "") index = 1 python, pythonpath = get_python_and_pythonpath() script_dir = working_dir pythonscript = WAIT_FILE_TEMPLATE.format(script_dir=script_dir) waitfilename = os.path.join(script_dir, ".wait") if sys.platform == "win32": # Avoid problems with encoding python = win32api.GetShortPathName(python) for i, path in enumerate(pythonpath): if os.path.exists(path): pythonpath[i] = win32api.GetShortPathName(path) # Write out .wait.py file scriptfilename = f"{waitfilename}.py" with open(scriptfilename, "w", encoding="utf-8") as scriptfile: scriptfile.write(pythonscript) scriptfilename = win32api.GetShortPathName(scriptfilename) # Write out .wait.cmd file with open(f"{waitfilename}.cmd", "w", encoding="utf-8") as waitfile: waitfile.write("@echo off\n") waitfile.write("echo.\n") waitfile.write("echo Current RGB %*\n") waitfile.write( 'set "PYTHONPATH={}"\n'.format( safe_str(os.pathsep.join(pythonpath)), enc ) ) waitfile.write( '"{}" -S "{}" %*\n'.format( safe_str(python, enc), safe_str(scriptfilename, enc) ) ) args[index] += waitfilename else: # Write out .wait file with open(waitfilename, "w") as waitfile: waitfile.write(f"#!/usr/bin/env python3\n{pythonscript}") os.chmod(waitfilename, 0o755) args[index] += "{} ./{}".format( strtr(safe_str(python), {'"': r"\"", "$": r"\$"}), os.path.basename(waitfilename), ) if verbose >= 1 or not silent: if not silent or verbose >= 3: if not silent and dry_run and not self.cmdrun: print(lang.getstr("dry_run")) print("") self.cmdrun = True if working_dir: self.log(lang.getstr("working_dir")) indent = " " for name in working_dir.split(os.path.sep): self.log( textwrap.fill( name + os.path.sep, 80, expand_tabs=False, replace_whitespace=False, initial_indent=indent, subsequent_indent=indent, ) ) indent += " " self.log("") self.log(lang.getstr("commandline")) printcmdline(cmd, args, fn=self.log, cwd=working_dir) self.log("") if not silent and dry_run: if not self.lastcmdname or self.lastcmdname == cmdname: print(lang.getstr("dry_run.end")) if self.owner and hasattr(self.owner, "infoframe_toggle_handler"): wx.CallAfter(self.owner.infoframe_toggle_handler, show=True) if use_madnet: self.madtpg_disconnect() return UnloggedInfo(lang.getstr("dry_run.info")) cmdline = [cmd] + args for i, item in enumerate(cmdline): if i > 0 and item.find(os.path.sep) > -1: if sys.platform == "win32": item = make_win32_compatible_long_path(item) if ( re.search(r"[^\x20-\x7e]", os.path.basename(item)) and os.path.exists(item) and i < len(cmdline) - 1 ): # Avoid problems with encoding under Windows by using # GetShortPathName, but be careful with the last # parameter which may be used as the basename for the # output file item = win32api.GetShortPathName(item) if working_dir and os.path.dirname(cmdline[i]) == working_dir: # Strip the path from all items in the working dir item = os.path.basename(item) if item != cmdline[i]: cmdline[i] = item if ( working_dir and sys.platform == "win32" and re.search(r"[^\x20-\x7e]", working_dir) and os.path.exists(working_dir) ): # Avoid problems with encoding working_dir = win32api.GetShortPathName(working_dir) sudo = None if asroot and ( (sys.platform != "win32" and os.geteuid() != 0) or (sys.platform == "win32" and sys.getwindowsversion() >= (6,)) ): if sys.platform == "win32": # Vista and later pass else: if not self.auth_timestamp: if hasattr(self, "thread") and self.thread.is_alive(): # Careful: We can only show the auth dialog if running # in the main GUI thread! if use_madnet: self.madtpg_disconnect() return Error("Authentication requested in non-GUI thread") result = self.authenticate(cmd, title, parent) if result is False: if use_madnet: self.madtpg_disconnect() return None elif isinstance(result, Exception): if use_madnet: self.madtpg_disconnect() return result sudo = str(self.sudo) if sudo: if not use_pty: # Sudo may need a tty depending on configuration use_pty = True cmdline.insert(0, sudo) if ( cmdname == get_argyll_utilname("dispwin") and sys.platform != "darwin" and self.sudo.availoptions.get("E") and getcfg("sudo.preserve_environment") ): # Preserve environment so $DISPLAY is set cmdline.insert(1, "-E") if not use_pty: cmdline.insert(1, "-S") # Set empty string as password prompt to hide it from stderr cmdline.insert(1, "") cmdline.insert(1, "-p") else: # Use a designated prompt cmdline.insert(1, "Password:") cmdline.insert(1, "-p") if ( working_dir and working_basename and not skip_scripts and not getcfg("skip_scripts") ): try: cmdfilename = os.path.join( working_dir, working_basename + "." + cmdname + script_ext ) allfilename = os.path.join( working_dir, working_basename + ".all" + script_ext ) first = not os.path.exists(allfilename) last = cmdname == get_argyll_utilname("dispwin") cmdfile = open(cmdfilename, "w") allfile = open(allfilename, "a") cmdfiles = Files((cmdfile, allfile)) if first: context = cmdfiles else: context = cmdfile if sys.platform == "win32": context.write("@echo off\n") context.write( ("PATH {};%PATH%\n".format(os.path.dirname(cmd))).encode( enc, "safe_asciize" ) ) cmdfiles.write('pushd "%~dp0"\n'.encode(enc, "safe_asciize")) if cmdname in ( get_argyll_utilname("dispcal"), get_argyll_utilname("dispread"), ): cmdfiles.write("color 07\n") else: context.write( ( "PATH={}:$PATH\n".format(os.path.dirname(cmd)).encode( enc, "safe_asciize" ) ) ) if sys.platform == "darwin" and config.mac_create_app: cmdfiles.write('pushd "`dirname \\"$0\\"`/../../.."\n') else: cmdfiles.write('pushd "`dirname \\"$0\\"`"\n') if ( cmdname in ( get_argyll_utilname("dispcal"), get_argyll_utilname("dispread"), ) and sys.platform != "darwin" ): cmdfiles.write('echo -e "\\033[40;2;37m" && clear\n') os.chmod(cmdfilename, 0o755) os.chmod(allfilename, 0o755) cmdfiles.write( " ".join(quote_args(cmdline)) .replace(cmd, cmdname) .encode(enc, "safe_asciize") + "\n".encode() ) if sys.platform == "win32": cmdfiles.write("set exitcode=%errorlevel%\n") if cmdname in ( get_argyll_utilname("dispcal"), get_argyll_utilname("dispread"), ): # Reset to default commandline shell colors cmdfiles.write("color\n") cmdfiles.write("popd\n") cmdfiles.write("if not %exitcode%==0 exit /B %exitcode%\n") else: cmdfiles.write("exitcode=$?\n") if ( cmdname in ( get_argyll_utilname("dispcal"), get_argyll_utilname("dispread"), ) and sys.platform != "darwin" ): # reset to default commandline shell colors cmdfiles.write('echo -e "\\033[0m" && clear\n') cmdfiles.write("popd\n") cmdfiles.write("if [ $exitcode -ne 0 ]; then exit $exitcode; fi\n") cmdfiles.close() if sys.platform == "darwin": if config.mac_create_app: # Could also use .command file directly, but using # applescript allows giving focus to the terminal # window automatically after a delay script = ( mac_terminal_do_script() + mac_terminal_set_colors(do=False) + [ "-e", "set shellscript to quoted form of " "(POSIX path of (path to resource " '"main.command"))', "-e", 'tell app "Terminal"', "-e", "do script shellscript in first window", "-e", "delay 3", "-e", "activate", "-e", "end tell", "-o", ] ) # Part 1: "cmdfile" appfilename = os.path.join( working_dir, working_basename + "." + cmdname + ".app" ) cmdargs = ["osacompile"] + script + [appfilename.decode()] p = sp.Popen( cmdargs, stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE ) p.communicate() shutil.move( cmdfilename, appfilename + "/Contents/Resources/main.command", ) os.chmod( appfilename + "/Contents/Resources/main.command", 0o755 ) # Part 2: "allfile" appfilename = os.path.join( working_dir, working_basename + ".all.app" ) cmdargs = ["osacompile"] + script + [appfilename] p = sp.Popen( cmdargs, stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE ) p.communicate() shutil.copyfile( allfilename, appfilename + "/Contents/Resources/main.command", ) os.chmod( appfilename + "/Contents/Resources/main.command", 0o755 ) if last: os.remove(allfilename) except Exception as exception: self.log( "Warning - error during shell script creation:", str(exception) ) cmdline = [safe_str(arg, fs_enc) for arg in cmdline] working_dir = None if not working_dir else working_dir try: if not self.measure_cmd and self.argyll_version >= [1, 2]: # Argyll tools will no longer respond to keys if debug: self.log("[D] Setting ARGYLL_NOT_INTERACTIVE 1") os.environ["ARGYLL_NOT_INTERACTIVE"] = "1" elif "ARGYLL_NOT_INTERACTIVE" in os.environ: del os.environ["ARGYLL_NOT_INTERACTIVE"] if debug: self.log("[D] argyll_version", self.argyll_version) self.log( "[D] ARGYLL_NOT_INTERACTIVE", os.environ.get("ARGYLL_NOT_INTERACTIVE"), ) if self.measure_cmd: if isinstance(self.measurement_sound, audio.DummySound): self._init_sounds(dummy=False) for name, version in ( ("MIN_DISPLAY_UPDATE_DELAY_MS", [1, 5]), ("DISPLAY_SETTLE_TIME_MULT", [1, 7]), ): backup = os.getenv(f"ARGYLL_{name}_BACKUP") value = None if ( getcfg(f"measure.override_{name.lower()}") and self.argyll_version >= version ): if backup is None: # Backup current value if any current = os.getenv(f"ARGYLL_{name}", "") os.environ[f"ARGYLL_{name}_BACKUP"] = current else: current = backup if current: self.log(f"{appname}: Overriding ARGYLL_{name} {current}") # Override value = str(getcfg(f"measure.{name.lower()}")) self.log(f"{appname}: Setting ARGYLL_{name} {value}") elif backup is not None: value = backup del os.environ[f"ARGYLL_{name}_BACKUP"] if value: self.log(f"{appname}: Restoring ARGYLL_{name} {value}") elif f"ARGYLL_{name}" in os.environ: del os.environ[f"ARGYLL_{name}"] elif f"ARGYLL_{name}" in os.environ: self.log( f"{appname}: ARGYLL_{name}", os.getenv(f"ARGYLL_{name}"), ) if value: os.environ[f"ARGYLL_{name}"] = value elif cmdname in ( get_argyll_utilname("iccgamut"), get_argyll_utilname("tiffgamut"), get_argyll_utilname("viewgam"), get_argyll_utilname("colprof"), get_argyll_utilname("collink"), ): os.environ["ARGYLL_3D_DISP_FORMAT"] = "VRML" if sys.platform not in ("darwin", "win32"): os.environ["ENABLE_COLORHUG"] = "1" if sys.platform == "win32": startupinfo = sp.STARTUPINFO() startupinfo.dwFlags |= sp.STARTF_USESHOWWINDOW startupinfo.wShowWindow = sp.SW_HIDE else: startupinfo = None if not use_pty: data_encoding = enc if silent: stderr = sp.STDOUT else: stderr = tempfile.SpooledTemporaryFile() if capture_output: stdout = tempfile.SpooledTemporaryFile() elif ( sys.stdout and hasattr(sys.stdout, "isatty") and sys.stdout.isatty() ): stdout = sys.stdout else: stdout = sp.PIPE if sudo: stdin = tempfile.SpooledTemporaryFile() stdin.write(self.pwd.encode(enc, "replace") + os.linesep) stdin.seek(0) else: stdin = sp.PIPE else: data_encoding = self.pty_encoding kwargs = dict(timeout=20, cwd=working_dir, env=os.environ) if sys.platform == "win32": # FIX: stdio cp1252 vs utf-8 (cp65001) issue under Windows 10/11+ # os.environ["PYTHONLEGACYWINDOWSSTDIO"] = "1" kwargs["codepage"] = windll.kernel32.GetACP() # As Windows' console always hard wraps at the # rightmost column, increase the buffer width kwargs["columns"] = 160 stderr = None stdout = EncodedWriter(StringIO(), None, data_encoding) logfiles = [] if ( hasattr(self, "thread") and self.thread.is_alive() and self.interactive and getattr(self, "terminal", None) ): logfiles.append( FilteredStream( self.terminal, discard="", triggers=self.triggers ) ) if log_output: linebuffered_logfiles = [] if ( sys.stdout and hasattr(sys.stdout, "isatty") and sys.stdout.isatty() ): linebuffered_logfiles.append(print) else: linebuffered_logfiles.append(log) if self.sessionlogfile: linebuffered_logfiles.append(self.sessionlogfile) logfiles.append( LineBufferedStream( FilteredStream( Files(linebuffered_logfiles), data_encoding, discard="", linesep_in="\n", triggers=[], ) ) ) logfiles.append(stdout) if hasattr(self, "thread") and self.thread.is_alive(): logfiles.extend([self.recent, self.lastmsg, self]) logfiles = Files(logfiles) if self.use_patterngenerator: pgname = config.get_display_name() self.setup_patterngenerator(logfiles) if not hasattr(self.patterngenerator, "conn") and hasattr( self.patterngenerator, "wait" ): # Wait for connection - blocking self.patterngenerator.wait() if hasattr(self.patterngenerator, "conn"): self.patterngenerator_send( (0.5,) * 3, increase_sent_count=False ) else: # User aborted before connection was established return False if pgname == "Prisma": x, y, w, h, size = get_pattern_geometry() if use_3dlut_override: self.patterngenerator.enable_processing(size=size * 100) else: self.patterngenerator.disable_processing(size=size * 100) tries = 1 while tries > 0: if self.subprocess_abort: break if use_pty: if ( self.argyll_version >= [1, 2] and USE_WPOPEN and os.environ.get("ARGYLL_NOT_INTERACTIVE") ): self.subprocess = WPopen( cmdline, stdin=sp.PIPE, stdout=tempfile.SpooledTemporaryFile(), stderr=sp.STDOUT, shell=shell, cwd=working_dir, startupinfo=startupinfo, ) else: # Minimum Windows version: XP or Server 2003 if sys.platform == "win32" and sys.getwindowsversion() < (5, 1): raise Error(lang.getstr("windows.version.unsupported")) try: self.subprocess = wexpect.spawn( cmdline[0], cmdline[1:], **kwargs ) except wexpect.ExceptionPexpect as exception: self.retcode = -1 raise Error(str(exception)) if sys.platform == "darwin" and self.measure_cmd: # Caffeinate (prevent sleep/screensaver) caffeinate = which("caffeinate") if caffeinate: wait_pid = str(self.subprocess.pid) try: # -d prevent idle display sleep # -i prevent idle system sleep # -w wait for process to exit caffeinated = sp.Popen( [caffeinate, "-d", "-i", "-w", wait_pid], stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE, ) except Exception as exception: self.log( f"{appname}: caffeinate could not " "be started - screensaver and " "display/system sleep may still " "occur!" ) self.log(exception) else: self.log( f"{appname}: caffeinate started, " "preventing screensaver and " "display/system sleep - waiting " "for {} (PID {}) to exit".format( cmdname, wait_pid ) ) def caffeinate_wait(): caffeinated.wait() self.log( f"{appname}: caffeinate exited " "with code {}".format( caffeinated.returncode ) ) wait_thread = threading.Thread( target=caffeinate_wait ) wait_thread.daemon = True wait_thread.start() else: self.log( f"{appname}: caffeinate not found - " "screensaver and display/system sleep " "may still occur!" ) if debug >= 9 or (test and "-?" not in args): self.subprocess.interact() self.subprocess.logfile_read = logfiles if self.measure_cmd: keyhit_strs = [" or Q to ", r"8\) Exit"] patterns = keyhit_strs + ["Current", r" \d+ of \d+"] self.log(f"{appname}: Starting interaction with subprocess") else: patterns = [] self.log(f"{appname}: Waiting for EOF") loop = 0 pwdsent = False authfailed = False eof = False while 1: if loop < 1 and sudo: curpatterns = ["Password:"] + patterns else: curpatterns = patterns # NOTE: Using a timeout of None can block indefinitely # and prevent expect() from ever returning! self.subprocess.expect( curpatterns + [wexpect.EOF, wexpect.TIMEOUT], timeout=1 ) if self.subprocess.after is wexpect.EOF: self.log(f"{appname}: Reached EOF (OK)") break elif self.subprocess.after is wexpect.TIMEOUT: if not self.subprocess.isalive(): self.log( f"{appname}: Subprocess no longer alive (timeout)" ) if eof: break eof = True continue elif self.subprocess.after == "Password:" and loop < 1 and sudo: if pwdsent: self.subprocess.sendcontrol("C") authfailed = True self.auth_timestamp = 0 else: self._safe_send( self.pwd + os.linesep, obfuscate=True, ) pwdsent = True if not self.subprocess.isalive(): break continue elif self.measure_cmd: if [ keyhit_str for keyhit_str in keyhit_strs if re.search(keyhit_str, self.subprocess.after) ]: # Wait for the keypress self.log(f"{appname}: Waiting for send buffer") while not self.send_buffer: if not self.subprocess.isalive(): self.log( f"{appname}: Subprocess no longer alive (unknown reason)" ) break sleep(0.05) self.log( f"{appname}: Send buffer received: {self.send_buffer}" ) if ( self.send_buffer is not None and self.subprocess.isalive() ): if ( self.send_buffer == "7" and use_madvr and cmdname == get_argyll_utilname("dispcal") ): # Restore madTPG OSD and fullscreen self.madtpg_restore_settings(False) self.log( f"{appname}: Sending buffer: {self.send_buffer}" ) self._safe_send(self.send_buffer) self.send_buffer = None if not self.subprocess.isalive(): break loop += 1 # We need to call isalive() to set the exitstatus. # We can't use wait() because it might block in the # case of a timeout if self.subprocess.isalive(): self.log(f"{appname}: Checking subprocess status") while self.subprocess.isalive(): sleep(0.1) self.log(f"{appname}: Subprocess no longer alive (OK)") self.retcode = self.subprocess.exitstatus if authfailed: raise Error(lang.getstr("auth.failed")) else: try: if ( asroot and sys.platform == "win32" and sys.getwindowsversion() >= (6,) ): p = run_as_admin(cmd, args, close_process=False, show=False) while not self.subprocess_abort: # Wait for subprocess to exit self.retcode = win32event.WaitForSingleObject( p["hProcess"], 50 ) if not self.retcode: break p["hProcess"].Close() return self.retcode == 0 else: self.subprocess = sp.Popen( cmdline, stdin=stdin, stdout=stdout, stderr=stderr, shell=shell, cwd=working_dir, startupinfo=startupinfo, ) except Exception as exception: self.retcode = -1 raise Error(str(exception)) self.retcode = self.subprocess.wait() if stdin != sp.PIPE and not getattr(stdin, "closed", True): stdin.close() if self.is_working() and self.subprocess_abort and self.retcode == 0: self.retcode = -1 self.subprocess = None tries -= 1 if not silent and stderr: stderr.seek(0) errors = stderr.readlines() if not capture_output or stderr is not stdout: stderr.close() if len(errors): for line in errors: if isinstance(line, bytes): line = line.decode() line = line.strip() if ( "Instrument Access Failed" in line and "-N" in cmdline[:-1] ): cmdline.remove("-N") tries = 1 break if ( line.find("User Aborted") < 0 and line.find( "XRandR 1.2 is faulty - falling back " "to older extensions" ) < 0 ): self.errors.append(line) if tries > 0 and not use_pty: stderr = tempfile.SpooledTemporaryFile() if capture_output or use_pty: stdout.seek(0) stdout_readlines = stdout.readlines() self.output = [] for line in stdout_readlines: if isinstance(line, bytes): line = line.decode() line = line.strip() line = re.sub(r"^\.{4,}\s*$", "", line).strip() self.output.append(line) stdout.close() if len(self.output) and log_output: if not use_pty: self.log("".join(self.output).strip()) if ( display_output and self.owner and hasattr(self.owner, "infoframe_toggle_handler") ): wx.CallAfter(self.owner.infoframe_toggle_handler, show=True) if tries > 0 and not use_pty: stdout = tempfile.SpooledTemporaryFile() if not silent and len(self.errors): errstr = "".join(self.errors).strip() self.log(errstr) except (Error, socket.error, EnvironmentError, RuntimeError) as exception: return exception except Exception: if debug: self.log("[D] working_dir:", working_dir) # TODO: Fix this in the source of the problem, not here!!! new_cmdline = [] for item in cmdline: if isinstance(item, bytes): item = item.decode() new_cmdline.append(item) cmdline = new_cmdline errmsg = " ".join(cmdline) + "\n" + str(traceback.format_exc()) self.retcode = -1 return Error(errmsg) finally: if ( sudo and cmdname not in ("chown", get_argyll_utilname("dispwin")) and working_dir and working_dir == self.tempdir and os.listdir(working_dir) ): # We need to take ownership of any files created by commands # run via sudo otherwise we cannot move or remove them from # the temporary directory! errors = self.errors output = self.output retcode = self.retcode self.exec_cmd( "chown", ["-R", getpass.getuser().decode(fs_enc), working_dir], capture_output=capture_output, skip_scripts=True, asroot=True, ) self.errors = errors self.output = output self.retcode = retcode finished = ( (self.cmdname == "dispcal" and not self.dispread_after_dispcal) or (self.cmdname == "dispread" and not self._detecting_video_levels) or self.retcode ) if self.patterngenerator: if hasattr(self.patterngenerator, "conn"): try: if config.get_display_name() == "Resolve": # Send fullscreen black to prevent burn-in if finished: try: self.patterngenerator.send( (0,) * 3, x=0, y=0, w=1, h=1 ) except socket.error: pass else: self.patterngenerator.disconnect_client() except Exception as exception: self.log(exception) if hasattr(self, "madtpg") and finished: self.madtpg_disconnect() if ( sys.platform not in ("darwin", "win32") and self.measure_cmd and self._use_patternwindow and (profiling_inhibit or display_profile) and not report_current_cal ): # Preliminary Wayland support. This still needs a lot # of work as Argyll doesn't support Wayland natively yet, # so we use virtual display to drive our own patch window. # We need to restore the display profile. if profiling_inhibit: # Use DBus interface to call ProfilingInhibit() try: cd_device.profiling_uninhibit() except Exception as cd_exception: self.log(cd_exception) profiling_inhibit = False else: self.log(f"{appname}: Uninhibited display device") if not profiling_inhibit: # Fallback - restore display profile self.log(f"{appname}: Re-assigning display profile...") cdinstall = self._attempt_install_profile_colord(display_profile) if cdinstall is True: self.log(f"{appname}: Successfully re-assigned display profile") elif not cdinstall: self.log(lang.getstr("calibration.load_error")) # Remove temp sRGB profile try: os.remove( os.path.join( xdg_data_home, "icc", os.path.basename(self.srgb.fileName), ) ) except Exception as exception: self.log(exception) if not silent: self.log(cmdname, "exitcode:", self.retcode) if self.retcode != 0: if use_pty and verbose >= 1 and not silent: self.log(lang.getstr("aborted")) if use_pty and len(self.output): errmsg = None for i, line in enumerate(self.output): if ( "Calibrate failed with 'User hit Abort Key' (No device error)" in line ): break if ( ( ": Error" in line and "failed with 'User Aborted'" not in line and "returned error code 1" not in line ) or ( line.startswith("Failed to") and "Failed to meet target" not in line ) or ( "Requested ambient light capability" in line and len(self.output) == i + 2 ) or ( "Diagnostic:" in line and ( len(self.output) == i + 1 or self.output[i + 1].startswith("usage:") ) ) or "communications failure" in line.lower() ): # "returned error code 1" == user aborted if ( sys.platform == "win32" and ( "config 1 failed (Operation not supported or " "unimplemented on this platform) (Permissions ?)" ) in line ): self.output.insert( i, lang.getstr("argyll.instrument.driver.missing") + "\n\n" + lang.getstr("argyll.error.detail") + " ", ) if "Diagnostic:" in line: errmsg = line else: errmsg = "".join(self.output[i:]) startpos = errmsg.find(": Error") if startpos > -1: errmsg = errmsg[startpos + 2 :] if errmsg: return UnloggedError(errmsg.strip()) if self.exec_cmd_returnvalue is not None: return self.exec_cmd_returnvalue return self.retcode == 0 def flush(self): pass def _generic_consumer( self, delayedResult, consumer, continue_next, *args, **kwargs ): # consumer must accept result as first arg result = None try: result = delayedResult.get() except Exception as exception: if ( exception.__class__ is Exception and exception.args and exception.args[0] == "aborted" ): # Special case - aborted result = False elif isinstance(exception, (UntracedError, Info)): result = exception else: if hasattr(exception, "originalTraceback"): self.log(exception.originalTraceback) else: self.log(traceback.format_exc()) result = UnloggedError(safe_str(exception)) if self.progress_start_timer.IsRunning(): self.progress_start_timer.Stop() self.finished = True if not continue_next or isinstance(result, Exception) or not result: self.stop_progress() self.subprocess_abort = False self.thread_abort = False self.recent.clear() self.lastmsg.clear() if self.thread.is_alive(): # Consumer may check if thread is still alive. Technically # it shouldn't be at that point when using CallAfter, but e.g. on # OS X there seems to be overlap with the thread counting as # 'alive' even though it already exited self.thread.join() wx.CallAfter(consumer, result, *args, **kwargs) def generate_A2B0(self, profile, clutres=None, logfile=None): # Lab cLUT is currently not implemented and should NOT be used! if profile.connectionColorSpace != b"XYZ": raise Error( lang.getstr( "profile.unsupported", (profile.connectionColorSpace, profile.connectionColorSpace), ) ) if logfile: print("-" * 80) logfile.write("Creating perceptual A2B0 table\n") logfile.write("\n") # Make new A2B0 A2B0 = LUT16Type(None, "A2B0", profile) # Matrix (identity) A2B0.matrix = [[1, 0, 0], [0, 1, 0], [0, 0, 1]] # Input / output curves (linear) A2B0.input = [] A2B0.output = [] channel = [] for j in range(256): channel.append(j * 257) for table in (A2B0.input, A2B0.output): for i in range(3): table.append(channel) # cLUT if logfile: logfile.write("Generating A2B0 table lookup input values...\n") A2B0.clut = [] if not clutres: clutres = len(profile.tags.A2B0.clut[0]) if logfile: logfile.write("cLUT grid res: {:d}\n".format(clutres)) vrange = range(clutres) step = 1.0 / (clutres - 1.0) idata = [] for R in vrange: for G in vrange: for B in vrange: idata.append([v * step for v in (R, G, B)]) if logfile: logfile.write("Looking up input values through A2B0 table...\n") odata = self.xicclu(profile, idata, pcs="x", logfile=logfile) numrows = len(odata) if numrows != clutres**3: raise ValueError( "Number of cLUT entries ({}) exceeds cLUT res " "maximum ({}^3 = {})".format(numrows, clutres, clutres**3) ) XYZbp = list(odata[0]) XYZwp = list(odata[-1]) if logfile: logfile.write("Filling cLUT...\n") for i, (X, Y, Z) in enumerate(odata): if i % clutres == 0: if self.thread_abort: raise Info(lang.getstr("aborted")) A2B0.clut.append([]) if logfile: logfile.write("\r{:0.0f}%".format(round(i / (numrows - 1.0) * 100))) # Apply black point compensation XYZ = colormath.blend_blackpoint(X, Y, Z, XYZbp) XYZ = [v / XYZwp[1] for v in XYZ] A2B0.clut[-1].append([max(v * 32768, 0) for v in XYZ]) if logfile: logfile.write("\n") profile.tags.A2B0 = A2B0 return True def generate_B2A_from_inverse_table( self, profile, clutres=None, source="A2B", tableno=None, bpc=False, smooth=True, rgb_space=None, logfile=None, filename=None, only_input_curves=False, ): """Generate a profile's B2A table by inverting the A2B table (default A2B1 or A2B0) It is also possible to re-generate a B2A table by interpolating the B2A table itself. """ if tableno is None: if "A2B1" in profile.tags: tableno = 1 else: tableno = 0 if not clutres: if "B2A{:d}".format(tableno) in profile.tags: tablename = f"B2A{tableno:d}" else: tablename = f"A2B{tableno:d}" clutres = len(profile.tags[tablename].clut[0]) if source == "B2A" and clutres > 23: # B2A interpolation is smoothest when used with a lower cLUT res clutres = 23 if logfile: if source == "A2B": msg = f"Generating B2A{tableno:d} table by inverting A2B{tableno:d} table\n" else: msg = f"Re-generating B2A{tableno:d} table by interpolation\n" logfile.write(msg) logfile.write("\n") cat = profile.guess_cat() or "Bradford" self.log("Using chromatic adaptation transform matrix:", cat) # Note that intent 0 will be colorimetric if no other tables are # present intent = {0: "p", 1: "r", 2: "s"}[tableno] # Lookup RGB -> XYZ for primaries, black- and white point idata = [[0, 0, 0], [1, 1, 1], [1, 0, 0], [0, 1, 0], [0, 0, 1]] direction = {"A2B": "f", "B2A": "ib"}[source] odata = self.xicclu(profile, idata, intent, direction, pcs="x") # Scale to Y = 1 XYZwp_abs = odata[1] XYZwpY = odata[1][1] odata = [[n / XYZwpY for n in v] for v in odata] XYZbp = odata[0] XYZwp = odata[1] XYZr = odata[2] XYZg = odata[3] XYZb = odata[4] # Sanity check whitepoint if ( round(XYZwp[0], 3) != 0.964 or round(XYZwp[1], 3) != 1 or round(XYZwp[2], 3) != 0.825 ): raise Error( "Argyll CMS xicclu: Invalid white XYZ: {:.4f} {:.4f} {:.4f}".format( *XYZwp_abs ) ) # Get the primaries XYZrgb = [XYZr, XYZg, XYZb] # Sanity check primaries: # Red Y, Z shall not be higher than X # Green X, Z shall not be higher than Y # Blue X, Y shall not be higher than Z for i, XYZ in enumerate(XYZrgb): for j, v in enumerate(XYZ): if v > XYZ[i]: raise Error( "xicclu: Invalid primary {} XYZ: {:.4f} {:.4f} {:.4f}".format( *(("RGB"[i],) + tuple(XYZ)) ) ) if logfile: logfile.write("Black XYZ: {:.4f} {:.4f} {:.4f}\n".format(*XYZbp)) logfile.write("White XYZ: {:.4f} {:.4f} {:.4f}\n".format(*XYZwp)) for i in range(3): logfile.write( "{} XYZ: {:.4f} {:.4f} {:.4f}\n".format( *(("RGB"[i],) + tuple(XYZrgb[i])) ) ) # Prepare input PCS values if logfile: logfile.write("Generating input curve PCS values...\n") idata = [] numentries = 4096 maxval = numentries - 1.0 vrange = range(numentries) Lbp, abp, bbp = colormath.XYZ2Lab(*[v * 100 for v in XYZbp]) # Method to determine device <-> PCS neutral axis relationship # 0: L* (a*=b*=0) -> RGB # 1: As method 0, but blend a* b* to blackpoint hue # 2: R=G=B -> PCS # 3: As method 0, but blend a* b* to blackpoint hue in XYZ (BPC) method = 2 if method != 2: for i in vrange: L, a, b = i / maxval * 100, 0, 0 if method in (1, 3) and not bpc and XYZbp != [0, 0, 0]: # Blend to blackpoint hue if method == 1: vv = (L - Lbp) / (100.0 - Lbp) # 0 at bp, 1 at wp vv = 1.0 - vv if vv < 0.0: vv = 0.0 elif vv > 1.0: vv = 1.0 vv = math.pow(vv, 40.0) a += vv * abp b += vv * bbp else: X, Y, Z = colormath.Lab2XYZ(L, a, b) XYZ = colormath.blend_blackpoint(X, Y, Z, None, XYZbp) a, b = colormath.XYZ2Lab(*[v * 100 for v in XYZ])[1:] idata.append((L, a, b)) pcs = profile.connectionColorSpace[0:1].lower().decode("utf-8") if source == "B2A": # NOTE: # Argyll's B2A tables are slightly inaccurate: # 0 0 0 PCS -> RGB may give RGB levels > 0 (it should clip # instead). Inversely, 0 0 0 RGB -> PCS (through inverted B2A) # will return PCS values that are too low or zero (ie. not the # black point as expected) # TODO: How to deal with this? # TODO: Erkan Ozgur Yilmaz, please do a research for this issue. pass if method == 2: # lookup RGB -> XYZ values through profile using xicclu to get TRC odata = [] if not bpc: numentries -= 1 maxval -= 1 for i in range(numentries): odata.append([i / maxval] * 3) idata = self.xicclu( profile, odata, intent, {"A2B": "f", "B2A": "ib"}[source], pcs="x" ) wY = idata[-1][1] idata = [[v[1] / wY * n for n in XYZwp] for v in idata] # Input curve maps neutral (except near black) XYZ -> RGB idata = [ list( colormath.blend_blackpoint( *v, bp_in=idata[0], bp_out=XYZbp, wp=XYZwp ) ) for v in idata ] if not bpc: numentries += 1 maxval += 1 idata.insert(0, [0, 0, 0]) odata.insert(0, [0, 0, 0]) oXYZ = idata D50 = colormath.get_whitepoint("D50") fpL = [colormath.XYZ2Lab(*v + [D50])[0] for v in oXYZ] else: oXYZ = [colormath.Lab2XYZ(*v) for v in idata] fpL = [v[0] for v in idata] fpX = [v[0] for v in oXYZ] fpY = [v[1] for v in oXYZ] fpZ = [v[2] for v in oXYZ] if method != 2 and bpc and XYZbp != [0, 0, 0]: if logfile: logfile.write("Applying BPC to input curve PCS values...\n") for i, (L, a, b) in enumerate(idata): X, Y, Z = colormath.Lab2XYZ(L, a, b) X, Y, Z = colormath.blend_blackpoint(X, Y, Z, None, XYZbp) idata[i] = colormath.XYZ2Lab(X * 100, Y * 100, Z * 100) if logfile: logfile.write("Looking up input curve RGB values...\n") direction = {"A2B": "if", "B2A": "b"}[source] if method != 2: # Lookup Lab -> RGB values through profile using xicclu to get TRC odata = self.xicclu( profile, idata, intent, direction, pcs="l", get_clip=True ) # Deal with values that got clipped (below black as well as white) do_low_clip = True for i, values in enumerate(odata): if values[3] is True or i == 0: if do_low_clip and (i / maxval * 100 < Lbp or i == 0): # Set to black self.log( "Setting curve entry #{:d} ({:.6f} {:.6f} {:.6f}) to " "black because it got clipped".format( *((i,) + tuple(values[:3])) ) ) values[:] = [0.0, 0.0, 0.0] elif i == maxval and [round(v, 4) for v in values[:3]] == [1, 1, 1]: # Set to white self.log( "Setting curve entry #{:d} ({:.6f} {:.6f} {:.6f}) to " "white because it got clipped".format( *((i,) + tuple(values[:3])) ) ) values[:] = [1.0, 1.0, 1.0] else: # First non-clipping value disables low clipping do_low_clip = False if len(values) > 3: values.pop() # Sanity check white if ( round(odata[-1][0], 3) != 1 or round(odata[-1][1], 3) != 1 or round(odata[-1][2], 3) != 1 ): wrgb_warning = ( "Warning: xicclu: Suspicious white RGB: " "{:.4f} {:.4f} {:.4f}\n".format(*odata[-1]) ) if logfile: logfile.write(wrgb_warning) else: print(wrgb_warning) xpR = [v[0] for v in odata] xpG = [v[1] for v in odata] xpB = [v[2] for v in odata] # Initialize B2A if only_input_curves: # Use existing B2A table itable = profile.tags[f"B2A{tableno:d}"] else: # Create new B2A table itable = LUT16Type(None, f"B2A{tableno:d}", profile) use_cam_clipping = True # Setup matrix scale = 1 + (32767 / 32768.0) m3 = colormath.Matrix3x3(((scale, 0, 0), (0, scale, 0), (0, 0, scale))) matrices = [] if profile.connectionColorSpace == b"Lab": # L*a*b* LUT # Use identity matrix for Lab as mandated by ICC spec itable.matrix = colormath.Matrix3x3([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) m2 = None elif only_input_curves: # Use existing matrix m2 = itable.matrix * m3.inverted() # Scale for BPC XYZbp_relcol = self.xicclu(profile, [[0, 0, 0]], pcs="x")[0] XYZbp_relcol_D50 = [v * XYZbp_relcol[1] for v in XYZwp] m2i = m2.inverted() XYZrgb = [m2i * (1, 0, 0), m2i * (0, 1, 0), m2i * (0, 0, 1)] for i, XYZ in enumerate(XYZrgb): XYZrgb[i] = colormath.apply_bpc( *XYZ, bp_in=(0, 0, 0), bp_out=XYZbp_relcol_D50, wp_out=XYZwp ) else: # Use a matrix that scales the profile colorspace into the XYZ # encoding range, to make optimal use of the cLUT grid points xyYrgb = [colormath.XYZ2xyY(*XYZ) for XYZ in XYZrgb] area1 = 0.5 * abs( sum( x0 * y1 - x1 * y0 for ((x0, y0, Y0), (x1, y1, Y1)) in zip( xyYrgb, xyYrgb[1:] + [xyYrgb[0]] ) ) ) if logfile: logfile.write("Setting up matrix\n") # RGB spaces used as PCS candidates. # Six synthetic RGB spaces that are large enough to encompass # display gamuts (except the LaserVue one) found on # http://www.tftcentral.co.uk/articles/pointers_gamut.htm # aswell as a selection of around two dozen profiles from openSUSE # ICC Profile Taxi database aswell as other user contributions rgb_spaces = [] rgb = [ ("R", (1.0, 0.0, 0.0)), ("G", (0.0, 1.0, 0.0)), ("B", (0.0, 0.0, 1.0)), ] # Add matrix from just white + 50% gray + black + primaries # as first entry # outname = os.path.splitext(profile.fileName)[0] # if not os.path.isfile(outname + ".ti3"): # if isinstance(profile.tags.get("targ"), Text): # with open(outname + ".ti3", "wb") as ti3: # ti3.write(profile.tags.targ) # else: # ti1name = "ti1/d3-e4-s2-g28-m0-b0-f0.ti1" # ti1 = get_data_path(ti1name) # if not ti1: # raise Error(lang.getstr("file.missing", ti1name)) # ti1, ti3, gray = self.ti1_lookup_to_ti3(ti1, profile, # intent="a", # white_patches=1) # outname += "." + ti1name # ti3.write(outname + ".ti3") # result = self._create_matrix_profile(outname, omit="TRC") result = True if isinstance(result, Exception) or not result: if logfile: logfile.write("Warning - could not compute RGBW matrix") if result: logfile.write(": " + str(result)) else: logfile.write("\n") else: comp_rgb_space = [2.2, "D50"] # Oversaturate primaries to add headroom wx, wy = colormath.XYZ2xyY(*XYZwp)[:2] # Determine saturation factor by looking at distance between # Rec. 2020 blue and actual blue primary bx, by, bY = colormath.XYZ2xyY( *colormath.adapt( *colormath.RGB2XYZ(0, 0, 1, "Rec. 2020"), whitepoint_source="D65", cat=cat, ) ) bx2, by2, bY2 = xyYrgb[2] bu, bv = colormath.xyY2Lu_v_(bx, by, bY)[1:] bu2, bv2 = colormath.xyY2Lu_v_(bx2, by2, bY2)[1:] dist = math.sqrt((bx - bx2) ** 2 + (by - by2) ** 2) sat = 1 + math.ceil(dist * 100) / 100.0 if logfile: logfile.write( "Increasing saturation of actual " "primaries for PCS candidate to " "{:0.0f}%...\n".format(round(sat * 100)) ) for i, channel in enumerate("rgb"): # x, y, Y = result.tags[channel + "XYZ"].pcs.xyY x, y, Y = xyYrgb[i] if logfile: logfile.write( "{} xy {:.6f} {:.6f} -> ".format(channel.upper(), x, y) ) x, y, Y = colormath.xyYsaturation(x, y, Y, wx, wy, sat) if logfile: logfile.write("{:.6f} {:.6f}\n".format(x, y)) xyYrgb[i] = x, y, Y (rx, ry, rY), (gx, gy, gY), (bx, by, bY) = xyYrgb mtx = colormath.rgb_to_xyz_matrix(rx, ry, gx, gy, bx, by, XYZwp) for i, (channel, components) in enumerate(rgb): X, Y, Z = mtx * components comp_rgb_space.append(colormath.XYZ2xyY(X, Y, Z)) comp_rgb_space.append("PCS candidate based on actual primaries") rgb_spaces.append(comp_rgb_space) # A colorspace that encompasses Rec709. Uses Rec. 2020 blue. rgb_spaces.append( [ 2.2, "D50", [0.68280181011, 0.315096403371, 0.224182128906], [0.310096375087, 0.631250246526, 0.73258972168], [0.129244796433, 0.0471357502953, 0.0432281494141], "Rec709-encompassing, variant 1", ] ) # A colorspace that encompasses Rec709. Uses slightly different # primaries (based on WLED and B+RG LED) than variant 1. rgb_spaces.append( [ 2.2, "D50", [0.664580313612, 0.329336320112, 0.228820800781], [0.318985161632, 0.644740328564, 0.742568969727], [0.143284983488, 0.0303535582465, 0.0286102294922], "Rec709-encompassing, variant 2", ] ) # A colorspace that encompasses Rec709 with imaginary red and blue rgb_spaces.append( [ 2.2, "D50", [0.672053135694, 0.331936091367, 0.250122070312], [0.319028093312, 0.644705491217, 0.710144042969], [0.113899645442, 0.0424325604954, 0.0396270751953], "Rec709-encompassing, variant 3", ] ) # A colorspace that encompasses Rec709. Uses red and blue from # variant 2, but a slightly different green primary. rgb_spaces.append( [ 2.2, "D50", [0.664627993657, 0.329338357942, 0.244033813477], [0.300155771607, 0.640946446796, 0.728302001953], [0.143304213944, 0.0303410650333, 0.0276641845703], "Rec709-encompassing, variant 4", ] ) # A colorspace with Plasma-like primaries. Uses Rec. 2020 blue. rgb_spaces.append( [ 2.2, "D50", [0.692947816539, 0.30857396028, 0.244430541992], [0.284461719244, 0.70017174365, 0.709167480469], [0.129234824405, 0.0471509419335, 0.0464019775391], "SMPTE-431-2/DCI-P3-encompassing, variant 1", ] ) # A colorspace that encompasses both AdobeRGB and NTSC1953. Uses # Rec. 2020 blue. rgb_spaces.append( [ 2.2, "D50", [0.680082575358, 0.319746686121, 0.314331054688], [0.200003470174, 0.730003123156, 0.641983032227], [0.129238369699, 0.0471305063812, 0.0436706542969], "AdobeRGB-NTSC1953-hybrid, variant 1", ] ) # A colorspace with Plasma-like primaries. Uses Rec. 2020 blue. # More saturated green primary than variant 1. rgb_spaces.append( [ 2.2, "D50", [0.692943297796, 0.308579731457, 0.268966674805], [0.249088838269, 0.730263586072, 0.684844970703], [0.129230721306, 0.047147329564, 0.0461883544922], "SMPTE-431-2/DCI-P3-encompassing, variant 2", ] ) # A colorspace that encompasses both AdobeRGB and NTSC1953. # Different, more saturated primaries than variant 1. rgb_spaces.append( [ 2.2, "D50", [0.700603882817, 0.299296301842, 0.274520874023], [0.200006562972, 0.75, 0.697494506836], [0.143956453416, 0.0296952711131, 0.0279693603516], "AdobeRGB-NTSC1953-hybrid, variant 2", ] ) # A colorspace that encompasses DCI P3 with imaginary red and blue rgb_spaces.append( [ 2.2, "D50", [0.699964323939, 0.312334528794, 0.253814697266], [0.284337791321, 0.68212854805, 0.73779296875], [0.098165262763, 0.00937830372063, 0.00839233398438], "SMPTE-431-2/DCI-P3-encompassing, variant 3", ] ) # A colorspace that encompasses DCI P3 with imaginary red and blue # (red and blue are practically the same as Rec2020-encompassing) rgb_spaces.append( [ 2.2, "D50", [0.717267960557, 0.29619267491, 0.231002807617], [0.284277504105, 0.682088122605, 0.760604858398], [0.0981978292034, 0.00940337224384, 0.00840759277344], "SMPTE-431-2/DCI-P3-encompassing, variant 4", ] ) # Rec. 2020 rgb_spaces.append( [ 2.2, "D50", [0.7084978651, 0.293540723619, 0.279037475586], [0.190200063067, 0.775375775201, 0.675354003906], [0.129244405192, 0.0471399056886, 0.0456085205078], "Rec2020", ] ) # A colorspace that encompasses Rec2020 with imaginary primaries rgb_spaces.append( [ 2.2, "D50", [0.71715243505, 0.296225595183, 0.291244506836], [0.191129060214, 0.795212673762, 0.700057983398], [0.0981403936826, 0.00939694681658, 0.00869750976562], "Rec2020-encompassing", ] ) if rgb_space: rgb_space = list(rgb_space[:5]) rgb_spaces = [rgb_space + ["Custom"]] # Find smallest candidate that encompasses space defined by actual # primaries if logfile: logfile.write("Checking for suitable PCS candidate...\n") pcs_candidate = None pcs_candidates = [] XYZsrgb = [] for channel, components in rgb: XYZsrgb.append( colormath.adapt( *colormath.RGB2XYZ(*components), whitepoint_source="D65", cat=cat, ) ) XYZrgb_sequence = [XYZrgb, XYZsrgb] for rgb_space in rgb_spaces: if rgb_space[1] not in ("D50", colormath.get_whitepoint("D50")): # Adapt to D50 for i in range(3): X, Y, Z = colormath.xyY2XYZ(*rgb_space[2 + i]) X, Y, Z = colormath.adapt(X, Y, Z, rgb_space[1], cat=cat) rgb_space[2 + i] = colormath.XYZ2xyY(X, Y, Z) rgb_space[1] = "D50" extremes = [] skip = False for XYZrgb in XYZrgb_sequence: for i, color in enumerate(["red", "green", "blue"]): RGB = colormath.XYZ2RGB( XYZrgb[i][0], XYZrgb[i][1], XYZrgb[i][2], rgb_space=rgb_space, clamp=False, ) maxima = max(RGB) minima = min(RGB) if minima < 0: maxima += abs(minima) if XYZrgb is XYZsrgb: if maxima > 1 and color == "blue": # We want our PCS candiate to contain Rec. 709 # blue, which may not be the case for our # candidate based off the actual display # primaries. Blue region is typically the one # where the most artifacts would be visible in # color conversions if the source blue is # clipped if logfile: logfile.write( "Skipping {} because it does " "not encompass Rec. 709 {}\n".format( rgb_space[-1], color ) ) skip = True break else: extremes.append(maxima) if skip: break if skip: continue # Check area % (in xy for simplicity's sake) xyYrgb = rgb_space[2:5] area2 = 0.5 * abs( sum( x0 * y1 - x1 * y0 for ((x0, y0, Y0), (x1, y1, Y1)) in zip( xyYrgb, xyYrgb[1:] + [xyYrgb[0]] ) ) ) if logfile: logfile.write( "{} fit: {:.2f} (area: {:.2f}%)\n".format( rgb_space[-1], round(1.0 / max(extremes), 2), area1 / area2 * 100, ) ) pcs_candidates.append((area1 / area2, 1.0 / max(extremes), rgb_space)) # Check if tested RGB space contains actual primaries if round(max(extremes), 2) <= 1.0: break XYZrgb = [] if not pcs_candidate and False: # NEVER? # Create quick medium quality shaper+matrix profile and use the # matrix from that if logfile: logfile.write( "No suitable PCS candidate. Computing best fit matrix...\n" ) # Lookup small testchart so profile computation finishes quickly ti1name = "ti1/d3-e4-s5-g52-m5-b0-f0.ti1" ti1 = get_data_path(ti1name) if not ti1: raise Error(lang.getstr("file.missing", ti1name)) ti1, ti3, gray = self.ti1_lookup_to_ti3( ti1, profile, intent="a", white_patches=1 ) dirname, basename = os.path.split(profile.fileName) basepath = os.path.join( dirname, f".{os.path.splitext(basename)[0]}-MTX.tmp" ) ti3.write(f"{basepath}.ti3") # Calculate profile cmd, args = get_argyll_util("colprof"), ["-v", "-qm", "-as", basepath] result = self.exec_cmd( cmd, args, capture_output=True, sessionlogfile=getattr(self, "sessionlogfile", None), ) if isinstance(result, Exception): raise result if result: mtx = ICCProfile(f"{basepath}{profile_ext}") for column in "rgb": tag = mtx.tags.get(column + "XYZ") if isinstance(tag, XYZType): XYZrgb.append(list(tag.values())) # os.remove(basepath + ".ti3") # os.remove(basepath + profile_ext) if not XYZrgb: raise Error( lang.getstr( "profile.required_tags_missing", "rXYZ/gXYZ/bXYZ" ) ) pcs_candidate = "BestFit" else: # If clutres is -1 (auto), set it depending on area coverage if clutres == -1: if area1 / area2 <= 0.51: clutres = 45 elif area1 / area2 <= 0.73: clutres = 33 # Use PCS candidate with best fit # (best fit is the smallest fit greater or equal 1 and # largest possible coverage) pcs_candidates.sort(key=lambda row_: (-row_[0], row_[1])) for coverage, fit, rgb_space in pcs_candidates: if round(fit, 2) >= 1: break if logfile: logfile.write("Using primaries: {}\n".format(rgb_space[-1])) for channel, components in rgb: XYZrgb.append(colormath.RGB2XYZ(*components, rgb_space=rgb_space)) pcs_candidate = rgb_space[-1] for i in range(3): logfile.write( "Using {} XYZ: {:.4f} {:.4f} {:.4f}\n".format( *(("RGB"[i],) + tuple(XYZrgb[i])) ) ) if profile.connectionColorSpace == b"XYZ": # Construct the final matrix Xr, Yr, Zr = XYZrgb[0] Xg, Yg, Zg = XYZrgb[1] Xb, Yb, Zb = XYZrgb[2] if logfile: logfile.write( "R+G+B XYZ: {:.4f} {:.4f} {:.4f}\n".format( Xr + Xg + Xb, Yr + Yg + Yb, Zr + Zg + Zb, ) ) m1 = colormath.Matrix3x3( ((Xr, Xg, Xb), (Yr, Yg, Yb), (Zr, Zg, Zb)) ).inverted() matrices.append(m1) Sr, Sg, Sb = m1 * XYZwp if logfile: logfile.write( "Correction factors: {:.4f} {:.4f} {:.4f}\n".format(Sr, Sg, Sb) ) m2 = colormath.Matrix3x3( ( (Sr * Xr, Sg * Xg, Sb * Xb), (Sr * Yr, Sg * Yg, Sb * Yb), (Sr * Zr, Sg * Zg, Sb * Zb), ) ).inverted() matrices.append(m2) matrices.append(m3) for m, matrix in enumerate(matrices): if logfile: logfile.write("Matrix {:d}:\n".format(m + 1)) for row in matrix: logfile.write("{}\n".format(repr(row))) itable.matrix = m2 * m3 if logfile: logfile.write("Final matrix:\n") for row in itable.matrix: logfile.write("{}\n".format(repr(row))) if logfile: logfile.write("Applying matrix to input curve XYZ values...\n") # Apply matrix rX = [] rY = [] rZ = [] for i in vrange: X, Y, Z = fpX[i], fpY[i], fpZ[i] X, Y, Z = m2 * (X, Y, Z) rX.append(X) rY.append(Y) rZ.append(Z) interp = ( colormath.Interp(xpR, rX), colormath.Interp(xpG, rY), colormath.Interp(xpB, rZ), ) rinterp = ( colormath.Interp(rX, xpR), colormath.Interp(rY, xpG), colormath.Interp(rZ, xpB), ) Linterp = None else: Lscale = 65280.0 / 65535.0 oldmin = (xpR[0] + xpG[0] + xpB[0]) / 3.0 oldmax = (xpR[-1] + xpG[-1] + xpB[-1]) / 3.0 oldrange = oldmax - oldmin newmin = 0.0 newmax = 100 newrange = newmax - newmin xpL = [] for i in vrange: v = (xpR[i] + xpG[i] + xpB[i]) / 3.0 v = max((((v - oldmin) * newrange) / oldrange) + newmin, 0) xpL.append(v) Linterp = colormath.Interp(xpL, fpL) rLinterp = colormath.Interp(fpL, xpL) interp = None # Set input curves # Apply inverse TRC to input values to distribute them # optimally across cLUT grid points if logfile: logfile.write("Generating input curves...\n") itable.input = [[], [], []] for j in vrange: if self.thread_abort: raise Info(lang.getstr("aborted")) if profile.connectionColorSpace == b"XYZ": v = [rinterp[i](j / maxval) for i in range(3)] else: # CIELab PCS encoding v = [rLinterp(j / (maxval * Lscale) * 100) / 100.0] v.extend([j / maxval] * 2) for i in range(len(itable.input)): itable.input[i].append(min(v[i] * 65535, 65535)) if logfile and j % math.floor(maxval / 100.0) == 0: logfile.write("\r{:0.0f}%".format(round(j / maxval * 100))) if logfile: logfile.write("\n") if False and method and not bpc: # Force the blackpoint - NEVER if logfile: logfile.write("Forcing B2A input curve blackpoint...\n") XYZbp_m = m2 * XYZbp for i in range(3): black_index = int(math.ceil(maxval * XYZbp_m[i])) if logfile: logfile.write(f"Channel #{i:d}\n") for j in range(black_index + 1): v = 0 if logfile: logfile.write( "#{:d} {:d} -> {:d}\n".format(j, itable.input[i][j], v) ) itable.input[i][j] = v if only_input_curves: # We are done return True if clutres == -1: # Auto if pcs == "l" and smooth: # Counteract L*a*b* cLUT accuracy loss when smoothing. # With a res of 45, about the same accuracy as when using # colprof B2A with a res of 33 and no smoothing. # This is not necessary with XYZ cLUT as the accuracy is always # higher than colprof baseline due to restricting the XYZ space # with a matrix. clutres = 45 else: clutres = 33 step = 1.0 / (clutres - 1.0) do_lookup = True if do_lookup: # Generate inverse table lookup input values # Use slightly less than equal the amount of CPUs for workers # for best utilization (each worker has 2 xicclu sub-processes) num_cpus = cpu_count() num_workers = min(max(num_cpus, 1), clutres) if num_cpus > 2: num_workers = int(num_workers * 0.75) if logfile: logfile.write( "Generating {}{:d} table lookup input values...\n".format( source, tableno ) ) logfile.write(f"cLUT grid res: {clutres:d}\n") logfile.write( "Looking up input values through " f"{source}{tableno:d} table ({num_workers:d} workers)...\n" ) logfile.write( "{} CAM Jab for clipping\n".format( use_cam_clipping and "Using" or "Not using" ) ) idata = [] odata1 = [] odata2 = [] threshold = int((clutres - 1) * 0.75) threshold2 = int((clutres - 1) / 3) for slices in pool_slice( _mp_generate_B2A_clut, list(range(clutres)), ( profile.fileName, intent, direction, pcs, use_cam_clipping, clutres, step, threshold, threshold2, interp, Linterp, m2, XYZbp, XYZwp, bpc, lang.getstr("aborted"), ), {}, num_workers, self.thread_abort, logfile, num_batches=clutres // 9, ): for i, data in enumerate((idata, odata1, odata2)): data.extend(slices[i]) if logfile: logfile.write("\n") if logfile and (pcs == "x" or clutres // 2 != clutres / 2.0): if pcs == "x": iXYZbp = idata[0] iXYZwp = idata[-1] logfile.write(f"Input black XYZ: {iXYZbp}\n") logfile.write(f"Input white XYZ: {iXYZwp}\n") else: iLabbp = idata[clutres * (clutres // 2) + clutres // 2] iLabwp = idata[ ( clutres**2 * (clutres - 1) + clutres * (clutres // 2) + clutres // 2 ) ] logfile.write(f"Input black L*a*b*: {iLabbp}\n") logfile.write(f"Input white L*a*b*: {iLabwp}\n") if not use_cam_clipping: odata = odata1 elif pcs == "l": odata = odata2 else: # Linearly interpolate the crossover to CAM Jab clipping region cam_diag = False odata = [] j, k = 0, 0 r = float(threshold - threshold2) for a in range(clutres): for b in range(clutres): for c in range(clutres): if a <= threshold and b <= threshold and c <= threshold: v = odata1[j] j += 1 if a > threshold2 or b > threshold2 or c > threshold2: d = max(a, b, c) if cam_diag: v = [100.0, 100.0, 0.0] v2 = [0.0, 100.0, 100.0] else: v2 = odata2[k] k += 1 for i, n in enumerate(v): v[i] *= (threshold - d) / r v2[i] *= 1 - (threshold - d) / r v[i] += v2[i] else: if cam_diag: v = [100.0, 0.0, 100.0] else: v = odata2[k] k += 1 odata.append(v) numrows = len(odata) if numrows != clutres**3: raise ValueError( f"Number of cLUT entries ({numrows}) exceeds cLUT res " f"maximum ({clutres}^3 = {clutres**3})" ) if logfile and (pcs == "x" or clutres // 2 != clutres / 2.0): if pcs == "x": oRGBbp = odata[0] oRGBwp = odata[-1] else: oRGBbp = odata[clutres * (clutres // 2) + clutres // 2] oRGBwp = odata[ ( clutres**2 * (clutres - 1) + clutres * (clutres // 2) + clutres // 2 ) ] logfile.write( "Output black RGB: {:.4f} {:.4f} {:.4f}\n".format(*oRGBbp) ) logfile.write( "Output white RGB: {:.4f} {:.4f} {:.4f}\n".format(*oRGBwp) ) odata = [[n / 100.0 for n in v] for v in odata] # Fill cCLUT itable.clut = [] if logfile: logfile.write("Filling cLUT...\n") if not do_lookup: # Linearly scale RGB for R in range(clutres): if self.thread_abort: raise Info(lang.getstr("aborted")) for G in range(clutres): itable.clut.append([]) for B in range(clutres): itable.clut[-1].append([v * step * 65535 for v in (R, G, B)]) if logfile: logfile.write( "\r{:0.0f}%".format( round((R * G * B) / ((clutres - 1.0) ** 3) * 100) ) ) else: for i, RGB in enumerate(odata): if i % clutres == 0: if self.thread_abort: raise Info(lang.getstr("aborted")) itable.clut.append([]) if logfile: logfile.write( "\r{:0.0f}%".format(round(i / (numrows - 1.0) * 100)) ) # Set RGB black and white explicitly if pcs == "x": if i == 0: RGB = 0, 0, 0 elif i == numrows - 1.0: RGB = 1, 1, 1 elif clutres // 2 != clutres / 2.0: # For CIELab cLUT, white- and black point will only # fall on a cLUT point if uneven cLUT res if i == clutres * (clutres // 2) + clutres // 2: # if raw_input("{:d} {}".format(i, repr(RGB))): RGB = 0, 0, 0 elif i == ( clutres**2 * (clutres - 1) + clutres * (clutres // 2) + clutres // 2 ): # if raw_input("{:d} {}".format(i, repr(RGB))): RGB = 1, 1, 1 itable.clut[-1].append([v * 65535 for v in RGB]) if logfile: logfile.write("\n") if getcfg("profile.b2a.hires.diagpng") and filename: # Generate diagnostic images fname, ext = os.path.splitext(filename) for suffix, table in [ ("pre", profile.tags.get(f"B2A{tableno}")), ("post", itable), ]: if table: table.clut_writepng(f"{fname}.B2A{tableno:d}.{suffix}.CLUT.png") # Update profile profile.tags[f"B2A{tableno:d}"] = itable if method == 2: if logfile: logfile.write("Generating output curves...\n") # Output curve maps RGB to RGB # Lookup neutral (except near black) XYZ -> RGB oRGB = self.xicclu( profile, oXYZ, intent, {"A2B": "if", "B2A": "b"}[source], pcs="x", get_clip=True, ) # Deal with values that got clipped (below black as well as white) do_low_clip = True for i, values in enumerate(oRGB): if values[3] is True or i == 0: if do_low_clip: # Set to black self.log( "Setting curve entry #{:d} ({:.6f} {:.6f} {:.6f}) to " "black because it got clipped".format( *((i,) + tuple(values[:3])) ) ) values[:] = [0.0, 0.0, 0.0] elif i == maxval and [round(v, 4) for v in values[:3]] == [1, 1, 1]: # Set to white self.log( "Setting curve entry #{:d} ({:.6f} {:.6f} {:.6f}) to " "white because it got clipped".format( *((i,) + tuple(values[:3])) ) ) values[:] = [1.0, 1.0, 1.0] else: # First non-clipping value disables low clipping do_low_clip = False if len(values) > 3: values.pop() ocurves = [[], [], []] for i, RGB in enumerate(oRGB): for j, v in enumerate(RGB): ocurves[j].append(v) ointerp = [] for i, ocurve in enumerate(ocurves): olen = len(ocurve) ointerp_i = colormath.Interp( [j / (olen - 1.0) for j in range(olen)], ocurve, use_numpy=True ) ocurve_i = [ointerp_i(j / (clutres - 1.0)) for j in range(clutres)] ocurve_i = colormath.interp_resize( ocurve_i, len(ocurve), use_numpy=True ) ointerp_o = colormath.Interp(ocurve_i, ocurve, use_numpy=True) ointerp.append(ointerp_o) # Set output curves itable.output = [[], [], []] numentries = 256 maxval = numentries - 1.0 for i in range(len(itable.output)): for j in range(numentries): v = j / maxval if method == 2: v = ointerp[i](v) itable.output[i].append(v * 65535) if smooth: self.smooth_B2A( profile, tableno, getcfg("profile.b2a.hires.diagpng"), filename, logfile ) return True def smooth_B2A(self, profile, tableno, diagpng=2, filename=None, logfile=None): """Apply extra smoothing to the cLUT""" itable = profile.tags.get(f"B2A{tableno:d}") if not itable: return False itable.smooth2(diagpng, profile.connectionColorSpace, filename, logfile) return True def get_device_id( self, quirk=False, use_serial_32=True, truncate_edid_strings=False, omit_manufacturer=False, query=False, ): """Get org.freedesktop.ColorManager device key""" if not self.display_edid or config.is_virtual_display(): return None display_no = max(0, min(len(self.displays) - 1, getcfg("display.number") - 1)) edid = self.display_edid[display_no] if not edid: # Fall back to XrandR name if not ( not quirk and use_serial_32 and not truncate_edid_strings and not omit_manufacturer ): return if RDSMM: display = RDSMM.get_display(display_no) if display: xrandr_name = display.get("xrandr_name") if xrandr_name: edid = {"monitor_name": xrandr_name} elif os.getenv("XDG_SESSION_TYPE") == "wayland": # Preliminary Wayland support under non-GNOME desktops. # This still needs a lot of work. device_ids = colord.get_display_device_ids() if device_ids and display_no < len(device_ids): return device_ids[display_no] return colord.device_id_from_edid( edid, quirk=quirk, use_serial_32=use_serial_32, truncate_edid_strings=truncate_edid_strings, omit_manufacturer=omit_manufacturer, query=query, ) def get_display(self): """Get the currently configured display. Returned is the Argyll CMS dispcal/dispread -d argument """ display_name = config.get_display_name(None, True) if display_name == "Web @ localhost": return "web:{:d}".format(getcfg("webserver.portnumber")) if display_name == "madVR": return "madvr" if display_name == "Untethered": return "0" if display_name == "Resolve": if ( self.argyll_virtual_display # and os.getenv("XDG_SESSION_TYPE") == "wayland" ): return self.argyll_virtual_display else: return "1" if display_name == "Prisma" and not defaults["patterngenerator.prisma.argyll"]: if self.argyll_virtual_display: return self.argyll_virtual_display else: return "1" if display_name == "Prisma": host = getcfg("patterngenerator.prisma.host") try: host = socket.gethostbyname(host) except socket.error: pass return f"prisma:{host}" if display_name.startswith("Chromecast "): return "cc:{}".format(display_name.split(":")[0].split(None, 1)[1].strip()) if display_name.startswith("Prisma "): return "prisma:{}".format(display_name.split("@")[-1].strip()) if self._use_patternwindow: # Preliminary Wayland support. This still needs a lot # of work as Argyll doesn't support Wayland natively, # so we use virtual display to drive our own patch window. return self.argyll_virtual_display display_no = min(len(self.displays), getcfg("display.number")) - 1 display = str(display_no + 1) if ( (sys.platform not in ("darwin", "win32") or test) and (self.has_separate_lut_access() or getcfg("use_separate_lut_access")) and ( not getcfg("display_lut.link") or (display_no > -1 and not self.lut_access[display_no]) ) ): display_lut_no = min(len(self.displays), getcfg("display_lut.number")) - 1 if display_lut_no > -1 and not self.lut_access[display_lut_no]: for display_lut_no, disp in enumerate(self.lut_access): if disp: break display += "," + str(display_lut_no + 1) return display def get_display_edid(self): """Return EDID of currently configured display""" n = getcfg("display.number") - 1 if 0 <= n < len(self.display_edid): return self.display_edid[n] return {} def get_display_name( self, prepend_manufacturer=False, prefer_edid=False, remove_manufacturer=True ): """Return name of currently configured display""" n = getcfg("display.number") - 1 if 0 <= n < len(self.display_names): display = [] manufacturer = None display_name = None if prefer_edid: edid = self.get_display_edid() manufacturer = edid.get("manufacturer") display_name = edid.get( "monitor_name", edid.get("ascii", str(edid.get("product_id") or "")) ) if not manufacturer: manufacturer = self.display_manufacturers[n] if not display_name: display_name = self.display_names[n] if manufacturer: manufacturer = colord.quirk_manufacturer(manufacturer) if prepend_manufacturer: if manufacturer.lower() not in display_name.lower(): display.append(manufacturer) elif remove_manufacturer: start = display_name.lower().find(manufacturer.lower()) if start > -1: display_name = ( display_name[:start] + display_name[start + len(manufacturer) :] ).lstrip() display_name = re.sub(r"^[^([{\w]+", "", display_name) display.append(display_name) return " ".join(display) return "" def get_display_name_short(self, prepend_manufacturer=False, prefer_edid=False): """Return shortened name of configured display (if possible) If name can't be shortened (e.g. because it's already 10 characters or less), return full string """ display_name = self.get_display_name(prepend_manufacturer, prefer_edid) if len(display_name) > 10: maxweight = 0 for part in re.findall( r"[^\s_]+(?:\s*\d+)?", re.sub(r"\([^)]+\)", "", display_name) ): digits = re.search(r"\d+", part) if digits: # Weigh parts with digits higher than those without chars = re.sub(r"\d+", "", part) weight = len(chars) + len(digits.group()) * 5 else: # Weigh parts with uppercase letters higher than those without chars = "" for char in part: if char.lower() != char: chars += char weight = len(chars) if chars and weight >= maxweight: # Weigh parts further to the right higher display_name = re.sub(r"^[^([{\w]+", "", part) maxweight = weight # Shortname should not contain any spaces. display_name = re.sub(r"[\s]+", "_", display_name) return display_name def get_dispwin_display_profile_argument(self, display_no=0): """Return argument corresponding to the display profile for use with dispwin. Will either return '-L' (use current profile) or a filename. """ arg = "-L" try: profile = get_display_profile(display_no) except Exception as exception: print(exception) return arg else: if not profile: return arg if profile.fileName: prefix = os.path.basename(profile.fileName) else: prefix = ( make_filename_safe(profile.getDescription(), concat=False) + profile_ext ) prefix += "-" if profile.version >= 4 and not profile.convert_iccv4_tags_to_iccv2(): print( "\n".join( [lang.getstr("profile.iccv4.unsupported"), profile.getDescription()] ) ) elif not profile.fileName: fd, profile.fileName = tempfile.mkstemp("", prefix) stream = os.fdopen(fd, "wb") profile.write(stream) stream.close() atexit.register(os.remove, profile.fileName) return profile.fileName or arg def update_display_name_manufacturer( self, ti3, display_name=None, display_manufacturer=None, write=True ): """Update display name and manufacturer in colprof arguments embedded in 'ARGYLL_COLPROF_ARGS' section in a TI3 file.""" options_colprof = [] if not display_name and not display_manufacturer: # Note: Do not mix'n'match display name and manufacturer from # different sources try: ti3_options_colprof = get_options_from_ti3(ti3)[1] except ( IOError, CGATSInvalidError, CGATSInvalidOperationError, CGATSKeyError, CGATSTypeError, CGATSValueError, ) as exception: print(exception) ti3_options_colprof = [] for option in ti3_options_colprof: if option[0] == "M": display_name = option.split(None, 1)[-1][1:-1] elif option[0] == "A": display_manufacturer = option.split(None, 1)[-1][1:-1] if not display_name and not display_manufacturer: # Note: Do not mix'n'match display name and manufacturer from # different sources edid = self.display_edid[ max(0, min(len(self.displays), getcfg("display.number")) - 1) ] display_name = edid.get( "monitor_name", edid.get("ascii", str(edid.get("product_id") or "")) ) display_manufacturer = edid.get("manufacturer") if not display_name and not display_manufacturer: # Note: Do not mix'n'match display name and manufacturer from # different sources display_name = self.get_display_name() if display_name: options_colprof.append("-M") options_colprof.append(display_name) if display_manufacturer: options_colprof.append("-A") options_colprof.append(display_manufacturer) if write: # Add dispcal and colprof arguments to ti3 if is_ccxx_testchart(): options_dispcal = [] else: options_dispcal = self.options_dispcal ti3 = add_options_to_ti3(ti3, options_dispcal, options_colprof) if ti3: ti3.write() return options_colprof def get_instrument_features(self, instrument_name=None): """Return features of currently configured instrument""" features = all_instruments.get( instrument_name or self.get_instrument_name(), {} ) if test_require_sensor_cal: features["sensor_cal"] = True features["skip_sensor_cal"] = False return features def get_instrument_measurement_modes( self, instrument_id=None, skip_ccxx_modes=True ): """Enumerate measurement modes supported by the instrument""" if not instrument_id: features = self.get_instrument_features() instrument_id = features.get("id", self.get_instrument_name()) if instrument_id: measurement_modes = self.measurement_modes.get(instrument_id, dict()) if not measurement_modes: result = self.exec_cmd( get_argyll_util("spotread"), ["-?"], capture_output=True, skip_scripts=True, silent=True, log_output=False, ) if isinstance(result, Exception): print(result) # Need to get and remember output of spotread because calling # self.get_technology_strings() will overwrite self.output output = self.output if test: output.extend( """Measure spot values, Version 1.7.0_beta Author: Graeme W. Gill, licensed under the GPL Version 2 or later Diagnostic: Usage requested usage: spotread [-options] [logfile] -v Verbose mode -s Print spectrum for each reading -S Plot spectrum for each reading -c listno Set communication port from the following list (default 1) 1 = 'COM13 (Klein K-10)' 2 = 'COM1' 3 = 'COM3' 4 = 'COM4' -t Use transmission measurement mode -e Use emissive measurement mode (absolute results) -eb Use display white brightness relative measurement mode -ew Use display white point relative chromatically adjusted mode -p Use telephoto measurement mode (absolute results) -pb Use projector white brightness relative measurement mode -pw Use projector white point relative chromatically adjusted mode -a Use ambient measurement mode (absolute results) -f Use ambient flash measurement mode (absolute results) -y F K-10: Factory Default [Default,CB1] c K-10: Default CRT File P K-10: Klein DLP Lux E K-10: Klein SMPTE C b K-10: TVL XVM245 d K-10: Klein LED Bk LCD m K-10: Klein Plasma p K-10: DLP Screen o K-10: TVL LEM150 O K-10: Sony EL OLED z K-10: Eizo CG LCD L K-10: FSI 2461W h K-10: HP DreamColor 2 1 K-10: LCD CCFL Wide Gamut IPS (LCD2690WUXi) l|c Other: l = LCD, c = CRT -I illum Set simulated instrument illumination using FWA (def -i illum): M0, M1, M2, A, C, D50, D50M2, D65, F5, F8, F10 or file.sp] -i illum Choose illuminant for computation of CIE XYZ from spectral data & FWA: A, C, D50 (def.), D50M2, D65, F5, F8, F10 or file.sp -Q observ Choose CIE Observer for spectral data or CCSS instrument: 1931_2 (def), 1964_10, S&B 1955_2, shaw, J&V 1978_2 (Choose FWA during operation) -F filter Set filter configuration (if aplicable): n None p Polarising filter 6 D65 u U.V. Cut -E extrafilterfile Apply extra filter compensation file -x Display Yxy instead of Lab -h Display LCh instead of Lab -V Show running average and std. devation from ref. -T Display correlated color temperatures and CRI -N Disable auto calibration of instrument -O Do one cal. or measure and exit -H Start in high resolution spectrum mode (if available) -X file.ccmx Apply Colorimeter Correction Matrix -Y r|n Override refresh, non-refresh display mode -Y R:rate Override measured refresh rate with rate Hz -Y A Use non-adaptive integration time mode (if available). -W n|h|x Override serial port flow control: n = none, h = HW, x = Xon/Xoff -D [level] Print debug diagnostics to stderr logfile Optional file to save reading results as text""".splitlines() ) measurement_modes_follow = False technology_strings = self.get_technology_strings() for line in output: line = line.strip() if line.startswith("-y "): line = line.lstrip("-y ") measurement_modes_follow = True elif line.startswith("-"): measurement_modes_follow = False parts = [v.strip() for v in line.split(None, 1)] if measurement_modes_follow and len(parts) == 2: measurement_mode, desc = parts if measurement_mode not in ( string.digits[1:] + string.ascii_letters ): # Ran out of selectors continue measurement_mode_instrument_id, desc = desc.split(":", 1) desc = desc.strip() if measurement_mode_instrument_id == instrument_id: # Found a mode for our instrument if ( re.sub(r"\s*\(.*?\)?$", "", desc) in list(technology_strings.values()) + [""] and skip_ccxx_modes ): # This mode is supplied via CCMX/CCSS, skip continue desc = re.sub(r"\s*(?:File|\[[^\]]*\])", "", desc) measurement_modes[measurement_mode] = desc self.measurement_modes[instrument_id] = measurement_modes return measurement_modes return {} def get_instrument_name(self): """Return name of currently configured instrument""" try: return self.instruments[getcfg("comport.number") - 1] except IndexError: return "" def get_real_displays(self): """Get real (nonvirtual) displays""" real_displays = [] for display_no in range(len(self.displays)): if not config.is_virtual_display(display_no): real_displays.append(display_no) return real_displays def get_technology_strings(self): """Return technology strings mapping (from ccxxmake -??)""" if self.argyll_version < [1, 7]: # Argyll ccxxmake before V1.7 didn't have the ability to list # dtechs with -?? # Argyll V1.7 had different keys (we still want to use those for # V1.7) with some duplicates # Use Argyll V1.7.1 mapping (which has no duplicate keys) for # Argyll before V1.7 return { "c": "CRT", "m": "Plasma", "l": "LCD", "1": "LCD CCFL", "2": "LCD CCFL IPS", "3": "LCD CCFL VPA", "4": "LCD CCFL TFT", "L": "LCD CCFL Wide Gamut", "5": "LCD CCFL Wide Gamut IPS", "6": "LCD CCFL Wide Gamut VPA", "7": "LCD CCFL Wide Gamut TFT", "e": "LCD White LED", "8": "LCD White LED IPS", "9": "LCD White LED VPA", "d": "LCD White LED TFT", "b": "LCD RGB LED", "f": "LCD RGB LED IPS", "g": "LCD RGB LED VPA", "i": "LCD RGB LED TFT", "h": "LCD RG Phosphor", "j": "LCD RG Phosphor IPS", "k": "LCD RG Phosphor VPA", "n": "LCD RG Phosphor TFT", "o": "LED OLED", "a": "LED AMOLED", "p": "DLP Projector", "q": "DLP Projector RGB Filter Wheel", "r": "DPL Projector RGBW Filter Wheel", "s": "DLP Projector RGBCMY Filter Wheel", "u": "Unknown", } result = self.exec_cmd( get_argyll_util("ccxxmake"), ["-??"], capture_output=True, skip_scripts=True, silent=True, log_output=False, ) if isinstance(result, Exception): traceback.print_exc() print(result) return dict() technology_strings = dict() in_tech = False for line in self.output: if not (parts := line.strip().split(None, 1)): continue if (arg := parts.pop(0)) == "-t": parts = parts[0].split(None, 1) if len(parts) == 2: arg = parts.pop(0) in_tech = True elif arg.startswith("-"): in_tech = False if in_tech and parts: technology_strings[arg] = parts[0] return technology_strings def has_lut_access(self): display_no = min(len(self.lut_access), getcfg("display.number")) - 1 return display_no > -1 and bool(self.lut_access[display_no]) def has_separate_lut_access(self): """Return True if separate LUT access is possible and needed.""" # Filter out Prisma, Resolve and Untethered # IMPORTANT: Also make changes to display filtering in # worker.Worker.enumerate_displays_and_ports lut_access = self.lut_access[:-3] if self.argyll_version >= [1, 6, 0]: # Filter out madVR lut_access = lut_access[:-1] if self.argyll_version >= [1, 4, 0]: # Filter out Web @ localhost lut_access = lut_access[:-1] return len(self.displays) > 1 and False in lut_access and True in lut_access def import_colorimeter_corrections(self, cmd, args=None, asroot=False): """Import colorimeter corrections. cmd can be 'i1d3ccss', 'spyd4en' or 'oeminst'""" if not args: args = [] if (is_superuser() or asroot) and "-Sl" not in args: # If we are root or need root privs anyway, install to local # system scope args.insert(0, "-Sl") return self.exec_cmd( cmd, ["-v"] + args, capture_output=True, skip_scripts=True, silent=False, asroot=asroot, ) def import_edr(self, args=None, asroot=False): """Import X-Rite .edr files""" return self.import_colorimeter_corrections( get_argyll_util("i1d3ccss"), args, asroot ) def import_spyd4cal(self, args=None, asroot=False): """Import Spyder4/5 calibrations to spy4cal.bin""" return self.import_colorimeter_corrections( get_argyll_util("spyd4en"), args, asroot ) def install_3dlut(self, path, filename=None): if getcfg("3dlut.format") == "madVR" and madvr: # Install (load) 3D LUT using madTPG print(path) hdr_to_sdr = not getcfg("3dlut.hdr_display") # Get parameters from actual 3D LUT file h3dlut = madvr.H3DLUT(path) xy = h3dlut.parametersData.get("Input_Primaries", []) smpte2084 = h3dlut.parametersData.get("Input_Transfer_Function") == "PQ" if len(xy) < 6: # Should never happen return Error("madVR 3D LUT doesn't contain Input_Primaries") slot, rgb_space_name = h3dlut.source_colorspace if slot is not None: print("Input primaries match", rgb_space_name) else: return Error( lang.getstr( "3dlut.madvr.colorspace.unsupported", [rgb_space_name or lang.getstr("unknown")] + list(xy[:6]), ) ) args = [path, True, slot] if smpte2084: methodname = "load_hdr_3dlut_file" args.append(hdr_to_sdr) lut3d_section = "HDR" if hdr_to_sdr: lut3d_section += " to SDR" else: methodname = "load_3dlut_file" lut3d_section = "calibration" print( "Installing madVR 3D LUT for {} slot {:d} ({})...".format( lut3d_section, slot, rgb_space_name ) ) try: # Connect & load 3D LUT if self.madtpg_connect() and getattr(self.madtpg, methodname)(*args): raise Info(lang.getstr("3dlut.install.success")) else: raise Error(lang.getstr("3dlut.install.failure")) except Exception as exception: return exception elif config.get_display_name(None, True) == "Prisma": try: # Use Prisma HTTP REST interface to upload 3D LUT if not self.patterngenerator: self.setup_patterngenerator() self.patterngenerator.connect() # Check preset. If it has a custom LUT assigned, we delete the # currently assigned LUT before uploading, unless its filename # is the same as the LUT to be uploaded, in which case it will # be simply overwritten, and unless the custom LUT is still # assigned to another preset as well. presetname = getcfg("patterngenerator.prisma.preset") if False: # NEVER? # Check all presets for currently assigned LUT # Check the preset we're going to use for the upload last presetnames = [ name for name in config.valid_values[ "patterngenerator.prisma.preset" ] if name != presetname ] else: # Check only the preset we're going to use for the upload presetnames = [] presetnames.append(presetname) assigned_luts = {} for presetname in presetnames: self.log("Loading Prisma preset", presetname) preset = self.patterngenerator.load_preset(presetname) assigned_lut = preset["v"].get("cube", "") if assigned_lut not in assigned_luts: assigned_luts[assigned_lut] = 0 assigned_luts[assigned_lut] += 1 # Only remove the currently assigned custom LUT if it's not # assigned to another preset if ( assigned_lut.lower().endswith(".3dl") and assigned_luts[assigned_lut] == 1 ): remove = preset["v"]["cube"] else: remove = False # Check total size of installed 3D LUTs. The Prisma has 1 MB of # custom LUT storage, which is enough for 15 67 KB LUTs. maxsize = 1024 * 67 * 15 installed = self.patterngenerator.get_installed_3dluts() rawlen = len(installed["raw"]) size = 0 numinstalled = 0 for table in installed["v"]["tables"]: if table.get("n") != remove: size += table.get("s", 0) numinstalled += 1 else: rawlen -= len( '{"n":"{}", "s":{:d}},'.format( table["n"], table.get("s", 0) ) ) filesize = os.stat(path).st_size size_exceeded = size + filesize > maxsize # NOTE that the total number of 3D LUT slots seems to be limited # to 32, which includes built-in LUTs. maxluts = 32 luts_exceeded = numinstalled >= maxluts if size_exceeded or luts_exceeded: if size_exceeded: missing = size + filesize - maxsize elif luts_exceeded: missing = filesize * (numinstalled + 1 - maxluts) else: missing = size + filesize - 1024 * 67 * 2 raise Error( lang.getstr( "3dlut.holder.out_of_memory", ( getcfg("patterngenerator.prisma.host"), round(missing / 1024.0), getcfg("patterngenerator.prisma.host"), "Prisma", ), ) ) if remove and remove != filename: self.log("Removing currently assigned LUT", remove) self.patterngenerator.remove_3dlut(remove) self.log("Uploading LUT", path, "as", filename) self.patterngenerator.load_3dlut_file(path, filename) self.log("Setting LUT", filename) self.patterngenerator.set_3dlut(filename) self.log("Setting PrismaVue to zero") self.patterngenerator.set_prismavue(0) except Exception as exception: return exception return Info(lang.getstr("3dlut.install.success")) else: return Error(lang.getstr("3dlut.install.unsupported")) def install_profile( self, profile_path, capture_output=True, skip_scripts=False, silent=False ): """Install a profile by copying it to an appropriate location and registering it with the system""" colord_install = None oy_install = None argyll_install = self._install_profile_argyll( profile_path, capture_output, skip_scripts, silent ) if isinstance(argyll_install, str): # The installed name may be different due to escaping non-ASCII # chars (see prepare_dispwin), so get the profile path profile_path = argyll_install argyll_install = True if sys.platform == "win32": # Assign profile to active display display_no = min(len(self.displays), getcfg("display.number")) - 1 monitors = util_win.get_real_display_devices_info() moninfo = monitors[display_no] displays = util_win.get_display_devices(moninfo["Device"]) active_display = util_win.get_active_display_device(None, displays) if not active_display: self.log(f"{appname}: Warning - no active display device!") if not displays: self.log( f"{appname}: Warning - could not enumerate " "display devices for {}!".format(moninfo["Device"]) ) elif active_display.DeviceKey != displays[0].DeviceKey: self.log(f"{appname}: Setting profile for active display device...") try: set_display_profile( os.path.basename(profile_path), devicekey=active_display.DeviceKey, ) except Exception as exception: # Not a critical error. Only log the exception. if ( isinstance(exception, EnvironmentError) and not exception.filename and not os.path.isfile(profile_path) ): exception.filename = profile_path self.log( f"{appname}: Warning - could not set profile for " "active display device:", exception, ) else: self.log(f"{appname}: ...ok") loader_install = None profile = None try: profile = ICCProfile(profile_path) except (IOError, ICCProfileInvalidError) as exception: return exception device_id = self.get_device_id(quirk=False, query=True) if ( sys.platform not in ("darwin", "win32") and not getcfg("dry_run") and ( argyll_install is not True or self.argyll_version < [1, 6] or not os.getenv("ARGYLL_USE_COLORD") or not dlopen("libcolordcompat.so") ) and which("colormgr") ): if device_id: result = self._attempt_install_profile_colord(profile, device_id) colord_install = result if not device_id or result is not True: gcm_import = bool(which("gcm-import")) if gcm_import: self._install_profile_gcm(profile) # gcm-import doesn't seem to return a useful exit code or # stderr output, so check for our profile profilename = os.path.basename(profile.fileName) for dirname in iccprofiles_home: profile_install_path = os.path.join(dirname, profilename) if os.path.isfile(profile_install_path): colord_install = Warn(lang.getstr("profile.import.success")) break if which("oyranos-monitor") and self.check_display_conf_oy_compat( getcfg("display.number") ): if device_id: profile_name = re.sub(r"[- ]", "_", device_id.lower()) + ".icc" else: profile_name = None result = self._install_profile_oy( profile_path, profile_name, capture_output, skip_scripts, silent ) oy_install = result if argyll_install is not True and ( (colord_install and not isinstance(colord_install, colord.CDError)) or oy_install is True ): # Ignore Argyll install errors if colord or Oyranos install was # succesful argyll_install = None # Check if atleast one of our profile install methods did return a # result that is not an error for result in (argyll_install, colord_install, oy_install): check = result is True or isinstance(result, Warning) if check: break # Only go on to create profile loader if profile loading on login # isn't disabled in the config file, and we are not under Mac OS X # (no loader required there), and if atleast one of our profile # install methods did return a result that is not an error if getcfg("profile.load_on_login") and sys.platform != "darwin" and check: # Create profile loader. Failing to create it is a critical error # under Windows if calibration loading isn't handled by the OS # (this is checked), and also under Linux if colord profile install # failed (colord handles loading otherwise) check = sys.platform == "win32" or ( not colord_install or isinstance(colord_install, colord.CDError) ) if getcfg("profile.install_scope") == "l" and sys.platform != "win32": # We need a system-wide config file to store the path to # the Argyll binaries for the profile loader if not config.makecfgdir("system", self) or ( not config.writecfg("system", self) and check ): # If the system-wide config dir could not be created, # or the system-wide config file could not be written, # error out if under Linux and colord profile install failed return Error(lang.getstr("error.autostart_system")) if sys.platform == "win32": loader_install = self._install_profile_loader_win32(silent) else: loader_install = self._install_profile_loader_xdg(silent) if loader_install is not True and check: return loader_install # Check if atleast one of our profile install methods returned a result for result in (argyll_install, colord_install, oy_install): if result is not None: return argyll_install, colord_install, oy_install, loader_install if not result: # This should never happen result = Error(lang.getstr("profile.install.error")) return result def install_argyll_instrument_conf(self, uninstall=False, filenames=None): """(Un-)install Argyll CMS instrument configuration under Linux""" udevrules = "/etc/udev/rules.d" hotplug = "/etc/hotplug" if not os.path.isdir(udevrules) and not os.path.isdir(hotplug): return Error(lang.getstr("udev_hotplug.unavailable")) if not filenames: filenames = get_argyll_instrument_config("installed" if uninstall else None) if not filenames: return Error( "\n".join( lang.getstr("file.missing", filename) for filename in get_argyll_instrument_config("expected") ) ) if uninstall: backupbase = os.path.join( config.datahome, "backup", strftime("%Y%m%dT%H%M%S") ) for filename in filenames: if filename.endswith(".rules"): dst = udevrules else: dst = hotplug if uninstall: # Move file to backup location backupdir = "".join([backupbase, os.path.dirname(filename)]) if not os.path.isdir(backupdir): os.makedirs(backupdir) cmd, args = "mv", [filename, "".join([backupbase, filename])] else: cmd, args = "cp", ["--remove-destination", filename] args.append(os.path.join(dst, os.path.basename(filename))) result = self.exec_cmd( cmd, args, capture_output=True, skip_scripts=True, asroot=True ) if result is not True: break elif not uninstall: self.exec_cmd( "chmod", ["0644", args[-1]], capture_output=True, skip_scripts=True, asroot=True, ) install_result = result paths = ["/sbin", "/usr/sbin"] paths.extend(getenvu("PATH", os.defpath).split(os.pathsep)) if not uninstall: if not isinstance(result, Exception) and result: # Add colord group if it does not exist if "colord" not in [g.gr_name for g in grp.getgrall()]: groupadd = which("groupadd", paths) if groupadd: result = self.exec_cmd( groupadd, ["colord"], capture_output=True, skip_scripts=True, asroot=True, ) if not isinstance(result, Exception) and result: # Add user to colord group if not yet a member if "colord" not in getgroups(getpass.getuser(), True): usermod = which("usermod", paths) if usermod: result = self.exec_cmd( usermod, ["-a", "-G", "colord", getpass.getuser()], capture_output=True, skip_scripts=True, asroot=True, ) if install_result is True and dst == udevrules: # Reload udev rules udevadm = which("udevadm", paths) if udevadm: result = self.exec_cmd( udevadm, ["control", "--reload-rules"], capture_output=True, skip_scripts=True, asroot=True, ) return result def install_argyll_instrument_drivers(self, uninstall=False, launch_devman=False): """(Un-)install the Argyll CMS instrument drivers under Windows""" winxp = sys.getwindowsversion() < (6,) if launch_devman: if winxp: cmd = "start" args = ["mmc", "devmgmt.msc"] else: cmd = "mmc" args = ["devmgmt.msc"] self.exec_cmd( cmd, args, capture_output=True, skip_scripts=True, asroot=not winxp, shell=winxp, working_dir=False, ) if uninstall: if not winxp: # Windows Vista and newer with win64_disable_file_system_redirection(): pnputil = which("PnPutil.exe") if not pnputil: return Error(lang.getstr("file.missing", "PnPutil.exe")) result = self.exec_cmd( pnputil, ["-e"], capture_output=True, log_output=False, silent=True, skip_scripts=True, ) if not result: return Error( lang.getstr("argyll.instrument.drivers.uninstall.failure") ) elif isinstance(result, Exception): return result output = universal_newlines("".join(self.output)) for entry in output.split("\n\n"): entry = [ line.split(":", 1)[-1].strip() for line in entry.split("\n") ] for value in entry: if value == "ArgyllCMS": result = self.exec_cmd( pnputil, ["-f", "-d", entry[0]], capture_output=True, skip_scripts=True, asroot=True, ) else: # Windows XP # Uninstallation not supported pass else: # Install driver using modified 'zadic' command line tool from # https://github.com/fhoech/libwdi result = None # Get Argyll version argyll_version_string = self.argyll_version_string if argyll_version_string == "0.0.0": # Download version info resp = http_request( None, DOMAIN, "GET", "/Argyll/VERSION", failure_msg=lang.getstr("update_check.fail"), silent=True, ) if resp: argyll_version_string = resp.read().strip() installer_basename = "ArgyllCMS_install_USB.exe" download_dir = os.path.join(config.datahome, "dl") installer = os.path.join( download_dir, f"Argyll_V{argyll_version_string}", "usb", installer_basename, ) if not os.path.isfile(installer): # Update installer_basename to the one that is used in DisplayCAL.net installer_basename = ( f"Argyll_V{argyll_version_string}_USB_driver_installer.exe" ) installer_zip = self.download( f"https://{DOMAIN}/Argyll/{installer_basename}.zip" ) if isinstance(installer_zip, Exception): return installer_zip elif not installer_zip: # Cancelled return installer = os.path.splitext(installer_zip)[0] # Open installer ZIP archive try: with zipfile.ZipFile(installer_zip) as z: # Extract installer if it does not exist or if the existing # file is different from the one in the archive if os.path.isfile(installer): with open(installer, "rb") as f: crc = zlib.crc32(f.read()) else: crc = None if ( not os.path.isfile(installer) or crc != z.getinfo(installer_basename).CRC ): z.extract( installer_basename, os.path.dirname(installer_zip) ) except Exception as exception: return exception # Get supported instruments USB device IDs usb_ids = {} for instrument_name in all_instruments: instrument = all_instruments[instrument_name] if instrument.get("usb_ids"): for entry in instrument.get("usb_ids"): usb_id = (entry["vid"], entry["pid"]) if entry.get("hid"): # Skip HID devices continue else: usb_ids[usb_id] = usb_ids.get(usb_id, [instrument_name]) usb_ids[usb_id].append(instrument_name) # Check connected USB devices for supported instruments not_main_thread = currentThread().__class__.__name__ != "_MainThread" if not_main_thread: # If running in a thread, need to call pythoncom.CoInitialize pythoncom.CoInitialize() try: if not wmi: raise NotImplementedError("WMI not available") wmi_connection = wmi.WMI() query = "Select * From Win32_USBControllerDevice" for item in wmi_connection.query(query): try: device_id = item.Dependent.DeviceID except wmi.x_wmi as exception: self.log(exception) continue for usb_id in usb_ids: instrument_names = usb_ids[usb_id] hardware_id = r"USB\VID_{:04X}&PID_{:04X}".format(*usb_id) if device_id.startswith(hardware_id): # Found supported instrument try: self.log(item.Dependent.Caption) except wmi.x_wmi: self.log(", ".join(instrument_names)) # Install driver for specific device result = self.exec_cmd( installer, [ "--noprompt", "--usealldevices", "--vid", hex(usb_id[0]), "--pid", hex(usb_id[1]), ], capture_output=True, skip_scripts=True, asroot=True, ) output = universal_newlines("".join(self.output)) if isinstance(result, Exception): return result elif not result or "Failed to install driver" in output: return Error( lang.getstr( "argyll.instrument.drivers.install.failure" ) ) except Exception as exception: self.log(exception) finally: if not_main_thread: # If running in a thread, need to call pythoncom.CoUninitialize pythoncom.CoUninitialize() if not result: # No matching device found. Install driver anyway, doesn't # matter for which specific device as the .inf contains entries # for all supported ones, thus instruments that are connected # later should be recognized usb_id, instrument_names = usb_ids.popitem() result = self.exec_cmd( installer, [ "--noprompt", "--vid", hex(usb_id[0]), "--pid", hex(usb_id[1]), "--create", f"{instrument_names[-1]} (Argyll)", ], capture_output=True, skip_scripts=True, asroot=True, ) output = universal_newlines("".join(self.output)) if not result or "Failed to install driver" in output: return Error( lang.getstr("argyll.instrument.drivers.install.failure") ) return result def _install_profile_argyll( self, profile_path, capture_output=False, skip_scripts=False, silent=False ): """Install profile using dispwin. Return the profile path, an error or False """ if sys.platform == "darwin" and False: # NEVER # Alternate way of 'installing' the profile under OS X by just # copying it profiles = os.path.join("Library", "ColorSync", "Profiles") profile_install_path = os.path.join( profiles, os.path.basename(profile_path) ) network = os.path.join(os.path.sep, "Network", profiles) if getcfg("profile.install_scope") == "l": profile_install_path = os.path.join(os.path.sep, profile_install_path) elif getcfg("profile.install_scope") == "n" and os.path.isdir(network): profile_install_path = os.path.join(network, profile_install_path) else: profile_install_path = os.path.join( os.path.expanduser("~"), profile_install_path ) cmd, args = "cp", ["-f", profile_path, profile_install_path] result = self.exec_cmd( cmd, args, capture_output, low_contrast=False, skip_scripts=skip_scripts, silent=silent, asroot=getcfg("profile.install_scope") in ("l", "n"), title=lang.getstr("profile.install"), ) if not isinstance(result, Exception) and result: self.output = ["Installed"] else: cmd, args = self.prepare_dispwin(None, profile_path, True) if not isinstance(cmd, Exception): profile_path = args[-1] if sys.platform == "win32" and sys.getwindowsversion() >= (6,): # Set/unset per-user profiles under Vista / Windows 7 idx = getcfg("display.number") - 1 try: device0 = util_win.get_display_device(idx, exception_cls=None) devicea = util_win.get_display_device(idx, True) except Exception as exception: self.log(f"util_win.get_display_device({idx}):", exception) else: per_user = "-Sl" not in args for i, device in enumerate((device0, devicea)): if not device: self.log( "Warning: There is no {} display " "device to {} per-user profiles".format( "1st" if i == 0 else "active", "enable" if per_user else "disable", ) ) continue try: util_win.enable_per_user_profiles( per_user, devicekey=device.DeviceKey ) except Exception as exception: self.log( "util_win.enable_per_user_profiles({}, devicekey={}): {}".format( per_user, repr(device.DeviceKey), exception ) ) if "-Sl" in args and ( sys.platform != "darwin" or intlist(mac_ver()[0].split(".")) >= [10, 6] ): # If a 'system' install is requested under Linux, # Mac OS X >= 10.6 or Windows, # install in 'user' scope first because a system-wide install # doesn't also set it as current user profile on those systems # (on Mac OS X < 10.6, we can use ColorSyncScripting to set it). # It has the small drawback under Linux and OS X 10.6 that # it will copy the profile to both the user and system-wide # locations, though, which is not a problem under Windows as # they are the same. args.remove("-Sl") result = self.exec_cmd( cmd, args, capture_output, low_contrast=False, skip_scripts=skip_scripts, silent=silent, title=lang.getstr("profile.install"), ) output = list(self.output) args.insert(0, "-Sl") else: output = None result = True if not isinstance(result, Exception) and result: result = self.exec_cmd( cmd, args, capture_output, low_contrast=False, skip_scripts=skip_scripts, silent=silent, title=lang.getstr("profile.install"), ) else: result = cmd if not isinstance(result, Exception) and result is not None: result = False for line in output or self.output: if "Installed" in line: if ( sys.platform == "darwin" and "-Sl" in args and intlist(mac_ver()[0].split(".")) < [10, 6] ): # The profile has been installed, but we need a little # help from AppleScript to actually make it the default # for the current user. Only works under Mac OS < 10.6 n = getcfg("display.number") path = os.path.join( os.path.sep, "Library", "ColorSync", "Profiles", os.path.basename(args[-1]), ) applescript = [ 'tell app "ColorSyncScripting"', f'set displayProfile to POSIX file "{path}" as alias', f"set display profile of display {n:d} to displayProfile", "end tell", ] try: retcode, output, errors = osascript(applescript) except Exception as exception: self.log(exception) else: if errors.strip(): self.log(f"osascript error: {errors}") else: result = True break elif sys.platform == "darwin" and False: # NEVER # After 'installing' a profile under Mac OS X by just # copying it, show system preferences applescript = [ 'tell application "System Preferences"', "activate", 'set current pane to pane id "com.apple.preference.displays"', 'reveal (first anchor of current pane whose name is "displaysColorTab")', # This needs access for assistive devices enabled # 'tell application "System Events"', # 'tell process "System Preferences"', # 'select row 2 of table 1 of scroll area 1 of group 1 of tab group 1 of window ""', # 'end tell', # 'end tell', "end tell", ] try: retcode, output, errors = osascript(applescript) except Exception as exception: self.log(exception) else: if errors.strip(): self.log(f"osascript error: {errors}") else: result = True else: result = True break if not result and self.errors: result = Error("".join(self.errors).strip()) else: result = profile_path # DO NOT call wrapup() here, it'll remove the profile in the temp # directory before dispwin can get a hold of it when running with UAC # under Windows, because that makes the call to dispwin run in a # separate thread. DisplayCAL.MainFrame.profile_finish_consumer calls # DisplayCAL.MainFrame.start_timers(True) after displaying the result # message which takes care of cleanup. return result def _install_profile_colord(self, profile, device_id): """Install profile using colord""" self.log(f"{appname}: Trying device ID {device_id}") try: colord.install_profile(device_id, profile, logfn=self.log) except Exception as exception: self.log(exception) return exception return True def _attempt_install_profile_colord(self, profile, device_id=None): if not device_id: device_id = self.get_device_id(quirk=False, query=True) if device_id: result = False # Try a range of possible device IDs device_ids = [ device_id, self.get_device_id(quirk=True, truncate_edid_strings=True), self.get_device_id(quirk=True, use_serial_32=False), self.get_device_id( quirk=True, use_serial_32=False, truncate_edid_strings=True ), self.get_device_id(quirk=True), self.get_device_id(quirk=False, truncate_edid_strings=True), self.get_device_id(quirk=False, use_serial_32=False), self.get_device_id( quirk=False, use_serial_32=False, truncate_edid_strings=True ), # Try with manufacturer omitted self.get_device_id(omit_manufacturer=True), self.get_device_id(truncate_edid_strings=True, omit_manufacturer=True), self.get_device_id(use_serial_32=False, omit_manufacturer=True), self.get_device_id( use_serial_32=False, truncate_edid_strings=True, omit_manufacturer=True, ), ] for device_id in dict.fromkeys(device_ids).keys(): if device_id: # NOTE: This can block result = self._install_profile_colord(profile, device_id) if isinstance(result, colord.CDObjectQueryError): # Device ID was not found, try next one continue else: # Either returned ok or there was another error break return result def _install_profile_gcm(self, profile): """Install profile using gcm-import""" if which("colormgr"): # Check if profile already exists in database try: colord.get_object_path("icc-" + hexlify(profile.ID).decode(), "profile") except colord.CDObjectQueryError: # Profile not in database pass except colord.CDError as exception: self.log(exception) else: # Profile already in database, nothing to do return None # gcm-import will check if the profile is already in the database # (based on profile ID), but will fail to overwrite a profile with the # same name. We need to remove those profiles so gcm-import can work. profilename = os.path.basename(profile.fileName) for dirname in iccprofiles_home: profile_install_path = os.path.join(dirname, profilename) if ( os.path.isfile(profile_install_path) and profile_install_path != profile.fileName ): try: send2trash([profile_install_path]) except OSError as exc: self.log(exc) else: # Give colord time to recognize that the profile was # removed, otherwise gcm-import may complain if it's # a profile that was already in the database sleep(3) if self._progress_wnd and not getattr(self._progress_wnd, "dlg", None): self._progress_wnd.dlg = DummyDialog() # Run gcm-import cmd, args = which("gcm-import"), [profile.fileName] # gcm-import does not seem to return a useful exit code (it's always 1) # or stderr output self.exec_cmd(cmd, args, capture_output=True, skip_scripts=True) def _install_profile_oy( self, profile_path, profile_name=None, capture_output=False, skip_scripts=False, silent=False, ): """Install profile using oyranos-monitor""" display = self.displays[ max(0, min(len(self.displays) - 1, getcfg("display.number") - 1)) ] x, y = [pos.strip() for pos in display.split("@")[-1].split(",")[0:2]] if getcfg("profile.install_scope") == "l": # If system-wide install, copy profile to # /var/lib/color/icc/devices/display var_icc = "/var/lib/color/icc/devices/display" if not profile_name: profile_name = os.path.basename(profile_path) profile_install_path = os.path.join(var_icc, profile_name) result = self.exec_cmd( "mkdir", ["-p", os.path.dirname(profile_install_path)], capture_output=True, low_contrast=False, skip_scripts=True, silent=True, asroot=True, ) if not isinstance(result, Exception) and result: result = self.exec_cmd( "cp", ["-f", profile_path, profile_install_path], capture_output=True, low_contrast=False, skip_scripts=True, silent=True, asroot=True, ) else: result = True dirname = None for dirname in iccprofiles_display_home: if os.path.isdir(dirname): # Use the first one that exists break else: dirname = None if not dirname: # Create the first one in the list dirname = iccprofiles_display_home[0] try: os.makedirs(dirname) except Exception as exception: self.log(exception) result = False if result is not False: profile_install_path = os.path.join( dirname, os.path.basename(profile_path) ) try: shutil.copyfile(profile_path, profile_install_path) except Exception as exception: self.log(exception) result = False if not isinstance(result, Exception) and result is not False: cmd = which("oyranos-monitor") args = ["-x", x, "-y", y, profile_install_path] result = self.exec_cmd( cmd, args, capture_output, low_contrast=False, skip_scripts=skip_scripts, silent=silent, working_dir=False, ) # if getcfg("profile.install_scope") == "l": # result = self.exec_cmd(cmd, args, # capture_output, # low_contrast=False, # skip_scripts=skip_scripts, # silent=silent, # asroot=True, # working_dir=False) if not result and self.errors: result = Error("".join(self.errors).strip()) return result def _install_profile_loader_win32(self, silent=False): """Install profile loader""" if ( sys.platform == "win32" and sys.getwindowsversion() >= (6, 1) and util_win.calibration_management_isenabled() ): self._uninstall_profile_loader_win32() return True # Must return either True on success or an Exception object on error result = True # Remove outdated (pre-0.5.5.9) profile loaders display_no = self.get_display() name = f"{appname} Calibration Loader (Display {display_no})" if autostart_home: loader_v01b = os.path.join(autostart_home, f"dispwin-d{display_no}-c-L.lnk") if os.path.exists(loader_v01b): try: # delete v0.1b loader os.remove(loader_v01b) except Exception as exception: self.log( "Warning - could not remove old " "v0.1b calibration loader '{}': {}".format( loader_v01b, exception ) ) loader_v02b = os.path.join(autostart_home, f"{name}.lnk") if os.path.exists(loader_v02b): try: # delete v02.b/v0.2.1b loader os.remove(loader_v02b) except Exception as exception: self.log( "Warning - could not remove old " "v0.2b calibration loader '{}': {}".format( loader_v02b, exception ) ) loader_v0558 = os.path.join(autostart_home, name + ".lnk") if os.path.exists(loader_v0558): try: # delete v0.5.5.8 user loader os.remove(loader_v0558) except Exception as exception: self.log( "Warning - could not remove old " "v0.2b calibration loader '{}': {}".format( loader_v02b, exception ) ) if autostart: loader_v0558 = os.path.join(autostart, f"{name}.lnk") if os.path.exists(loader_v0558): try: # delete v0.5.5.8 system loader os.remove(loader_v0558) except Exception as exception: self.log( "Warning - could not remove old " "v0.2b calibration loader '{}': {}".format( loader_v02b, exception ) ) # Create unified loader name = f"{appname} Profile Loader" if autostart: autostart_lnkname = os.path.join(autostart, name + ".lnk") if autostart_home: autostart_home_lnkname = os.path.join(autostart_home, name + ".lnk") loader_args = [] if os.path.basename(exe).lower() in ("python.exe", "pythonw.exe"): cmd = os.path.join(exedir, "pythonw.exe") pyw = os.path.normpath( os.path.join(pydir, "..", f"{appname}-apply-profiles.pyw") ) if os.path.exists(pyw): # Running from source or 0install # Check if this is a 0install implementation, in which # case we want to call 0launch with the appropriate # command if re.match( r"sha\d+(?:new)?", os.path.basename(os.path.dirname(pydir)) ): cmd = which("0install-win.exe") or "0install-win.exe" loader_args.extend( [ "run", "--batch", "--no-wait", "--offline", "--command=run-apply-profiles", f"http://{DOMAIN}/0install/{appname}.xml", ] ) else: # Running from source loader_args.append(pyw) else: # Regular install loader_args.append( get_data_path(os.path.join("scripts", f"{appname}-apply-profiles")) ) else: cmd = os.path.join(pydir, f"{appname}-apply-profiles.exe") not_main_thread = currentThread().__class__.__name__ != "_MainThread" if not_main_thread: # If running in a thread, need to call pythoncom.CoInitialize pythoncom.CoInitialize() from DisplayCAL import taskscheduler try: ts = taskscheduler.TaskScheduler() except Exception as exception: print("Warning - could not access task scheduler:", exception) ts = None task = None else: task = ts.query_task(f"{appname} Profile Loader Launcher") elevate = getcfg( "profile.install_scope" ) == "l" and sys.getwindowsversion() >= (6,) loader_lockfile = os.path.join( config.confighome, appbasename + "-apply-profiles.lock" ) loader_running = os.path.isfile(loader_lockfile) if not loader_running or (not task and elevate): # Launch profile loader if not yet running, or restart if no task # and going to elevate (launching profile loader with elevated # privileges will try to create scheduled task so we can run # elevated at login without UAC prompt) errmsg = "Warning - could not launch profile loader" if elevate: errmsg += " with elevated privileges" try: shell_exec( cmd, loader_args + ["--skip"], operation="runas" if elevate else "open", wait_for_idle=True, ) except pywintypes.error as exception: if exception.args[0] == winerror.ERROR_CANCELLED: errmsg += " (user cancelled)" else: errmsg += " " + safe_str(exception) print(errmsg) if task or (ts and ts.query_task(f"{appname} Profile Loader Launcher")): if not_main_thread: pythoncom.CoUninitialize() return True try: scut = pythoncom.CoCreateInstance( win32com_shell.CLSID_ShellLink, None, pythoncom.CLSCTX_INPROC_SERVER, win32com_shell.IID_IShellLink, ) scut.SetPath(cmd) if len(loader_args) == 1: scut.SetWorkingDirectory(pydir) if os.path.basename(cmd) == f"{appname}-apply-profiles.exe": scut.SetIconLocation(cmd, 0) else: scut.SetIconLocation( get_data_path( os.path.join("theme", "icons", f"{appname}-apply-profiles.ico") ), 0, ) scut.SetArguments(sp.list2cmdline(loader_args)) scut.SetShowCmd(win32con.SW_SHOWDEFAULT) if is_superuser(): if autostart: try: scut.QueryInterface(pythoncom.IID_IPersistFile).Save( autostart_lnkname, 0 ) except Exception as exception: if not silent: result = Warning( lang.getstr("error.autostart_creation", autostart) + "\n" + str(exception) ) # Now try user scope else: if not silent: result = Warning(lang.getstr("error.autostart_system")) if autostart_home: if autostart and os.path.isfile(autostart_lnkname): # Remove existing user loader if os.path.isfile(autostart_home_lnkname): os.remove(autostart_home_lnkname) else: # Only create user loader if no system loader try: scut.QueryInterface(pythoncom.IID_IPersistFile).Save( autostart_home_lnkname, 0 ) except Exception as exception: if not silent: result = Warning( lang.getstr("error.autostart_creation", autostart_home) + "\n" + str(exception) ) else: if not silent: result = Warning(lang.getstr("error.autostart_user")) except Exception as exception: if not silent: result = Warning( lang.getstr("error.autostart_creation", autostart_home) + "\n" + str(exception) ) finally: if not_main_thread: # If running in a thread, need to call pythoncom.CoUninitialize pythoncom.CoUninitialize() return result def _uninstall_profile_loader_win32(self): """Uninstall profile loader""" name = f"{appname} Profile Loader" if autostart and is_superuser(): autostart_lnkname = os.path.join(autostart, name + ".lnk") if os.path.exists(autostart_lnkname): try: os.remove(autostart_lnkname) except Exception as exception: self.log(autostart_lnkname, exception) if autostart_home: autostart_home_lnkname = os.path.join(autostart_home, name + ".lnk") if os.path.exists(autostart_home_lnkname): try: os.remove(autostart_home_lnkname) except Exception as exception: self.log(autostart_home_lnkname, exception) return True def _install_profile_loader_xdg(self, silent=False): """Install profile loader""" # See http://standards.freedesktop.org/autostart-spec # Must return either True on success or an Exception object on error result = True # Remove wrong-cased entry potentially created by DisplayCAL < 3.1.6 name = f"z-{appname}-apply-profiles" desktop_file_path = os.path.join(autostart_home, f"{name}.desktop") if os.path.exists(desktop_file_path): try: os.remove(desktop_file_path) except Exception as exception: result = Warning( lang.getstr("error.autostart_remove_old", desktop_file_path) ) # Create unified loader # Prepend 'z' so our loader hopefully loads after # possible nvidia-settings entry (which resets gamma table) name = f"z-{appname.lower()}-apply-profiles" desktop_file_path = os.path.join(autostart_home, f"{name}.desktop") system_desktop_file_path = os.path.join(autostart, f"{name}.desktop") try: # Create user loader, even if we later try to # move it to the system-wide location so that at least # the user loader is present if the move to the system # dir fails if not os.path.exists(autostart_home): os.makedirs(autostart_home) desktop_file_buffer = [] desktop_file_buffer.append("[Desktop Entry]") desktop_file_buffer.append("Version=1.0") desktop_file_buffer.append("Encoding=UTF-8") desktop_file_buffer.append("Type=Application") desktop_file_buffer.append(f"Name={appname} ICC Profile Loader") desktop_file_buffer.append( "Comment={}".format( lang.getstr("calibrationloader.description", lcode="en") ) ) if lang.getcode() != "en": desktop_file_buffer.append( ( "Comment[{}]={}".format( lang.getcode(), lang.getstr("calibrationloader.description") ) ) ) pyw = os.path.normpath( os.path.join(pydir, "..", f"{appname}-apply-profiles.pyw") ) icon = f"{appname.lower()}-apply-profiles" if os.path.exists(pyw): # Running from source, or 0install/installer install # Check if this is a 0install implementation, in which # case we want to call 0launch with the appropriate # command if re.match( r"sha\d+(?:new)?", os.path.basename(os.path.dirname(pydir)) ): executable = ( "0launch --console --offline " "--command=run-apply-profiles " f"http://{DOMAIN}/0install/{appname}.xml" ) else: icon = os.path.join( pydir, "theme", "icons", "256x256", f"{appname.lower()}-apply-profiles.png", ) executable = pyw else: # Regular install executable = f"{appname.lower()}-apply-profiles" desktop_file_buffer.append(f"Icon={icon}") desktop_file_buffer.append(f"Exec={executable}") desktop_file_buffer.append("Terminal=false") with open(desktop_file_path, "w") as desktop_file: desktop_file.write("\n".join(desktop_file_buffer)) except Exception as exception: if not silent: result = Warning( lang.getstr("error.autostart_creation", desktop_file_path) + "\n" + str(exception) ) else: if getcfg("profile.install_scope") == "l" and autostart: # Move system-wide loader if ( self.exec_cmd( "mkdir", ["-p", autostart], capture_output=True, low_contrast=False, skip_scripts=True, silent=True, asroot=True, ) is not True or self.exec_cmd( "mv", ["-f", desktop_file_path, system_desktop_file_path], capture_output=True, low_contrast=False, skip_scripts=True, silent=True, asroot=True, ) is not True ) and not silent: result = Warning( lang.getstr( "error.autostart_creation", system_desktop_file_path ) ) return result def instrument_supports_ccss(self, instrument_name=None): """Return whether instrument supports CCSS files or not""" if not instrument_name: instrument_name = self.get_instrument_name() return self.get_instrument_features(instrument_name).get("spectral_cal") def create_ccxx(self, args=None, working_dir=None): """Create CCMX or CCSS""" if not args: args = [] cmd = get_argyll_util("ccxxmake") if "-I" not in args: # Display manufacturer & name name = self.get_display_name(True) if name: args.insert(0, "-I") args.insert(1, name) elif "-T" not in args: # Display technology args.insert(0, "-T") displaytech = ["LCD" if getcfg("measurement_mode") == "l" else "CRT"] if self.get_instrument_features().get("projector_mode") and getcfg( "measurement_mode.projector" ): displaytech.append("Projector") args.insert(1, " ".join(displaytech)) if not getcfg("ccmx.use_four_color_matrix_method"): args.insert(0, "-v") return self.exec_cmd( cmd, args, capture_output=True, skip_scripts=True, silent=False, working_dir=working_dir, ) def create_gamut_views(self, profile_path): """Generate gamut views (VRML files) and show progress in current progress dialog""" if getcfg("profile.create_gamut_views"): self.log("-" * 80) self.log(lang.getstr("gamut.view.create")) self.lastmsg.clear() self.recent.clear() self.recent.write(lang.getstr("gamut.view.create")) sleep(0.75) # Allow time for progress window to update return self.calculate_gamut(profile_path) else: return None, None def create_profile( self, dst_path=None, skip_scripts=False, display_name=None, display_manufacturer=None, tags=None, ): """Create an ICC profile and process the generated file""" print(lang.getstr("create_profile")) if dst_path is None: dst_path = os.path.join( getcfg("profile.save_path"), getcfg("profile.name.expanded"), getcfg("profile.name.expanded") + profile_ext, ) cmd, args = self.prepare_colprof( os.path.basename(os.path.splitext(dst_path)[0]), display_name, display_manufacturer, tags, ) if isinstance(cmd, Exception): result = cmd else: result = True profile = None profile_path = args[-1] + profile_ext if "-aX" in args: # If profile type is X (XYZ cLUT + matrix), only create the # cLUT, then add the matrix tags later from a forward lookup of # a smaller testchart (faster computation!) args.insert(args.index("-aX"), "-ax") args.remove("-aX") check_for_ti1_match = False is_regular_grid = False is_primaries_only = False ti3 = CGATS(args[-1] + ".ti3") XYZbp = None try: ( ti3_extracted, ti3_RGB_XYZ, ti3_remaining, ) = extract_device_gray_primaries(ti3, logfn=self.log) except Error as exception: self.log(exception) else: if getcfg("profile.type") in ("X", "x", "S", "s"): # Check if TI3 RGB matches one of our regular grid or # primaries + gray charts check_for_ti1_match = True if ti3_RGB_XYZ[(0, 0, 0)] != (0, 0, 0): # Note: Setting black chroma to zero fixes smoothness # issues on devices with not very neutral black. bpcorr = getcfg("profile.black_point_correction") if False: # getcfg("profile.black_point_compensation"): XYZbp = (0, 0, 0) Labbp = (0, 0, 0) else: # Correct black point a* b* and make neutral hues near # black blend over to the new blackpoint. The correction # factor determines the amount of the measured black hue # that should be retained. # It makes the profile slightly less accurate near # black, but the effect is negligible and the visual # benefit is of greater importance (allows for # calibration blackpoint hue correction to have desired # effect, and makes relcol with BPC visually match # perceptual in Photoshop). XYZwp = ti3_RGB_XYZ[(100, 100, 100)] Labbp = colormath.XYZ2Lab( *ti3_RGB_XYZ[(0, 0, 0)], whitepoint=XYZwp ) Labbp = (Labbp[0], Labbp[1] * bpcorr, Labbp[2] * bpcorr) XYZbp = colormath.Lab2XYZ( *Labbp, whitepoint=[v / XYZwp[1] for v in XYZwp] ) if XYZbp and bpcorr < 1: ti3.write(args[-1] + ".ti3.backup") if False: # getcfg("profile.black_point_compensation"): logmsg = "Applying black point compensation" else: logmsg = ( f"Applying {bpcorr * 100:0.0f}% black point correction" ) self.log(f"{logmsg} to TI3") ti3[0].apply_bpc(XYZbp) ti3.write() if check_for_ti1_match: for ti1_name in ( "ti1/d3-e4-s2-g28-m0-b0-f0", # Primaries + gray "ti1/d3-e4-s3-g52-m3-b0-f0", # 3^3 grid "ti1/d3-e4-s4-g52-m4-b0-f0", # 4^3 grid "ti1/d3-e4-s5-g52-m5-b0-f0", # 5^3 grid "ti1/d3-e4-s9-g52-m9-b0-f0", # 9^3 grid "ti1/d3-e4-s17-g52-m17-b0-f0", ): # 17^3 grid ti1_filename = f"{ti1_name}.ti1" ti1_path = get_data_path(ti1_filename) if not ti1_path: if ti1_name in ( "ti1/d3-e4-s2-g28-m0-b0-f0", "ti1/d3-e4-s3-g52-m3-b0-f0", "ti1/d3-e4-s4-g52-m4-b0-f0", "ti1/d3-e4-s5-g52-m5-b0-f0", ): return Error(lang.getstr("file.missing", ti1_filename)) else: continue ti1 = CGATS(ti1_path) ( ti1_extracted, ti1_RGB_XYZ, ti1_remaining, ) = extract_device_gray_primaries(ti1) # Quantize to 8 bit for comparison # XXX Note that round(50 * 2.55) = 127, but # round(50 / 100 * 255) = 128 (the latter is what we want)! if sorted( tuple(round(v / 100.0 * 255) for v in RGB) for RGB in list(ti3_remaining.keys()) ) == sorted( tuple(round(v / 100.0 * 255) for v in RGB) for RGB in list(ti1_remaining.keys()) ): if ti1_name == "ti1/d3-e4-s2-g28-m0-b0-f0": is_primaries_only = True if getcfg("profile.type") not in ("S", "s"): options_dispcal = get_options_from_ti3(ti3)[0] setcfg( "profile.type", "S" if get_arg("q", options_dispcal) else "s", ) elif getcfg("profile.type") in ("X", "x"): is_regular_grid = True break if not display_name: arg = get_arg("-M", args, True) if arg and len(args) - 1 > arg[0]: display_name = args[arg[0] + 1] if not display_manufacturer: arg = get_arg("-A", args, True) if arg and len(args) - 1 > arg[0]: display_manufacturer = args[arg[0] + 1] if is_regular_grid: # Use our own forward profile code profile = self.create_RGB_XYZ_cLUT_fwd_profile( ti3, os.path.basename(args[-1]), getcfg("copyright"), display_manufacturer, display_name, self.log, ) if getcfg("profile.type") == "x" and ( self.argyll_version < [2, 1, 0] or "-aY" in args ): # Swapped matrix - need to create it ourselves # Start with sRGB sRGB = profile.from_named_rgb_space("sRGB") for channel in "rgb": tagname = channel + "TRC" profile.tags[tagname] = sRGB.tags[tagname] # Swap RGB -> BRG profile.tags.rXYZ = sRGB.tags.bXYZ profile.tags.gXYZ = sRGB.tags.rXYZ profile.tags.bXYZ = sRGB.tags.gXYZ elif not is_primaries_only: # Use colprof to create profile result = self.exec_cmd( cmd, args, low_contrast=False, skip_scripts=skip_scripts ) if not isinstance(result, Exception) and result: try: profile = ICCProfile(profile_path) except (IOError, ICCProfileInvalidError): result = Error( lang.getstr("profile.invalid") + "\n" + profile_path ) if not isinstance(result, Exception) and result: if getcfg("profile.type") == "X" or is_primaries_only: # Use our own accurate matrix cat = "Bradford" if not is_primaries_only: cat = profile.guess_cat() or cat mtx = self._create_simple_matrix_profile( ti3_RGB_XYZ, ti3_remaining, os.path.basename(args[-1]), getcfg("copyright"), display_manufacturer, display_name, ( getcfg("profile.type") in ("X", "x") and getcfg("profile.b2a.hires") ) or getcfg("profile.black_point_compensation"), cat, ) if is_primaries_only: # Use matrix profile profile = mtx # Add luminance tag luminance_XYZ_cdm2 = ti3.queryv1("LUMINANCE_XYZ_CDM2") if luminance_XYZ_cdm2: profile.tags.lumi = XYZType(profile=profile) profile.tags.lumi.Y = float(luminance_XYZ_cdm2.split()[1]) # Add blackpoint tag profile.tags.bkpt = XYZType(profile=profile) if XYZbp: black_XYZ = XYZbp else: black_XYZ = (0, 0, 0) ( profile.tags.bkpt.X, profile.tags.bkpt.Y, profile.tags.bkpt.Z, ) = black_XYZ # Check if we have calibration, if so, add vcgt for cgats in ti3.values(): if cgats.type == b"CAL": profile.tags.vcgt = cal_to_vcgt(cgats) else: # Add matrix tags to cLUT profile for tagcls in ("XYZ", "TRC"): for channel in "rgb": tagname = channel + tagcls profile.tags[tagname] = mtx.tags[tagname] if is_regular_grid or is_primaries_only: # Write profile profile.write(profile_path) if os.path.isfile(args[-1] + ".chrm"): # Get ChromaticityType tag with open(args[-1] + ".chrm", "rb") as blob: chrm = ChromaticityType(blob.read()) else: chrm = None if XYZbp: Ybp = XYZbp[1] XYZbp = colormath.adapt( *XYZbp, whitepoint_source=[v / XYZwp[1] for v in XYZwp], cat=profile.guess_cat() or "Bradford", ) XYZbp = tuple(XYZbp) bpc_applied = False profchanged = False if not isinstance(result, Exception) and result: errors = self.errors output = self.output retcode = self.retcode try: if not profile: profile = ICCProfile(profile_path) except (IOError, ICCProfileInvalidError): result = Error(lang.getstr("profile.invalid") + "\n" + profile_path) else: # Do we have a B2A0 table? has_B2A = "B2A0" in profile.tags # Hires CIECAM02 gamut mapping - perceptual and saturation # tables, also colorimetric table for non-RGB profiles # Use collink for smoother result. # Only for XYZ LUT and if source profile is a simple matrix # profile, otherwise CIECAM02 tables will already have been # created by colprof gamap = ( getcfg("gamap_perceptual") or getcfg("gamap_saturation") ) and getcfg("gamap_profile") collink = None if ( "A2B0" in profile.tags and profile.connectionColorSpace == b"XYZ" and (gamap or profile.colorSpace != b"RGB") and getcfg("profile.b2a.hires") ): collink = get_argyll_util("collink") if not collink: self.log(lang.getstr("argyll.util.not_found", "collink")) gamap_profiles = [] gamap_profile = None if gamap and collink: gamap_profile_filename = getcfg("gamap_profile") try: gamap_profile = ICCProfile(gamap_profile_filename) except (IOError, ICCProfileInvalidError) as exception: self.log(exception) else: if ( not "A2B0" in gamap_profile.tags and "rXYZ" in gamap_profile.tags and "gXYZ" in gamap_profile.tags and "bXYZ" in gamap_profile.tags and "rTRC" in gamap_profile.tags and "gTRC" in gamap_profile.tags and "bTRC" in gamap_profile.tags ): # Simple matrix source profile if gamap_profile.convert_iccv4_tags_to_iccv2(): # Write to temp file fd, gamap_profile.fileName = mkstemp_bypath( gamap_profile_filename, dir=self.tempdir ) stream = os.fdopen(fd, "wb") gamap_profile.write(stream) stream.close() gamap_profiles.append(gamap_profile) if profile.colorSpace == b"RGB" and has_B2A: # Only table 0 (colorimetric) in display profile. # Assign it to table 1 as per ICC spec to prepare # for adding table 0 (perceptual) and 2 (saturation) profile.tags.B2A1 = profile.tags.B2A0 else: gamap_profile = None tables = [] if gamap_profile or (collink and profile.colorSpace != b"RGB"): self.log("-" * 80) self.log("Creating CIECAM02 gamut mapping using collink") size = getcfg("profile.b2a.hires.size") # Make sure to map 'auto' value (-1) to an actual size size = {-1: 33}.get(size, size) collink_args = [ "-v", "-q" + getcfg("profile.quality"), "-G", f"-r{size:d}", ] if is_regular_grid: # Do not preserve output shaper curves in devicelink collink_args.append("-no") if profile.colorSpace == b"RGB" and self.argyll_version >= [1, 7]: # Use RGB->RGB forced black point hack collink_args.append("-b") if gamap_profile: for tableno, cfgname in [ (0, "gamap_perceptual"), (2, "gamap_saturation"), ]: if getcfg(cfgname): tables.append((tableno, getcfg(cfgname + "_intent"))) if profile.colorSpace != b"RGB": # Create colorimetric table for non-RGB profile tables.insert(0, (1, "r")) if not gamap_profile: # Create perceptual table with # luminance matched appearance rendering # (similar to rel. col. + BPC) tables.append((0, "la")) # Get inking rules from colprof extra args extra_args = getcfg("extra_args.colprof") inking = re.findall( r"-[Kk](?:[zhxr]|p[0-9.\s]+)|-[Ll][0-9.\s]+", extra_args, ) if inking: collink_args.extend(parse_argument_string(" ".join(inking))) # Get rid of lores B2A tables - they affect # collink even in inverse forward lookup mode # (probably because collink tries to determine inking # rules by looking at B2A?) for tableno in range(3): tablename = f"B2A{tableno:d}" if tablename in profile.tags: del profile.tags[tablename] profchanged = True if profchanged: # Need to write updated profile for xicclu/collink profile.write() # Input curve clipping. # Setting to True makes rel. col. + BPC produce a # smoother result, but reduces accuracy of the # colorimetric table input_curve_clipping = False # Determine profile blackpoint if input_curve_clipping: # Figure out profile blackpoint by looking up # neutral values from L* = 0 to L* = 50, # in 0.1 increments idata = [] for i in range(501): idata.append((i / 10.0, 0, 0)) odata = self.xicclu( profile, idata, intent="r", direction="if", pcs="l", use_cam_clipping=True, get_clip=True, ) Labbp = (0, 0, 0) for i, values in enumerate(odata): if not values[-1]: # Not clipped Labbp = idata[i] break ogamap_profile = gamap_profile for tableno, intent in tables: # Create device link(s) gamap_args = [] if tableno == 1: # Use PhotoPrintRGB as PCS if creating colorimetric # table for non-RGB profile. # PhotoPrintRGB is a synthetic L* TRC space # with the Rec2020 red and blue adapted to D50 # and a green of x 0.1292 (same as blue x) y 0.8185 # It almost completely encompasses PhotoGamutRGB pcs = get_data_path("ref/PhotoPrintRGB_Lstar.icc") if pcs: try: gamap_profile = ICCProfile(pcs) except (IOError, ICCProfileInvalidError) as exception: self.log(exception) else: missing = lang.getstr( "file.missing", "ref/PhotoPrintRGB_Lstar.icc" ) if gamap_profile: self.log(missing) else: result = Error(missing) break if pcs and input_curve_clipping and Labbp: self.log( "Applying black offset L*a*b* {:.2f} {:.2f} {:.2f} to {}...".format( *(Labbp + (gamap_profile.getDescription(),)) ) ) XYZbp = colormath.Lab2XYZ(*Labbp) gamap_profile.apply_black_offset(XYZbp) # Write to temp file because file changed fd, gamap_profile.fileName = mkstemp_bypath( gamap_profile.fileName, dir=self.tempdir ) stream = os.fdopen(fd, "wb") gamap_profile.write(stream) stream.close() gamap_profiles.append(gamap_profile) elif gamap: gamap_profile = ogamap_profile if getcfg("gamap_src_viewcond"): gamap_args.append("-c" + getcfg("gamap_src_viewcond")) if getcfg("gamap_out_viewcond"): gamap_args.append("-d" + getcfg("gamap_out_viewcond")) # Preserve input curves in resulting devicelink? preserve_input_curves = True if gamap_profile and not preserve_input_curves: for channel in "rgb": trc = gamap_profile.tags[channel + "TRC"] trc_len = len(trc) # Do not preserve input shaper curves if nonlinear if trc_len > 1 or trc[0] != 1.0: if trc_len > 1: # Check if nonlinear (10 bit precision) values = [ round(v / 65535.0 * 1023) for v in trc ] ivalues = [ round(v / (trc_len - 1.0) * 1023) for v in range(trc_len) ] ni = values != ivalues else: # Single gamma != 1.0 (nonlinear) ni = True if ni and "-ni" not in collink_args: # Do not preserve input shaper curves in # devicelink collink_args.append("-ni") break elif not ni and "-ni" in collink_args: # Preserve input shaper curves in # devicelink collink_args.remove("-ni") break link_profile = tempfile.mktemp(profile_ext, dir=self.tempdir) result = self.exec_cmd( collink, collink_args + gamap_args + [ "-i" + intent, gamap_profile.fileName, profile_path, link_profile, ], sessionlogfile=self.sessionlogfile, ) if not isinstance(result, Exception) and result: try: link_profile = ICCProfile(link_profile) except (IOError, ICCProfileInvalidError) as exception: self.log(exception) continue table = f"B2A{tableno:d}" profile.tags[table] = link_profile.tags.A2B0 if gamap_profile: # Map B2A input curves to inverse source # profile TRC for i, channel in enumerate("rgb"): curve = profile.tags[table].input[i] trc = gamap_profile.tags[channel + "TRC"] if len(trc) == 1: trc.set_trc(trc[0], len(curve)) elif len(trc) != len(curve): trc = colormath.interp_resize( trc, len(curve), use_numpy=True ) interp = colormath.Interp( trc, curve, use_numpy=True ) profile.tags[table].input[i] = icurve = [] for j in range(4096): icurve.append(interp(j / 4095.0 * 65535)) # Remove temporary link profile os.remove(link_profile.fileName) # Update B2A matrix with source profile matrix matrix = colormath.Matrix3x3( [ [ gamap_profile.tags.rXYZ.X, gamap_profile.tags.gXYZ.X, gamap_profile.tags.bXYZ.X, ], [ gamap_profile.tags.rXYZ.Y, gamap_profile.tags.gXYZ.Y, gamap_profile.tags.bXYZ.Y, ], [ gamap_profile.tags.rXYZ.Z, gamap_profile.tags.gXYZ.Z, gamap_profile.tags.bXYZ.Z, ], ] ) matrix.invert() scale = 1 + (32767 / 32768.0) matrix *= colormath.Matrix3x3( ((scale, 0, 0), (0, scale, 0), (0, 0, scale)) ) profile.tags[table].matrix = matrix profchanged = True else: break elif ( getcfg("profile.b2a.hires") and getcfg("profile.b2a.hires.smooth") and gamap ): # Smooth existing B2A tables linebuffered_logfiles = [] if ( sys.stdout and hasattr(sys.stdout, "isatty") and sys.stdout.isatty() ): linebuffered_logfiles.append(print) else: linebuffered_logfiles.append(log) if self.sessionlogfile: linebuffered_logfiles.append(self.sessionlogfile) logfiles = Files( [ LineBufferedStream( FilteredStream( Files(linebuffered_logfiles), enc, discard="", linesep_in="\n", triggers=[], ) ), self.recent, self.lastmsg, ] ) smooth_tables = [] for tableno in (0, 2): table = profile.tags.get(f"B2A{tableno:d}") if table in smooth_tables: continue if self.smooth_B2A( profile, tableno, getcfg("profile.b2a.hires.diagpng") and 2, logfile=logfiles, ): smooth_tables.append(table) profchanged = True self.errors = errors self.output = output self.retcode = retcode if not isinstance(result, Exception) and result: for gamap_profile in gamap_profiles: if ( gamap_profile and os.path.dirname(gamap_profile.fileName) == self.tempdir ): # Remove temporary source profile os.remove(gamap_profile.fileName) if profchanged and tables: # Make sure we match Argyll colprof i.e. have a complete # set of tables if "A2B1" not in profile.tags: profile.tags.A2B1 = profile.tags.A2B0 if "A2B2" not in profile.tags: profile.tags.A2B2 = profile.tags.A2B0 if ( profile.colorSpace == b"RGB" and profile.connectionColorSpace in (b"XYZ", b"Lab") and "A2B0" in profile.tags and (getcfg("profile.b2a.hires") or "B2A1" in profile.tags) ): # Apply BPC to A2B0/A2B2 to match B2A0/B2A2 black if profchanged: # We need to write the changed profile try: profile.write() except Exception as exception: return exception if "A2B1" not in profile.tags: self.log("Generating A2B1 by copying A2B0") profile.tags.A2B1 = profile.tags.A2B0 A2B1 = profile.tags.get("A2B1") a2b_tables = [0] if profile.tags.get("B2A2"): a2b_tables.append(2) D50 = colormath.get_whitepoint("D50") XYZrgb = self.xicclu( profile, [[1, 0, 0], [0, 1, 0], [0, 0, 1]], pcs="x" ) Xr, Yr, Zr = XYZrgb[0] Xg, Yg, Zg = XYZrgb[1] Xb, Yb, Zb = XYZrgb[2] m1 = colormath.Matrix3x3( ((Xr, Xg, Xb), (Yr, Yg, Yb), (Zr, Zg, Zb)) ).inverted() Sr, Sg, Sb = m1 * D50 m2 = colormath.Matrix3x3( ( (Sr * Xr, Sg * Xg, Sb * Xb), (Sr * Yr, Sg * Yg, Sb * Yb), (Sr * Zr, Sg * Zg, Sb * Zb), ) ).inverted() for tableno in a2b_tables: tablename = f"A2B{tableno:d}" table = profile.tags.get(tablename) if not table: continue if tables: # Get inverse B2A0/B2A2 black XYZbp_B2A = self.xicclu( profile, [[0, 0, 0]], intent="prs"[tableno], direction="ib", pcs="x", )[0] XYZbp_B2A = tuple(XYZbp_B2A) else: XYZbp_B2A = (0, 0, 0) Labbp_B2A = colormath.XYZ2Lab(*XYZbp_B2A, scale=1) if XYZbp and (0, 0, 0) not in (XYZbp, XYZbp_B2A): # Make it same hue as relcol black self.log( f"Inverse B2A{tableno:d}", "blackpoint L*a*b* {:.6f} {:.6f} {:.6f}".format( *Labbp_B2A ), ) if XYZbp_B2A != (0, 0, 0): # Always... continue Labbp_B2A = (Labbp_B2A[0], Labbp[1], Labbp[2]) self.log( "Adjusted", tablename, "blackpoint L*a*b* {:.6f} {:.6f} {:.6f}".format( *Labbp_B2A ), ) XYZbp_B2A = colormath.Lab2XYZ(*Labbp_B2A) if XYZbp_B2A == XYZbp: continue if table is A2B1 and not getcfg( "profile.black_point_compensation" ): # Make A2B0/A2B2 a distinct table self.log("Making distinct", tablename) table = LUT16Type(None, tablename, profile) table.matrix = [] for row in A2B1.matrix: table.matrix.append(list(row)) table.input = [] table.output = [] for curves in ("input", "output"): for channel in getattr(A2B1, curves): getattr(table, curves).append(list(channel)) table.clut = [] for block in A2B1.clut: table.clut.append([]) for row in block: table.clut[-1].append(list(row)) profile.tags[tablename] = table else: table = profile.tags[tablename] # Apply BPC to A2B0/A2B2 self.log( f"Applying black point compensation to {tablename}:", "L*a*b* {:.6f} {:.6f} {:.6f}".format(*Labbp_B2A), ) table.apply_black_offset( XYZbp_B2A, None, self.thread_abort, lang.getstr("aborted") ) profchanged = True if XYZbp: # Adjust for BPC if XYZbp_B2A != (0, 0, 0): XYZbp_A2B = XYZbp_B2A else: XYZbp_A2B = [v * Ybp for v in D50] XYZtmp = list(XYZrgb) for i, XYZ in enumerate(XYZtmp): XYZtmp[i] = colormath.blend_blackpoint( *XYZ, bp_in=(0, 0, 0), bp_out=XYZbp_A2B ) Xr, Yr, Zr = XYZtmp[0] Xg, Yg, Zg = XYZtmp[1] Xb, Yb, Zb = XYZtmp[2] m3 = colormath.Matrix3x3( ((Xr, Xg, Xb), (Yr, Yg, Yb), (Zr, Zg, Zb)) ).inverted() Sr, Sg, Sb = m3 * D50 m4 = colormath.Matrix3x3( ( (Sr * Xr, Sg * Xg, Sb * Xb), (Sr * Yr, Sg * Yg, Sb * Yb), (Sr * Zr, Sg * Zg, Sb * Zb), ) ) if debug: for i in range(3): self.log( colormath.XYZ2xyY(*XYZrgb[i]), colormath.XYZ2xyY(*XYZtmp[i]), colormath.XYZ2xyY(*m4 * (m2 * XYZrgb[i])), ) interp = [] rinterp = [] osize = len(table.output[0]) omaxv = osize - 1.0 orange = [i / omaxv * 65535 for i in range(osize)] for i in range(3): interp.append(colormath.Interp(orange, table.output[i])) rinterp.append( colormath.Interp(table.output[i], orange) ) if len(table.clut[0]) < 33: num_workers = 1 else: num_workers = None table.clut = sum( pool_slice( _mp_apply, table.clut, ( profile.connectionColorSpace, colormath.matmul, (m4, m2), D50, interp, rinterp, lang.getstr("aborted"), ), {}, num_workers, self.thread_abort, ), [], ) # A2B processing process_A2B = ( "A2B0" in profile.tags and profile.colorSpace == b"RGB" and profile.connectionColorSpace in (b"XYZ", b"Lab") and ( getcfg("profile.b2a.hires") or getcfg("profile.quality.b2a") in ("l", "n") or not has_B2A ) ) if process_A2B: if getcfg("profile.b2a.hires") or not has_B2A: if profchanged: # We need to write the changed profile before # enhancing B2A resolution! try: profile.write() except Exception as exception: return exception result = self.update_profile_B2A(profile) if not isinstance(result, Exception) and result: profchanged = True # All table processing done if not isinstance(result, Exception) and result: if profchanged and tables: # Make sure we match Argyll colprof i.e. have a complete # set of tables if profile.colorSpace != b"RGB": if len(tables) == 1: # We only created a colorimetric table, the # others are still low quality. Assign # colorimetric table profile.tags.B2A0 = profile.tags.B2A1 if len(tables) < 3: # We only created colorimetric and/or perceptual # tables, saturation table is still low quality. # Assign perceptual table profile.tags.B2A2 = profile.tags.B2A0 if "B2A2" not in profile.tags: profile.tags.B2A2 = profile.tags.B2A0 apply_bpc = ( getcfg("profile.black_point_compensation") and "A2B0" not in profile.tags ) or (process_A2B and (getcfg("profile.b2a.hires") or not has_B2A)) # If profile type is X (XYZ cLUT + matrix) add the matrix tags # from a lookup of a smaller testchart or A2B/B2A (faster # computation!). If profile is a shaper+matrix profile, # re-generate shaper curves from testchart with only # gray+primaries (better curve smoothness and neutrality) # Make sure we do this *after* all changes on the A2B/B2A tables # are done, because we may end up using them for lookup! if ( getcfg("profile.type") in ("X", "s", "S") and profile.colorSpace == b"RGB" ): if getcfg("profile.type") == "X": if ( not isinstance( profile.tags.get("vcgt"), VideoCardGammaType ) or profile.tags.vcgt.is_linear() ): # Use matrix from 3x shaper curves profile if vcgt # is linear ptype = "s" if profchanged: # We need to write the changed profile before # creating TRC tags because we will be using # lookup through A2B/B2A table! try: profile.write() except Exception as exception: return exception else: # Use matrix from single shaper curve profile if # vcgt is nonlinear ptype = "S" else: ptype = getcfg("profile.type") result = self._create_matrix_profile( args[-1], profile, ptype, "XYZ", apply_bpc ) if isinstance(result, ICCProfile): result = True profchanged = True if not isinstance(result, Exception) and result: if ( "rTRC" in profile.tags and "gTRC" in profile.tags and "bTRC" in profile.tags and isinstance(profile.tags.rTRC, CurveType) and isinstance(profile.tags.gTRC, CurveType) and isinstance(profile.tags.bTRC, CurveType) and apply_bpc and len(profile.tags.rTRC) > 1 and len(profile.tags.gTRC) > 1 and len(profile.tags.bTRC) > 1 and ( profile.tags.rTRC[0] != 0 or profile.tags.gTRC[0] != 0 or profile.tags.bTRC[0] != 0 ) ): self.log("-" * 80) for component in ("r", "g", "b"): self.log(f"Applying black point compensation to {component}TRC") profile.apply_black_offset( (0, 0, 0), include_A2B=False, set_blackpoint=False ) if getcfg("profile.black_point_compensation"): bpc_applied = True profchanged = True if profchanged and not isinstance(result, Exception) and result: if "bkpt" in profile.tags and bpc_applied: # We need to update the blackpoint tag try: odata = self.xicclu(profile, (0, 0, 0), intent="a", pcs="x") if len(odata) != 1 or len(odata[0]) != 3: raise ValueError(f"Blackpoint is invalid: {odata}") except Exception as exception: self.log(exception) else: ( profile.tags.bkpt.X, profile.tags.bkpt.Y, profile.tags.bkpt.Z, ) = odata[0] # We need to write the changed profile try: profile.write() except Exception as exception: return exception if os.path.isfile(args[-1] + ".ti3.backup") and os.path.isfile( args[-1] + ".ti3" ): # Restore backed up TI3 os.rename(args[-1] + ".ti3", args[-1] + ".bpc.ti3") os.rename(args[-1] + ".ti3.backup", args[-1] + ".ti3") ti3_file = open(args[-1] + ".ti3", "rb") ti3 = ti3_file.read() ti3_file.close() elif not is_regular_grid and not is_primaries_only: ti3 = None if not isinstance(result, Exception) and result: # Always explicitly do profile self check self.exec_cmd( get_argyll_util("profcheck"), [args[-1] + ".ti3", args[-1] + profile_ext], capture_output=True, skip_scripts=True, ) # Get profile max and avg err to be later added to metadata # Argyll outputs the following: # Profile check complete, peak err = x.xxxxxx, avg err = x.xxxxxx, RMS = x.xxxxxx peak = None avg = None rms = None for line in self.output: if line.startswith("Profile check complete"): peak = re.search(r"(?:peak err|max\.) = (\d+(?:\.\d+))", line) avg = re.search(r"avg(?: err|\.) = (\d+(?:\.\d+))", line) rms = re.search(r"RMS = (\d+(?:\.\d+))", line) if peak: peak = peak.groups()[0] if avg: avg = avg.groups()[0] if rms: rms = rms.groups()[0] break if not isinstance(result, Exception) and result: (gamut_volume, gamut_coverage) = self.create_gamut_views(profile_path) self.log("-" * 80) if not isinstance(result, Exception) and result: result = self.update_profile( profile, ti3, chrm, tags, avg, peak, rms, gamut_volume, gamut_coverage, quality=getcfg("profile.quality"), ) result2 = self.wrapup( not isinstance(result, UnloggedInfo) and result, dst_path=dst_path ) if isinstance(result2, Exception): if isinstance(result, Exception): result = Error(str(result) + "\n\n" + str(result2)) else: result = result2 elif not isinstance(result, Exception) and result: setcfg("last_cal_or_icc_path", dst_path) setcfg("last_icc_path", dst_path) return result def create_RGB_XYZ_cLUT_fwd_profile( self, ti3, description, copyright, manufacturer, model, logfn=None, clutres=33, cat="Bradford", ): """Create a RGB to XYZ forward profile""" # Extract grays and remaining colors (ti3_extracted, RGB_XYZ, remaining) = extract_device_gray_primaries( ti3, True, logfn ) bwd_matrix = colormath.Matrix3x3([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) # Check if we have calibration, if so, add vcgt vcgt = False options_dispcal = [] is_hq_cal = False for cgats in ti3.values(): if cgats.type == b"CAL": vcgt = cal_to_vcgt(cgats) options_dispcal = get_options_from_cal(cgats)[0] is_hq_cal = "qh" in options_dispcal dEs = [] RGB_XYZ = dict_sort(RGB_XYZ) for X, Y, Z in RGB_XYZ.values(): if Y >= 1: X, Y, Z = colormath.adapt(X, Y, Z, RGB_XYZ[(100, 100, 100)], cat=cat) L, a, b = colormath.XYZ2Lab(X, Y, Z) dE = colormath.delta(L, 0, 0, L, a, b, "00")["E"] dEs.append(dE) if debug or verbose > 1: self.log( "L* {:5.2f} a* {:5.2f} b* {:5.2f} dE*00 {:4.2f}".format( L, a, b, dE ) ) dE_avg = sum(dEs) / len(dEs) dE_max = max(dEs) self.log("R=G=B (>= 1% luminance) dE*00 avg", dE_avg, "peak", dE_max) # Create profile profile = ICCProfile() profile.version = 2.2 # Match ArgyllCMS profile.setDescription(description) profile.setCopyright(copyright) if manufacturer: profile.setDeviceManufacturerDescription(manufacturer) if model: profile.setDeviceModelDescription(model) luminance_XYZ_cdm2 = ti3.queryv1("LUMINANCE_XYZ_CDM2") if luminance_XYZ_cdm2: profile.tags.lumi = XYZType(profile=profile) profile.tags.lumi.Y = float(luminance_XYZ_cdm2.split()[1]) profile.tags.wtpt = XYZType(profile=profile) white_XYZ = [v / 100.0 for v in RGB_XYZ[(100, 100, 100)]] (profile.tags.wtpt.X, profile.tags.wtpt.Y, profile.tags.wtpt.Z) = white_XYZ profile.tags.bkpt = XYZType(profile=profile) black_XYZ = [v / 100.0 for v in RGB_XYZ[(0, 0, 0)]] (profile.tags.bkpt.X, profile.tags.bkpt.Y, profile.tags.bkpt.Z) = black_XYZ profile.tags.arts = chromaticAdaptionTag() profile.tags.arts.update(colormath.get_cat_matrix(cat)) # Check if we have calibration, if so, add vcgt if vcgt: profile.tags.vcgt = vcgt # Interpolate shaper curves from grays - returned curves are adapted # to D50 self.single_curve = round(dE_max, 2) <= 1.25 and round(dE_avg, 2) <= 0.5 if self.single_curve: self.log( "Got high quality calibration, using single device to PCS " "shaper curve for cLUT" ) gray = create_shaper_curves( RGB_XYZ, bwd_matrix, self.single_curve, getcfg("profile.black_point_compensation"), logfn, profile=profile, options_dispcal=options_dispcal, optimize=self.single_curve, cat=cat, ) curves = [curve[:] for curve in gray] # Add black back in XYZbp = [ v / 100.0 for v in colormath.adapt( *RGB_XYZ[(0, 0, 0)], whitepoint_source=RGB_XYZ[(100, 100, 100)], cat=cat ) ] for i in range(len(gray[0])): (gray[0][i], gray[1][i], gray[2][i]) = colormath.apply_bpc( *(curve[i] for curve in gray), bp_in=(0, 0, 0), bp_out=XYZbp ) grayinterp = [ colormath.Interp(list(range(len(curve))), curve, use_numpy=True) for curve in gray ] def get_XYZ_from_curves(n, m): # Curves are adapted to D50 return [interp((len(interp.xp) - 1.0) / m * n) for interp in grayinterp] # Quantize RGB to make lookup easier # XXX Note that round(50 * 2.55) = 127, but # round(50 / 100 * 255) = 128 (the latter is what we want)! remaining = dict( [ (tuple(round(k / 100.0 * 255) for k in RGB), XYZ) for RGB, XYZ in remaining.items() ] ) # Need to sort so columns increase (fastest to slowest) B G R remaining = dict_sort(remaining) # Build initial cLUT # Try to fill a 5x5x5 or 3x3x3 cLUT clut_actual = 0 for iclutres in (17, 9, 5, 4, 3, 2): clut = [] step = 100 / (iclutres - 1.0) for a in range(iclutres): for b in range(iclutres): clut.append([]) for c in range(iclutres): # XXX Note that round(50 * 2.55) = 127, but # round(50 / 100 * 255) = 128 (the latter is what we want)! RGB = tuple(round((k * step) / 100.0 * 255) for k in (a, b, c)) # Prefer actual measurements over interpolated values XYZ = remaining.get(RGB) if not XYZ: if a == b == c: # Fall back to interpolated values for gray # (already black scaled) XYZ = get_XYZ_from_curves(a, iclutres - 1) # Range 0..1 clut[-1].append(XYZ) elif iclutres > 2: # Try next smaller cLUT res break else: raise ValueError( "Measurement data is missing RGB " "{:.4f} {:.4f} {:.4f}".format(*RGB) ) else: clut_actual += 1 X, Y, Z = (v / 100.0 for v in XYZ) # # Need to black scale actual measurements # X, Y, Z = colormath.blend_blackpoint(X, Y, Z, # black_XYZ, None, white_XYZ) # Range 0..1 clut[-1].append( colormath.adapt(X, Y, Z, white_XYZ, cat=cat) ) if c < iclutres - 1: break if b < iclutres - 1: break if a == iclutres - 1: break self.log("Initial cLUT resolution {:d}x{:d}x{:d}".format(*(iclutres,) * 3)) profile.tags.A2B0 = create_RGB_A2B_XYZ(curves, clut, self.log) # Interpolate to higher cLUT resolution quality = getcfg("profile.quality") clutres = {"m": 17, "l": 9}.get(quality, clutres) # XXX: Need to implement proper 3D interpolation if clutres > iclutres: # Lookup input RGB to interpolated XYZ RGB_in = [] step = 100 / (clutres - 1.0) for a in range(clutres): for b in range(clutres): for c in range(clutres): RGB_in.append([a * step, b * step, c * step]) XYZ_out = self.xicclu(profile, RGB_in, "a", pcs="X", scale=100) profile.fileName = None # Create new cLUT clut = [] i = -1 actual = 0 interpolated = 0 for a in range(clutres): for b in range(clutres): clut.append([]) for c in range(clutres): # XXX Note that round(50 * 2.55) = 127, but # round(50 / 100 * 255) = 128 (the latter is what we want)! RGB = tuple(round((k * step) / 100.0 * 255) for k in (a, b, c)) # Prefer actual measurements over interpolated values prev_actual = actual XYZ = remaining.get(RGB) i += 1 if not XYZ: # Fall back to interpolated values # (already black scaled) if a == b == c: XYZ = get_XYZ_from_curves(a, clutres - 1) # Range 0..1 clut[-1].append(XYZ) continue else: XYZ = XYZ_out[i] interpolated += 1 else: actual += 1 X, Y, Z = (v / 100.0 for v in XYZ) # if actual > prev_actual: # # Need to black scale actual measurements # X, Y, Z = colormath.blend_blackpoint(X, Y, Z, # black_XYZ, None, white_XYZ) # Range 0..1 clut[-1].append(colormath.adapt(X, Y, Z, white_XYZ, cat=cat)) if actual > clut_actual: # Did we get any additional actual measured cLUT points? self.log( "cLUT resolution {:d}x{:d}x{:d}: Got {:d} additional values from " "actual measurements".format( clutres, clutres, clutres, actual - clut_actual ) ) profile.tags.A2B0 = create_RGB_A2B_XYZ(curves, clut, self.log) clut_actual = actual self.log( "Final interpolated cLUT resolution {:d}x{:d}x{:d}".format( *((len(profile.tags.A2B0.clut[0]),) * 3) ) ) profile.tags.A2B0.profile = profile # # Add black back in # black_XYZ_D50 = colormath.adapt(*black_XYZ, whitepoint_source=white_XYZ, cat=cat) # profile.tags.A2B0.apply_black_offset(black_XYZ_D50) return profile def _create_simple_matrix_profile( self, ti3_RGB_XYZ, ti3_remaining, desc, copyright="No copyright", display_manufacturer=None, display_name=None, bpc=False, cat="Bradford", ): self.log("-" * 80) self.log("Creating matrix from primaries") xy = [] XYZbp = ti3_RGB_XYZ[(0, 0, 0)] XYZwp = ti3_RGB_XYZ[(100, 100, 100)] for R, G, B in [(100, 0, 0), (0, 100, 0), (0, 0, 100), (100, 100, 100)]: if R == G == B: RGB_XYZ = ti3_RGB_XYZ else: RGB_XYZ = ti3_remaining X, Y, Z = RGB_XYZ[(R, G, B)] if XYZbp != (0, 0, 0) and not bpc: # Adjust for black offset X, Y, Z = colormath.blend_blackpoint(X, Y, Z, XYZbp, (0, 0, 0), XYZwp) xy.append(colormath.XYZ2xyY(*(v / 100 for v in (X, Y, Z)))[:2]) self.log("Using chromatic adaptation transform matrix:", cat) mtx = ICCProfile.from_chromaticities( xy[0][0], xy[0][1], xy[1][0], xy[1][1], xy[2][0], xy[2][1], xy[3][0], xy[3][1], 2.2, # Will be replaced desc, copyright, display_manufacturer, display_name, cat=cat, ) return mtx def _create_matrix_profile( self, outname, profile=None, ptype="s", omit=None, bpc=False, cat="Bradford" ): """Create matrix profile from lookup through ti3 .ti3 has to exist. If is given, it has to be an ICCProfile instance, and the matrix tags will be added to this profile. should be the type of profile, i.e. one of g, G, s or S. if given should be the tag to omit, either 'TRC' or 'XYZ'. We use a testchart with only gray + primaries for TRC, and larger testchart for the matrix. This should give the smoothest overall result. Returns an ICCProfile with fileName set to .ic[cm]. """ if profile: cat = profile.guess_cat() or cat if omit == "XYZ": tags = "shaper" else: tags = "shaper+matrix" self.log("-" * 80) self.log(f"Creating {tags} tags in separate step") self.log("Using chromatic adaptation transform matrix:", cat) fakeread = get_argyll_util("fakeread") if not fakeread: return Error(lang.getstr("argyll.util.not_found", "fakeread")) colprof = get_argyll_util("colprof") if not colprof: return Error(lang.getstr("argyll.util.not_found", "colprof")) # Strip potential CAL from Ti3 try: oti3 = CGATS(outname + ".ti3") except (IOError, CGATSError) as exception: return exception else: if 0 in oti3: ti3 = oti3[0] ti3.filename = oti3.filename # So we can log the name ti3.fix_zero_measurements(logfile=self.get_logfiles(False)) else: return Error( lang.getstr("error.measurement.file_invalid", outname + ".ti3") ) for ti1name, tagcls in [("d3-e4-s3-g52-m3-b0-f0", "XYZ"), (None, "TRC")]: if tagcls == omit: continue elif ( tagcls == "TRC" and profile and "A2B0" in profile.tags and ptype == "s" ): # Create TRC from forward lookup through A2B numentries = 256 maxval = numentries - 1.0 RGBin = [] for i in range(numentries): RGBin.append((i / maxval,) * 3) if "B2A0" in profile.tags: # Inverse backward direction = "ib" else: # Forward direction = "f" try: XYZout = self.xicclu(profile, RGBin, "p", direction, pcs="x") except Info as exception: return exception # Get RGB space from already added matrix column tags rgb_space = colormath.get_rgb_space(profile.get_rgb_space("pcs", 1)) mtx = rgb_space[-1].inverted() self.log("-" * 80) for channel in "rgb": tagname = channel + tagcls self.log( "Adding {} from {} lookup to {}".format( tagname, { "f": "forward A2B0", "ib": "inverse backward B2A0", }.get(direction), profile.getDescription(), ) ) profile.tags[tagname] = CurveType() for XYZ in XYZout: RGB = mtx * XYZ for i, channel in enumerate("rgb"): tagname = channel + tagcls profile.tags[tagname].append(min(max(RGB[i], 0), 1) * 65535) break if not ti1name: # Extract gray+primaries into new TI3 (ti3, RGB_XYZ, remaining) = extract_device_gray_primaries( ti3, tagcls == "TRC", self.log ) ti3.sort_by_RGB() self.log(ti3.DATA) if tagcls == "TRC" and profile: rgb_space = colormath.get_rgb_space(profile.get_rgb_space("pcs", 1)) fwd_mtx = rgb_space[-1] bwd_mtx = fwd_mtx.inverted() self.log("-" * 80) options_dispcal = get_options_from_ti3(oti3)[0] curves = create_shaper_curves( RGB_XYZ, bwd_mtx, ptype == "S", bpc, self.log, profile=profile, options_dispcal=options_dispcal, optimize=ptype == "S", cat=cat, ) for i, channel in enumerate("rgb"): tagname = channel + tagcls self.log( "Adding {} from interpolation to {}".format( tagname, profile.getDescription() ) ) profile.tags[tagname] = trc = CurveType(profile=profile) # Slope limit for 16-bit encoding trc[:] = [ max(v, j / 65535.0) * 65535 for j, v in enumerate(curves[i]) ] if not bpc: XYZbp = None for R, G, B in RGB_XYZ: X, Y, Z = RGB_XYZ[(R, G, B)] if R == G == B == 0: XYZbp = [v / 100 for v in (X, Y, Z)] XYZbp = colormath.adapt( *XYZbp, whitepoint_source=RGB_XYZ[(100, 100, 100)], cat=cat, ) if XYZbp: # Add black back in profile.apply_black_offset(XYZbp, include_A2B=False) if ptype == "S": # Single curve profile.tags["rTRC"][:] = profile.tags["gTRC"][:] profile.tags["bTRC"][:] = profile.tags["gTRC"][:] break ti3.write(f"{outname}.0.ti3") if ti1name: ti1 = get_data_path(f"ti1/{ti1name}.ti1") if not ti1: return Error(lang.getstr("file.missing", f"ti1/{ti1name}.ti1")) fakeout = f"{outname}.{ti1name}" try: shutil.copyfile(ti1, f"{fakeout}.ti1") except EnvironmentError as exception: return exception # Lookup ti1 through ti3 result = self.exec_cmd( fakeread, [f"{outname}.0.ti3", fakeout], capture_output=True, skip_scripts=True, sessionlogfile=self.sessionlogfile, ) try: os.remove(f"{fakeout}.ti1") except EnvironmentError as exception: self.log(exception) if not result: return UnloggedError("\n".join(self.errors)) elif isinstance(result, Exception): return result try: os.remove(f"{outname}.0.ti3") except EnvironmentError as exception: self.log(exception) else: # Use gray+primaries from existing ti3 fakeout = f"{outname}.0" result = self.exec_cmd( colprof, ["-v", "-q" + getcfg("profile.quality"), "-a" + ptype, fakeout], sessionlogfile=self.sessionlogfile, ) try: os.remove(f"{fakeout}.ti3") except EnvironmentError as exception: self.log(exception) if isinstance(result, Exception) or not result: return result try: matrix_profile = ICCProfile(fakeout + profile_ext) except (IOError, ICCProfileInvalidError): return Error( lang.getstr("profile.invalid") + "\n" + fakeout + profile_ext ) if profile: self.log("-" * 80) for channel in "rgb": tagname = channel + tagcls tag = matrix_profile.tags.get(tagname) if tag: self.log( "Adding {} from matrix profile to {}".format( tagname, profile.getDescription() ) ) profile.tags[tagname] = tag else: self.log(lang.getstr("profile.required_tags_missing", tagname)) else: profile = matrix_profile profile.fileName = outname + profile_ext try: os.remove(fakeout + profile_ext) except EnvironmentError as exception: self.log(exception) return profile def update_profile( self, profile, ti3=None, chrm=None, tags=None, avg=None, peak=None, rms=None, gamut_volume=None, gamut_coverage=None, quality=None, ): """Update profile tags and metadata""" if isinstance(profile, str): profile_path = profile try: profile = ICCProfile(profile_path) except (IOError, ICCProfileInvalidError): return Error(lang.getstr("profile.invalid") + "\n" + profile_path) else: profile_path = profile.fileName if ( profile.profileClass == b"mntr" and profile.colorSpace == b"RGB" and not (self.tempdir and profile_path.startswith(self.tempdir)) ): setcfg("last_cal_or_icc_path", profile_path) setcfg("last_icc_path", profile_path) if ti3: # Embed original TI3 profile.tags.targ = profile.tags.DevD = profile.tags.CIED = TextType( b"text\0\0\0\0" + bytes(ti3) + b"\0", b"targ" ) if chrm: # Add ChromaticityType tag profile.tags.chrm = chrm # Fixup desc tags - ASCII needs to be 7-bit # also add Unicode strings if different from ASCII if "desc" in profile.tags and isinstance( profile.tags.desc, TextDescriptionType ): profile.setDescription(profile.getDescription()) if "dmdd" in profile.tags and isinstance( profile.tags.dmdd, TextDescriptionType ): profile.setDeviceModelDescription(profile.getDeviceModelDescription()) if "dmnd" in profile.tags and isinstance( profile.tags.dmnd, TextDescriptionType ): profile.setDeviceManufacturerDescription( profile.getDeviceManufacturerDescription() ) if tags and tags is not True: # Add custom tags for tagname in tags: tag = tags[tagname] if tagname == "mmod": profile.device["manufacturer"] = ( b"\0\0" + tag["manufacturer"][1] + tag["manufacturer"][0] ) profile.device["model"] = ( b"\0\0" + tag["model"][0] + tag["model"][1] ) profile.tags[tagname] = tag elif tags is True: edid = self.get_display_edid() if edid: profile.device["manufacturer"] = ( b"\0\0" + edid["edid"][9:10] + edid["edid"][8:9] ) profile.device["model"] = ( b"\0\0" + edid["edid"][11:12] + edid["edid"][10:11] ) # Add Apple-specific 'mmod' tag (TODO: need full spec) mmod = ( b"mmod" + (b"\x00" * 6) + edid["edid"][8:10] + (b"\x00" * 2) + edid["edid"][11:12] + edid["edid"][10:11] + (b"\x00" * 4) + (b"\x00" * 20) ) profile.tags.mmod = ICCProfileTag(mmod, "mmod") # Add new meta information based on EDID profile.set_edid_metadata(edid) elif "meta" not in profile.tags: # Make sure meta tag exists profile.tags.meta = DictType() if tags is True or (tags and "meta" in tags): profile.tags.meta.update( {"CMF_product": appname, "CMF_binary": appname, "CMF_version": version} ) # Set license profile.tags.meta["License"] = getcfg("profile.license") # Set profile quality quality = {"v": "very low", "l": "low", "m": "medium", "h": "high"}.get( quality ) if quality: profile.tags.meta["Quality"] = quality spec_prefixes = "CMF_" if tags is True: # Set OPENICC_automatic_generated to "0" profile.tags.meta["OPENICC_automatic_generated"] = "0" # Set GCM DATA_source to "calib" profile.tags.meta["DATA_source"] = "calib" # Add instrument profile.tags.meta["MEASUREMENT_device"] = self.get_instrument_name().lower() spec_prefixes = "CMF_,DATA_,MEASUREMENT_,OPENICC_" # Add screen brightness if applicable if sys.platform not in ("darwin", "win32") and dbus_session: try: iface = DBusObject( BUSTYPE_SESSION, "org.gnome.SettingsDaemon.Power", "/org/gnome/SettingsDaemon/Power", "Screen", ) brightness = iface.get_percentage() except DBusException: pass else: profile.tags.meta["SCREEN_brightness"] = str(brightness) spec_prefixes += ",SCREEN_" # Set device ID device_id = self.get_device_id(quirk=False, query=True) if device_id: profile.tags.meta["MAPPING_device_id"] = device_id spec_prefixes += ",MAPPING_" if tags is True or (tags and "meta" in tags): prefix = profile.tags.meta.getvalue("prefix", b"", None) if isinstance(prefix, bytes): prefix = prefix.decode("utf-8") prefixes = (prefix or spec_prefixes).split(",") for prefix in spec_prefixes.split(","): if prefix not in prefixes: prefixes.append(prefix) profile.tags.meta["prefix"] = ",".join(prefixes) if (avg, peak, rms) != (None,) * 3: # Make sure meta tag exists if "meta" not in profile.tags: profile.tags.meta = DictType() # Update meta prefix prefix = profile.tags.meta.getvalue("prefix", b"", None) if isinstance(prefix, bytes): prefix = prefix.decode("utf-8") prefixes = (prefix or "ACCURACY_").split(",") if "ACCURACY_" not in prefixes: prefixes.append("ACCURACY_") profile.tags.meta["prefix"] = ",".join(prefixes) # Add error info if avg is not None: profile.tags.meta["ACCURACY_dE76_avg"] = avg if peak is not None: profile.tags.meta["ACCURACY_dE76_max"] = peak if rms is not None: profile.tags.meta["ACCURACY_dE76_rms"] = rms profile.set_gamut_metadata(gamut_volume, gamut_coverage) # Set default rendering intent if "B2A0" in profile.tags and ( "B2A1" in profile.tags or "B2A2" in profile.tags ): profile.intent = {"p": 0, "r": 1, "s": 2, "a": 3}[ getcfg("gamap_default_intent") ] # Check if we need to video scale vcgt if isinstance(profile.tags.get("vcgt"), VideoCardGammaType): try: cal = extract_cal_from_profile(profile, None, False, prefer_cal=True) except Exception as exception: self.log(exception) else: white = False if cal: if cal.queryv1("TV_OUTPUT_ENCODING") == "YES": black, white = (16, 235) else: output_enc = cal.queryv1("OUTPUT_ENCODING") if output_enc: try: black, white = (float(v) for v in output_enc.split()) except (TypeError, ValueError): white = False if white and (black, white) != (0, 255): self.log(f"Need to scale vcgt to video levels ({black}..{white})") # Need to create videoscaled vcgt from calibration data = cal.queryv1("DATA") if data: self.log(f"Scaling vcgt to video levels ({black}..{white})") for entry in data.values(): for column in "RGB": v_old = entry["RGB_" + column] # For video encoding the extra bits of # precision are created by bit shifting rather # than scaling, so we need to scale the fp # value to account for this newmin = (black / 256.0) * (65536 / 65535.0) newmax = (white / 256.0) * (65536 / 65535.0) v_new = colormath.convert_range( v_old, 0, 1, newmin, newmax ) entry["RGB_" + column] = v_new profile.tags.vcgt = cal_to_vcgt(cal) else: self.log("Warning - no scaling applied - no calibration data!") # Calculate profile ID profile.calculateID() try: profile.write() except Exception as exception: return exception return True def get_logfiles(self, include_progress_buffers=True): linebuffered_logfiles = [] if sys.stdout and hasattr(sys.stdout, "isatty") and sys.stdout.isatty(): linebuffered_logfiles.append(print) else: linebuffered_logfiles.append(log) if self.sessionlogfile: linebuffered_logfiles.append(self.sessionlogfile) logfiles = LineBufferedStream( FilteredStream( Files(linebuffered_logfiles), enc, discard="", linesep_in="\n", triggers=[], ) ) if include_progress_buffers: logfiles = Files([logfiles, self.recent, self.lastmsg]) return logfiles def update_profile_B2A( self, profile, generate_perceptual_table=True, clutres=None, smooth=None, rgb_space=None, ): # Use reverse A2B interpolation to generate B2A table if not clutres: if getcfg("profile.b2a.hires"): # Chosen resolution clutres = getcfg("profile.b2a.hires.size") elif getcfg("profile.quality.b2a") in "ln": # Low quality/resolution clutres = 9 else: # Medium quality/resolution clutres = 17 if smooth is None: smooth = getcfg("profile.b2a.hires.smooth") logfiles = self.get_logfiles() tables = [1] self.log("-" * 80) # Add perceptual tables if not present if "A2B0" in profile.tags and "A2B1" not in profile.tags: if not isinstance(profile.tags.A2B0, LUT16Type): self.log(f"{appname}: Can't process non-LUT16Type A2B0 table") return [] try: # Copy A2B0 logfiles.write("Generating A2B1 by copying A2B0\n") profile.tags.A2B1 = profile.tags.A2B0 if "B2A0" in profile.tags: # Copy B2A0 B2A0 = profile.tags.B2A0 profile.tags.B2A1 = B2A1 = LUT16Type(None, "B2A1", profile) B2A1.matrix = [] for row in B2A0.matrix: B2A1.matrix.append(list(row)) B2A1.input = [] B2A1.output = [] for table in ("input", "output"): for channel in getattr(B2A0, table): getattr(B2A1, table).append(list(channel)) B2A1.clut = [] for block in B2A0.clut: B2A1.clut.append([]) for row in block: B2A1.clut[-1].append(list(row)) except Exception as exception: return exception if "A2B2" not in profile.tags and generate_perceptual_table: # Argyll always creates a complete set of A2B / B2A tables if # colprof -s (perceptual) or -S (perceptual and saturation) is used, # so we can assume that if A2B2 is not present then it is safe to # re-generate B2A0 because it was not created by Argyll CMS. tables.append(0) # Invert A2B tables if present. Always invert colorimetric A2B table. rtables = [] filename = profile.fileName for tableno in tables: if f"A2B{tableno:d}" in profile.tags: if ( f"B2A{tableno:d}" in profile.tags and profile.tags[f"B2A{tableno:d}"] in rtables ): continue if not isinstance(profile.tags[f"A2B{tableno:d}"], LUT16Type): self.log( f"{appname}: Can't process non-LUT16Type A2B{tableno:d} table" ) continue # Check if we want to apply BPC bpc = tableno != 1 if bpc and ( profile.tags["A2B1"].clut[0][0] != [0, 0, 0] or profile.tags["A2B1"].input[0][0] != 0 or profile.tags["A2B1"].input[1][0] != 0 or profile.tags["A2B1"].input[2][0] != 0 or profile.tags["A2B1"].output[0][0] != 0 or profile.tags["A2B1"].output[1][0] != 0 or profile.tags["A2B1"].output[2][0] != 0 ): # Need to apply BPC table = LUT16Type(profile=profile) # Copy existing B2A1 table matrix, cLUT and output curves table.matrix = rtables[0].matrix table.clut = rtables[0].clut table.output = rtables[0].output profile.tags[f"B2A{tableno:d}"] = table elif bpc: # BPC not needed, copy existing B2A profile.tags[f"B2A{tableno:d}"] = rtables[0] return rtables if not filename or not os.path.isfile(filename) or bpc: # Write profile to temp dir tempdir = self.create_tempdir() if isinstance(tempdir, Exception): return tempdir fd, profile.fileName = tempfile.mkstemp(profile_ext, dir=tempdir) stream = os.fdopen(fd, "wb") profile.write(stream) stream.close() temp = True else: temp = False # Invert A2B try: result = self.generate_B2A_from_inverse_table( profile, clutres, "A2B", tableno, bpc, smooth, rgb_space, logfiles, filename, bpc, ) except (Error, Info) as exception: return exception except Exception as exception: self.log(traceback.format_exc()) return exception else: if result: rtables.append(profile.tags[f"B2A{tableno:d}"]) else: return False finally: if temp: os.remove(profile.fileName) profile.fileName = filename return rtables def is_working(self): """Check if any Worker instance is busy. Return True or False.""" for worker in workers: if not getattr(worker, "finished", True): return True return False def start_measurement( self, consumer, apply_calibration=True, progress_msg="", resume=False, continue_next=False, ): """Start a measurement and use a progress dialog for progress information""" self.start( consumer, self.measure, wkwargs={"apply_calibration": apply_calibration}, progress_msg=progress_msg, resume=resume, continue_next=continue_next, pauseable=True, ) def start_calibration( self, consumer, remove=False, progress_msg="", resume=False, continue_next=False ): """Start a calibration and use a progress dialog for progress information""" self.start( consumer, self.calibrate, wkwargs={"remove": remove}, progress_msg=progress_msg, resume=resume, continue_next=continue_next, interactive_frame="adjust", pauseable=True, ) def madtpg_init(self): if not hasattr(self, "madtpg"): if sys.platform == "win32" and getcfg("madtpg.native"): # Using native implementation (madHcNet32.dll) self.madtpg = madvr.MadTPG() else: # Using madVR net-protocol pure python implementation self.madtpg = madvr.MadTPG_Net() self.madtpg.debug = verbose def madtpg_connect(self): self.madtpg_init() self.patterngenerator = self.madtpg if self.madtpg.connect(method3=madvr.CM_StartLocalInstance, timeout3=3000): # Check madVR version madvr_version = self.madtpg.get_version() if not madvr_version or madvr_version < madvr.min_version: self.madtpg_disconnect(False) raise Error(lang.getstr("madvr.outdated", madvr.min_version)) self.log( "Connected to madVR version {:d}.{:d}.{:d}.{:d} ({})".format( *(madvr_version + (self.madtpg.uri,)) ) ) self.madtpg.set_osd_text("\u25b6") # "Play" symbol return True return False def madtpg_disconnect(self, restore_settings=True): """Restore madVR settings and disconnect""" if restore_settings: self.madtpg_restore_settings() if self.madtpg.disconnect(): self.log("Successfully disconnected from madTPG") def madtpg_restore_settings( self, reconnect=True, restore_fullscreen=None, restore_osd=None ): if restore_fullscreen is None: restore_fullscreen = getattr(self, "madtpg_previous_fullscreen", None) if restore_osd is None: restore_osd = getattr(self, "madtpg_osd", None) is False if restore_fullscreen or restore_osd: check = not reconnect or self.madtpg.get_version() if not check and reconnect: check = self.madtpg_connect() if check: if restore_fullscreen: # Restore fullscreen if self.madtpg.set_use_fullscreen_button(True): self.log( f"{appname}: Restored madTPG 'use fullscreen' button state" ) self.madtpg_previous_fullscreen = None else: self.log( f"{appname}: Warning - couldn't restore madTPG " "'use fullscreen' button state" ) if not reconnect: if self.madtpg.is_fse_mode_enabled(): # Allow three seconds for automatic switch to FSE sleep(3) # Allow three seconds for fullscreen to settle sleep(3) if restore_osd: # Restore disable OSD if self.madtpg.set_disable_osd_button(True): self.log( f"{appname}: Restored madTPG 'disable OSD' button state" ) self.madtpg_osd = None else: self.log( f"{appname}: Warning - couldn't restore madTPG " "'disable OSD' button state" ) else: buttons = [] if restore_fullscreen: buttons.append("'use fullscreen'") if restore_osd: buttons.append("'disable OSD'") self.log( f"{appname}: Warning - couldn't re-connect to madTPG " f"to restore {'/'.join(buttons)} button states" ) def madtpg_show_osd(self, msg=None, leave_fullscreen=False): """Show madTPG OSD, optionally with message and leaving fullscreen""" if self.madtpg.is_fullscreen() and leave_fullscreen: self.madtpg_previous_fullscreen = True self.madtpg.set_use_fullscreen_button(False) self.madtpg_osd = not self.madtpg.is_disable_osd_button_pressed() if not self.madtpg_osd: self.madtpg.set_disable_osd_button(False) if msg: self.madtpg.set_osd_text(msg) if self.cmdname == "dispcal": self.madtpg.show_progress_bar(6) def measure(self, apply_calibration=True): """Measure the configured testchart""" result = self.detect_video_levels() if isinstance(result, Exception) or not result: return result precond_ti1 = None precond_ti3 = None testchart_file = getcfg("testchart.file") auto = getcfg("testchart.auto_optimize") or 7 if testchart_file == "auto" and auto > 4: # Testchart auto-optimization # Create optimized testchart on-the-fly. To do this, create a # simple profile for preconditioning if config.get_display_name() == "Untethered": return Error( lang.getstr("testchart.auto_optimize.untethered.unsupported") ) # Use small testchart for grayscale+primaries (34 patches) precond_ti1_path = get_data_path("ti1/d3-e4-s2-g28-m0-b0-f0.ti1") precond_ti1 = CGATS(precond_ti1_path) setcfg("testchart.file", precond_ti1_path) cmd, args = self.prepare_dispread(apply_calibration) setcfg("testchart.file", "auto") if not isinstance(cmd, Exception): # Measure testchart result = self.exec_cmd(cmd, args) if not isinstance(result, Exception) and result: # Create preconditioning profile self.pauseable = False basename = args[-1] precond_ti3 = CGATS(f"{basename}.ti3") precond_ti3.fix_zero_measurements(logfile=self.get_logfiles(False)) precond_ti3.write() # Extract grays and remaining colors ( ti3_extracted, ti3_RGB_XYZ, ti3_remaining, ) = extract_device_gray_primaries(precond_ti3, True, self.log) profile = self._create_simple_matrix_profile( ti3_RGB_XYZ, ti3_remaining, os.path.basename(basename) ) result = self._create_matrix_profile(basename, profile, omit="XYZ") if not isinstance(result, Exception) and result: # Write matrix profile result.write(basename + profile_ext) # Create optimized testchart if getcfg("use_fancy_progress"): # Fade out animation/sound self.cmdname = get_argyll_utilname("targen") # Allow time for fade out sleep(4) s = min(auto, 11) * 4 - 3 g = s * 3 - 2 f = get_total_patches(4, 4, s, g, auto, auto, 0) f += 120 cmd, args = ( get_argyll_util("targen"), [ "-v", "-d3", "-e4", f"-s{s:d}", f"-g{g:d}", "-m0", f"-f{f:d}", "-A1.0", ], ) if self.argyll_version >= [1, 1]: args.append("-G") if self.argyll_version >= [1, 3, 3]: args.append("-N0.5") if self.argyll_version >= [1, 6]: args.extend(["-B4", "-b0"]) if self.argyll_version >= [1, 6, 2]: args.append("-V1.6") args.extend(["-c", basename + profile_ext, basename]) result = self.exec_cmd(cmd, args) self.pauseable = True else: result = cmd else: result = True if testchart_file == "auto" and auto < 5: # Use pre-baked testchart if auto == 1: testchart = "ti1/d3-e4-s2-g28-m0-b0-f0.ti1" elif auto == 2: testchart = "ti1/d3-e4-s3-g52-m3-b0-f0.ti1" elif auto == 3: testchart = "ti1/d3-e4-s4-g52-m4-b0-f0.ti1" else: testchart = "ti1/d3-e4-s5-g52-m5-b0-f0.ti1" testchart_path = get_data_path(testchart) if testchart_path: setcfg("testchart.file", testchart_path) else: result = Error(lang.getstr("not_found", testchart)) if not isinstance(result, Exception) and result: cmd, args = self.prepare_dispread(apply_calibration) if testchart_file == "auto": # Restore "auto" setting setcfg("testchart.file", "auto") else: cmd = result if not isinstance(cmd, Exception) and cmd: if config.get_display_name() == "Untethered": cmd, args2 = get_argyll_util("spotread"), ["-v", "-e"] if getcfg("extra_args.spotread").strip(): args2 += parse_argument_string(getcfg("extra_args.spotread")) result = self.add_measurement_features( args2, False, allow_nondefault_observer=is_ccxx_testchart() ) if isinstance(result, Exception): return result else: args2 = args result = self.exec_cmd(cmd, args2) if not isinstance(result, Exception) and result: self.update_display_name_manufacturer(args[-1] + ".ti3") ti3 = args[-1] + ".ti3" if precond_ti3: # Add patches from preconditioning measurements ti3 = insert_ti_patches_omitting_RGB_duplicates( precond_ti3, ti3, self.log ) options = { "OBSERVER": get_cfg_option_from_args("observer", "-Q", args[:-1]) } ti3 = add_keywords_to_cgats(ti3, options) if 1 in ti3: # Add video level encoding flag if needed black_white = False if "-E" in args2: black_white = (16, 235) elif config.get_display_name() == "madVR": # Get output encoding from madVR # Note: 'tags' will only be True if creating profile # directly after measurements, and only in that case will # we want to query madVR black_white = self.madtpg_bw_lvl if black_white == (16, 235): ti3[1].add_keyword("TV_OUTPUT_ENCODING", "YES") elif black_white == (0, 255): ti3[1].add_keyword("TV_OUTPUT_ENCODING", "NO") elif black_white and black_white != (0, 255): ti3[1].add_keyword( "OUTPUT_ENCODING", " ".join(str(v) for v in black_white) ) ti3.write() # Restore original TI1 ti1_orig = args[-1] + ".original.ti1" ti1 = args[-1] + ".ti1" if os.path.isfile(ti1_orig): try: if os.path.isfile(ti1): # Should always exist os.remove(ti1) os.rename(ti1_orig, ti1) except Exception as exception: self.log( "Warning - could not restore " f"backup of original TI1 file {ti1_orig}:", exception, ) else: self.log("Restored backup of original TI1 file") if precond_ti1 and os.path.isfile(ti1): # Need to add precond TI1 patches to TI1. # Do this AFTER the measurements because we don't want to # measure precond patches twice. ti1 = insert_ti_patches_omitting_RGB_duplicates( precond_ti1, ti1, self.log ) ti1.write() else: result = cmd result2 = self.wrapup( not isinstance(result, UnloggedInfo) and result, isinstance(result, Exception) or not result, ) if isinstance(result2, Exception): if isinstance(result, Exception): result = Error(str(result) + "\n\n" + str(result2)) else: result = result2 return result def ensure_patch_sequence(self, ti1, write=True): """Ensure correct patch sequence of TI1 file Return either the changed CGATS object or the original path/TI1 """ patch_sequence = getcfg("testchart.patch_sequence") if patch_sequence != "optimize_display_response_delay": # Need to re-order patches if not isinstance(ti1, CGATS): try: ti1 = CGATS(ti1) except Exception as exception: self.log(f"Warning - could not process TI1 file {ti1}:", exception) return ti1 self.log( "Changing patch sequence:", lang.getstr(f"testchart.{patch_sequence}") ) if patch_sequence == "maximize_lightness_difference": result = ti1.checkerboard(sort1=stable_sort_by_L) elif patch_sequence == "maximize_rec709_luma_difference": result = ti1.checkerboard(sort_by_rec709_luma) elif patch_sequence == "maximize_RGB_difference": result = ti1.checkerboard(sort_by_RGB_sum) elif patch_sequence == "vary_RGB_difference": result = ti1.checkerboard( sort_by_RGB, None, split_grays=True, shift=True ) if not result: self.log("Warning - patch sequence was not changed") elif write: # Make a copy try: shutil.copyfile( ti1.filename, os.path.splitext(ti1.filename)[0] + ".original.ti1", ) except Exception as exception: self.log( f"Warning - could not make backup of TI1 file {ti1.filename}:", exception, ) # Write new TI1 to original filename try: ti1.write() except Exception as exception: self.log( f"Warning - could not write TI1 file {ti1.filename}:", exception, ) return ti1 def parse(self, txt): if not txt: return self.logger.info(f"{txt}") self.check_instrument_calibration(txt) self.check_instrument_place_on_screen(txt) self.check_instrument_sensor_position(txt) self.check_retry_measurement(txt) self.check_is_single_measurement(txt) self.check_spotread_result(txt) def audio_visual_feedback(self, txt): if isinstance(txt, bytes): txt = txt.decode() if self.cmdname in ( get_argyll_utilname("dispcal"), get_argyll_utilname("dispread"), get_argyll_utilname("spotread"), ): if ( self.cmdname == get_argyll_utilname("dispcal") and ", repeat" in txt.lower() ): self.repeat = True elif ", ok" in txt.lower(): self.repeat = False if ( re.search(r"Patch [2-9]\d* of ", txt, re.I) or ( re.search( r"Patch \d+ of |The instrument can be removed from the screen", txt, re.I, ) and self.patch_count > 1 ) or ( "Result is XYZ:" in txt and not isinstance(self.progress_wnd, UntetheredFrame) ) ): if self.cmdname == get_argyll_utilname("dispcal") and self.repeat: if getcfg("measurement.play_sound") and hasattr( self.progress_wnd, "sound_on_off_btn" ): self.measurement_sound.safe_play() else: if getcfg("measurement.play_sound") and ( hasattr(self.progress_wnd, "sound_on_off_btn") or isinstance(self.progress_wnd, DisplayUniformityFrame) or getattr(self.progress_wnd, "Name", None) == "VisualWhitepointEditor" ): self.commit_sound.safe_play() if hasattr(self.progress_wnd, "animbmp"): self.progress_wnd.animbmp.frame = 0 def setup_patterngenerator(self, logfile=None): pgname = config.get_display_name(None, True) if self.patterngenerator: # Use existing pattern generator instance self.patterngenerator.logfile = logfile self.patterngenerator.use_video_levels = getcfg( "patterngenerator.use_video_levels" ) if hasattr(self.patterngenerator, "conn"): # Try to use existing connection try: self.patterngenerator_send( (0.5,) * 3, raise_exceptions=True, increase_sent_count=False ) except (socket.error, http.client.HTTPException) as exception: self.log(exception) self.patterngenerator.disconnect_client() elif pgname == "Prisma": patterngenerator = PrismaPatternGeneratorClient self.patterngenerator = patterngenerator( host=getcfg("patterngenerator.prisma.host"), port=getcfg("patterngenerator.prisma.port"), use_video_levels=getcfg("patterngenerator.use_video_levels"), logfile=logfile, ) elif pgname == "Web @ localhost": patterngenerator = WebWinHTTPPatternGeneratorServer self.patterngenerator = patterngenerator( port=getcfg("webserver.portnumber"), logfile=logfile ) elif pgname.startswith("Chromecast "): from DisplayCAL.chromecast_patterngenerator import ( ChromeCastPatternGenerator, ) self.patterngenerator = ChromeCastPatternGenerator( name=self.get_display_name(), logfile=logfile ) elif pgname == "Resolve": # Resolve if getcfg("patterngenerator.resolve") == "LS": patterngenerator = ResolveLSPatternGeneratorServer else: patterngenerator = ResolveCMPatternGeneratorServer self.patterngenerator = patterngenerator( port=getcfg("patterngenerator.resolve.port"), use_video_levels=getcfg("patterngenerator.use_video_levels"), logfile=logfile, ) @property def patterngenerator(self): pgname = config.get_display_name() return self._patterngenerators.get(pgname) @patterngenerator.setter def patterngenerator(self, patterngenerator): pgname = config.get_display_name() self._patterngenerators[pgname] = patterngenerator @property def patterngenerators(self): return self._patterngenerators def patterngenerator_send( self, rgb, bgrgb=None, raise_exceptions=False, increase_sent_count=True ): """Send RGB color to pattern generator""" if getattr(self, "abort_requested", False): return x, y, w, h, size = get_pattern_geometry() if bgrgb is not None: pass elif getcfg("measure.darken_background"): bgrgb = (0, 0, 0) elif size == 1.0: bgrgb = list(rgb) else: # Constant APL (matches madTPG 'gamma light') desired_apl = getcfg("patterngenerator.apl") bgrgb = [min(max(desired_apl - v * size, 0) / (1.0 - size), 1) for v in rgb] bgrgb_apl = sum(bgrgb) / 3.0 * (1 - size) rgb_apl = sum(rgb) / 3.0 * size needed_bgrgb_apl = max(desired_apl - rgb_apl, 0) if bgrgb_apl > needed_bgrgb_apl: f = needed_bgrgb_apl / bgrgb_apl bgrgb = [v * f for v in bgrgb] self.log( f"{appname}: Sending RGB {rgb[0]:.3f} {rgb[1]:.3f} {rgb[2]:.3f}, " f"background RGB {bgrgb[0]:.3f} {bgrgb[1]:.3f} {bgrgb[2]:.3f}, " f"x {x:.4f}, y {y:.4f}, w {w:.4f}, h {h:.4f}" ) if self._use_patternwindow: # Preliminary Wayland support. This still needs a lot # of work as Argyll doesn't support Wayland natively yet, # so we use virtual display to drive our own patch window. self._patterngenerator_wait = True wx.CallAfter(self.owner.measureframe.show_rgb, rgb) # Wait for call to return while self._patterngenerator_wait and not self.subprocess_abort: sleep(0.001) else: try: self.patterngenerator.send(rgb, bgrgb, x=x, y=y, w=w, h=h) except Exception as exception: if raise_exceptions: raise else: self.exec_cmd_returnvalue = exception self.abort_subprocess() return if increase_sent_count: self.patterngenerator_sent_count += 1 self.log( f"{appname}: Patterngenerator sent count: " f"{self.patterngenerator_sent_count:d}" ) @property def pauseable(self): return self._pauseable @pauseable.setter def pauseable(self, pauseable): self._pauseable = pauseable self.pauseable_now = False def pause_continue(self): if not self.pauseable or not self.pauseable_now: return if getattr(self.progress_wnd, "paused", False) and not getattr( self, "paused", False ): self.paused = True self.log(f"{appname}: Pausing...") self.safe_send("\x1b") if self.use_madnet_tpg: self.madtpg.set_osd_text("\u23f8") # "Pause" symbol elif not getattr(self.progress_wnd, "paused", False) and getattr( self, "paused", False ): self.paused = False self.log(f"{appname}: Continuing...") self.safe_send(" ") if self.use_madnet_tpg: self.madtpg.set_osd_text("\u25b6") # "Play" symbol def prepare_colprof( self, profile_name=None, display_name=None, display_manufacturer=None, tags=None ): """Prepare a colprof commandline. All options are read from the user configuration. Profile name and display name can be overridden by passing thecorresponding arguments. """ if profile_name is None: profile_name = getcfg("profile.name.expanded") in_out_file = self.setup_inout(profile_name) if not in_out_file or isinstance(in_out_file, Exception): return in_out_file, None if not os.path.exists(f"{in_out_file}.ti3"): return ( Error( lang.getstr("error.measurement.file_missing", f"{in_out_file}.ti3") ), None, ) if not os.path.isfile(f"{in_out_file}.ti3"): return Error(lang.getstr("file_notfile", f"{in_out_file}.ti3")), None cmd = get_argyll_util("colprof") args = ["-v", f"-q{getcfg('profile.quality')}", f"-a{getcfg('profile.type')}"] gamap_args = args if getcfg("profile.type") in ["l", "x", "X"]: if getcfg("gamap_saturation"): gamap = "S" elif getcfg("gamap_perceptual"): gamap = "s" else: gamap = None gamap_profile = None if gamap and getcfg("gamap_profile"): # CIECAM02 gamut mapping - perceptual and saturation tables # Only for L*a*b* LUT or if source profile is not a simple matrix # profile, otherwise create hires CIECAM02 tables with collink try: gamap_profile = ICCProfile(getcfg("gamap_profile")) except ICCProfileInvalidError as exception: self.log(exception) return Error( lang.getstr("profile.invalid") + "\n" + getcfg("gamap_profile") ) except IOError as exception: return exception if ( getcfg("profile.type") != "l" and getcfg("profile.b2a.hires") and "A2B0" not in gamap_profile.tags and "rXYZ" in gamap_profile.tags and "gXYZ" in gamap_profile.tags and "bXYZ" in gamap_profile.tags and "rTRC" in gamap_profile.tags and "gTRC" in gamap_profile.tags and "bTRC" in gamap_profile.tags ): self.log("Delegating CIECAM02 gamut mapping to collink") # Make a copy, so we can store options without adding them # to actual colprof arguments gamap_args = [] gamap_profile = None gamap_args.append(f"-{gamap}") gamap_args.append(getcfg("gamap_profile")) gamap_args.append(f"-t{getcfg('gamap_perceptual_intent')}") if gamap == "S": gamap_args.append(f"-T{getcfg('gamap_saturation_intent')}") if getcfg("gamap_src_viewcond"): gamap_args.append(f"-c{getcfg('gamap_src_viewcond')}") if getcfg("gamap_out_viewcond"): gamap_args.append(f"-d{getcfg('gamap_out_viewcond')}") b2a_q = getcfg("profile.quality.b2a") if ( getcfg("profile.b2a.hires") and getcfg("profile.type") in ("l", "x", "X") and not (gamap and gamap_profile) ): rgb = False is_lab_clut_ptype = getcfg("profile.type") == "l" if is_lab_clut_ptype: with open(f"{in_out_file}.ti3", "rb") as ti3_file: for line in ti3_file: if line.startswith(b"COLOR_REP"): if b"RGB_XYZ" in line: rgb = True break if rgb or not is_lab_clut_ptype: # Disable B2A creation in colprof, B2A is handled # by A2B inversion code (only for cLUT profiles) b2a_q = "n" if b2a_q and b2a_q != getcfg("profile.quality"): args.append(f"-b{b2a_q}") args.append("-C") args.append(getcfg("copyright").encode("ASCII", "asciize").decode("utf-8")) if getcfg("extra_args.colprof").strip(): args += parse_argument_string(getcfg("extra_args.colprof")) options_dispcal = [] if "-d3" in self.options_targen: # only add display desc and dispcal options if creating RGB profile options_dispcal = self.options_dispcal if len(self.displays): args.extend( self.update_display_name_manufacturer( f"{in_out_file}.ti3", display_name, display_manufacturer, write=False, ) ) self.options_colprof = list(args) if gamap_args is not args: self.options_colprof.extend(gamap_args) args.append("-D") args.append(profile_name) args.append(in_out_file) # Add dispcal and colprof arguments to ti3 ti3 = add_options_to_ti3( f"{in_out_file}.ti3", options_dispcal, self.options_colprof ) if ti3: color_rep = (ti3.queryv1("COLOR_REP").decode("utf-8") or "").split("_") # Prepare ChromaticityType tag self.log("Preparing ChromaticityType tag from TI3 colorants") colorants = ti3.get_colorants() if colorants and None not in colorants: chrm = ChromaticityType() chrm.type = 0 for colorant in colorants: if color_rep[1] == "LAB": XYZ = colormath.Lab2XYZ( colorant["LAB_L"], colorant["LAB_A"], colorant["LAB_B"] ) else: XYZ = (colorant["XYZ_X"], colorant["XYZ_Y"], colorant["XYZ_Z"]) chrm.channels.append(colormath.XYZ2xyY(*XYZ)[:-1]) with open(in_out_file + ".chrm", "wb") as blob: blob.write(chrm.tagData) self.log("Storing settings in TI3") # Black point compensation ti3[0].add_keyword( "USE_BLACK_POINT_COMPENSATION", "YES" if getcfg("profile.black_point_compensation") else "NO", ) # Black point correction # NOTE that profile black point correction is not the same as # calibration black point correction! # See Worker.create_profile ti3[0].add_keyword( "BLACK_POINT_CORRECTION", getcfg("profile.black_point_correction") ) # Hires B2A with optional smoothing ti3[0].add_keyword( "HIRES_B2A", "YES" if getcfg("profile.b2a.hires") else "NO" ) ti3[0].add_keyword("HIRES_B2A_SIZE", getcfg("profile.b2a.hires.size")) ti3[0].add_keyword( "SMOOTH_B2A", "YES" if getcfg("profile.b2a.hires.smooth") else "NO" ) # Display update delay if getcfg("measure.override_min_display_update_delay_ms"): ti3[0].add_keyword( "MIN_DISPLAY_UPDATE_DELAY_MS", getcfg("measure.min_display_update_delay_ms"), ) # Display settle time multiplier if getcfg("measure.override_display_settle_time_mult"): ti3[0].add_keyword( "DISPLAY_SETTLE_TIME_MULT", getcfg("measure.display_settle_time_mult"), ) # FFP if getcfg("patterngenerator.ffp_insertion"): for keyword in ("INTERVAL", "DURATION", "LEVEL"): ti3[0].add_keyword( f"FFP_INSERTION_{keyword}", getcfg(f"patterngenerator.ffp_insertion.{keyword.lower()}"), ) # Remove AUTO_OPTIMIZE if ti3[0].queryv1("AUTO_OPTIMIZE"): ti3[0].remove_keyword("AUTO_OPTIMIZE") # Patch sequence ti3[0].add_keyword( "PATCH_SEQUENCE", getcfg("testchart.patch_sequence").upper() ) # Add 3D LUT options if set, else remove them for keyword, cfgname in { "3DLUT_SOURCE_PROFILE": "3dlut.input.profile", "3DLUT_TRC": "3dlut.trc", "3DLUT_HDR_PEAK_LUMINANCE": "3dlut.hdr_peak_luminance", "3DLUT_HDR_SAT": "3dlut.hdr_sat", "3DLUT_HDR_HUE": "3dlut.hdr_hue", "3DLUT_HDR_MAXMLL": "3dlut.hdr_maxmll", "3DLUT_HDR_MAXMLL_ALT_CLIP": "3dlut.hdr_maxmll_alt_clip", "3DLUT_HDR_MINMLL": "3dlut.hdr_minmll", "3DLUT_HDR_AMBIENT_LUMINANCE": "3dlut.hdr_ambient_luminance", "3DLUT_HDR_DISPLAY": "3dlut.hdr_display", "3DLUT_GAMMA": "3dlut.trc_gamma", "3DLUT_DEGREE_OF_BLACK_OUTPUT_OFFSET": "3dlut.trc_output_offset", "3DLUT_INPUT_ENCODING": "3dlut.encoding.input", "3DLUT_OUTPUT_ENCODING": "3dlut.encoding.output", "3DLUT_GAMUT_MAPPING_MODE": "3dlut.gamap.use_b2a", "3DLUT_RENDERING_INTENT": "3dlut.rendering_intent", "3DLUT_FORMAT": "3dlut.format", "3DLUT_SIZE": "3dlut.size", "3DLUT_INPUT_BITDEPTH": "3dlut.bitdepth.input", "3DLUT_OUTPUT_BITDEPTH": "3dlut.bitdepth.output", "3DLUT_APPLY_CAL": "3dlut.output.profile.apply_cal", "SIMULATION_PROFILE": "measurement_report.simulation_profile", }.items(): if getcfg("3dlut.create"): value = getcfg(cfgname) if cfgname == "3dlut.gamap.use_b2a": if value: value = "g" else: value = "G" elif cfgname == "3dlut.trc_gamma": if getcfg("3dlut.trc_gamma_type") == "B": value = -value elif ( cfgname == "3dlut.input.profile" and os.path.basename(os.path.dirname(value)) == "ref" and get_data_path("ref/" + os.path.basename(value)) == value ): # Store relative path instead of absolute path if # ref file value = "ref/" + os.path.basename(value) elif cfgname == "measurement_report.simulation_profile": if ( getcfg("3dlut.trc").startswith("smpte2084") or getcfg("3dlut.trc") == "hlg" ): # Use 3D LUT profile value = getcfg("3dlut.input.profile") # Add 3D LUT HDR parameters and store only filename # (file will be copied to profile dir) fn, ext = os.path.splitext(os.path.basename(value)) lut3d_fn = self.lut3d_get_filename(fn, False, False) value = lut3d_fn + ext else: value = None else: value = None if value is not None: ti3[0].add_keyword(keyword, safe_str(value, "utf-8")) elif keyword in ti3[0]: ti3[0].remove_keyword(keyword) # 3D LUT content color space (currently only used for HDR) for color in ("white", "red", "green", "blue"): for coord in "xy": keyword = "3DLUT_CONTENT_COLORSPACE_{}_{}".format( color.upper(), coord.upper(), ) if getcfg("3dlut.create"): value = getcfg( "3dlut.content.colorspace.{}.{}".format(color, coord) ) ti3[0].add_keyword(keyword, safe_str(value, "utf-8")) elif keyword in ti3[0]: ti3[0].remove_keyword(keyword) ti3[0].fix_zero_measurements(logfile=self.get_logfiles(False)) ti3.write() return cmd, args def prepare_dispcal(self, calibrate=True, verify=False, dry_run=False): """Prepare a dispcal commandline. All options are read from the user configuration. You can choose if you want to calibrate and/or verify by passing the corresponding arguments. """ cmd = get_argyll_util("dispcal") args = ["-v2"] if getcfg("argyll.debug"): args.append("-D8") result = self.add_measurement_features(args, allow_nondefault_observer=True) if isinstance(result, Exception): return result, None if calibrate: if getcfg("trc"): args.append("-q" + getcfg("calibration.quality")) inoutfile = self.setup_inout() if not inoutfile or isinstance(inoutfile, Exception): return inoutfile, None if getcfg("profile.update") or self.dispcal_create_fast_matrix_shaper: args.append("-o") if getcfg("calibration.update") and not dry_run: cal = getcfg("calibration.file", False) calcopy = os.path.join(f"{inoutfile}.cal") filename, ext = os.path.splitext(cal) ext = ".cal" cal = f"{filename}{ext}" if ext.lower() == ".cal": result = check_cal_isfile(cal) if isinstance(result, Exception): return result, None if not result: return None, None if not os.path.exists(calcopy): try: # Copy cal to profile dir shutil.copyfile(cal, calcopy) except Exception as exception: return ( Error( lang.getstr("error.copy_failed", (cal, calcopy)) + "\n\n" + str(exception) ), None, ) result = check_cal_isfile(calcopy) if isinstance(result, Exception): return result, None if not result: return None, None cal = calcopy else: rslt = extract_fix_copy_cal(cal, calcopy) if isinstance(rslt, ICCProfileInvalidError): return Error(lang.getstr("profile.invalid") + "\n" + cal), None elif isinstance(rslt, Exception): traceback.print_exc() return ( Error( lang.getstr("cal_extraction_failed") + "\n" + cal + "\n\n" + rslt ), None, ) if not isinstance(rslt, list): return None, None if getcfg("profile.update"): profile_path = ( os.path.splitext(getcfg("calibration.file", False))[0] + profile_ext ) result = check_profile_isfile(profile_path) if isinstance(result, Exception): return result, None if not result: return None, None profilecopy = os.path.join(inoutfile + profile_ext) if not os.path.exists(profilecopy): try: # Copy profile to profile dir shutil.copyfile(profile_path, profilecopy) except Exception as exception: return ( Error( lang.getstr( "error.copy_failed", (profile_path, profilecopy) ) + "\n\n" + str(exception) ), None, ) result = check_profile_isfile(profilecopy) if isinstance(result, Exception): return result, None if not result: return None, None args.append("-u") if calibrate or verify: if calibrate and not getcfg("calibration.interactive_display_adjustment"): # Skip interactive display adjustment args.append("-m") whitepoint_colortemp = getcfg("whitepoint.colortemp", False) whitepoint_x = getcfg("whitepoint.x", False) whitepoint_y = getcfg("whitepoint.y", False) if whitepoint_colortemp or None in (whitepoint_x, whitepoint_y): whitepoint = getcfg("whitepoint.colortemp.locus") if whitepoint_colortemp: whitepoint += str(whitepoint_colortemp) args.append(f"-{whitepoint}") else: args.append(f"-w{whitepoint_x},{whitepoint_y}") luminance = getcfg("calibration.luminance", False) self.log(f"{appname}: luminance: {luminance}") if luminance is not None: args.append(f"-b{luminance}") if getcfg("trc"): args.append("-{}{}".format(getcfg("trc.type"), getcfg("trc"))) args.append("-f{}".format(getcfg("calibration.black_output_offset"))) if bool(int(getcfg("calibration.ambient_viewcond_adjust"))): # Argyll dispcal uses 20% of ambient (in lux, # fixed steradiant of 3.1415) as adapting # luminance, but we assume it already *is* # the adapting luminance. To correct for this, # scale so that dispcal gets the correct value. ambient = getcfg("calibration.ambient_viewcond_adjust.lux") args.append("-a{}".format(ambient * 5)) if not getcfg("calibration.black_point_correction.auto"): args.append( "-k{}".format(getcfg("calibration.black_point_correction")) ) if ( defaults["calibration.black_point_rate.enabled"] and float(getcfg("calibration.black_point_correction")) < 1 ): black_point_rate = getcfg("calibration.black_point_rate") if black_point_rate: args.append(f"-A{black_point_rate}") black_luminance = getcfg("calibration.black_luminance", False) if black_luminance: args.append(f"-B{black_luminance:f}") elif ( not ( getcfg("calibration.black_point_correction.auto") or getcfg("calibration.black_point_correction") ) and defaults["calibration.black_point_hack"] ): # Forced black point hack # (Argyll CMS 1.7b 2014-12-22) # Always use this if no black luminance or black point hue # correction specified. The rationale is that a reasonably good # quality digitally driven display should have no "dead zone" # above zero device input if set up correctly. Using this option # with a display that is not well behaved may result in a loss # of shadow detail. self.log("skipping -b parameter") # args.append("-b") pass if verify: if calibrate and isinstance(verify, int): args.append(f"-e{verify}") # Verify final computed curves elif self.argyll_version >= [1, 6]: args.append("-z") # Verify current curves else: args.append("-E") # Verify current curves if getcfg("extra_args.dispcal").strip(): args += parse_argument_string(getcfg("extra_args.dispcal")) if config.get_display_name() == "Resolve" or ( config.get_display_name() == "Prisma" and not defaults["patterngenerator.prisma.argyll"] ): # Substitute actual measurement frame dimensions self.options_dispcal = [ re.sub( r"^-[Pp]1,1,0.01$", "-P" + getcfg("dimensions.measureframe"), arg ) for arg in args ] # Re-add -F (darken background) so it can be set when loading settings if getcfg("measure.darken_background"): self.options_dispcal.append("-F") else: self.options_dispcal = list(args) if calibrate: args.append(inoutfile) return cmd, args def prepare_dispread(self, apply_calibration=True): """Prepare a dispread commandline. All options are read from the user configuration. You can choose if you want to apply the current calibration, either the previously by dispcal created one by passing in True, by passing in a valid path to a .cal file, or by passing in None (current video card gamma table). """ self.lastcmdname = get_argyll_utilname("dispread") inoutfile = self.setup_inout() if not inoutfile or isinstance(inoutfile, Exception): return inoutfile, None if not os.path.exists(f"{inoutfile}.ti1"): filename, ext = os.path.splitext(getcfg("testchart.file")) result = check_file_isfile(filename + ext) if isinstance(result, Exception): return result, None try: if ext.lower() in (".icc", ".icm"): try: profile = ICCProfile(filename + ext) except (IOError, ICCProfileInvalidError): return ( Error( lang.getstr( "error.testchart.read", getcfg("testchart.file") ) ), None, ) ti3 = BytesIO( profile.tags.get("CIED", b"") or profile.tags.get("targ", b"") ) elif ext.lower() == ".ti1": shutil.copyfile(filename + ext, f"{inoutfile}.ti1") else: # ti3 try: ti3 = open(filename + ext, "rb") except Exception: return ( Error( lang.getstr( "error.testchart.read", getcfg("testchart.file") ) ), None, ) if ext.lower() != ".ti1": ti3_lines = [line.strip() for line in ti3] ti3.close() if b"CTI3" not in ti3_lines: return ( Error( lang.getstr( "error.testchart.invalid", getcfg("testchart.file") ) ), None, ) with open(f"{inoutfile}.ti1", "wb") as ti1: ti1.write(ti3_to_ti1(ti3_lines)) except Exception as exception: localized_error_message = lang.getstr( "error.testchart.creation_failed", f"{inoutfile}.ti1" ) return ( Error(f"{localized_error_message}\n\n{exception}"), None, ) if apply_calibration is not False: if apply_calibration is True: # Always a .cal file in that case cal = ( os.path.join( getcfg("profile.save_path"), getcfg("profile.name.expanded"), getcfg("profile.name.expanded"), ) + ".cal" ) elif apply_calibration is None: # Use current videoLUT cal = f"{inoutfile}.cal" result = self.save_current_video_lut(self.get_display(), cal) if isinstance(result, Exception) and not isinstance( result, UnloggedInfo ): return result, None else: cal = apply_calibration # can be .cal or .icc / .icm calcopy = f"{inoutfile}.cal" filename, ext = os.path.splitext(cal) if getcfg("dry_run"): options_dispcal = [] elif ext.lower() == ".cal": result = check_cal_isfile(cal) if isinstance(result, Exception): return result, None if not result: return None, None # Get dispcal options if present try: options_dispcal = get_options_from_cal(cal)[0] except ( IOError, CGATSInvalidError, CGATSInvalidOperationError, CGATSKeyError, CGATSTypeError, CGATSValueError, ) as exception: return exception, None if not os.path.exists(calcopy): try: # Copy cal to temp dir shutil.copyfile(cal, calcopy) except Exception as exception: return ( Error( lang.getstr("error.copy_failed", (cal, calcopy)) + "\n\n" + str(exception) ), None, ) result = check_cal_isfile(calcopy) if isinstance(result, Exception): return result, None if not result: return None, None else: # .icc / .icm result = check_profile_isfile(cal) if isinstance(result, Exception): return result, None if not result: return None, None try: profile = ICCProfile(filename + ext) except (IOError, ICCProfileInvalidError): profile = None if profile: ti3 = StringIO( profile.tags.get("CIED", "") or profile.tags.get("targ", "") ) # Get dispcal options if present options_dispcal = get_options_from_profile(profile)[0] else: ti3 = StringIO("") ti3_lines = [line.strip() for line in ti3] ti3.close() if "CTI3" not in ti3_lines: return Error(lang.getstr("error.cal_extraction", (cal))), None try: tmpcal = open(calcopy, "w") tmpcal.write(extract_cal_from_ti3(ti3_lines)) tmpcal.close() except Exception as exception: return ( Error( lang.getstr("error.cal_extraction", (cal)) + "\n\n" + str(exception) ), None, ) cal = calcopy if options_dispcal: self.options_dispcal = [f"-{arg}" for arg in options_dispcal] # # Make sure any measurement options are present if not self.options_dispcal: self.prepare_dispcal(dry_run=True) # Special case -X because it can have a separate filename argument if "-X" in self.options_dispcal: index = self.options_dispcal.index("-X") if ( len(self.options_dispcal) > index + 1 and self.options_dispcal[index + 1][0] != "-" ): self.options_dispcal = ( self.options_dispcal[:index] + self.options_dispcal[index + 2 :] ) # Strip options we may override (basically all the stuff which can be # added by add_measurement_features. -X is repeated because it can # have a number instead of explicit filename argument, e.g. -X1) dispcal_override_args = ( "-F", "-H", "-I", "-P", "-V", "-X", "-d", "-c", "-p", "-y", ) self.options_dispcal = [ arg for arg in self.options_dispcal if arg[:2] not in dispcal_override_args ] # Only add the dispcal extra args which may override measurement features dispcal_extra_args = parse_argument_string(getcfg("extra_args.dispcal")) for i, arg in enumerate(dispcal_extra_args): if not arg.startswith("-") and i > 0: # Assume option to previous arg arg = dispcal_extra_args[i - 1] if arg[:2] in dispcal_override_args: self.options_dispcal.append(dispcal_extra_args[i]) result = self.add_measurement_features( self.options_dispcal, ignore_display_name=True ) if isinstance(result, Exception): return result, None cmd = get_argyll_util("dispread") args = [] args.append("-v") # verbose if getcfg("argyll.debug"): args.append("-D8") result = self.add_measurement_features( args, allow_nondefault_observer=is_ccxx_testchart(), quantize=True ) if isinstance(result, Exception): return result, None if apply_calibration is not False: if ( self.argyll_version >= [1, 3, 3] and ( not self.has_lut_access() or not getcfg("calibration.use_video_lut") ) # Only use -K if we don't use -d n,m (Linux X11) and len(get_arg("-d", args)[1].split(",")) == 1 ): # Apply calibration to test values directly instead of via # videoLUT args.append("-K") else: # Apply calibration via videoLUT (in special case of madVR, # always applied to test values directly instead) args.append("-k") args.append(cal) if self.get_instrument_features().get("spectral"): args.append("-s") if getcfg("extra_args.dispread").strip(): args += parse_argument_string(getcfg("extra_args.dispread")) self.options_dispread = list(args) cgats = self.ensure_patch_sequence(inoutfile + ".ti1") if getattr(self, "terminal", None) and isinstance( self.terminal, UntetheredFrame ): result = self.set_terminal_cgats(cgats) if isinstance(result, Exception): return result, None return cmd, self.options_dispread + [inoutfile] def prepare_dispwin(self, cal=None, profile_path=None, install=True): """Prepare a dispwin commandline. All options are read from the user configuration. If you pass in cal as True, it will try to load the current display profile's calibration. If cal is a path, it'll use that instead. If cal is False, it'll clear the current calibration. If cal is None, it'll try to load the calibration from a profile specified by profile_path. """ cmd = get_argyll_util("dispwin") args = [] args.append("-v") if getcfg("argyll.debug"): if self.argyll_version >= [1, 3, 1]: args.append("-D8") else: args.append("-E8") args.append("-d" + self.get_display()) if sys.platform != "darwin" or cal is False: # Mac OS X 10.7 Lion needs root privileges when clearing # calibration args.append("-c") if cal is True: args.append( self.get_dispwin_display_profile_argument( max(0, min(len(self.displays), getcfg("display.number")) - 1) ) ) elif cal: result = check_cal_isfile(cal) if isinstance(result, Exception): return result, None if not result: return None, None args.append(cal) else: if cal is None: if not profile_path: profile_save_path = os.path.join( getcfg("profile.save_path"), getcfg("profile.name.expanded") ) profile_path = os.path.join( profile_save_path, getcfg("profile.name.expanded") + profile_ext ) result = check_profile_isfile(profile_path) if isinstance(result, Exception): return result, None if not result: return None, None try: profile = ICCProfile(profile_path) except (IOError, ICCProfileInvalidError): return ( Error(lang.getstr("profile.invalid") + "\n" + profile_path), None, ) if profile.profileClass != b"mntr" or profile.colorSpace != b"RGB": return ( Error( lang.getstr( "profile.unsupported", (profile.profileClass, profile.colorSpace), ) + "\n" + profile_path ), None, ) if install: if getcfg("profile.install_scope") != "u" and ( ( ( sys.platform == "darwin" or ( sys.platform != "win32" and self.argyll_version >= [1, 1, 0] ) ) and (os.geteuid() == 0 or which("sudo")) ) or ( sys.platform == "win32" and sys.getwindowsversion() >= (6,) and self.argyll_version > [1, 1, 1] ) ): # -S option is broken on Linux with current Argyll # releases args.append("-S" + getcfg("profile.install_scope")) else: # Make sure user profile dir exists # (e.g. on Mac OS X 10.9 Mavericks, it does not by # default) for profile_dir in reversed(iccprofiles_home): if os.path.isdir(profile_dir): break if not os.path.isdir(profile_dir): try: os.makedirs(profile_dir) except OSError as exception: return exception, None args.append("-I") # Always copy to temp dir so if a user accidentally tries # to install a profile from the location where it's already # installed (e.g. system32/spool/drivers/color) it doesn't # get nuked by dispwin tmp_dir = self.create_tempdir() if not tmp_dir or isinstance(tmp_dir, Exception): return tmp_dir, None # Check directory and in/output file(s) result = check_create_dir(tmp_dir) if isinstance(result, Exception): return result, None profile_name = os.path.basename(profile_path) if ( sys.platform in ("win32", "darwin") or fs_enc.upper() not in ("UTF8", "UTF-8") ) and re.search(r"[^\x20-\x7e]", profile_name): # Copy to temp dir and give ASCII-only name to # avoid profile install issues profile_tmp_path = os.path.join( tmp_dir, safe_asciize(profile_name).decode("utf-8", "ignore"), ) else: profile_tmp_path = os.path.join(tmp_dir, profile_name) shutil.copyfile(profile_path, profile_tmp_path) profile_path = profile_tmp_path args.append(profile_path) return cmd, args def prepare_targen(self): """Prepare a targen commandline. All options are read from the user configuration. """ path = self.create_tempdir() if not path or isinstance(path, Exception): return path, None # Check directory and in/output file(s) result = check_create_dir(path) if isinstance(result, Exception): return result, None inoutfile = os.path.join(path, "temp") cmd = get_argyll_util("targen") args = [] args.append("-v") args.append("-d3") args.append("-e{}".format(getcfg("tc_white_patches"))) if self.argyll_version >= [1, 6]: args.append("-B{}".format(getcfg("tc_black_patches"))) args.append("-s{}".format(getcfg("tc_single_channel_patches"))) args.append("-g{}".format(getcfg("tc_gray_patches"))) args.append("-m{}".format(getcfg("tc_multi_steps"))) if self.argyll_version >= [1, 6, 0]: args.append("-b{}".format(getcfg("tc_multi_bcc_steps"))) tc_algo = getcfg("tc_algo") if getcfg("tc_fullspread_patches") > 0: args.append("-f{}".format(config.get_total_patches())) if tc_algo: args.append("-" + tc_algo) if tc_algo in ("i", "I"): args.append("-a{}".format(getcfg("tc_angle"))) if tc_algo == "": args.append("-A{}".format(getcfg("tc_adaption"))) if self.argyll_version >= [1, 3, 3]: args.append("-N{}".format(getcfg("tc_neutral_axis_emphasis"))) if self.argyll_version == [1, 1, "RC1"] or self.argyll_version >= [1, 1]: args.append("-G") else: args.append("-f0") if getcfg("tc_precond") and getcfg("tc_precond_profile"): args.append("-c") args.append(getcfg("tc_precond_profile")) if getcfg("tc_filter"): args.append( "-F{},{},{},{}".format( getcfg("tc_filter_L"), getcfg("tc_filter_a"), getcfg("tc_filter_b"), getcfg("tc_filter_rad"), ) ) if self.argyll_version >= [1, 6, 2] and ( "-c" in args or self.argyll_version >= [1, 6, 3] ): args.append("-V{}".format(1 + getcfg("tc_dark_emphasis") * 3)) if self.argyll_version == [1, 1, "RC2"] or self.argyll_version >= [1, 1]: args.append("-p{}".format(getcfg("tc_gamma"))) if getcfg("extra_args.targen").strip(): # Disallow -d and -D as the testchart editor only supports # video RGB (-d3) args += [ arg for arg in parse_argument_string(getcfg("extra_args.targen")) if not arg.lower().startswith("-d") ] self.options_targen = list(args) args.append(inoutfile) return cmd, args def progress_handler(self, event): """Handle progress dialog updates and react to Argyll CMS command output""" if getattr(self, "subprocess_abort", False) or getattr( self, "thread_abort", False ): self.progress_wnd.Pulse(lang.getstr("aborting")) return percentage = None msg = self.recent.read(FilteredStream.triggers) lastmsg = self.lastmsg.read(FilteredStream.triggers).strip() warning = r"\D+: Warning -.*" msg = re.sub(warning, "", msg) lastmsg = re.sub(warning, "", lastmsg) # Filter for '=' so that 1% reading during calibration check # measurements doesn't trigger swapping from the interactive adjustment # to the progress window if re.match(r"\s*\d+%\s*(?:[^=]+)?$", lastmsg): # colprof, download progress try: percentage = int(self.lastmsg.read().split("%")[0]) except ValueError: pass elif re.match(r"Patch \d+ of \d+", lastmsg, re.I): # dispcal/dispread components = lastmsg.split() try: start = float(components[1]) end = float(components[3]) except ValueError: pass else: percentage = max(start - 1, 0) / end * 100 elif re.match(r"Added \d+/\d+", lastmsg, re.I): # targen components = lastmsg.lower().replace("added ", "").split("/") try: start = float(components[0]) end = float(components[1]) except ValueError: pass else: percentage = start / end * 100 else: iteration = re.search(r"It (\d+):", msg) if iteration: # targen try: start = float(iteration.groups()[0]) except ValueError: pass else: end = 20 percentage = min(start, 20.0) / end * 100 lastmsg = "" if ( percentage is not None and time() > self.starttime + 3 and self.progress_wnd is getattr(self, "terminal", None) and not self._detecting_video_levels ): # We no longer need keyboard interaction, switch over to # progress dialog wx.CallAfter(self.swap_progress_wnds) self.set_progress_type() if ( getattr(self.progress_wnd, "original_msg", None) and msg != self.progress_wnd.original_msg ): # UGLY HACK: This 'print' call fixes a GTK assertion and # segfault under Arch Linux when setting the window title. # This has a chance of throwing a IOError: [Errno 9] Bad file # descriptor under Windows, so check for wxGTK if "__WXGTK__" in wx.PlatformInfo: print("") self.progress_wnd.SetTitle(self.progress_wnd.original_msg) self.progress_wnd.original_msg = None if percentage is not None: if ( "Setting up the instrument" in msg or "Commencing device calibration" in msg or "Commencing display calibration" in msg or "Calibration complete" in msg ): self.recent.clear() msg = "" keepGoing, skip = self.progress_wnd.UpdateProgress( max(min(percentage, 100), 0), msg + "\n" + lastmsg ) elif re.match(r"\d+(?:\.\d+)? (?:[KM]iB)", lastmsg, re.I): keepGoing, skip = self.progress_wnd.Pulse("\n".join([msg, lastmsg])) else: if getattr(self.progress_wnd, "lastmsg", "") == msg or not msg: keepGoing, skip = self.progress_wnd.Pulse() else: if "Setting up the instrument" in lastmsg: msg = lang.getstr("instrument.initializing") elif "Created web server at" in msg: webserver = re.search(r"(http\:\/\/[^']+)", msg) if webserver: msg = ( lang.getstr("webserver.waiting") + " " + webserver.groups()[0] ) keepGoing, skip = self.progress_wnd.Pulse(msg) self.pause_continue() if hasattr(self.progress_wnd, "pause_continue"): if "read stopped at user request!" in lastmsg: self.progress_wnd.pause_continue.Enable() if self.progress_wnd.pause_continue.IsShown() != self.pauseable: self.progress_wnd.pause_continue.Show(self.pauseable) self.progress_wnd.Layout() if not keepGoing and not getattr(self, "abort_requested", False): # Only confirm abort if we are not currently doing interactive # display adjustment self.abort_subprocess( not isinstance(self._progress_wnd, DisplayAdjustmentFrame) ) if self.finished is True: return if ( self.progress_wnd.IsShownOnScreen() and not self.progress_wnd.IsActive() and ( not getattr(self.progress_wnd, "dlg", None) or not self.progress_wnd.dlg.IsShownOnScreen() ) and wx.GetApp().GetTopWindow() and wx.GetApp().GetTopWindow().IsShownOnScreen() and ( wx.GetApp().IsActive() or (sys.platform == "darwin" and not self.activated) ) ): for window in list(wx.GetTopLevelWindows()): if ( window and window is not self.progress_wnd and isinstance(window, wx.Dialog) and window.IsShownOnScreen() ): return self.activated = True self.progress_wnd.Raise() def progress_dlg_start( self, progress_title="", progress_msg="", parent=None, resume=False, fancy=True ): """Start a progress dialog, replacing existing one if present""" if self._progress_wnd and self.progress_wnd is getattr(self, "terminal", None): self.terminal.stop_timer() self.terminal.Hide() if self.finished is True: return fancy = fancy and getcfg("use_fancy_progress") if ( resume and self._progress_wnd and self._progress_wnd in list(self._progress_dlgs.values()) ): progress_wnd = self._progress_wnd else: key = ( self.show_remaining_time, self.cancelable, fancy, parent, parent and parent.IsShownOnScreen(), ) progress_wnd = self._progress_dlgs.get(key) if progress_wnd: if self._progress_wnd is not progress_wnd: self.progress_wnd = progress_wnd # UGLY HACK: This 'print' call fixes a GTK assertion and # segfault under Arch Linux when setting the window title # This has a chance of throwing a IOError: [Errno 9] Bad file # descriptor under Windows, so check for wxGTK if "__WXGTK__" in wx.PlatformInfo: print("") self.progress_wnd.SetTitle(progress_title) if not resume or not self.progress_wnd.IsShown(): self.progress_wnd.reset() self.progress_wnd.Pulse(progress_msg) if hasattr(self.progress_wnd, "pause_continue"): self.progress_wnd.pause_continue.Show(self.pauseable) self.progress_wnd.Layout() self.progress_wnd.Resume() if not self.progress_wnd.IsShownOnScreen(): self.progress_wnd.place() self.progress_wnd.Show() else: style = wx.PD_SMOOTH | wx.PD_ELAPSED_TIME if self.show_remaining_time: style |= wx.PD_REMAINING_TIME if self.cancelable: style |= wx.PD_CAN_ABORT # Set maximum to 101 to prevent the 'cancel' changing to 'close' # when 100 is reached self._progress_dlgs[key] = ProgressDialog( progress_title, progress_msg, maximum=101, parent=parent, handler=self.progress_handler, keyhandler=self.terminal_key_handler, pauseable=self.pauseable, style=style, start_timer=False, fancy=fancy, ) self.progress_wnd = self._progress_dlgs[key] self.set_progress_type() if not self.progress_wnd.timer.IsRunning(): self.progress_wnd.start_timer() self.progress_wnd.original_msg = progress_msg def set_progress_type(self): """Set progress type for fancy progress dialog""" if hasattr(self.progress_wnd, "progress_type"): if self.pauseable or getattr(self, "interactive_frame", "") in ( "ambient", "luminance", ): # If pauseable, we assume it's a measurement progress_type = 1 # Measuring elif self.cmdname == get_argyll_utilname("targen"): progress_type = 2 # Generating test patches else: progress_type = 0 # Processing if self.progress_wnd.progress_type != progress_type: if self.progress_wnd.timer.IsRunning(): # Fade-out current progress type, fade-in new one self.progress_wnd.set_progress_type(progress_type) else: # Not yet running, just set initial progress type self.progress_wnd.progress_type = progress_type def quit_terminate_cmd(self): """Forcefully abort the current subprocess. Try to gracefully exit first by sending common Argyll CMS abort keystrokes (ESC), forcefully terminate the subprocess if not reacting """ # If running wexpect.spawn in a thread under Windows, writing to # sys.stdout from another thread can fail sporadically with IOError 9 # 'Bad file descriptor', so don't use sys.stdout # Careful: Python 2.5 Producer objects don't have a name attribute if ( hasattr(self, "thread") and self.thread.is_alive() and ( not hasattr(currentThread(), "name") or currentThread().name != self.thread.name ) ): logfn = log else: logfn = print subprocess = getattr(self, "subprocess", None) if self.isalive(subprocess): try: if self.measure_cmd and hasattr(subprocess, "send"): self.log( f"{appname}: Trying to end subprocess gracefully...", fn=logfn ) try: if subprocess.after == "Current": # Stop measurement self.safe_send(" ") sleep(1) ts = time() while ( self.isalive(subprocess) and self.subprocess == subprocess ): self.safe_send("\x1b") if time() > ts + 20: break sleep(0.5) except Exception as exception: self.log(traceback.format_exc(), fn=logfn) self.log( f"{appname}: Exception in quit_terminate_command: {exception}", fn=logfn, ) elif hasattr(subprocess, "sendintr"): self.log(f"{appname}: Sending CTRL+C to subprocess...", fn=logfn) try: subprocess.sendintr() except Exception as exception: self.log(traceback.format_exc(), fn=logfn) self.log( f"{appname}: Exception in quit_terminate_command: {exception}", fn=logfn, ) ts = time() while self.isalive(subprocess): if time() > ts + 20: break sleep(0.25) if self.isalive(subprocess): self.log(f"{appname}: Trying to terminate subprocess...", fn=logfn) subprocess.terminate() ts = time() while self.isalive(subprocess): if time() > ts + 3: break sleep(0.25) if sys.platform != "win32" and self.isalive(subprocess): self.log( f"{appname}: Trying to terminate subprocess forcefully...", fn=logfn, ) if isinstance(subprocess, sp.Popen): subprocess.kill() else: subprocess.terminate(force=True) ts = time() while self.isalive(subprocess): if time() > ts + 3: break sleep(0.25) if self.isalive(subprocess): self.log("...warning: couldn't terminate subprocess.", fn=logfn) else: self.log("...subprocess terminated.", fn=logfn) except Exception as exception: self.log(traceback.format_exc(), fn=logfn) self.log( f"{appname}: Exception in quit_terminate_command: {exception}", fn=logfn, ) subprocess_isalive = self.isalive(subprocess) if subprocess_isalive or ( hasattr(self, "thread") and not self.thread.is_alive() ): # We don't normally need this as closing of the progress window is # handled by _generic_consumer(), but there are two cases where it # is desirable to have this 'safety net': # 1. The user aborted a running task, but we couldn't terminate the # associated subprocess. In that case, we have a lingering # subprocess which is problematic but we can't do anything about # it. Atleast we need to give control back to the user by closing # the progress window so he can interact with the application # and doesn't have to resort to forecfully terminate it. # 2. We started a thread with continue_next=True, which then exited # without returning an error, yet not the result we were looking # for, so we never started the next thread with resume=True, but # we forgot to call stop_progress() exlicitly. This should never # happen if we design our result consumer correctly to handle # this particular case, but we need to make sure the user can # close the progress window in case we mess up. if hasattr(self, "thread") and not self.thread.is_alive(): wx.CallAfter(self.stop_progress) if subprocess_isalive: wx.CallAfter( show_result_dialog, Warning( f"Couldn't terminate {self.cmd}. Please try to end it manually " f"before continuing to use {appname}. If you can not terminate " f"{self.cmd}, restarting {appname} may also help. Apologies " "for the inconvenience." ), self.owner, ) if self.patterngenerator: self.patterngenerator.listening = False return not subprocess_isalive def report(self, report_calibrated=True): """Report on calibrated or uncalibrated display device response""" result = self.detect_video_levels() if isinstance(result, Exception) or not result: return result cmd, args = self.prepare_dispcal(calibrate=False) if isinstance(cmd, Exception): return cmd if args: if report_calibrated: args.append("-r") else: args.append("-R") return self.exec_cmd(cmd, args, capture_output=True, skip_scripts=True) def reset_cal(self): cmd, args = self.prepare_dispwin(False) result = self.exec_cmd( cmd, args, capture_output=True, skip_scripts=True, silent=False ) return result def safe_send(self, bytes_): self.send_buffer = bytes_ return True def _safe_send(self, bytes_, retry=3, obfuscate=False): """Safely send a keystroke to the current subprocess.""" for i in range(0, retry): if obfuscate: logbytes = "***" else: logbytes = bytes_ self.logger.info("Sending key(s) {} ({:d})".format(logbytes, i + 1)) try: if sys.platform == "win32": # directly send the bytes_ without encoding to anything self.subprocess.send(bytes_) else: # for Linux and MacOS encode to bytes self.subprocess.send(bytes_.encode()) except Exception as exception: self.logger.exception(f"Exception: {exception}") else: return True sleep(0.25) return False def save_current_video_lut( self, display_no, outfilename, interpolate_to_256=True, silent=False ): """Save current videoLUT, optionally interpolating to n entries""" result = None if self.argyll_version[0:3] > [1, 1, 0] or ( self.argyll_version[0:3] == [1, 1, 0] and "Beta" not in self.argyll_version_string ): cmd, args = ( get_argyll_util("dispwin"), [f"-d{display_no}", "-s", outfilename], ) result = self.exec_cmd( cmd, args, capture_output=True, skip_scripts=True, silent=silent ) if isinstance(result, Exception) and not isinstance(result, UnloggedInfo): return result if not result: return Error(lang.getstr("calibration.load_error")) # Make sure there are 256 entries in the .cal file, otherwise dispwin # will complain and not be able to load it back in. # Under Windows, the GetDeviceGammaRamp API seems to enforce 256 entries # regardless of graphics card, but under Linux and Mac OS X there may be # more than 256 entries if the graphics card has greater than 8 bit # videoLUTs (e.g. Quadro and newer consumer cards) cgats = CGATS(outfilename) data = cgats.queryv1("DATA") if data and len(data) != 256: print("VideoLUT has {:d} entries, interpolating to 256".format(len(data))) rgb = {"I": [], "R": [], "G": [], "B": []} for entry in data.values(): for column in ("I", "R", "G", "B"): rgb[column].append(entry["RGB_" + column]) interp = {} for column in ("R", "G", "B"): interp[column] = colormath.Interp(rgb["I"], rgb[column]) resized = CGATS() data.parent.DATA = resized resized.key = "DATA" resized.parent = data.parent resized.root = cgats resized.type = b"DATA" for i in range(256): entry = {"RGB_I": i / 255.0} for column in ("R", "G", "B"): entry["RGB_" + column] = interp[column](entry["RGB_I"]) resized.add_data(entry) cgats.write() return result def set_argyll_version(self, name, silent=False, cfg=False): self.set_argyll_version_from_string( get_argyll_version_string(name, silent), cfg ) def set_argyll_version_from_string(self, argyll_version_string, cfg=True): self.argyll_version_string = argyll_version_string if cfg: setcfg("argyll.version", argyll_version_string) # Always write cfg directly after setting Argyll version so # subprocesses that read the configuration will use the right # version writecfg() self.argyll_version = parse_argyll_version_string(argyll_version_string) def set_sessionlogfile(self, sessionlogfile, basename, dirname): if sessionlogfile: self.sessionlogfile = sessionlogfile else: self.sessionlogfile = LogFile(basename, dirname) self.sessionlogfiles[basename] = self.sessionlogfile def set_terminal_cgats(self, cgats): if not isinstance(cgats, CGATS): try: cgats = CGATS(cgats) except ( IOError, CGATSInvalidError, CGATSInvalidOperationError, CGATSKeyError, CGATSTypeError, CGATSValueError, ) as exception: return exception self.terminal.cgats = cgats def setup_inout(self, basename=None): """Setup in/outfile basename and session logfile.""" dirname = self.create_tempdir() if not dirname or isinstance(dirname, Exception): return dirname # Check directory and in/output file(s) result = check_create_dir(dirname) if isinstance(result, Exception): return result if basename is None: basename = getcfg("profile.name.expanded") basename = make_argyll_compatible_path(basename) self.set_sessionlogfile(None, basename, dirname) return os.path.join(dirname, basename) def single_real_display(self): return len(self.get_real_displays()) == 1 def argyll_support_file_exists(self, name, scope=None): """Check if named file exists in any of the known Argyll support locations valid for the chosen Argyll CMS version. Scope can be 'u' (user), 'l' (local system) or None (both) """ paths = [] if sys.platform != "darwin": if not scope or scope == "u": paths.append(defaultpaths.appdata) if not scope or scope == "l": paths += defaultpaths.commonappdata else: if not scope or scope == "u": paths.append(defaultpaths.library_home) if not scope or scope == "l": paths.append(defaultpaths.library) searchpaths = [] if self.argyll_version >= [1, 5, 0]: if sys.platform != "darwin": searchpaths.extend( os.path.join(dir_, "ArgyllCMS", name) for dir_ in paths ) else: paths2 = [] if not scope or scope == "u": paths2.append(defaultpaths.appdata) if not scope or scope == "l": paths2.append(defaultpaths.library) if [1, 9] <= self.argyll_version <= [1, 9, 1]: # Argyll CMS 1.9 and 1.9.1 use *nix locations due to a # configuration problem paths2.extend( [ os.path.join(defaultpaths.home, ".local", "share"), "/usr/local/share", ] ) searchpaths.extend( os.path.join(dir_, "ArgyllCMS", name) for dir_ in paths2 ) searchpaths.extend(os.path.join(dir_, "color", name) for dir_ in paths) for searchpath in searchpaths: if os.path.isfile(searchpath): return True return False def spyder2_firmware_exists(self, scope=None): """Check if the Spyder 2 firmware file exists in any of the known locations valid for the chosen Argyll CMS version. Scope can be 'u' (user), 'l' (local system) or None (both) """ if self.argyll_version < [1, 2, 0]: spyd2en = get_argyll_util("spyd2en") if not spyd2en: return False return os.path.isfile( os.path.join(os.path.dirname(spyd2en), "spyd2PLD.bin") ) else: return self.argyll_support_file_exists("spyd2PLD.bin", scope=scope) def spyder4_cal_exists(self): """Check if the Spyder4/5 calibration file exists in any of the known locations valid for the chosen Argyll CMS version.""" if self.argyll_version < [1, 3, 6]: # We couldn't use it even if it exists return False return self.argyll_support_file_exists("spyd4cal.bin") def start( self, consumer, producer, cargs=(), ckwargs=None, wargs=(), wkwargs=None, progress_title=appname, progress_msg="", parent=None, progress_start=100, resume=False, continue_next=False, stop_timers=True, interactive_frame="", pauseable=False, cancelable=True, show_remaining_time=True, fancy=True, ): # The following statement is super hacky, I didn't want to use it but the # original developer wanted to add the ``appname`` into the docstring # programmatically. So, I think this is the best but hacky way to do it. self.start.__func__.__doc__ = f"""Start a worker process. Also show a progress dialog while the process is running. consumer consumer function. producer producer function. cargs consumer arguments. ckwargs consumer keyword arguments. wargs producer arguments. wkwargs producer keyword arguments. progress_title progress dialog title. Defaults to '{appname}'. progress_msg progress dialog message. Defaults to ''. progress_start show progress dialog after delay (ms). resume resume previous progress dialog (elapsed time etc). continue_next do not hide progress dialog after producer finishes. stop_timers stop the timers on the owner window if True interactive_frame "" or "uniformity" (selects the type of interactive window) pauseable Is the operation pauseable? (show pause button on progress dialog) cancelable Is the operation cancelable? (show cancel button on progress dialog) fancy Use fancy progress dialog with animated throbber & sound fx """ if ckwargs is None: ckwargs = {} if wkwargs is None: wkwargs = {} while self.is_working(): sleep(0.25) # wait until previous worker thread finishes if hasattr(self.owner, "stop_timers") and stop_timers: self.owner.stop_timers() if not parent: parent = self.owner if progress_start < 1: # Can't be zero! progress_start = 1 self.activated = False self.cmdname = None self.cmdrun = False self.finished = False self.instrument_calibration_complete = False if not resume: self.instrument_on_screen = False self.instrument_place_on_screen_msg = False self.instrument_sensor_position_msg = False self.interactive_frame = interactive_frame self.is_single_measurement = ( interactive_frame == "ambient" or interactive_frame == "luminance" or ( isinstance(interactive_frame, wx.TopLevelWindow) and interactive_frame.Name == "VisualWhitepointEditor" ) ) self.is_ambient_measurement = interactive_frame == "ambient" self.lastcmdname = None self.pauseable = pauseable self.paused = False self.cancelable = cancelable self.show_remaining_time = show_remaining_time self.fancy = fancy self.resume = resume self.subprocess_abort = False self.abort_requested = False self.starttime = time() self.thread_abort = False if ( fancy and ( not self.interactive or interactive_frame not in ("uniformity", "untethered") ) and not isinstance(interactive_frame, wx.TopLevelWindow) ): # Pre-init progress dialog bitmaps ProgressDialog.get_bitmaps(0) ProgressDialog.get_bitmaps(1) if self.interactive: self.progress_start_timer = wx.Timer() if progress_msg and progress_title == appname: progress_title = progress_msg if ( config.get_display_name() == "Untethered" and interactive_frame != "uniformity" ): interactive_frame = "untethered" if interactive_frame == "adjust": windowclass = DisplayAdjustmentFrame elif interactive_frame == "uniformity": windowclass = DisplayUniformityFrame elif interactive_frame == "untethered": windowclass = UntetheredFrame else: windowclass = SimpleTerminal if getattr(self, "terminal", None) and isinstance( self.terminal, windowclass ): self.progress_wnd = self.terminal if not resume: if isinstance(self.progress_wnd, SimpleTerminal): self.progress_wnd.console.SetValue("") elif ( isinstance(self.progress_wnd, DisplayAdjustmentFrame) or isinstance(self.progress_wnd, DisplayUniformityFrame) or isinstance(self.progress_wnd, UntetheredFrame) ): self.progress_wnd.reset() self.progress_wnd.stop_timer() self.progress_wnd.Resume() self.progress_wnd.start_timer() # UGLY HACK: This 'print' call fixes a GTK assertion and # segfault under Arch Linux when setting the window title print("") if isinstance(self.progress_wnd, SimpleTerminal): self.progress_wnd.SetTitle(progress_title) self.progress_wnd.Show() if resume and isinstance(self.progress_wnd, SimpleTerminal): self.progress_wnd.console.ScrollLines( self.progress_wnd.console.GetNumberOfLines() ) else: if getattr(self, "terminal", None): # Destroy the wx object so the decref'd python object can # be garbage collected self.terminal.Destroy() if interactive_frame == "adjust": self.terminal = DisplayAdjustmentFrame( parent, handler=self.progress_handler, keyhandler=self.terminal_key_handler, ) elif interactive_frame == "uniformity": self.terminal = DisplayUniformityFrame( parent, handler=self.progress_handler, keyhandler=self.terminal_key_handler, ) elif interactive_frame == "untethered": self.terminal = UntetheredFrame( parent, handler=self.progress_handler, keyhandler=self.terminal_key_handler, ) elif isinstance(interactive_frame, wx.TopLevelWindow): self.terminal = interactive_frame else: self.terminal = SimpleTerminal( parent, title=progress_title, handler=self.progress_handler, keyhandler=self.terminal_key_handler, ) if getattr(self.terminal, "worker", self) is not self: print( "DEBUG: In worker.Worker.start: worker.Worker()." "terminal.worker is not self! This is probably a" "bug." ) self.terminal.worker = self self.progress_wnd = self.terminal else: if not progress_msg: progress_msg = lang.getstr("please_wait") # Show the progress dialog after a delay self.progress_start_timer = BetterCallLater( progress_start, self.progress_dlg_start, progress_title, progress_msg, parent, resume, fancy, ) if not hasattr(self, "_disabler"): skip = self.progress_wnds if self.owner and hasattr(self.owner, "measureframe"): skip.append(self.owner.measureframe) self._disabler = BetterWindowDisabler(skip) # Can't use startWorker because we may need access to self.thread from # within thread, and startWorker does not return before the actual # thread starts running jobID = None sender = delayedresult.SenderCallAfter( self._generic_consumer, jobID, args=[consumer, continue_next] + list(cargs), kwargs=ckwargs, ) self.thread = delayedresult.Producer( sender, Producer(self, producer, continue_next), args=wargs, kwargs=wkwargs, name=jobID, group=None, daemon=False, senderArg=None, sendReturn=True, ) self.thread.start() return True def stop_progress(self): if hasattr(self, "_disabler"): del self._disabler if getattr(self, "progress_wnd", False): if getattr(self.progress_wnd, "dlg", None): if self.progress_wnd.dlg.IsShownOnScreen(): self.progress_wnd.dlg.EndModal(wx.ID_CANCEL) self.progress_wnd.dlg = None self.progress_wnd.stop_timer() if getattr(self.progress_wnd, "Name", None) == "VisualWhitepointEditor": self.progress_wnd.Close() else: self.progress_wnd.Hide() self.subprocess_abort = False self.thread_abort = False self.interactive = False self.resume = False self._detected_output_levels = False # Uninhibit session if needed if hasattr(self, "dbus_ifaces"): for bus_name in self.dbus_ifaces: iface_dict = self.dbus_ifaces[bus_name] cookie = iface_dict.get("cookie") if cookie: # Uninhibit. Note that if (e.g.) screensaver timeout has # occured during the time the session was inhibited, that # may now kick in immediately after uninhibiting uninhibit = iface_dict.get("uninhibit", "un_inhibit") try: getattr(iface_dict["iface"], uninhibit)(cookie) except DBusException as exception: self.log(exception) else: iface_dict["cookie"] = None self.log(f"{appname}: Uninhibited {bus_name}") def swap_progress_wnds(self): """Swap the current interactive window with a progress dialog""" parent = self.terminal.GetParent() if isinstance(self.terminal, DisplayAdjustmentFrame): title = lang.getstr("calibration") else: title = self.terminal.GetTitle() self.progress_dlg_start(title, "", parent, self.resume, self.fancy) def terminal_key_handler(self, event): """Key handler for the interactive window or progress dialog.""" keycode = None if event.GetEventType() in (wx.EVT_CHAR_HOOK.typeId, wx.EVT_KEY_DOWN.typeId): keycode = event.GetKeyCode() elif event.GetEventType() == wx.EVT_MENU.typeId: keycode = self.progress_wnd.id_to_keycode.get(event.GetId()) if ( keycode is not None and getattr(self, "subprocess", None) and hasattr(self.subprocess, "send") ): keycode = keycodes.get(keycode, keycode) if keycode in (ord("\x1b"), ord("8"), ord("Q"), ord("q")): # exit self.abort_subprocess(True) return try: self.safe_send(chr(keycode)) except Exception: pass def calculate_gamut( self, profile_path, intent="r", direction="f", order="n", compare_standard_gamuts=True, ): """Calculate gamut, volume, and coverage % against sRGB and Adobe RGB. Return gamut volume (int, scaled to sRGB = 1.0) and coverage (dict) as tuple. """ if isinstance(profile_path, list): profile_paths = profile_path else: profile_paths = [profile_path] outname = os.path.splitext(profile_paths[0])[0] mods = [] if intent != "r": mods.append(intent) if direction != "f": mods.append(direction) if order != "n": mods.append(order) if mods: outname += " {}".format( "".join(["[{}]".format(mod.upper()) for mod in mods]) ) gamut_volume = None gamut_coverage = {} # Create profile gamut and vrml det = getcfg("iccgamut.surface_detail") for i, profile_path in enumerate(profile_paths): if not profile_path: self.log(f"Warning: calculate_gamut(): No profile path {i:d}") continue result = self.exec_cmd( get_argyll_util("iccgamut"), [ "-v", "-w", "-i" + intent, "-f" + direction, "-o" + order, f"-d{det:.2f}", profile_path, ], capture_output=True, skip_scripts=True, ) if not isinstance(result, Exception) and result: # iccgamut output looks like this: # Header: # <...> # # Total volume of gamut is xxxxxx.xxxxxx cubic colorspace units for line in self.output: match = re.search( r"(\d+(?:\.\d+)?)\s+cubic\s+colorspace\s+units", line ) if match: gamut_volume = float(match.groups()[0]) / GAMUT_VOLUME_SRGB break else: break name = os.path.splitext(profile_paths[0])[0] gamfilename = name + ".gam" wrlfilename = name + ".wrl" tmpfilenames = [gamfilename, wrlfilename] if compare_standard_gamuts: comparison_gamuts = [ ("srgb", "sRGB"), ("adobe-rgb", "ClayRGB1998"), ("dci-p3", "SMPTE431_P3"), ] else: comparison_gamuts = [] for profile_path in profile_paths[1:]: filename, ext = os.path.splitext(profile_path) comparison_gamuts.append( (filename.lower().replace(" ", "-"), filename + ".gam") ) threads = [] viewgam = get_argyll_util("viewgam") for key, src in comparison_gamuts: if not isinstance(result, Exception) and result: # Create gamut view and intersection if os.path.isabs(src): src_path = src src = os.path.splitext(os.path.basename(src))[0] else: if mods: src += " " + "".join([f"[{mod.upper()}]" for mod in mods]) src_path = get_data_path(f"ref/{src}.gam") if not src_path: continue outfilename = outname + " vs " + src if mods: outfilename += " " + "".join([f"[{mod.upper()}]" for mod in mods]) outfilename += ".wrl" tmpfilenames.append(outfilename) # Multi-threaded gamut view calculation worker = Worker() args = [ "-cw", "-t0", "-w", src_path, "-cn", "-t.3", "-s", gamfilename, "-i", outfilename, ] thread = threading.Thread( target=self.create_gamut_view_worker, name="CreateGamutViewWorker", args=(worker, viewgam, args, key, src, gamut_coverage), ) threads.append((thread, worker, args)) thread.start() # Wait for threads to finish for thread, worker, args in threads: thread.join() self.log("-" * 80) self.log(lang.getstr("commandline")) printcmdline(viewgam, args, fn=self.log, cwd=os.path.dirname(args[-1])) self.log("") self.log("".join(worker.output)) if not isinstance(result, Exception) and result: for tmpfilename in tmpfilenames: if tmpfilename == gamfilename and tmpfilename != f"{outname}.gam": # Use the original file name filename = f"{outname}.gam" elif tmpfilename == wrlfilename and tmpfilename != f"{outname}.wrl": # Use the original file name filename = f"{outname}.wrl" else: filename = tmpfilename try: def tweak_vrml(vrml): # Set viewpoint further away vrml = re.sub( rb"(Viewpoint\s*\{)[^}]+\}", rb"\1 position 0 0 340 }", vrml ) # Fix label color for -a* axis label = re.search( rb'Transform\s*\{\s*translation\s+[+\-0-9.]+\s*[+\-0-9.]+\s*[+\-0-9.]+\s+children\s*\[\s*Shape\s*\{\s*geometry\s+Text\s*\{\s*string\s*\["-a\*"\]\s*fontStyle\s+FontStyle\s*\{[^}]*\}\s*\}\s*appearance\s+Appearance\s*\{\s*material\s+Material\s*{[^}]*\}\s*\}\s*\}\s*\]\s*\}', vrml, ) if label: label = label.group() vrml = vrml.replace( label, re.sub( rb"(diffuseColor)\s+[+\-0-9.]+\s+[+\-0-9.]+\s+[+\-0-9.]+", rb"\1 0.0 1.0 0.0", label, ), ) # Add range to axes vrml = re.sub( rb'(string\s*\[")(\+?)(L\*)("\])', rb'\1\3", b"\2\0$\4', vrml, ) vrml = re.sub( rb'(string\s*\[")([+\-]?)(a\*)("\])', rb'\1\3", b"\2\0$\4', vrml, ) vrml = re.sub( rb'(string\s*\[")([+\-]?)(b\*)("\])', rb"\1\3 \2\0$\4", vrml ) vrml = vrml.replace(b"\0$", b"100") return vrml gzfilename = f"{filename}.gz" if sys.platform == "win32": filename = make_win32_compatible_long_path(filename) gzfilename = make_win32_compatible_long_path(gzfilename) tmpfilename = make_win32_compatible_long_path(tmpfilename) if getcfg("vrml.compress"): # Compress gam and wrl files using gzip with GzipFileProper(gzfilename, "wb") as gz: # Always use original filename with '.gz' extension, # that way the filename in the header will be correct with open(tmpfilename, "rb") as infile: gz.write(tweak_vrml(infile.read())) # Remove uncompressed file os.remove(tmpfilename) tmpfilename = gzfilename else: with open(tmpfilename, "rb") as infile: vrml = infile.read().decode() with open(tmpfilename, "wb") as outfile: outfile.write(tweak_vrml(vrml).encode()) if filename.endswith(".wrl"): filename = f"{filename[:-4]}.wrz" else: filename = gzfilename if tmpfilename != filename: # Rename the file if filename is different if os.path.exists(filename): os.remove(filename) os.rename(tmpfilename, filename) except Exception as exception: self.log(exception) elif result: # Exception self.log(result) return gamut_volume, gamut_coverage @staticmethod def create_gamut_view_worker(worker, viewgam, args, key, src, gamut_coverage): """Gamut view creation producer""" try: result = worker.exec_cmd( viewgam, args, capture_output=True, skip_scripts=True, silent=True, log_output=False, ) if not isinstance(result, Exception) and result: # viewgam output looks like this: # Intersecting volume = xxx.x cubic units # 'path/to/1.gam' volume = xxx.x cubic units, intersect = xx.xx% # 'path/to/2.gam' volume = xxx.x cubic units, intersect = xx.xx% for line in worker.output: match = re.search( r"[\/]{}.gam'\s+volume\s*=\s*" r"\d+(?:\.\d+)?\s+cubic\s+units,?" r"\s+intersect\s*=\s*" r"(\d+(?:\.\d+)?)".format(re.escape(src)), line, ) if match: gamut_coverage[key] = float(match.groups()[0]) / 100.0 break except Exception: traceback.print_exc() worker.log(traceback.format_exc()) def calibrate(self, remove=False): """Calibrate the screen and process the generated file(s).""" result = self.detect_video_levels() if isinstance(result, Exception) or not result: return result capture_output = False if sys.stdout and hasattr(sys.stdout, "isatty") and not sys.stdout.isatty(): capture_output = True cmd, args = self.prepare_dispcal() if not isinstance(cmd, Exception): print(f"cmd: {cmd}") print(f"args: {args}") result = self.exec_cmd(cmd, args, capture_output=capture_output) print(f"result: {result}") else: result = cmd if not isinstance(result, Exception) and result and getcfg("trc"): dst_pathname = os.path.join( getcfg("profile.save_path"), getcfg("profile.name.expanded"), getcfg("profile.name.expanded"), ) print(f"dst_pathname: {dst_pathname}") cal = args[-1] + ".cal" print(f"cal : {cal}") result = check_cal_isfile( cal, lang.getstr("error.calibration.file_not_created") ) print(f"result : {result}") if not isinstance(result, Exception) and result: cal_cgats = add_dispcal_options_to_cal(cal, self.options_dispcal) if cal_cgats: cal_cgats.write() if getcfg("profile.update") or self.dispcal_create_fast_matrix_shaper: profile_path = args[-1] + profile_ext result = check_profile_isfile( profile_path, lang.getstr("error.profile.file_not_created") ) if not isinstance(result, Exception) and result: try: profile = ICCProfile(profile_path) except (IOError, ICCProfileInvalidError): result = Error( lang.getstr("profile.invalid") + "\n" + profile_path ) if not isinstance(result, Exception) and result: if not getcfg("profile.update"): # Created fast matrix shaper profile # we need to set cprt, targ and a few other things profile.setCopyright(getcfg("copyright")) # Fast matrix shaper profiles currently don't # contain TI3 data, but look for it anyways # to be future-proof ti3 = add_options_to_ti3( profile.tags.get("targ", profile.tags.get("CIED", "")), self.options_dispcal, ) if not ti3: ti3 = CGATS("TI3\n") ti3[1] = cal_cgats edid = self.get_display_edid() display_name = edid.get( "monitor_name", edid.get("ascii", str(edid.get("product_id") or "")), ) display_manufacturer = edid.get("manufacturer") profile.setDeviceModelDescription(display_name) if display_manufacturer: profile.setDeviceManufacturerDescription( display_manufacturer ) (gamut_volume, gamut_coverage) = self.create_gamut_views( profile_path ) self.update_profile( profile, ti3=str(ti3), chrm=None, tags=True, avg=None, peak=None, rms=None, gamut_volume=gamut_volume, gamut_coverage=gamut_coverage, quality=getcfg("calibration.quality"), ) else: # Update desc tag - ASCII needs to be 7-bit # also add Unicode string if different from ASCII if "desc" in profile.tags and isinstance( profile.tags.desc, TextDescriptionType ): profile.setDescription(getcfg("profile.name.expanded")) # Calculate profile ID profile.calculateID() try: profile.write() except Exception as exception: self.log(exception) result2 = self.wrapup( not isinstance(result, UnloggedInfo) and result, remove or isinstance(result, Exception) or not result, ) if isinstance(result2, Exception): if isinstance(result, Exception): result = Error(str(result) + "\n\n" + str(result2)) else: result = result2 elif not isinstance(result, Exception) and result and getcfg("trc"): setcfg("last_cal_path", dst_pathname + ".cal") setcfg("calibration.file.previous", getcfg("calibration.file", False)) if getcfg("profile.update") or self.dispcal_create_fast_matrix_shaper: setcfg("last_cal_or_icc_path", dst_pathname + profile_ext) setcfg("last_icc_path", dst_pathname + profile_ext) setcfg("calibration.file", dst_pathname + profile_ext) else: setcfg("calibration.file", dst_pathname + ".cal") setcfg("last_cal_or_icc_path", dst_pathname + ".cal") return result @property def calibration_loading_generally_supported(self): # Loading/clearing calibration seems to have undesirable side-effects # on Mac OS X 10.6 and newer # Wayland does not support videoLUT access (only by installing a # profile via colord) return ( sys.platform != "darwin" or intlist(mac_ver()[0].split(".")) < [10, 6] ) and os.getenv("XDG_SESSION_TYPE") != "wayland" @property def calibration_loading_supported(self): # Loading/clearing calibration seems to have undesirable side-effects # on Mac OS X 10.6 and newer return ( self.calibration_loading_generally_supported and not config.is_virtual_display() ) def change_display_profile_cal_whitepoint( self, profile, x, y, outfilename, calibration_only=False, use_collink=False ): """Change display profile (and calibration) whitepoint. Do it in an colorimetrically accurate manner (as far as possible). """ XYZw = colormath.xyY2XYZ(x, y) xicclu = get_argyll_util("xicclu") if not xicclu: return Error(lang.getstr("argyll.util.not_found", "xicclu")) tempdir = self.create_tempdir() if isinstance(tempdir, Exception): return tempdir outpathname = os.path.splitext(outfilename)[0] outname = os.path.basename(outpathname) logfiles = Files([self.recent, self.lastmsg, LineBufferedStream(print)]) ofilename = profile.fileName temppathname = os.path.join(tempdir, outname) if ofilename and os.path.isfile(ofilename): # Profile comes from a file temp = False temporig = ofilename else: # Profile not associated to a file, write to temp dir temp = True profile.fileName = temporig = temppathname + ".orig.icc" profile.write(temporig) # Remember original white XYZ origXYZ = profile.tags.wtpt.X, profile.tags.wtpt.Y, profile.tags.wtpt.Z # Make a copy of the profile with changed whitepoint profile.tags.wtpt.X, profile.tags.wtpt.Y, profile.tags.wtpt.Z = XYZw tempcopy = temppathname + ".copy.icc" profile.write(tempcopy) # Generate updated calibration with changed whitepoint if use_collink: collink = get_argyll_util("collink") if not collink: profile.fileName = ofilename self.wrapup(False) return Error(lang.getstr("argyll.util.not_found", "collink")) linkpath = temppathname + ".link.icc" result = self.exec_cmd( collink, ["-v", "-n", "-G", "-iaw", "-b", tempcopy, temporig, linkpath], capture_output=True, ) if not result or isinstance(result, Exception): profile.fileName = ofilename self.wrapup(False) return result link = ICCProfile(linkpath) RGBscaled = [] for i in range(256): RGBscaled.append([i / 255.0] * 3) RGBscaled = self.xicclu(link, RGBscaled) logfiles.write("RGB white {:6.4f} {:6.4f} {:6.4f}\n".format(*RGBscaled[-1])) # Restore original white XYZ profile.tags.wtpt.X, profile.tags.wtpt.Y, profile.tags.wtpt.Z = origXYZ # Get white RGB XYZwscaled = self.xicclu(profile, RGBscaled[-1], "a", pcs="x")[0] logfiles.write( "XYZ white {:6.4f} {:6.4f} {:6.4f}, CCT {:0.0f}\n".format( *(XYZwscaled + [colormath.XYZ2CCT(*XYZwscaled)]) ) ) else: # Lookup scaled down white XYZ logfiles.write("Looking for solution...\n") XYZscaled = [] for i in range(2000): XYZscaled.append([v * (1 - i / 1999.0) for v in XYZw]) RGBscaled = self.xicclu( profile, XYZscaled, "a", "if", pcs="x", get_clip=True ) # Set filename to copy (used by worker.xicclu to get profile path) profile.fileName = tempcopy # Find point at which it no longer clips for i, RGBclip in enumerate(RGBscaled): if RGBclip[3] is True: # Clipped, skip continue # Found XYZwscaled = XYZscaled[i] logfiles.write( "Solution found at index {:d} (step size {:f})\n".format( i, 1 / 1999.0 ) ) logfiles.write( "RGB white {:6.4f} {:6.4f} {:6.4f}\n".format(*RGBclip[:3]) ) logfiles.write( "XYZ white {:6.4f} {:6.4f} {:6.4f}, CCT {:0.0f}\n".format( *(XYZscaled[i] + [colormath.XYZ2CCT(*XYZscaled[i])]) ) ) break else: profile.fileName = ofilename self.wrapup(False) return Error(f"No solution found in {i:d} steps") # Generate RGB input values # Reduce interpolation res as target whitepoint moves farther away # from profile whitepoint in RGB res = max(int(round((min(RGBclip[:3]) / 1.0) * 33)), 9) logfiles.write(f"Interpolation res {res:d}\n") RGBscaled = [] for i in range(res): RGBscaled.append([v * (i / (res - 1.0)) for v in (1, 1, 1)]) # Lookup RGB -> XYZ through whitepoint adjusted profile RGBscaled2XYZ = self.xicclu(profile, RGBscaled, "a", pcs="x") # Restore original XYZ profile.tags.wtpt.X, profile.tags.wtpt.Y, profile.tags.wtpt.Z = origXYZ # Restore original filename (used by worker.xicclu to get profile path) profile.fileName = temporig # Get original black point XYZk = self.xicclu(profile, [0, 0, 0], "a", pcs="x")[0] logfiles.write("XYZ black {:6.4f} {:6.4f} {:6.4f}\n".format(*XYZk)) logfiles.write( "XYZ white after forward lookup {:6.4f} {:6.4f} {:6.4f}\n".format( *RGBscaled2XYZ[-1] ) ) # Scale down XYZ XYZscaled = [] for i in range(res): XYZ = [v * XYZwscaled[1] for v in RGBscaled2XYZ[i]] if i == 0: bp_in = XYZ XYZ = colormath.apply_bpc( *XYZ, bp_in=bp_in, bp_out=XYZk, wp_out=XYZwscaled, weight=True ) XYZscaled.append(XYZ) logfiles.write( "XYZ white after scale down {:6.4f} {:6.4f} {:6.4f}\n".format( *XYZscaled[-1] ) ) # Lookup XYZ -> RGB through original profile RGBscaled = self.xicclu( profile, XYZscaled, "a", "if", pcs="x", use_cam_clipping=True ) logfiles.write( "RGB black after inverse forward lookup {:6.4f} {:6.4f} {:6.4f}\n".format( RGBscaled[0] ) ) logfiles.write( "RGB white after inverse forward lookup {:6.4f} {:6.4f} {:6.4f}\n".format( *RGBscaled[-1] ) ) if res != 256: # Interpolate R = [] G = [] B = [] for i, RGB in enumerate(RGBscaled): R.append(RGB[0]) G.append(RGB[1]) B.append(RGB[2]) if res > 2: # Catmull-Rom spline interpolation Ri = CRInterpolation(R) Gi = CRInterpolation(G) Bi = CRInterpolation(B) else: # Linear interpolation Ri = colormath.Interp(list(range(res)), R) Gi = colormath.Interp(list(range(res)), G) Bi = colormath.Interp(list(range(res)), B) RGBscaled = [] step = (res - 1) / 255.0 for i in range(256): RGB = [Ri(i * step), Gi(i * step), Bi(i * step)] RGBscaled.append(RGB) logfiles.write( "RGB black after interpolation {:6.4f} {:6.4f} {:6.4f}\n".format( *RGBscaled[0] ) ) logfiles.write( "RGB white after interpolation {:6.4f} {:6.4f} {:6.4f}\n".format( *RGBscaled[-1] ) ) has_nonlinear_vcgt = ( isinstance(profile.tags.get("vcgt"), VideoCardGammaType) and not profile.tags.vcgt.is_linear() ) if has_nonlinear_vcgt: # Apply cal ocal = extract_cal_from_profile(profile) bp_out = list(ocal.queryv1({"RGB_R": 0, "RGB_G": 0, "RGB_B": 0}).values()) ocalpath = temppathname + ".cal" ocal.filename = ocalpath RGBscaled = self.xicclu(ocal, RGBscaled) logfiles.write( "RGB black after cal {:6.4f} {:6.4f} {:6.4f}\n".format(*RGBscaled[0]) ) logfiles.write( "RGB white after cal {:6.4f} {:6.4f} {:6.4f}\n".format(*RGBscaled[-1]) ) else: bp_out = (0, 0, 0) cal = """CAL KEYWORD "DEVICE_CLASS" DEVICE_CLASS "DISPLAY" KEYWORD "COLOR_REP" COLOR_REP "RGB" BEGIN_DATA_FORMAT RGB_I RGB_R RGB_G RGB_B END_DATA_FORMAT NUMBER_OF_SETS 256 BEGIN_DATA """ for i, RGB in enumerate(RGBscaled): R, G, B = colormath.apply_bpc( *RGB, bp_in=RGBscaled[0], bp_out=bp_out, wp_out=RGBscaled[-1], weight=True, ) cal += "{:f} {:f} {:f} {:f}\n".format(i / 255.0, R, G, B) cal += "END_DATA" cal = CGATS(cal) cal.filename = outpathname + ".cal" cal.write() if calibration_only: # Only update calibration profile.setDescription(outname) profile.tags.vcgt = cal_to_fake_profile(cal).tags.vcgt profile.tags.wtpt.X, profile.tags.wtpt.Y, profile.tags.wtpt.Z = XYZw profile.calculateID() profile.write(outfilename) self.wrapup(False) return True else: # Re-create profile cti3 = None if isinstance(profile.tags.get("targ"), Text): # Get measurement data try: cti3 = CGATS(profile.tags.targ) except (IOError, CGATSError): pass else: if 0 not in cti3 or cti3[0].type.strip() != b"CTI3": # Not Argyll measurement data cti3 = None if not cti3: # Use fakeread fakeread = get_argyll_util("fakeread") if not fakeread: profile.fileName = ofilename self.wrapup(False) return Error(lang.getstr("argyll.util.not_found", "fakeread")) shutil.copyfile(defaults["testchart.file"], temppathname + ".ti1") result = self.exec_cmd(fakeread, [temporig, temppathname]) if not result or isinstance(result, Exception): profile.fileName = ofilename self.wrapup(False) return result cti3 = CGATS(temppathname + ".ti3") # Get RGB from measurement data RGBorig = [] for i, sample in cti3[0].DATA.items(): RGB = [] for j, component in enumerate("RGB"): RGB.append(sample["RGB_" + component]) RGBorig.append(RGB) # Lookup RGB -> scaled RGB through calibration RGBscaled = self.xicclu(cal, RGBorig, scale=100) if has_nonlinear_vcgt: # Undo original calibration RGBscaled = self.xicclu(ocal, RGBscaled, direction="b", scale=100) # Update CAL in ti3 file if 1 in cti3 and cti3[1].type.strip() == b"CAL": cti3[1].DATA = cal[0].DATA else: cti3[1] = cal[0] # Lookup scaled RGB -> XYZ through profile RGBscaled2XYZ = self.xicclu(profile, RGBscaled, "a", pcs="x", scale=100) # Update measurement data if "LUMINANCE_XYZ_CDM2" in cti3[0]: XYZa = [ float(v) * XYZwscaled[i] for i, v in enumerate(cti3[0].LUMINANCE_XYZ_CDM2.split()) ] cti3[0].add_keyword( "LUMINANCE_XYZ_CDM2", " ".join([str(v) for v in XYZa]) ) for i, sample in cti3[0].DATA.items(): for j, component in enumerate("XYZ"): sample["XYZ_" + component] = ( RGBscaled2XYZ[i][j] / XYZwscaled[1] * 100 ) cti3.write(temppathname + ".ti3") # Preserve custom tags display_name = profile.getDeviceModelDescription() display_manufacturer = profile.getDeviceManufacturerDescription() tags = {} for tagname in ("mmod", "meta"): if tagname in profile.tags: tags[tagname] = profile.tags[tagname] if temp: os.remove(temporig) os.remove(tempcopy) # Compute profile self.options_targen = ["-d3"] return self.create_profile( outfilename, True, display_name, display_manufacturer, tags ) def chart_lookup( self, cgats, profile, as_ti3=False, fields=None, check_missing_fields=False, function="f", pcs="l", intent="r", bt1886=None, white_patches=4, white_patches_total=True, raise_exceptions=False, ): """Lookup CIE or device values through profile""" if profile.colorSpace == b"RGB": labels = ("RGB_R", "RGB_G", "RGB_B") else: labels = ("CMYK_C", "CMYK_M", "CMYK_Y", "CMYK_K") ti1 = None ti3_ref = None gray = None try: if not isinstance(cgats, CGATS): cgats = CGATS(cgats, True) else: # Always make a copy and do not alter a passed in CGATS instance! cgats_filename = cgats.filename cgats = CGATS(bytes(cgats)) cgats.filename = cgats_filename if 0 in cgats: # only look at the first section cgats[0].filename = cgats.filename cgats = cgats[0] primaries = cgats.queryi(labels) if primaries and not as_ti3: primaries.fix_device_values_scaling(profile.colorSpace) cgats.type = b"CTI1" cgats.COLOR_REP = profile.colorSpace ti1, ti3_ref, gray = self.ti1_lookup_to_ti3( cgats, profile, function, pcs, "r", white_patches, white_patches_total, ) if bt1886 or intent == "a": cat = profile.guess_cat() or "Bradford" for item in ti3_ref.DATA.values(): if pcs == "l": X, Y, Z = colormath.Lab2XYZ( item["LAB_L"], item["LAB_A"], item["LAB_B"] ) else: X, Y, Z = ( v / 100.0 for v in (item["XYZ_X"], item["XYZ_Y"], item["XYZ_Z"]) ) if bt1886: X, Y, Z = bt1886.apply(X, Y, Z) if intent == "a": X, Y, Z = colormath.adapt( X, Y, Z, "D50", list(profile.tags.wtpt.values()), cat=cat, ) X, Y, Z = [v * 100 for v in (X, Y, Z)] if pcs == "l": ( item["LAB_L"], item["LAB_A"], item["LAB_B"], ) = colormath.XYZ2Lab(X, Y, Z) else: item["XYZ_X"], item["XYZ_Y"], item["XYZ_Z"] = X, Y, Z else: if not primaries and check_missing_fields: raise ValueError( lang.getstr( "error.testchart.missing_fields", (cgats.filename, ", ".join(labels)), ) ) ti1, ti3_ref = self.ti3_lookup_to_ti1( cgats, profile, fields, intent, white_patches ) except Exception as exception: traceback.print_exc() if raise_exceptions: raise exception if not isinstance(exception, (TypeError, ValueError)) or isinstance( exception, UnicodeError ): handle_error(exception, self.owner) else: show_result_dialog(exception, self.owner) return ti1, ti3_ref, gray def ti1_lookup_to_ti3( self, ti1, profile, function="f", pcs=None, intent="r", white_patches=4, white_patches_total=True, ): """Read TI1 (filename or CGATS instance), lookup device->pcs values colorimetrically through profile using Argyll's xicclu utility and return TI3 (CGATS instance) """ # ti1 if isinstance(ti1, str): ti1 = CGATS(ti1) if not isinstance(ti1, CGATS): raise TypeError( "Wrong type for ti1, needs to be a CGATS instance, " f"not {t11.__class__.__name__}" ) # profile if isinstance(profile, str): profile = ICCProfile(profile) if not isinstance(profile, ICCProfile): raise TypeError( "Wrong type for profile, needs to be a ICCProfile instance, " f"not {profile.__class__.__name__}" ) # determine pcs for lookup color_rep = profile.connectionColorSpace.upper() if color_rep == b"RGB": pcs = None elif not pcs: if color_rep == b"LAB": pcs = "l" elif color_rep == b"XYZ": pcs = "x" else: raise ValueError("Unknown CIE color representation " + color_rep) else: if pcs == "l": color_rep = b"LAB" elif pcs == "x": color_rep = b"XYZ" # get profile color space colorspace = profile.colorSpace # required fields for ti1 if colorspace == b"CMYK": required = ("CMYK_C", "CMYK_M", "CMYK_Y", "CMYK_K") else: required = ("RGB_R", "RGB_G", "RGB_B") ti1_filename = ti1.filename try: ti1 = verify_cgats(ti1, required, True) except CGATSInvalidError: raise ValueError(lang.getstr("error.testchart.invalid", ti1_filename)) except CGATSKeyError: raise ValueError( lang.getstr( "error.testchart.missing_fields", (ti1_filename, ", ".join(required)), ) ) # read device values from ti1 data = ti1.queryv1("DATA") if not data: raise ValueError(lang.getstr("error.testchart.invalid", ti1_filename)) device_data = data.queryv(required) if not device_data: raise ValueError( lang.getstr( "error.testchart.missing_fields", (ti1_filename, ", ".join(required)), ) ) if colorspace == b"RGB" and white_patches: # make sure the first four patches are white so the whitepoint can be # averaged white_rgb = {"RGB_R": 100, "RGB_G": 100, "RGB_B": 100} white = dict(white_rgb) wp = ti1.queryv1("APPROX_WHITE_POINT") if wp: wp = [float(v) for v in wp.split()] wp = [rpad((v / wp[1]) * 100.0, data.vmaxlen) for v in wp] else: wp = colormath.get_standard_illuminant("D65", scale=100) for label in list(data.parent.DATA_FORMAT.values()): label = label.decode("utf-8") if label not in white: if label.upper() == "LAB_L": value = 100 elif label.upper() in ("LAB_A", "LAB_B"): value = 0 elif label.upper() == "XYZ_X": value = wp[0] elif label.upper() == "XYZ_Y": value = 100 elif label.upper() == "XYZ_Z": value = wp[2] else: value = b"0" white.update({label: value}) white_added_count = 0 if profile.profileClass != b"link": if white_patches_total: # Ensure total of n white patches while len(data.queryi(white_rgb)) < white_patches: data.insert(0, white) white_added_count += 1 else: # Add exactly n white patches while white_added_count < white_patches: data.insert(0, white) white_added_count += 1 print("Added {:d} white patch(es)".format(white_added_count)) idata = [] for primaries in list(device_data.values()): idata.append(list(primaries.values())) if debug: print( "ti1_lookup_to_ti3 {} -> {} idata".format(profile.colorSpace, color_rep) ) for v in idata: print(" ".join(("{:3.4f}",) * len(v)).format(*v)) # lookup device->cie values through profile using (x)icclu if pcs or self.argyll_version >= [1, 6]: use_icclu = False else: # DeviceLink profile, we have to use icclu under older Argyll CMS # versions because older xicclu cannot handle devicelink use_icclu = True input_encoding = None output_encoding = None if not pcs: # Try to determine input/output encoding for devicelink if isinstance(profile.tags.get("meta"), DictType): input_encoding = profile.tags.meta.getvalue("encoding.input") output_encoding = profile.tags.meta.getvalue("encoding.output") if input_encoding == "T": # 'T' (clip wtw on input) not supported for xicclu input_encoding = "t" # Fall back to configured 3D LUT encoding if ( not input_encoding or input_encoding not in config.valid_values["3dlut.encoding.input"] ): input_encoding = getcfg("3dlut.encoding.input") if input_encoding == "T": # 'T' (clip wtw on input) not supported for xicclu input_encoding = "t" if ( not output_encoding or output_encoding not in config.valid_values["3dlut.encoding.output"] ): output_encoding = getcfg("3dlut.encoding.output") if self.argyll_version < [1, 6] and not ( input_encoding == output_encoding == "n" ): # Fail if encoding is not n (data levels) raise ValueError( "The used version of ArgyllCMS only" "supports full range RGB encoding." ) odata = self.xicclu( profile, idata, intent, function, pcs=pcs, scale=100, use_icclu=use_icclu, input_encoding=input_encoding, output_encoding=output_encoding, ) gray = [] igray = [] igray_idx = [] if colorspace == b"RGB": # treat r=g=b specially: set expected a=b=0 for i, cie in enumerate(odata): r, g, b = idata[i] if r == g == b < 100: # if grayscale and not white if pcs == "x": # Need to scale XYZ coming from xicclu # Lab is already scaled cie = colormath.XYZ2Lab(*[n * 100.0 for n in cie]) cie = (cie[0], 0, 0) # set a=b=0 igray.append("{} {} {}".format(*cie)) igray_idx.append(i) if pcs == "x": cie = colormath.Lab2XYZ(*cie) luminance = cie[1] else: luminance = colormath.Lab2XYZ(*cie)[1] if luminance * 100.0 >= 1: # only add if luminance is greater or equal 1% because # dark tones fluctuate too much gray.append((r, g, b)) if False: # NEVER? # set cie in odata to a=b=0 odata[i] = cie if igray and False: # NEVER? # lookup cie->device values for grays through profile using xicclu gray = [] ogray = self.xicclu(profile, igray, "r", "b", pcs="l", scale=100) for i, rgb in enumerate(ogray): cie = idata[i] if colormath.Lab2XYZ(cie[0], 0, 0)[1] * 100.0 >= 1: # only add if luminance is greater or equal 1% because # dark tones fluctuate too much gray.append(rgb) # update values in ti1 and data for ti3 for n, channel in enumerate(("R", "G", "B")): data[igray_idx[i] + white_added_count]["RGB_" + channel] = rgb[n] odata[igray_idx[i]] = cie # write output ti3 ofile = BytesIO() if pcs: ofile.write(b"CTI3 \n") ofile.write( b'\nDESCRIPTOR "Argyll Calibration Target chart information 3"\n' ) else: ofile.write(b"CTI1 \n") ofile.write( b'\nDESCRIPTOR "Argyll Calibration Target chart information 1"\n' ) ofile.write(b'KEYWORD "DEVICE_CLASS"\n') ofile.write( b'DEVICE_CLASS "' + (b"DISPLAY" if colorspace == b"RGB" else b"OUTPUT") + b'"\n' ) include_sample_name = False for i, cie in enumerate(odata): if i == 0: icolor = profile.colorSpace if icolor == b"RGB": olabel = b"RGB_R RGB_G RGB_B" elif icolor == b"CMYK": olabel = b"CMYK_C CMYK_M CMYK_Y CMYK_K" else: raise ValueError("Unknown color representation " + icolor) if color_rep == b"LAB": ilabel = b"LAB_L LAB_A LAB_B" elif color_rep in (b"XYZ", b"RGB"): ilabel = b"XYZ_X XYZ_Y XYZ_Z" else: raise ValueError("Unknown CIE color representation " + color_rep) ofile.write(b'KEYWORD "COLOR_REP"\n') if icolor == color_rep: ofile.write(b'COLOR_REP "' + icolor + b'"\n') else: ofile.write(b'COLOR_REP "' + icolor + b"_" + color_rep + b'"\n') ofile.write(b"\n") ofile.write(b"NUMBER_OF_FIELDS ") if include_sample_name: ofile.write( bytes(str(2 + len(icolor) + len(color_rep)), "utf-8") + b"\n" ) else: ofile.write( bytes(str(1 + len(icolor) + len(color_rep)), "utf-8") + b"\n" ) ofile.write(b"BEGIN_DATA_FORMAT\n") ofile.write(b"SAMPLE_ID ") if include_sample_name: ofile.write(b"SAMPLE_NAME " + olabel + b" " + ilabel + b"\n") else: ofile.write(olabel + b" " + ilabel + b"\n") ofile.write(b"END_DATA_FORMAT\n") ofile.write(b"\n") ofile.write( b"NUMBER_OF_SETS " + bytes(str(len(odata)), "utf-8") + b"\n" ) ofile.write(b"BEGIN_DATA\n") if pcs == "x": # Need to scale XYZ coming from xicclu, Lab is already scaled cie = [round(n * 100.0, 5 - len(str(int(abs(n * 100.0))))) for n in cie] elif not pcs: # Actually CIE = RGB because Devicelink idata[i] = cie cie = [ round(n * 100.0, 5 - len(str(int(abs(n * 100.0))))) for n in colormath.RGB2XYZ(*[n / 100.0 for n in cie]) ] device = [bytes(str(n), "utf-8") for n in idata[i]] cie = [bytes(str(n), "utf-8") for n in cie] if include_sample_name: ofile.write( bytes(str(i), "utf-8") + b" " + data[i - 1][1].strip(b'"') + b" " + b" ".join(device) + b" " + b" ".join(cie) + b"\n" ) else: ofile.write( bytes(str(i), "utf-8") + b" " + b" ".join(device) + b" " + b" ".join(cie) + b"\n" ) ofile.write(b"END_DATA\n") ofile.seek(0) ti3 = CGATS(ofile)[0] if colorspace == b"RGB" and white_patches and profile.profileClass == b"link": if white_patches_total: # Ensure total of n white patches while len(ti3.DATA.queryi(white_rgb)) < white_patches: ti3.DATA.insert(0, white) white_added_count += 1 else: # Add exactly n white patches while white_added_count < white_patches: ti3.DATA.insert(0, white) white_added_count += 1 print(f"Added {white_added_count:d} white patch(es)") if debug: print(f"ti3: {ti3}") return ti1, ti3, list(map(list, gray)) def ti3_lookup_to_ti1( self, ti3, profile, fields=None, intent="r", add_white_patches=4 ): """Read TI3 (filename or CGATS instance), lookup cie->device values colorimetrically through profile using Argyll's xicclu utility and return TI1 and compatible TI3 (CGATS instances) """ # ti3 copy = True if isinstance(ti3, (str, bytes)): copy = False ti3 = CGATS(ti3) if not isinstance(ti3, CGATS): raise TypeError( "Wrong type for ti3, needs to be CGATS instance, " f"not {ti3.__class__.__name__}" ) ti3_filename = ti3.filename if copy: # Make a copy and do not alter a passed in CGATS instance! ti3 = CGATS(bytes(ti3)) if fields == "XYZ": labels = ("XYZ_X", "XYZ_Y", "XYZ_Z") else: labels = ("LAB_L", "LAB_A", "LAB_B") try: ti3v = verify_cgats(ti3, labels, True) except CGATSInvalidError as exception: raise ValueError( lang.getstr("error.testchart.invalid", ti3_filename) + "\n" + lang.getstr(str(exception)) ) except CGATSKeyError: try: if fields: raise else: labels = ("XYZ_X", "XYZ_Y", "XYZ_Z") ti3v = verify_cgats(ti3, labels, True) except CGATSKeyError: missing = ", ".join(labels) if not fields: missing += " " + lang.getstr("or") + " LAB_L, LAB_A, LAB_B" raise ValueError( lang.getstr( "error.testchart.missing_fields", (ti3_filename, missing) ) ) else: color_rep = "XYZ" else: color_rep = fields or "LAB" # profile if isinstance(profile, str): profile = ICCProfile(profile) if not isinstance(profile, ICCProfile): raise TypeError( "Wrong type for profile, needs to be ICCProfile instance, " f"not {profile.__class__.__name__}" ) # determine pcs for lookup if color_rep == "LAB": pcs = "l" required = ("LAB_L", "LAB_A", "LAB_B") elif color_rep == "XYZ": pcs = "x" required = ("XYZ_X", "XYZ_Y", "XYZ_Z") else: raise ValueError("Unknown CIE color representation " + color_rep) # get profile color space colorspace = profile.colorSpace # read cie values from ti3 data = ti3v.queryv1("DATA") if not data: raise ValueError(lang.getstr("error.testchart.invalid", ti3_filename)) cie_data = data.queryv(required) if not cie_data: raise ValueError( lang.getstr( "error.testchart.missing_fields", (ti3_filename, ", ".join(required)), ) ) idata = [] if colorspace == "RGB" and add_white_patches: # make sure the first four patches are white so the whitepoint can be # averaged wp = [n * 100.0 for n in list(profile.tags.wtpt.values())] if color_rep == "LAB": wp = colormath.XYZ2Lab(*wp) wp = dict((("L", wp[0]), ("a", wp[1]), ("b", wp[2]))) else: wp = dict((("X", wp[0]), ("Y", wp[1]), ("Z", wp[2]))) wp = [wp] * int(add_white_patches) print(f"Added {add_white_patches:d} white patches") else: wp = [] for cie in wp + list(cie_data.values()): cie = list(cie.values()) if color_rep == "XYZ": # assume scale 0...100 in ti3, we need to convert to 0...1 cie = [n / 100.0 for n in cie] idata.append(cie) if debug: print(f"ti3_lookup_to_ti1 {color_rep} -> {profile.colorSpace} idata") for v in idata: print(" ".join(("{:3.4f}",) * len(v)).format(*v)) # lookup cie->device values through profile.icc using xicclu odata = self.xicclu(profile, idata, intent, "b", pcs=pcs, scale=100) # write output ti1/ti3 ti1out = BytesIO() ti1out.write(b"CTI1\n") ti1out.write(b"\n") ti1out.write(b'DESCRIPTOR "Argyll Calibration Target chart information 1"\n') include_sample_name = False for i, device in enumerate(odata): if i == 0: if color_rep == "LAB": ilabel = b"LAB_L LAB_A LAB_B" elif color_rep == "XYZ": ilabel = b"XYZ_X XYZ_Y XYZ_Z" else: raise ValueError(f"Unknown CIE color representation {color_rep}") ocolor = profile.colorSpace.upper() if ocolor == b"RGB": olabel = b"RGB_R RGB_G RGB_B" elif ocolor == b"CMYK": olabel = b"CMYK_C CMYK_M CMYK_Y CMYK_K" else: raise ValueError(f"Unknown color representation {ocolor}") olabels = olabel.split() # add device fields to DATA_FORMAT if not yet present if ( olabels[0] not in list(ti3v.DATA_FORMAT.values()) and olabels[1] not in list(ti3v.DATA_FORMAT.values()) and not olabels[2] in list(ti3v.DATA_FORMAT.values()) and ( ocolor == b"RGB" or ( ocolor == b"CMYK" and not olabels[3] in list(ti3v.DATA_FORMAT.values()) ) ) ): ti3v.DATA_FORMAT.add_data(olabels) # add required fields to DATA_FORMAT if not yet present if ( not bytes(required[0], "utf-8") in list(ti3v.DATA_FORMAT.values()) and not bytes(required[1], "utf-8") in list(ti3v.DATA_FORMAT.values()) and not bytes(required[2], "utf-8") in list(ti3v.DATA_FORMAT.values()) ): ti3v.DATA_FORMAT.add_data(required) ti1out.write(b'KEYWORD "COLOR_REP"\n') ti1out.write(b'COLOR_REP "%s"\n' % ocolor) ti1out.write(b"\n") ti1out.write(b"NUMBER_OF_FIELDS ") if include_sample_name: ti1out.write( bytes(str(2 + len(color_rep) + len(ocolor)), "utf-8") + b"\n" ) else: ti1out.write( bytes(str(1 + len(color_rep) + len(ocolor)), "utf-8") + b"\n" ) ti1out.write(b"BEGIN_DATA_FORMAT\n") ti1out.write(b"SAMPLE_ID ") if include_sample_name: ti1out.write(b"SAMPLE_NAME %s %s\n" % (olabel, ilabel)) else: ti1out.write(b"%s %s\n" % (olabel, ilabel)) ti1out.write(b"END_DATA_FORMAT\n") ti1out.write(b"\n") ti1out.write(b"NUMBER_OF_SETS %s\n" % bytes(str(len(odata)), "utf-8")) ti1out.write(b"BEGIN_DATA\n") if i < len(wp): if ocolor == b"RGB": device = [100.00, 100.00, 100.00] else: device = [0, 0, 0, 0] # Make sure device values do not exceed valid range of 0..100 device = [bytes(str(max(0, min(v, 100))), "utf-8") for v in device] cie = list((wp + list(cie_data.values()))[i].values()) cie = [bytes(str(n), "utf-8") for n in cie] if include_sample_name: cie_ = b"%s %s %s %s\n" % ( bytes(str(i + 1)), data[i][1].strip(b'"'), b" ".join(device), b" ".join(cie), ) ti1out.write(cie_) else: cie_ = b"%s %s %s\n" % ( bytes(str(i + 1), "utf-8"), b" ".join(device), b" ".join(cie), ) ti1out.write(cie_) if i > len(wp) - 1: # don't include whitepoint patches in ti3 # set device values in ti3 for n, v in enumerate(olabels): # Assuming 0..100, 4 decimal digits is # enough for roughly 19 bits integer # device values ti3v.DATA[i - len(wp)][v.decode("utf-8")] = round( float(device[n]), 4 ) # set PCS values in ti3 for n, v in enumerate(cie): ti3v.DATA[i - len(wp)][required[n]] = float(v) ti1out.write(b"END_DATA\n") ti1out.seek(0) ti1 = CGATS(ti1out) if debug: print(ti1) return ti1, ti3v def download(self, uri, force=False, download_dir=None): # Set timeout to a sane value default_timeout = socket.getdefaulttimeout() socket.setdefaulttimeout(20) # 20 seconds try: return self._download(uri, force=force, download_dir=download_dir) finally: socket.setdefaulttimeout(default_timeout) def _download(self, uri, force=False, download_dir=None): if test_badssl: uri = f"https://{test_badssl}.badssl.com/" orig_uri = uri total_size = None filename = os.path.basename(uri) if not download_dir: download_dir = os.path.join(config.datahome, "dl") download_path = os.path.join(download_dir, filename) response = None hashes = None is_main_dl = uri.startswith(f"https://{DOMAIN}/download/") if is_main_dl: # Always force connection to server even if local file exists for # displaycal.net/downloads/* and displaycal.net/Argyll/* # to force a hash check force = True if force or not os.path.isfile(download_path): cafile = None try: import ssl from ssl import CertificateError, SSLError except ImportError: CertificateError = ValueError SSLError = socket.error else: if hasattr(ssl, "get_default_verify_paths"): cafile = ssl.get_default_verify_paths().cafile if cafile: print("Using CA file", cafile) components = urllib.parse.urlparse(uri) # Don't use socket.getservbyname, as it apparently can fail with # socket.error under Windows 10 (although why remains a mystery, # we're only dealing with HTTP and HTTPS protocols...) scheme2port = {"http": 80, "https": 443} print( lang.getstr( "connecting.to", ( f"{components.scheme}://{components.hostname}", components.port or scheme2port.get(components.scheme, "?"), ), ) ) LoggingHTTPRedirectHandler.newurl = uri opener = urllib.request.build_opener(LoggingHTTPRedirectHandler) opener.addheaders = list(get_default_headers().items()) try: response = opener.open(uri) if always_fail_download or test_badssl: raise urllib.error.URLError("") newurl = getattr(LoggingHTTPRedirectHandler, "newurl", uri) if is_main_dl or not newurl.startswith(f"https://{DOMAIN}/"): # Get SHA-256 hashes so we can verify the downloaded file. # Only do this for 3rd party hosts/mirrors (no sense # doing it for files downloaded securely directly from # displaycal.net when that is also the source of our hashes # file, unless we are verifying an existing local app setup # or portable archive) noredir = urllib.request.build_opener(NoHTTPRedirectHandler) noredir.addheaders = list(get_default_headers().items()) hashes = noredir.open(f"https://{DOMAIN}/sha256sums.txt") except ( socket.error, urllib.error.URLError, http.client.HTTPException, CertificateError, SSLError, ) as exception: if response: response.close() if "CERTIFICATE_VERIFY_FAILED" in safe_str(exception): ekey = "ssl.certificate_verify_failed" if not cafile and isapp: ekey += ".root_ca_missing" print(lang.getstr(ekey)) elif "SSLV3_ALERT_HANDSHAKE_FAILURE" in safe_str(exception): print(lang.getstr("ssl.handshake_failure")) elif "SSL:" not in safe_str(exception): return exception else: print(exception) if getattr(LoggingHTTPRedirectHandler, "newurl", uri) != uri: uri = LoggingHTTPRedirectHandler.newurl return DownloadError( lang.getstr("download.fail") + " " + lang.getstr("connection.fail", uri), orig_uri, ) uri = response.geturl() filename = Path(Path(uri).name) actualhash = sha256() if hashes and False: # skip this for now # Read max. 64 KB hashes hashesdata = hashes.read(1024 * 64) hashes.close() hashesdict = {} for line in hashesdata.splitlines(): if not line.strip(): continue name_hash = [value.strip() for value in line.split(None, 1)] if len(name_hash) != 2 or "" in name_hash: response.close() return DownloadError( lang.getstr("file.hash.malformed", filename), orig_uri ) else: hashesdict[Path(name_hash[1].decode().lstrip("*"))] = name_hash[ 0 ] expectedhash_hex = hashesdict[filename] if not expectedhash_hex: response.close() return DownloadError( lang.getstr("file.hash.missing", filename), orig_uri ) total_size = response.info().get("Content-Length") if total_size is not None: try: total_size = int(total_size) except (TypeError, ValueError): return DownloadError( lang.getstr( "download.fail.wrong_size", ("<{}>".format(lang.getstr("unknown")),) * 2, ), orig_uri, ) else: if not total_size: total_size = None contentdispo = response.info().get("Content-Disposition") if contentdispo: filename = re.search(r'filename="([^"]+)"', contentdispo) if filename: filename = filename.groups()[0] if not filename: filename = make_filename_safe(uri.rstrip("/"), concat=False) content_type = response.info().get("Content-Type") if content_type: content_type = content_type.split(";", 1)[0] ext = mimetypes.guess_extension(content_type or "", False) filename += ext or ".html" download_path = os.path.join(download_dir, filename) if not os.path.isfile(download_path) or ( total_size is not None and os.stat(download_path).st_size != total_size ): if not os.path.isdir(download_dir): os.makedirs(download_dir) # Acquire files safely so no-one but us can mess with them fd = tmp_fd = tmp_download_path = None try: fd, download_path = mksfile(download_path) tmp_fd, tmp_download_path = mksfile(download_path + ".download") except EnvironmentError as mksfile_exception: response.close() for fd, pth in [(fd, download_path), (tmp_fd, tmp_download_path)]: if fd: os.close(fd) try: os.remove(download_path) except EnvironmentError as exception: print(exception) return mksfile_exception print(lang.getstr("downloading"), uri, "\u2192", download_path) self.recent.write(lang.getstr(f"downloading {filename}\n")) min_chunk_size = 1024 * 8 chunk_size = min_chunk_size bytes_so_far = 0 prev_bytes_so_far = 0 unit = "Bytes" unit_size = 1.0 if total_size > 1048576: unit = "MiB" unit_size = 1048576.0 elif total_size > 1024: unit = "KiB" unit_size = 1024.0 ts = time() bps = 0 prev_percent = -1 update_ts = time() fps = 20 frametime = 1.0 / fps download_file = None download_file_exception = None try: with os.fdopen(tmp_fd, "rb+") as tmp_download_file: while True: if self.thread_abort: print(lang.getstr("aborted")) return False chunk = response.read(chunk_size) if not chunk: break bytes_read = len(chunk) bytes_so_far += bytes_read tmp_download_file.write(chunk) # Determine data rate tdiff = time() - ts if tdiff >= 1: bps = (bytes_so_far - prev_bytes_so_far) / tdiff prev_bytes_so_far = bytes_so_far ts = time() elif not bps: if tdiff: bps = bytes_so_far / tdiff else: bps = bytes_read bps_unit = "Bytes" bps_unit_size = 1.0 if bps > 1048576: bps_unit = "MiB" bps_unit_size = 1048576.0 elif bps > 1024: bps_unit = "KiB" bps_unit_size = 1024.0 if total_size: percent = int( math.floor(float(bytes_so_far) / total_size * 100) ) if ( percent > prev_percent or time() >= update_ts + frametime ): self.lastmsg.write( "\r{:d}% ({:.1f} / {:.1f} {}, {:.2f} {}/s)".format( percent, bytes_so_far / unit_size, total_size / unit_size, unit, round(bps / bps_unit_size, 2), bps_unit, ) ) prev_percent = percent update_ts = time() elif time() >= update_ts + frametime: if bytes_so_far > 1048576 > unit_size: unit = "MiB" unit_size = 1048576.0 elif bytes_so_far > 1024 > unit_size: unit = "KiB" unit_size = 1024.0 self.lastmsg.write( "\r{:.1f} {} ({:.2f} {}/s)".format( bytes_so_far / unit_size, unit, round(bps / bps_unit_size, 2), bps_unit, ) ) update_ts = time() # Adjust chunk size based on DL rate if int(bps / fps) > chunk_size or min_chunk_size <= int( bps / fps ) < int(chunk_size * 0.75): if debug or test or verbose > 1: print( "Download buffer size changed from {:0.0f} KB to {:0.0f} KB".format( chunk_size / 1024.0, bps / fps / 1024 ) ) chunk_size = int(bps / fps) if not bytes_so_far: return DownloadError( lang.getstr("download.fail.empty_response", uri), orig_uri ) if total_size is not None and bytes_so_far != total_size: return DownloadError( lang.getstr( "download.fail.wrong_size", (total_size, bytes_so_far) ), orig_uri, ) if total_size is None or bytes_so_far == total_size: # Succesful download, write to destination tmp_download_file.seek(0) try: with os.fdopen(fd, "wb") as download_file: while True: chunk = tmp_download_file.read(1024 * 1024) if not chunk: break download_file.write(chunk) if hashes: actualhash.update(chunk) except EnvironmentError as download_file_exception: return download_file_exception print(lang.getstr("success")) finally: response.close() if not download_file_exception: # Remove temporary download file unless there was an error # writing destination try: os.remove(tmp_download_path) except EnvironmentError as exception: print(exception) if self.thread_abort or download_file_exception: # Remove destination file if download aborted or error # writing destination \ if not download_file: # Need to close file descriptor first os.close(fd) try: os.remove(download_path) except EnvironmentError as exception: print(exception) else: # File already exists if response: response.close() if hashes: # Verify hash. Get hash of existing file with open(download_path, "rb") as download_file: while True: chunk = download_file.read(1024 * 1024) if not chunk: break actualhash.update(chunk) if hashes and False: # skip this for now # Verify hash. Compare to expected hash actualhash_hex = actualhash.hexdigest() if actualhash_hex != expectedhash_hex.decode(): return Error( lang.getstr( "file.hash.verification.fail", ( download_path, f"SHA-256= {expectedhash_hex.decode()}", f"SHA-256= {actualhash_hex}", ), ) ) else: print(f"Verified hash SHA-256= {actualhash_hex}") return download_path def process_argyll_download(self, result, exit=False): if isinstance(result, Exception): show_result_dialog(result, self.owner) elif result: if result.lower().endswith(".zip") or result.lower().endswith(".tgz"): self.start( self.set_argyll_bin, self.extract_archive, cargs=(result,), wargs=(result,), progress_msg=lang.getstr("please_wait"), fancy=False, ) else: show_result_dialog( f"{lang.getstr('error.file_type_unsupported')}\n{result}", self.owner, ) def extract_archive(self, filename): extracted = [] if filename.lower().endswith(".zip"): cls = zipfile.ZipFile mode = "r" elif filename.lower().endswith(".tgz"): cls = TarFileProper.open # classmethod mode = "r:gz" else: return extracted with cls(filename, mode) as z: outdir = os.path.realpath(os.path.dirname(filename)) if cls is not zipfile.ZipFile: method = z.getnames else: method = z.namelist try: names = method() except EOFError as e: # probably didn't download properly, # delete the file and let the user download again print(f"Got EOFError, deleting the current downloaded file: {filename}") os.remove(filename) raise e names.sort() extracted = [os.path.join(outdir, os.path.normpath(name)) for name in names] if names: name0 = os.path.normpath(names[0]) for outpath in extracted: if not os.path.realpath(outpath).startswith( os.path.join(outdir, name0) ): return Error(lang.getstr("file.invalid") + "\n" + filename) if cls is not zipfile.ZipFile: z.extractall(outdir) else: for name in names: # If the ZIP file was created with Unicode names stored # in the file, 'name' will already be Unicode. # Otherwise, it'll either be 7-bit ASCII or (legacy) # cp437 encoding outname = name outpath = os.path.join(outdir, os.path.normpath(outname)) if outname.endswith("/"): if not os.path.isdir(outpath): os.makedirs(outpath) elif not os.path.isfile(outpath): with open(outpath, "wb") as outfile: outfile.write(z.read(name)) return extracted def set_argyll_bin(self, result, filename): """Set Argyll bin directory.""" if isinstance(result, Exception): show_result_dialog(result, self.owner) elif result and os.path.isdir(result[0]): setcfg("argyll.dir", os.path.join(result[0], "bin")) # Always write cfg directly after setting Argyll directory so # subprocesses that read the configuration will use the right # executables writecfg() from DisplayCAL.display_cal import check_donation snapshot = VERSION > VERSION_BASE self.owner.set_argyll_bin_handler( None, True, self.owner.check_instrument_setup, (check_donation, (self.owner, snapshot)), ) else: show_result_dialog( lang.getstr("error.no_files_extracted_from_archive", filename), self.owner, ) def process_download(self, result, exit=False): if isinstance(result, Exception): show_result_dialog(result, self.owner) elif result: if exit: if self.owner: self.owner.Close() else: wx.GetApp().ExitMainLoop() launch_file(result) def verify_calibration(self): """Verify the current calibration""" result = self.detect_video_levels() if isinstance(result, Exception) or not result: return result cmd, args = self.prepare_dispcal(calibrate=False, verify=True) if not isinstance(cmd, Exception): result = self.exec_cmd(cmd, args, capture_output=True, skip_scripts=True) else: result = cmd return result def measure_ti1( self, ti1_path, cal_path=None, colormanaged=False, allow_video_levels=True ): """Measure a TI1 testchart file""" if allow_video_levels: result = self.detect_video_levels() if isinstance(result, Exception) or not result: return result if config.get_display_name() == "Untethered": cmd, args = get_argyll_util("spotread"), ["-v", "-e"] if getcfg("extra_args.spotread").strip(): args += parse_argument_string(getcfg("extra_args.spotread")) result = self.set_terminal_cgats(ti1_path) if isinstance(result, Exception): return result else: cmd = get_argyll_util("dispread") args = ["-v"] if getcfg("argyll.debug"): args.append("-D8") if config.get_display_name() in ("madVR", "Prisma") and colormanaged: args.append("-V") if cal_path: if self.argyll_version >= [1, 3, 3] and ( not self.has_lut_access() or not getcfg("calibration.use_video_lut") ): args.append("-K") else: args.append("-k") args.append(cal_path) if getcfg("extra_args.dispread").strip(): args += parse_argument_string(getcfg("extra_args.dispread")) result = self.add_measurement_features( quote_args(args) if sys.platform == "win32" else args, cmd == get_argyll_util("dispread"), allow_nondefault_observer=is_ccxx_testchart(), allow_video_levels=allow_video_levels, quantize=True, ) if isinstance(result, Exception): return result self.options_dispread = list(args) if config.get_display_name() != "Untethered": args.append(os.path.splitext(ti1_path)[0]) return self.exec_cmd(cmd, args, skip_scripts=True) def wrapup(self, copy=True, remove=True, dst_path=None, ext_filter=None): """Wrap up - copy and/or clean temporary file(s).""" if debug: print(f"[D] wrapup(copy={copy}, remove={remove})") if not self.tempdir or not os.path.isdir(self.tempdir): return # nothing to do if ( isinstance(copy, Exception) and not isinstance(copy, (UnloggedError, UnloggedInfo, UnloggedWarning)) and self.sessionlogfile ): # This is an incomplete run, log exception to session logfile self.sessionlogfile.write(safe_basestring(copy)) while self.sessionlogfiles: self.sessionlogfiles.popitem()[1].close() self.sessionlogfile = None if isinstance(copy, Exception): # This is an incomplete run, check if any files have been added or # modified (except log files and 'hidden' temporary files) changes = False for filename in os.listdir(self.tempdir): if filename.endswith(".log") or filename in ( ".abort", ".ok", ".wait", ".wait.cmd", ".wait.py", ): # Skip log files and 'hidden' temporary files continue if ( filename not in self.tmpfiles or os.stat(os.path.join(self.tempdir, filename)).st_mtime != self.tmpfiles[filename] ): changes = True break if not changes: copy = False result = True if copy: try: src_listdir = os.listdir(self.tempdir) except Exception as exception: result = exception remove = False if not isinstance(result, Exception) and src_listdir: if not ext_filter: ext_filter = [ ".app", ".cal", ".ccmx", ".ccss", ".cmd", ".command", ".gam", ".gz", ".icc", ".icm", ".log", ".png", ".sh", ".ti1", ".ti3", ".wrl", ".wrz", ] save_path = getcfg("profile.save_path") if dst_path is None: dst_path = os.path.join( save_path, getcfg("profile.name.expanded"), getcfg("profile.name.expanded") + ".ext", ) if isinstance(copy, Exception): # This is an incomplete run parts = os.path.normpath(dst_path).split(os.sep) # DON'T use os.path.join due to how it works under Windows: # os.path.join("c:", "foo") represents a path relative to # the current directory on drive C: (c:foo), not c:\foo. # Save incomplete runs to different directory parts = [config.datahome, "incomplete"] + parts[-2:] dst_path = os.sep.join(parts) result = check_create_dir(os.path.dirname(dst_path)) if isinstance(result, Exception): remove = False else: if isinstance(copy, Exception): print( "Moving files of incomplete run to", os.path.dirname(dst_path), ) for basename in src_listdir: name, ext = os.path.splitext(basename) if ext_filter is None or ext.lower() in ext_filter: src = os.path.join(self.tempdir, basename) dst = os.path.join(os.path.dirname(dst_path), basename) if sys.platform == "win32": dst = make_win32_compatible_long_path(dst) if os.path.exists(dst): if os.path.isdir(dst): if verbose >= 2: print( f"{appname}: Removing existing destination " "directory tree", dst, ) try: shutil.rmtree(dst, True) except Exception as exception: print( f"Warning - directory '{dst}' could not be removed: {exception}" ) else: if verbose >= 2: print( f"{appname}: Removing existing destination " "file", dst, ) try: os.remove(dst) except Exception as exception: print( f"Warning - file '{dst}' could not be removed: {exception}" ) if remove: if verbose >= 2: print( f"{appname}: Moving temporary object " f"{src} to {dst}" ) try: shutil.move(src, dst) except Exception as exception: print( f"Warning - temporary object '{src}' could not " f"be moved to '{dst}': {exception}" ) try: shutil.copyfile(src, dst) except Exception as exception: result2 = Error( lang.getstr("error.copy_failed", (src, dst)) + "\n" + str(exception) ) if isinstance(result, Exception): result = "\n".join( str(error) for error in (result, result2) ) else: result = result2 remove = False else: if os.path.isdir(src): if verbose >= 2: print( f"{appname}: Copying temporary " f"directory tree {src} to {dst}" ) try: shutil.copytree(src, dst) except Exception as exception: print( f"Warning - temporary directory '{src}' " "could not be copied to " f"'{dst}': {exception}" ) else: if verbose >= 2: print( f"{appname}: Copying temporary " f"file {src} to {dst}" ) try: shutil.copyfile(src, dst) except Exception as exception: print( f"Warning - temporary file '{src}' could " f"not be copied to '{dst}': {exception}" ) if remove: try: src_listdir = os.listdir(self.tempdir) except Exception as exception: print(f"Error - directory '{self.tempdir}' listing failed: {exception}") else: for basename in src_listdir: name, ext = os.path.splitext(basename) if ext_filter is None or ext.lower() not in ext_filter: src = os.path.join(self.tempdir, basename) isdir = os.path.isdir(src) if isdir: if verbose >= 2: print( f"{appname}: Removing temporary directory tree", src, ) try: shutil.rmtree(src, True) except Exception as exception: print( f"Warning - temporary directory '{src}' could not " f"be removed: {exception}" ) else: if verbose >= 2: print(f"{appname}: Removing temporary file", src) try: os.remove(src) except Exception as exception: print( f"Warning - temporary file '{src}' could not be " f"removed: {exception}" ) try: src_listdir = os.listdir(self.tempdir) except Exception as exception: print(f"Error - directory '{self.tempdir}' listing failed: {exception}") else: if not src_listdir: if verbose >= 2: print( f"{appname}: Removing empty temporary directory", self.tempdir, ) try: shutil.rmtree(self.tempdir, True) except Exception as exception: print( f"Warning - temporary directory '{self.tempdir}' could " f"not be removed: {exception}" ) if isinstance(result, Exception): result = Error( "{}\n\n{}".format( result, lang.getstr("tempdir_should_still_contain_files", self.tempdir), ) ) return result def write(self, txt): if True: # Don't buffer self._write(txt) return # NEVER - Use line buffer self.buffer.append(txt) self.buffer = [line for line in StringIO("".join(self.buffer))] for line in self.buffer: if not ( line.endswith("\n") or line.rstrip().endswith(":") or line.rstrip().endswith(",") or line.rstrip().endswith(".") ): break self._write(line) self.buffer = self.buffer[1:] def _write(self, txt): if isinstance(txt, bytes): txt = txt.decode() wx.CallAfter(self.audio_visual_feedback, txt) if getattr(self, "measure_cmd", None): # i1 Pro, Spyders: Instrument Type # i1D3: Product Name # K10: Model # specbos: Identification instrument = re.search( r"(?:Instrument Type|Product Name|Model|Identificaton):\s+([^\r\n]+)", txt, re.I, ) if instrument: self._detected_instrument = instrument.group(1) serial = re.search(r"(?:Serial Number):\s+([^\r\n]+)", txt, re.I) if serial: self._detected_instrument_serial = serial.group(1) if re.search(r"press 1|space when done|patch 1 of ", txt, re.I): # There are some intial measurements which we can't check for # unless -D (debug) is used for Argyll tools if "patch 1 of " not in txt.lower() or not self.patch_sequence: if "patch 1 of " in txt.lower(): self.patch_sequence = True self.patch_count = 0 self.patterngenerator_sent_count = 0 update = re.search( r"[/\\] current|patch \d+ of |the instrument can be removed from the screen", txt, re.I, ) # Send colors to pattern generator use_patterngenerator = ( self.use_patterngenerator and self.patterngenerator and hasattr(self.patterngenerator, "conn") ) if use_patterngenerator or self.use_madnet_tpg or self._use_patternwindow: # sometimes the data is not fully received if self.partial_data != "": # combine the partial data with the currently received one self.log(f"Combining previous data of: {self.partial_data}") self.log(f"with : {txt}") txt = self.partial_data + txt self.log(f"to : {txt}") rgb = re.search(r"Current RGB(?:\s+\d+){3}((?:\s+\d+(?:\.\d+)){3})", txt) # Check if the data is partial if "Current RGB" in txt and rgb is None: self.log(f"Data is not fully received, storing partial data: {txt}") self.partial_data = txt if rgb: # reset the partial data storage, as we fully received the data self.partial_data = "" update_ffp_insertion_ts = False if ( getcfg("patterngenerator.ffp_insertion") and self.patterngenerator_sent_count > 1 ): # Frame insertion frq = getcfg("patterngenerator.ffp_insertion.interval") if time() - getattr(self, "_ffp_insertion_ts", 0) > frq: dur = getcfg("patterngenerator.ffp_insertion.duration") lvl = getcfg("patterngenerator.ffp_insertion.level") self.log( f"{appname}: Frame insertion duration {dur:d}s, " f"level = {lvl * 100:d}%" ) ts = time() patternconfig = [] if self.use_madnet_tpg: patternconfig = self.madtpg.get_pattern_config() self.madtpg.set_pattern_config( patternconfig[0], int(lvl * 100), 0, 0 ) self.madtpg.show_rgb(lvl, lvl, lvl) self.madtpg.set_pattern_config(100, 0, 0, 0) else: self.patterngenerator_send((lvl, lvl, lvl), (lvl, lvl, lvl)) while time() - ts < dur and not ( self.subprocess_abort or self.thread_abort ): sleep(0.05) if self.use_madnet_tpg: self.madtpg.set_pattern_config(*patternconfig) update_ffp_insertion_ts = True if ( not hasattr(self, "_ffp_insertion_ts") or update_ffp_insertion_ts ): self._ffp_insertion_ts = time() rgb = [float(v) for v in rgb.groups()[0].strip().split()] if self.use_madnet_tpg: if self.madtpg.show_rgb(*rgb): self.patterngenerator_sent_count += 1 self.log( f"{appname}: MadTPG_Net sent count: " f"{self.patterngenerator_sent_count}" ) else: self.exec_cmd_returnvalue = Error( lang.getstr("patterngenerator.sync_lost") ) self.abort_subprocess() else: self.patterngenerator_send(rgb) if getcfg("patterngenerator.ffp_insertion") and update_ffp_insertion_ts: # Delay to allow patch update and settle time after # frame insertion. If display update delay is bigger, # do not use extra delay. Otherwise, subtract display # update delay from fixed delay. if getcfg("measure.override_min_display_update_delay_ms"): dur = getcfg("measure.min_display_update_delay_ms") / 1000.0 else: dur = 0 ts = time() while time() - ts < max(0.8 - dur, 0) and not ( self.subprocess_abort or self.thread_abort ): sleep(0.05) # Create .ok file which will be picked up by .wait script okfilename = os.path.join(self.tempdir, ".ok") open(okfilename, "w").close() if update: # Check if patch count is higher than patterngenerator sent count if ( self.patch_count > self.patterngenerator_sent_count and self.exec_cmd_returnvalue is None ): # XXX: This can happen when pausing/unpausing? # Need to investigate self.log("Warning - did we loose sync with the pattern generator?") # self.exec_cmd_returnvalue = Error(lang.getstr("patterngenerator.sync_lost")) # self.abort_subprocess() if update and not ( self.subprocess_abort or self.thread_abort or "the instrument can be removed from the screen" in txt.lower() ): self.patch_count += 1 if use_patterngenerator or self.use_madnet_tpg: self.log(f"{appname}: Patch update count: {self.patch_count:d}") if self.use_madnet_tpg: progress = re.search( r"(?:Patch (\d+) of|Number of patches =) (\d+)", txt, re.I ) if progress: # Set madTPG progress bar try: start = int(progress.group(1) or 0) end = int(progress.group(2)) except ValueError: pass else: self.madtpg.set_progress_bar_pos(start, end) # Parse wx.CallAfter(self.parse, txt) @property def _use_patternwindow(self): # Preliminary Wayland support. This still needs a lot # of work as Argyll doesn't support Wayland natively yet, # so we use virtual display to drive our own patch window. return ( not config.is_virtual_display() and ( # os.getenv("XDG_SESSION_TYPE") == "wayland" getcfg("patterngenerator.use_pattern_window") ) and self.argyll_virtual_display )