# -*- coding: utf-8 -*- import math import os from time import gmtime, strftime from DisplayCAL import ( config, localization as lang, worker, xh_bitmapctrls, xh_fancytext, xh_filebrowsebutton, xh_hstretchstatbmp, ) from DisplayCAL.cgats import ( CGATS, CGATSInvalidError, CGATSInvalidOperationError, CGATSKeyError, CGATSTypeError, CGATSValueError, ) from DisplayCAL.config import ( get_data_path, getcfg, geticon, hascfg, initcfg, setcfg, ) from DisplayCAL.icc_profile import ( CurveType, ICCProfile, ICCProfileInvalidError, LUT16Type, XYZType, ) from DisplayCAL.meta import name as appname from DisplayCAL.util_list import natsort_key_factory from DisplayCAL.util_str import strtr from DisplayCAL.worker import Error, get_current_profile_path, show_result_dialog from DisplayCAL.wxTestchartEditor import TestchartEditor from DisplayCAL.wxfixes import TempXmlResource from DisplayCAL.wxwindows import BaseApp, BaseFrame, FileDrop, InfoDialog, wx from wx import xrc class ReportFrame(BaseFrame): """Measurement report creation window.""" def __init__(self, parent=None): BaseFrame.__init__(self, parent, -1, lang.getstr("measurement_report")) self.Bind(wx.EVT_CLOSE, self.OnClose) self.SetIcons(config.get_icon_bundle([256, 48, 32, 16], appname)) self.XYZbpin = None self.XYZbpout = None res = TempXmlResource(get_data_path(os.path.join("xrc", "report.xrc"))) res.InsertHandler(xh_fancytext.StaticFancyTextCtrlXmlHandler()) res.InsertHandler(xh_filebrowsebutton.FileBrowseButtonWithHistoryXmlHandler()) res.InsertHandler(xh_hstretchstatbmp.HStretchStaticBitmapXmlHandler()) res.InsertHandler(xh_bitmapctrls.BitmapButton()) res.InsertHandler(xh_bitmapctrls.StaticBitmap()) self.panel = res.LoadPanel(self, "panel") self.Sizer = wx.BoxSizer(wx.VERTICAL) self.Sizer.Add(self.panel, 1, flag=wx.EXPAND) self.set_child_ctrls_as_attrs(self) self.measurement_report_btn = wx.Button(self.panel, -1, lang.getstr("measure")) self.panel.Sizer.Insert( 2, self.measurement_report_btn, flag=wx.RIGHT | wx.BOTTOM | wx.ALIGN_RIGHT, border=16, ) self.worker = worker.Worker(self) self.worker.set_argyll_version("xicclu") BaseFrame.setup_language(self) self.mr_setup_language() self.mr_init_controls() self.mr_update_controls() self.mr_init_frame() def mr_init_controls(self): for which in ( "chart", "simulation_profile", "devlink_profile", "output_profile", ): ctrl = xrc.XRCCTRL(self, f"{which}_ctrl" ) setattr(self, f"{which}_ctrl", ctrl) ctrl.changeCallback = getattr(self, f"{which}_ctrl_handler") if which not in ("devlink_profile", "output_profile"): if which == "chart": wildcard = r"\.(cie|ti1|ti3)$" else: wildcard = r"\.(icc|icm)$" history = [] if which == "simulation_profile": standard_profiles = config.get_standard_profiles(True) basenames = [] for path in standard_profiles: basename = os.path.basename(path) if basename not in basenames: basenames.append(basename) history.append(path) else: paths = get_data_path("ref", wildcard) or [] for path in paths: basepath, ext = os.path.splitext(path) if os.getenv("XDG_SESSION_TYPE") == "wayland": # When the number of items in a dropdown popup menu # exceeds the available display client area height, # the popup menu gets shown at weird positions or # not at all under Wayland. Work-around this wx bug # by truncating the choices. Yuck. Also see: # FileBrowseBitmapButtonWithChoiceHistory.SetHistory if ( ext.lower() != ".ti1" or os.path.basename(path) == "ccxx.ti1" ): continue if not ( path.lower().endswith(".ti2") and f"{basepath}.cie" in paths ): history.append(path) natsort_key = natsort_key_factory() history = sorted( history, key=lambda path: natsort_key(os.path.basename(path)) ) ctrl.SetHistory(history) ctrl.SetMaxFontSize(11) # Drop targets handler = getattr(self, f"{which}_drop_handler") if which.endswith("_profile"): drophandlers = {".icc": handler, ".icm": handler} else: drophandlers = { ".cgats": handler, ".cie": handler, ".ti1": handler, ".ti2": handler, ".ti3": handler, ".txt": handler, } ctrl.SetDropTarget(FileDrop(self, drophandlers)) # Bind event handlers self.fields_ctrl.Bind(wx.EVT_CHOICE, self.fields_ctrl_handler) self.chart_btn.Bind(wx.EVT_BUTTON, self.chart_btn_handler) self.simulation_profile_cb.Bind( wx.EVT_CHECKBOX, self.use_simulation_profile_ctrl_handler ) self.use_simulation_profile_as_output_cb.Bind( wx.EVT_CHECKBOX, self.use_simulation_profile_as_output_handler ) self.enable_3dlut_cb.Bind(wx.EVT_CHECKBOX, self.enable_3dlut_handler) self.apply_none_ctrl.Bind(wx.EVT_RADIOBUTTON, self.apply_trc_ctrl_handler) self.apply_black_offset_ctrl.Bind( wx.EVT_RADIOBUTTON, self.apply_trc_ctrl_handler ) self.apply_trc_ctrl.Bind(wx.EVT_RADIOBUTTON, self.apply_trc_ctrl_handler) self.mr_trc_ctrl.Bind(wx.EVT_CHOICE, self.mr_trc_ctrl_handler) self.mr_trc_gamma_ctrl.Bind(wx.EVT_COMBOBOX, self.mr_trc_gamma_ctrl_handler) self.mr_trc_gamma_ctrl.Bind(wx.EVT_KILL_FOCUS, self.mr_trc_gamma_ctrl_handler) self.mr_trc_gamma_type_ctrl.Bind( wx.EVT_CHOICE, self.mr_trc_gamma_type_ctrl_handler ) self.mr_black_output_offset_ctrl.Bind( wx.EVT_SLIDER, self.mr_black_output_offset_ctrl_handler ) self.mr_black_output_offset_intctrl.Bind( wx.EVT_TEXT, self.mr_black_output_offset_ctrl_handler ) self.simulate_whitepoint_cb.Bind( wx.EVT_CHECKBOX, self.simulate_whitepoint_ctrl_handler ) self.simulate_whitepoint_relative_cb.Bind( wx.EVT_CHECKBOX, self.simulate_whitepoint_relative_ctrl_handler ) self.devlink_profile_cb.Bind( wx.EVT_CHECKBOX, self.use_devlink_profile_ctrl_handler ) self.output_profile_current_btn.Bind( wx.EVT_BUTTON, self.output_profile_current_ctrl_handler ) def mr_init_frame(self): self.measurement_report_btn.SetDefault() self.update_layout() config.defaults.update( { "position.reportframe.x": self.GetDisplay().ClientArea[0] + 40, "position.reportframe.y": self.GetDisplay().ClientArea[1] + 60, "size.reportframe.w": self.ClientSize[0], "size.reportframe.h": self.ClientSize[1], } ) if ( hascfg("position.reportframe.x") and hascfg("position.reportframe.y") and hascfg("size.reportframe.w") and hascfg("size.reportframe.h") ): self.SetSaneGeometry( int(getcfg("position.reportframe.x")), int(getcfg("position.reportframe.y")), int(getcfg("size.reportframe.w")), int(getcfg("size.reportframe.h")), ) else: self.Center() def OnClose(self, event=None): if self.IsShownOnScreen() and not self.IsMaximized() and not self.IsIconized(): x, y = self.GetScreenPosition() setcfg("position.reportframe.x", x) setcfg("position.reportframe.y", y) setcfg("size.reportframe.w", self.ClientSize[0]) setcfg("size.reportframe.h", self.ClientSize[1]) config.writecfg() if event: event.Skip() def apply_trc_ctrl_handler(self, event): v = self.apply_trc_ctrl.GetValue() setcfg("measurement_report.apply_trc", int(v)) setcfg( "measurement_report.apply_black_offset", int(self.apply_black_offset_ctrl.GetValue()), ) self.mr_update_main_controls() def mr_black_output_offset_ctrl_handler(self, event): if event.GetId() == self.mr_black_output_offset_intctrl.GetId(): self.mr_black_output_offset_ctrl.SetValue( self.mr_black_output_offset_intctrl.GetValue() ) else: self.mr_black_output_offset_intctrl.SetValue( self.mr_black_output_offset_ctrl.GetValue() ) v = self.mr_black_output_offset_ctrl.GetValue() / 100.0 if v != getcfg("measurement_report.trc_output_offset"): setcfg("measurement_report.trc_output_offset", v) self.mr_update_trc_control() # self.mr_show_trc_controls() def mr_trc_gamma_ctrl_handler(self, event): try: v = float(self.mr_trc_gamma_ctrl.GetValue().replace(",", ".")) if ( v < config.valid_ranges["measurement_report.trc_gamma"][0] or v > config.valid_ranges["measurement_report.trc_gamma"][1] ): raise ValueError() except ValueError: wx.Bell() self.mr_trc_gamma_ctrl.SetValue(str(getcfg("measurement_report.trc_gamma"))) else: if str(v) != self.mr_trc_gamma_ctrl.GetValue(): self.mr_trc_gamma_ctrl.SetValue(str(v)) if v != getcfg("measurement_report.trc_gamma"): setcfg("measurement_report.trc_gamma", v) self.mr_update_trc_control() self.mr_show_trc_controls() event.Skip() def mr_trc_ctrl_handler(self, event): self.Freeze() if self.mr_trc_ctrl.GetSelection() == 1: # BT.1886 setcfg("measurement_report.trc_gamma", 2.4) setcfg("measurement_report.trc_gamma_type", "B") setcfg("measurement_report.trc_output_offset", 0.0) self.mr_update_trc_controls() elif self.mr_trc_ctrl.GetSelection() == 0: # Pure power gamma 2.2 setcfg("measurement_report.trc_gamma", 2.2) setcfg("measurement_report.trc_gamma_type", "b") setcfg("measurement_report.trc_output_offset", 1.0) self.mr_update_trc_controls() else: # Custom # Have to use CallAfter, otherwise only part of the text will # be selected (wxPython bug?) wx.CallAfter(self.mr_trc_gamma_ctrl.SetFocus) wx.CallLater(1, self.mr_trc_gamma_ctrl.SelectAll) self.mr_show_trc_controls() self.Thaw() def mr_trc_gamma_type_ctrl_handler(self, event): v = self.trc_gamma_types_ab[self.mr_trc_gamma_type_ctrl.GetSelection()] if v != getcfg("measurement_report.trc_gamma_type"): setcfg("measurement_report.trc_gamma_type", v) self.mr_update_trc_control() self.mr_show_trc_controls() def chart_btn_handler(self, event): if self.Parent: parent = self.Parent else: parent = self chart = getcfg("measurement_report.chart") if not hasattr(parent, "tcframe"): parent.tcframe = TestchartEditor( parent, path=chart, cfg="measurement_report.chart", parent_set_chart_methodname="mr_set_testchart", ) elif not hasattr(parent.tcframe, "ti1") or chart != parent.tcframe.ti1.filename: parent.tcframe.tc_load_cfg_from_ti1( None, chart, "measurement_report.chart", "mr_set_testchart" ) setcfg("tc.show", 1) parent.tcframe.Show() parent.tcframe.Raise() def chart_ctrl_handler(self, event): chart = self.chart_ctrl.GetPath() values = [] try: cgats = CGATS(chart) except ( IOError, CGATSInvalidError, CGATSInvalidOperationError, CGATSKeyError, CGATSTypeError, CGATSValueError, ) as exception: show_result_dialog(exception, self) else: data_format = cgats.queryv1("DATA_FORMAT") accurate = cgats.queryv1("ACCURATE_EXPECTED_VALUES") == "true" if data_format: basename, ext = os.path.splitext(chart) for column in data_format.values(): column_prefix = column.split(b"_")[0].decode("utf-8") if ( column_prefix in ("CMYK", "LAB", "RGB", "XYZ") and column_prefix not in values and ( ( (ext.lower() == ".cie" or accurate) and column_prefix in ("LAB", "XYZ") ) or ( ext.lower() == ".ti1" and column_prefix in ("CMYK", "RGB") ) or (ext.lower() not in (".cie", ".ti1")) ) ): values.append(column_prefix) if values: self.panel.Freeze() self.fields_ctrl.SetItems(values) self.fields_ctrl.GetContainingSizer().Layout() self.panel.Thaw() fields = getcfg("measurement_report.chart.fields") if ext.lower() == ".ti1": index = 0 elif "RGB" in values and not ext.lower() == ".cie": index = values.index("RGB") elif "CMYK" in values: index = values.index("CMYK") elif "XYZ" in values: index = values.index("XYZ") elif "LAB" in values: index = values.index("LAB") else: index = 0 self.fields_ctrl.SetSelection(index) setcfg("measurement_report.chart", chart) self.chart_patches_amount.Freeze() self.chart_patches_amount.SetLabel( str(cgats.queryv1("NUMBER_OF_SETS") or "") ) self.update_estimated_measurement_time("chart") self.chart_patches_amount.GetContainingSizer().Layout() self.chart_patches_amount.Thaw() self.chart_white = cgats.get_white_cie() if not values: if chart: show_result_dialog( lang.getstr( "error.testchart.missing_fields", (chart, f"RGB/CMYK {lang.getstr('or')} LAB/XYZ"), ), self, ) self.chart_ctrl.SetPath(getcfg("measurement_report.chart")) else: self.chart_btn.Enable("RGB" in values) if self.Parent: parent = self.Parent else: parent = self if ( event and self.chart_btn.Enabled and hasattr(parent, "tcframe") and self.tcframe.IsShownOnScreen() and ( not hasattr(parent.tcframe, "ti1") or chart != parent.tcframe.ti1.filename ) ): parent.tcframe.tc_load_cfg_from_ti1( None, chart, "measurement_report.chart", "mr_set_testchart" ) self.fields_ctrl.Enable(self.fields_ctrl.GetCount() > 1) self.fields_ctrl_handler(event) def set_simulate_whitepoint(self, set_whitepoint_simulate_relative=False): sim_profile = self.get_simulation_profile() is_prtr_profile = sim_profile and sim_profile.profileClass == b"prtr" if set_whitepoint_simulate_relative: setcfg( "measurement_report.whitepoint.simulate", int( not getattr(self, "chart_white", None) or "RGB" not in self.fields_ctrl.Items or is_prtr_profile ), ) setcfg( "measurement_report.whitepoint.simulate.relative", int("LAB" in self.fields_ctrl.Items or is_prtr_profile), ) def chart_drop_handler(self, path): if not self.worker.is_working(): self.chart_ctrl.SetPath(path) self.chart_ctrl_handler(True) def devlink_profile_ctrl_handler(self, event): self.set_profile("devlink") def devlink_profile_drop_handler(self, path): if not self.worker.is_working(): self.devlink_profile_ctrl.SetPath(path) self.set_profile("devlink") def enable_3dlut_handler(self, event): setcfg("3dlut.enable", int(self.enable_3dlut_cb.GetValue())) setcfg("measurement_report.use_devlink_profile", 0) self.mr_update_main_controls() def fields_ctrl_handler(self, event): setcfg("measurement_report.chart.fields", self.fields_ctrl.GetStringSelection()) if event: self.mr_update_main_controls(event) def output_profile_ctrl_handler(self, event): self.set_profile("output") def output_profile_current_ctrl_handler(self, event): profile_path = get_current_profile_path(True, True) if profile_path and os.path.isfile(profile_path): self.output_profile_ctrl.SetPath(profile_path) self.set_profile("output") def output_profile_drop_handler(self, path): if not self.worker.is_working(): self.output_profile_ctrl.SetPath(path) self.set_profile("output") def set_profile(self, which, profile_path=None, silent=False): path = getattr(self, f"{which}_profile_ctrl").GetPath() if which == "output": # if profile_path is None: # profile_path = get_current_profile_path(True, True) # self.output_profile_current_btn.Enable(self.output_profile_ctrl.IsShown() and # bool(profile_path) and # os.path.isfile(profile_path) and # profile_path != path) profile = config.get_current_profile(True) if profile: path = profile.fileName else: path = None setcfg("measurement_report.output_profile", path) XYZbpout = self.XYZbpout # XYZbpout will be set to the blackpoint of the selected profile. # This is used to determine if black output offset controls should # be shown. Set a initial value slightly above zero so output # offset controls are shown if the selected profile doesn't exist. self.XYZbpout = [0.001, 0.001, 0.001] else: profile = None if which == "input": XYZbpin = self.XYZbpin self.XYZbpin = [0, 0, 0] if path or profile: if path and not os.path.isfile(path): if not silent: show_result_dialog( Error(lang.getstr("file.missing", path)), parent=self ) return if not profile: try: profile = ICCProfile(path) except (IOError, ICCProfileInvalidError): if not silent: show_result_dialog( Error( f"{lang.getstr('profile.invalid')}\n{path}"), parent=self, ) except IOError as exception: if not silent: show_result_dialog(exception, parent=self) if profile: profile_path = profile.fileName if ( ( which == "simulation" and ( profile.profileClass not in (b"mntr", b"prtr") or profile.colorSpace not in (b"CMYK", b"RGB") ) ) or ( which == "output" and ( profile.profileClass != b"mntr" or profile.colorSpace != b"RGB" ) ) or (which == "devlink" and profile.profileClass != b"link") ): show_result_dialog( NotImplementedError( lang.getstr( "profile.unsupported", (profile.profileClass, profile.colorSpace), ) ), parent=self, ) else: if ( not getattr(self, f"{which}_profile", None) or getattr(self, f"{which}_profile").fileName != profile.fileName ): # Profile selection has changed if which == "simulation": # Get profile blackpoint so we can check if it makes # sense to show TRC type and output offset controls try: odata = self.worker.xicclu(profile, (0, 0, 0), pcs="x") except Exception as exception: show_result_dialog(exception, self) self.set_profile_ctrl_path(which) return else: if len(odata) != 1 or len(odata[0]) != 3: show_result_dialog( f"Blackpoint is invalid: {odata}", self ) self.set_profile_ctrl_path(which) return self.XYZbpin = odata[0] elif which == "output": # Get profile blackpoint so we can check if input # values would be clipped try: odata = self.worker.xicclu(profile, (0, 0, 0), pcs="x") except Exception as exception: show_result_dialog(exception, self) self.set_profile_ctrl_path(which) return else: if len(odata) != 1 or len(odata[0]) != 3: show_result_dialog( f"Blackpoint is invalid: {odata}", self ) self.set_profile_ctrl_path(which) return if odata[0][1]: # Got above zero blackpoint from lookup self.XYZbpout = odata[0] else: # Got zero blackpoint from lookup. # Try chardata instead. XYZbp = profile.get_chardata_bkpt() if XYZbp: self.XYZbpout = XYZbp else: self.XYZbpout = [0, 0, 0] else: # Profile selection has not changed # Restore cached XYZbp values if which == "output": self.XYZbpout = XYZbpout elif which == "input": self.XYZbpin = XYZbpin setattr(self, f"{which}_profile", profile) if not silent: setcfg( f"measurement_report.{which}_profile", profile and profile_path, ) if which == "simulation": self.use_simulation_profile_ctrl_handler(None) elif hasattr(self, "XYZbpin"): self.mr_update_main_controls() return profile if path: self.set_profile_ctrl_path(which) else: setattr(self, f"{which}_profile", None) if not silent: setcfg(f"measurement_report.{which}_profile", None) self.mr_update_main_controls() def set_profile_ctrl_path(self, which): getattr(self, f"{which}_profile_ctrl").SetPath( getcfg(f"measurement_report.{which}_profile") ) def mr_setup_language(self): # Shared with main window for which in ( "chart", "simulation_profile", "devlink_profile", "output_profile", ): if which.endswith("_profile"): wildcard = f'{lang.getstr("filetype.icc")}|*.icc;*.icm' else: wildcard = ( f'{lang.getstr("filetype.ti1_ti3_txt")}|' "*.cgats;*.cie;*.ti1;*.ti2;*.ti3;*.txt" ) msg = { "chart": "measurement_report_choose_chart_or_reference", "devlink_profile": "devicelink_profile", "output_profile": "measurement_report_choose_profile", }.get(which, which) kwargs = dict( toolTip=lang.getstr(msg).rstrip(":"), dialogTitle=lang.getstr(msg), fileMask=wildcard, ) ctrl = getattr(self, f"{which}_ctrl") for name in kwargs: value = kwargs[name] setattr(ctrl, name, value) items = [] for item in ("Gamma 2.2", "trc.rec1886", "custom"): items.append(lang.getstr(item)) self.mr_trc_ctrl.SetItems(items) self.trc_gamma_types_ab = {0: "b", 1: "B"} self.trc_gamma_types_ba = {"b": 0, "B": 1} self.mr_trc_gamma_type_ctrl.SetItems( [lang.getstr("trc.type.relative"), lang.getstr("trc.type.absolute")] ) def mr_show_trc_controls(self): shown = self.apply_trc_ctrl.IsShown() enable6 = shown and bool(getcfg("measurement_report.apply_trc")) show = shown and ( self.mr_trc_ctrl.GetSelection() == 2 or getcfg("show_advanced_options") ) self.panel.Freeze() self.mr_trc_ctrl.Enable(enable6) self.mr_trc_ctrl.Show(shown) self.mr_trc_gamma_label.Enable(enable6) self.mr_trc_gamma_label.Show(show) self.mr_trc_gamma_ctrl.Enable(enable6) self.mr_trc_gamma_ctrl.Show(show) self.mr_trc_gamma_type_ctrl.Enable(enable6) self.mr_black_output_offset_label.Enable(enable6 and self.XYZbpout > [0, 0, 0]) self.mr_black_output_offset_label.Show(show and self.XYZbpout > [0, 0, 0]) self.mr_black_output_offset_ctrl.Enable(enable6 and self.XYZbpout > [0, 0, 0]) self.mr_black_output_offset_ctrl.Show(show and self.XYZbpout > [0, 0, 0]) self.mr_black_output_offset_intctrl.Enable( enable6 and self.XYZbpout > [0, 0, 0] ) self.mr_black_output_offset_intctrl.Show(show and self.XYZbpout > [0, 0, 0]) self.mr_black_output_offset_intctrl_label.Enable( enable6 and self.XYZbpout > [0, 0, 0] ) self.mr_black_output_offset_intctrl_label.Show( show and self.XYZbpout > [0, 0, 0] ) self.mr_trc_gamma_type_ctrl.Show(show and self.XYZbpout > [0, 0, 0]) self.panel.Layout() self.panel.Thaw() def simulate_whitepoint_ctrl_handler(self, event): v = self.simulate_whitepoint_cb.GetValue() setcfg("measurement_report.whitepoint.simulate", int(v)) self.mr_update_main_controls() def simulate_whitepoint_relative_ctrl_handler(self, event): setcfg( "measurement_report.whitepoint.simulate.relative", int(self.simulate_whitepoint_relative_cb.GetValue()), ) def simulation_profile_ctrl_handler(self, event): self.set_profile("simulation") def simulation_profile_drop_handler(self, path): if not self.worker.is_working(): self.simulation_profile_ctrl.SetPath(path) self.set_profile("simulation") def mr_set_filebrowse_paths(self): for which in ("simulation", "devlink", "output"): self.set_profile_ctrl_path(which) chart = getcfg("measurement_report.chart") if not chart or not os.path.isfile(chart): chart = config.defaults["measurement_report.chart"] setcfg("measurement_report.chart", chart) self.mr_set_testchart(chart, load=False) def mr_update_controls(self, set_filebrowse_paths=True): """Update controls with values from the configuration""" self.panel.Freeze() if set_filebrowse_paths: self.mr_set_filebrowse_paths() self.set_profile("simulation", silent=True) self.mr_update_trc_controls() self.set_profile("devlink", silent=True) self.set_profile("output", silent=True) self.chart_ctrl_handler(None) self.use_simulation_profile_ctrl_handler(None, update_trc=False) self.panel.Thaw() def mr_update_trc_control(self): if ( getcfg("measurement_report.trc_gamma_type") == "B" and getcfg("measurement_report.trc_output_offset") == 0 and getcfg("measurement_report.trc_gamma") == 2.4 ): self.mr_trc_ctrl.SetSelection(1) # BT.1886 elif ( getcfg("measurement_report.trc_gamma_type") == "b" and getcfg("measurement_report.trc_output_offset") == 1 and getcfg("measurement_report.trc_gamma") == 2.2 ): self.mr_trc_ctrl.SetSelection(0) # Pure power gamma 2.2 else: self.mr_trc_ctrl.SetSelection(2) # Custom def mr_update_trc_controls(self): self.mr_update_trc_control() self.mr_trc_gamma_ctrl.SetValue(str(getcfg("measurement_report.trc_gamma"))) self.mr_trc_gamma_type_ctrl.SetSelection( self.trc_gamma_types_ba[getcfg("measurement_report.trc_gamma_type")] ) outoffset = int(getcfg("measurement_report.trc_output_offset") * 100) self.mr_black_output_offset_ctrl.SetValue(outoffset) self.mr_black_output_offset_intctrl.SetValue(outoffset) def mr_set_testchart(self, path, load=True): self.chart_ctrl.SetPath(path) if load: self.chart_ctrl_handler(None) def mr_update_main_controls(self, event=None): # print("MR update main ctrls") self.panel.Freeze() chart_has_white = bool(getattr(self, "chart_white", None)) color = getcfg("measurement_report.chart.fields") sim_profile_color = ( getattr(self, "simulation_profile", None) and self.simulation_profile.colorSpace ) if isinstance(sim_profile_color, bytes): sim_profile_color = sim_profile_color.decode("utf-8") if getcfg("measurement_report.use_simulation_profile"): setcfg( "measurement_report.use_simulation_profile", int(sim_profile_color == color), ) self.simulation_profile_cb.Enable(sim_profile_color == color) self.simulation_profile_cb.Show(color in ("CMYK", "RGB")) enable1 = bool(getcfg("measurement_report.use_simulation_profile")) # print(enable1) enable2 = sim_profile_color == "RGB" and bool( getcfg("measurement_report.use_simulation_profile_as_output") ) self.simulation_profile_cb.SetValue(enable1) self.simulation_profile_ctrl.Show(color in ("CMYK", "RGB")) self.use_simulation_profile_as_output_cb.Show( enable1 and sim_profile_color == "RGB" ) self.use_simulation_profile_as_output_cb.SetValue(enable1 and enable2) self.enable_3dlut_cb.Enable(enable1 and enable2) self.enable_3dlut_cb.SetValue( enable1 and enable2 and bool(getcfg("3dlut.enable")) ) self.enable_3dlut_cb.Show( enable1 and sim_profile_color == "RGB" and config.get_display_name() in ("madVR", "Prisma") ) enable5 = ( sim_profile_color == "RGB" and isinstance(self.simulation_profile.tags.get("rXYZ"), XYZType) and isinstance(self.simulation_profile.tags.get("gXYZ"), XYZType) and isinstance(self.simulation_profile.tags.get("bXYZ"), XYZType) and not isinstance(self.simulation_profile.tags.get("A2B0"), LUT16Type) ) # print(enable5, self.XYZbpin, self.XYZbpout) self.mr_trc_label.Show(enable1 and enable5) self.apply_none_ctrl.Show(enable1 and enable5) self.apply_none_ctrl.SetValue( ( not getcfg("measurement_report.apply_black_offset") and not getcfg("measurement_report.apply_trc") ) or not enable5 ) self.apply_black_offset_ctrl.Show(enable1 and enable5) self.apply_black_offset_ctrl.SetValue( enable5 and bool(getcfg("measurement_report.apply_black_offset")) ) self.apply_trc_ctrl.Show(enable1 and enable5) self.apply_trc_ctrl.SetValue( enable5 and bool(getcfg("measurement_report.apply_trc")) ) enable6 = ( enable1 and enable5 and bool( getcfg("measurement_report.apply_trc") or getcfg("measurement_report.apply_black_offset") ) ) self.mr_show_trc_controls() show = ( self.apply_none_ctrl.GetValue() and enable1 and enable5 and self.XYZbpout > self.XYZbpin ) self.input_value_clipping_bmp.Show(show) self.input_value_clipping_label.Show(show) if event: self.set_simulate_whitepoint(True) self.simulate_whitepoint_cb.Enable( (enable1 and not enable2) or (color in ("LAB", "XYZ") and chart_has_white) ) enable3 = bool(getcfg("measurement_report.whitepoint.simulate")) self.simulate_whitepoint_cb.SetValue( ((enable1 and not enable2) or color in ("LAB", "XYZ")) and enable3 ) self.simulate_whitepoint_relative_cb.Enable( ((enable1 and not enable2) or color in ("LAB", "XYZ")) and enable3 ) self.simulate_whitepoint_relative_cb.SetValue( ((enable1 and not enable2) or color in ("LAB", "XYZ")) and enable3 and bool(getcfg("measurement_report.whitepoint.simulate.relative")) ) self.devlink_profile_cb.Show(enable1 and enable2) enable4 = bool(getcfg("measurement_report.use_devlink_profile")) self.devlink_profile_cb.SetValue(enable1 and enable2 and enable4) self.devlink_profile_ctrl.Enable(enable1 and enable2 and enable4) self.devlink_profile_ctrl.Show(enable1 and enable2) self.output_profile_label.Enable( (color in ("LAB", "RGB", "XYZ") or enable1) and ( not enable1 or not enable2 or self.apply_trc_ctrl.GetValue() or self.apply_black_offset_ctrl.GetValue() ) ) self.output_profile_ctrl.Enable( (color in ("LAB", "RGB", "XYZ") or enable1) and ( not enable1 or not enable2 or self.apply_trc_ctrl.GetValue() or self.apply_black_offset_ctrl.GetValue() ) ) output_profile = ( hasattr(self, "presets") and getcfg("measurement_report.output_profile") not in self.presets or not hasattr(self, "presets") ) and bool(getattr(self, "output_profile", None)) self.measurement_report_btn.Enable( ( ( enable1 and enable2 and (not enable6 or output_profile) and ( not enable4 or ( bool(getcfg("measurement_report.devlink_profile")) and os.path.isfile( getcfg("measurement_report.devlink_profile") ) ) ) ) or ( ( (not enable1 and color in ("LAB", "RGB", "XYZ")) or (enable1 and sim_profile_color == color and not enable2) ) and output_profile ) ) and bool(getcfg("measurement_report.chart")) and os.path.isfile(getcfg("measurement_report.chart")) ) self.panel.Layout() self.panel.Thaw() if hasattr(self, "update_scrollbars"): self.update_scrollbars() self.calpanel.Layout() else: self.update_layout() def update_estimated_measurement_time(self, which, patches=None): """Update the estimated measurement time shown""" integration_time = self.worker.get_instrument_features().get("integration_time") if integration_time: if which == "chart" and not patches: patches = int(self.chart_patches_amount.Label) opatches = patches # Scale integration time based on display technology tech = getcfg("display.technology").lower() if isinstance(tech, bytes): tech = tech.decode("utf-8") prop = [1, 1] if "plasma" in tech or "crt" in tech: prop[0] = 1.9 elif "projector" in tech or "dlp" in tech: prop[0] = 2.2 prop[1] = 2.2 elif "oled" in tech: prop[0] = 2.2 integration_time = [ min(prop[i] * v, 20) for i, v in enumerate(integration_time) ] # Get time per patch (tpp) tpp = [v for v in integration_time] if ( "plasma" in tech or "crt" in tech or "projector" in tech or "dlp" in tech ) and self.worker.get_instrument_features().get("refresh"): # Not all instruments can measure refresh rate! Add .25 secs # for those who do if refresh mode is used. tpp = [v + 0.25 for v in tpp] if config.get_display_name() == "madVR": # madVR takes a tad longer tpp = [v + 0.45 for v in tpp] min_delay_s = 0.2 if getcfg("measure.override_min_display_update_delay_ms"): # Add additional display update delay (zero at <= 200 ms) min_delay_ms = getcfg("measure.min_display_update_delay_ms") min_delay_s = max(min_delay_ms / 1000.0, min_delay_s) if getcfg("measure.override_display_settle_time_mult"): # We don't have access to display rise/fall time, so use this as # generic delay multiplier settle_mult = getcfg("measure.display_settle_time_mult") else: settle_mult = 1.0 tpp = [v + min_delay_s + 0.145 * settle_mult for v in tpp] avg_delay = sum(tpp) / (8 / 3.0) seconds = avg_delay * patches oseconds = seconds if getcfg("drift_compensation.blacklevel"): # Assume black patch every 60 seconds seconds += math.ceil(oseconds / 60.0) * ((20 - tpp[0]) / 2.0 + tpp[0]) # Assume black patch every n samples seconds += math.ceil(opatches / 40.0) * ((20 - tpp[0]) / 2.0 + tpp[0]) if getcfg("drift_compensation.whitelevel"): # Assume white patch every 60 seconds seconds += math.ceil(oseconds / 60.0) * tpp[1] # Assume white patch every n samples seconds += math.ceil(opatches / 40.0) * tpp[1] if ( which in ("testchart", "chart") and getcfg("testchart.patch_sequence") != "optimize_display_response_delay" ): # Roughly 650s patch response delay per 1000 patches # reduced by roughly 1 / 1.75 through optimization. seconds -= 0.65 / 1.75 * patches seconds += 0.65 * patches if ( getcfg("patterngenerator.ffp_insertion") and hasattr(self, "ffp_insertion") and self.ffp_insertion.IsShown() ): interval = getcfg("patterngenerator.ffp_insertion.interval") duration = getcfg("patterngenerator.ffp_insertion.duration") if getcfg("measure.override_min_display_update_delay_ms"): dur = getcfg("measure.min_display_update_delay_ms") / 1000.0 else: dur = 0 ffp_delay = max(0.8 - dur, 0) seconds += seconds / max(interval, avg_delay) * (duration + ffp_delay) timestamp = gmtime(seconds) hours = int(strftime("%H", timestamp)) minutes = int(strftime("%M", timestamp)) minutes += int(math.ceil(int(strftime("%S", timestamp)) / 60.0)) if minutes > 59: minutes = 0 hours += 1 else: hours, minutes = "--", "--" getattr(self, f"{which}_meas_time").Label = lang.getstr( "estimated_measurement_time", (hours, minutes) ) # Show visual warning by coloring the text if measurement is going to # take a long time. Display and instrument stability and repeatability # may be an issue over such long periods of time. if hours != "--" and hours > 7: # Warning color "red" color = "#FF3300" elif hours != "--" and hours > 3: # Warning color "orange" color = "#F07F00" else: # Default text color color = wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOWTEXT) getattr(self, f"{which}_meas_time").ForegroundColour = color def use_devlink_profile_ctrl_handler(self, event): setcfg("3dlut.enable", 0) setcfg( "measurement_report.use_devlink_profile", int(self.devlink_profile_cb.GetValue()), ) self.mr_update_main_controls() def get_simulation_profile(self): """Return simulation profile if enabled""" use_sim_profile = getcfg("measurement_report.use_simulation_profile") return use_sim_profile and getattr(self, "simulation_profile", None) def use_simulation_profile_ctrl_handler(self, event, update_trc=True): if event: setcfg( "measurement_report.use_simulation_profile", int(self.simulation_profile_cb.GetValue()), ) sim_profile = self.get_simulation_profile() enable = False if sim_profile: self.set_simulate_whitepoint() if ( "rTRC" in sim_profile.tags and "gTRC" in sim_profile.tags and "bTRC" in sim_profile.tags and sim_profile.tags.rTRC == sim_profile.tags.gTRC == sim_profile.tags.bTRC and isinstance(sim_profile.tags.rTRC, CurveType) ): tf = sim_profile.tags.rTRC.get_transfer_function(outoffset=1.0) if update_trc or self.XYZbpin == self.XYZbpout: # Use only BT.1886 black output offset or not setcfg( "measurement_report.apply_black_offset", int( tf[0][1] not in (-240, -709) and (not tf[0][0].startswith("Gamma") or tf[1] < 0.95) and self.XYZbpin != self.XYZbpout ), ) if update_trc: # Use BT.1886 gamma mapping for SMPTE 240M / Rec. 709 TRC setcfg( "measurement_report.apply_trc", int( tf[0][1] in (-240, -709) or (tf[0][0].startswith("Gamma") and tf[1] >= 0.95) ), ) # Set gamma to profile gamma if single gamma profile if tf[0][0].startswith("Gamma") and tf[1] >= 0.95: if not getcfg("measurement_report.trc_gamma.backup", False): # Backup current gamma setcfg( "measurement_report.trc_gamma.backup", getcfg("measurement_report.trc_gamma"), ) setcfg("measurement_report.trc_gamma", round(tf[0][1], 2)) # Restore previous gamma if not single gamma profile elif getcfg("measurement_report.trc_gamma.backup", False): setcfg( "measurement_report.trc_gamma", getcfg("measurement_report.trc_gamma.backup"), ) setcfg("measurement_report.trc_gamma.backup", None) self.mr_update_trc_controls() enable = tf[0][1] not in (-240, -709) and self.XYZbpin != self.XYZbpout elif update_trc: enable = self.XYZbpin != self.XYZbpout setcfg("measurement_report.apply_black_offset", int(enable)) setcfg("measurement_report.apply_trc", 0) self.apply_black_offset_ctrl.Enable(bool(sim_profile) and enable) self.mr_update_main_controls() def use_simulation_profile_as_output_handler(self, event): setcfg( "measurement_report.use_simulation_profile_as_output", int(self.use_simulation_profile_as_output_cb.GetValue()), ) self.mr_update_main_controls() if __name__ == "__main__": config.initcfg() lang.init() lang.update_defaults() app = BaseApp(0) app.TopWindow = ReportFrame() app.TopWindow.Show() app.MainLoop()