[Enhancement]
Added Python 3 support. DisplayCAL now works with Python 3.8+.
[Enhancement]
Dropped Python 2.x support. DisplayCAL will not work with Python 2.x anymore.
[Enhancement]
Dropped 32bit support. DisplayCAL is now working only in 64bit OSes.
Release highlights since 2022-04-01:
2025-04-02 - DisplayCAL 3.9.15
[Moderate]
Windows startup and executable launch reliability fixes, including handling for paths with spaces and frozen-environment launch variables.
[Minor]
macOS splash-screen rendering fix and improved Windows installer/driver handling.
[Moderate]
Stability fixes for profile loader and 3D view/reporting edge cases.
2025-05-04 - DisplayCAL 3.9.16
[Enhancement]
Dropped Python 3.8 support and aligned project metadata/build tooling with current Python packaging expectations.
[Enhancement]
Package naming and CI workflow improvements for more reliable test/build automation.
[Moderate]
Fixed recursion and menu-flow issues around ArgyllCMS detection and instrument configuration install paths.
2025-09-11 - DisplayCAL 3.9.17
[Moderate]
Corrected black point correction handling so the -b argument flow is respected during calibration preparation.
[Enhancement]
Added support for ArgyllCMS 3.4 observer naming updates (CIE 2015 names).
[Moderate]
Startup and runtime reliability fixes, including UTF-8 decode and madVR integration issues.
Post-3.9.17 development (ongoing)
[Enhancement]
Ongoing Python 3.14 compatibility and packaging modernization work.
[Enhancement]
Expanded ArgyllCMS compatibility work for 3.5.0, including newer archive/platform handling (Windows ARM64 and macOS ARM64) and related UI/docs updates.
[Minor]
Broad linting, refactoring, and translation/documentation maintenance across the codebase.
[Moderate]
Improved Web @ localhost reliability and responsiveness: fixed polling freeze/retry behavior, corrected CSS color encoding accuracy, improved multi-device browser handling, and avoided unnecessary probe-session reconnect churn before interactive adjustment.
2019-12-12 22:33 (UTC) 3.8.9.2
DisplayCAL 3.8.9.2
Fixed in this release:
[Minor] When previous instance was force quit, override leftover lockfile.
[Trivial] When using a custom profiling testchart with very few or no dark RGB gray patches, try to better maintain slope of existing points during shaper curve generation.
2019-12-08 01:19 (UTC) 3.8.9.1
DisplayCAL 3.8.9.1
Fixed in this release:
[Moderate] Fix SpyderX calibration issue when using 32-bit ArgyllCMS executables.
2019-12-07 16:21 (UTC) 3.8.9
DisplayCAL 3.8.9
Changed in this release:
[Enhancement] Show the instrument serial number (if available) when prompting to physically interact with the instrument.
[Enhancement] Check SpyderX dark offset calibration and abort if it is too high (user error).
[Enhancement] Adjust perceptual device to PCS table black point to match perceptual PCS to device table.
[Enhancement] Warn during automatic output levels detection if the display device input range or graphics driver output range look to be misconfigured.
[Enhancement] Profile loader (Windows): Use an alternate method to enforce single instance if local IPC is blocked.
Tone response curve plot now uses the illuminant-relative profile whitepoint instead of D50 for input values if using absolute colorimetric intent.
Rename “LG OLED” (.dcl) 3D LUT format to “DeviceControl” and unlock available resolutions.
Fixed in this release:
[Trivial] Reload current calibration when cancelling profile installation (regression of a change to profile installation dialog handling in DisplayCAL 3.8.8, SVN revision r6252).
[Trivial] When loading settings from a profile, restore unused CIECAM02 viewing conditions (if applicable).
[Trivial] Prevent potential double prompt for instrument calibration.
[Cosmetic] Do not re-use logfiles for standalone tools as long as other instances are still running.
[Moderate] Linux: Failure to launch with pre-release versions of wxPython 4.
2019-11-07 21:16 (UTC) 3.8.8.1
DisplayCAL 3.8.8.1
Fixed in this release:
[Moderate] Linux: Work-around failure to launch if wxPython 3.0 / wxWidgets 3.0 release number do not match (using wxPython 3.0 is deprecated).
2019-11-06 23:12 (UTC) 3.8.8
DisplayCAL 3.8.8
Changed in this release:
[Enhancement] Detect and warn about malformed colorimeter corrections (e.g. from non-official sources). Move them to the trash automatically if they were previously (manually) installed.
[Enhancement] Always enumerate instruments on application startup if more than one instrument was detected the last time the application was used (cross-platform consistency).
[Enhancement] When prompting for instrument calibration, display the just now detected instrument name instead of the previously enumerated name (the latter might be stale if you forgot to refresh after changing connected instruments).
[Enhancement] Use a slightly improved smoothing method when creating high resolution PCS to device tables.
[Enhancement] Increase automatic PCS to device table resolution for L*a*b* LUT profiles to 45x45x45 if using smoothing.
[Enhancement][UI] Only auto-close profile/3D LUT installation dialog after a successful installation.
[Enhancement] Don't auto-close madTPG after 3D LUT installation.
[Enhancement] macOS: Warn if a black luminance calibration target is set.
[Enhancement] Profile loader (Windows): Use a minimally faster method to check for other running applications.
Fixed in this release:
[Minor] madVR 3D LUT generation: Always write D65 white to 3D LUT input primaries metadata so madVR does not attempt to correct whitepoint differences on its own when using a custom whitepoint (the 3D LUT itself will map the custom whitepoint correctly).
[Minor] madVR 3D LUT installation: Don't attempt to install 3D LUTs with unsupported input primaries metadata (i.e. not Rec. 709, SMPTE C, EBU/PAL, Rec. 2020 or DCI P3) as madVR will overwrite the metadata depending on the 3D LUT install slot. Such 3D LUTs should only be assigned manually in madVR instead.
[Trivial][UI] When loading settings, always enable the 3D LUT tab if the display is virtual (consistent with display selection behavior).
[Trivial] Also apply black point correction when creating a matrix profile without black point compensation (consistency).
[Trivial] Do not create swapped matrix fallback tags for XYZ LUT profiles when using the alternate forward profiler and the used ArgyllCMS version is >= 2.1 (be consistent with ArgyllCMS).
[Trivial] madVR 3D LUT generation: Accept negative values for input primaries metadata.
[Trivial] madVR 3D LUT installation (Linux, macOS): Send the 3D LUT in chunks and increase the timeout to prevent the installation failing over a slow network (e.g. WiFi).
[Cosmetic][UI] Profile loader (Windows): Prevent a stale tray icon remaining (until mouse over) in some rare cases after exiting the profile loader.
[Trivial][UI] Profile information (Linux): When using wxPython 3.0 instead of 4.0, clicking the sash would throw an error (using wxPython 3.0 is deprecated).
[Trivial] macOS: Only automatically re-enable black point compensation if restoring defaults or loading a non-3D-LUT preset.
[Trivial] Profile loader (Windows): Work-around two instances of the profile loader being started after powering on the system if fast startup was enabled in Windows power settings.
2019-09-22 13:23 (UTC) 3.8.7
DisplayCAL 3.8.7
Changed in this release:
[Enhancement] macOS: Automatically enable not using the video card gamma table to apply calibration during characterization measurements if using limited range (16..235). This should mitigate issues with older graphics chipsets and/or macOS versions that use the wrong output range internally when connected to some monitors that expect to receive limited range signals.
[Enhancement] Profile loader (Windows): A scheduled task now restarts the profile loader after resume from standby/hibernation as well as daily at 04:00 AM (whichever comes first), to mitigate the Windows GDI SetDeviceGammaRamp API leaking memory since Windows 10 1903.
Fixed in this release:
[Trivial] Don't automatically disable interactive display adjustment when setting calibration tone curve to “As measured” (unintended behavioral change introduced in DisplayCAL 3.8.6, SVN revision r6194).
[Minor] Linux (GNOME on Wayland): Latency incurred by a large measurement window size was not accounted for, introducing the possibility of measurements failing due to loss of synchronization.
[Minor] Linux (GNOME on Wayland): Limited range (16..235) support.
[Cosmetic][UI] macOS: Get rid of brief profile installation dialog flicker after installation.
2019-09-06 10:23 (UTC) 3.8.6
DisplayCAL 3.8.6
Changed in this release:
[Enhancement] If the graphics drivers or hardware do not support loadable gamma ramps or calibration, show a more descriptive error message.
[Enhancement] Increase the timeout for display & instrument detection during application startup from 10 to 20 seconds, to allow for slow opening of legacy serial ports.
[Enhancement] Windows 10 1903: Always do instrument detection during application startup if more than one instrument was connected the last time the application was used, as the list of instruments is not guaranteed to be consistent between sessions under 1903.
[Enhancement] Profile loader (Windows): Apply smoothing to calibration if the quantization bitdepth is set to 8.
[Enhancement] Profile loader (Windows): No longer require running elevated to be able to detect changes in the display configuration under Windows 10 1903.
Fixed in this release:
[Minor] Do not attempt to access properties of non-existent objects if a subprocess is not succesfully terminated after reaching a timeout during display & instrument detection at application startup (unexpected failure).
[Trivial][UI] Disable the profile installation button if no displays have been detected.
[Trivial][UI] Disable the measurement report menu item if no instruments have been detected.
[Trivial] Profile loader (Windows): Work around Windows 10 1903 handle leaks in Windows Color System APIs.
2019-08-14 13:06 (UTC) 3.8.5
DisplayCAL 3.8.5
Changed in this release:
[Enhancement] macOS: Use caffeinate to prevent display sleep and screensaver.
Fixed in this release:
[Moderate] DisplayCAL 3.8.4 broke video levels (16..235) output encoding/decoding for video card gamma table tags (profiles using calibration with video output levels created by 3.8.4 can be fixed by re-creating via menu “File”, “Create profile from measurement data...” and selecting the existing profile).
2019-08-10 21:17 (UTC) 3.8.4
DisplayCAL 3.8.4
Changed in this release:
[Enhancement] Do early detection of highly non-monotonic luminance responses when doing on-the-fly generation of the preconditioning profile for auto-optimized testcharts with 425 or more patches.
[Enhancement] Always create a single shaper curve for the fallback matrix tags of cLUT profiles with nonlinear calibration.
[Enhancement] Profile loader (Windows): Only try to restore profile associations on exit if they had to be fixed on launch to begin with.
Fixed in this release:
[Minor] Work-around Argyll applycal bug with gamma value TRC curve tags in profiles (fixes generating HDR 3D LUTs from display profiles with such tags).
[Trivial][UI] Windows with display scaling above 100% (HiDPI): Prevent occasional text cutoff/wrapping issues on dialog messages by adding one pixel to the minimum width of the message text area (wxWidgets bug).
2019-07-02 21:00 (UTC) 3.8.3
DisplayCAL 3.8.3
Changed in this release:
Profile loader (Windows): Work around Windows 10 1903 (May 2019 update) severe banding bug and automatically disable Microsoft Windows Color System Calibration Loader task. Logging out and back in is required, and may be required each time a display's default associated profile is changed.
Fixed in this release:
[Minor] Verification: Prevent unintended mixing of unicode and binary strings when a device link profile is used.
[Cosmetic][UI] Linux (KDE): Centering the measurement window would increase its size slightly and resetting its size would move the window down and right (regression of SVN revision r6137).
2019-06-09 15:18 (UTC) 3.8.2
DisplayCAL 3.8.2
Changed in this release:
[Enhancement] Always try to skip initial colorimeter calibration for uniformity measurements (e.g. SpyderX).
[Enhancement] Linux: Use GObject Introspection for DBus access (if available).
[Enhancement] Linux: Use a default timeout of 500 ms for DBus calls.
[Enhancement] Profile loader (Windows): If registry access to the display configuration fails (e.g. due to running non-elevated), log a warning only once.
Windows: Only log Windows exceptions that are actually errors.
Fixed in this release:
[Minor] If invoked from the main application's “Tools” menu, the synthetic ICC profile creator HDR configuration could affect the main application's 3D LUT HDR configuration.
[Minor] Successive requested instrument calibration during uniformity measurements did not wait for the calibration to complete before continuing (e.g. SpyderX).
[Trivial] Prevent potential blocking of socket binding if a previous instance exited unexpectedly.
[Trivial][UI] Change parent inheritance for pathdialog wrappers so interacting with the parent is appropriately prevented when the wrapper dialog is shown via a scripting request.
[Trivial][UI] Linux: Always prefer the global DPI value (Xft.dpi) for HiDPI scaling with wxGTK2.
[Trivial][UI] Windows: Work-around wxPython Phoenix bug: Destroying a frame loaded from XRC affects subsequently loaded XRC resources (leading to instantiated controls being of the wrong type and failing initialization due to not having the expected interfaces).
2019-05-24 01:13 (UTC) 3.8.1.1
DisplayCAL 3.8.1.1
Fixed in this release:
[Minor][UI] Linux: Some custom widgets could have a size of zero with wxGTK2 under non-KDE desktop environments when org.gnome.desktop.interface scaling-factor was set to 0 (regression of a change in DisplayCAL 3.8.1, SVN revision r5979).
[Minor][UI] Linux: No scaling for some custom widgets with wxGTK2 and HiDPI unless org.gnome.desktop.interface scaling-factor was set to a value of 2 or higher (regression of a change in DisplayCAL 3.8.1, SVN revision r6005). HiDPI scaling with wxGTK2 under X11 is now handled entirely by the global DPI value (Xft.dpi).
[Minor][UI] Linux: Too small size for the contents of some custom widgets with wxGTK2 and HiDPI.
[Cosmetic][UI] Linux: Too much padding inside some custom widgets with wxGTK2 and HiDPI.
[Cosmetic][UI] Linux: Occasional glitchy window sizing under Wayland.
[Cosmetic][UI] Linux: Added workaround for double window decorations when the environment variable GTK_CSD is set to a nonzero value under X11 (e.g. elementary OS Juno with Phanteon desktop).
2019-05-18 15:11 (UTC) 3.8.1
DisplayCAL 3.8.1
Added in this release:
[Feature] Linux: Preliminary experimental Wayland support under GNOME 3 using colord (requires ArgyllCMS 2.1 or newer as well). Caveats do apply:
Window placement and ordering is completely up to the compositor under Wayland. There is generally no way for an application to place its own windows at specific relative locations or z-orders. As a result of this, the measurement window cannot stay always on top or be automatically centered. Extra care needs to be taken that other windows are not placed on top.
Video card gamma table (videoLUT) access is handled by colord. Some functions like viewing current videoLUT contents may not be available.
The measurement window color depth is limited to 8 bits per channel per pixel (but dithering is used to achieve a higher effective color depth).
The measurement window may be subject to desktop-wide color management in upcoming versions of Wayland (although the display device is inhibited during measurements via the org.freedesktop.ColorManager.Device D-Bus API which should prevent this, and as a fallback a linear calibration sRGB profile is temporarily installed during measurements if the D-BUs API is unavailable, which should result in an identity transform, i.e. effectively no color management, as well as linear video card gamma tables).
Application support for color management under Wayland via colord still seems to lacking (although the list may well be out-of-date).
Only tested under GNOME 3 (Fedora 30, Ubuntu 19.04). Support for other desktop environments will need to be implemented separately until Wayland gains a color management and calibration/profiling protocol.
[Feature] LG OLED 3D LUT format.
Changed in this release:
[Enhancement] If the currently used ArgyllCMS version is not a standard version, but also not a beta, do not offer to switch to an installed official stable version if it's otherwise the same version number.
[Enhancement] Include Quantum Dot LED (Samsung QLED Q9F) spectral sample colorimeter correction when importing for i1 Display Pro and ColorMunki Display (sourced from community colorimeter corrections database).
[UI] Linux (Debian, Fedora, Ubuntu): Use wxPython Phoenix if installed.
Prisma, Resolve: Set pattern generator background color to pattern color if using fullscreen patterns.
Fixed in this release:
[Moderate] UnicodeDecodeError when a CCSS file contains unicode characters in the display device description (regression of a change in DisplayCAL 3.8 to use localized technology descriptions, SVN revision r5810).
[Minor] APL calculation for Prisma and Resolve pattern generators was off by a few percent depending on pattern area and current pattern color.
[Minor] Quick reporting on calibrated or uncalibrated display did not try to detect output levels if set to “Auto”.
[Trivial] More gracefully deal with faulty tags in ICC profiles (fixes ICC profile information unhandled exception for colord-created profiles with malformed targ tags).
[Trivial][UI] Correctly update the audio button state on progress dialogs when changed on a previous window.
[Cosmetic][UI] Various minor potential rendering glitches.
[Cosmetic][UI] macOS (standalone application bundle): Splash screen did not animate.
[Cosmetic][UI] Linux: Add work-arounds for various Wayland-related wxPython rendering quirks and bugs (e.g. spacing around windows, popup menu placement).
[Trivial] Linux: Try to work around sporadic colord profile installation quirks (“The profile was not added in time”).
Phasing out 0install support. While the 0install version of DisplayCAL (which was originally introduced as a replacement for the long-defunct Autopackage system under Linux) has had its uses, the low distribution (around 6%) of 0install versus the standalone version does no longer warrant the additional time and work needed to maintain this separate deployment path.
0install support is thus being phased out starting with DisplayCAL 3.7.2 and following releases, which are only available as “standalone” installations. Windows and macOS users will be updated automatically to the standalone version. Linux users should switch to a standalone package at their earliest convenience.
There will be a transition period of a few months during which old 0install-based DisplayCAL versions will continue to run, but afterwards the respective online infrastructure will be decommissioned.
2019-04-26 01:17 (UTC) 3.8
DisplayCAL 3.8
Added in this release:
[Feature]SpyderX support (requires ArgyllCMS 2.1.0 or newer, use ArgyllCMS 2.1.1 or newer to be able to skip instrument self-calibration).
[Feature]Colorimeter correction information with graph.
[Feature] Synthetic ICC profile creator: Drag & drop support for TI3 measurement files.
[Enhancement] Rudimentary support for hypothetical future instruments and their measurement modes (any new instrument support added to ArgyllCMS in the future should be fully usable in DisplayCAL right away without needing an update for instrument-specific measurement modes).
[Enhancement] Display technology information to aid in the choice of a suitable measurement mode or correction.
[Enhancement] Include some additional spectral sample colorimeter corrections when importing for i1 Display Pro and ColorMunki Display (e.g. MacBook Pro 2016 Retina with PFS Phosphor WLED “P3” display, LG OLED 6-series WOLED based on samples from LG C6 and E6 OLED TVs, sourced and combined from community colorimeter corrections database contributions).
[Enhancement] macOS: Automatically warn about incompatibilities of Apple software with calibration black point hue correction and profile types other than single curve + matrix with black point compensation.
Changed in this release:
[UI] Updated simplified chinese localization (thanks to Mars).
[UI] Updated french localization (thanks to Jean-Luc Coulon).
[Enhancement] Prefer colorimeter corrections from “ArgyllCMS” folder and ignore duplicate (spectral) colorimeter corrections from “color” folder (e.g. installed by HCFR under Windows).
[Enhancement] Default to high-resolution spectrum mode (if available) for spectrometers that support it.
[Enhancement] Implicitly try to skip repeat instrument self-calibration for colorimeters that want it if already done at least once per measurement run.
[Enhancement] Converted translation file format from JSON to YAML for better readability.
[Enhancement] Use a localized description for known quality spectral sample colorimeter corrections.
[Minor] Not all programmed measurement modes were enumerated for the K10-A colorimeter (regression of a change in DisplayCAL 3.7, SVN revision r5557).
[Minor] ColorHug/ColorHug2 “auto” measurement mode was not working anymore.
[Trivial] Curve viewer: Re-introduced being able to view the current contents of the video card gamma table if no display profile is set or the profile used does not contain calibration.
[Cosmetic] Curve viewer, profile information: Curve graphing identical channel detection was not working properly in some cases (only affected synthetic curves).
2019-12-14 12:14 (UTC) 3.8.9.3
DisplayCAL 3.8.9.3
Fixed in this release:
[Cosmetic][UI] Improve PCS to device gamut outline plot.
[Blocker] Linux, macOS: Fix failure to launch if initial install (regression of lockfile change in 3.8.9.2)
2019-12-12 22:33 (UTC) 3.8.9.2
DisplayCAL 3.8.9.2
Fixed in this release:
[Minor] When previous instance was force quit, override leftover lockfile.
[Trivial] When using a custom profiling testchart with very few or no dark RGB gray patches, try to better maintain slope of existing points during shaper curve generation.
2019-12-08 01:19 (UTC) 3.8.9.1
DisplayCAL 3.8.9.1
Fixed in this release:
[Moderate] Fix SpyderX calibration issue when using 32-bit ArgyllCMS executables.
2019-12-07 16:21 (UTC) 3.8.9
DisplayCAL 3.8.9
Changed in this release:
[Enhancement] Show the instrument serial number (if available) when prompting to physically interact with the instrument.
[Enhancement] Check SpyderX dark offset calibration and abort if it is too high (user error).
[Enhancement] Adjust perceptual device to PCS table black point to match perceptual PCS to device table.
[Enhancement] Warn during automatic output levels detection if the display device input range or graphics driver output range look to be misconfigured.
[Enhancement] Profile loader (Windows): Use an alternate method to enforce single instance if local IPC is blocked.
Tone response curve plot now uses the illuminant-relative profile whitepoint instead of D50 for input values if using absolute colorimetric intent.
Rename “LG OLED” (.dcl) 3D LUT format to “DeviceControl” and unlock available resolutions.
Fixed in this release:
[Trivial] Reload current calibration when cancelling profile installation (regression of a change to profile installation dialog handling in DisplayCAL 3.8.8, SVN revision r6252).
[Trivial] When loading settings from a profile, restore unused CIECAM02 viewing conditions (if applicable).
[Trivial] Prevent potential double prompt for instrument calibration.
[Cosmetic] Do not re-use logfiles for standalone tools as long as other instances are still running.
[Moderate] Linux: Failure to launch with pre-release versions of wxPython 4.
2019-11-07 21:16 (UTC) 3.8.8.1
DisplayCAL 3.8.8.1
Fixed in this release:
[Moderate] Linux: Work-around failure to launch if wxPython 3.0 / wxWidgets 3.0 release number do not match (using wxPython 3.0 is deprecated).
2019-11-06 23:12 (UTC) 3.8.8
DisplayCAL 3.8.8
Changed in this release:
[Enhancement] Detect and warn about malformed colorimeter corrections (e.g. from non-official sources). Move them to the trash automatically if they were previously (manually) installed.
[Enhancement] Always enumerate instruments on application startup if more than one instrument was detected the last time the application was used (cross-platform consistency).
[Enhancement] When prompting for instrument calibration, display the just now detected instrument name instead of the previously enumerated name (the latter might be stale if you forgot to refresh after changing connected instruments).
[Enhancement] Use a slightly improved smoothing method when creating high resolution PCS to device tables.
[Enhancement] Increase automatic PCS to device table resolution for L*a*b* LUT profiles to 45x45x45 if using smoothing.
[Enhancement][UI] Only auto-close profile/3D LUT installation dialog after a successful installation.
[Enhancement] Don't auto-close madTPG after 3D LUT installation.
[Enhancement] macOS: Warn if a black luminance calibration target is set.
[Enhancement] Profile loader (Windows): Use a minimally faster method to check for other running applications.
Fixed in this release:
[Minor] madVR 3D LUT generation: Always write D65 white to 3D LUT input primaries metadata so madVR does not attempt to correct whitepoint differences on its own when using a custom whitepoint (the 3D LUT itself will map the custom whitepoint correctly).
[Minor] madVR 3D LUT installation: Don't attempt to install 3D LUTs with unsupported input primaries metadata (i.e. not Rec. 709, SMPTE C, EBU/PAL, Rec. 2020 or DCI P3) as madVR will overwrite the metadata depending on the 3D LUT install slot. Such 3D LUTs should only be assigned manually in madVR instead.
[Trivial][UI] When loading settings, always enable the 3D LUT tab if the display is virtual (consistent with display selection behavior).
[Trivial] Also apply black point correction when creating a matrix profile without black point compensation (consistency).
[Trivial] Do not create swapped matrix fallback tags for XYZ LUT profiles when using the alternate forward profiler and the used ArgyllCMS version is >= 2.1 (be consistent with ArgyllCMS).
[Trivial] madVR 3D LUT generation: Accept negative values for input primaries metadata.
[Trivial] madVR 3D LUT installation (Linux, macOS): Send the 3D LUT in chunks and increase the timeout to prevent the installation failing over a slow network (e.g. WiFi).
[Cosmetic][UI] Profile loader (Windows): Prevent a stale tray icon remaining (until mouse over) in some rare cases after exiting the profile loader.
[Trivial][UI] Profile information (Linux): When using wxPython 3.0 instead of 4.0, clicking the sash would throw an error (using wxPython 3.0 is deprecated).
[Trivial] macOS: Only automatically re-enable black point compensation if restoring defaults or loading a non-3D-LUT preset.
[Trivial] Profile loader (Windows): Work-around two instances of the profile loader being started after powering on the system if fast startup was enabled in Windows power settings.
2019-09-22 13:23 (UTC) 3.8.7
DisplayCAL 3.8.7
Changed in this release:
[Enhancement] macOS: Automatically enable not using the video card gamma table to apply calibration during characterization measurements if using limited range (16..235). This should mitigate issues with older graphics chipsets and/or macOS versions that use the wrong output range internally when connected to some monitors that expect to receive limited range signals.
[Enhancement] Profile loader (Windows): A scheduled task now restarts the profile loader after resume from standby/hibernation as well as daily at 04:00 AM (whichever comes first), to mitigate the Windows GDI SetDeviceGammaRamp API leaking memory since Windows 10 1903.
Fixed in this release:
[Trivial] Don't automatically disable interactive display adjustment when setting calibration tone curve to “As measured” (unintended behavioral change introduced in DisplayCAL 3.8.6, SVN revision r6194).
[Minor] Linux (GNOME on Wayland): Latency incurred by a large measurement window size was not accounted for, introducing the possibility of measurements failing due to loss of synchronization.
[Minor] Linux (GNOME on Wayland): Limited range (16..235) support.
[Cosmetic][UI] macOS: Get rid of brief profile installation dialog flicker after installation.
2019-09-06 10:23 (UTC) 3.8.6
DisplayCAL 3.8.6
Changed in this release:
[Enhancement] If the graphics drivers or hardware do not support loadable gamma ramps or calibration, show a more descriptive error message.
[Enhancement] Increase the timeout for display & instrument detection during application startup from 10 to 20 seconds, to allow for slow opening of legacy serial ports.
[Enhancement] Windows 10 1903: Always do instrument detection during application startup if more than one instrument was connected the last time the application was used, as the list of instruments is not guaranteed to be consistent between sessions under 1903.
[Enhancement] Profile loader (Windows): Apply smoothing to calibration if the quantization bitdepth is set to 8.
[Enhancement] Profile loader (Windows): No longer require running elevated to be able to detect changes in the display configuration under Windows 10 1903.
Fixed in this release:
[Minor] Do not attempt to access properties of non-existent objects if a subprocess is not succesfully terminated after reaching a timeout during display & instrument detection at application startup (unexpected failure).
[Trivial][UI] Disable the profile installation button if no displays have been detected.
[Trivial][UI] Disable the measurement report menu item if no instruments have been detected.
[Trivial] Profile loader (Windows): Work around Windows 10 1903 handle leaks in Windows Color System APIs.
2019-08-14 13:06 (UTC) 3.8.5
DisplayCAL 3.8.5
Changed in this release:
[Enhancement] macOS: Use caffeinate to prevent display sleep and screensaver.
Fixed in this release:
[Moderate] DisplayCAL 3.8.4 broke video levels (16..235) output encoding/decoding for video card gamma table tags (profiles using calibration with video output levels created by 3.8.4 can be fixed by re-creating via menu “File”, “Create profile from measurement data...” and selecting the existing profile).
2019-08-10 21:17 (UTC) 3.8.4
DisplayCAL 3.8.4
Changed in this release:
[Enhancement] Do early detection of highly non-monotonic luminance responses when doing on-the-fly generation of the preconditioning profile for auto-optimized testcharts with 425 or more patches.
[Enhancement] Always create a single shaper curve for the fallback matrix tags of cLUT profiles with nonlinear calibration.
[Enhancement] Profile loader (Windows): Only try to restore profile associations on exit if they had to be fixed on launch to begin with.
Fixed in this release:
[Minor] Work-around Argyll applycal bug with gamma value TRC curve tags in profiles (fixes generating HDR 3D LUTs from display profiles with such tags).
[Trivial][UI] Windows with display scaling above 100% (HiDPI): Prevent occasional text cutoff/wrapping issues on dialog messages by adding one pixel to the minimum width of the message text area (wxWidgets bug).
2019-07-02 21:00 (UTC) 3.8.3
DisplayCAL 3.8.3
Changed in this release:
Profile loader (Windows): Work around Windows 10 1903 (May 2019 update) severe banding bug and automatically disable Microsoft Windows Color System Calibration Loader task. Logging out and back in is required, and may be required each time a display's default associated profile is changed.
Fixed in this release:
[Minor] Verification: Prevent unintended mixing of unicode and binary strings when a device link profile is used.
[Cosmetic][UI] Linux (KDE): Centering the measurement window would increase its size slightly and resetting its size would move the window down and right (regression of SVN revision r6137).
2019-06-09 15:18 (UTC) 3.8.2
DisplayCAL 3.8.2
Changed in this release:
[Enhancement] Always try to skip initial colorimeter calibration for uniformity measurements (e.g. SpyderX).
[Enhancement] Linux: Use GObject Introspection for DBus access (if available).
[Enhancement] Linux: Use a default timeout of 500 ms for DBus calls.
[Enhancement] Profile loader (Windows): If registry access to the display configuration fails (e.g. due to running non-elevated), log a warning only once.
Windows: Only log Windows exceptions that are actually errors.
Fixed in this release:
[Minor] If invoked from the main application's “Tools” menu, the synthetic ICC profile creator HDR configuration could affect the main application's 3D LUT HDR configuration.
[Minor] Successive requested instrument calibration during uniformity measurements did not wait for the calibration to complete before continuing (e.g. SpyderX).
[Trivial] Prevent potential blocking of socket binding if a previous instance exited unexpectedly.
[Trivial][UI] Change parent inheritance for pathdialog wrappers so interacting with the parent is appropriately prevented when the wrapper dialog is shown via a scripting request.
[Trivial][UI] Linux: Always prefer the global DPI value (Xft.dpi) for HiDPI scaling with wxGTK2.
[Trivial][UI] Windows: Work-around wxPython Phoenix bug: Destroying a frame loaded from XRC affects subsequently loaded XRC resources (leading to instantiated controls being of the wrong type and failing initialization due to not having the expected interfaces).
2019-05-24 01:13 (UTC) 3.8.1.1
DisplayCAL 3.8.1.1
Fixed in this release:
[Minor][UI] Linux: Some custom widgets could have a size of zero with wxGTK2 under non-KDE desktop environments when org.gnome.desktop.interface scaling-factor was set to 0 (regression of a change in DisplayCAL 3.8.1, SVN revision r5979).
[Minor][UI] Linux: No scaling for some custom widgets with wxGTK2 and HiDPI unless org.gnome.desktop.interface scaling-factor was set to a value of 2 or higher (regression of a change in DisplayCAL 3.8.1, SVN revision r6005). HiDPI scaling with wxGTK2 under X11 is now handled entirely by the global DPI value (Xft.dpi).
[Minor][UI] Linux: Too small size for the contents of some custom widgets with wxGTK2 and HiDPI.
[Cosmetic][UI] Linux: Too much padding inside some custom widgets with wxGTK2 and HiDPI.
[Cosmetic][UI] Linux: Occasional glitchy window sizing under Wayland.
[Cosmetic][UI] Linux: Added workaround for double window decorations when the environment variable GTK_CSD is set to a nonzero value under X11 (e.g. elementary OS Juno with Phanteon desktop).
2019-05-18 15:11 (UTC) 3.8.1
DisplayCAL 3.8.1
Added in this release:
[Feature] Linux: Preliminary experimental Wayland support under GNOME 3 using colord (requires ArgyllCMS 2.1 or newer as well). Caveats do apply:
Window placement and ordering is completely up to the compositor under Wayland. There is generally no way for an application to place its own windows at specific relative locations or z-orders. As a result of this, the measurement window cannot stay always on top or be automatically centered. Extra care needs to be taken that other windows are not placed on top.
Video card gamma table (videoLUT) access is handled by colord. Some functions like viewing current videoLUT contents may not be available.
The measurement window color depth is limited to 8 bits per channel per pixel (but dithering is used to achieve a higher effective color depth).
The measurement window may be subject to desktop-wide color management in upcoming versions of Wayland (although the display device is inhibited during measurements via the org.freedesktop.ColorManager.Device D-Bus API which should prevent this, and as a fallback a linear calibration sRGB profile is temporarily installed during measurements if the D-BUs API is unavailable, which should result in an identity transform, i.e. effectively no color management, as well as linear video card gamma tables).
Application support for color management under Wayland via colord still seems to lacking (although the list may well be out-of-date).
Only tested under GNOME 3 (Fedora 30, Ubuntu 19.04). Support for other desktop environments will need to be implemented separately until Wayland gains a color management and calibration/profiling protocol.
[Feature] LG OLED 3D LUT format.
Changed in this release:
[Enhancement] If the currently used ArgyllCMS version is not a standard version, but also not a beta, do not offer to switch to an installed official stable version if it's otherwise the same version number.
[Enhancement] Include Quantum Dot LED (Samsung QLED Q9F) spectral sample colorimeter correction when importing for i1 Display Pro and ColorMunki Display (sourced from community colorimeter corrections database).
[UI] Linux (Debian, Fedora, Ubuntu): Use wxPython Phoenix if installed.
Prisma, Resolve: Set pattern generator background color to pattern color if using fullscreen patterns.
Fixed in this release:
[Moderate] UnicodeDecodeError when a CCSS file contains unicode characters in the display device description (regression of a change in DisplayCAL 3.8 to use localized technology descriptions, SVN revision r5810).
[Minor] APL calculation for Prisma and Resolve pattern generators was off by a few percent depending on pattern area and current pattern color.
[Minor] Quick reporting on calibrated or uncalibrated display did not try to detect output levels if set to “Auto”.
[Trivial] More gracefully deal with faulty tags in ICC profiles (fixes ICC profile information unhandled exception for colord-created profiles with malformed targ tags).
[Trivial][UI] Correctly update the audio button state on progress dialogs when changed on a previous window.
[Cosmetic][UI] Various minor potential rendering glitches.
[Cosmetic][UI] macOS (standalone application bundle): Splash screen did not animate.
[Cosmetic][UI] Linux: Add work-arounds for various Wayland-related wxPython rendering quirks and bugs (e.g. spacing around windows, popup menu placement).
[Trivial] Linux: Try to work around sporadic colord profile installation quirks (“The profile was not added in time”).
Phasing out 0install support. While the 0install version of DisplayCAL (which was originally introduced as a replacement for the long-defunct Autopackage system under Linux) has had its uses, the low distribution (around 6%) of 0install versus the standalone version does no longer warrant the additional time and work needed to maintain this separate deployment path.
0install support is thus being phased out starting with DisplayCAL 3.7.2 and following releases, which are only available as “standalone” installations. Windows and macOS users will be updated automatically to the standalone version. Linux users should switch to a standalone package at their earliest convenience.
There will be a transition period of a few months during which old 0install-based DisplayCAL versions will continue to run, but afterwards the respective online infrastructure will be decommissioned.
2019-04-26 01:17 (UTC) 3.8
DisplayCAL 3.8
Added in this release:
[Feature]SpyderX support (requires ArgyllCMS 2.1.0 or newer, use ArgyllCMS 2.1.1 or newer to be able to skip instrument self-calibration).
[Feature]Colorimeter correction information with graph.
[Feature] Synthetic ICC profile creator: Drag & drop support for TI3 measurement files.
[Enhancement] Rudimentary support for hypothetical future instruments and their measurement modes (any new instrument support added to ArgyllCMS in the future should be fully usable in DisplayCAL right away without needing an update for instrument-specific measurement modes).
[Enhancement] Display technology information to aid in the choice of a suitable measurement mode or correction.
[Enhancement] Include some additional spectral sample colorimeter corrections when importing for i1 Display Pro and ColorMunki Display (e.g. MacBook Pro 2016 Retina with PFS Phosphor WLED “P3” display, LG OLED 6-series WOLED based on samples from LG C6 and E6 OLED TVs, sourced and combined from community colorimeter corrections database contributions).
[Enhancement] macOS: Automatically warn about incompatibilities of Apple software with calibration black point hue correction and profile types other than single curve + matrix with black point compensation.
Changed in this release:
[UI] Updated simplified chinese localization (thanks to Mars).
[UI] Updated french localization (thanks to Jean-Luc Coulon).
[Enhancement] Prefer colorimeter corrections from “ArgyllCMS” folder and ignore duplicate (spectral) colorimeter corrections from “color” folder (e.g. installed by HCFR under Windows).
[Enhancement] Default to high-resolution spectrum mode (if available) for spectrometers that support it.
[Enhancement] Implicitly try to skip repeat instrument self-calibration for colorimeters that want it if already done at least once per measurement run.
[Enhancement] Converted translation file format from JSON to YAML for better readability.
[Enhancement] Use a localized description for known quality spectral sample colorimeter corrections.
[Minor] Not all programmed measurement modes were enumerated for the K10-A colorimeter (regression of a change in DisplayCAL 3.7, SVN revision r5557).
[Minor] ColorHug/ColorHug2 “auto” measurement mode was not working anymore.
[Trivial] Curve viewer: Re-introduced being able to view the current contents of the video card gamma table if no display profile is set or the profile used does not contain calibration.
[Cosmetic] Curve viewer, profile information: Curve graphing identical channel detection was not working properly in some cases (only affected synthetic curves).
2019-03-17 18:36 (UTC) 3.7.2
DisplayCAL 3.7.2
Added in this release:
[UI] Russian and ukrainian localization (thanks to Alex Sikorsky).
Changed in this release:
[Enhancement] Apply black point correction/compensation to measurement data directly instead of device-to-PCS table (improves smoothness of profiles for displays with not very neutral black).
[Enhancement] Optimize single gamma curve without offset to single gamma value.
[Enhancement] Network: Get rid of gethostbyname usage because it can have a long delay.
[UI] Updated traditional chinese localization (thanks to 楊添明).
Fixed in this release:
[Minor] Fallback TRC tags were created using a wrong backward matrix when using ArgyllCMS 2.0.2b or newer.
[Trivial] When connecting to a pattern generator, closing the connection dialog should be equivalent to cancelling.
[Cosmetic][UI] Show a dialog while the UI is blocked when connecting to madTPG.
[Cosmetic][UI] Do not show the visual whitepoint editor fullscreen warning if using a pattern generator.
[Cosmetic][UI] Synthetic ICC creator: Set chromatic adaptation up/down arrow increment to 0.0001.
[Cosmetic][UI] Synthetic ICC creator: Hide (unused) hue & saturation controls for SMPTE 2084 hard clip.
2019-01-24 14:44 (UTC) 3.7.1.4
DisplayCAL 3.7.1.4
Changed in this release:
[Enhancement] Changed full field pattern insertion interval and duration granularity to 0.1 seconds.
[Enhancement] Store and read full field pattern insertion parameters from profile.
[Enhancement] madVR (Windows): Search on the network before trying to start a local madTPG instance.
Fixed in this release:
[Minor] Full field pattern insertion should not run during display update delay measurements and requires an extra delay after being shown.
[cosmetic][UI] Include full field pattern insertion in estimated measurement time calculation.
[Minor] Profile loader (Windows): Undefined variable under legacy versions of Windows (i.e. XP) when selecting the profile associations popup menu item.
2018-12-03 00:48 (UTC) 3.7.1.3
DisplayCAL 3.7.1.3
Changed in this release:
[Cosmetic][UI] Show ColorMunki spectrometer as “ColorMunki Design/Photo, i1Studio” in instrument dropdown for better differentiation from “ColorMunki Display” and “ColorMunki Smile” colorimeters.
Fixed in this release:
[Minor]: UnicodeError when trying to access 3rd-party ICC v4 profiles MultiLocalizedUnicodeType tags with non-US/UK country code(s) for english language.
[Minor] Profile loader (Windows): Work-around an incompatibility with Wacom tablets (tray icon right-click popup menu didn't work).
[Minor] macOS: Creating a colorimeter correction didn't work if the display manufacturer couldn't be determined automatically (regression of autocomplete change in DisplayCAL 3.7 due to undocumented wxPython incompatibility).
2018-11-14 20:19 (UTC) 3.7.1.2
DisplayCAL 3.7.1.2
Fixed in this release:
[Regression] Linux: Display enumeration didn't work correctly due to 3.7.1 full field pattern insertion change for ArgyllCMS 2.0.2b.
2018-11-02 15:50 (UTC) 3.7.1.1
DisplayCAL 3.7.1.1
Fixed in this release:
[Moderate] macOS: Potential startup problem introduced by 3.7 splash screen changes.
2018-11-01 22:30 (UTC) 3.7.1
DisplayCAL 3.7.1
Changed in this release:
[Enhancement] Measurement report: Updated Fogra Media Wedge V3 evaluation criteria to ISO 12647-7:2016 version of the standard (use ΔE*00 and ΔCh for CMY gray).
[Enhancement] Measurement report: Moved ΔICtCp to general evaluation criteria so it can be shown in the additional statistics for all available criteria.
[Enhancement] Updated simplified chinese translation (thanks to Mars).
[Enhancement] Full field pattern insertion: Support the latest ArgyllCMS 2.0.2 Beta development code.
[Enhancement][UI] Consistency: When changing the verification chart, set the simulate whitepoint relative to display profile whitepoint option according to the simulation profile (just as when changing the simuation profile itself) and don't reset the simulate whitepoint option when changing the simulation profile.
[Cosmetic] Automatically fall back to the default verification chart if the selected one no longer exists (due to the chart file having been moved or deleted).
[Cosmetic] Detect highly non-monotonic luminance responses when creating shaper curves (intended to let creating a profile from highly non-monotonic measurements fail just as before, but with a nicer, more descriptive error message instead of the raw exception from the underlying fitting function).
[Cosmetic] When creating a profile fails and results in an error dialog, do not show the superfluous additional “profiling not finished” message.
Fixed in this release:
[Minor] Restored the ability to create colorimeter corrections for virtual displays, which was accidentally removed in DisplayCAL 3.7.
[Trivial] madVR (Linux, macOS): Querying the madVR configured black & white level didn't work via the madVR network protocol.
[Cosmetic] madVR (Linux, macOS, Windows when using pattern insertion): Prevent lingering madTPG OSD messages.
[Cosmetic][UI] macOS: Incorrect rendering of splash screen under macOS 10.14 Mojave.
2018-10-10 22:04 (UTC) 3.7
DisplayCAL 3.7
Added in this release:
[Feature] Full field pattern insertion option for selected pattern generators (madTPG*, Prisma and Resolve).
*madTPG on Windows requires using a modified version of ArgyllCMS.
[Feature] Chromatic adaptation control for the synthetic ICC profile creator.
Resolve HDR 3D LUT preset (SMPTE 2084 hard clip, no tonemapping).
Changed in this release:
[Enhancement] Show a column with the spectral resolution and range of the reference measurements when listing colorimeter corrections from the online database (if available).
[Enhancement] Improved support for (3rd party) profiles with chromatic adaptation transforms other than Bradford, e.g. for use as 3D LUT source profiles.
[Enhancement] Early abort when cancelling video level detection measurements.
[Enhancement] Early abort if connecting to madTPG fails.
[Enhancement] Updated simplified chinese translation (thanks to Mars).
[Enhancement] If using madTPG and continuing from interactive adjustment to iterative grayscale calibration, wait three seconds after switching to fullscreen and exclusive fullscreen respectively, to give the display time to complete the switch, before commencing measurements.
[Enhancement] Show messages from instrument related popup dialogs during measurements on the madTPG on-screen display as well.
Hue preservation less than 100% for HDR SMPTE 2084 3D LUTs with roll-off tonemapping now only affects red-orange/orange/amber hues (i.e. match madVR's “color tweaks for fire & explosions”).
[Enhancement] Verification: Before attempting to create a measurement report, automatically check the PCS to device table resolution for LUT profiles if necessary and warn about low resolution tables.
[Enhancement] 3D LUT verification: When using a different whitepoint target for a 3D LUT, use the altered source profile as simulation profile for verification.
[Enhancement] 3D LUT verification: When creating a self check report, automatically use the device link profile.
[Enhancement] Measurement report: Show weighted ΔL, ΔC and ΔH for ΔE*94 and ΔE*00.
[Enhancement] Measurement report: Signed values for ΔL*76, ΔL*94, ΔC*76 and ΔC*94 are now always relative to the nominal values (match ΔE*00 and ΔICtCp).
[Enhancement] Measurement report: Measured vs display profile whitepoint is now a purely informational statistic, no longer a pass criteria.
[UI] When creating a colorimeter correction, allow selecting a display manufacturer via autocomplete if not set.
[UI][Cosmetic] Minor UI spacing adjustments.
[Cosmetic] For HDR 3D LUTs with SMPTE 2084 (hard clip) tone curve, set the mastering display peak luminance in the simulation profile description to the target peak.
[Enhancement] macOS: For iMacs, use the model identifier as display description.
Fixed in this release:
[Minor] Interpolation between clipping and roll-off for HDR 3D LUTs with SMPTE 2084 tone curve was not as smooth as intended with mastering display peak luminance below 10000 cd/m² or just above target peak.
[Minor] HDR 3D LUTs with SMPTE 2084 (hard clip) tone curve did reproduce slightly too low luminance in a limited region below the chosen target peak.
[Minor] Verification controls were not being initialized if loading settings before switching to the verification tab.
[Trivial] Also update verification tone curve controls if a matrix profile with non-identical shaper curves is selected as simulation profile.
[Trivial] Make eeColor to madVR converter exit cleanly when receiving SIGBREAK.
[Trivial] Correctly escape/unescape quotes in CGATS.
[Trivial] Reset enumerated measurement modes when changing Argyll version.
[Trivial] Do not automatically disable interactive display adjustment after visual whitepoint editor measurement.
[Trivial] When using madTPG, restore fullscreen and OSD button states when continuing on to calibration after interactive adjustment.
[Trivial] madTPG did not automatically enter fullscreen if enabled when skipping interactive display adjustment and detecting video levels.
[Trivial] Only show the place instrument on screen countdown in madTPG if we don't temporarily leave fullscreen for interactive adjustment during calibration anyway.
[Trivial] Always force HDR 3D LUT SMPTE 2084 mastering display peak luminance to be greater than or equal to target peak luminance.
[Cosmetic] Do not show HDR 3D LUT tone mapping hue/saturation controls for SMPTE 2084 (hard clip).
[Minor] Measurement report: Measured vs assumed/profile whitepoint delta ICtCp should always be referenced to assumed/profile whitepoint.
[Minor] Measurement report: Using absolute values without display profile whitepoint as reference in ICtCp mode referenced the values to D50 instead of the natural ICtCp whitepoint of D65.
[Cosmetic] Measurement report: RGB color comparison swatches when using absolute values and display profile whitepoint as reference were not referenced to chosen whitepoint.
[Trivial] Profile information: Whitepoint delta E to locus should always be referenced to locus, not D50.
[Cosmetic] Profile information: Use correct axis labels for DIN99b 2D gamut plot.
[Minor] Standalone 3D LUT maker: Unmatched Thaw() call when setting abstract profile.
[Minor] Linux, macOS: When connecting to madTPG, don't send 'bye' commands when closing duplicate connections so madTPG doesn't close the main connection prematurely.
[Trivial] Linux with wxPython Phoenix, Windows: Menu item labels in submenus weren't updated until restarting the application after switching to a different language.
[Trivial] Profile loader (Windows): Use Unicode APIs for creating the popup menu items, so that they are displayed correctly regardless of Windows codepage (makes non-western languages display correctly on western versions of Windows).
[Trivial] Windows: Restore compatibility of measurement report with MSIE 11.
[Cosmetic] macOS: When creating a colorimeter correction for a MacBook, correctly unescape backslashes in the automatically filled description.
2018-08-25 14:03 (UTC) 3.6.2
DisplayCAL 3.6.2
Added in this release:
[Feature] Measurement report: ICtCp and ΔICtCp color distance metric.
Changed in this release:
[Enhancement] Show report type in self check report.
[Enhancement] Add actual display profile description to self check report if a simulation profile is used as display profile.
[Enhancement] Use the same method to create HDR 3D LUTs whether the display profile is cLUT or matrix based.
[Enhancement] Verification: Do not automatically enable “Simulate whitepoint relative to display profile whitepoint” if the verification chart does not contain L*a*b* reference data.
[Enhancement] Measurement and self check report: Only automatically enable the use of absolute values when simulating the reference whitepoint if no simulation profile was used.
[Enhancement] macOS: On Apple computers with integrated displays (i.e. iMac/MacBook), use the model identifier (e.g. “MacBookPro15,2”) instead of the generic “Color LCD” as display name and add the model description (e.g. “MacBook Pro (Mid 2018)”) when creating colorimeter corrections, to ease identification.
Fixed in this release:
[Minor] 3D LUT/verification with a display profile that has a black level of zero, but embedded characterization data black level above zero: Black offset also needs to be applied if not using BT.1886 for correct results.
[Minor] When generating high resolution PCS to device tables during HDR 3D LUT creation, use the configured resolution even if low quality PCS to device tables were generated when creating the profile.
2018-08-07 16:14 (UTC) 3.6.1.1
DisplayCAL 3.6.1.1
Fixed in this release:
[Minor] Linux: Don't call setlocale() unconditionally, and restore previous locale (fixes build under non-english locales, regression of XDG changes in DisplayCAL 3.6.1, SVN revision 5457 and up).
2018-08-06 13:57 (UTC) 3.6.1
DisplayCAL 3.6.1
Added in this release:
[Feature] Adjustable hue preservation (values less than 100% will gradually hue shift very bright and saturated red-orange/orange/yellow-green hues to a more yellowish tone, preserving more saturation and detail) for HDR SMPTE 2084 3D LUTs with roll-off tonemapping (default 50%).
[Feature] Ability to set a calibration target luminance by measuring the ambient light level.
[Feature] Verification tab: Hold the “alt” key on your keyboard to create a profile or device link (3D LUT) self check report instead of a measurement report.
[Enhancement] DCI P3 D65 profile for use as 3D LUT source colorspace or measurement report simulation profile.
Changed in this release:
[Enhancement] Increased the default number of patches for the madVR HDR preset back to 425.
[Enhancement] HDR 3D LUT SMPTE 2084 tonemapping: Restored near black tone reproduction for displays with non-zero black level and output offset less than 100% to pre-v3.6 values.
[Enhancement] Improved HDR 3D LUT SMPTE 2084 tonemapping speed.
[Enhancement] Improved HDR 3D LUT accuracy for colorimetric rendering intents.
[Enhancement] Increased default display update delay for Resolve preset to 1000 ms.
[Enhancement] Quantize Autodesk/Kodak (.3dl) 3D LUT values by always rounding up (match the format specification in the Lustre user guide).
[Enhancement] Limit the number of concurrent worker processes depending on system memory to avoid swapping.
[Enhancement] Always normalize CGATS data to Y = 100 when processing files not created by DisplayCAL.
[Enhancement] Get the black level for computation of 3D LUT or verification target tone curves from the embedded characterization data if a lookup through the display profile returns zero (makes e.g. Rec. 1886 work properly in that case).
[Enhancement] Synthetic ICC profile creator: Increase number of decimal digits for black level to 6 and do not clamp to 16-bit integer values to offer more fine grained control.
[Enhancement] Linux: Use configured XDG “well known” user directories (currently only used to determine the localized name of the “Downloads” directory).
[UI] Moved HDR 3D LUT SMPTE 2084 tonemapping luminance/saturation/hue preservation controls to advanced options (hidden by default).
Fixed in this release:
[Moderate] madVR 3D LUT generation via the main application: When using a non-standard source colorspace whitepoint (by setting a calibration whitepoint target different from the source colorspace's original whitepoint, e.g. not using DCI white for DCI P3), non-standard values for input primaries and whitepoint were written to the 3D LUT header, madVR 3D LUT slot auto-detection for installation did not work if the source colorspace was not Rec. 709, and color conversion was affected if the 3D LUT was not installed via the madVR API (i.e. by not clicking the “Install 3D LUT” button, but choosing the 3D LUT manually in madVR's settings).
[Minor] Downloads within DisplayCAL failed if the download directory didn't exist (regression of changes made in DisplayCAL 3.5, SVN revision 5081).
[Minor] HDR 3D LUT SMPTE 2084 tonemapping for non-Rec. 2020 source colorspaces did not work correctly (Rec. 2020 was assumed despite different choice).
[Minor] Standalone 3D LUT maker: Don't unexpectedly switch to the source profile's gamma for simple gamma + matrix source profiles (e.g. DCI P3) when creating a 3D LUT.
[Minor] Profile loader (Windows): Catch errors in case of a corrupted Windows registry.
2018-06-21 22:06 (UTC) 3.6
DisplayCAL 3.6
Added in this release:
[Feature] Adjustable weighting between luminance and saturation preservation for HDR SMPTE 2084 3D LUTs with roll-off tonemapping.
[Feature] Option to adjust the roll-off for HDR SMPTE 2084 3D LUTs with roll-off tonemapping when the mastering display peak luminance is below 10000 cd/m² (previous behavior with the introduction of BT.2390-2 was to always adjust, the new default behavior is don't adjust).
Changed in this release:
[Enhancement] Improved HDR 3D LUT SMPTE 2084 roll-off tonemapping to eliminate possible over-darkening in rolled-off highlights due to luminance reduction related effects.
[Enhancement] Removed HDR 3D LUT SMPTE 2084 roll-off tonemapping allowance for hue shifts in rolled-off highlights.
[Enhancement] Use extended model for HDR 3D LUT Hybrid-Log Gamma (HLG) display gamma adjustment described in BT.2390-4.
[Enhancement] Do not create PCS-to-device tables for synthetic HDR SMPTE 2084 profiles with roll-off tonemapping as they are meant purely as source profiles.
[Enhancement] Only enable the visual whitepoint editor button if the whitepoint target is set to chromaticity coordinates.
[UI] Keep dropdowns with only one choice enabled.
[Cosmetic] Catch any madTPG connection errors to show a nicer error dialog without a traceback.
[Trivial] Do not update the profile description when increasing the effective resolution of an existing profile's PCS-to-device tables.
[Trivial] Testchart editor: Only limit the view to six decimal digits, not the underlying data.
Fixed in this release:
[Minor] Confirm instrument placement when madTPG is not fullscreen.
[Minor] Creating synthetic grayscale profiles with HLG tone response did not work correctly.
[Trivial] Set allowed filetypes for selecting files when importing 3rd party software colorimeter corrections to “any”.
[Trivial] Mac OS X: Updated bundled Python to 2.7.15 which includes a recent version of OpenSSL (fixes SSL connection errors due to more recent server-side encryption when using the standalone application bundles).
[Trivial] Mac OS X: Restored correct BundleId for application bundles.
[UI] Linux (GTK3 under Wayland): Explicit refresh/update needed for ClientDC (fixes graphs not updating until the window is resized).
2018-04-25 13:30 (UTC) 3.5.3
DisplayCAL 3.5.3
Added in this release:
[Feature] Rudimentary ICCv4 profile autoconversion support (only matrix profile types).
[Enhancement] Lookup table based test profiles for evaluating display color management.
[Enhancement] Profile information: Ability to plot CMYK profile tone response curves.
Linux: Temporarily restored compatibility with wxPython 2.8.11/12 to support older distribution LTS releases that have not yet reached end-of-life. Note that this compatibility will not be maintained indefinitely, and will likely end by no later than April 2019. If you cannot update to a newer wxPython version on your current Linux distribution, consider upgrading your distribution to the latest release if possible.
Fixed in this release:
[Minor] Restored ability to create profiles from non RGB device measurement files.
[Minor] Profile information: Deal with potential NULL values in meta tags of 3rd party ICC profiles.
[Trivial] Profile information: Correctly parse non-default device media type attributes.
[Trivial] Profile information: Keep original tag order of 3rd party profiles when checking ID.
[Minor] Profile loader (Windows): Popup menu items stopped responding when used for a long time.
2018-03-31 21:11 (UTC) 3.5.2
DisplayCAL 3.5.2
Fixed in this release:
[Trivial] Prevent potential “service/proto not found” error due to unreliable system APIs when attempting to automatically download updates or vendor files.
[Trivial] Linux: Restore missing icons in the window switcher and panel under XFCE.
[Trivial] Linux: Add missing i1 Studio entry to bundled instrument configuration files (ArgyllCMS >= 2.0).
[Trivial] Windows: Use bundled certificate authority (CA) certificates to circumvent potentially outdated system certificates under older versions of Windows.
2018-03-16 16:04 (UTC) 3.5.1
DisplayCAL 3.5.1
Added in this release:
[Feature] Rudimentary support for WCS Color Device Model profiles (only description, author, white- & blackpoint, gamma, parametric curve, and matrix tags are recognized and mapped to appropriate ICCv2 types).
Changed in this release:
[UI] Updated traditional chinese localization (thanks to 楊添明).
[Enhancement] Update bundled vendor PNP ID database.
[Enhancement] Linux: Use SDL (Simple DirectMedia Layer) directly.
Fixed in this release:
[Minor] Work around Python issue #738361 (shell pattern compilation fails raising an unhandled exception if a path contains certain combinations of meta characters).
[Minor] Measurement report: Deal with quantization when creating the report (fixes error when using video output levels in combination with some display profiles).
[Minor] Profile loader (Windows): Display a proper error message when associating an invalid profile.
[Minor] Profile loader (Windows): In case of an invalid profile (e.g. damaged file), fall back to linear gamma ramps instead of using the previously cached ramps and change the tray icon to reflect this.
[Minor] Profile loader (Windows): Ignore potential stray WM_COMMAND messages caused by 3rd party application interference.
[Minor] Bump minimum required wxPython version to 3.0 (fixes a compatibility problem under Linux if wxPython 2.8 was installed).
[Cosmetic] Refresh output levels control when loading settings.
2018-02-18 14:47 (UTC) 3.5
DisplayCAL 3.5
Added in this release:
[Feature] Support the madVR HDR 3D LUT installation API (madVR >= 0.92.13).
Changed in this release:
[Enhancement] In case of a download problem (e.g. automatic updates), offer to visit the download URL manually.
[Enhancement] Security: Check file hashes of application setup and portable archive downloads when updating DisplayCAL or ArgyllCMS.
[Enhancement] Security: Use HTTPS for ArgyllCMS download as well.
[UI] New application icons and slightly refreshed theme.
[UI] Improved HiDPI support by adjusting relative dialog button spacing, margins, and interactive display adjustment window gauge sizes to match proportionally regardless of DPI.
[UI] Improved visual consistency of tab buttons (don't lose “selected” state if clicking on a button and then moving the mouse outside of it, “hover” state does no longer override “selected” state, keyboard navigation skips over selected button).
[Cosmetic] Measurement report: Make patch preview take into account the “Use absolute values” option again.
[Cosmetic] Measurement report: Colorize CCT graph points according to change in hue and chroma.
[Cosmetic] Measurement report: Colorize gamma graph points according to change in gamma.
[Cosmetic] Measurement report: Make RGB balance graph match HCFR (Rec. 709 only). Note that new and old balance graphs are only comparable to a limited extent (use “Update measurement or uniformity report” in the “Tools” menu to update existing reports).
[Cosmetic] Profile loader (Windows): Unset non belonging profile when resetting a profile association.
Mac OS X: Set default profile type to single curve + matrix with black point compensation due to long-standing Mac OS X bugs with any other profile type.
Fixed in this release:
[Moderate] Unhandled exception and UI freeze when the 3D LUT format was set to madVR and there never was a prior version of ArgyllCMS on the system or the previous version was older than or equal to 1.6.3 during that same DisplayCAL session, due to a missing capability check.
[Moderate] Division by zero when trying to create a SMPTE 2084 HDR 3D LUT if the profile black level was zero (regression of a change in DisplayCAL 3.4, SVN revision r4896).
[Minor] If using the alternate forward profiler and the profile type was XYZ LUT + swapped matrix, the swapped matrix was overwritten with an accurate one (regression introduced in DisplayCAL 3.3.4, SVN revision r4736).
[Minor] It was not possible to run a measurement report with a simulation profile set as display profile, but no profile assigned to the actual display.
[Minor] Rec. 1886 measurement report with originally non Rec. 709 tone response profile: Make sure to override the original tone response of the profile so Rec. 1886 gives the expected result.
[Minor] If a measurement report HTML file was mangled by another application that removed the XML self-closing tags forward slashes, it was not possible to correctly update the report using “Update measurement or uniformity report” from the “Tools” menu.
[Minor] If using a pattern generator, check it is valid before binding a disconnect-on-close event when using the visual whitepoint editor. Prevents an attribute error when using the visual whitepoint editor and the madTPG network implementation (i.e. under Mac OS X).
[Minor] Windows: Always use the active display device directly when querying or setting profiles instead of mimicking applications using the Windows GetICMProfile API (fixes getting the correct profile with display configurations consisting of three or more displays where some of them are deactivated).
[Minor] Profile loader (Windows): Check whether or not a display device is attached to multiple adapters and disable fixing profile associations in that case.
[Minor] Profile loader (Windows): Work-around hitching caused by Windows WcsGetDefaultColorProfile API call on some systems.
[UI] Measurement window: Make sure focus stays on the last focused control when the window itself gains focus again after losing focus.
[UI] Synthetic ICC Profile Creator: Update HDR SMPTE 2084 diffuse white info text when changing luminance.
[Trivial] HDR SMPTE 2084 3D LUT: Interpolate the last two segments before the clipping point of the intermediate input LUT shaper curves (prevents potential slight banding in highlights).
[Trivial] Windows: Make sure the profile loader is launched directly after installing a profile when using a portable version of DisplayCAL (parity with installer version).
[Trivial] Profile loader (Windows): Re-introduce --skip command line option.
[Cosmetic] Profile loader (Windows): When disassociating a profile from a device, suppress ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE error sometimes (in some cases always?) resulting from the WcsDisassociateColorProfileFromDevice Windows API call, even though the profile was successfully disassociated.
2017-12-30 14:16 (UTC) 3.4
DisplayCAL 3.4
Added in this release:
[Feature] HDR Hybrid Log-Gamma transfer function option for 3D LUTs.
[Feature] HDR verification testcharts.
[UI] Simplified chinese translation thanks to 林泽帆(Xpesir).
[Enhancement] Profile loader (Windows): Notifications (for 3rd party calibration/profiling software and user-defined exceptions) can be turned off.
Changed in this release:
[Enhancement] HDR 3D LUTs: SMPTE 2084 with roll-off now allows specifying the mastering display minimum and peak luminance which are used to adjust the roll-off start and clipping points (BT.2390-3).
[Enhancement] HDR 3D LUTs: Chroma compression is now done in Lpt color space, providing improved preservation of detail in compressed highlights.
[Enhancement]
Do not disable the measurement report button if the selected setting is a preset and a simulation profile is used as display profile with tone curve set to “Unchanged” (i.e. do not require selecting “<Current>” under settings to allow verifying the native device response against a selected simulation profile).
[Enhancement] Limit profile name length taking into account the full path of the final storage directory.
Changed the “Softproof” and “Video” presets to no longer intentionally swap red and green for the fallback matrix.
[UI][Cosmetic] Minor UI consistency changes.
[Enhancement] Linux: X11 root window _ICC_PROFILE_xxx atom enumeration for Xrandr now matches the Xinerama order, so that _ICC_PROFILE_xxx atoms match irrespective of which extension applications are using. This improves conformance to the ICC Profiles in X Specification and matches the respective change in ArgyllCMS 2.0.
Mac OS X (standalone application): No longer support OS X versions prior to 10.6. This streamlines and slims the application bundle and allows using more recent 3rd party dependencies which are not available for older Mac OS X releases. If you still need support for Mac OS X 10.5, use the 0install version of DisplayCAL.
Fixed in this release:
[Critical] Ensure alternate forward profiler device to PCS table input curves are strictly monotonically increasing to prevent clipping resulting in peaks in the response in case of bad underlying (non-monotonic) device behavior (regression of a change in DisplayCAL 3.3.5, SVN revision r4838).
[Minor] Always force the first entry in PCS to device table input curves to zero when generating high resolution PCS to device tables (fixes potential unexpected non-zero RGB output for zero input to perceptual PCS to device table).
[UI][Cosmetic] When not confirming a manual DisplayCAL update but ArgyllCMS is up to date, reflect this in the final dialog message.
[Trivial] ReShade 3D LUT: If ReShade 3.x default shaders are installed, write the different parts of the 3D LUT to the correct respective sub-directories and no longer write the superfluous ReShade.fx.
[UI][Cosmetic] Linux: Prevent flickering of tab buttons on some systems when switching tabs.
[Moderate] Linux: The way display device enumeration was performed was not always guaranteed to give consistent results across the different available external device to profile mapping APIs, which could lead to wrong profile associations in multi-display configurations (this fix is required to match how ArgyllCMS 2.0 enumerates displays).
[Minor] Mac OS X (standalone application): Bundle certificate authority certificates to enable verifying server certificates (fixes not being able to automatically download updates).
[Minor] Windows: When creating a colorimeter correction from measurement file(s) stored in a path where one or more components(s) started with a number from 1-9 or the lowercase letter g, the operation failed and the created colorimeter correction had to be retrieved from the temporary directory manually.
[Minor] Profile loader (Windows): When manually disabling calibration loading via the pop-up menu, and then starting DisplayCAL (or another application detected by the profile loader) and closing it again, the profile loader would stay disabled, including the calibration loading related menu items, requiring a profile loader restart.
2017-10-18 17:34 (UTC) 3.3.5
DisplayCAL 3.3.5
Changed in this release:
[Enhancement] Updated french localization (thanks to Jean-Luc Coulon).
[Enhancement] When generating high resolution PCS to device tables for XYZ LUT profiles, round PCS candidate “fit” so a good match is not potentially needlessly discarded in favor of a match with lower effective usage of the available lookup table grid points (may speed up the process as well).
[Enhancement] Use single curve detection based on calibration accuracy for shaper tags of XYZ LUT profiles as well.
Fixed in this release:
[Minor] When enabling the Spyder2, check if the spyd2PLD.bin firmware has actually been successfully extracted (taking into account the install scope) and fall back to alternate methods when using automatic mode if the firmware cannot be extracted from the vendor software present in the local filesystem (fixes inability to enable the Spyder2 under Mac OS X if the vendor software is installed).
[Minor] Windows: Make measurement report filename safe for filesystem encoding (works around encoding quirks with certain locales).
[Minor] Windows: Windows silently strips any combination of trailing spaces and dots in file and folder names, so do the same for the profile name.
[Minor] Profile loader (Windows): WCS can return no profile without error in some situations, but the no error case wasn't accounted for, resulting in an unhandled exception in that case.
[Minor] Profile loader (Windows): Get the process identifier before enumerating windows to prevent an unhandled exception if a madVR instance is already running before starting the profile loader.
[Cosmetic] Profile loader (Windows): Detect if the current display profile video card gamma table tag contains linear calibration when checking if madVR did reset the video card gamma table to linear to prevent the profile loader alternating between enabled and disabled state if using windowed overlay in madVR.
2017-09-13 12:09 (UTC) 3.3.4.1
DisplayCAL 3.3.4.1
Fixed in this release:
[Moderate] Linux (profile installation and profile loading): Getting the fallback XrandR display device ID could unexpectedly return no result in some cases due to incorrect parsing, leading to potential application of a stale device to profile mapping or no profile at all (regression of a change in DisplayCAL 3.3.4, SVN revision r4800).
[Minor] Linux, Mac OS X: The visual whitepoint editor was failing to update the test pattern area of a connected madTPG instance when madVR was selected as display device, due to an implementation bug related to setting the background color.
2017-09-09 15:53 (UTC) 3.3.4
DisplayCAL 3.3.4
Added in this release:
Verification charts for ISO 14861:2015 soft proofing evaluation.
Changed in this release:
[Enhancement] More even and consistent CPU utilization on multi CPU/multi core systems during high resolution device-to-PCS table generation.
[Enhancement] Use an alternate way to generate the matrix for profiles created from the small testchart for matrix profiles (may improve accuracy on very linear displays) and use an optimized tone response curve if using a single curve and the measured response is a good match to an idealized parametric or standardized tone response curve.
[Enhancement] Uniformity report: No longer include (meaningless) correlated/closest color temperature. Use “traffic light” visual indicators in conjunction with unambiguous pass/fail messages to allow easy at-a-glance assessment of the results, and also include contrast ratio deviation to fully conform to ISO 12646:2015 and 14861:2015. You can update old reports via “Update measurement or uniformity report...” in the “Report” sub-menu of the “Tools” menu.
[Enhancement] Measurement report: Use the display profile whitepoint as reference white for the measured vs. profile white delta E calculation and use the assumed target whitepoint as reference white for the measured vs. assumed white delta E calculation to make the reported delta E more meaningful.
[Enhancement] Measurement report: Allow to use the display profile whitepoint as reference white when using absolute (not D50 adapted) values.
[Enhancement] Profile installation (Linux): Always do fallback colord profile installation using colormgr if available unless the ARGYLL_USE_COLORD environment variable is set.
[Enhancement] Profile loader (Linux): Include the profile source (colord or Argyll's UCMM) in diagnostic output and use the XrandR device ID as fallback when no EDID is available.
[Enhancement] Profile loader (Windows): Slightly improve encoding accuracy of quantizing to 8 < n < 16 bits.
[Trivial] Offer the complete range of input encodings for the eeColor 3D LUT format and do not force an identical output encoding.
[Trivial] Do not store calibration settings in a profile if calibration is disabled.
[Trivial] Revert the default profile type for the 79 patches auto-optimized testchart slider step to XYZ LUT + matrix.
[Trivial] Iridas cube 3D LUTs: Increase compatibility by stripping leading whitespace from text lines and adding DOMAIN_MIN/MAX keywords if missing.
[Trivial] Measurement report: Calculate true combined a*b* range for grayscale instead of summing separate ranges.
[Trivial] Measurement report: Automatically enable “Use absolute values” if using full whitepoint simulation (i.e. not relative to display profile whitepoint).
Fixed in this release:
[Moderate] When cancelling profiling measurements with the testchart set to “Auto”, the testchart UI and the internal test chart setting were no longer in sync until changing the profile type or restarting the application.
[Moderate] Synthetic ICC profile creator: Unhandled exception when trying to create DICOM (regression of a change in DisplayCAL 3.1.5, SVN revision r4020) or SMPTE 2084 profiles (regression of multiprocessing changes in DisplayCAL 3.3).
[Minor] Protect against potentially clipping slightly above black values during high resolution device-to-PCS table generation (regression of a change in DisplayCAL 3.3.3, SVN revision r4705).
[Minor] Protect against enumerating displays and ports in response to a DISPLAY_CHANGED event when the main window isn't shown or isn't enabled which could lead to a hang due to a race condition.
[Minor] Verification using a simulation profile that defines an identity matrix in its 'chad' tag (e.g. ISOnewspaperv4) did not work correctly due to the matrix being mapped to “None” insatead of “XYZ scaling”.
[Minor] Verification using a CMYK simulation profile failed with a “Profile invalid” error if previously “Use simulation profile as display profile” and “Device link profile” were enabled but no device link profile selected.
[Minor] Remove separate videoLUT access support under Windows and Mac OS X (separate videoLUT access is only supported under X11).
[Minor] Downloaded files were not renamed from their temporary name if the server did not return a Content-Length header (this typically only happens for text files, not binary files). Fixes not being able to import colorimeter corrections from iColor Display.
[Trivial] Do not reflect the black point hue in tone response curves of single curve + matrix profiles when not using black point compensation.
[Trivial] Measurement report: Additional stats median calculation index was off by n+1.
[Cosmetic] Display model name and manufacturer description tags were missing from profiles created using the alternate forward profiler.
[Cosmetic] Measurement report: Eliminate “Use absolute values” having a side-effect on the RGB patches preview.
[Cosmetic] Windows: When closing some of the standalone tools when minimized, e.g. by right-clicking the taskbar button and choosing “Close” from the menu, or by using the taskbar preview close button, the application did not close until restored from its minified state (i.e. by clicking on the taskbar button or switching to it with the task switcher).
2017-08-08 18:40 (UTC) 3.3.3
DisplayCAL 3.3.3
Added in this release:
Intermediate auto-optimized testchart step with 115 patches.
Changed in this release:
[UI][Cosmetic] Verification tab: Always show advanced tone response curve options when “Show advanced options” is enabled in the “Options” menu.
[UI][Trivial] Verification tab: Don't reset the simulation profile tone response curve choice unless changing the simulation profile.
[Enhancement][Trivial] When encountering an invalid peak white reading during output levels detection, advise to check if the instrument sensor is blocked.
[Enhancement] Visual whitepoint editor: Use whitepoint of currently selected profile (unless it's a preset or “<Current>”) instead of associated display profile.
[Enhancement] Blend profile black point to a*b* = 0 by default. This makes the visual appearance of black and near black response in Photoshop (which uses relative colorimetric intent with black point compensation for display by default) match the DisplayCAL perceptual table of XYZ LUT profiles (which means neutral hues gradually blend over to the display black point hue relatively close to black. The rate of this blend and black point hue correction are influenced by the respective calibration settings, which is another added benefit of this change).
[Enhancement] Measurement & uniformity report: Change average delta a, b, L, C, and H to be calculated from absolute values.
[Enhancement] Profile loader (Windows): Don't implicitly reset the video card gamma table to linear if no profile is assigned or couldn't be determined. Show an orange-red error icon in the latter case and display details in the left-click notification popup.
[Cosmetic] Windows: Log errors when trying to determine the active display device during profile installation.
Fixed in this release:
[UI][Cosmetic] Verification tab: Don't accidentally enable the simulation profile tone response curve black output offset (100%) radio button when switching tabs.
[Trivial] Show error dialog if not able to connect to instrument for single reading.
[Minor] Strip the “firmware missing” message from the Spyder2 instrument name if it was not yet enabled (makes the automatic popup to enable the Spyder2 work).
[Minor] Prisma 3D LUT upload with 1.07 firmware.
[Minor] More accurately encode the black point in the colorimetric PCS to device table by explicitly clipping below black values to zero.
2017-06-29 15:10 (UTC) 3.3.2
DisplayCAL 3.3.2
Added in this release:
IPT and Lpt color spaces (profile information 2D and 3D gamut view, testchart editor 3D view).
ACEScg and DCDM X'Y'Z' source profiles.
Changed in this release:
[Enhancement] Changed HDR 3D LUT SMPTE 2084 roll-off colorimetric rendering to do gamut mapping in ICtCp (slightly improved hue and saturation preservation of bright saturated colors).
[Trivial] Include output levels detection related files in session archives.
Fixed in this release:
[Moderate] Unhandled exception when trying to set a white or black level target on the calibration tab via the newly introduced measurement buttons (regression of a change in DisplayCAL 3.3.x, SVN revision r4557).
[Moderate] Black point compensation for cLUT-type profiles in the advanced options did not work correctly (regression of a change in DisplayCAL 3.3.x, SVN revision r4538).
[Moderate] Unhandled exception when creating L*a*b* LUT profiles (regression of multiprocessing changes in DisplayCAL 3.3.x, SVN revision r4433). Note that creating L*a*b* LUT profiles is not recommended due to the limited ICC encoding range (not suitable for wide-gamut) and lower accuracy and smoothness compared to XYZ LUT.
[Minor] Output levels detection and alternate forward profiler were not working when using output levels quantization via additional dispread command line option -Z nbits.
[Minor] Do not create shaper curves for gamma + matrix profiles.
[Minor] Don't fall back to colorimetric rendering for HDR 3D LUT SMPTE 2084 roll-off when using luminance matched appearance or luminance preserving perceptual appearance rendering intents.
[Trivial] DIN99c and DIN99d white point misalignment (profile information 2D and 3D gamut view, testchart editor 3D view).
[UI][Cosmetic] Change info panel text to use system text color instead of defaulting to black.
[Minor] Linux (0install): Prevent system-installed protobuf package shadowing 0install implementation.
2017-06-04 16:04 (UTC) 3.3.1
DisplayCAL 3.3.1
Fixed in this release:
Unhandled exception if using CIECAM02 gamut mapping when creating XYZ LUT profiles from regularly spaced grid patch sets with the alternate forward profiling method introduced in DisplayCAL 3.3.
2017-05-30 17:48 (UTC) 3.3
DisplayCAL 3.3
Added in this release:
Profiling engine enhancements:
[Feature]Better multi CPU/multi core support. Generating high resolution PCS-to-device tables is now taking more advantage of multiple (physical or logical) processors (typical 2x speedup on a i7 6700K CPU).
[Enhancement] Generating a simple high resolution perceptual table is now done by copying the colorimetric table and only generating new input curves. This markedly reduces the processing time needed to create the perceptual table (6x speedup on a i7 6700K CPU).
[Enhancement] Black point compensation now tries to maintain the whitepoint hue until closer to the black point. This makes curves + matrix profiles in the default configuration (slightly) more accurate as well as the default simple perceptual table of cLUT profiles provide a result that is closer to the colorimetric table.
[Enhancement] The curves tags of XYZ LUT + matrix profiles will now more closely match the device-to-PCS table response (improves grayscale accuracy of the curves tags and profile generation speed slightly).
[Enhancement] The curves tags of matrix profiles are further optimized for improved grayscale accuracy (possibly slightly reduced overall accuracy if a display device is not very linear).
[Enhancement] XYZ LUT profiles created from small patch sets (79 and 175 patches) with regularly spaced grids (3x3x3+49 and 5x5x5+49) now have improved accuracy due to an alternate forward profiling method that works better for very sparsely sampled data. Most presets now use 5x5x5+49 grid-based patch sets by default that provide a reduction in measurement time at about the same or in some cases even slightly better accuracy than the previously used small patch sets.
[Enhancement] Additional PCS candidate based on the actual measured primaries of the display device for generating high resolution PCS-to-device tables. This may further reduce PCS-to-device table generation time in some cases and lead to better utilization of the available cLUT grid points.
[Feature] Calibration whitepoint targets other than “As measured” will now also be used as 3D LUT whitepoint target, allowing the use of the visual whitepoint editor to set a custom whitepoint target for 3D LUTs.
[Feature] Automatically offer to change the 3D LUT rendering intent to relative colorimetric when setting the calibration whitepoint to “As measured”.
[Feature] Support for madVR's ability to send HDR metadata to the display via nVidia or Windows 10 APIs (i.e. switch a HDR capable display to HDR mode) when creating SMPTE 2084 3D LUTs. Note that you need to have profiled the display in HDR mode as well (currently only possible by manually enabling a display's HDR mode).
[Feature]Output levels selection as advanced option and automatic output levels detection. Note that this cannot detect if you're driving a display that expects full range (0..255) in limited range (16..235), but it can detect if you're driving a display that expects limited range in full range and will adjust the output levels accordingly.
[Feature]New experimental profiling patch sequence advanced options. “Minimize display response delay” is the ArgyllCMS default (same as in previous versions of DisplayCAL). “Maximize lightness difference”, “Maximize luma difference”, “Maximize RGB difference” and “Vary RGB difference” are alternate choices which are aimed at potentially dealing better with displays employing ASBL (automatic static brightness limiting) leading to distorted measurements, and should be used together with display white level drift compensation.
[Feature] Optional alternate method for creating colorimeter correction matrices that minimizes xy chromaticity difference (four color matrix method).
[Feature] The curve viewer and profile information now have the ability to plot tone response curves of RGB device link profiles.
[Feature] The white and black level calibration target can now be set by measurement.
[Enhancement] The visual whitepoint editor is now compatible with Chromecast, Web @ localhost, madVR, Prisma and Resolve pattern generators.
[Enhancement] 3D LUT generator ReShade 3.0 compatibility.
[Feature] Support calibration from WCS profiles embedded in ICC profiles (like the ones created by the Windows Display Color Calibration Tool).
[Feature] Profile loader (Windows): Detect the Windows Display Color Calibration Tool.
[Feature] Profile loader (Windows): The quantization bitdepth can now be selected.
Changed in this release:
[Enhancement] The visual whitepoint editor now uses the calibration of the currently active display profile as the initial whitepoint.
[Enhancement] Temporary files will no longer be removed if moving the files to the final location failed, and a non-empty temporary directory will no longer be removed on exit.
[Enhancement] Incomplete runs are now always saved to a folder named 'incomplete' in the parent directory of the 'storage' directory (previously when creating a profile from existing measurement data, a failed run could overwrite existing files in a source folder that did not reside in the 'storage' directory).
[Enhancement] Use a different (numbered) logfile name when starting additional instances of the standalone tools.
[Enhancement] When creating colorimeter correction matrices from existing spectral reference data, use the selected observer.
[UI] Hide the observer selector in the colorimeter correction creation dialog when creating a spectral colorimeter correction as observer isn't applicable in that case.
[UI] Remove the single “Browse...” button from the colorimeter correction creation dialog and add individual file pickers for reference and colorimeter measurement data files.
[UI] When creating colorimeter corrections for “virtual” display devices like madVR or Resolve, offer to specify the actual display model and manufacturer.
[UI] Use smaller increments when paging up/down the black point rate or testchart patches amount sliders.
[Cosmetic] Default whitepoint color temperature and chromaticity to 6500K and D65 respectively.
[Cosmetic] If you explicitly pause measurements prior to attempting to cancel them, and then dismiss the confirmation dialog, the measurements will no longer automatically resume (unpause) anymore.
[Enhancement] Linux: When installing instrument udev rules, backup existing rules to a timestamped backup directory ~/.local/share/DisplayCAL/backup/YYYYMMDDTHHMMSS instead of overwriting existing backups in ~/.local/share/DisplayCAL/backup, and automatically add the current user to the 'colord' group (which will be created if nonexistent) if not yet a member.
[Cosmetic] Mac OS X: Don't include ID in profile header (stops ColorSync utility from complaining).
[Enhancement] Profile loader (Windows): The selected calibration state will not be implicitly (re-)applied every three seconds, but only if a change in the running processes or video card gamma tables is detected. This has been reported to stop hitching on some systems using Intel integrated graphics, and works around an issue with the Windows 10 Creators Update and fullscreen applications (e.g. games) where the calibration state would not be restored automatically when returning to the desktop.
[Enhancement] Profile loader (Windows): The profile loader will check whether or not madVR resets the videoLUT and preserve calibration state if not.
[UI][Cosmetic] Profile loader (Windows): Renamed “Preserve calibration state” menu item to “Load calibration on login & preserve calibration state” to reduce ambiguity.
[UI][Cosmetic] Profile loader (Windows): The tray icon will animate when calibration is reloaded.
[UI][Cosmetic] Windows 7 and newer: Show progress in the taskbar.
Fixed in this release:
[Minor] Prevent ArgyllCMS from removing measurements with one or two zero CIE components by fudging them to be non-zero.
[Minor] In some cases the high resolution colorimetric PCS-to-device table of XYZ LUT profiles would clip slightly more near black than expected.
[Trivial] Save and restore SMPTE 2084 content colorspace 3D LUT settings with profile.
[UI][Minor] Changing the application language for the second time in the same session when a progress dialog had been shown at any point before changing the language for the first time, resulted in an unhandled exception. This error had the follow-up effect of preventing any standalone tools to be notified of the second language change.
[UI][Trivial] The “Install Argyll instrument drivers” menu item in the “Tools” menu is now always enabled (previously, you would need to select the location of the ArgyllCMS executables first, which was counter-intuitive as the driver installer is separate since DisplayCAL 3.1.7).
[UI][Cosmetic] When showing the main window (e.g. after measurements), the progress dialog (if present) could become overlapped by the main window instead of staying in front of it. Clicking on the progress dialog would not bring it back into the foreground.
[UI][Minor] 3D LUT tab: When selecting a source colorspace with a custom gamma tone response curve, the gamma controls should be shown regardless of whether advanced options are enabled or not.
[Trivial] Testchart editor: Pasting values did not enable the “Save” button.
[UI][Minor] Untethered measurement window: The “Measure” button visual state is now correctly updated when cancelling a confirmation to abort automatic measurements.
[Minor] Windows: Suppress errors related to WMI (note that this will prevent getting the display name from EDID and individual ArgyllCMS instrument driver installation).
[UI][Cosmetic] Profile loader (Windows): Changing the scaling in Windows display settings would prevent further profile loader tray icon updates (this did not affect functionality).
[Minor] Profile loader (Windows): Undefined variable if launched without an active display (i.e. if launched under a user account that is currently not the active session).
[Minor] Profile loader (Windows): Original profile loader instance did not close after elevation if the current user is not an administrator.
2017-02-18 15:52 (UTC) 3.2.4
3.2.4
Added in this release:
Korean translation thanks to 김환(Howard Kim).
Changed in this release:
Disable observer selection if observer is set by a colorimeter correction.
3D LUT maker: Enable black output offset choice for 16-bit table-based source profiles.
Profile loader (Windows): “Automatically fix profile associations” is now enabled by default.
Build system: Filter out “build”, “dist” as well as entries starting with a dot (“.”) to speed up traversing the source directory tree (distutils/setuptools hack).
Fixed in this release:
Could not create colorimeter correction from existing measurements for instruments that don't support alternative standard observers.
ColorHug / ColorHug2 “Auto” measurement mode threw an error if the extended display identification data did not contain a model name.
[Trivial][Cosmetic] Testchart editor: When adding reference patches, resize row labels if needed.
Profile loader (Linux): When errors occured during calibration loading, there was no longer any message popup.
Profile loader (Windows): Filter non-existing profiles (e.g. ones that have been deleted via Windows Explorer without first disassociating them from the display device) from the list of associated profiles (same behavior as Windows color management settings).
Profile loader (Windows): When changing the language on-the-fly via DisplayCAL, update primary display device identfier string.
2017-01-04 14:10 (UTC) 3.2.3
3.2.3
Changed in this release:
Updated traditional chinese translation (thanks to 楊添明).
Profile loader (Windows): When creating the profile loader launcher task, set it to stop existing instance of the task when launching to circumvent a possible Windows bug where a task would not start even if no previous instance was running.
Fixed in this release:
When querying the online colorimeter corrections database for matching corrections, only query for corrections with a matching manufacturer ID in addition to a matching display model name (fixes corrections being offered for displays from different manufacturers, but matching model names).
Profile loader (Windows): Fix unhandled exception if no profile is assigned to a display (regression of a change to show the profile description instead of just the file name in DisplayCAL 3.2.1).
2016-12-13 22:27 (UTC) 3.2.2
3.2.2
Changed in this release:
Importing colorimeter corrections from other display profiling software now only imports from the explicitly selected entries in automatic mode.
Profile loader launcher (Windows): Pass through --oneshot argument to profile loader.
Fixed in this release:
Visual whitepoint editor: Opening a second editor on the same display without first dragging the previously opened editor to another display would overwrite the cached profile association for the current display with the visual whitepoint editor temporary profile, thus preventing the correct profile association being restored when the editor was closed.
Mac OS X: Fall back to HTTP when downloading X3D viewer components to work around broken Python TLS support.
Windows: When installing instrument drivers, catch WMI errors while trying to query device hardware IDs for instruments.
Profile loader (Windows): Possibility of unhandled exception when resuming from sleep if the graphics chipset is an Intel integrated HD graphics with more than one attached display device (may affect other graphics chipsets as well).
2016-11-25 13:35 (UTC) 3.2.1
3.2.1
Changed in this release:
Profile loader (Windows Vista and later): The profile loader process now auto-starts with the highest available privileges if installed as administrator. This allows changing system default profile associations whenever logged in with administrative privileges.
Profile loader (Windows Vista and later): If running under a restricted user account and using system defaults, clicking any of the “Add...”, “Remove” and “Set as default” buttons will allow to restart the profile loader with elevated privileges.
Profile loader (Windows): Show profile description in addition to profile file name in profile associations dialog.
Fixed in this release:
Linux, Windows: Visual whitepoint editor was not working in HiDPI mode.
Windows: Irritating “File not found” error after installing a profile with special characters in the profile name (note that the profile was installed regardless).
[Cosmetic] Standalone executables (Windows): In HiDPI mode, taskbar and task switcher icons could be showing placeholders due to missing icon files.
[Minor] Profile loader (Windows): Enable the profile associations dialog “Add...” button irrespective of the current list of profiles being empty.
[Minor] Profile loader (Windows): Suppress error message when trying to remove a profile from the active display device if the profile is the system default for said device (and thus cannot be removed unless running as administrator) but not for the current one.
Profile loader (Windows): Do not fail to close profile information windows if the profile associations dialog has already been closed.
Profile loader (Windows): If logging into another user account with different DPI settings while keeping the original session running, then logging out of the other account and returning to the original session, the profile loader could deadlock.
2016-11-19 11:01 (UTC) 3.2
3.2
Added in this release:
Visual whitepoint editor. This allows visually adjusting the whitepoint on display devices that lack hardware controls as well as match several displays to one another (or a reference). To use it, set the whitepoint to “Chromaticity” on the “Calibration” tab and click the visual whitepoint editor button (you can open as many visual whitepoint editors simultaneously as you like, so that e.g. one can be left unchanged as reference, while the other can be adjusted to match said reference). The editor window can be put into a distraction-free fullscreen mode by maximizing it (press ESC to leave fullscreen again). Adjust the whitepoint using the controls on the editor tool pane until you have achieved a visual match. Then, place your instrument on the measurement area and click “Measure”. The measured whitepoint will be set as calibration target.
Another “Auto” testchart slider step with 154 patches (equal to small testchart for LUT profiles) for XYZ LUT + matrix profile type.
Changed in this release:
Menu overhaul. Menus are now better organized using categorized sub-menus and some menu items have been moved to more appropriate locations:
The “Options” menu no longer contains any functionality besides actual options. Advanced options have been moved to a sub-menu.
Profile creation from existing measurement files or EDID, profile installation as well as profile upload (sharing) functionality can now be found in the “File” menu.
Most functionality available in the “Tools” menu has been grouped into categorized sub-menus, with some of the less-used functionality now available under a separate “Advanced” sub-menu.
Measuring the selected testchart, enhancing the effective resolution of a colorimetric PCS-to-device table, loading calibration and resetting the video card gamma tables, detecting displays & instruments, as well as user-initiated spectrometer self-calibration functionality has been moved to the “Tools” menu and respective sub-menus where applicable.
Changed default curves + matrix profile testchart as well as first “Auto” testchart slider step back to pre-3.1.7 chart with 73 patches.
Better curves + matrix profiles as well as faster computation of XYZ LUT + matrix profiles. The matrix and shaper curves of gamma + matrix, curves + matrix as well as XYZ LUT + matrix profiles are now generated in separate steps which improves the shape and grayscale neutrality of the curves on less well-behaved displays. XYZ LUT + matrix profiles will compute faster, because the curves and matrix are created from a sub-set of the profiling patches, and take around the same time as XYZ LUT + swapped matrix profiles, resulting in a typical overall computation speed increase of around +33% (+100% if just looking at the time needed when not creating PCS-to-device tables) for a XYZ LUT + matrix profile computed from 1148 patches. XYZ LUT + matrix profiles computed from more patches should see a larger computation speed increase of up to +100% depending on patch count.
Resolve pattern generator and non-native madVR network implementation: Determine the computer's local network IP address in a way that is hopefully more reliable across platforms.
Profile loader (Windows): Detect and work-around buggy Intel video drivers which, despite reverting to linear gamma tables at certain points (e.g. UAC prompts), will effectively ignore attempts to restore the gamma table calibration if it is considered to be already loaded by the driver.
Profile loader (Windows): Replaced “Open Windows color management settings...” pop-up menu item with own “Profile associations...” implementation. This should work better with multi-display configurations in contrast to Windows' braindead built-in counterpart, i.e. display devices will be listed under their EDID name (if available) as well as their viewport position and size on the virtual desktop and not only their often meaningless generic driver name like “PnP-Monitor”. Also, there won't be multiple entries for the same display device or ambiguous “1|2” identifications if there are display devices that are currently not part of the desktop due to being disabled in Windows display settings. Changing profile associations around is of course still using Windows color management functionality, but the custom UI will look and act more sane than what Windows color management settings has to offer.
Profile loader (Windows): Clicking the task bar tray icon will now always show up-to-date (at the time of clicking) information in the notification popup even if the profile loader is disabled.
Profile loader (Windows): Starting a new instance of the profile loader will now always attempt to close an already running instance instead of just notifying it, allowing for easy re-starting.
Windows (Vista and later): Installing a profile as system default will now automatically turn off “Use my settings for this device” for the current user, so that if the system default profile is changed by another user, the change is propagated to all users that have opted to use the system default profile (which is the whole point of installing a profile as system default).
Fixed in this release:
Spectrometer self-calibration using an i1 Pro or i1 Pro 2 with Argyll >= 1.9 always presented the emissive dark calibration dialog irrespective of measurement mode (but still correctly did a reflective calibration if the measurement mode was one of the high resolution spectrum modes).
User-initiated spectrometer self-calibration was not performed if “Allow skipping of spectrometer self-calibration” was enabled in the “Options” menu and the most recent self-calibration was still fresh.
Cosmetic: If an update check, colorimeter correction query or profile sharing upload returned a HTTP status code equal to or greater than 400 (server-side error), an unhandled exception was raised instead of presenting a nicer, formatted error dialog (regression of DisplayCAL 3.1.7 instrument driver installer download related changes).
Profile loader (Windows, cosmetic): Reflect changed display resolution and position in UI (doesn't influence functionality).
Resolve pattern generator: Unhandled exception if the system hostname could not be resolved to an IP address.
2016-10-24 10:13 (UTC) 3.1.7.3
3.1.7.3
Fixed in this release:
0install (Linux): (un)install-standalone-tools-icons command was broken with 3.1 release.
Profile loader (Linux): Unhandled exception if oyranos-monitor is present (regression of late initialization change made in 3.1.7).
2016-10-21 12:26 (UTC) 3.1.7.2
3.1.7.2
Changed in this release:
Windows: Toggling the “Load calibration on login” checkbox in the profile installation dialog now also toggles preserving calibration state in the profile loader and vice versa, thus actually affecting if calibration is loaded on login or not (this restores functionality that was lost with the initial DisplayCAL 3.1 release).
Windows: The application, setup and Argyll USB driver installer executables are now digitally signed (starting from October 18, 2016 with SHA-1 digest for 3.1.7.1 and dual SHA-1 and SHA-256 digests for 3.1.7.2 from October 21, 2016).
Fixed in this release:
Profile loader (Windows): User-defined exceptions could be lost if exiting the profile loader followed by (re-)loading settings or restoring defaults in DisplayCAL.
2016-10-18 10:00 (UTC) 3.1.7.1
3.1.7.1
Fixed in this release:
Profile loader (Windows): Setting calibration state to reset video card gamma tables overwrote cached gamma ramps for the 2nd display in a multi-display configuration.
2016-10-04 20:49 (UTC) 3.1.7
3.1.7
Added in this release:
3D LUT sizes 5x5x5 and 9x9x9.
JETI spectraval 1511/1501 support (requires ArgyllCMS >= 1.9).
Profile loader (Windows): Added reset-vcgt scripting command (equivalent to selecting “Reset video card gamma table” from the popup menu).
Changed in this release:
“Auto” resolution of PCS-to-device tables is now limited to 45x45x45 to prevent excessive processing times with profiles from “funky” measurements (i.e. due to bad/inaccurate instrument).
Automatically optimized testcharts now use curves + matrix profiles for preconditioning to prevent a possible hang while creating the preconditioned testchart with LUT-type profiles from sufficiently “badly behaved” displays.
2nd auto-optimized testchart slider step now defaults to XYZ LUT profile type as well, and the previous patch count was increased from 97 to 271 (necessary for baseline LUT profile accuracy).
Adjusted curves + matrix testcharts to only include fully saturated RGB and grayscale to prevent tinted neutrals and/or “rollercoaster” curves on not-so-well behaved displays (also reduces testchart patch count and measurement time, but may worsen the resulting profile's overall accuracy).
Removed near-black and near-white 1% grayscale increments from “video” verification charts.
Use a 20 second timeout for unresponsive downloads.
Windows: Much easier ArgyllCMS instrument driver installation (for instruments that require it). No need to disable driver signature enforcement under Windows 8/10 anymore. Select “Install ArgyllCMS instrument drivers...” from the “Tools” menu, click “Download & install”, wait briefly for the download to finish (400 KB), confirm the User Access Control popup, done. Note that the driver installer executable is currently not digitally signed (obtaining a suitable certificate from a trusted authority is in progress), but the driver itself is signed as usual. The installer is based on libwdi.
Profile loader (Windows): Changed apply-profiles scripting command to behave excatly like selecting “Load calibration from current display device profile(s)” from the popup menu, i.e. not only load calibration, but also change the setting.
Profile loader (Windows): Also count calibration state being (re)applied when the profile loader state or profile association(s) changes.
Fixed in this release:
Update measurement modes after importing colorimeter corrections. Fixes additional measurement modes for the Spyder4/5 not appearing until the program is restarted or a different instrument is selected first.
Trivial: Instrument setup was unnecessarily being called twice after downloading ArgyllCMS when the latter wasn't previously detected.
Mac OS X: Work around a wxPython bug which prevents launching the application from a path containing non-ASCII characters.
Mac OS X: Work around a configuration problem affecting ArgyllCMS 1.9 and 1.9.1 (fixes Spyder2 firmware, additional Spyder4/5 measurement modes, and imported colorimeter corrections not being seen by DisplayCAL if imported via ArgyllCMS 1.9 or 1.9.1).
2016-08-24 21:33 (UTC) 3.1.6
3.1.6
Added in this release:
HDR/SMPTE 2084: Advanced options to specify maximum content light level for roll-off (use with care!) as well as content colorspace (affects perceptual intent gamut mapping, less so colorimetric).
Changed in this release:
Increased timeout to launch ArgyllCMS tools to 20 seconds.
Show failed items when otherwise successfully importing colorimeter corrections, and detect updated CCSS files.
Linux/colord: When checking for a valid colord device ID, also try with manufacturer omitted.
Windows Vista and later: Use “known folders” API to determine path to “Downloads” directory.
Fixed in this release:
HDR/SMPTE 2084: Slightly too light near-black tones when black output offset was set to below 100%.
Synthetic ICC Profile Creator: Undefined variable when creating synthetic profile with custom gamma or BT.1886 and non-zero black level (regression of HDR-related changes made in 3.1.5).
When loading settings from a profile created with DisplayCAL prior to 3.1.5 and custom 3D LUT tone curve gamma in DisplayCAL 3.1.5, the gamma and output offset controls wouldn't be shown if advanced options weren't enabled until re-selecting the tone curve choice.
Cosmetic (Windows 10): Banner would go blank under some Windows 10 configurations when showing the profile or 3D LUT installation dialog.
Cosmetic (Linux): Missing backgrounds and wrongly sized combo boxes when wxGTK is built against GTK3.
Linux: Profile loader autostart entry was installed under wrong (mixed-case) name if installing for the current user, which lead to the loader unnecesarily being run twice if DisplayCAL was installed from a RPM or DEB package. The superfluous loader entry will be automatically removed the next time you install a profile, or you can remove it manually by running rm ~/.config/autostart/z-DisplayCAL-apply-profiles.desktop in a terminal.
Linux/colord: Don't cache device IDs that are not the result of a successful query.
Windows: Make elevated subprocess calls synchronous. Fixes importing colorimeter corrections system-wide not listing all succesfully imported items on the first use.
2016-08-02 22:28 (UTC) 3.1.5
3.1.5
Added in this release:
HDR: Allow specifying of black output offset for SMPTE 2084.
Changed in this release:
HDR: Implemented SMPTE 2084 rolloff according to ITU-R BT.2390.
HDR: Implemented SMPTE 2084 3D LUT tone mapping (preserve hue and saturation with rolloff).
HDR: Improved SMPTE 2084 3D LUT perceptual intent rendering (better preserve saturation). Note that colorimetric intent is recommended and will also do tone mapping.
Linux/colord: Increase timeout when querying for newly installed profiles to 20 seconnds.
Fixed in this release:
Minor: HDR peak luminance textbox was sometimes not able to receive focus.
Minor (Mac OS X): Don't omit ICC files from compressed archives (regression of adding device link profiles as possible 3D LUT output format in DisplayCAL 3.1.3).
2016-07-10 23:35 (UTC) 3.1.4
3.1.4
Added in this release:
A fourth Rec. 709 encompassing color space variant as a profile connection space candidate for XYZ LUT profiles. May lead to better utilization of PCS-to-device color lookup table grid points in some cases (and thus potentially smaller profiles when the effective resolution is set to the default of “Auto”).
An option to include legacy serial ports (if any) in detected instruments.
SMPTE 2084 (HDR) as 3D LUT tone curve choice.
Changed in this release:
Don't preserve shaper curves in ICC device link profiles if selected as 3D LUT output format (effectively matching other 3D LUT formats).
Removed “Prepress” preset due to large overlap with “Softproof”.
Changed “Softproof” preset to use 5800K whitepoint target (in line with Fogra softproof handbook typical photography workflow suggested starting point value) and automatic black point hue correction.
Synthetic ICC profile creator: Changed SMPTE 2084 to always clip (optionally with roll-off) if peak white is below 10000 cd/m².
Synthetic ICC profile creator: Changed transition to specified black point of generated profiles to be consistent with BT.1886 black point blending (less gradual transition, blend over to specified black point considerably closer to black).
Profile loader (Windows): If no profile assigned, load implicit linear calibration.
Fixed in this release:
When loading settings from an existing profile, some CIECAM02 advanced profiling options were not recognized correctly.
Don't accidentally remove the current display profile if ArgyllCMS is older than version 1.1 or the ArgyllCMS version is not included in the first line of output due to interference with QuickKeys under Mac OS X.
Make sure the ArgyllCMS version is detected even if it isn't contained in the first line of output (fixes ArgyllCMS version not being detected if QuickKeys Input Manager is installed under Mac OS X).
When loading settings, add 3D LUT input profile to selector if not yet present.
Curve viewer/profile information: Fix potential division by zero error when graphing unusual curves (e.g. non-monotonic or with very harsh bends).
Profile information: Reset right pane row background color on each profile load (fixes “named color” profile color swatches sticking even after loading a different profile).
2016-04-11 10:50 (UTC) 3.1.3.1
3.1.3.1
Changed in this release:
Updated traditional chinese localization (work-in-progress, thanks to 楊添明).
Windows: If madTPG is set to fullscreen and there's more than one display connected, don't temporarily override fullscreen if interactive display adjustment is enabled.
Fixed in this release:
Windows: If interactive display adjustment is disabled and madTPG is set to fullscreen, show instrument placement countdown messages in madTPG OSD.
Windows: Restore madTPG fullscreen button state on disconnect if it was temporarily overridden.
Profile loader (Windows): Error message when right-clicking the profile loader task tray icon while DisplayCAL is running.
2016-04-09 12:16 (UTC) 3.1.3
3.1.3
If you update from DisplayCAL 3.1/3.1.1/3.1.2 standalone under Windows using the installer, please close the profile loader manually (if it is running) before running setup - due to an unfortunate bug, the installer may not be able to close and restart the profile loader automatically, which may then require using the task manager to end the profile loader process. Apologies for the inconvenience.
Added in this release:
Device link profile as possible 3D LUT output format.
French ReadMe (thanks to Jean-Luc Coulon).
Partial traditional chinese localization (work-in-progress, thanks to 楊添明).
When you change the language in DisplayCAL, the Windows Profile Loader will follow on-the-fly if running.
Synthetic ICC profile creator: Capability to specify profile class, technology and colorimetric image state.
Windows: When the display configuration is changed while DisplayCAL is running, automatically re-enumerate displays, and load calibration if using the profile loader.
Profile loader (Windows): Starting the loader with the --oneshot argument will make it exit after launching.
Changed in this release:
Updated ReShade 3D LUT installation instructions in the ReadMe.
Improved “Enhance effective resolution of PCS to device tables” smoothing accuracy slightly.
Profile loader (Windows):
Detect CPKeeper (Color Profile Keeper) and HCFR.
Show any calibration loading errors on startup or display/profile change in a notification popup, and also reflect this with a different icon.
Fixed in this release:
Added semicolon (“;”) to disallowed profile name characters.
ICC profile objects were leaking memory.
Windows: Made sure that the virtual console size is not larger than the maximum allowed size (fixes possible inability to launch ArgyllCMS tools on some systems if the Windows scaling factor was equal to or above 175%).
Windows (Vista and newer): Use system-wide profiles if per-user profiles are disabled.
Profile loader (Windows):
If Windows calibration management is enabled (not recommended!), correctly reflect the disabled state of the profile loader in the task tray icon and don't load calibration when launching the profile loader (but keep track of profile assignment changes).
Prevent a race condition when “Fix profile associations automatically” is enabled and changing the display configuration, which could lead to wrong profile associations not being fixed.
Sometimes the loader did not exit cleanly if using taskkill or similar external methods.
Prevent a race condition where the loader could try to access a no longer available display device right after a display configuration change, which resulted in no longer being able to influence the calibration state (requiring a loader restart to fix).
Profile loader not reacting to display changes under Windows XP.
2016-03-03 22:33 (UTC) 3.1.2
3.1.2
Fixed in this release:
Profile loader (Windows): Pop-up wouldn't work if task bar was set to auto-hide.
2016-02-29 17:42 (UTC) 3.1.1
3.1.1
Added in this release:
Profile loader (Windows): Right-click menu items to open Windows color management and display settings.
Changed in this release:
Profile loader (Windows):
Detect f.lux and dispcal/dispread when running outside DisplayCAL.
Don't notify on launch or when detecting DisplayCAL or madVR.
Detect madVR through window enumeration instead of via madHcNet (so madVR can be updated without having to close and restart the profile loader).
Enforce calibration state periodically regardless of video card gamma table state.
Don't use Windows native notifications to overcome their limitations (maximum number of lines, text wrapping).
Show profile associations and video card gamma table state in notification popup.
Fixed in this release:
Error after measurements when doing verification with “Untethered” selected as display device and using a simulation profile (not as target).
Windows: Sporadic application errors on logout/reboot/shutdown on some systems when DisplayCAL or one of the other applications was still running.
Standalone installer (Windows): Remove dispcalGUI program group entries on upgrade.
Profile loader (Windows):
Error when trying to enable “Fix profile associations automatically” when one or more display devices don't have a profile assigned.
Sporadic errors related to taskbar icon redraw on some systems when showing a notification after changing the display configuration (possibly a wxPython/wxWidgets bug).
Mac OS X: Application hang when trying to quit while the testchart editor had unsaved changes.
2016-02-01 00:32 (UTC) 3.1
3.1
dispcalGUI has been renamed to DisplayCAL.
If you upgrade using 0install under Linux: It is recommended that you download the respective DisplayCAL-0install package for your distribution and install it so that the applications accessible via the menu of your desktop environment are updated properly.
If you upgrade using 0install under Mac OS X: It is recommended that you delete existing dispcalGUI application icons, then download the DisplayCAL-0install.dmg disk image to get updated applications.
Added in this release:
Better HiDPI support. All text should now be crisp on HiDPI displays (with the exception of axis labels on curve and gamut graphs under Mac OS X). Icons will be scaled according to the scaling factor or DPI set in the display settings under Windows, or the respective (font) scaling or DPI system setting under Linux. Icons will be scaled down or up from their 2x version if a matching size is not available. Note that support for crisp icons in HiDPI mode is currently not available in the GTK3 and Mac OS X port of wxPython/wxWidgets. Also note that if you run a multi-monitor configuration, the application is system-DPI aware but not per-monitor-DPI aware, which is a limitation of wxPython/wxWidgets (under Windows, you will need to log out and back in after changing DPI settings for changes to take effect in DisplayCAL).
When having created a compressed archive of a profile and related files, it can now also be imported back in via drag'n'drop or the “Load settings...” menu entry and respective button.
ArgyllCMS can be automatically downloaded and updated.
A compressed logs archive can be created from the log window.
Windows: New profile loader. It will stay in the taskbar tray and automatically reload calibration if the display configuration changes or if the calibration is lost (although fullscreen Direct3D applications can still override the calibration). It can also automatically fix profile associations when switching from a multi-monitor configuration to a single display and vice versa (only under Vista and later). In addition, the profile loader is madVR-aware and will disable calibration loading if it detects e.g. madTPG or madVR being used by a video player.
Changed in this release:
Changed default calibration speed from “Medium” to “Fast”. Typically this cuts calibration time in half, while the accuracy difference is negligible at below 0.2 delta E.
Enabled “Enhance effective resolution of PCS to device tables” and smoothing for L*a*b* LUT profiles.
Fixed in this release:
In some cases, importing colorimeter corrections from the vendor software CD could fail (falling back to downloading them from the web).
Moving the auto testchart patches slider to a value that changed the profile type did not update BPC accordingly (shaper+matrix defaults to BPC on).
Minor: Safari/IE messed up positioning of CCT graph vertical axis labels in measurement reports.
Minor: When clicking the “Install profile” button while not on the 3D LUT tab, and “Create 3D LUT after profiling” is enabled, don't create a 3D LUT.
Minor: When changing profile type, only change the selected testchart if needed, and default to “Auto” for all profile types.
Minor: 1st launch defaults were slightly different from what was intended (testchart should be “Auto”).
Minor: Use OS line separator when writing configuration files.
Linux: Text and icon sizes should be more consistent accross the application when the system text scaling or DPI has been adjusted (application restart required).
Linux: Fall back to use the XrandR display name for colord device IDs if EDID is not available.
Linux/Mac OS X: madVR test pattern generator interface was prone to connection failures due to a race condition. Also, verifying a madVR 3D LUT didn't work.
displaycal-py3-3.9.19/DisplayCAL-3DLUT-maker.pyw 000775 000000 000000 00000000344 15225167330 021057 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL-VRML-to-X3D-converter-console.py 000664 000000 000000 00000000345 15225167330 024177 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL-VRML-to-X3D-converter.pyw 000775 000000 000000 00000000345 15225167330 022731 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL-apply-profiles.pyw 000775 000000 000000 00000000344 15225167330 022075 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL-curve-viewer.pyw 000775 000000 000000 00000000344 15225167330 021552 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL-eeColor-to-madVR-converter.py 000775 000000 000000 00000000345 15225167330 023765 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL-profile-info.pyw 000775 000000 000000 00000000345 15225167330 021521 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL-scripting-client.pyw 000775 000000 000000 00000000345 15225167330 022406 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL-synthprofile.pyw 000775 000000 000000 00000000345 15225167330 021656 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL-testchart-editor.pyw 000775 000000 000000 00000000345 15225167330 022415 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL.pyw 000775 000000 000000 00000000345 15225167330 017132 0 ustar 00root root 000000 000000 #!/usr/bin/env python3
import os
exec(
open(
os.path.join(
os.path.dirname(__file__),
"scripts",
os.path.splitext(os.path.basename(__file__))[0].lower(),
)
).read()
)
displaycal-py3-3.9.19/DisplayCAL/ 000775 000000 000000 00000000000 15225167330 016364 5 ustar 00root root 000000 000000 displaycal-py3-3.9.19/DisplayCAL/ColorLookupTable.fx 000664 000000 000000 00000005062 15225167330 022146 0 ustar 00root root 000000 000000 // Color Look Up Table Shader ==================================================
// Configuration ---------------------------------------------------------------
#define CLUT_ENABLED 1
// Key to toggle CLUT on or off. See MSDN, "Virtual-Key Codes",
// msdn.microsoft.com/library/windows/desktop/dd375731%28v=vs.85%29.aspx
// for a list of key codes.
#define CLUT_TOGGLEKEY 0x24 // 0x24 = HOME key
// NOTE that only textures with a height of 2 ^ n and a width of ^ 2
// will work correctly! E.g. x: 256x16, 1024x32, 4096x64
#define CLUT_TEXTURE "ColorLookupTable.png"
#define CLUT_TEXTURE_WIDTH ${WIDTH}
#define CLUT_SIZE ${HEIGHT}
// END Configuration -----------------------------------------------------------
#pragma message "\nColor Look Up Table Shader ${VERSION}\n"
#pragma reshade showtogglemessage
texture2D ColorLookupTable_texColor : COLOR;
texture ColorLookupTable_texCLUT < string source = CLUT_TEXTURE; >
{
Width = CLUT_TEXTURE_WIDTH;
Height = CLUT_SIZE;
Format = ${FORMAT};
};
sampler2D ColorLookupTable_samplerColor
{
Texture = ColorLookupTable_texColor;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = Clamp;
AddressV = Clamp;
};
sampler2D ColorLookupTable_samplerCLUT
{
Texture = ColorLookupTable_texCLUT;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = Clamp;
AddressV = Clamp;
};
void ColorLookupTable_VS(in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0)
{
texcoord.x = (id == 2) ? 2.0 : 0.0;
texcoord.y = (id == 1) ? 2.0 : 0.0;
position = float4(texcoord * float2(2.0, -2.0) + float2(-1.0, 1.0), 0.0, 1.0);
}
#define CLUTscale float2(1.0 / CLUT_TEXTURE_WIDTH, 1.0 / CLUT_SIZE)
float4 ColorLookupTable_PS(in float4 position : SV_Position,
in float2 texcoord : TEXCOORD) : SV_Target
{
float4 color = tex2D(ColorLookupTable_samplerColor, texcoord.xy);
float3 CLUTcoord = float3((color.rg * (CLUT_SIZE - 1) + 0.5) * CLUTscale,
color.b * (CLUT_SIZE - 1));
float shift = floor(CLUTcoord.z);
CLUTcoord.x += shift * CLUTscale.y;
color.rgb = lerp(tex2D(ColorLookupTable_samplerCLUT, CLUTcoord.xy).rgb,
tex2D(ColorLookupTable_samplerCLUT,
float2(CLUTcoord.x + CLUTscale.y, CLUTcoord.y)).rgb,
CLUTcoord.z - shift);
return color;
}
technique ColorLookupTable < bool enabled = CLUT_ENABLED; toggle = CLUT_TOGGLEKEY; >
{
pass
{
VertexShader = ColorLookupTable_VS;
PixelShader = ColorLookupTable_PS;
}
}
displaycal-py3-3.9.19/DisplayCAL/VERSION 000664 000000 000000 00000000006 15225167330 017430 0 ustar 00root root 000000 000000 3.9.19 displaycal-py3-3.9.19/DisplayCAL/__init__.py 000664 000000 000000 00000000072 15225167330 020474 0 ustar 00root root 000000 000000 from DisplayCAL.meta import VERSION_STRING as __version__
displaycal-py3-3.9.19/DisplayCAL/__main__.py 000775 000000 000000 00000000523 15225167330 020461 0 ustar 00root root 000000 000000 #!/usr/bin/env python3 # noqa: N999
"""This is the entry point for the DisplayCAL application.
It imports and executes the `main` function from the `DisplayCAL.main` module,
which initializes and runs the application.
Usage:
Run this script directly to start the DisplayCAL application.
"""
from DisplayCAL.main import main
main()
displaycal-py3-3.9.19/DisplayCAL/argyll.py 000664 000000 000000 00000061347 15225167330 020243 0 ustar 00root root 000000 000000 """Argyll utilities situated here.
The utilities that were previously spread around are gathered here.
"""
# Standard Library Imports
from __future__ import annotations
import contextlib
import json
import os
import re
import string
import subprocess as sp
import sys
import time
import urllib.error
import urllib.request
from functools import cache
from typing import TYPE_CHECKING, Callable, overload
# Local Imports
from DisplayCAL import config, options
from DisplayCAL import localization as lang
from DisplayCAL.argyll_names import ALTNAMES as ARGYLL_ALTNAMES
from DisplayCAL.argyll_names import NAMES as ARGYLL_NAMES
from DisplayCAL.argyll_names import OPTIONAL as ARGYLL_OPTIONAL
from DisplayCAL.config import (
APPNAME,
EXE_EXT,
FS_ENC,
get_data_path,
get_icon,
get_verified_path,
getcfg,
setcfg,
writecfg,
)
from DisplayCAL.util_os import getenvu, safe_glob, which
from DisplayCAL.util_str import make_filename_safe
if TYPE_CHECKING:
import wx # noqa: TC004
ARGYLL_UTILS = {}
def debug_print(*args, **kwargs) -> None:
"""Prints messages if DEBUG is set to 1 or higher."""
if kwargs.pop("debug_level", 1) <= options.DEBUG:
print(*args, **kwargs)
def verbose_print(*args, **kwargs) -> None:
"""Prints messages if VERBOSE is set to 1 or higher."""
if kwargs.pop("verbose_level", 1) <= options.VERBOSE:
print(*args, **kwargs)
def get_path_from_env() -> list[str]:
"""Parse environment paths into a list.
Returns:
list[str]: A list of paths.
"""
return getenvu("PATH", os.defpath).split(os.pathsep)
def check_argyll_bin(paths: None | list[str] = None) -> bool:
"""Check if the Argyll binaries can be found.
Args:
paths (None | list[str]): The paths to look for.
Returns:
bool: True if all required Argyll binaries are found, False otherwise.
"""
prev_dir = None
cur_dir = os.curdir
for name in ARGYLL_NAMES:
exe = get_argyll_util(name, paths)
if not exe:
if name in ARGYLL_OPTIONAL:
continue
return False
cur_dir = os.path.dirname(exe)
if not prev_dir:
prev_dir = cur_dir
continue
if cur_dir == prev_dir:
continue
if name in ARGYLL_OPTIONAL:
verbose_print(
f"Warning: Optional Argyll executable {exe} is not "
"in the same directory as the main executables "
f"({prev_dir})."
)
else:
verbose_print(
f"Error: Main Argyll executable {exe} is not in the "
f"same directory as the other executables ({prev_dir})."
)
return False
verbose_print("Argyll binary directory:", cur_dir, verbose_level=3)
debug_print("[D] check_argyll_bin OK")
if options.DEBUG >= 2:
if not paths:
paths = get_path_from_env()
argyll_dir = (getcfg("argyll.dir") or "").rstrip(os.path.sep)
if argyll_dir:
if argyll_dir in paths:
paths.remove(argyll_dir)
paths = [argyll_dir, *paths]
print("[D] Search path:\n ", "\n ".join(paths))
# Fedora doesn't ship Rec709.icm
config.DEFAULTS["3dlut.input.profile"] = (
get_data_path(os.path.join("ref", "Rec709.icm"))
or get_data_path(os.path.join("ref", "sRGB.icm"))
or ""
)
config.DEFAULTS["testchart.reference"] = (
get_data_path(os.path.join("ref", "ColorChecker.cie")) or ""
)
config.DEFAULTS["gamap_profile"] = (
get_data_path(os.path.join("ref", "sRGB.icm")) or ""
)
return True
def prompt_argyll_dir(
parent: wx.Window = None,
callafter: None | Callable = None,
callafter_args: None | tuple = None,
) -> str:
"""Prompt the user for the Argyll CMS directory.
Args:
parent (wx.Window): The parent window for dialogs.
callafter (callable): A function to call after setting the Argyll bin.
callafter_args (None | tuple): Arguments to pass to the callafter
function.
Returns:
str: The path to the Argyll CMS directory.
"""
# Check if Argyll version on PATH is newer than configured Argyll version
paths = get_path_from_env()
argyll_version_string = get_argyll_version_string("dispwin", True, paths)
argyll_version = parse_argyll_version_string(argyll_version_string)
argyll_version_string_cfg = get_argyll_version_string("dispwin", True)
argyll_version_cfg = parse_argyll_version_string(argyll_version_string_cfg)
# Don't prompt for 1.2.3_foo if current version is 1.2.3
# but prompt for 1.2.3 if current version is 1.2.3_foo
# Also prompt for 1.2.3_beta2 if current version is 1.2.3_beta
argyll_dir = None
if (
argyll_version > argyll_version_cfg
and (
argyll_version[:4] == argyll_version_cfg[:4]
or not argyll_version_string.startswith(argyll_version_string_cfg)
)
) or (
argyll_version < argyll_version_cfg
and argyll_version_string_cfg.startswith(argyll_version_string)
and "beta" in argyll_version_string_cfg.lower()
):
from DisplayCAL.wx_windows import ConfirmDialog
argyll_dir = os.path.dirname(get_argyll_util("dispwin", paths) or "")
dlg = ConfirmDialog(
parent,
msg=lang.getstr(
"dialog.select_argyll_version",
(argyll_version_string, argyll_version_string_cfg),
),
ok=lang.getstr("ok"),
cancel=lang.getstr("cancel"),
alt=lang.getstr("browse"),
bitmap=get_icon(size=32, name="dialog-question"),
)
dlg_result = dlg.ShowModal()
dlg.Destroy()
if dlg_result == wx.ID_OK:
setcfg("argyll.dir", None)
# Always write cfg directly after setting Argyll directory so
# subprocesses that read the configuration will use the right
# executables
writecfg()
return True
if dlg_result == wx.ID_CANCEL:
if callafter:
callafter(*callafter_args)
return False
return argyll_dir
def get_homebrew_argyll_bin() -> None | str:
"""Return Homebrew ArgyllCMS bin directory on macOS if available."""
if sys.platform != "darwin":
return None
brew = which("brew") or which("brew", ["/opt/homebrew/bin", "/usr/local/bin"])
if not brew:
return None
for formula in ("argyll-cms", "argyllcms"):
try:
result = sp.run(
[brew, "--prefix", formula],
check=False,
capture_output=True,
text=True,
timeout=10,
)
except (OSError, ValueError, sp.SubprocessError):
continue
if result.returncode != 0:
continue
prefix = (result.stdout or "").strip()
if not prefix:
continue
bin_dir = os.path.join(prefix, "bin")
if check_argyll_bin([bin_dir]):
return bin_dir
return None
def set_argyll_bin(
parent: wx.Window = None,
silent: bool = False,
callafter: None | Callable = None,
callafter_args: None | tuple = None,
) -> bool:
"""Set the directory containing the Argyll CMS binary executables.
Args:
parent (wx.Window): The parent window for dialogs.
silent (bool): If True, do not show any dialogs.
callafter (callable): A function to call after setting the Argyll bin.
callafter_args (None | tuple): Arguments to pass to the callafter
function.
Returns:
bool: True if the Argyll bin was set successfully, False otherwise.
"""
# TODO: This function contains UI stuff, please refactor it so that it is
# split into a separate function that can be called from the UI.
from DisplayCAL.wx_addons import wx
from DisplayCAL.wx_windows import InfoDialog
# Tests fails if wx.App is not initialized...
_ = wx.GetApp() or wx.App()
callafter_args = () if callafter_args is None else callafter_args
# do not center on parent if not visible
parent = None if parent and not parent.IsShownOnScreen() else parent
argyll_dir = prompt_argyll_dir(parent, callafter, callafter_args)
if parent and not check_argyll_bin():
choices = [
("download", lang.getstr("download")),
("browse", lang.getstr("browse")),
]
brew_argyll_bin = get_homebrew_argyll_bin()
if brew_argyll_bin:
choices.append(
(
"homebrew",
lang.getstr(
"argyll.use_homebrew",
brew_argyll_bin,
),
)
)
dlg = wx.SingleChoiceDialog(
parent,
lang.getstr("dialog.argyll.notfound.choice"),
APPNAME,
[label for _, label in choices],
style=wx.CHOICEDLG_STYLE,
)
dlg.SetSelection(0)
dlg_result = dlg.ShowModal()
selected = dlg.GetSelection()
dlg.Destroy()
if dlg_result != wx.ID_OK:
if callafter:
callafter(*callafter_args)
return False
action = choices[selected][0] if selected >= 0 else "browse"
if action == "download":
# Download Argyll CMS
from DisplayCAL.display_cal import app_update_check
try:
app_update_check(parent, silent, argyll=True)
except Exception as exception:
InfoDialog(
parent,
msg=f"{lang.getstr('download.fail')}\n{exception}",
ok=lang.getstr("ok"),
bitmap=get_icon(size=32, name="dialog-error"),
)
return False
if action == "homebrew" and brew_argyll_bin:
verbose_print(
"Using Homebrew Argyll binary directory:",
brew_argyll_bin,
verbose_level=3,
)
setcfg("argyll.dir", brew_argyll_bin)
# Always write cfg directly after setting Argyll directory so
# subprocesses that read the configuration will use the right
# executables
writecfg()
return True
dlg = wx.DirDialog(
parent,
lang.getstr("dialog.set_argyll_bin"),
defaultPath=os.path.join(*get_verified_path("argyll.dir", path=argyll_dir)),
style=wx.DD_DIR_MUST_EXIST,
)
dlg.Center(wx.BOTH)
result = False
while not result:
result = dlg.ShowModal() == wx.ID_OK
if result:
path = dlg.GetPath().rstrip(os.path.sep)
if os.path.basename(path) != "bin":
path = os.path.join(path, "bin")
result = check_argyll_bin([path])
if result:
verbose_print("Setting Argyll binary directory:", path, verbose_level=3)
setcfg("argyll.dir", path)
# Always write cfg directly after setting Argyll directory so
# subprocesses that read the configuration will use the right
# executables
writecfg()
break
not_found = [
f" {lang.getstr('or')} ".join(
[
altname
for altname in [
altname + EXE_EXT for altname in ARGYLL_ALTNAMES[name]
]
if "argyll" not in altname
]
)
for name in ARGYLL_NAMES
if not get_argyll_util(name, [path]) and name not in ARGYLL_OPTIONAL
]
InfoDialog(
parent,
msg="{}\n\n{}".format(
path, lang.getstr("argyll.dir.invalid", ", ".join(not_found))
),
ok=lang.getstr("ok"),
bitmap=get_icon(size=32, name="dialog-error"),
)
else:
break
dlg.Destroy()
if not result and callafter:
callafter(*callafter_args)
return result
def check_set_argyll_bin(paths: None | list[str] = None) -> bool:
"""Check if Argyll binaries can be found, otherwise let the user choose.
Args:
paths (list[str]): The paths to look for.
"""
if check_argyll_bin(paths):
return True
return set_argyll_bin()
def validate_search_paths(paths: None | list[str] = None) -> list[str]:
"""Validate the paths to look for Argyll utilities.
Args:
paths (None | list[str]): The paths to look for.
Returns:
list[str]: A list of paths to look for Argyll utilities.
"""
cfg_argyll_dir = getcfg("argyll.dir")
if not paths:
paths = get_path_from_env()
if argyll_dir := (cfg_argyll_dir or "").rstrip(os.path.sep):
with contextlib.suppress(ValueError):
paths.remove(argyll_dir)
paths = [argyll_dir, *paths]
return paths
def get_argyll_util(name: str, paths: None | list[str] = None) -> None | str:
"""Find a single Argyll utility. Return the full path.
Args:
name (str): The name of the utility.
paths (None | list[str]): The paths to look for.
Returns:
None | str: None if not found or the path of the utility.
"""
paths = validate_search_paths(paths)
cache_key = os.pathsep.join(paths)
if exe := ARGYLL_UTILS.get(cache_key, {}).get(name, None):
return exe
verbose_print(
"Info: Searching for", name, "in", os.pathsep.join(paths), verbose_level=4
)
for path in paths:
for altname in ARGYLL_ALTNAMES.get(name, []):
if exe := which(f"{altname}{EXE_EXT}", [path]):
break
if exe:
break
verbose_print(
*(
["Info:", name, "=", exe]
if exe
else [
"Info:",
"|".join(ARGYLL_ALTNAMES[name]),
"not found in",
os.pathsep.join(paths),
]
),
verbose_level=4,
)
if exe:
if cache_key not in ARGYLL_UTILS:
ARGYLL_UTILS[cache_key] = {}
ARGYLL_UTILS[cache_key][name] = exe
return exe
def get_argyll_utilname(name: str, paths: None | list[str] = None) -> str:
"""Find a single Argyll utility.
Args:
name (str): The name of the utility.
paths (None | list[str]): The paths to look for.
Returns:
str: The basename of the utility without extension, or an empty string
if not found.
"""
exe = get_argyll_util(name, paths)
if exe:
exe = os.path.basename(os.path.splitext(exe)[0])
return exe
def get_argyll_version(
name: str, silent: bool = False, paths: None | list[str] = None
) -> str:
"""Determine version of a certain Argyll utility.
Args:
name (str): The name of the Argyll utility.
silent (bool): Silently check Argyll version. Default is False.
paths (None | list[str]): Paths to look for Argyll executables.
Returns:
str: The Argyll utility version.
"""
argyll_version_string = get_argyll_version_string(name, silent, paths)
return parse_argyll_version_string(argyll_version_string)
def get_argyll_version_string(
name: str, silent: bool = False, paths: None | str = None
) -> str:
"""Return the version of the requested Argyll utility.
Args:
name (str): The name of the Argyll utility.
silent (bool): Silently check Argyll version. Default is False.
paths (None | str): Paths to look for Argyll executables.
Returns:
str: The Argyll utility version.
"""
argyll_version_string = "0.0.0"
if (not silent or not check_argyll_bin(paths)) and (
silent or not check_set_argyll_bin(paths)
):
return argyll_version_string
# Try getting the version from the log.txt file first
argyll_dir = getcfg("argyll.dir")
if argyll_dir:
log_path = os.path.join(argyll_dir, "log.txt")
if os.path.isfile(log_path):
try:
with open(log_path, "rb") as f:
log_data = f.read(150)
match = re.search(rb"(?<=Version )\d+\.\d+\.\d+(_\w+)?", log_data)
if match:
return match.group().decode("utf-8")
except Exception as e:
print(f"Error reading {log_path}: {e}")
else:
print("Warning: Argyll directory not set in config.")
# If the log.txt file is not available or doesn't contain the version,
# fall back to using the utility itself
# to get the version
cmd = get_argyll_util(name, paths)
if sys.platform == "win32":
startupinfo = sp.STARTUPINFO()
startupinfo.dwFlags |= sp.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = sp.SW_HIDE
else:
startupinfo = None
try:
p = sp.Popen(
[cmd.encode(FS_ENC), "-?"],
stdin=sp.PIPE,
stdout=sp.PIPE,
stderr=sp.STDOUT,
startupinfo=startupinfo,
)
except Exception as exception:
print(exception)
return argyll_version_string
for line in (p.communicate(timeout=30)[0] or b"").splitlines():
line = line.strip()
if b"version" in line.lower():
argyll_version_string = line[line.lower().find(b"version") + 8 :].decode(
"utf-8"
)
break
return argyll_version_string
def parse_argyll_version_string(argyll_version_string: str) -> list[int | str]:
"""Parse the Argyll version string.
Args:
argyll_version_string (str): The version string to parse.
Returns:
list[int | str]: A list of version components.
"""
if isinstance(argyll_version_string, bytes):
argyll_version_string = argyll_version_string.decode()
argyll_version = re.findall(r"(\d+|[^.\d]+)", argyll_version_string)
for i, v in enumerate(argyll_version):
with contextlib.suppress(ValueError):
argyll_version[i] = int(v)
return argyll_version
ARGYLLCMS_BINARIES_API_URL = (
"https://api.github.com/repos/eoyilmaz/argyllcms-binaries/releases/latest"
)
@cache
def get_argyll_latest_version() -> str:
"""Return the latest ArgyllCMS version from the argyllcms-binaries GitHub releases API.
Returns:
str: The latest version number.
"""
default_version = config.DEFAULTS.get("argyll.version")
max_retries = 5
base_delay = 5
request = urllib.request.Request(ARGYLLCMS_BINARIES_API_URL)
# Authenticated GitHub API requests get a 5000/hour rate limit instead of
# the 60/hour applied per-IP to anonymous requests, which CI runners can
# exhaust quickly since they share IP pools. GITHUB_TOKEN is provided for
# free by GitHub Actions when explicitly passed through to the job env.
github_token = os.environ.get("GITHUB_TOKEN")
if github_token:
request.add_header("Authorization", f"Bearer {github_token}")
for attempt in range(max_retries):
try:
response = urllib.request.urlopen(request, timeout=20) # noqa: S310
data = json.loads(response.read())
break
except urllib.error.HTTPError as exception:
delay = base_delay * (2**attempt)
if attempt < max_retries - 1:
print(
f"HTTP {exception.code} fetching ArgyllCMS latest version: "
f"{exception}. Waiting {delay}s before retry..."
)
time.sleep(delay)
else:
print(f"Could not fetch ArgyllCMS latest version: {exception}")
return default_version
except (urllib.error.URLError, OSError, TimeoutError) as exception:
delay = base_delay * (2**attempt)
if attempt < max_retries - 1:
print(
f"Error fetching ArgyllCMS latest version: {exception}. "
f"Waiting {delay}s before retry..."
)
time.sleep(delay)
else:
print(f"Could not fetch ArgyllCMS latest version: {exception}")
return default_version
else:
return default_version
tag_name = data.get("tag_name", "")
if not re.match(r"^\d+\.\d+", tag_name):
print(
f"Could not parse ArgyllCMS latest version from "
f"{ARGYLLCMS_BINARIES_API_URL}, falling back to {default_version}"
)
return default_version
print(f"Latest ArgyllCMS version: {tag_name}")
return tag_name
@overload
def make_argyll_compatible_path(path: bytes, is_name: bool = ...) -> bytes: ...
@overload
def make_argyll_compatible_path(path: str, is_name: bool = ...) -> str: ...
def make_argyll_compatible_path(path, is_name=False):
"""Make the path compatible with the Argyll utilities.
This is currently only effective under Windows to make sure that any
unicode 'division' slashes in the profile name are replaced with
underscores.
Args:
path (bytes | str): The path to be made compatible.
is_name (bool): If True, treat ``path`` as a single filename/profile
name component instead of a real filesystem path. All invalid
filename characters (including path separators such as ``/`` and
``\\``) are replaced instead of being preserved as directory
boundaries. Use this whenever the string is not guaranteed to be
an actual, already validated path (e.g. an ICC profile
description or a user-editable profile name).
Returns:
bytes | str: The compatible path.
"""
if is_name:
pattern = r'[\\/:;*?"<>|]+'
substitute = "_"
if isinstance(path, bytes):
pattern = pattern.encode("utf-8")
substitute = substitute.encode("utf-8")
return make_filename_safe(re.sub(pattern, substitute, path))
skip = -1
regex = r"\\\\\?\\"
driver_letter_escape_char = ":"
os_path_sep = os.path.sep
string_ascii_uppercase = string.ascii_uppercase
if isinstance(path, bytes):
regex = regex.encode("utf-8")
driver_letter_escape_char = driver_letter_escape_char.encode("utf-8")
os_path_sep = os_path_sep.encode("utf-8")
string_ascii_uppercase = string_ascii_uppercase.encode("utf-8")
if re.match(regex, path, re.I):
# Don't forget about UNC paths:
# \\?\UNC\Server\Volume\File
# \\?\C:\File
skip = 2
parts = path.split(os_path_sep)
if sys.platform == "win32" and len(parts) > skip + 1:
driveletterpart = parts[skip + 1]
if (
len(driveletterpart) == 2
and driveletterpart[0:1].upper() in string_ascii_uppercase
and driveletterpart[1:2] == driver_letter_escape_char
):
skip += 1
for i, part in enumerate(parts):
if i > skip:
parts[i] = make_filename_safe(part)
return os_path_sep.join(parts)
def get_argyll_instrument_config(what: None | str = None) -> list[str]:
"""Check for Argyll CMS udev rules/hotplug scripts.
Args:
what (str): The type of files to look for. Can be "installed",
"expected", or None.
Returns:
list[str]: A list of file paths that match the criteria.
"""
filenames = []
if what == "installed":
argyll_rule_filepaths = (
"/etc/udev/rules.d/55-Argyll.rules",
"/etc/udev/rules.d/45-Argyll.rules",
"/etc/hotplug/Argyll",
"/etc/hotplug/Argyll.usermap",
"/lib/udev/rules.d/55-Argyll.rules",
"/lib/udev/rules.d/69-cd-sensors.rules",
)
filenames = [
filename for filename in argyll_rule_filepaths if os.path.isfile(filename)
]
else:
if what == "expected":
def fn(filename: bytes | str) -> bytes | str:
"""Return the full path to the Argyll utility."""
return filename
else:
fn = get_data_path
if os.path.isdir("/etc/udev/rules.d"):
if safe_glob("/dev/bus/usb/*/*"):
# USB and serial instruments using udev, where udev
# already creates /dev/bus/usb/00X/00X devices
filenames.append(fn("usb/55-Argyll.rules"))
else:
# USB using udev, where there are NOT /dev/bus/usb/00X/00X
# devices
filenames.append(fn("usb/45-Argyll.rules"))
elif os.path.isdir("/etc/hotplug"):
# USB using hotplug and Serial using udev
# (older versions of Linux)
filenames.extend(
fn(filename) for filename in ("usb/Argyll", "usb/Argyll.usermap")
)
return [filename for filename in filenames if filename]
displaycal-py3-3.9.19/DisplayCAL/argyll_cgats.py 000664 000000 000000 00000074430 15225167330 021421 0 ustar 00root root 000000 000000 """Utilities for working with Argyll CMS CGATS files and calibration data.
It includes functions for manipulating CGATS data, extracting calibration
information, and creating or modifying ICC profiles with embedded calibration
data.
"""
from __future__ import annotations
# import decimal
# Decimal = decimal.Decimal
import contextlib
import decimal
import os
import traceback
from decimal import Decimal
from io import BytesIO
from time import strftime
from DisplayCAL import colormath
from DisplayCAL import localization as lang
from DisplayCAL.cgats import (
CGATS,
CGATSError,
CGATSInvalidError,
CGATSInvalidOperationError,
CGATSKeyError,
CGATSTypeError,
CGATSValueError,
)
from DisplayCAL.debughelpers import Error
from DisplayCAL.icc_profile import (
ICCProfile,
ICCProfileInvalidError,
Text,
TextDescriptionType,
VideoCardGammaTableType,
VideoCardGammaType,
WcsProfilesTagType,
)
from DisplayCAL.options import DEBUG
CALS = {}
def quote_nonoption_args(args: list[str]) -> list[bytes]:
"""Put quotes around all arguments which are not options.
(ie. which do not start with a hyphen '-')
Args:
args (list[str]): A list of arguments to be quoted.
Returns:
list[bytes]: A list of quoted arguments, where each argument that does not
start with a hyphen is wrapped in quotes.
"""
args = list(args)
for i, arg in enumerate(args):
# first convert everything to bytes
if not isinstance(arg, bytes):
arg = bytes(str(arg), "utf-8")
args[i] = b'"%s"' % arg if arg[:1] != b"-" else arg
return args
def add_dispcal_options_to_cal(cal: str | CGATS, options_dispcal: list[str]) -> CGATS:
"""Add dispcal options to cal.
Args:
cal (str | CGATS): The input CAL file or CGATS instance.
options_dispcal (list[str]): List of dispcal options to add.
Returns:
CGATS: The modified CGATS instance with added options.
"""
# Add dispcal options to cal
options_dispcal = quote_nonoption_args(options_dispcal)
try:
cgats = CGATS(cal)
cgats[0].add_section("ARGYLL_DISPCAL_ARGS", b" ".join(options_dispcal))
return cgats
except Exception:
print(traceback.format_exc())
def add_options_to_ti3(
ti3: str | CGATS,
options_dispcal: None | list[str] = None,
options_colprof: None | list[str] = None,
) -> CGATS:
"""Add dispcal and colprof options to ti3.
Args:
ti3 (str or CGATS): The input TI3 file or CGATS instance.
options_dispcal (list): List of dispcal options to add.
options_colprof (list): List of colprof options to add.
Returns:
CGATS: The modified CGATS instance with added options.
"""
# Add dispcal and colprof options to ti3
try:
cgats = CGATS(ti3)
if options_colprof:
options_colprof = quote_nonoption_args(options_colprof)
cgats[0].add_section(
"ARGYLL_COLPROF_ARGS",
b" ".join(options_colprof),
)
if options_dispcal and 1 in cgats:
options_dispcal = quote_nonoption_args(options_dispcal)
cgats[1].add_section(
"ARGYLL_DISPCAL_ARGS",
b" ".join(options_dispcal),
)
return cgats
except BaseException:
print(traceback.format_exc())
def cal_to_fake_profile(cal: str | CGATS) -> None | ICCProfile:
"""Create and return a 'fake' ICCProfile with just a vcgt tag.
cal must refer to a valid Argyll CAL file and can be a CGATS instance
or a filename.
Args:
cal (str | CGATS): The input CAL file or CGATS instance.
Returns:
None | ICCProfile: Returns an ICCProfile instance with a vcgt tag
containing the calibration data, or None if the input is invalid
or required fields are missing.
"""
if not (cal := validate_cgats(cal)) or not (vcgt := cal_to_vcgt(cal)):
return None
profile = ICCProfile()
profile.filename = cal.filename
profile._data = b"\0" * 128
profile._tags.desc = TextDescriptionType(b"", "desc")
profile._tags.desc.ASCII = str(os.path.basename(cal.filename)).encode(
"ascii", "asciize"
)
profile._tags.desc.Unicode = str(os.path.basename(cal.filename))
profile._tags.vcgt = vcgt
profile.size = len(profile.data)
profile.is_loaded = True
return profile
def cal_to_vcgt(cal: str | CGATS) -> None | VideoCardGammaTableType:
"""Create a vcgt tag from calibration data.
Args:
cal (str | CGATS): The input CAL file or CGATS instance. It must refer
to a valid Argyll CAL file or can be a CGATS instance or a
filename.
Returns:
None | VideoCardGammaTableType: Returns a VideoCardGammaTableType
instance containing the `vcgt` data. Returns None if the input is
invalid or required fields are missing.
"""
if not (cal := validate_cgats(cal)):
return None
required_fields = ("RGB_I", "RGB_R", "RGB_G", "RGB_B")
if data_format := cal.queryv1("DATA_FORMAT"):
for field in required_fields:
if field.encode("utf-8") not in list(data_format.values()):
if DEBUG:
print(f"[D] Missing required field: {field}")
return None
for field in list(data_format.values()):
if field.decode("utf-8") not in required_fields:
if DEBUG:
print(f"[D] Unknown field: {field}")
return None
entries = cal.queryv(required_fields)
if len(entries) < 1:
if DEBUG:
print(f"[D] No entries found in calibration {cal.filename}")
return None
vcgt = VideoCardGammaTableType(b"", "vcgt")
vcgt.update(
{
"channels": 3,
"entryCount": len(entries),
"entrySize": 2,
"data": [[], [], []],
}
)
for n in entries:
for i in range(3):
vcgt.data[i].append(entries[n][i + 1] * 65535.0)
return vcgt
def validate_cgats(cal: str | CGATS) -> CGATS:
"""Validate and return a CGATS instance.
Args:
cal (str | CGATS): The input CAL file or CGATS instance.
Returns:
CGATS: A validated CGATS instance.
"""
if not isinstance(cal, CGATS):
try:
cal = CGATS(cal)
except (
OSError,
CGATSInvalidError,
CGATSInvalidOperationError,
CGATSKeyError,
CGATSTypeError,
CGATSValueError,
) as exception:
print(f"Warning - couldn't process CGATS file '{cal}': {exception}")
return None
return cal
def can_update_cal(path: str) -> bool:
"""Check if cal can be updated by checking for required fields.
Args:
path (str): The path to the CGATS file.
Returns:
bool: True if the CGATS file can be updated, False otherwise.
"""
try:
calstat = os.stat(path)
except Exception as exception:
print(f"Warning - os.stat('{path}') failed: {exception}")
return False
if path not in CALS or CALS[path].mtime != calstat.st_mtime:
try:
cal = CGATS(path)
except (
OSError,
CGATSInvalidError,
CGATSInvalidOperationError,
CGATSKeyError,
CGATSTypeError,
CGATSValueError,
) as exception:
CALS.pop(path, None)
print(f"Warning - couldn't process CGATS file '{path}': {exception}")
else:
if cal.queryv1("DEVICE_CLASS") == "DISPLAY" and None not in (
cal.queryv1("TARGET_WHITE_XYZ"),
cal.queryv1("TARGET_GAMMA"),
cal.queryv1("BLACK_POINT_CORRECTION"),
cal.queryv1("QUALITY"),
):
CALS[path] = cal
return path in CALS and CALS[path].mtime == calstat.st_mtime
def extract_cal_from_profile(
profile: ICCProfile,
out_cal_path: None | str = None,
raise_on_missing_cal: bool = True,
prefer_cal: bool = False,
) -> bool | CGATS:
"""Extract calibration from 'targ' tag in profile or vcgt as fallback.
Args:
profile (ICCProfile): The ICCProfile to extract the data from.
out_cal_path (str, optional): If provided, the extracted calibration
data will be saved to this path as a CGATS file.
raise_on_missing_cal (bool): If True, raises an error if no calibration
data is found in the profile. If False, returns False instead.
prefer_cal (bool): If True, prefers the calibration data from the
'targ' tag over the 'vcgt' tag, if both are present. If False,
prefers the 'vcgt' tag if it is nonlinear.
Raises:
Error: If the calibration extraction fails or if no calibration data
is found and `raise_on_missing_cal` is True.
Returns:
bool | CGATS: Returns a CGATS instance containing the calibration data
if successful, or False if no calibration data is found and
`raise_on_missing_cal` is False.
"""
white = False
# Check if calibration is included in TI3
targ = profile.tags.get("targ", profile.tags.get("CIED"))
cal = None
cgats_builder = None
if isinstance(targ, Text) and (cal := extract_cal_from_ti3(targ)):
check = cal
cgats_builder = CGATS
arg = cal
if not cal:
check, cgats_builder, arg = convert_cal_info_from_embedded_wcs_profile(profile)
if check:
try:
cgats = cgats_builder(arg)
except (OSError, CGATSError) as e:
traceback.print_exc()
raise Error(lang.getstr("cal_extraction_failed")) from e
elif raise_on_missing_cal:
raise Error(lang.getstr("profile.no_vcgt"))
else:
return False
if (
not cal
or prefer_cal
or not isinstance(profile.tags.get("vcgt"), VideoCardGammaType)
):
if out_cal_path:
cgats.write(out_cal_path)
return cgats
black, white = get_black_and_white_levels(cgats)
cgats = vcgt_to_cal(profile)
cgats = unscale_vcgt_from_video_levels(profile, cgats, black, white)
if out_cal_path:
cgats.write(out_cal_path)
return cgats
def get_black_and_white_levels(cgats: CGATS) -> None | tuple[float, float]:
"""Get black and white levels for video encoding.
Args:
cgats (CGATS): The CGATS instance to query for black and white levels.
Returns:
tuple[float, float]: A tuple containing the black and white levels.
"""
# When vcgt is nonlinear, prefer it
# Check for video levels encoding
black = None
white = None
if cgats.queryv1("TV_OUTPUT_ENCODING") == b"YES":
black, white = (16, 235)
elif output_enc := cgats.queryv1("OUTPUT_ENCODING"):
try:
black, white = (float(v) for v in output_enc.split())
except (TypeError, ValueError):
white = False
return black, white
def convert_cal_info_from_embedded_wcs_profile(
profile: ICCProfile,
) -> tuple[bool, callable, ICCProfile]:
"""Convert calibration info from embedded WCS profile to vcgt if missing.
Args:
profile (ICCProfile): The ICCProfile to extract the calibration data from.
Returns:
tuple[bool, callable, ICCProfile]: A tuple containing:
- bool: True if the profile has a vcgt tag or can be converted to one,
- callable: A function to convert the vcgt tag to calibration data,
- ICCProfile: The ICCProfile instance with the vcgt tag.
"""
if (
isinstance(profile.tags.get("MS00"), WcsProfilesTagType)
and "vcgt" not in profile.tags
):
profile.tags["vcgt"] = profile.tags["MS00"].get_vcgt()
# Get the calibration from profile vcgt
check = isinstance(profile.tags.get("vcgt"), VideoCardGammaType)
cgats_builder = vcgt_to_cal
arg = profile
return check, cgats_builder, arg
def unscale_vcgt_from_video_levels(
profile: ICCProfile, cgats: CGATS, black: float, white: float
) -> CGATS:
"""Un-scale vcgt from video levels.
Args:
profile (ICCProfile): The ICC profile containing the vcgt tag.
cgats (CGATS): The CGATS instance to apply scaling to.
black (float): The black level for video encoding.
white (float): The white level for video encoding.
Returns:
CGATS: The CGATS instance with applied video level scaling.
"""
if not white or (black, white) == (0, 255):
print(
"No need to un-scale vcgt from video levels as black and white "
f"levels are ({black}..{white})"
)
return cgats
print(f"Need to un-scale vcgt from video levels ({black}..{white})")
# Need to un-scale video levels
if not (data := cgats.queryv1("DATA")):
print("Warning - no un-scaling applied - no calibration data!")
return cgats
print(f"Un-scaling vcgt from video levels ({black}..{white})")
encoding_mismatch = False
# 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
old_min = (black / 256.0) * (65536 / 65535.0)
old_max = (white / 256.0) * (65536 / 65535.0)
for entry in data.values():
for column in "RGB":
v_old = entry[f"RGB_{column}"]
lvl = round(v_old * (65535 / 65536.0) * 256, 2)
if lvl < round(black, 2) or lvl > round(white, 2):
# Can't be right. Metadata says it's video encoded,
# but clearly exceeds the encoding range.
print(
f"Warning: Metadata claims video levels ("
f"{round(black, 2)}..{round(white, 2)}) but "
f"vcgt value {lvl} exceeds encoding range. "
f"Using values as-is."
)
encoding_mismatch = True
break
v_new = colormath.convert_range(v_old, old_min, old_max, 0, 1)
entry[f"RGB_{column}"] = min(max(v_new, 0), 1)
if encoding_mismatch:
break
if encoding_mismatch:
cgats = vcgt_to_cal(profile)
# Add video levels hint to CGATS
elif (black, white) == (16, 235):
cgats[0].add_keyword("TV_OUTPUT_ENCODING", "YES")
else:
cgats[0].add_keyword(
"OUTPUT_ENCODING",
b" ".join(bytes(str(v), "utf-8") for v in (black, white)),
)
return cgats
def extract_cal_from_ti3(ti3: str | BytesIO) -> bytes:
"""Extract and return the CAL section of a TI3.
ti3 can be a file object or a string holding the data.
Returns:
bytes: The extracted data.
"""
if isinstance(ti3, CGATS):
ti3 = bytes(ti3)
if isinstance(ti3, bytes):
ti3 = BytesIO(ti3)
cal = False
cal_lines = []
for line in ti3:
line = line.strip()
if line == b"CAL":
line = b"CAL " # Make sure CGATS file identifiers are
# always a minimum of 7 characters
cal = True
if cal:
cal_lines.append(line)
if line == b"END_DATA":
break
with contextlib.suppress(AttributeError):
ti3.close()
return b"\n".join(cal_lines)
def extract_fix_copy_cal(
source_filename: str, target_filename: None | str = None
) -> None | list[str] | Exception:
"""Return the CAL section from a profile's embedded measurement data.
Try to 'fix it' (add information needed to make the resulting .cal file
'updatable') and optionally copy it to target_filename.
Args:
source_filename (str): The path to the source profile file.
target_filename (str, optional): The path to save the fixed CAL data.
If None, the data is not saved to a file.
Returns:
None | list[str] | Exception: Returns a list of CAL lines if found and
None if not and Exception if any exception is raised.
"""
from DisplayCAL.worker import get_options_from_profile
try:
profile = ICCProfile(source_filename)
except (OSError, ICCProfileInvalidError) as exception:
return exception
if "CIED" not in profile.tags and "targ" not in profile.tags:
return None
cal_lines = []
with BytesIO(profile.tags.get("CIED", b"") or profile.tags.get("targ", b"")) as ti3:
ti3_lines = [line.strip() for line in ti3]
cal_found = False
for line in ti3_lines:
if line == b"CAL":
# Make sure CGATS file identifiers are always a minimum of 7 characters long
line = line.ljust(7)
cal_found = True
if not cal_found:
continue
cal_lines.append(line)
if line != b'DEVICE_CLASS "DISPLAY"':
continue
options_dispcal = get_options_from_profile(profile)[0]
if not options_dispcal:
continue
# b = profile.tags.lumi.Y
cal_lines = build_cal_from_profile(cal_lines, options_dispcal)
if cal_lines:
if target_filename:
try:
with open(target_filename, "wb") as f:
f.write(b"\n".join(cal_lines))
except Exception as exception:
return exception
return cal_lines
return None
def build_cal_from_profile(
cal_lines: list[bytes], options_dispcal: list
) -> list[bytes]:
"""Build a CAL section from profile options.
Args:
cal_lines (list[bytes]): The list to append CAL lines to.
options_dispcal (list): List of dispcal options to add to the CAL section.
"""
whitepoint = False
for option in options_dispcal:
if option[0] == b"y":
cal_lines.extend(
[
b'KEYWORD "DEVICE_TYPE"',
{b"c": b'DEVICE_TYPE "CRT"'}.get(option[1], b'DEVICE_TYPE "LCD"'),
]
)
continue
if option[0] in (b"t", b"T", b"w"):
continue
if option[0] in (b"g", b"G"):
trc = {
b"240": b"SMPTE240M",
b"709": b"REC709",
b"l": b"L_STAR",
b"s": b"sRGB",
}.get(option[1:], option[1:])
if trc == option[1:] and option[0] == b"G":
try:
trc = 0 - Decimal(trc)
except decimal.InvalidOperation:
continue
cal_lines.extend((b'KEYWORD "TARGET_GAMMA"', b'TARGET_GAMMA "%s"' % trc))
continue
to_extend = {
b"f": (
b'KEYWORD "DEGREE_OF_BLACK_OUTPUT_OFFSET"',
b'DEGREE_OF_BLACK_OUTPUT_OFFSET "%s"' % option[1:],
),
b"k": (
b'KEYWORD "BLACK_POINT_CORRECTION"',
b'BLACK_POINT_CORRECTION "%s"' % option[1:],
),
b"B": (
b'KEYWORD "TARGET_BLACK_BRIGHTNESS"',
b'TARGET_BLACK_BRIGHTNESS "%s"' % option[1:],
),
}.get(option[0:1], None)
if to_extend:
cal_lines.extend(to_extend)
continue
if option[0] == b"q":
q = {
b"l": b"low",
b"m": b"medium",
}.get(option[1:2], b"high")
cal_lines.extend((b'KEYWORD "QUALITY"', b'QUALITY "%s"' % q))
cal_lines.extend(
(
b'KEYWORD "NATIVE_TARGET_WHITE"',
b'NATIVE_TARGET_WHITE ""',
)
if not whitepoint
else ()
)
return cal_lines
def extract_device_gray_primaries(
ti3: CGATS,
gray: bool = True,
logfn: None | bool = None,
include_neutrals: bool = False,
neutrals_ab_threshold: float = 0.1,
) -> tuple[CGATS, dict, dict]:
"""Extract gray or primaries into new TI3.
Args:
ti3 (CGATS): The CGATS instance containing the TI3 data.
gray (bool): If True, extract gray neutrals, otherwise extract RGB primaries.
logfn (callable): A logging function to call with messages.
include_neutrals (bool): If True, include neutral readings in the extraction.
neutrals_ab_threshold (float): Threshold for neutral readings in Lab space.
Returns:
tuple: A tuple containing:
- CGATS: The extracted TI3 data.
- dict: A mapping of extracted RGB to XYZ values.
- dict: A mapping of remaining RGB to XYZ values.
"""
filename = ti3.filename
ti3 = ti3.queryi1("DATA")
ti3.filename = filename
ti3_extracted = CGATS(
b"""CTI3
DEVICE_CLASS "DISPLAY"
COLOR_REP "RGB_XYZ"
BEGIN_DATA_FORMAT
END_DATA_FORMAT
BEGIN_DATA
END_DATA"""
)[0]
ti3_extracted.DATA_FORMAT.update(ti3.DATA_FORMAT)
subset = [(100.0, 100.0, 100.0), (0.0, 0.0, 0.0)]
if not gray:
subset.extend(
[
(100.0, 0.0, 0.0),
(0.0, 100.0, 0.0),
(0.0, 0.0, 100.0),
(50.0, 50.0, 50.0),
]
)
if logfn:
logfn(f"Extracting neutrals and primaries from {ti3.filename}")
elif logfn:
logfn(f"Extracting neutrals from {ti3.filename}")
ti3_extracted, rgb_xyz_extracted, rgb_xyz_remaining, dupes = extract_rgb_xyz_data(
ti3,
gray,
include_neutrals,
neutrals_ab_threshold,
ti3_extracted,
subset,
)
for rgb, count in dupes.items():
for rgb_xyz in (rgb_xyz_extracted, rgb_xyz_remaining):
if rgb in rgb_xyz:
# Average values
xyz = tuple(rgb_xyz[rgb][i] / count for i in range(3))
rgb_xyz[rgb] = xyz
return ti3_extracted, rgb_xyz_extracted, rgb_xyz_remaining
def extract_rgb_xyz_data(
ti3: CGATS,
gray: bool,
include_neutrals: bool,
neutrals_ab_threshold: float,
ti3_extracted: CGATS,
subset: list[tuple[float, float, float]],
) -> CGATS:
"""Extract RGB and XYZ data from TI3.
Args:
ti3 (CGATS): The CGATS instance containing the TI3 data.
gray (bool): If True, extract gray neutrals, otherwise extract RGB primaries.
include_neutrals (bool): If True, include neutral readings in the extraction.
neutrals_ab_threshold (float): Threshold for neutral readings in Lab space.
ti3_extracted (CGATS): The CGATS instance to store extracted data.
subset (list): List of RGB values to be included in the extraction.
Raises:
Error: If required fields are missing in the TI3 data.
Returns:
tuple[CGATS, dict, dict, dict]: The CGATS instance containing the
extracted data, the dictionary of extracted RGB to XYZ mappings,
the dictionary of remaining RGB to XYZ mappings, and the dictionary
of duplicate RGB values.
"""
rgb_xyz_extracted = {}
rgb_xyz_remaining = {}
dupes = {}
if include_neutrals:
white = ti3.get_white_cie("XYZ")
str_thresh = str(neutrals_ab_threshold)
round_digits = len(str_thresh[str_thresh.find(".") + 1 :])
for i in ti3.DATA:
item = ti3.DATA[i]
if not i: # don't validate the header
validate_ti3_item(ti3, item)
rgb = (item["RGB_R"], item["RGB_G"], item["RGB_B"])
xyz = (item["XYZ_X"], item["XYZ_Y"], item["XYZ_Z"])
for rgb_xyz in (rgb_xyz_extracted, rgb_xyz_remaining):
if rgb not in rgb_xyz:
continue
if rgb != (100.0, 100.0, 100.0):
# Add to existing values for averaging later
# if it's not white (all other readings are scaled to the
# white Y by dispread, so we don't alter it. Note that it's
# always the first encountered white that will have Y = 100,
# even if subsequent white readings may be higher)
xyz = tuple(rgb_xyz[rgb][i] + xyz[i] for i in range(3))
if rgb not in dupes:
dupes[rgb] = 1.0
dupes[rgb] += 1.0
elif rgb in subset:
# We have white already, remove it from the subset so any
# additional white readings we encounter are ignored
subset.remove(rgb)
if (
gray
and (
item["RGB_R"] == item["RGB_G"] == item["RGB_B"]
or (
include_neutrals
and all(
round(abs(v), round_digits) <= neutrals_ab_threshold
for v in colormath.XYZ2Lab(
item["XYZ_X"],
item["XYZ_Y"],
item["XYZ_Z"],
whitepoint=white,
)[1:]
)
)
)
and rgb not in [(100.0, 100.0, 100.0), (0.0, 0.0, 0.0)]
) or rgb in subset:
ti3_extracted.DATA.add_data(item)
rgb_xyz_extracted[rgb] = xyz
elif rgb not in [(100.0, 100.0, 100.0), (0.0, 0.0, 0.0)]:
rgb_xyz_remaining[rgb] = xyz
return ti3_extracted, rgb_xyz_extracted, rgb_xyz_remaining, dupes
def validate_ti3_item(ti3: CGATS, item: dict) -> None:
"""Validate a TI3 item to ensure it contains required fields.
Args:
ti3 (CGATS): The CGATS instance containing the TI3 data.
item (dict): The TI3 item to validate.
Raises:
Error: If required fields are missing in the TI3 item.
"""
# Check if fields are missing
required_fields = ("RGB_R", "RGB_G", "RGB_B", "XYZ_X", "XYZ_Y", "XYZ_Z")
for field in required_fields:
if field not in item:
lang.getstr("error.testchart.missing_fields", (ti3.filename, field))
def ti3_to_ti1(ti3_data: str | list[str] | BytesIO) -> bytes:
"""Create and return TI1 data converted from TI3.
Args:
ti3_data (str | list[str] | BytesIO): Can be a file object, a list of
strings or a string holding the data.
Returns:
bytes: The converted TI1 data as bytes.
"""
ti3 = CGATS(ti3_data)
if not ti3:
return ""
ti3[0].type = b"CTI1"
ti3[0].DESCRIPTOR = b"Argyll Calibration Target chart information 1"
ti3[0].ORIGINATOR = b"Argyll targen"
if hasattr(ti3[0], "COLOR_REP"):
color_rep = ti3[0].COLOR_REP.split(b"_")[0]
else:
color_rep = b"RGB"
ti3[0].add_keyword("COLOR_REP", color_rep)
ti3[0].remove_keyword("DEVICE_CLASS")
if hasattr(ti3[0], "LUMINANCE_XYZ_CDM2"):
ti3[0].remove_keyword("LUMINANCE_XYZ_CDM2")
if hasattr(ti3[0], "ARGYLL_COLPROF_ARGS"):
del ti3[0].ARGYLL_COLPROF_ARGS
return bytes(ti3[0])
def vcgt_to_cal(profile: ICCProfile) -> CGATS:
"""Return a CAL (CGATS instance) from vcgt.
Args:
profile (ICCProfile): The ICC profile containing the vcgt tag.
Returns:
CGATS: A CGATS instance representing the calibration data.
"""
cgats = CGATS(file_identifier=b"CAL")
context = cgats.add_data({"DESCRIPTOR": b"Argyll Device Calibration State"})
context.add_data({"ORIGINATOR": b"vcgt"})
context.add_data(
{
"CREATED": bytes(
strftime("%a %b %d %H:%M:%S %Y", profile.dateTime.timetuple()),
"utf-8",
"replace",
)
}
)
context.add_keyword("DEVICE_CLASS", b"DISPLAY")
context.add_keyword("COLOR_REP", b"RGB")
context.add_keyword("RGB_I")
key = "DATA_FORMAT"
context[key] = CGATS()
context[key].key = key
context[key].parent = context
context[key].root = cgats
context[key].type = key.encode("utf-8")
context[key].add_data((b"RGB_I", b"RGB_R", b"RGB_G", b"RGB_B"))
key = "DATA"
context[key] = CGATS()
context[key].key = key
context[key].parent = context
context[key].root = cgats
context[key].type = key.encode("utf-8")
values = profile.tags.vcgt.getNormalizedValues()
for i, triplet in enumerate(values):
context[key].add_data((b"%.7f" % (i / float(len(values) - 1)), *triplet))
return cgats
def verify_cgats(
cgats: CGATS, required: tuple[str], ignore_unknown: bool = True
) -> CGATS:
"""Verify and return a CGATS instance or None on failure.
Verify if a CGATS instance has a section with all required fields.
Return the section as CGATS instance on success, None on failure.
If ignore_unknown evaluates to True, ignore fields which are not required.
Otherwise, the CGATS data must contain only the required fields, no more,
no less.
Args:
cgats (CGATS): The CGATS instance to verify.
required (tuple[str]): A tuple of required field names.
ignore_unknown (bool): Whether to ignore unknown fields.
Raises:
CGATSKeyError: If a required field is missing.
CGATSInvalidError: If the CGATS data is invalid or incomplete.
CGATSError: If an unknown field is found and ignore_unknown is False.
Returns:
CGATS: The verified CGATS instance containing the required section,
or raises an error if verification fails.
"""
cgats_1 = cgats.queryi1(required)
if not cgats_1 or not cgats_1.parent or not cgats_1.parent.parent:
raise CGATSKeyError(f"Missing required fields: {', '.join(required)}")
cgats_1 = cgats_1.parent.parent
if not cgats_1.queryv1("NUMBER_OF_SETS"):
raise CGATSInvalidError("Missing NUMBER_OF_SETS")
if not cgats_1.queryv1("DATA_FORMAT"):
raise CGATSInvalidError("Missing DATA_FORMAT")
for field in required:
if field.encode("utf-8") not in list(cgats_1.queryv1("DATA_FORMAT").values()):
raise CGATSKeyError(f"Missing required field: {field}")
if not ignore_unknown:
for field in list(cgats_1.queryv1("DATA_FORMAT").values()):
if field not in required:
raise CGATSError(f"Unknown field: {field}")
modified = cgats_1.modified
cgats_1.filename = cgats.filename
cgats_1.modified = modified
return cgats_1
def verify_ti1_rgb_xyz(cgats: CGATS) -> None | CGATS:
"""Verify and return a CGATS instance or None on failure.
Verify if a CGATS instance has a TI1 section with all required fields
for RGB devices. Return the TI1 section as CGATS instance on success,
None on failure.
Args:
cgats (CGATS): The CGATS instance to verify.
Returns:
None | CGATS: The verified CGATS instance containing the TI1 section, or None
if verification fails.
"""
return verify_cgats(cgats, ("RGB_R", "RGB_B", "RGB_G", "XYZ_X", "XYZ_Y", "XYZ_Z"))
displaycal-py3-3.9.19/DisplayCAL/argyll_instruments.py 000664 000000 000000 00000042400 15225167330 022703 0 ustar 00root root 000000 000000 """Supported instruments and their properties for Argyll CMS.
It provides utilities for managing instrument names, removing vendor prefixes,
and mapping instrument names to canonical forms.
"""
from __future__ import annotations
import re
from DisplayCAL.util_str import strtr
instruments = {
# instrument names from Argyll source spectro/insttypes.c
#
# vid: USB Vendor ID
#
# pid: USB Product ID
#
# hid: Is the device a USB HID (Human Interface Device) class device?
#
# spectral: Does the instrument support spectral readings?
#
# adaptive_mode: Does the instrument support adaptive emissive readings?
#
# highres_mode: Does the instrument support high-res spectral readings?
#
# projector_mode: Does the instrument support a special projector mode?
#
# sensor_cal: Does the instrument need to calibrate its sensor by putting
# it on a reference tile or black surface?
# A value of False for sensor_cal means the instrument can be
# left on the display
# A value of True for sensor_cal means the instrument must be
# removed from the display for sensor calibration if it cannot
# be skipped
#
# skip_sensor_cal: Can the sensor calibration be skipped?
#
# integration_time: Approx. integration time (seconds) for black and white,
# based on measurements on wide-gamut IPS display with
# 0.23 cd/m2 black and 130 cd/m2 white level, rounded to
# multiple of .1 seconds.
# Instruments which I don't own have been estimated.
#
# refresh: Can the instrument do refresh rate measurements?
#
# spectral_cal: Does the instrument support spectral sample (CCSS)
# calibration?
#
# A missing key, or a value of None, means unknown/not tested
#
# Instruments can have an id (short string) that is different than the
# long instrument name. In case no id is given, the instrument name is
# the same as the id.
# TODO: Update instrument names from Argyll 2.3.0
"DTP92": {
"usb_ids": [{"vid": 0x0765, "pid": 0xD092, "hid": False}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"refresh": True,
},
"DTP94": {
"usb_ids": [{"vid": 0x0765, "pid": 0xD094, "hid": False}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": False,
"skip_sensor_cal": False, # DTP94 instrument access fails
# when using -N option to skip automatic sensor calibration
# (dispread -D9 output: "Setting no-sensor_calibrate failed
# with 'Unsupported function'")
"integration_time": [4.0, 1.1], # Estimated
"refresh": True,
},
"Spectrolino": {
"spectral": True,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True,
},
"SpectroScan": {
"spectral": True,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True,
},
"SpectroScanT": {
"spectral": True,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True,
},
"Spectrocam": {
"spectral": True,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": None,
},
"i1 Display": { # Argyll 1.3.5 and earlier
"usb_ids": [{"vid": 0x0670, "pid": 0x0001, "hid": False}],
"id": "i1D1",
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": False,
"skip_sensor_cal": False,
"integration_time": [4.0, 1.0], # Using i1D2 values
"refresh": True,
},
"i1 Display 1": { # Argyll 1.3.6 and newer
"usb_ids": [{"vid": 0x0670, "pid": 0x0001, "hid": False}],
"id": "i1D1",
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": False,
"integration_time": [4.0, 1.0], # Using i1D2 values
"refresh": True,
},
"i1 Display 2": { # Argyll 1.3.6 and newer
"usb_ids": [{"vid": 0x0971, "pid": 0x2003, "hid": False}],
"id": "i1D2",
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": False,
"skip_sensor_cal": False, # i1 Display 2 instrument access fails
# when using -N option to skip automatic sensor calibration
# (dispread -D9 output: "Setting no-sensor_calibrate failed
# with 'Unsupported function'")
"integration_time": [4.0, 1.0], # Measured
"refresh": True,
},
"i1 DisplayPro, ColorMunki Display": {
"usb_ids": [{"vid": 0x0765, "pid": 0x5020, "hid": True}],
"id": "i1D3",
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": False,
"skip_sensor_cal": False,
"measurement_mode_map": {"c": "r", "l": "n"},
"integration_time": [2.6, 0.2], # Measured
"refresh": True,
"spectral_cal": True,
},
"i1 Monitor": { # like i1Pro
"usb_ids": [{"vid": 0x0971, "pid": 0x2001, "hid": False}],
"spectral": True,
"adaptive_mode": True,
"highres_mode": True,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True,
"integration_time": [9.2, 3.9], # Using i1 Pro values
"refresh": True,
},
"i1 Pro": {
"usb_ids": [{"vid": 0x0971, "pid": 0x2000, "hid": False}],
"spectral": True,
"adaptive_mode": True,
"highres_mode": True,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True,
"integration_time": [9.2, 3.9], # Measured (i1 Pro Rev. A)
"refresh": True,
},
"i1 Pro 2": {
"usb_ids": [{"vid": 0x0971, "pid": 0x2000, "hid": False}],
"spectral": True,
"adaptive_mode": True,
"highres_mode": True,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True,
"integration_time": [9.2, 3.9], # Using i1 Pro values
"refresh": True,
},
"i1 Pro 3": {
"usb_ids": [{"vid": 0x0765, "pid": 0x6009, "hid": False}],
"spectral": True,
"adaptive_mode": True,
"highres_mode": True,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True,
"integration_time": [9.2, 3.9], # Still just using i1 Pro values
"refresh": True,
},
"ColorHug": {
"usb_ids": [
{"vid": 0x04D8, "pid": 0xF8DA, "hid": True},
{"vid": 0x273F, "pid": 0x1001, "hid": True},
],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"integration_time": [1.8, 0.8], # Measured (ColorHug #660)
"refresh": True,
},
"ColorHug2": {
"usb_ids": [{"vid": 0x273F, "pid": 0x1004, "hid": True}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"integration_time": [2.0, 0.6], # Measured (ColorHug2 prototype #2)
"refresh": True,
},
"ColorMunki": {
"usb_ids": [
{"vid": 0x0971, "pid": 0x2007, "hid": False},
{"vid": 0x0765, "pid": 0x6008, "hid": False}, # ColorMunki i1Studio
],
"spectral": True,
"adaptive_mode": True,
"highres_mode": True,
"projector_mode": True,
"sensor_cal": True,
"skip_sensor_cal": True,
"integration_time": [9.2, 3.9], # Using i1 Pro values
"refresh": True,
},
"Colorimtre HCFR": {
"usb_ids": [
{"vid": 0x04DB, "pid": 0x005B, "hid": False}, # V3.1
{"vid": 0x04D8, "pid": 0xFE17, "hid": False}, # V4.0
],
"id": "HCFR",
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
},
"ColorMunki Smile": { # Argyll 1.5.x and newer
"usb_ids": [{"vid": 0x0765, "pid": 0x6003, "hid": False}],
"id": "Smile",
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": False,
"skip_sensor_cal": False,
"integration_time": [4.0, 1.0], # Using i1D2 values
},
"EX1": {
"usb_ids": [{"vid": 0x2457, "pid": 0x4000, "hid": False}],
"spectral": True,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True,
"integration_time": [9.2, 3.9], # Using i1 Pro values
},
"K-10": {
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"integration_time": [1.1, 0.1], # Using i1D3 values halved
"refresh": True,
},
"Spyder1": {
"usb_ids": [{"vid": 0x085C, "pid": 0x0100, "hid": False}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"integration_time": [10.5, 2.3], # Using Spyder3 values
},
"Spyder2": {
"usb_ids": [{"vid": 0x085C, "pid": 0x0200, "hid": False}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"integration_time": [10.5, 2.3], # Using Spyder3 values
"refresh": True,
},
"Spyder3": {
"usb_ids": [{"vid": 0x085C, "pid": 0x0300, "hid": False}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"measurement_mode_map": {"c": "r", "l": "n"},
"integration_time": [10.5, 2.3], # Estimated
"refresh": True,
},
"Spyder4": {
"usb_ids": [{"vid": 0x085C, "pid": 0x0400, "hid": False}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"measurement_mode_map": {"c": "r", "l": "n"},
"integration_time": [10.5, 2.3], # Using Spyder3 values
"refresh": True,
"spectral_cal": True,
},
"Spyder5": {
"usb_ids": [{"vid": 0x085C, "pid": 0x0500, "hid": False}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"measurement_mode_map": {"c": "r", "l": "n"},
"integration_time": [10.5, 2.3], # Using Spyder3 values
"refresh": True,
"spectral_cal": True,
},
"SpyderX": {
"usb_ids": [{"vid": 0x085C, "pid": 0x0A00, "hid": False}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True, # Not yet officially, but likely supported in future
"integration_time": [1.6, 1.6],
"refresh": False,
},
"SpyderX2": {
"usb_ids": [{"vid": 0x085C, "pid": 0x0A0B, "hid": False}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True,
"integration_time": [1.6, 1.6], # Using SpyderX values until measured
"refresh": False,
},
"Spyder 2024": {
"usb_ids": [{"vid": 0x085C, "pid": 0x0A0B, "hid": False}],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": True,
"skip_sensor_cal": True,
"integration_time": [1.6, 1.6], # Using SpyderX values until measured
"refresh": False,
},
"Huey": {
"usb_ids": [
{"vid": 0x0971, "pid": 0x2005, "hid": True},
{"vid": 0x0765, "pid": 0x5001, "hid": True}, # HueyL
{"vid": 0x0765, "pid": 0x5010, "hid": True}, # HueyL
],
"spectral": False,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"integration_time": [4.0, 1.0], # Using i1D2 values
},
"specbos": {
"spectral": True,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"measurement_mode_map": {"c": "r", "l": "n"},
"integration_time": [3.3, 0.8], # Estimated, VERY rough
"refresh": True,
},
"specbos 1201": {
"spectral": True,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"integration_time": [10.3, 2.8], # Estimated, VERY rough
"refresh": True,
},
"spectraval": {
"spectral": True,
"adaptive_mode": False,
"highres_mode": False,
"projector_mode": False,
"sensor_cal": None,
"skip_sensor_cal": None,
"integration_time": [3.3, 0.8], # Estimated, VERY rough
"refresh": True,
},
"Dummy Meter / Hires & Projector": {
# dummy instrument, just for testing
"spectral": False,
"adaptive_mode": False,
"highres_mode": True,
"projector_mode": True,
"sensor_cal": False,
"skip_sensor_cal": False,
},
"Dummy Spectro / Hires & Projector": {
# dummy instrument, just for testing
"spectral": True,
"adaptive_mode": False,
"highres_mode": True,
"projector_mode": True,
"sensor_cal": True,
"skip_sensor_cal": True,
},
"Dummy Meter / Adaptive, Hires & Projector": {
# dummy instrument, just for testing
"spectral": False,
"adaptive_mode": True,
"highres_mode": True,
"projector_mode": True,
"sensor_cal": False,
"skip_sensor_cal": False,
},
"Dummy Spectro / Adaptive, Hires & Projector": {
# dummy instrument, just for testing
"spectral": True,
"adaptive_mode": True,
"highres_mode": True,
"projector_mode": True,
"sensor_cal": True,
"skip_sensor_cal": True,
},
}
vendors = [
"ColorVision",
"Datacolor",
"GretagMacbeth",
"Hughski",
"Image Engineering",
"JETI",
"Klein",
"X-Rite",
"Xrite",
]
def get_canonical_instrument_name(
instrument_name: bytes | str,
replacements: None | dict = None,
inverse: bool = False,
) -> str:
"""Get canonical instrument name.
This function removes vendor names from the instrument name and replaces
the instrument name with a canonical name if it is found in the
replacements dictionary.
Args:
instrument_name (bytes, str): Instrument name to be canonicalized.
replacements (dict): Dictionary of replacements. The keys are the
canonical names and the values are the instrument names to be
replaced. If None, no replacements are made.
inverse (bool): If True, the replacements are inverted. The keys are
the instrument names and the values are the canonical names. If
False, the replacements are not inverted. Default is False.
Returns:
str: Canonical instrument name.
"""
replacements = replacements or {}
if inverse:
replacements = dict(zip(iter(replacements.values()), iter(replacements.keys())))
return strtr(remove_vendor_names(instrument_name), replacements)
def remove_vendor_names(txt: str) -> str:
"""Remove vendor names from the instrument name.
Args:
txt (bytes, str): Instrument name to be processed.
Returns:
str: Instrument name without vendor names.
"""
for vendor in vendors:
if isinstance(txt, bytes):
txt = re.sub(
re.compile(re.escape(bytes(vendor, "utf-8")) + rb"\s*", re.I), b"", txt
)
elif isinstance(txt, str):
txt = re.sub(re.compile(re.escape(vendor) + r"\s*", re.I), "", txt)
txt = txt.strip()
return txt
displaycal-py3-3.9.19/DisplayCAL/argyll_names.py 000664 000000 000000 00000005201 15225167330 021411 0 ustar 00root root 000000 000000 """Argyll CMS tool names and related configurations for DisplayCAL.
It includes predefined tool names, optional tools, alternative naming
conventions, viewing conditions, intents, video encodings, and observer types.
"""
# Argyll CMS tools used by DisplayCAL
NAMES = [
"applycal",
"average",
"cctiff",
"ccxxmake",
"dispcal",
"dispread",
"collink",
"colprof",
"dispwin",
"fakeread",
"iccgamut",
"icclu",
"xicclu",
"spotread",
"spyd2en",
"spyd4en",
"targen",
"tiffgamut",
"timage",
"txt2ti3",
"i1d3ccss",
"viewgam",
"oeminst",
"profcheck",
"spec2cie",
"specplot",
]
# Argyll CMS tools optionally used by DisplayCAL
OPTIONAL = [
"applycal",
"average",
"cctiff",
"ccxxmake",
"i1d3ccss",
"oeminst",
"specplot",
"spec2cie",
"spyd2en",
"spyd4en",
"tiffgamut",
"timage",
]
PREFIXES_SUFFIXES = ["argyll"]
# Alternative tool names (from older Argyll CMS versions or with filename
# prefix/suffix like on some Linux distros)
ALTNAMES = {
"txt2ti3": ["logo2cgats"],
"icclu": ["xicclu"],
"ccxxmake": ["ccmxmake"],
"i1d3ccss": ["oeminst"],
"spyd2en": ["oeminst"],
"spyd4en": ["oeminst"],
}
def add_prefixes_suffixes(name: str, altname: str) -> None:
"""Add prefixes and suffixes to the alternative tool names.
Args:
name (str): The original tool name.
altname (str): The alternative tool name.
"""
for prefix_suffix in PREFIXES_SUFFIXES:
ALTNAMES[name].append(f"{altname}-{prefix_suffix}")
ALTNAMES[name].append(f"{prefix_suffix}-{altname}")
# Automatically populate the alternative tool names with prefixed/suffixed
# versions
for name in NAMES:
if name not in ALTNAMES:
ALTNAMES[name] = []
_altnames = list(ALTNAMES[name])
for altname in _altnames:
add_prefixes_suffixes(name, altname)
ALTNAMES[name].append(name)
add_prefixes_suffixes(name, name)
ALTNAMES[name].reverse()
# Viewing conditions supported by colprof (only predefined choices)
VIEWCONDS = [
"pp",
"pe",
"pc", # Argyll 1.1.1
"mt",
"mb",
"md",
"jm",
"jd",
"tv", # Argyll 1.6
"pcd",
"ob",
"cx",
]
# Intents supported by colprof
# pa = Argyll >= 1.3.3
# lp = Argyll >= 1.8.3
INTENTS = ["a", "aa", "aw", "la", "lp", "ms", "p", "pa", "r", "s"]
# Video input/output encodings supported by collink (Argyll >= 1.6)
VIDEO_ENCODINGS = ["n", "t", "6", "7", "5", "2", "C", "x", "X"]
# Observers
# TODO: OBSERVERS should include 2012_2 and 2012_10.
OBSERVERS = ["1931_2", "1955_2", "1964_10", "1964_10c", "1978_2", "shaw"]
displaycal-py3-3.9.19/DisplayCAL/argyll_rgb2xyz.py 000664 000000 000000 00000010447 15225167330 021725 0 ustar 00root root 000000 000000 """Functions and data for RGB/XYZ color space conversions.
It defines ink tables, normalization factors, and channel mappings used in the
conversion process.
"""
import math
from DisplayCAL import colormath
# from xcolorants.c
ICX_INK_TABLE = {
"C": [[0.12, 0.18, 0.48], [0.12, 0.18, 0.48]],
"M": [[0.38, 0.19, 0.20], [0.38, 0.19, 0.20]],
"Y": [[0.76, 0.81, 0.11], [0.76, 0.81, 0.11]],
"K": [[0.01, 0.01, 0.01], [0.04, 0.04, 0.04]],
"O": [[0.59, 0.41, 0.03], [0.59, 0.41, 0.05]],
"R": [[0.412414, 0.212642, 0.019325], [0.40, 0.21, 0.05]],
"G": [[0.357618, 0.715136, 0.119207], [0.11, 0.27, 0.21]],
"B": [[0.180511, 0.072193, 0.950770], [0.11, 0.27, 0.47]],
"W": [
[0.950543, 1.0, 1.089303], # D65 ?
colormath.get_standard_illuminant("D50"),
], # D50
"LC": [[0.76, 0.89, 1.08], [0.76, 0.89, 1.08]],
"LM": [[0.83, 0.74, 1.02], [0.83, 0.74, 1.02]],
"LY": [[0.88, 0.97, 0.72], [0.88, 0.97, 0.72]],
"LK": [[0.56, 0.60, 0.65], [0.56, 0.60, 0.65]],
"MC": [[0.61, 0.81, 1.07], [0.61, 0.81, 1.07]],
"MM": [[0.74, 0.53, 0.97], [0.74, 0.53, 0.97]],
"MY": [[0.82, 0.93, 0.40], [0.82, 0.93, 0.40]],
"MK": [[0.27, 0.29, 0.31], [0.27, 0.29, 0.31]],
"LLK": [
[0.76, 0.72, 0.65], # Very rough - should substitute real numbers
[0.76, 0.72, 0.65],
],
"": [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
}
NORMALIZATION_FACTOR = {"Ynorm": 0.0}
IIX_CHANNEL_MAPPING = {"iix": {0: "R", 1: "G", 2: "B"}}
for e in range(3):
NORMALIZATION_FACTOR["Ynorm"] += ICX_INK_TABLE[IIX_CHANNEL_MAPPING["iix"][e]][0][1]
NORMALIZATION_FACTOR["Ynorm"] = 1.0 / NORMALIZATION_FACTOR["Ynorm"]
def xyz_denormalize_remove_glare(x: float, y: float, z: float) -> tuple:
"""Convert XYZ to RGB using the inverse of the RGB to XYZ conversion.
Args:
x (float): The X component of the XYZ color.
y (float): The Y component of the XYZ color.
z (float): The Z component of the XYZ color.
Returns:
tuple: A tuple containing the X, Y, and Z components of the XYZ color.
"""
xyz = [x, y, z]
# De-Normalize Y from 1.0, & remove black glare
for j in range(3):
xyz[j] = (xyz[j] - ICX_INK_TABLE["K"][0][j]) / (1.0 - ICX_INK_TABLE["K"][0][j])
xyz[j] /= NORMALIZATION_FACTOR["Ynorm"]
return tuple(xyz)
def xyz_normalize_add_glare(x: float, y: float, z: float) -> tuple:
"""Convert XYZ to RGB using the inverse of the RGB to XYZ conversion.
Args:
x (float): The X component of the XYZ color.
y (float): The Y component of the XYZ color.
z (float): The Z component of the XYZ color.
Returns:
tuple: A tuple containing the X, Y, and Z components of the XYZ color.
"""
xyz = [x, y, z]
# Normalize Y to 1.0, & add black glare
for j in range(3):
xyz[j] *= NORMALIZATION_FACTOR["Ynorm"]
xyz[j] = xyz[j] * (1.0 - ICX_INK_TABLE["K"][0][j]) + ICX_INK_TABLE["K"][0][j]
return tuple(xyz)
def rgb2xyz(r: float, g: float, b: float) -> tuple:
"""Convert RGB to XYZ using the RGB to XYZ conversion.
from xcolorants.c -> icxColorantLu_to_XYZ
Args:
r (float): The red component of the RGB color.
g (float): The green component of the RGB color.
b (float): The blue component of the RGB color.
Returns:
tuple: A tuple containing the X, Y, and Z components of the XYZ color.
"""
d = (r, g, b)
# We assume a simple additive model with gamma
xyz = [0.0, 0.0, 0.0]
for e in range(3):
v = d[e]
if v < 0.0:
v = 0.0
elif v > 1.0:
v = 1.0
if v <= 0.03928:
v /= 12.92
else:
v = math.pow((0.055 + v) / 1.055, 2.4) # Gamma
for j in range(3):
xyz[j] += v * ICX_INK_TABLE[IIX_CHANNEL_MAPPING["iix"][e]][0][j]
return xyz_normalize_add_glare(*xyz)
def xyz2rgb(x: float, y: float, z: float) -> tuple:
"""Convert XYZ to RGB using the inverse of the RGB to XYZ conversion.
Args:
x (float): The X component of the XYZ color.
y (float): The Y component of the XYZ color.
z (float): The Z component of the XYZ color.
Returns:
tuple: A tuple containing the R, G, and B components of the RGB color.
"""
return colormath.XYZ2RGB(*xyz_denormalize_remove_glare(x, y, z))
displaycal-py3-3.9.19/DisplayCAL/audio.py 000664 000000 000000 00000077221 15225167330 020050 0 ustar 00root root 000000 000000 """Audio wrapper module.
Can use SDL, pyglet, pyo or wx.
pyglet or SDL will be used by default if available.
pyglet can only be used if version >= 1.2.2 is available.
pyo is still buggy under Linux and has a few quirks under Windows.
wx doesn't support fading, changing volume, multiple concurrent sounds,
and only supports wav format.
Example:
sound = Sound("test.wav", loop=True)
sound.Play(fade_ms=1000)
"""
from __future__ import annotations
import atexit
import contextlib
import ctypes.util
import os
import sys
import threading
import time
from ctypes import (
POINTER,
Structure,
c_int,
c_uint8,
c_uint16,
c_uint32,
)
from typing import TYPE_CHECKING, ClassVar
if sys.platform == "win32":
try:
import pywintypes
import win32api
except ImportError:
win32api = None
from DisplayCAL.config import PYDIR
from DisplayCAL.util_os import dlopen, getenvu
from DisplayCAL.util_str import safe_str
if TYPE_CHECKING:
import pyglet.media # noqa: TC004
import pyo # noqa: TC004
import sdl # noqa: TC004
import sdl2 # noqa: TC004
import wx
# Workaround for pyglet crash on exit
try:
import pyglet
except ImportError:
pass
else:
def _pyglet_cleanup():
with contextlib.suppress(Exception):
for ch in list(_CH.values()):
if hasattr(ch, "delete"):
ch.delete()
# Only touch the audio driver when pyglet.media was actually
# imported during this session. Calling get_audio_driver() when
# the module is absent would initialize (and immediately tear down)
# the driver, which crashes on macOS via Swift/AVFoundation during
# atexit.
if "pyglet.media" not in sys.modules:
return
driver = pyglet.media.get_audio_driver()
if driver:
driver.delete()
atexit.register(_pyglet_cleanup)
_CH = {}
_INITIALIZED = False
_LIB = None
_LIB_VERSION = None
_SERVER = None
_SND = {}
_SOUNDS = {}
# Loaded SDL library (set by the _init_sdl_* helpers, read by the Sound class).
sdl = None
SDL_INIT_AUDIO = 16
AUDIO_S16LSB = 0x8010
AUDIO_S16MSB = 0x9010
MIX_DEFAULT_FORMAT = AUDIO_S16LSB if sys.byteorder == "little" else AUDIO_S16MSB
def init(
lib: None | str = None,
samplerate: int = 22050,
channels: int = 2,
buffersize: int = 2048,
reinit: str = False,
) -> None | pyglet.media | pyo.Server | sdl.Mixer | sdl2.Mixer | wx.Sound:
"""(Re-)Initialize sound subsystem.
Args:
lib (str): The audio library to use (e.g., "SDL", "pyglet", "pyo", "wx").
samplerate (int): The sample rate to use.
channels (int): The number of audio channels.
buffersize (int): The size of the audio buffer.
reinit (bool): Whether to reinitialize the sound subsystem.
Returns:
None | pyglet.media | pyo.Server | sdl.Mixer | sdl2.Mixer | wx.Sound:
The initialized audio library or None if no suitable library was found.
"""
# Note on buffer size: Too high values cause crackling during fade, too low
# values cause choppy playback of ogg files when using pyo (good value for
# pyo is >= 2048)
global _INITIALIZED, _LIB, _LIB_VERSION, _SERVER, pyglet, pyo, sdl, wx
if _INITIALIZED and not reinit:
# To re-initialize, explicitly set reinit to True
return None
# Select the audio library we're going to use.
# User choice or SDL > pyglet > pyo > wx
if not lib:
if sys.platform in ("darwin", "win32"):
# Mac OS X, Windows
libs = ("pyglet", "SDL", "pyo", "wx")
else:
# Linux
libs = ("SDL", "pyglet", "pyo", "wx")
audio_lib = None
for lib_ in libs:
try:
audio_lib = init(lib_, samplerate, channels, buffersize, reinit)
break
except Exception:
pass
if not audio_lib:
raise RuntimeError("No suitable audio library found!")
return audio_lib
if lib == "pyglet":
_init_pyglet()
elif lib == "pyo":
_init_pyo(samplerate, channels, buffersize)
elif lib == "SDL":
_init_sdl(samplerate, channels, buffersize)
elif lib == "wx":
_init_wx()
if not _LIB:
raise RuntimeError("No audio library available")
_INITIALIZED = True
return _SERVER
def _init_wx() -> None:
"""Initialize wx audio subsystem."""
global _SERVER, _LIB, _LIB_VERSION, wx
try:
import wx
_LIB = "wx"
except ImportError:
_LIB = None
else:
_SERVER = wx
_LIB_VERSION = wx.__version__
def _load_audio_dll(
sdl: None | sdl.Mixer | sdl2.Mixer,
samplerate: int,
channels: int,
buffersize: int,
libname: str,
libfn: str | None,
handle: None | int | str = None,
) -> None | sdl.Mixer | sdl2.Mixer:
"""Load the audio DLL.
Args:
sdl (None | sdl.Mixer | sdl2.Mixer): The SDL audio library to use.
samplerate (int): The sample rate to use.
channels (int): The number of audio channels.
buffersize (int): The size of the audio buffer.
libname (str): The name of the audio library.
libfn (str | None): The filename of the audio library.
handle (None | int | str): The handle to the loaded library.
Returns:
None | sdl.Mixer | sdl2.Mixer: The loaded SDL audio library or None if
the library could not be loaded.
"""
global _SERVER, _LIB, _LIB_VERSION, _INITIALIZED
dll = dlopen(libfn, handle=handle)
if dll:
print(f"{libname}:", libfn)
if libname.endswith("_mixer"):
if not dll:
return None
if not sdl:
raise RuntimeError("SDL library not loaded")
sdl.SDL_RWFromFile.restype = POINTER(SDL_RWops)
_SERVER = dll
_SERVER.Mix_OpenAudio.argtypes = [c_int, c_uint16, c_int, c_int]
_SERVER.Mix_LoadWAV_RW.argtypes = [POINTER(SDL_RWops), c_int]
_SERVER.Mix_LoadWAV_RW.restype = POINTER(Mix_Chunk)
_SERVER.Mix_PlayChannelTimed.argtypes = [
c_int,
POINTER(Mix_Chunk),
c_int,
c_int,
]
_SERVER.Mix_VolumeChunk.argtypes = [POINTER(Mix_Chunk), c_int]
if _INITIALIZED:
_SERVER.Mix_Quit()
sdl.SDL_Quit()
sdl.SDL_Init(SDL_INIT_AUDIO)
_SERVER.Mix_OpenAudio(samplerate, MIX_DEFAULT_FORMAT, channels, buffersize)
_LIB = "SDL"
_LIB_VERSION = "2.0" if libname.startswith("SDL2") else "1.2"
return sdl
sdl = dll
_SERVER = None
return sdl
def _init_sdl_windows(samplerate: int, channels: int, buffersize: int) -> None:
"""Initialize SDL on Windows.
Args:
samplerate (int): The sample rate to use.
channels (int): The number of audio channels.
buffersize (int): The size of the audio buffer.
"""
global _SERVER, sdl
sdl = None
pth = getenvu("PATH")
libpth = os.path.join(PYDIR, "lib")
if not pth.startswith(libpth + os.pathsep):
pth = libpth + os.pathsep + pth
os.environ["PATH"] = safe_str(pth)
for libname in ("SDL2", "SDL2_mixer", "SDL", "SDL_mixer"):
handle = None
libfn = ctypes.util.find_library(libname)
if libfn and win32api:
# Support for unicode paths
libfn = str(libfn)
with contextlib.suppress(pywintypes.error):
handle = win32api.LoadLibrary(libfn)
sdl = _load_audio_dll(
sdl,
samplerate,
channels,
buffersize,
libname,
libfn,
handle,
)
def _init_sdl_macos(samplerate: int, channels: int, buffersize: int) -> None:
"""Initialize SDL on macOS.
Args:
samplerate (int): The sample rate to use.
channels (int): The number of audio channels.
buffersize (int): The size of the audio buffer.
"""
global _SERVER, sdl
sdl = None
if x_framework_pth := os.getenv("X_DYLD_FALLBACK_FRAMEWORK_PATH"):
if framework_pth := os.getenv("DYLD_FALLBACK_FRAMEWORK_PATH"):
x_framework_pth = os.pathsep.join([x_framework_pth, framework_pth])
os.environ["DYLD_FALLBACK_FRAMEWORK_PATH"] = x_framework_pth
for libname in ("SDL2", "SDL2_mixer", "SDL", "SDL_mixer"):
handle = None
libfn = ctypes.util.find_library(libname)
sdl = _load_audio_dll(
sdl,
samplerate,
channels,
buffersize,
libname,
libfn,
handle,
)
def _init_sdl_linux(samplerate: int, channels: int, buffersize: int) -> None:
"""Initialize SDL on Linux.
Args:
samplerate (int): The sample rate to use.
channels (int): The number of audio channels.
buffersize (int): The size of the audio buffer.
"""
global _SERVER, sdl
sdl = None
for libname in ("SDL2", "SDL2_mixer", "SDL", "SDL_mixer"):
handle = None
# Hard-code lib names for Linux
libfn = f"lib{libname}"
if libname.startswith("SDL2"):
# SDL 2.0
libfn += "-2.0.so.0"
else:
# SDL 1.2
libfn += "-1.2.so.0"
sdl = _load_audio_dll(
sdl,
samplerate,
channels,
buffersize,
libname,
libfn,
handle,
)
def _init_sdl(samplerate: int, channels: int, buffersize: int) -> None:
"""Initialize SDL audio subsystem.
Args:
samplerate (int): The sample rate to use.
channels (int): The number of audio channels.
buffersize (int): The size of the audio buffer.
"""
if sys.platform == "win32":
_init_sdl_windows(samplerate, channels, buffersize)
elif sys.platform == "darwin":
_init_sdl_macos(samplerate, channels, buffersize)
else:
_init_sdl_linux(samplerate, channels, buffersize)
def _init_pyo(samplerate: int, channels: int, buffersize: int) -> None:
"""Initialize pyo audio subsystem.
Args:
samplerate (int): The sample rate to use.
channels (int): The number of audio channels.
buffersize (int): The size of the audio buffer.
Raises:
ImportError: If pyo is not installed or cannot be imported.
RuntimeError: If pyo server initialization fails.
"""
global _SERVER, _LIB, _LIB_VERSION, pyo
try:
import pyo
_LIB = "pyo"
except ImportError:
_LIB = None
else:
if isinstance(_SERVER, pyo.Server):
_SERVER.reinit(
sr=samplerate, nchnls=channels, buffersize=buffersize, duplex=0
)
else:
_SERVER = pyo.Server(
sr=samplerate,
nchnls=channels,
buffersize=buffersize,
duplex=0,
winhost="asio",
).boot()
_SERVER.start()
_LIB_VERSION = ".".join(str(v) for v in pyo.getVersion())
def _init_pyglet() -> None:
"""Initialize pyglet audio subsystem."""
global _SERVER, _LIB, _LIB_VERSION, pyglet
if not getattr(sys, "frozen", False):
# Use included pyglet
lib_dir = os.path.join(os.path.dirname(__file__), "lib")
if lib_dir not in sys.path:
sys.path.insert(0, lib_dir)
try:
import pyglet
version = []
for item in pyglet.version.split("."):
try:
version.append(int(item))
except ValueError:
version.append(item)
if version < [1, 2, 2]:
raise ImportError(f"pyglet version {pyglet.version} is too old")
_LIB = "pyglet"
except ImportError:
_LIB = None
else:
# Work around localization preventing fallback to RIFFSourceLoader
pyglet.lib.LibraryLoader.darwin_not_found_error = ""
pyglet.lib.LibraryLoader.linux_not_found_error = ""
# Set audio driver preference
pyglet.options["audio"] = ("pulse", "openal", "directsound", "silent")
_SERVER = pyglet.media
_LIB_VERSION = pyglet.version
def safe_init(
lib: None | str = None,
samplerate: int = 22050,
channels: int = 2,
buffersize: int = 2048,
reinit: bool = False,
) -> None | Exception:
"""Safely initialize the sound subsystem.
Like init(), but catch any exceptions.
Args:
lib (str): The audio library to use (e.g., "SDL", "pyglet", "pyo", "wx").
samplerate (int): The sample rate to use.
channels (int): The number of audio channels.
buffersize (int): The size of the audio buffer.
reinit (bool): Whether to reinitialize the sound subsystem.
Returns:
None | Exception: None if initialization was successful, or an
Exception if an error occurred.
"""
global _INITIALIZED
try:
return init(lib, samplerate, channels, buffersize, reinit)
except Exception as exception:
# So we can check if initialization failed
_INITIALIZED = exception
return exception
class DummySound:
"""Dummy sound wrapper class.
Args:
filename (str): The filename of the sound file (not used).
loop (bool): Whether to loop the sound (not used).
"""
def __init__(self, filename: None | str = None, loop: bool = False) -> None:
pass
def fade(self, fade_ms: int, fade_in: None | bool = None) -> bool:
"""Fade in/out.
Args:
fade_ms (int): Fade in/out duration in milliseconds.
fade_in (bool): If True, fade in, if False, fade out. If None,
fade in if currently not playing, otherwise fade out.
Returns:
bool: Always True for DummySound.
"""
return True
@property
def is_playing(self) -> bool:
"""Return whether the sound is currently playing.
Returns:
bool: Always False for DummySound.
"""
return False
def play(self, fade_ms: int = 0) -> bool:
"""Play the sound.
Args:
fade_ms (int): Fade in duration in milliseconds.
Returns:
bool: True if the sound was played, False otherwise.
"""
return True
@property
def play_count(self) -> int:
"""Return the number of times the sound has been played.
Returns:
int: The number of times the sound has been played.
"""
return 0
def safe_fade(self, fade_ms: int, fade_in: None | bool = None) -> bool:
"""Like fade(), but catch any exceptions.
Args:
fade_ms (int): Fade in/out duration in milliseconds.
fade_in (None | bool): If True, fade in, if False, fade out. If
None, fade in if currently not playing, otherwise fade out.
Returns:
bool: True if the fade was successful, False otherwise.
"""
return True
def safe_play(self, fade_ms: int = 0) -> bool:
"""Like play(), but catch any exceptions.
Args:
fade_ms (int): Fade in duration in milliseconds.
Returns:
bool: True if the sound was played, False otherwise.
"""
return True
def safe_stop(self, fade_ms: int = 0) -> bool:
"""Like stop(), but catch any exceptions.
Args:
fade_ms (int): Fade out duration in milliseconds.
Returns:
bool: True if the sound was stopped, False otherwise.
"""
return True
def stop(self, fade_ms: int = 0) -> bool:
"""Stop playback.
Args:
fade_ms (int): Fade out duration in milliseconds.
Returns:
bool: True if the sound was stopped, False otherwise.
"""
return True
volume = 0
class SDL_RWops(Structure): # noqa: N801
"""SDL_RWops structure."""
class Mix_Chunk(Structure): # noqa: N801
"""SDL_Mixer chunk structure."""
_fields_: ClassVar[list[tuple]] = [
("allocated", c_int),
("abuf", POINTER(c_uint8)),
("alen", c_uint32),
("volume", c_uint8),
]
class Sound:
"""Sound wrapper class.
Args:
filename (str): The filename of the sound file.
loop (bool): Whether to loop the sound.
"""
def __new__(cls, filename: str, loop: bool = False) -> Sound: # noqa: PYI034
"""Create a new Sound instance.
Args:
filename (str): The filename of the sound file.
loop (bool): Whether to loop the sound.
Returns:
Sound: A new Sound instance.
"""
if (filename, loop) in _SOUNDS:
# Cache hit
return _SOUNDS[(filename, loop)]
# Create and instance and cache it
sound = super().__new__(cls)
_SOUNDS[(filename, loop)] = sound
return sound
def __init__(self, filename: str, loop: bool = False) -> None:
self._filename = filename
self._is_playing = False
self._lib = _LIB
self._lib_version = _LIB_VERSION
self._loop = loop
self._play_timestamp = 0
self._play_count = 0
self._thread = -1
if not _INITIALIZED:
self._server = init()
else:
self._server = _SERVER
if not _INITIALIZED or isinstance(_INITIALIZED, Exception):
return
if not self._lib and _LIB:
self._lib = _LIB
self._lib_version = _LIB_VERSION
if self._snd or not self._filename:
return
if self._lib == "pyo":
self._snd = pyo.SfPlayer(safe_str(self._filename), loop=self._loop)
elif self._lib == "pyglet":
snd = pyglet.media.load(self._filename, streaming=False)
self._ch = pyglet.media.Player()
self._snd = snd
elif self._lib == "SDL":
rw = sdl.SDL_RWFromFile(safe_str(self._filename, "UTF-8"), "rb")
self._snd = self._server.Mix_LoadWAV_RW(rw, 1)
elif self._lib == "wx":
self._snd = wx.Sound(self._filename)
@property
def _ch(self) -> None | int | pyglet.media.Player:
"""Return the channel object or value.
Returns:
None | int | pyglet.media.Player : The channel object or None if
not available.
"""
return _CH.get((self._filename, self._loop))
@_ch.setter
def _ch(self, ch: None | int | pyglet.media.Player) -> None:
"""Set the channel object or value.
Args:
ch (None | int | pyglet.media.Player): The channel object to set.
"""
_CH[(self._filename, self._loop)] = ch
def _fade(self, fade_ms: int, fade_in: bool, thread: int) -> None:
"""Fade in/out the sound.
Args:
fade_ms (int): Fade in/out duration in milliseconds.
fade_in (bool): If True, fade in, if False, fade out.
thread (int): Thread identifier to check if we are still the current thread.
"""
volume = self.volume
if fade_ms and ((fade_in and volume < 1) or (not fade_in and volume)):
count = 200
for i in range(count + 1):
if fade_in:
self.volume = volume + i / float(count) * (1.0 - volume)
else:
self.volume = volume - i / float(count) * volume
time.sleep(fade_ms / 1000.0 / count)
if self._thread is not thread:
# If we are no longer the current thread, return immediately
return
if not self.volume:
self.stop()
@property
def volume(self) -> float:
"""Return the current volume of the sound.
If the sound is not playing, return 0.0.
If the sound is not available, return 1.0.
Returns:
float: The current volume of the sound, between 0.0 and 1.0.
"""
volume = 1.0
if self._snd:
if self._lib == "pyo":
volume = self._snd.mul
elif self._lib == "pyglet":
volume = self._ch.volume
elif self._lib == "SDL":
volume = float(self._server.Mix_VolumeChunk(self._snd, -1)) / 128
return volume
@volume.setter
def volume(self, volume: float) -> None:
"""Set the volume of the sound.
Args:
volume (float): The volume to set, between 0.0 and 1.0.
"""
if not self._snd or self._lib == "wx":
return
if self._lib == "pyo":
self._snd.mul = volume
elif self._lib == "pyglet":
self._ch.volume = volume
elif self._lib == "SDL":
self._server.Mix_VolumeChunk(self._snd, round(volume * 128))
@property
def _snd(self) -> None | Sound:
"""Return the sound object.
Returns:
None | Sound: The sound object or None if not available.
"""
return _SND.get((self._filename, self._loop))
@_snd.setter
def _snd(self, snd: Sound) -> None:
"""Set the sound object.
Args:
snd: The sound object to set.
"""
_SND[(self._filename, self._loop)] = snd
def fade(self, fade_ms: int, fade_in: None | bool = None) -> bool:
"""Fade in/out.
If fade_in is None, fade in/out depending on current volume.
Args:
fade_ms (int): Fade in/out duration in milliseconds.
fade_in (bool): If True, fade in, if False, fade out. If None,
fade in if currently not playing, otherwise fade out.
Returns:
bool: True if the fade was started, False otherwise.
"""
if fade_in is None:
fade_in = not self.volume
if fade_in and not self.is_playing:
return self.play(fade_ms=fade_ms)
if not self._snd or self._lib == "wx":
return False
self._thread += 1
threading.Thread(
target=self._fade,
name=f"AudioFading-{self._thread}[{fade_ms}ms]",
args=(fade_ms, fade_in, self._thread),
).start()
return True
@property
def is_playing(self) -> bool:
"""Return whether the sound is currently playing.
Returns:
bool: True if the sound is playing, False otherwise.
"""
if self._lib == "pyo":
return bool(self._snd and self._snd.isOutputting())
if self._lib == "pyglet":
return bool(
self._ch
and self._ch.playing
and self._ch.source
and (
self._loop
or time.time() - self._play_timestamp < self._ch.source.duration
)
)
if self._lib == "SDL":
return bool(self._ch is not None and self._server.Mix_Playing(self._ch))
return self._is_playing
def _play_pyglet(self, fade_ms: int = 0, stop_already_playing: bool = True) -> bool:
"""Play the sound using pyglet.
Args:
fade_ms (int): Fade in duration in milliseconds.
stop_already_playing (bool): If True, stop the sound if it is
already playing before starting playback.
Returns:
bool: True if the sound was played, False otherwise.
"""
if not self._snd:
return False
volume = self.volume
if stop_already_playing:
self.stop()
# Can't reuse the player, won't replay the sound under Mac OS X
# and Linux even when seeking to start position which allows
# replaying the sound under Windows.
if stop_already_playing:
with contextlib.suppress(TypeError):
self._ch.delete()
self._ch = pyglet.media.Player()
if self._lib_version >= "1.4.0":
self._ch.loop = self._loop
self.volume = volume
if not self.is_playing and fade_ms and volume == 1:
self.volume = 0
self._play_timestamp = time.time()
if self._loop and self._lib_version < "1.4.0":
snd = pyglet.media.SourceGroup(
self._snd.audio_format, self._snd.video_format
)
snd.loop = True
snd.queue(self._snd)
else:
snd = self._snd
self._ch.queue(snd)
self._ch.play()
if self._lib:
self._play_count += 1
if fade_ms:
self.fade(fade_ms, True)
return True
def _play_pyo(self, fade_ms: int = 0, stop_already_playing: bool = True) -> bool:
"""Play the sound using pyo.
Args:
fade_ms (int): Fade in duration in milliseconds.
stop_already_playing (bool): If True, stop the sound if it is
already playing before starting playback.
Returns:
bool: True if the sound was played, False otherwise.
"""
if not self._snd:
return False
volume = self.volume
if stop_already_playing:
self.stop()
if not self.is_playing and fade_ms and volume == 1:
self.volume = 0
self._play_timestamp = time.time()
self._snd.out()
if self._lib:
self._play_count += 1
if fade_ms:
self.fade(fade_ms, True)
return True
def _play_sdl(self, fade_ms: int = 0, stop_already_playing: bool = True) -> bool:
"""Play the sound using SDL.
Args:
fade_ms (int): Fade in duration in milliseconds.
stop_already_playing (bool): If True, stop the sound if it is
already playing before starting playback.
Returns:
bool: True if the sound was played, False otherwise.
"""
if not self._snd:
return False
volume = self.volume
if stop_already_playing:
self.stop()
if not self.is_playing and fade_ms and volume == 1:
self.volume = 0
self._play_timestamp = time.time()
self._ch = self._server.Mix_PlayChannelTimed(
-1, self._snd, -1 if self._loop else 0, -1
)
if self._lib:
self._play_count += 1
if fade_ms:
self.fade(fade_ms, True)
return True
def _play_wx(self, fade_ms: int = 0, stop_already_playing: bool = True) -> bool:
"""Play the sound using wx.
Args:
fade_ms (int): Fade in duration in milliseconds.
stop_already_playing (bool): If True, stop the sound if it is
already playing before starting playback.
Returns:
bool: True if the sound was played, False otherwise.
"""
if not self._snd:
return False
volume = self.volume
if stop_already_playing:
self.stop()
if not self.is_playing and fade_ms and volume == 1:
self.volume = 0
self._play_timestamp = time.time()
if self._snd.IsOk():
flags = wx.SOUND_ASYNC
if self._loop:
flags |= wx.SOUND_LOOP
# The best we can do is have the correct state reflected
# for looping sounds only
self._is_playing = True
# wx.Sound.Play is supposed to return True on success.
# When I tested this, it always returned False, but still
# played the sound.
self._snd.Play(flags)
if self._lib:
self._play_count += 1
return True
def play(self, fade_ms: int = 0, stop_already_playing: bool = True) -> bool:
"""Play the sound.
Args:
fade_ms (int): Fade in duration in milliseconds.
stop_already_playing (bool): If True, stop the sound if it is
already playing before starting playback.
Returns:
bool: True if the sound was played, False otherwise.
"""
if not self._snd:
return False
if self._lib == "pyglet":
return self._play_pyglet(fade_ms, stop_already_playing)
if self._lib == "pyo":
return self._play_pyo(fade_ms, stop_already_playing)
if self._lib == "pyglet":
return self._play_pyglet(fade_ms, stop_already_playing)
if self._lib == "SDL":
return self._play_sdl(fade_ms, stop_already_playing)
if self._lib == "wx":
return self._play_wx(fade_ms, stop_already_playing)
return True
@property
def play_count(self) -> int:
"""Return the number of times the sound has been played.
Returns:
int: The number of times the sound has been played.
"""
return self._play_count
def safe_fade(self, fade_ms: int, fade_in: None | bool = None) -> bool | Exception:
"""Safely fade in/out.
Like fade(), but catch any exceptions.
Args:
fade_ms (int): Fade in/out duration in milliseconds.
fade_in (None | bool): If True, fade in, if False, fade out. If
None, fade in if currently not playing, otherwise fade out.
Returns:
bool | Exception: True if the fade was successful, False otherwise,
or an exception if an error occurred.
"""
if not _INITIALIZED:
safe_init()
try:
return self.fade(fade_ms, fade_in)
except Exception as exception:
return exception
def safe_play(self, fade_ms: int = 0) -> bool | Exception:
"""Safely play the sound.
Like play(), but catch any exceptions.
Args:
fade_ms (int): Fade in duration in milliseconds.
Returns:
bool | Exception: True if the sound was played, False otherwise,
or an exception if an error occurred.
"""
if not _INITIALIZED:
safe_init()
try:
return self.play(fade_ms)
except Exception as exception:
return exception
def safe_stop(self, fade_ms: int = 0) -> bool | Exception:
"""Safely stop playback.
Like stop(), but catch any exceptions.
Returns:
bool | Exception: True if the sound was stopped, False otherwise,
or an exception if an error occurred.
"""
try:
return self.stop(fade_ms)
except Exception as exception:
return exception
def stop(self, fade_ms: int = 0) -> bool:
"""Stop playback.
Args:
fade_ms (int): Fade out duration in milliseconds.
Returns:
bool: True if the sound was stopped, False otherwise.
"""
if self._snd and self.is_playing:
if self._lib == "wx":
self._snd.Stop()
self._is_playing = False
elif fade_ms:
self.fade(fade_ms, False)
elif self._lib == "pyglet":
self._ch.pause()
elif self._lib == "SDL":
self._server.Mix_HaltChannel(self._ch)
else:
self._snd.stop()
return True
return False
if __name__ == "__main__":
import wx
from DisplayCAL.config import get_data_path
sound = Sound(get_data_path("theme/engine_hum_loop.wav"), True)
app = wx.App(0)
frame = wx.Frame(None, -1, "Test")
frame.Bind(
wx.EVT_CLOSE,
lambda event: (
sound.stop(1000) and _LIB != "wx" and time.sleep(1),
event.Skip(),
),
)
panel = wx.Panel(frame)
panel.Sizer = wx.BoxSizer()
button = wx.Button(panel, -1, "Play")
button.Bind(wx.EVT_BUTTON, lambda event: not sound.is_playing and sound.play(3000))
panel.Sizer.Add(button, 1)
button = wx.Button(panel, -1, "Stop")
button.Bind(wx.EVT_BUTTON, lambda event: sound.is_playing and sound.stop(3000))
panel.Sizer.Add(button, 1)
panel.Sizer.SetSizeHints(frame)
frame.Show()
app.MainLoop()
displaycal-py3-3.9.19/DisplayCAL/beep.wav 000664 000000 000000 00000051474 15225167330 020031 0 ustar 00root root 000000 000000 RIFF4S WAVEfmt D dataS 6 4 $%+* ^^mnTTllMLuxAB CCZYuu
) * =< xw<>^\ KI./
YW gfLL
8
7
(($%
fg**
Z
Z
\]a_45wu
y
y
bcxw
|{LM}{xyi
h
nm ACCBH
I
32FI_^ &
(
hfPS
EEED /-ut77vw]\gg
II24 ,+NO""10 dd53km!"""$$t u ~~hf77N O 55QQ
xw) ' gfhiAAPP W W - + hg \ [ DC 11 aajja ` DDed)*225 6 53 ~ FF
))
YWE
F
FG
iis
s
--67ggwwQSJI
srzz
fgmlVX \
[
bb
87.
-
NO
>=! ! __ )(I K POEE ML%% u u ~~00 t t US C C yzt w 42$$uu; < mk\^
\]NN= < DC ~~a ` ,-ONrr 99&'OQ VV KL@>ab32 << zz==\] JL/-
WYfgMM
7
7
&&%'
ef+,
X
X
]]a`56uu
y
z
abww
}~KK}{xyi
h
on CBCBG
I
11IJ^`
%
'
ghRS
EDCC -.us77wu[]hg
JJ13
,,OM!$// bc55mm!!#!%'t v ~gg89O N 65PPyx( ) hhhi@AON Y X
, + ig ] ] CC
22 abkka _ ! BCed+,125 5 33 }
FF
)+
XWD
E
IH
jls
q
-,79fgwwRTJH
sr||
ffmnXX [
Z
bc
89.
.
OP
;= _` ()J K PMFGKL%% t t ~}10 r u TU D D yyt u 44$$ut: : km][ \ZNP = < DE b b --ONqp <9&%PQ WW
JL@@bc21<; yx=?\] KK./
VXegNM
9
7
&(%&
fg,+
X
Y
^\_`54tw
y
y
baxw
}}JJ~}xyi
g
mn !BBBBH
H
12HH^_
'
'
fgRQ
EFCD .-uu79xvZ[hh JI 42 +-OO"!01 dd44ln"" "'$t t ~hg89N O 66POzx( ( ghih?@PP Y X + , gg [ \ DB 22 abkja ` BCdf,*125 4 43 ~~
GG
*(
ZYE
E
IG
kjr
s
,,88ffvwSQJJ
ss{|
hgllWX \
\
``
79-
.
QO
=>! __ ))K L NMEG
MJ&& t u }}10 s t UT !
ts][U T 65
89onQQ|| 32 morsGFMN 5 5 ##,, _^onTUlmMNvxBB EDXYuu
+ ) =; yx=>\\! JK/.
YWefNL
7
7
('$%
he*+
Y
Y
^]`_56vt
y
y
bawy
~}KL{{yyi
i
on !BACBH
H
22IH_^ '
'
hhOP
EDDE ..tv88vv\]hg II22 ,+PO!"/0 ee44mm !"!&&u t ~}ih99 N N 54QQ
yx' ) hghhA>PO W Y - - ff ] [ BC
12 ackj^ _ CDed,)037 5 34 |}
FE
))
WZF
D
IH
iks
r
,-76ghwvQQJJ
ts{{
gflmVV \
Z
ac
88-
/
QP
==" ! _` *+J K NOFEKK&$ t t |}11 s s US C D zzu v 22#$vu; ; ml[[
[\PN < < DD ` b ,,MOqq ::'(PN VW
KL@>bd11 << xz>=]\ JJ./
XWfgML
7
7
('#% fg+,
X
X
^^__76ts
x
y
abxx
}|KL||yyi
i
oo ACCBH
H
43HI_^
&
'
ggQQ
FCDB ..ut98ww\Zgh KI23 -,NN"#0/ dd55mn !""&'s t }fh8:N P 46QP
xx( ( gghg>@OO V X * + gf \ \ CB
13 bakj_ ` CCde+)225 6 43 |
FF
**
ZYE
E
HH
kjq
s
-,78ggxxQRKJ
ss{z
ghmkWW [
[
cb
:8/
/
QP
=>! ~`a *+K L ONFE
MK%% u v |}10 t t TT C D zzv w 34%"tv; : lk[^ \\NN ; < DD b a ,-NMqq ::''NQXX
LK?@bb21 ;: zy>>^^ II-/
YWdgNM
8
6
()%#
ee*+
Y
W
\^``66ut
y
y
abxx
~}JK}|wzj
g
lo CBBBH
H
34HH^^
(
(
hgPR
EECF /.vv78wx[[hg
II33 +,NO$#// dd53kn !!&&s r ~gg78 N O 56PPxy( ) ghhh>@ON W W - * gg \ \ BC
31! a`jka a BBee*)128 6 23 |~
GG
+(
YYC
E
HH
kir
s
.-87gfxvRQIJ
tq{|
hfkmVW ]
\
`b
99.
/
QO
==! ! `_ ))L L NNFE KL%$ u s }|21 t t TU "
ut[[T S 57
87noQQ}| 41 mntsHHOM displaycal-py3-3.9.19/DisplayCAL/camera_shutter.wav 000664 000000 000000 00000072366 15225167330 022127 0 ustar 00root root 000000 000000 RIFFt WAVEfmt D X datat ~~}}~~~~}}}}~~~~}}~~||{{~~||}}}}~~}}}}}}}}{{zz~~zz{{~~}}{{zz{{||{{{{}}yy~~||{{}}}}}}~~tt~~ttppgg[[llssss~~}}ssee__[[tt{{{{ssvv||uuooxxjj__dduu{{TT[[xxbbnnvvmm}}ttMMNNccqqggkk}}llhhoozzwwee^^ppxx^^OOggzzooyyqqbbeeppvvwwzz}}||nnnnuuzzttxxxxnnqqttvv}}vvoommxxyylljjqq{{{{||ssooooss{{qquu||{{vvooooww~~xxkkoowwuu{{}}ttww{{}}}}}}{{{{wwuu}}{{xx{{}}~~~~rrss}}||||~~{{zz}}~~zzwwyy}}{{||}}~~{{uuoorr}}~~{{wwwwzz}}||||{{||}}{{~~~~||zz{{}}zzww||}}}}~~}}||yyzz~~}}}}~~}}}}}}~~~~}}~~~~~~~~~~~~}}}}~~~~~~||}}}}}}~~~~||||~~~~~~}}~~~~}}{{}}}}||}}||}}}}}}~~}}}}~~~~~~||~~}}}}}}}}xx{{||{{~~{{}}{{uu{{vvrrttvvvvqqzz}}vvuuxxttxx}}~~~~{{ttww{{xxwwxx}}~~zz}}{{uuww~~||wwttxx{{}}{{{{~~}}{{xx{{~~||{{}}~~||}}}}}}}}}}~~}}~~}}||}}}}}}||||~~}}}}}}}}}}{{{{}}~~}}||||~~~~}}}}~~~~}}||||~~~~~~}}~~~~~~}}}}~~~~~~}}}}~~}}}}~~~~~~~~}}}}}}}}~~}}}}}}}}}}~~~~}}}}}}~~}}}}||}}~~~~}}}}~~}}}}}}}}~~~~~~||}}}}~~~~}}~~}}}}}}~~~~}}}}}}}}~~~~}}}}~~~~~~~~~~}}~~~~~~}}~~}}}}}}{{||}}||~~}}}}{{yyzzrroovv{{vvpprr}}||vvqqqqvvzzuuttyyzzwwzz||yyrrsszzxxttuu{{~~yyzz}}}}yyxx{{~~~~~~}}~~~~~~~~~~~~}}~~~~~~~~}}}}}}}}}}}}~~}}}}~~}}{{}}~~}}~~~~~~~~}}}}||}}}}}}}}~~~~~~~~~~~~~~}}}}}}~~~~~~~~}}~~}}~~~~~~}}}}~~~~{{{{}}}}{{||}}}}}}}}~~~~~~}}}}~~||}}~~~~~~}}~~}}~~~~~~}}~~~~~~}}}}}}}}}}~~}}}}~~~~~~~~}}~~}}||}}~~~~~~~~~~~~}}~~~~}}~~~~~~~~~~}}}}~~~~}}}}~~}}}}~~~~~~~~}}~~~~}}}}~~~~}}~~~~}}~~~~~~~~~~~~}}~~}}~~~~}}}}}}}}~~~~~~~~~~~~~~}}}}~~~~}}}}}}}}~~}}||}}~~~~~~~~~~~~~~}}}}~~}}~~~~~~~~~~~~~~~~~~~~~~~~~~}}}}~~}}||||}}}}||||~~}}}}~~~~{{vv||{{rrrrxxzzzzxx||}}}}}}~~}}}}{{xxxx}}{{xxvvxxzz{{}}yyww{{yyuuyy{{||||yy{{}}}}}}{{xxxxzz~~~~||zzzz{{}}}}{{{{||~~~~{{yyzz~~}}{{{{{{~~}}{{zz{{}}zzxxwwxx}}~~}}||||{{zz{{}}}}{{{{}}yy``oozzhhooqqjjllvveessgggg{{rrbboojjggzz^^YYuujjttssxxvvooxx~~}}xxvvrrooss{{}}uuqqssxx}}{{zz{{~~~~~~~~{{yy{{||yy{{}}}}{{~~}}~~}}{{{{yyyy~~}}yyxx~~}}{{}}}}{{yy{{||{{}}~~~~}}{{{{}}||||||zzzz{{}}}}}}||{{||}}}}~~}}}}}}||}}~~~~}}}}}}}}}}}}}}zz{{}}}}}}||yywwxxzz}}~~{{{{~~}}{{{{{{{{}}}}{{{{~~~~~~}}{{yyzz||}}~~}}||}}}}||}}~~}}{{||~~}}}}}}{{}}~~}}}}{{xxwwww{{}}}}||||}}{{{{{{}}~~~~~~||zz{{}}}}~~~~}}||||}}~~}}||}}~~~~~~~~~~}}}}}}~~}}}}~~}}}}}}~~}}}}~~~~~~}}}}~~~~~~~~~~~~~~}}}}~~~~~~~~~~~~}}~~~~~~}}}}~~~~}}}}~~}}}}}}}}}}}}}}}}}}~~}}||}}}}||}}{{}}~~}}||}}~~{{||}}||~~zz}}{{rryy{{zzzzsswwyyvvvvttvvxxzz}}zzww{{yyzz}}xx||}}{{}}}}zzvvuu{{||xxxxzz{{{{~~wwuu{{~~zzxxzz}}}}||}}}}||~~}}||~~||{{{{}}~~~~}}}}}}~~{{||}}||||}}||{{yyxxxx{{~~~~}}}}~~||{{zz{{~~}}}}~~}}||zz~~{{{{xx||||zz~~}}{{zz||yyvvqqvv}}xxxxzz~~zzvvssssttxxzzxxwwxx~~||~~xxqqxx}}zzxx}}}}~~||{{}}xxyy~~~~{{{{}}{{xx}}}}{{}}}}yy{{||{{}}~~}}||||||xxvvxx}}{{{{}}}}~~~~~~||||||~~}}{{}}{{zz{{}}~~~~~~~~~~}}||||}}{{zzxxyy{{~~~~}}||||}}}}~~~~~~~~~~{{{{{{}}~~}}}}}}}}{{||}}~~~~}}}}}}~~~~~~~~~~~~~~~~}}}}}}~~~~~~}}}}}}~~~~~~}}}}}}~~~~~~~~}}}}~~~~}}~~~~}}}}~~~~}}~~~~~~~~~~}}||}}~~~~~~~~~~~~}}}}}}}}}}~~}}~~~~~~~~~~~~}}}}~~~~~~~~}}}}~~~~}}}}~~~~}}}}~~}}}}~~~~}}}}~~~~~~~~~~}}}}}}~~~~}}}}~~~~}}}}}}~~~~}}~~~~~~~~}}}}~~}}{{{{}}~~}}}}~~~~~~~~~~~~~~}}~~~~}}~~~~~~~~}}~~~~}}}}}}}}~~~~}}||||}}~~~~~~}}}}}}}}}}}}||||}}~~~~}}}}}}}}}}}}{{yy{{~~~~~~}}~~}}}}}}~~~~~~}}{{{{||}}||||{{{{{{}}~~}}}}}}}}}}~~}}{{{{{{{{}}}}~~~~~~}}}}}}||||||}}~~~~}}{{{{||||}}}}||{{{{{{{{||}}~~~~}}~~}}}}}}}}~~}}}}}}}}}}}}}}}}~~}}}}}}}}||||||}}||}}}}}}~~~~~~}}{{{{{{{{{{{{{{{{}}~~~~}}||||||}}{{wwww{{~~}}}}}}~~}}{{yyzz||~~~~~~}}||||}}~~~~~~||}}}}~~||{{||~~~~~~~~}}}}||}}~~~~~~~~~~}}}}}}}}}}}}}}~~~~~~~~~~}}~~}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}}}}}}}}}}~~~~}}~~~~~~~~}}}}}}~~~~}}}}}}}}}}}}~~~~}}}}}}}}~~~~~~}}||||}}}}}}~~~~~~}}}}~~}}}}}}~~~~~~~~}}}}||{{{{}}}}~~}}}}}}~~~~}}~~~~}}}}}}~~~~~~~~}}}}~~~~~~~~~~}}~~~~~~~~~~~~}}}}~~~~~~~~~~~~}}~~}}}}}}}}~~~~}}||}}~~~~~~~~~~}}}}}}~~{{zz{{}}~~~~~~~~~~}}}}~~~~}}}}}}~~~~~~~~~~}}}}||}}~~~~~~~~}}~~}}||||||}}~~}}||{{{{{{}}}}||}}~~~~~~}}||{{{{}}}}{{zzzz{{}}}}||{{||||}}~~}}}}||}}~~~~}}}}}}}}}}}}}}}}~~}}}}~~}}||||||||}}~~~~}}}}~~}}}}||||}}}}~~}}}}}}~~~~}}||}}}}}}~~}}{{}}}}~~~~}}}}~~~~~~}}~~~~}}}}~~~~~~||||||}}~~~~~~}}~~}}}}~~~~}}}}~~}}}}{{zz||~~}}}}}}}}||{{||||}}~~}}{{}}~~~~~~yy}}xxzz~~}}||||{{~~}}{{{{||{{{{}}}}~~}}}}}}}}~~}}}}}}}}||||}}}}~~||}}~~}}}}}}{{||}}}}||xxxxyyzz||~~}}||{{||}}~~~~}}||{{{{}}}}{{zz{{{{}}}}||||||}}}}~~}}{{zzzz{{}}~~}}{{{{{{}}~~}}{{{{{{}}~~~~}}}}}}||||~~}}{{zzzz{{||~~~~||{{yyxxyy{{}}~~}}{{{{{{{{{{}}}}||}}}}}}}}}}{{yy{{{{yy{{zz{{zz{{xx}}zzvvvvwwzz{{wwoovv{{oommrryywwuu{{}}ttrrvv{{zz}}}}ssqqvvyyyy~~yyuussvvxx{{~~~~{{zz{{{{yy{{}}}}xxvvvvxx||~~xxxx{{{{{{{{wwuuvvzz}}{{xxvvvvuuxx{{}}~~}}||yyxxxxyy}}||yyxxwwyy}}||{{zzzz}}~~}}}}~~}}}}}}~~}}~~~~||zzyyyy{{~~||{{{{{{{{{{zzzz}}}}zzxxyy{{{{zz{{}}~~}}}}}}{{{{}}~~}}{{||}}~~{{yy{{~~~~~~}}xxvvyyzz{{}}{{{{}}~~~~~~~~~~}}zzxxzz}}}}}}}}}}||||}}}}{{zz{{||~~~~~~~~}}||}}}}||}}~~}}||{{{{{{||}}~~~~}}~~}}{{zzyyzz{{||}}}}}}~~~~}}}}||{{zzzz{{}}~~}}}}}}||}}||}}}}{{{{{{}}}}||||~~}}}}}}{{{{{{{{}}}}}}}}}}~~~~}}||{{{{||}}~~~~}}~~}}~~~~}}}}}}~~||zzzz{{~~}}||||}}~~~~~~~~}}||}}}}~~}}{{{{}}{{{{{{}}}}}}}}~~~~~~}}}}}}}}~~~~{{zz{{||}}}}}}}}zzxxxx{{}}~~}}}}}}}}}}||}}~~}}{{xxzz||~~~~||{{{{{{}}||zzyyzz{{||}}~~}}}}{{zz{{||~~~~}}}}{{{{||}}}}}}||{{}}}}||||}}}}}}}}~~}}||{{||}}}}}}~~~~}}{{zz{{||}}||||}}||zz{{{{||}}~~~~}}{{||}}}}}}~~~~~~}}{{||~~}}{{zz{{||}}~~~~||zzyy{{{{{{{{||||||~~}}||{{}}}}}}}}}}}}~~}}||{{||||||~~}}}}||||}}~~~~~~}}{{yyxxxxzz~~~~}}~~~~~~}}}}}}}}}}~~{{zz{{}}}}{{zzyyyyyyyy{{~~}}}}}}}}||}}~~{{yyxxyy}}~~}}{{zz{{{{}}}}{{{{{{||}}||{{zzzz||~~}}}}||}}}}}}~~}}||{{{{{{{{}}}}||{{{{{{||}}~~}}}}}}||}}~~{{zzzz{{||}}~~}}{{{{{{}}}}{{{{{{}}}}||{{{{{{{{~~~~}}||{{zz{{}}}}||{{{{}}~~||{{{{||}}}}}}}}}}}}||{{}}}}{{{{{{||}}}}}}||||||~~}}||{{{{}}~~}}{{{{}}~~}}{{{{{{||}}}}~~}}{{{{{{{{~~~~||{{zzzz{{}}~~}}}}}}||||}}}}||{{{{}}~~}}{{{{zz{{~~||{{||zzxxxxzz}}}}zzzz}}~~{{yyyy{{}}{{{{||}}}}{{zzyy{{}}}}{{{{{{||}}~~}}{{zzzz{{||~~}}}}||||||}}}}||{{{{{{{{||}}}}}}||{{{{||~~~~}}{{zzzz{{||~~}}{{yyyy{{}}}}{{zzzz{{{{}}}}~~||{{{{{{||}}~~||{{zzzz{{{{}}}}{{{{{{{{}}||zzxxxxxxzz{{~~~~}}}}}}}}}}~~}}{{yyxxyyzz||~~}}||||||}}~~}}{{{{zzzz{{||}}~~||||{{{{||}}~~}}{{zzyyzzzz||~~}}||||||}}~~~~}}||{{{{{{{{}}}}}}||{{{{||}}}}||{{zzzz{{||~~}}}}}}||||}}~~~~}}{{{{{{{{{{~~~~}}}}}}||}}~~~~}}{{{{{{{{}}~~~~~~}}}}}}}}}}}}}}||{{{{||}}}}}}}}}}}}~~}}}}}}}}}}}}}}}}~~~~~~}}}}~~~~~~}}}}}}}}}}}}~~~~~~~~~~~~}}}}}}}}}}}}}}~~}}}}}}~~}}||||||||||||||}}}}~~}}}}~~~~}}{{{{||}}}}}}~~~~}}}}}}}}~~~~~~~~~~}}}}}}}}}}~~~~~~~~~~~~~~}}}}||}}}}~~~~~~~~~~~~~~~~~~~~~~}}}}}}~~~~~~~~~~~~~~~~}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}}}}}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~}}}}}}}}~~~~~~~~~~}}}}}}~~~~~~~~}}}}}}}}~~~~~~~~~~~~~~~~~~~~}}}}~~}}~~~~~~~~}}}}}}~~~~~~}}}}~~~~~~}}}}}}}}~~~~}}}}}}}}~~}}}}}}}}}}~~~~}}}}}}~~~~~~~~}}~~~~~~~~~~~~~~}}}}}}}}~~~~~~~~}}}}}}~~~~~~~~~~~~~~}}}}}}}}}}~~}}}}~~~~}}}}~~~~~~~~~~~~}}}}}}}}}}~~}}}}}}~~}}}}{{~~{{ww}}}}||||}}~~}}{{}}}}||}}||~~}}||{{}}}}}}~~~~}}}}}}}}}}~~}}}}}}}}~~}}~~~~~~}}}}}}}}}}~~}}{{||~~~~}}}}}}~~~~~~}}}}~~~~~~~~}}}}}}}}~~~~~~~~~~~~~~}}}}}}~~~~~~~~~~~~}}}}~~~~~~~~~~~~~~~~~~~~~~}}}}}}~~~~}}}}~~~~}}}}~~~~}}~~~~~~~~~~~~~~}}}}~~}}}}}}}}~~~~~~~~}}}}~~~~}}}}||||}}~~}}}}}}||||||}}}}~~~~~~~~}}}}~~}}}}}}}}~~~~}}~~~~~~}}}}||||||}}}}~~~~~~~~}}}}}}}}~~~~}}}}~~}}}}~~~~~~}}}}~~~~}}||~~~~~~}}||}}~~}}}}~~~~~~~~~~~~}}~~~~~~~~~~~~}}}}~~~~}}}}}}}}~~}}}}~~~~~~~~}}}}~~}}}}}}}}~~}}||||||}}}}~~}}||}}~~~~~~~~}}}}}}~~}}~~~~}}}}||||}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}}||}}}}}}~~~~}}}}~~~~~~~~}}}}~~~~~~~~~~~~}}}}~~~~}}}}}}}}~~}}}}~~}}}}}}~~~~~~~~}}}}}}~~~~}}}}}}}}}}~~~~~~~~~~~~}}~~~~}}}}~~~~~~~~~~~~~~~~~~}}}}~~~~}}~~~~}}}}~~~~}}}}}}}}~~~~~~~~~~~~~~~~}}}}||}}~~}}}}}}}}~~~~}}}}}}~~~~}}||||}}}}~~~~~~~~~~~~~~}}~~~~~~}}}}~~~~~~~~~~~~~~}}}}}}~~~~}}}}}}~~}}||||||||}}~~~~~~~~}}}}~~}}}}}}~~~~~~~~}}}}}}~~~~~~~~}}}}}}}}~~~~||{{||}}~~}}}}~~~~~~}}}}~~~~}}}}}}}}}}~~}}}}||||}}~~~~}}}}}}}}~~~~}}}}}}}}~~}}}}}}~~}}}}}}}}}}}}}}~~}}{{{{{{{{}}}}||||}}}}~~~~||||{{{{}}}}}}~~}}}}}}}}~~~~~~}}}}}}~~}}}}}}}}}}}}~~~~}}}}}}||}}~~~~}}}}}}||}}~~~~~~~~~~~~~~~~~~}}}}~~}}}}||||}}~~}}}}}}}}}}~~~~~~~~~~~~~~~~~~}}}}~~}}}}}}}}}}~~}}}}||}}~~~~~~~~~~~~~~}}~~~~}}~~~~~~}}}}~~~~~~~~}}~~~~}}}}~~~~~~~~~~}}~~}}||{{||}}~~}}~~}}{{||}}~~~~~~}}}}~~~~}}~~~~}}}}}}~~}}}}~~~~}}}}}}~~~~~~~~}}{{||}}}}~~~~~~~~}}||}}}}~~}}~~~~}}||||}}~~~~}}}}}}}}}}~~}}||}}}}}}}}}}~~}}~~~~~~~~~~~~~~~~~~~~~~~~}}~~~~}}}}~~}}~~~~}}}}}}}}~~~~~~}}}}}}~~~~}}~~~~}}~~~~}}}}~~~~~~~~}}}}}}}}~~~~}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}}}}}}}}~~}}}}~~~~~~}}}}||||}}~~}}~~~~}}}}~~~~}}}}}}}}~~~~}}~~~~~~~~~~~~~~~~}}~~~~~~~~}}}}}}}}~~~~}}}}~~~~}}}}}}~~~~~~~~~~}}{{yy}}||vvvv||~~zzzz}}||}}}}vvvv}}}}{{{{{{{{zzyyxxzz}}~~}}~~~~}}~~}}{{xxxxxxxx||}}{{yyzz}}{{vvrrrruuxx}}}}||}}}}{{||}}{{}}~~}}||}}~~~~}}{{yyyyyyzz{{}}}}{{{{{{||{{{{||{{zz||}}~~}}}}||{{}}}}||}}~~~~}}~~}}{{||}}{{yy{{}}}}}}}}~~||}}~~}}}}~~}}{{||}}~~~~~~||||}}}}}}~~~~}}~~~~}}~~~~~~{{yyxxxxzz{{}}}}}}}}}}~~}}||}}}}}}~~}}}}~~}}}}~~~~}}}}}}||}}}}}}||||}}}}}}}}~~}}~~~~~~~~}}}}}}}}~~~~~~}}}}~~~~~~~~~~~~~~~~~~~~}}}}}}~~~~~~~~}}}}~~~~~~~~}}}}~~}}||||}}~~~~}}}}}}~~~~~~}}~~~~}}}}}}}}}}}}}}~~~~}}~~||}}~~~~}}~~||{{{{}}{{xxttzz}}||~~zz{{{{wwzzuuwwyy}}zz{{ssllxxxx}}~~~~yyqq}}}}wwvvuuvv}}}}}}{{rrvv||xxwwvvvv}}~~||{{zz||~~~~~~{{xxxx{{~~}}~~~~||{{zzzz~~~~{{zzyy{{~~~~}}~~}}||}}~~}}}}}}}}~~}}~~}}}}}}}}~~}}}}~~}}}}~~}}~~~~||||}}~~~~zzxxzzzz{{}}}}}}}}}}~~}}{{yyyy{{~~}}||}}~~||zzxx{{~~~~{{||}}}}}}{{}}}}{{zzwwxx~~~~}}{{{{||}}}}}}}}||yyvvwwzz{{~~~~~~~~||{{{{zzxxzz{{}}~~}}{{yywwvvvvwwxxzz{{{{{{||~~}}xxrrooxxkkbblltt}}xx{{||{{yyvv{{~~~~}}}}{{||}}vvuuzzxxoonnvv}}||zzzz~~{{{{~~}}~~}}}}~~~~~~~~}}~~}}}}~~~~}}{{}}~~}}}}~~~~}}~~~~~~~~}}~~~~}}||||~~}}||}}~~~~}}}}||{{}}}}{{||~~~~~~}}}}~~}}}}}}~~~~}}}}~~~~}}}}}}}}}}~~~~~~~~}}{{||}}}}~~~~~~~~}}~~~~~~~~~~~~}}}}~~}}}}}}}}~~~~}}~~~~~~~~~~~~}}~~~~~~~~~~}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~}}}}}}~~~~~~~~}}~~~~~~~~~~~~}}~~~~~~~~}}}}}}~~~~}}}}~~~~~~~~~~~~}}}}}}~~~~}}~~~~~~~~}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ displaycal-py3-3.9.19/DisplayCAL/ccmx.py 000664 000000 000000 00000007766 15225167330 017710 0 ustar 00root root 000000 000000 """Convert iColorDisplay DeviceCorrections.txt to Argyll CCMX files.
It parses the input file, extracts relevant data, and generates CCMX files in
the specified format for use with color calibration tools.
"""
import json
import os
import sys
import time
CCMX_TEMPLATE = """CCMX
DESCRIPTOR "%(Name)s"
KEYWORD "INSTRUMENT"
INSTRUMENT "%(Device)s"
KEYWORD "DISPLAY"
DISPLAY "%(Display)s"
KEYWORD "DISPLAY_TYPE_BASE_ID"
DISPLAY_TYPE_BASE_ID "1"
KEYWORD "REFERENCE"
REFERENCE "%(ReferenceDevice)s"
ORIGINATOR "%(Originator)s"
CREATED "%(DateTime)s"
KEYWORD "COLOR_REP"
COLOR_REP "XYZ"
NUMBER_OF_FIELDS 3
BEGIN_DATA_FORMAT
XYZ_X XYZ_Y XYZ_Z
END_DATA_FORMAT
NUMBER_OF_SETS 3
BEGIN_DATA
%(MatrixXYZ)s
END_DATA
"""
def convert_devicecorrections_to_ccmx(path: str, target_dir: str) -> tuple[int, int]:
"""Convert iColorDisplay DeviceCorrections.txt to individual Argyll CCMX files.
Args:
path (str): Path to the DeviceCorrections.txt file.
target_dir (str): Directory where the generated CCMX files will be saved.
Returns:
tuple[int, int]: A tuple containing the number of imported and skipped
entries.
"""
with open(path, "utf8") as devcorrections_file:
lines = devcorrections_file.read().strip().splitlines()
# Convert to JSON
# The DeviceCorrections.txt format is as follows, so a conversion is pretty
# straightforward:
# "Description here, e.g. Instrument X for Monitor Y" =
# {
# Name = "Description here, e.g. Instrument X for Monitor Y"
# Device = "Instrument X"
# Display = "Monitor Y"
# ReferenceDevice = "eye-one Pro Rev.D"
# MatrixXYZ = "3 3 1482250784 1.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 1.0 "
# }
# "Description here, e.g. Instrument X for Monitor Y" =
# {
# Name = "Description here, e.g. Instrument X for Monitor Y"
# Device = "Instrument X"
# Display = "Monitor Y"
# ReferenceDevice = "eye-one Pro Rev.D"
# MatrixXYZ = "3 3 1482250784 1.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 1.0 "
# }
# ...etc.
# NOTE: The first three numbers in MatrixXYZ are irrelevant for our purposes.
for i, line in enumerate(lines):
parts = line.strip().split("=")
if len(parts) == 2:
for j, part in enumerate(parts):
part = part.strip()
if part and not part.startswith('"') and not part.endswith('"'):
parts[j] = f'"{part}"'
if parts[-1].strip() not in ("", "{") and i < len(lines) - 1:
parts[-1] += ","
lines[i] = ":".join(parts)
devcorrections_data = "{{{}}}".format("".join(lines).replace(",}", "}"))
# Parse JSON
devcorrections = json.loads(devcorrections_data)
# Convert to ccmx
imported = 0
skipped = 0
for name in devcorrections:
devcorrection = devcorrections[name]
values = {
"DateTime": time.strftime("%a %b %d %H:%M:%S %Y"),
"Originator": "Quato iColorDisplay",
"Name": "{} & {}".format(
devcorrection.get("Device"), devcorrection.get("Display")
),
}
for key in ("Device", "Display", "ReferenceDevice", "MatrixXYZ"):
value = devcorrection.get(key)
if value is None:
break
if key == "MatrixXYZ":
# The first three numbers in the matrix are irrelevant for our
# purposes (see format example above).
matrix = value.split()[3:]
value = "\n".join(
[" ".join(part) for part in (matrix[0:3], matrix[3:6], matrix[6:9])]
)
values[key] = value
if value is None:
skipped += 1
continue
imported += 1
with open(
os.path.join(target_dir, f"{name}.ccmx"), "w", encoding="utf8"
) as ccmx:
ccmx.write(CCMX_TEMPLATE % values)
return imported, skipped
if __name__ == "__main__":
convert_devicecorrections_to_ccmx(sys.argv[1], os.path.dirname(sys.argv[1]))
displaycal-py3-3.9.19/DisplayCAL/cgats.py 000664 000000 000000 00000302223 15225167330 020041 0 ustar 00root root 000000 000000 """Simple CGATS file parser class.
Copyright (C) 2008 Florian Hoech
"""
from __future__ import annotations
import functools
import io
import math
import os
import re
from pathlib import Path
from typing import Any, BinaryIO, Callable
from DisplayCAL import colormath
from DisplayCAL.colorspace_to_vrml import COLORSPACE_NAME_TO_VRML_MAP, ColorSpaceToVRML
from DisplayCAL.icc_profile import ICCProfileTag
from DisplayCAL.log import safe_print
from DisplayCAL.options import DEBUG
def debug_print(*args, other_conditions: bool = True) -> None:
"""Print debug messages if DEBUG is enabled and other conditions are met.
Args:
*args: The arguments to print.
other_conditions (bool): Additional conditions to check before printing.
Defaults to True.
"""
if DEBUG and other_conditions:
print(*args)
def get_device_value_labels(color_rep: None | str = None) -> list[bytes]:
"""Return a list of device value labels.
Args:
color_rep (None | str): Color representation. Default is None.
Returns:
list: List of device value labels.
"""
# TODO: Avoid using filter...
return list(
filter(
bool,
[
v[1] if not color_rep or v[0] == color_rep else False
for v in {
b"CMYK": (b"CMYK_C", b"CMYK_M", b"CMYK_Y", b"CMYK_K"),
b"RGB": (b"RGB_R", b"RGB_G", b"RGB_B"),
}
],
)
)
def rpad(value: int | float | complex | str, width: int) -> bytes: # noqa: PYI041
"""If value isn't a number, return a quoted string representation.
If value is greater or equal than 1e+16, return string in scientific
notation. Otherwise, return string in decimal notation right-padded to
given width (using trailing zeros).
Args:
value (int | float | complex | str): The value to format.
width (int): The width to pad the string to.
"""
strval = b""
if not isinstance(value, bytes):
strval = bytes(str(value), "UTF-8")
if not isinstance(value, (int, float, complex)):
# Return quoted string representation
# Also need to escape single quote -> double quote
return b'"%s"' % strval.replace(b'"', b'""')
if value < 1e16:
i = strval.find(b".")
if i > -1:
if i < width - 1:
# Avoid scientific notation by formatting to decimal
fmt = b"%%%i.%if" % (width, width - i - 1)
strval = fmt % value
else:
strval = bytes(str(round(value)), "UTF-8")
return strval
def sort_rgb_gray_to_top(a: tuple, b: tuple) -> int:
"""Sort RGB values to the top.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
if a[0] == a[1] == a[2]:
if b[0] == b[1] == b[2]:
return 0
return -1
return 0
def sort_rgb_to_top_factory(i1: int, i2: int, i3: int, i4: int) -> Callable:
"""Return a function to sort RGB values to the top.
Args:
i1 (int): Index of the first RGB value.
i2 (int): Index of the second RGB value.
i3 (int): Index of the third RGB value.
i4 (int): Index of the fourth RGB value.
Returns:
function: A function that sorts two RGB tuples by their values.
"""
def sort_rgb_to_top(
a: tuple[float, float, float], b: tuple[float, float, float]
) -> int:
"""Sort two RGB tuples by their values.
Args:
a (tuple[float, float, float]): First RGB tuple.
b (tuple[float, float, float]): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
if a[i1] == a[i2] and 0 <= a[i3] < a[i4]:
if b[i1] == b[i2] and 0 <= b[i3] < b[i4]:
return 0
return -1
return 0
return sort_rgb_to_top
def sort_rgb_white_to_top(a: tuple, b: tuple) -> int:
"""Sort RGB values to the top.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
sum1 = sum(a[:3])
# sum2 = sum(b[:3])
return -1 if sum1 == 300 else 0
def sort_by_hsi(a: tuple, b: tuple) -> int:
"""Sort by HSI value.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
a = list(colormath.RGB2HSI(*a[:3]))
b = list(colormath.RGB2HSI(*b[:3]))
a[0] = round(math.degrees(a[0]))
b[0] = round(math.degrees(b[0]))
if a > b:
return 1
if a < b:
return -1
return 0
def sort_by_hsl(a: tuple, b: tuple) -> int:
"""Sort by HSL value.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
a = list(colormath.RGB2HSL(*a[:3]))
b = list(colormath.RGB2HSL(*b[:3]))
a[0] = round(math.degrees(a[0]))
b[0] = round(math.degrees(b[0]))
if a > b:
return 1
if a < b:
return -1
return 0
def sort_by_hsv(a: tuple, b: tuple) -> int:
"""Sort by HSV value.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
a = list(colormath.RGB2HSV(*a[:3]))
b = list(colormath.RGB2HSV(*b[:3]))
a[0] = round(math.degrees(a[0]))
b[0] = round(math.degrees(b[0]))
if a > b:
return 1
if a < b:
return -1
return 0
def sort_by_rgb(a: tuple, b: tuple) -> int:
"""Sort by RGB value.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
if a[:3] > b[:3]:
return 1
if a[:3] < b[:3]:
return -1
return 0
def sort_by_bgr(a: tuple, b: tuple) -> int:
"""Sort by BGR value.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
if a[:3][::-1] > b[:3][::-1]:
return 1
if a[:3] == b[:3]:
return 0
return -1
def sort_by_rgb_sum(a: tuple, b: tuple) -> int:
"""Sort by RGB sum.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
sum1, sum2 = sum(a[:3]), sum(b[:3])
if sum1 > sum2:
return 1
if sum1 < sum2:
return -1
return 0
def sort_by_rgb_pow_sum(a: tuple, b: tuple) -> int:
"""Sort by RGB power sum.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
sum1, sum2 = sum(v**2.2 for v in a[:3]), sum(v**2.2 for v in b[:3])
if sum1 > sum2:
return 1
if sum1 < sum2:
return -1
return 0
def stable_sort_by_l(a: tuple, b: tuple) -> int:
"""Stable sort by L* value.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
return sort_by_l(a, b, stable=True)
def sort_by_l(a: tuple, b: tuple, stable: bool = False) -> int:
"""Sort by L* value.
Args:
a (tuple): First RGB tuple.
b (tuple): Second RGB tuple.
stable (bool): If True, sort stably by L* value.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
def sort(a1: float, b1: float) -> int:
"""Compare two L* values.
Args:
a1 (float): First L* value.
b1 (float): Second L* value.
Returns:
int: 1 if a1 > b1, -1 if a1 < b1, 0 if equal.
"""
if a1 > b1:
return 1
if a1 < b1:
return -1
return 0
lab1 = colormath.XYZ2Lab(*a[3:])
lab2 = colormath.XYZ2Lab(*b[3:])
if stable:
for i in range(len(lab1)):
v = sort(lab1[i], lab2[i])
if v != 0:
return v
return 0
return sort(lab1[0], lab2[0])
def sort_by_luma_factory(ry: float, gy: float, by: float, gamma: float = 1) -> Callable:
"""Return a function to sort by luma.
Args:
ry (float): Red Y value.
gy (float): Green Y value.
by (float): Blue Y value.
gamma (float): Gamma correction value. Default is 1.
Returns:
function: A function that sorts two RGB tuples by their luma value.
"""
def sort_by_luma(
a: tuple[float, float, float], b: tuple[float, float, float]
) -> int:
"""Sort two RGB tuples by their luma value.
Args:
a (tupltuple[float, float, float]e): First RGB tuple.
b (tuple[float, float, float]): Second RGB tuple.
Returns:
int: 1 if a > b, -1 if a < b, 0 if equal.
"""
a = ry * a[0] ** gamma + gy * a[1] ** gamma + by * a[2] ** gamma
b = ry * b[0] ** gamma + gy * b[1] ** gamma + by * b[2] ** gamma
if a > b:
return 1
if a < b:
return -1
return 0
return sort_by_luma
sort_by_rec709_luma = sort_by_luma_factory(0.2126, 0.7152, 0.0722)
class CGATSError(Exception):
"""Base class for CGATS errors."""
class CGATSInvalidError(CGATSError, IOError):
"""Invalid CGATS file error."""
class CGATSInvalidOperationError(CGATSError):
"""Invalid operation error."""
class CGATSKeyError(CGATSError, KeyError):
"""CGATS key not found error."""
class CGATSTypeError(CGATSError, TypeError):
"""CGATS type error."""
class CGATSValueError(CGATSError, ValueError):
"""CGATS value error."""
class CGATS(dict):
"""CGATS structure.
CGATS files are treated mostly as 'soup', so only basic checking is in place.
TODO: Don't derive this from dict, but use a dict as a member variable.
Args:
cgats (None | str | bytes | list | Path | io.IOBase | ICCProfileTag, optional):
Can be a path, a string holding CGATS data, or a file object.
normalize_fields (bool, optional): If True, convert all KEYWORDs and
all fields in DATA_FORMAT to UPPERCASE and SampleId or SampleName
to SAMPLE_ID or SAMPLE_NAME respectively. Defaults to False.
file_identifier (bytes, optional): The file identifier to use. Defaults
to b"CTI3". It is used as fallback if no file identifier is
present.
emit_keywords (bool, optional): If True, emit KEYWORDs in the output.
Defaults to False.
strict (bool, optional): If True, raise errors for malformed data.
Defaults to False.
"""
datetime = None
filename = None
key = None
_lvl = 0
_modified = False
mtime = None
parent = None
root = None
type = b"ROOT"
vmaxlen = 0
def __init__(
self,
cgats: None | str | bytes | list | Path | io.IOBase | ICCProfileTag = None,
normalize_fields: bool = False,
file_identifier: bytes = b"CTI3",
emit_keywords: bool = False,
strict: bool = False,
) -> None:
super().__init__()
self.normalize_fields = normalize_fields
self.file_identifier = file_identifier.strip()
self.emit_keywords = emit_keywords
self.root = self
if not cgats:
return
raw_lines = self.read_raw_data(cgats)
if self.filename:
self.mtime = os.stat(self.filename).st_mtime
self.parse_raw_data(strict, raw_lines)
def read_raw_data(self, cgats: str | bytes | list | Path | io.IOBase) -> list:
"""Read raw CGATS data.
Args:
cgats (str | bytes | list | Path | io.IOBase): CGATS data to parse.
Raises:
CGATSInvalidError: If the type of cgats is unsupported.
Returns:
list: Parsed CGATS data lines.
"""
raw_lines = []
if isinstance(cgats, list):
raw_lines = cgats
elif isinstance(cgats, str):
if "\n" not in cgats or "\r" not in cgats:
# assume filename
with open(cgats, "rb") as cgats_:
self.filename = cgats_.name
cgats_.seek(0)
raw_lines = cgats_.readlines()
else:
# assume text
with io.StringIO(cgats) as cgats_:
cgats_.seek(0)
raw_lines = cgats_.readlines()
elif isinstance(cgats, bytes):
# assume text
with io.BytesIO(cgats) as cgats_:
cgats_.seek(0)
raw_lines = cgats_.readlines()
elif isinstance(cgats, ICCProfileTag):
with io.BytesIO(cgats.tagData) as cgats_:
cgats_.seek(0)
raw_lines = cgats_.readlines()
elif isinstance(cgats, Path):
self.filename = cgats.absolute()
with open(cgats, "rb") as cgats_:
cgats_.seek(0)
raw_lines = cgats_.readlines()
elif isinstance(cgats, io.IOBase):
if hasattr(cgats, "readlines"):
cgats.seek(0)
raw_lines = cgats.readlines()
else:
# Assume file-like object
raw_lines = cgats.read()
if isinstance(raw_lines, bytes):
raw_lines = [raw_lines]
cgats.close()
else:
raise CGATSInvalidError(f"Unsupported type: {type(cgats)}")
return raw_lines
def parse_raw_data(self, strict: bool, raw_lines: list) -> None:
"""Parse raw CGATS data.
Args:
strict (bool): If True, raise errors for malformed data.
raw_lines (list): List of raw CGATS data lines to parse.
Raises:
CGATSInvalidError: If strict is True and data is malformed.
"""
context = self
for raw_line in raw_lines:
# Replace 1.#IND00 with NaN
raw_line = raw_line.replace(b"1.#IND00", b"NaN")
# strip control chars and leading/trailing whitespace
line = re.sub(b"[^\x09\x20-\x7e\x80-\xff]", b"", raw_line.strip())
line, values = self._parse_raw_data_deal_with_quotes(line)
context = self._parse_raw_data_begin(context, line)
context = self._parse_data_begin_and_end(strict, context, line, values)
if 0 in self and self[0].get("NORMALIZED_TO_Y_100") == b"NO":
# Always normalize to Y = 100
reprstr = self.filename or (
f"<{self.__module__}.{self.__class__.__name__} "
f"instance at 0x{id(self):016x}>"
)
if self[0].normalize_to_y_100():
print("Normalized to Y = 100:", reprstr)
else:
print("Warning: Could not normalize to Y = 100:", reprstr)
self.setmodified(False)
def _parse_data_begin_and_end(
self, strict: bool, context: CGATS, line: bytes, values: list
) -> CGATS:
"""Parse data lines and handle BEGIN_ and END_ sections.
Args:
strict (bool): If True, raise errors for malformed data.
context (CGATS): Current CGATS context.
line (bytes): The line to parse.
values (list): List of values parsed from the line.
Returns:
CGATS: The updated CGATS context.
"""
if line == b"BEGIN_DATA_FORMAT":
context["DATA_FORMAT"] = CGATS()
context["DATA_FORMAT"].key = "DATA_FORMAT"
context["DATA_FORMAT"].parent = context
context["DATA_FORMAT"].root = self
context["DATA_FORMAT"].type = b"DATA_FORMAT"
context = context["DATA_FORMAT"]
elif line == b"END_DATA_FORMAT":
context = context.parent
elif line == b"BEGIN_DATA":
context["DATA"] = CGATS()
context["DATA"].key = "DATA"
context["DATA"].parent = context
context["DATA"].root = self
context["DATA"].type = b"DATA"
context = context["DATA"]
elif line == b"END_DATA":
context = context.parent
elif line[:6] == b"BEGIN_":
key = line[6:].decode()
context[key] = CGATS()
context[key].key = key
context[key].parent = context
context[key].root = self
context[key].type = b"SECTION"
context = context[key]
elif line[:4] == b"END_":
context = context.parent
elif context.type in (b"DATA_FORMAT", b"DATA"):
if len(values):
context = context.add_data(values)
elif context.type == b"SECTION":
context = context.add_data(line)
elif len(values) > 1:
context = self.parse_data_multi_values(strict, context, line, values)
elif (
values
and values[0] not in (b"Comment:", b"Date:")
and len(line) >= 3
and not re.search(b"[^ 0-9A-Za-z/.]", line)
):
context = self.add_data(line)
return context
def parse_data_multi_values(
self, strict: bool, context: CGATS, line: bytes, values: list
) -> CGATS:
"""Parse multi-value data lines.
Args:
strict (bool): If True, raise errors for malformed data.
context (CGATS): Current CGATS context.
line (bytes): The line to parse.
values (list): List of values parsed from the line.
Returns:
CGATS: The updated CGATS object.s
"""
if values[0] == b"Date:":
context.datetime = line
elif len(values) == 2 and b'"' not in values[0]:
key, value = values[0].decode(), values[1]
if value is not None:
context = context.add_data({key: value.strip(b'"')})
else:
context = context.add_data({key: b""})
elif strict:
raise CGATSInvalidError(
"Malformed {} file: {}".format(
(context.parent and context.type) or "CGATS",
self.filename or self,
)
)
return context
def _parse_raw_data_begin(self, context: CGATS, line: bytes) -> CGATS:
"""Parse raw data line and handle BEGIN_ sections.
Args:
context (CGATS): The current CGATS context.
line (bytes): The raw data line to parse.
Returns:
CGATS: The updated CGATS context.
"""
if line[:6] != b"BEGIN_":
return context
key = line[6:].decode()
if key in context:
# Start new CGATS
new = len(self)
self[new] = CGATS()
self[new].key = ""
self[new].parent = self
self[new].root = self.root
self[new].type = b""
context = self[new]
return context
def _parse_raw_data_deal_with_quotes(self, line: bytes) -> tuple[bytes, list]:
"""Parse raw data line and deal with comments and quotes.
Args:
line (bytes): The raw data line to parse.
Returns:
tuple[bytes, list]: The processed line and a list of values.
"""
if b"#" not in line and b'"' not in line:
# no comments or quotes
values = line.split()
return line, values
# Deal with comments and quotes
quoted = False
values = []
token_start = 0
end = len(line) - 1
for i in range(len(line)):
char = line[i : i + 1]
if char == b'"':
if quoted is False:
if not line[token_start:i]:
token_start = i
quoted = True
else:
quoted = False
if (quoted is False and char in b"# \t") or i == end:
if i == end:
i += 1
value = line[token_start:i]
if value:
if value[0:1] == b'"' == value[-2:-1]:
# Unquote
value = value[1:-1]
# Need to unescape double quote -> single quote
values.append(value.replace(b'""', b'"'))
if char == b"#":
# Strip comment
line = line[:i].strip()
break
if char in b" \t":
token_start = i + 1
return line, values
def __delattr__(self, name: str) -> None:
"""Delete attributes from CGATS dictionary.
Args:
name (str): The name of the attribute to delete.
"""
del self[name]
self.setmodified()
def __delitem__(self, name: str) -> None:
"""Delete item from CGATS dictionary.
Args:
name (str): The name of the item to delete.
"""
dict.__delitem__(self, name)
self.setmodified()
def __getattr__(self, name: str) -> Any: # noqa: ANN401
"""Get attributes from CGATS dictionary.
Args:
name (str): The name of the attribute to get.
Raises:
AttributeError: If the attribute is not found.
Returns:
Any: The value of the attribute.
"""
if name in self:
return self[name]
raise AttributeError(name)
def __getitem__(self, name: str) -> Any: # noqa: ANN401
"""Get item from CGATS dictionary.
Args:
name (str): The name of the item to get.
Raises:
CGATSKeyError: If the item is not found.
Returns:
Any: The value of the item.
"""
if name == -1:
return self.get(len(self) - 1)
if name in ("NUMBER_OF_FIELDS", "NUMBER_OF_SETS"):
return getattr(self, name)
if name in self:
if str(name).upper() in ("INDEX", "SAMPLE_ID", "SAMPLEID"):
if not isinstance(self.get(name), (int, float)):
return self.get(name)
if str(name).upper() == "INDEX":
return self.key
if isinstance(self.get(name), float):
return 1.0 / (self.NUMBER_OF_SETS - 1) * self.key
return self.key + 1
return self.get(name)
raise CGATSKeyError(name)
def get(self, name: int | str, default: None | Any = None) -> Any: # noqa: ANN401
"""Get item from CGATS dictionary.
Args:
name (int | str): The name or index of the item to get.
default (None | Any, optional): The value to return if the item is
not found.
Returns:
Any: The value of the item or the default value if not found.
"""
if name == -1:
return dict.get(self, len(self) - 1, default)
if name in ("NUMBER_OF_FIELDS", "NUMBER_OF_SETS"):
return getattr(self, name, default)
return dict.get(self, name, default)
def get_colorants(self) -> None | list:
"""Return colorants from CGATS file.
Returns:
None | list: List of colorants if available, otherwise None.
"""
color_rep = (self.queryv1("COLOR_REP") or b"").split(b"_")
if len(color_rep) != 2:
return None
query = {}
colorants = []
for i in range(len(color_rep[0])):
for j in range(len(color_rep[0])):
channelname = color_rep[0][j : j + 1]
# the key should be str
key = b"_".join([color_rep[0], channelname]).decode("utf-8")
query[key] = 100 if i == j else 0
colorants.append(self.queryi1(query))
return colorants
def get_descriptor(self, localized: bool = True) -> bytes:
"""Return CGATS description as string, based on metadata.
If 'localized' is True (default), include localized technology
description for CCSS files.
Args:
localized (bool, optional): If True, include localized technology
description for CCSS files. Defaults to True.
Returns:
bytes: CGATS description as bytes.
"""
desc = self.queryv1("DESCRIPTOR")
is_ccss = self.get(0, self).type == b"CCSS"
if not desc or desc == b"Not specified" or is_ccss:
if not is_ccss:
desc = self.queryv1("INSTRUMENT")
if desc:
display = self.queryv1("DISPLAY")
if display:
desc += b" & %s" % display
else:
tech = self.queryv1("TECHNOLOGY")
if tech:
if (
desc
and desc != b"Not specified"
and desc != b"CCSS for %s" % tech
):
display = desc
else:
display = self.queryv1("DISPLAY")
if localized:
from DisplayCAL import localization as lang
tech = tech.decode()
tech = lang.getstr(f"display.tech.{tech}", default=tech)
if display:
# Localized `tech` will always be a str,
# need to make sure `display` is as well.
display = (
display.decode("utf-8")
if isinstance(display, bytes)
else display
)
if display:
tech = f"{tech} ({display})"
desc = tech.encode("utf-8") if isinstance(tech, str) else tech
if not desc and self.filename:
# With Python 3.6+ the encoding is always "utf-8" independent of the OS.
desc = bytes(
str(os.path.splitext(os.path.basename(self.filename))[0]), "utf-8"
)
return desc
def __setattr__(self, name: str, value: Any) -> None: # noqa: ANN401
"""Set attributes on the CGATS object.
Args:
name (str): The name of the attribute to set.
value (Any): The value to set the attribute to.
"""
if name in ("_keys", "_lvl"):
object.__setattr__(self, name, value)
elif name == "modified":
self.setmodified(value)
elif name in (
"datetime",
"filename",
"fileName",
"file_identifier",
"key",
"mtime",
"normalize_fields",
"parent",
"root",
"type",
"vmaxlen",
"emit_keywords",
):
object.__setattr__(self, name, value)
self.setmodified()
else:
self[name] = value
def __setitem__(self, name: str, value: Any) -> None: # noqa: ANN401
"""Set item in CGATS dictionary.
Args:
name (str): The name of the item to set.
value (Any): The value to set for the item.
"""
dict.__setitem__(self, name, value)
self.setmodified()
def setmodified(self, modified: bool = True) -> None:
"""Set 'modified' state on the 'root' object."""
if self.root and self.root._modified != modified:
object.__setattr__(self.root, "_modified", modified)
def __bytes__(self) -> bytes:
"""Return CGATS data as bytes.
Returns:
bytes: CGATS data as bytes.
"""
result = []
lvl = self.root._lvl
self.root._lvl += 1
data = None
if self.type == b"SAMPLE":
result.append(
b" ".join(
rpad(self[item], self.parent.vmaxlen + (1 if self[item] < 0 else 0))
for item in list(self.parent.parent["DATA_FORMAT"].values())
)
)
elif self.type == b"DATA":
data = self
elif self.type == b"DATA_FORMAT":
result.append(b" ".join(list(self.values())))
else:
data, result = self.__bytes_from_subsections(data, result)
if data and data.parent["DATA_FORMAT"]:
if "KEYWORDS" in data.parent and self.emit_keywords:
result.extend(
b'KEYWORD "%s"' % item
for item in list(data.parent["DATA_FORMAT"].values())
if item in list(data.parent["KEYWORDS"].values())
)
result.append(
b"NUMBER_OF_FIELDS %s"
% bytes(str(len(data.parent["DATA_FORMAT"])), "utf-8")
)
result.append(b"BEGIN_DATA_FORMAT")
result.append(b" ".join(list(data.parent["DATA_FORMAT"].values())))
result.append(b"END_DATA_FORMAT")
result.append(b"")
result.append(b"NUMBER_OF_SETS %s" % (bytes(str(len(data)), "utf-8")))
result.append(b"BEGIN_DATA")
result.extend(
b" ".join(
[
rpad(
data[key][item.decode("utf-8")],
data.vmaxlen
+ (1 if data[key][item.decode("utf-8")] < 0 else 0),
)
for item in list(data.parent["DATA_FORMAT"].values())
]
)
for key in data
)
result.append(b"END_DATA")
if (
((self.parent and self.parent.type) or self.type) == b"ROOT"
and result
and result[-1] != b""
and lvl == 0
):
# Add empty line at end if not yet present
result.append(b"")
self.root._lvl -= 1
return b"\n".join(result)
def __bytes_from_subsections(self, data: CGATS, result: list) -> tuple[CGATS, list]:
"""Generate bytes from subsections.
Args:
data (CGATS): The CGATS data to process.
result (list): The list to append the generated bytes to.
Returns:
tuple[CGATS, list]: A tuple containing the data and the result
list.
"""
if self.datetime:
result.append(self.datetime)
if self.type == b"SECTION":
result.append(b"BEGIN_" + self.key.encode())
elif self.parent and self.parent.type == b"ROOT":
# Make sure CGATS file identifiers are always a minimum of 7 characters
result.append(self.type.ljust(7))
result.append(b"")
data, result = self.__bytes_from_subsection_data(data, result)
if self.type == b"SECTION":
result.append(b"END_" + self.key.encode())
if self.type == b"SECTION" or data:
result.append(b"")
return data, result
def __bytes_from_subsection_data(
self, data: CGATS, result: list
) -> tuple[CGATS, list]:
"""Generate bytes from subsection data.
Args:
data (CGATS): The CGATS data to process.
result (list): The list to append the generated bytes to.
Returns:
tuple[CGATS, list]: A tuple containing the data and the result
list.
"""
if self.type in (b"DATA", b"DATA_FORMAT", b"KEYWORDS", b"SECTION"):
iterable = self
else:
iterable = self.keys()
for key in iterable:
value = self[key]
value = value.encode("utf-8") if isinstance(value, str) else value
if key == "DATA":
data = value
elif isinstance(value, (float, int, bytes)):
if key not in ("NUMBER_OF_FIELDS", "NUMBER_OF_SETS"):
if isinstance(key, int):
result.append(
value
if isinstance(value, bytes)
else bytes(str(value), "utf-8")
)
else:
if (
"KEYWORDS" in self
and key in list(self["KEYWORDS"].values())
and self.emit_keywords
):
result.append(b'KEYWORD "%s"' % key.encode())
if isinstance(value, bytes):
# Need to escape single quote -> double quote
value = value.replace(b'"', b'""')
if isinstance(value, (float, int)):
value = bytes(str(value), "utf-8")
result.append(b'%s "%s"' % (key.encode(), value))
elif key not in ("DATA_FORMAT", "KEYWORDS"):
if value.type == b"SECTION" and result[-1:] and result[-1:][0] != b"":
result.append(b"")
result.append(bytes(value))
return data, result
def add_keyword(self, keyword: str, value: None | str = None) -> None:
"""Add a keyword to the list of keyword values.
Args:
keyword (str): The keyword to add.
value (str, optional): The value associated with the keyword.
Defaults to None.
"""
if isinstance(keyword, bytes):
keyword = keyword.decode()
if self.type in (b"DATA", b"DATA_FORMAT", b"KEYWORDS", b"SECTION"):
context = self.parent
elif self.type == b"SAMPLE":
context = self.parent.parent
else:
context = self
if "KEYWORDS" not in context:
context["KEYWORDS"] = CGATS()
context["KEYWORDS"].key = "KEYWORDS"
context["KEYWORDS"].parent = context
context["KEYWORDS"].root = self.root
context["KEYWORDS"].type = b"KEYWORDS"
if keyword.encode() not in list(context["KEYWORDS"].values()):
newkey = len(context["KEYWORDS"])
while newkey in context["KEYWORDS"]:
newkey += 1
context["KEYWORDS"][newkey] = keyword.encode()
if value is not None:
context[keyword] = value
def add_section(self, key: str, value: str) -> None:
"""Add a section to the CGATS data.
Args:
key (str): The key for the section.
value (str): The value for the section.
"""
self[key] = CGATS()
self[key].key = key
self[key].parent = self
self[key].root = self
self[key].type = b"SECTION"
self[key].add_data(value)
def remove_keyword(self, keyword: str, remove_value: bool = True) -> None:
"""Remove a keyword from the list of keyword values.
Args:
keyword (str): The keyword to remove.
remove_value (bool): If True, also remove the value associated
with the keyword. Defaults to True.
"""
if self.type in (b"DATA", b"DATA_FORMAT", b"KEYWORDS", b"SECTION"):
context = self.parent
elif self.type == b"SAMPLE":
context = self.parent.parent
else:
context = self
for key in list(context["KEYWORDS"].keys()):
if context["KEYWORDS"][key] == keyword.encode():
del context["KEYWORDS"][key]
if remove_value:
del context[keyword]
def insert(self, key: None | int = None, data: None | CGATS = None) -> None:
"""Insert data at index key. Also see add_data method.
Args:
key (int, optional): The index at which to insert the data.
If None, data is appended. Defaults to None.
data (CGATS, optional): The CGATS data to insert. If None,
the current CGATS instance is used. Defaults to None.
"""
self.add_data(data, key)
def append(self, data: CGATS) -> None:
"""Append data. Also see add_data method.
Args:
data (CGATS): The CGATS data to append.
"""
self.add_data(data)
def get_data(self, field_names: None | tuple = None) -> bool | CGATS:
"""Get CGATS data.
Args:
field_names (tuple, optional): A tuple of field names to query.
If None, all data is returned. Defaults to None.
Returns:
bool | CGATS: A dictionary containing the CGATS data.
"""
data = self.queryv1("DATA")
if not data:
return False
if field_names:
data = data.queryi(field_names)
return data
def get_rgb_xyz_values(self) -> tuple[bool, bool] | tuple[CGATS, list]:
"""Get RGB and XYZ values from the CGATS data.
Returns:
tuple: A tuple containing two elements:
- A dictionary with RGB and XYZ values.
- A list of lists containing RGB and XYZ values in the order:
[R, G, B, X, Y, Z].
If no data is found, returns (False, False).
"""
field_names = ("RGB_R", "RGB_G", "RGB_B", "XYZ_X", "XYZ_Y", "XYZ_Z")
data = self.get_data(field_names)
if not data:
return False, False
values_list = [
[data[_key][field_name] for field_name in field_names] for _key in data
]
return data, values_list
def set_rgb_xyz_values(self, values_list: list) -> bool:
"""Set RGB and XYZ values in the CGATS data.
Args:
values_list (list): A list of RGB and XYZ values, where each entry
is a list containing RGB and XYZ values in the order:
[R, G, B, X, Y, Z].
Returns:
bool: True if values were set successfully, False otherwise.
"""
field_names = ("RGB_R", "RGB_G", "RGB_B", "XYZ_X", "XYZ_Y", "XYZ_Z")
for i, values in enumerate(values_list):
for j, field_name in enumerate(field_names):
self[i][field_name] = values[j]
return True
def checkerboard(
self,
sort1: Callable = sort_by_l,
sort2: Callable = sort_rgb_white_to_top,
split_grays: bool = False,
shift: bool = False,
) -> bool:
"""Return a checkerboard of RGB values.
Args:
sort1 (Callable): Function to sort the first dimension.
sort2 (Callable): Function to sort the second dimension.
split_grays (bool): If True, split grays from colors.
shift (bool): If True, shift values in checkerboard.
Returns:
bool: True if checkerboard was created successfully, False
otherwise.
"""
data, values_list = self.get_rgb_xyz_values()
if not values_list:
return False
numvalues = len(values_list)
values_list = (
sorted(values_list, key=functools.cmp_to_key(sort1))
if sort1
else values_list
)
values_list = (
sorted(values_list, key=functools.cmp_to_key(sort2))
if sort2
else values_list
)
gray = []
color = (
self.split_grays(values_list, gray, numvalues)
if split_grays
else values_list
)
checkerboard = []
for values_list in [gray, color]:
if not values_list:
continue
split = round(len(values_list) / 2.0)
values_list1 = values_list[:split]
values_list2 = values_list[split:]
if shift:
# Shift values.
#
# If split is even:
# A1 A2 A3 A4 -> A1 B2 B3 B1 B4
# B1 B2 B3 B4 -> A3 A4 A2
#
# If split is uneven:
# A1 A2 A3 -> A1 B1 B2 B3 B4
# B1 B2 B3 B4 -> A2 A3
offset = 0
if split == len(values_list) / 2.0:
# Even split
offset += 1
values_list1_orig = list(values_list1)
values_list2_orig = list(values_list2)
values_list1 = values_list2_orig[offset:]
values_list2 = values_list1_orig[offset + 1 :]
values_list1.insert(0, values_list1_orig[0])
if offset:
values_list1.insert(-1, values_list2_orig[0])
values_list2.extend(values_list1_orig[1:2])
# Interleave.
# 1 2 3 4 5 6 7 8 -> 1 5 2 6 3 7 4 8
while values_list1 or values_list2:
for values_list in (values_list1, values_list2):
if values_list:
values = values_list.pop(0)
checkerboard.append(values)
if shift and checkerboard[-1][:3] == [100, 100, 100]:
# Move white patch to front
debug_print("INFO - moving white to front")
checkerboard.insert(0, checkerboard.pop())
if len(checkerboard) != numvalues:
# This should never happen
print(
"Number of patches incorrect after re-ordering "
f"(is {len(checkerboard)}, should be {numvalues})"
)
return False
return data.set_rgb_xyz_values(checkerboard)
def split_grays(self, values_list: list, gray: list, numvalues: int) -> list:
"""Split values into gray and color.
Args:
values_list (list): List of RGB values.
gray (list): List to store gray values.
numvalues (int): Total number of values.
Returns:
list: List of color and gray values.
"""
# Split values into gray and color. First gray in a consecutive
# sequence of two or more grays will be added to color list,
# following grays will be added to gray list.
color = []
prev_i = -1
prev_values = []
added = {prev_i: True} # Keep track of entries we have added
for i, values in enumerate(values_list):
debug_print(i + 1, "IN", values[:3])
is_gray = values[:3] == [values[:3][0]] * 3
prev = color
cur = color
if is_gray:
if not prev_values:
debug_print("WARNING - skipping gray because no prev")
elif values[:3] == prev_values[:3]:
# Same gray as prev value
prev = color
cur = gray
debug_print(
f"INFO - appending prev {prev_values[:3]} to color "
"because prev was same gray but got skipped",
other_conditions=prev_i not in added,
)
debug_print(
"INFO - appending cur to gray because prev "
f"{prev_values[:3]} was same gray"
)
elif prev_values[:3] == [prev_values[:3][0]] * 3:
# Prev value was different gray
prev = gray
cur = gray
debug_print(
f"INFO - appending prev {prev_values[:3]} to gray "
"because prev was different gray but got skipped",
other_conditions=prev_i not in added,
)
debug_print(
"INFO - appending cur to gray because prev "
f"{prev_values[:3]} was different gray"
)
elif i < numvalues - 1:
debug_print(
"WARNING - skipping gray because prev "
f"{prev_values[:3]} was not gray"
)
else:
# Last
debug_print(
"INFO - appending cur to color because prev "
f"{prev_values[:3]} was not gray but cur is last"
)
if not is_gray or cur is gray or i == numvalues - 1:
if prev_i not in added:
debug_print(
f"INFO - appending prev {prev_values[:3]} "
"to color because prev got skipped",
other_conditions=prev is cur is color,
)
prev.append(prev_values)
added[prev_i] = True
debug_print(
"INFO - appending cur to color",
other_conditions=not is_gray and cur is color,
)
cur.append(values)
added[i] = True
prev_i = i
prev_values = values
return color
def sort_rgb_gray_to_top(self) -> bool:
"""Sort RGB values with gray at the top.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_rgb_gray_to_top)
def sort_rgb_to_top(
self, red: bool = False, green: bool = False, blue: bool = False
) -> bool:
"""Sort quantities of R, G or B (or combinations) to top.
Example: sort_RGB_to_top(True, False, False) - sort red values to top
Example: sort_RGB_to_top(False, True, True) - sort cyan values to top
Args:
red (bool): If True, sort red values to top.
green (bool): If True, sort green values to top.
blue (bool): If True, sort blue values to top.
Returns:
bool: True if sorting was successful, False otherwise.
"""
if red and green and blue:
function = sort_rgb_gray_to_top
elif red and green:
function = sort_rgb_to_top_factory(0, 1, 2, 0)
elif red and blue:
function = sort_rgb_to_top_factory(0, 2, 1, 0)
elif green and blue:
function = sort_rgb_to_top_factory(1, 2, 0, 1)
elif red:
function = sort_rgb_to_top_factory(1, 2, 1, 0)
elif green:
function = sort_rgb_to_top_factory(0, 2, 0, 1)
elif blue:
function = sort_rgb_to_top_factory(0, 1, 0, 2)
else:
return False
return self.sort_data_rgb_xyz(function)
def sort_rgb_white_to_top(self) -> bool:
"""Sort RGB values with white at the top.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_rgb_white_to_top)
def sort_by_hsi(self) -> bool:
"""Sort by HSI values.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_by_hsi)
def sort_by_hsl(self) -> bool:
"""Sort by HSL values.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_by_hsl)
def sort_by_hsv(self) -> bool:
"""Sort by HSV values.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_by_hsv)
def sort_by_l(self) -> bool:
"""Sort by L values.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_by_l)
def sort_by_rgb(self) -> bool:
"""Sort by RGB values.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_by_rgb)
def sort_by_bgr(self) -> bool:
"""Sort by BGR values.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_by_bgr)
def sort_by_rgb_pow_sum(self) -> bool:
"""Sort by RGB power sum.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_by_rgb_pow_sum)
def sort_by_rgb_sum(self) -> bool:
"""Sort by RGB sum.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_by_rgb_sum)
def sort_by_rec709_luma(self) -> bool:
"""Sort by Rec. 709 luma.
Returns:
bool: True if sorting was successful, False otherwise.
"""
return self.sort_data_rgb_xyz(sort_by_rec709_luma)
def sort_data_rgb_xyz(
self,
cmp: None | Callable = None,
key: None | Callable = None,
reverse: bool = False,
) -> bool:
"""Sort RGB/XYZ data.
Args:
cmp (callable, optional): Comparison function to use for sorting.
key (callable, optional): Key function to use for sorting.
reverse (bool, optional): If True, sort in descending order.
Returns:
bool: True if sorting was successful, False otherwise.
"""
data, valueslist = self.get_rgb_xyz_values()
if not valueslist:
return False
valueslist = sorted(valueslist, key=functools.cmp_to_key(cmp), reverse=reverse)
return data.set_rgb_xyz_values(valueslist)
@property
def modified(self) -> bool:
"""Return whether the CGATS object has been modified.
Returns:
bool: True if modified, False otherwise.
"""
if self.root:
return self.root._modified
return self._modified
def moveby1(self, start: int, inc: int = 1) -> None:
"""Move items from start by incrementing or decrementing their key by inc.
Args:
start (int): The starting index from which to move items.
inc (int, optional): The increment by which to move items.
Defaults to 1.
"""
r = range(start, len(self) + 1)
if inc > 0:
r = reversed(r)
for key in r:
if key in self:
if key + inc < 0:
break
self[key].key += inc
self[key + inc] = self[key]
if key == len(self) - 1:
break
def add_data(
self, data: bytes | str | dict | list | tuple | CGATS, key: None | int = None
) -> CGATS:
"""Add data to the CGATS structure.
Args:
data (bytes | str | dict | list | tuple | CGATS): The data to add.
key (None | int, optional): The index at which to insert the data.
If None, data is appended. Defaults to None.
Returns:
CGATS: The context in which the data was added.
"""
context = self
if self.type == b"DATA":
key = self._add_data_array_type(data, key)
elif self.type == b"ROOT":
key, context = self._add_data_root(data, key)
elif self.type == b"SECTION":
self._add_data_section(data, key)
elif self.type in (b"DATA_FORMAT", b"KEYWORDS") or (
self.parent and self.parent.type == b"ROOT"
):
self._add_data_format_or_keywords(data)
else:
raise CGATSInvalidOperationError(f"Cannot add data to {self.type}")
return context
def _add_data_format_or_keywords(self, data: dict | list | tuple) -> None:
"""Add data to DATA_FORMAT or KEYWORDS type.
Args:
data (dict | list | tuple): The data to add.
Raises:
CGATSTypeError: If the data type is invalid.
"""
if not isinstance(data, (dict, list, tuple)):
raise CGATSTypeError(
f"Invalid data type for {self.type} (expected "
f"CGATS, dict, list or tuple, got {type(data)})"
)
for var in data:
var = var.decode() if isinstance(var, bytes) else var
if var in ("NUMBER_OF_FIELDS", "NUMBER_OF_SETS"):
self[var] = None
continue
if isinstance(data, dict):
if self.type in (b"DATA_FORMAT", b"KEYWORDS"):
key, value = len(self), data[var]
else:
key, value = var, data[var]
else:
key, value = len(self), var.encode()
if (
self.root.normalize_fields
and (self.type in (b"DATA_FORMAT", b"KEYWORDS") or var == "KEYWORD")
and isinstance(value, bytes)
):
value = value.upper()
value = value.replace(b"SAMPLEID", b"SAMPLE_ID").replace(
b"SAMPLENAME", b"SAMPLE_NAME"
)
# if value == b"SAMPLEID":
# value = b"SAMPLE_ID"
# elif value == b"SAMPLENAME":
# value = b"SAMPLE_NAME"
if var == "KEYWORD":
self.emit_keywords = True
if value != b"KEYWORD":
self.add_keyword(value)
else:
print('Warning: cannot add keyword "KEYWORD"')
else:
value = self.__add_data_from_bytes_value(key, value)
self[key] = value
def __add_data_from_bytes_value(
self, key: int | str, value: bytes | str
) -> int | float:
"""Add data from bytes value.
Args:
key (int | str): The key for the data.
value (bytes | str): The value to add.
Raises:
CGATSTypeError: If the value type is invalid.
Returns:
int | float: The value converted to int or float if applicable.
"""
if isinstance(value, bytes) and key not in (
"DESCRIPTOR",
"ORIGINATOR",
"CREATED",
"DEVICE_CLASS",
"COLOR_REP",
"TARGET_INSTRUMENT",
"LUMINANCE_XYZ_CDM2",
"OBSERVER",
"INSTRUMENT",
"MANUFACTURER_ID",
"MANUFACTURER",
"REFERENCE",
"REFERENCE_OBSERVER",
"DISPLAY",
"TECHNOLOGY",
"REFERENCE_FILENAME",
"REFERENCE_HASH",
"TARGET_FILENAME",
"TARGET_HASH",
"FIT_METHOD",
):
match = re.match(rb"(?:\d+|((?:\d*\.\d+|\d+)(?:e[+-]?\d+)?))$", value)
if match:
value = float(value) if match.groups()[0] else int(value)
if self.type in (b"DATA_FORMAT", b"KEYWORDS"):
raise CGATSTypeError(
f"Invalid data type for {self.type} "
"(expected bytes or str, "
f"got {type(value)})"
)
return value
def _add_data_section(self, data: str | CGATS, key: None | int = None) -> None:
"""Add data to SECTION type.
Args:
data (str | CGATS): The data to add.
key (None | int, optional): The index at which to insert the data.
If None, data is appended. Defaults to None.
Raises:
CGATSTypeError: If the data type is invalid.
"""
if isinstance(data, bytes):
if isinstance(key, int):
# accept only integer keys.
# move existing items
self.moveby1(key)
else:
key = len(self)
self[key] = data
else:
raise CGATSTypeError(
f"Invalid data type for {self.type} "
f"(expected bytes or str, got {type(data)})"
)
def _add_data_root(
self, data: bytes | str, key: None | int = None
) -> tuple[int, CGATS]:
"""Add data to ROOT type.
Args:
data (bytes | str): The data to add.
key (None | int, optional): The index at which to insert the data.
If None, data is appended. Defaults to None.
Returns:
tuple[int, CGATS]: A tuple containing the key at which the data was added
and the CGATS context where the data was added.
"""
if isinstance(data, bytes) and data.find(b"\n") < 0 and data.find(b"\r") < 0:
if isinstance(key, int):
# accept only integer keys.
# move existing items
self.moveby1(key)
else:
key = len(self)
self[key] = CGATS()
self[key].key = key
self[key].parent = self
self[key].root = self.root
self[key].type = data
context = self[key]
elif not len(self):
context = self.add_data(self.file_identifier) # create root element
context = context.add_data(data, key)
else:
raise CGATSTypeError(
f"Invalid data type for {self.type} "
f"(expected str or unicode without line endings, got {type(data)})"
)
return key, context
def _add_data_array_type(
self, data: dict | list | tuple | CGATS, key: None | int = None
) -> int:
"""Add data to DATA type.
Args:
data (CGATS | dict | list | tuple): The data to add.
key (None | int, optional): The index at which to insert the data.
If None, data is appended. Defaults to None.
Raises:
CGATSTypeError: If the data type is invalid.
CGATSInvalidOperationError: If DATA_FORMAT is missing.
Returns:
int: The key at which the data was added.
"""
if not isinstance(data, (dict, list, tuple)):
raise CGATSTypeError(
f"Invalid data type for {self.type} (expected CGATS, dict, list or "
f"tuple, got {type(data)})"
)
if not self.parent["DATA_FORMAT"]:
raise CGATSInvalidOperationError(
"Cannot add to DATA because of missing DATA_FORMAT"
)
fl, il = len(self.parent["DATA_FORMAT"]), len(data)
if fl != il:
raise CGATSTypeError(f"DATA entries take exactly {fl} values ({il} given)")
dataset = CGATS()
dataset = self._add_data_from_data_format_values(data, dataset)
if isinstance(key, int):
# accept only integer keys.
# move existing items
self.moveby1(key)
else:
key = len(self)
dataset.key = key
dataset.parent = self
dataset.root = self.root
dataset.type = b"SAMPLE"
self[key] = dataset
return key
def _add_data_from_data_format_values(
self, data: dict | list | tuple, dataset: CGATS
) -> CGATS:
"""Add data from DATA_FORMAT values.
Args:
data (dict | list | tuple): The data to add.
dataset (CGATS): The CGATS instance to which the data will be added.
Returns:
CGATS: The updated CGATS instance with the added data.
"""
for i, item in enumerate(list(self.parent["DATA_FORMAT"].values())):
if isinstance(data, dict):
try:
value = data[item.decode()]
except KeyError as e:
raise CGATSKeyError(item) from e
else:
value = data[i]
if item.upper() in (b"INDEX", b"SAMPLE_ID", b"SAMPLEID"):
item, value = self._add_data_from_sample_id(item, value)
elif item.upper() not in (b"SAMPLE_NAME", b"SAMPLE_LOC", b"SAMPLENAME"):
value = self._add_data_from_sample_name(item, value)
elif self.root.normalize_fields and item.upper() == b"SAMPLENAME":
item = b"SAMPLE_NAME"
dataset[item.decode()] = value
return dataset
def _add_data_from_sample_id(
self, item: bytes, value: bytes | str | float
) -> tuple[bytes, int | float]:
"""Add data from sample ID.
Args:
item (bytes): The item key.
value (bytes | str | float): The value associated with the
item.
Returns:
tuple[bytes, int | float]: The processed item key and value.
"""
if self.root.normalize_fields and item.upper() == b"SAMPLEID":
item = b"SAMPLE_ID"
# allow alphanumeric INDEX / SAMPLE_ID
if isinstance(value, bytes):
match = re.match(rb"(?:\d+|((?:\d*\.\d+|\d+)(?:e[+-]?\d+)?))$", value)
if match:
value = float(value) if match.groups()[0] else int(value)
return item, value
def _add_data_from_sample_name(
self, item: bytes, value: bytes | str | float
) -> float:
"""Add data from sample name.
Args:
item (bytes): The item key.
value (bytes | str | float): The value associated with the
item.
Returns:
float: The processed value.
"""
try:
value = float(value)
except ValueError as e:
raise CGATSValueError(
f"Invalid data type for {item} "
f"(expected float, got {value.__class__.__name__})"
) from e
else:
strval = bytes(str(abs(value)), "UTF-8")
if (
self.parent.type != b"CAL" and item.startswith(b"RGB_")
) or item.startswith(b"CMYK_"):
# Assuming 0..100, 4 decimal digits is
# enough for roughly 19 bits integer
# device values
parts = strval.split(b".")
if len(parts) == 2 and len(parts[-1]) > 4:
value = round(value, 4)
strval = bytes(str(abs(value)), "UTF-8")
parts = strval.split(b"e")
lencheck = len(parts[0])
if len(parts) > 1:
lencheck += abs(int(parts[1]))
self.vmaxlen = max(self.vmaxlen, lencheck)
return value
def export_3d(
self,
filename: str,
colorspace: str = "RGB",
rgb_black_offset: float = 40,
normalize_rgb_white: bool = False,
compress: bool = True,
file_format: str = "VRML",
) -> None:
"""Export 3D data to a file in the specified colorspace.
Args:
filename (str): The name of the file to export to.
colorspace (str): The colorspace to use for the export.
Supported values are: "DIN99", "DIN99b", "DIN99c", "DIN99d",
"LCH(ab)", "LCH(uv)", "Lab", "Luv", "Lu'v'", "RGB", "xyY",
"HSI", "HSL", "HSV", "ICtCp", "IPT", and "Lpt".
rgb_black_offset (float): The offset for black in RGB space.
normalize_rgb_white (bool): Whether to normalize RGB white.
compress (bool): Whether to compress the output file.
file_format (str): The format of the output file, e.g., 'VRML'.
Raises:
ValueError: If the specified colorspace is not supported.
"""
if colorspace not in ColorSpaceToVRML.VALID_COLOR_SPACE_NAMES:
raise ValueError(f"export_3d: Unknown colorspace {colorspace!r}")
if self.queryv1("ACCURATE_EXPECTED_VALUES") == "true":
cat = "Bradford"
else:
cat = "XYZ scaling"
data = self.queryv1("DATA")
white = data.queryi1({"RGB_R": 100, "RGB_G": 100, "RGB_B": 100})
white = white["XYZ_X"], white["XYZ_Y"], white["XYZ_Z"] if white else "D50"
white = colormath.get_whitepoint(white)
colorspace_to_vrml: ColorSpaceToVRML = COLORSPACE_NAME_TO_VRML_MAP[colorspace](
data=data,
white_point=white,
cat=cat,
rgb_black_offset=rgb_black_offset,
normalize_rgb_white=normalize_rgb_white,
)
colorspace_to_vrml.generate_vrml()
colorspace_to_vrml.write_vrml(
file_format=file_format,
filename=filename,
compress=compress,
)
@property
def NUMBER_OF_FIELDS(self) -> int: # noqa: N802
"""Get number of fields.
Returns:
int: Number of fields in the CGATS object.
"""
if "DATA_FORMAT" in self:
return len(self["DATA_FORMAT"])
return 0
@property
def NUMBER_OF_SETS(self) -> int: # noqa: N802
"""Get number of sets.
Returns:
int: Number of sets in the CGATS object.
"""
if "DATA" in self:
return len(self["DATA"])
return 0
def query( # noqa: C901
self,
query: str | dict | list | tuple,
query_value: None | Any = None, # noqa: ANN401
get_value: bool = False,
get_first: bool = False,
) -> int | float | bytes | CGATS:
"""Return CGATS object of items or values where query matches.
Query can be a dict with key / value pairs, a tuple or a string.
Return empty CGATS object if no matching items found.
Args:
query (str | dict | list | tuple): The query to match against.
query_value (Any, optional): The value to match against the query.
get_value (bool): If True, return values instead of items.
get_first (bool): If True, return only the first matching item or
value.
Returns:
int | float | bytes | CGATS: Matching items or values.
"""
# TODO: Simplify this method.
modified = self.modified
result = CGATS() if not get_first else None
if not isinstance(query, (dict, list, tuple)):
query = (query,)
items = [self] + [self[key] for key in self]
for item in items:
if not isinstance(item, (dict, list, tuple)):
continue
if not get_first:
n = len(result)
result_n = CGATS() if get_value else None
match_count = 0
for query_key in query:
if query_key in item or (
isinstance(item, CGATS)
and (
(query_key == "NUMBER_OF_FIELDS" and "DATA_FORMAT" in item)
or (query_key == "NUMBER_OF_SETS" and "DATA" in item)
)
):
current_query_value = (
query[query_key]
if query_value is None and isinstance(query, dict)
else query_value
)
if (
current_query_value is not None
and item[query_key] != current_query_value
):
break
if get_value:
result_n[len(result_n)] = item[query_key]
match_count += 1
else:
break
if match_count == len(query):
if not get_value:
result_n = item
if result_n is not None:
if get_first:
result = (
result_n[0]
if (
get_value
and isinstance(result_n, dict)
and len(result_n) == 1
)
else result_n
)
break
if len(result_n):
result[n] = (
result_n[0]
if (
get_value
and isinstance(result_n, dict)
and len(result_n) == 1
)
else result_n
)
if isinstance(item, CGATS) and item != self:
result_n = item.query(query, query_value, get_value, get_first)
if result_n is not None:
if get_first:
result = result_n
break
if len(result_n):
for i in result_n:
n = len(result)
if result_n[i] not in list(result.values()):
result[n] = result_n[i]
if isinstance(result, CGATS):
result.setmodified(modified)
return result
def queryi(
self,
query: str | dict | list | tuple,
query_value: None | Any = None, # noqa: ANN401
) -> int | float | bytes | CGATS:
"""Query and return matching items. See also query method.
Args:
query (str | dict | list | tuple): The query to match against.
query_value (Any, optional): The value to match against the query.
Returns:
int | float | bytes | CGATS: The matching items or CGATS object.
"""
return self.query(query, query_value, get_value=False, get_first=False)
def queryi1(
self,
query: str | dict | list | tuple,
query_value: None | Any = None, # noqa: ANN401
) -> int | float | bytes | CGATS:
"""Query and return first matching item. See also query method.
Args:
query (str | dict | list | tuple): The query to match against.
query_value (Any, optional): The value to match against the query.
Returns:
int | float | bytes | CGATS: The first matching item or CGATS object.
"""
return self.query(query, query_value, get_value=False, get_first=True)
def queryv(
self,
query: str | dict | list | tuple,
query_value: None | Any = None, # noqa: ANN401
) -> int | float | bytes | CGATS:
"""Query and return matching values. See also query method.
Args:
query (str | dict | list | tuple): The query to match against.
query_value (Any, optional): The value to match against the query.
Returns:
int | float | bytes | CGATS: The matching values or CGATS object.
"""
return self.query(query, query_value, get_value=True, get_first=False)
def queryv1(
self,
query: str | dict | list | tuple,
query_value: None | Any = None, # noqa: ANN401
) -> int | float | bytes | CGATS:
"""Query and return first matching value. See also query method.
Args:
query (str | dict | list | tuple): The query to match against.
query_value (Any, optional): The value to match against the query.
Returns:
int | float | bytes | CGATS: The first matching value or CGATS object.
"""
return self.query(query, query_value, get_value=True, get_first=True)
def remove(self, item: int | str | CGATS) -> Any: # noqa: ANN401
"""Remove an item from the internal CGATS structure."""
key = item.key if isinstance(item, CGATS) else item
maxindex = len(self) - 1
result = self[key]
if isinstance(key, int) and key != maxindex:
self.moveby1(key + 1, -1)
name = len(self) - 1
dict.pop(self, name)
self.setmodified()
return result
def convert_xyz_to_lab(self) -> None:
"""Convert XYZ to D50 L*a*b* and add it as additional fields.
Raises:
NotImplementedError: If the color representation is not supported.
CGATSError: If no data or white patch is found.
"""
color_rep = (self.queryv1("COLOR_REP") or b"").split(b"_")
if color_rep[1] == b"LAB":
# Nothing to do
return
if (
len(color_rep) != 2
or color_rep[0] not in (b"RGB", b"CMYK")
or color_rep[1] != b"XYZ"
):
raise NotImplementedError(
"Got unsupported color representation {}".format(
b"_".join(color_rep).decode("utf-8")
)
)
data = self.queryv1("DATA")
if not data:
raise CGATSError("No data")
white = self._get_white_patch(color_rep, data)
if not white:
raise CGATSError("Missing white patch")
device_labels = []
for i in range(len(color_rep[0])):
channel = color_rep[0][i : i + 1]
device_labels.append(color_rep[0] + b"_" + channel)
# Always XYZ
cie_labels = []
for i in range(len(color_rep[1])):
channel = color_rep[1][i : i + 1]
cie_labels.append(color_rep[1] + b"_" + channel)
# Add entries to DATA_FORMAT
lab_data_format = (b"LAB_L", b"LAB_A", b"LAB_B")
for label in lab_data_format:
if label not in list(data.parent.DATA_FORMAT.values()):
data.parent.DATA_FORMAT.add_data((label,))
# Add L*a*b* to each sample
for _key in data:
sample = data[_key]
cie_values = [sample[label.decode("utf-8")] for label in cie_labels]
lab = colormath.XYZ2Lab(*cie_values)
for i, label in enumerate(lab_data_format):
sample[label] = lab[i]
def _get_white_patch(self, color_rep: tuple, data: CGATS) -> None | bytes:
"""Get the white patch based on the color representation.
Args:
color_rep (tuple): The color representation of the sample.
data (CGATS): The CGATS data object containing samples.
Returns:
None | bytes: The white patch values for the color representation,
or None if not found.
"""
white = None
if color_rep[0] == b"RGB":
white = data.queryv1({"RGB_R": 100, "RGB_G": 100, "RGB_B": 100})
elif color_rep[0] == b"CMYK":
white = data.queryv1({"CMYK_C": 0, "CMYK_M": 0, "CMYK_Y": 0, "CMYK_K": 0})
return white
def fix_zero_measurements(
self, warn_only: bool = False, logfile: Callable = safe_print
) -> None:
"""Fix (or warn about) <= zero measurements.
If XYZ/Lab = 0, the sample gets removed. If only one component of
XYZ/Lab is <= 0, it gets fudged so that the component is nonzero
(because otherwise, Argyll's colprof will remove it, which can have bad
effects if it's an 'essential' sample)
Args:
warn_only (bool): If True, only warn about the issue, do not fix it.
logfile (callable): A function to log messages to, defaults to
safe_print.
"""
color_rep = (self.queryv1("COLOR_REP") or b"").split(b"_")
data = self.queryv1("DATA")
if len(color_rep) != 2 or not data:
return
# Check for XYZ/Lab = 0 readings
cie_labels = self._get_cie_labels(color_rep)
device_labels = self._generate_device_labels(color_rep)
remove = []
for _key in data:
sample = data[_key]
cie_values = [sample[label.decode("utf-8")] for label in cie_labels]
# Check if zero
device_label_values = sample.queryv1(device_labels)
if [v for v in cie_values if v]:
# Not all zero. Check if some component(s) equal or below zero
if min(cie_values) <= 0:
for label in cie_labels:
if sample[label.decode("utf-8")] > 0:
continue
if warn_only:
self._warn_sample_below_threshold(
logfile, color_rep, sample, device_label_values, label
)
else:
# Fudge to be nonzero
sample[label.decode("utf-8")] = 0.000001
self._log_fudged_sample(
logfile, color_rep, sample, device_label_values, label
)
continue
# All zero
device_values = [sample[label.decode("utf-8")] for label in device_labels]
if not max(device_values):
# Skip device black
continue
if warn_only:
self._warn_zero_measurement(
logfile, color_rep, sample, device_label_values
)
else:
# Queue sample for removal
remove.insert(0, sample)
self._log_sample_removal(
logfile, color_rep, sample, device_label_values
)
for sample in remove:
# Remove sample
data.pop(sample)
def _get_cie_labels(self, color_rep: tuple) -> list:
"""Generate CIE labels based on the color representation.
Args:
color_rep (tuple): The color representation of the sample.
Returns:
list: A list of CIE labels for the color representation.
"""
cie_labels = []
for i in range(len(color_rep[1])):
channel = color_rep[1][i : i + 1]
cie_labels.append(color_rep[1] + b"_" + channel)
if color_rep[1] == b"LAB":
# Only check L* for zero values
break
return cie_labels
def _generate_device_labels(self, color_rep: tuple) -> list:
"""Generate device labels based on the color representation.
Args:
color_rep (tuple): The color representation of the sample.
Returns:
list: A list of device labels for the color representation.
"""
device_labels = []
for i in range(len(color_rep[0])):
channel = color_rep[0][i : i + 1]
device_labels.append(color_rep[0] + b"_" + channel)
return device_labels
def _warn_sample_below_threshold(
self,
logfile: Callable,
color_rep: tuple,
sample: CGATS,
device_label_values: bytes,
label: bytes,
) -> None:
"""Log a warning for a sample with a measurement below or equal to zero.
Args:
logfile (callable): A function to log messages to, if None is given
this function does nothing.
color_rep (tuple): The color representation of the sample.
sample (CGATS): The sample that is being removed.
device_label_values (bytes): The device label values of the sample.
label (bytes): The label of the measurement that is below or equal
to zero.
"""
if not logfile:
return
logfile.write(
"Warning: Sample ID {:d} ({} {}) has {} <= 0!\n".format(
int(sample.SAMPLE_ID),
color_rep[0],
" ".join(
device_label_values.decode("utf-8").split()
if device_label_values
else [""]
),
label.decode("utf-8"),
)
)
def _log_fudged_sample(
self,
logfile: Callable,
color_rep: tuple,
sample: CGATS,
device_label_values: bytes,
label: bytes,
) -> None:
"""Log a message for a sample that was fudged to be non-zero.
Args:
logfile (callable): A function to log messages to, if None is given
this function does nothing.
color_rep (tuple): The color representation of the sample.
sample (CGATS): The sample that is being removed.
device_label_values (bytes): The device label values of the sample.
label (bytes): The label of the measurement that was fudged to be
non-zero.
"""
if not logfile:
return
logfile.write(
"Fudged sample ID {:d} ({} {}) {} to be non-zero\n".format(
int(sample.SAMPLE_ID),
color_rep[0],
" ".join(
device_label_values.decode("utf-8").split()
if device_label_values
else [""]
),
label.decode("utf-8"),
)
)
def _warn_zero_measurement(
self,
logfile: Callable,
color_rep: tuple,
sample: CGATS,
device_label_values: bytes,
) -> None:
"""Log a warning for a sample with zero measurements.
Args:
logfile (callable): A function to log messages to, if None is given
this function does nothing.
color_rep (tuple): The color representation of the sample.
sample (CGATS): The sample that is being removed.
device_label_values (bytes): The device label values of the sample.
"""
if not logfile:
return
logfile.write(
"Warning: Sample ID {} ({} {}) has {} = 0!\n".format(
sample.SAMPLE_ID,
color_rep[0],
" ".join(
device_label_values.decode("utf-8").split()
if device_label_values
else [""]
),
color_rep[1],
)
)
def _log_sample_removal(
self,
logfile: Callable,
color_rep: tuple,
sample: CGATS,
device_label_values: bytes,
) -> None:
"""Log the removal of a sample with zero measurements.
Args:
logfile (callable): A function to log messages to, if None is given
this function does nothing.
color_rep (tuple): The color representation of the sample.
sample (CGATS): The sample that is being removed.
device_label_values (bytes): The device label values of the sample.
"""
if not logfile:
return
logfile.write(
"Removed sample ID {:d} ({} {}) with {} = 0\n".format(
int(sample.SAMPLE_ID),
color_rep[0],
" ".join(
device_label_values.decode("utf-8").split()
if device_label_values
else [""]
),
color_rep[1],
)
)
def fix_device_values_scaling(self, color_rep: None | str = None) -> int:
"""Attempt to fix device value scaling so that max = 100.
Args:
color_rep (Nont | str): The color representation to fix. If None,
all device values are fixed. Defaults to None.
Returns:
int: The number of fixed DATA sections.
"""
fixed = 0
for labels in get_device_value_labels(color_rep):
for dataset in self.query(b"DATA").values():
for item in dataset.queryi(labels).values():
for label in labels:
if item[label] > 100:
dataset.scale_device_values(color_rep=color_rep)
fixed += 1
break
return fixed
def normalize_to_y_100(self) -> bool:
"""Scale XYZ values so that RGB 100 = Y 100.
Returns:
bool: True if normalization was applied, False otherwise.
"""
if "DATA" in self:
white_cie = self.get_white_cie()
if white_cie and "XYZ_Y" in white_cie:
white_y = white_cie["XYZ_Y"]
if white_y != 100:
self.add_keyword(
"LUMINANCE_XYZ_CDM2",
"{:.4f} {:.4f} {:.4f}".format(
white_cie["XYZ_X"], white_cie["XYZ_Y"], white_cie["XYZ_Z"]
),
)
for sample in self.DATA.values():
for label in "XYZ":
v = sample["XYZ_" + label]
sample["XYZ_" + label] = v / white_y * 100
self.add_keyword("NORMALIZED_TO_Y_100", "YES")
return True
return False
def quantize_device_values(
self, bits: int = 8, quantizer: Callable = round
) -> None:
"""Quantize device values to n bits.
Args:
bits (int): The number of bits to quantize to. Defaults to 8.
quantizer (callable): A function to use for quantization. Defaults
to round, which is suitable for most cases.
"""
q = 2**bits - 1.0
for data in self.queryv("DATA").values():
if data.parent.type == b"CAL":
maxv = 1.0
digits = 8
else:
maxv = 100.0
# Assuming 0..100, 4 decimal digits is
# enough for roughly 19 bits integer
# device values
digits = 4
color_rep = (data.parent.queryv1("COLOR_REP") or b"").split(b"_")[0]
for labels in get_device_value_labels(color_rep):
for item in data.queryi(labels).values():
for label in labels:
item[label] = round(
quantizer(item[label] / maxv * q) / q * maxv, digits
)
def scale_device_values(
self, factor: float = 100.0 / 255, color_rep: None | str = None
) -> None:
"""Scale device values by multiplying with factor.
Args:
factor (float): The factor to scale the device values by. Defaults
to 100.0 / 255, which is the scaling from 8-bit to 100% device
values.
color_rep (None | str): The color representation to scale. If None, all
device values are scaled. Defaults to None.
"""
for labels in get_device_value_labels(color_rep):
for data in self.queryv("DATA").values():
for item in data.queryi(labels).values():
for label in labels:
item[label] *= factor
def adapt(
self,
whitepoint_source: None | str = None,
whitepoint_destination: None | str = None,
cat: str = "Bradford",
) -> int:
"""Perform chromatic adaptation if possible (needs XYZ or LAB).
Args:
whitepoint_source (None | str): The source whitepoint to adapt
from. Defaults to None, which uses the whitepoint of the first
DATA section.
whitepoint_destination (None | str): The destination whitepoint to
adapt to. Defaults to "D50".
cat (str): The chromatic adaptation transform to use. Defaults to
"Bradford".
Returns:
int: The number of affected DATA sections.
"""
sections = 0
for dataset in self.query("DATA").values():
if not dataset.get_cie_data_format():
continue
if not whitepoint_source:
whitepoint_source = dataset.get_white_cie("XYZ")
if not whitepoint_source:
continue
sections += 1
for item in dataset.queryv1("DATA").values():
if "XYZ_X" in item:
x, y, z = item["XYZ_X"], item["XYZ_Y"], item["XYZ_Z"]
else:
x, y, z = colormath.Lab2XYZ(
item["LAB_L"], item["LAB_A"], item["LAB_B"], scale=100
)
x, y, z = colormath.adapt(
x, y, z, whitepoint_source, whitepoint_destination, cat
)
if "LAB_L" in item:
(
item["LAB_L"],
item["LAB_A"],
item["LAB_B"],
) = colormath.XYZ2Lab(x, y, z)
if "XYZ_X" in item:
item["XYZ_X"], item["XYZ_Y"], item["XYZ_Z"] = x, y, z
return sections
def apply_bpc(
self, bp_out: tuple[float, float, float] = (0, 0, 0), weight: bool = False
) -> int:
"""Apply black point compensation.
Scales XYZ so that black (RGB 0) = zero.
Needs a CGATS structure with RGB and XYZ data and atleast one black and
white patch.
Args:
bp_out (tuple[float, float, float]): The output black point to use.
Defaults to (0, 0, 0).
weight (bool): If True, use the weight method for BPC, otherwise
use the blend method. Defaults to False.
Returns:
int: The number of DATA sections that were affected by the BPC.
"""
n = 0
for dataset in self.query("DATA").values():
is_lab, labels, data, max_v, black, white = (
self._extract_white_black_from_data(dataset)
)
if black is None or white is None:
# Can't apply bpc
continue
# Apply black point compensation
n += 1
for i in data:
values = list(data[i].queryv1(labels).values())
if is_lab:
values = colormath.Lab2XYZ(*values)
else:
values = [v / max_v for v in values]
if weight:
values = colormath.apply_bpc(
values[0], values[1], values[2], black, bp_out, white, weight
)
else:
values = colormath.blend_blackpoint(
values[0], values[1], values[2], black, bp_out, white
)
values = [v * max_v for v in values]
if is_lab:
values = colormath.XYZ2Lab(*values)
for j, label in enumerate(labels):
if is_lab and j > 0:
data[i][label] = values[j]
else:
data[i][label] = max(0.0, values[j])
return n
def _extract_white_black_from_data(
self, dataset: CGATS
) -> tuple[bool, tuple, CGATS, float, list, list]:
"""Extract white and black points from the dataset.
Args:
dataset (CGATS): The dataset to extract white and black points from.
Returns:
tuple[bool, tuple, CGATS, float, list, list]: A tuple containing:
- is_lab (bool): True if the dataset is in Lab color space.
- labels (tuple): The labels for the color channels.
- data (CGATS): The data object containing the color values.
- max_v (float): The maximum value for scaling.
- black (list): The black point values.
- white (list): The white point values.
"""
if dataset.type.strip() == b"CAL":
is_lab = False
labels = ("RGB_R", "RGB_G", "RGB_B")
data = dataset.queryi(labels)
# Get black
black1 = data.queryi1({"RGB_I": 0})
# Get white
white1 = data.queryi1({"RGB_I": 1})
if not black1 or not white1:
# Can't apply bpc
return is_lab, labels, data, None, None, None
black = []
white = []
for label in labels:
black.append(black1[label])
white.append(white1[label])
max_v = 1.0
else:
is_lab = b"_LAB" in (dataset.queryv1("COLOR_REP") or b"")
labels = (
("LAB_L", "LAB_A", "LAB_B") if is_lab else ("XYZ_X", "XYZ_Y", "XYZ_Z")
)
# 0: Index of L* in labels
# 1: Index of Y in labels
index = 0 if is_lab else 1
data = dataset.queryi(("RGB_R", "RGB_G", "RGB_B", *labels))
# Get blacks
blacks = data.queryi({"RGB_R": 0, "RGB_G": 0, "RGB_B": 0})
# Get whites
whites = data.queryi({"RGB_R": 100, "RGB_G": 100, "RGB_B": 100})
if not blacks or not whites:
# Can't apply bpc
return is_lab, labels, data, max_v, None, None
black = [0, 0, 0]
white = [0, 0, 0]
for i in blacks:
if blacks[i][labels[index]] > black[index]:
for j, label in enumerate(labels):
black[j] = blacks[i][label]
for i in whites:
if whites[i][labels[index]] > white[index]:
for j, label in enumerate(labels):
white[j] = whites[i][label]
if is_lab:
max_v = 100.0
black = colormath.Lab2XYZ(*black)
white = colormath.Lab2XYZ(*white)
else:
max_v = white[1]
black = [v / max_v for v in black]
white = [v / max_v for v in white]
return is_lab, labels, data, max_v, black, white
def get_white_cie(
self, colorspace: None | str = None
) -> None | tuple[float, float, float] | dict:
"""Get the 'white' from the CIE values (if any).
Args:
colorspace (str, optional): The colorspace to return the white
point in. If None, returns a dict with XYZ or Lab values.
Returns:
None | tuple[float, float, float] | dict: The white point in the
specified colorspace or a dict with XYZ or Lab values.
"""
if not (data_format := self.get_cie_data_format()):
return None
if "RGB_R" in list(data_format.values()):
white = {"RGB_R": 100, "RGB_G": 100, "RGB_B": 100}
elif "CMYK_C" in list(data_format.values()):
white = {"CMYK_C": 0, "CMYK_M": 0, "CMYK_Y": 0, "CMYK_K": 0}
else:
white = None
if white:
white = self.queryi1(white)
if not white:
white = self._get_white_cie_from_luminance_or_approx_white_point()
if not white:
return None
return self._get_white_cie_from_xyz_or_lab(white, colorspace=colorspace)
def _get_white_cie_from_luminance_or_approx_white_point(self) -> None | dict:
"""Get the white point from LUMINANCE_XYZ_CDM2 or APPROX_WHITE_POINT.
Returns:
None | dict: None if no white point is found, otherwise a dict
with keys "XYZ_X", "XYZ_Y", and "XYZ_Z" representing the white
point in CIE XYZ format.
"""
for key in ("LUMINANCE_XYZ_CDM2", "APPROX_WHITE_POINT"):
if not (white := self.queryv1(key)):
continue
try:
white = [float(v) for v in white.split()]
except ValueError:
white = None
else:
if len(white) == 3:
white = [v / white[1] * 100 for v in white]
white = {
"XYZ_X": white[0],
"XYZ_Y": white[1],
"XYZ_Z": white[2],
}
break
white = None
return white
def _get_white_cie_from_xyz_or_lab(
self, white: dict, colorspace: None | str = None
) -> None | tuple[float, float, float] | dict:
"""Get the white point in the specified colorspace.
Args:
white (dict): The white point in XYZ or Lab format.
colorspace (str, optional): The colorspace to return the white
point in. If None, this function will return the white point as
it is.
Returns:
None | tuple[float, float, float] | dict: The white point in the
specified colorspace or a dict with XYZ or Lab values if the
given colorspace is not "Lab" or "XYZ" or None if the white
point is not given.
"""
if white and (
("XYZ_X" in white and "XYZ_Y" in white and "XYZ_Z" in white)
or ("LAB_L" in white and "LAB_B" in white and "LAB_B" in white)
):
if colorspace == "XYZ":
if "XYZ_X" in white:
return white["XYZ_X"], white["XYZ_Y"], white["XYZ_Z"]
return colormath.Lab2XYZ(
white["LAB_L"], white["LAB_A"], white["LAB_B"], scale=100
)
if colorspace == "Lab":
if "LAB_L" in white:
return white["LAB_L"], white["LAB_A"], white["LAB_B"]
return colormath.XYZ2Lab(white["XYZ_X"], white["XYZ_Y"], white["XYZ_Z"])
return white
return None
def get_cie_data_format(self) -> None | bytes:
"""Check if DATA_FORMAT defines any CIE XYZ or LAB columns.
Returns:
None | bytes: The DATA_FORMAT on success or None on failure.
"""
if data_format := self.queryv1("DATA_FORMAT"):
cie = {}
for channel in (b"LAB_L", b"LAB_A", b"LAB_B"):
cie[channel] = channel in list(data_format.values())
if len(list(cie.values())) in [0, 3]:
for channel in (b"XYZ_X", b"XYZ_Y", b"XYZ_Z"):
cie[channel] = channel in list(data_format.values())
if len([v for v in iter(cie.values()) if v is not False]) in {3, 6}:
return data_format
return None
pop = remove
def write(self, stream_or_filename: None | str | BinaryIO = None) -> None:
"""Write CGATS text to stream.
Args:
stream_or_filename (str | BinaryIO, optional): The stream
or filename to write the CGATS data to. If None, uses the
filename of the CGATS object. Defaults to None.
"""
if not stream_or_filename:
stream_or_filename = self.filename
if isinstance(stream_or_filename, str):
with open(stream_or_filename, "wb") as stream:
stream.write(bytes(self))
else:
stream = stream_or_filename
# This seems like a duplicate, but reduces complexity of the code
stream.write(bytes(self))
displaycal-py3-3.9.19/DisplayCAL/chromecast_pattern_generator.py 000664 000000 000000 00000014435 15225167330 024700 0 ustar 00root root 000000 000000 """Control Chromecast for pattern generation.
It includes classes to send color patterns, manage connections, and interact
with the Chromecast's pattern generator app for use in display calibration
workflows.
"""
# 0install: Make sure imported protobuf is from implementation to ensure
# correct version
from __future__ import annotations
import sys
from time import sleep
from typing import TextIO
if not getattr(sys, "frozen", False):
import os
import re
for pth in sys.path:
if os.path.basename(pth).startswith("protobuf-") and re.match(
r"sha\d+(?:new)?", os.path.basename(os.path.dirname(pth))
):
if "google" in sys.modules:
del sys.modules["google"]
syspath = sys.path[:]
sys.path[:] = [pth]
sys.path[:] = syspath
break
from pychromecast import get_chromecasts
from pychromecast.controllers import BaseController
from DisplayCAL import localization as lang
class ChromeCastPatternGeneratorController(BaseController):
"""Controller for the Chromecast pattern generator app."""
def __init__(self) -> None:
super().__init__("urn:x-cast:net.hoech.cast.patterngenerator", "B5C2CBFC")
self.request_id = 0
def receive_message(self, message: dict, data: dict) -> bool:
"""Handle incoming messages from the Chromecast device.
Args:
message (dict): The message received from the Chromecast.
data (dict): Additional data associated with the message.
Returns:
bool: True if the message was handled, False otherwise.
"""
return True # Indicate we handled this message
def send(
self,
rgb: tuple[float, float, float] = (0, 0, 0),
bgrgb: tuple[float, float, float] = (0, 0, 0),
offset_x: float = 0.5,
offset_y: float = 0.5,
h_scale: float = 1,
v_scale: float = 1,
) -> None:
"""Send a color pattern to the Chromecast device.
Args:
rgb (tuple): RGB color values (0-1 range).
bgrgb (tuple): Background RGB color values (0-1 range).
offset_x (float): Horizontal offset (0-1 range).
offset_y (float): Vertical offset (0-1 range).
h_scale (float): Horizontal scale factor.
v_scale (float): Vertical scale factor.
"""
fg = "#{:02X}{:02X}{:02X}".format(*tuple(round(v * 255) for v in rgb))
bg = "#{:02X}{:02X}{:02X}".format(*tuple(round(v * 255) for v in bgrgb))
self.request_id += 1
self.send_message(
{
"requestId": self.request_id,
"foreground": fg,
"offset": [offset_x, offset_y],
"scale": [h_scale, v_scale],
"background": bg,
}
)
class ChromeCastPatternGenerator:
"""Class to control a Chromecast device for pattern generation.
Args:
name (str): The friendly name of the Chromecast device.
logfile (file-like object, optional): A file-like object to log messages.
"""
def __init__(self, name: str, logfile: None | TextIO = None) -> None:
self._controller = ChromeCastPatternGeneratorController()
self.name = name
self.listening = False
self.logfile = logfile
def disconnect_client(self) -> None:
"""Disconnect the Chromecast client and clean up resources."""
self.listening = False
if hasattr(self, "_cc") and self._cc.app_id:
self._cc.quit_app()
if hasattr(self, "conn"):
del self.conn
def send(
self,
rgb: tuple[float, float, float] = (0, 0, 0),
bgrgb: tuple[float, float, float] = (0, 0, 0),
bits: None | int = None,
use_video_levels: None | bool = None,
x: float = 0,
y: float = 0,
w: float = 1,
h: float = 1,
) -> None:
"""Send a color pattern to the Chromecast device.
Args:
rgb (tuple): RGB color values (0-1 range).
bgrgb (tuple): Background RGB color values (0-1 range).
bits (int, optional): Not used in this implementation.
use_video_levels (bool, optional): Not used in this implementation.
x (float): Horizontal offset (0-1 range).
y (float): Vertical offset (0-1 range).
w (float): Width of the pattern (0-1 range).
h (float): Height of the pattern (0-1 range).
"""
if w < 1:
x /= 1.0 - w
else:
x = 0
if h < 1:
y /= 1.0 - h
else:
y = 0
self._controller.send(rgb, bgrgb, x, y, w * 10, h * 10)
def wait(self) -> None:
"""Wait for Chromecast to be ready and launch the pattern generator app."""
self.listening = True
if self.logfile:
self.logfile.write(
lang.getstr("connecting.to", ("Chromecast", " " + self.name)) + "\n"
)
if not hasattr(self, "_cc"):
# Find our ChromeCast
try:
self._cc = next(
cc
for cc in get_chromecasts()
if str(cc.device.friendly_name) == self.name
)
except StopIteration:
self.listening = False
raise
self._cc.register_handler(self._controller)
# Wait for ChromeCast device to be ready
while self.listening:
self._cc.wait(0.05)
if self._cc.status:
break
if self.listening:
# Launch pattern generator app
self._controller.launch()
# Wait for it
while (
self.listening and self._cc.app_id != self._controller.supporting_app_id
):
sleep(0.05)
self.conn = True
print(lang.getstr("connection.established"))
if __name__ == "__main__":
from DisplayCAL import config
config.initcfg()
lang.init()
pg = ChromeCastPatternGenerator("Smörebröd")
# Find our ChromeCast and connect to it, then launch the pattern generator
# app on the ChromeCast device
pg.wait()
# Display test color (yellow window on blue background)
pg.send((1, 1, 0), (0, 0, 1), x=0.375, y=0.375, w=0.25, h=0.25)
displaycal-py3-3.9.19/DisplayCAL/colord.py 000664 000000 000000 00000067161 15225167330 020233 0 ustar 00root root 000000 000000 """Interface to the colord service for managing color profiles and devices on Linux.
It supports querying, managing, and installing color profiles for display
devices, leveraging both the D-Bus API and the `colormgr` command-line utility.
"""
from __future__ import annotations
import contextlib
import os
import subprocess as sp
import sys
import warnings
from binascii import hexlify
from time import sleep
from typing import Callable
from DisplayCAL.options import USE_COLORD_GI
try:
# XXX D-Bus API is more complete currently
if not USE_COLORD_GI:
raise ImportError("")
from gi.repository import Colord, Gio
except ImportError:
Colord = None
Gio = None
else:
cancellable = Gio.Cancellable.new()
from DisplayCAL import localization as lang
from DisplayCAL.util_dbus import BUSTYPE_SYSTEM, DBusException, DBusObject
from DisplayCAL.util_os import which
from DisplayCAL.util_str import safe_str
if sys.platform not in ("darwin", "win32"):
from DisplayCAL.defaultpaths import XDG_DATA_HOME
if not Colord:
try:
Colord = DBusObject(
BUSTYPE_SYSTEM,
"org.freedesktop.ColorManager",
"/org/freedesktop/ColorManager",
)
except DBusException as exception:
warnings.warn(safe_str(exception), Warning, stacklevel=2)
# See colord/cd-client.c
CD_CLIENT_IMPORT_DAEMON_TIMEOUT = 5000 # ms
if (
not Colord
or isinstance(Colord, DBusObject)
or not hasattr(Colord, "quirk_vendor_name")
):
# from DisplayCAL.config import get_data_path
# From colord/lib/colord/cd_quirk.c, cd_quirk_vendor_name
quirk_cache = {
"suffixes": [
"Co.",
"Co",
"Inc.",
"Inc",
"Ltd.",
"Ltd",
"Corporation",
"Incorporated",
"Limited",
"GmbH",
"corp.",
],
"vendor_names": {
"Acer, inc.": "Acer",
"Acer Technologies": "Acer",
"AOC Intl": "AOC",
"Apple Computer Inc": "Apple",
"Arnos Insturments & Computer Systems": "Arnos",
"ASUSTeK Computer Inc.": "ASUSTeK",
"ASUSTeK Computer INC": "ASUSTeK",
"ASUSTeK COMPUTER INC.": "ASUSTeK",
"BTC Korea Co., Ltd": "BTC",
"CASIO COMPUTER CO.,LTD": "Casio",
"CLEVO": "Clevo",
"Delta Electronics": "Delta",
"Eizo Nanao Corporation": "Eizo",
"Envision Peripherals,": "Envision",
"FUJITSU": "Fujitsu",
"Fujitsu Siemens Computers GmbH": "Fujitsu Siemens",
"Funai Electric Co., Ltd.": "Funai",
"Gigabyte Technology Co., Ltd.": "Gigabyte",
"Goldstar Company Ltd": "LG",
"LG Electronics": "LG",
"GOOGLE": "Google",
"Hewlett-Packard": "Hewlett Packard",
"Hitachi America Ltd": "Hitachi",
"HP": "Hewlett Packard",
"HWP": "Hewlett Packard",
"IBM France": "IBM",
"Lenovo Group Limited": "Lenovo",
"LENOVO": "Lenovo",
"Iiyama North America": "Iiyama",
"MARANTZ JAPAN, INC.": "Marantz",
"Mitsubishi Electric Corporation": "Mitsubishi",
"Nexgen Mediatech Inc.,": "Nexgen Mediatech",
"NIKON": "Nikon",
"Panasonic Industry Company": "Panasonic",
"Philips Consumer Electronics Company": "Philips",
"RGB Systems, Inc. dba Extron Electronics": "Extron",
"SAM": "Samsung",
"Samsung Electric Company": "Samsung",
"Samsung Electronics America": "Samsung",
"samsung": "Samsung",
"SAMSUNG": "Samsung",
"Sanyo Electric Co.,Ltd.": "Sanyo",
"Sonix Technology Co.": "Sonix",
"System manufacturer": "Unknown",
"To Be Filled By O.E.M.": "Unknown",
"Toshiba America Info Systems Inc": "Toshiba",
"Toshiba Matsushita Display Technology Co.,": "Toshiba",
"TOSHIBA": "Toshiba",
"Unknown vendor": "Unknown",
"Westinghouse Digital Electronics": "Westinghouse Digital",
"Zalman Tech Co., Ltd.": "Zalman",
},
}
prefix = "/org/freedesktop/ColorManager/"
device_ids = {}
def client_connect() -> Colord.Client:
"""Connect to colord.
Raises:
CDError: If there is an error connecting to colord.
Returns:
Colord.Client: Colord client instance.
"""
client = Colord.Client.new()
# Connect to colord
if not client.connect_sync(cancellable):
raise CDError("Couldn't connect to colord")
return client
def device_connect(client: Colord.Client, device_id: bytes | str) -> Device:
"""Connect to device.
Args:
client (Colord.Client): Colord client instance.
device_id (bytes | str): Device ID to connect to.
Raises:
CDError: If there is an error connecting to the device or if the device
could not be found.
Returns:
Device: Connected device object.
"""
if isinstance(device_id, str):
device_id = device_id.encode("UTF-8")
try:
device = client.find_device_sync(device_id, cancellable)
except Exception as exception:
raise CDError(exception.args[0]) from exception
# Connect to device
if not device.connect_sync(cancellable):
raise CDError(f"Couldn't connect to device with ID {device_id!r}")
return device
def device_id_from_edid(
edid: dict,
quirk: bool = False,
use_serial_32: bool = True,
truncate_edid_strings: bool = False,
omit_manufacturer: bool = False,
query: bool = False,
) -> None | str:
"""Assemble device key from EDID.
Args:
edid (dict): EDID data containing keys like 'manufacturer',
'monitor_name', 'serial_ascii', and optionally 'hash'.
quirk (bool): Whether to apply manufacturer name quirks.
use_serial_32 (bool): Whether to include the 32-bit serial number.
truncate_edid_strings (bool): Whether to truncate EDID strings to 12 characters.
omit_manufacturer (bool): Whether to omit the manufacturer from the device ID.
query (bool): Whether to query colord for the device ID.
Returns:
None | str: Assembled device ID string or None if no valid ID could be
constructed.
"""
# https://github.com/hughsie/colord/blob/master/doc/device-and-profile-naming-spec.txt
# Should match device ID returned by gcm_session_get_output_id in
# gnome-settings-daemon/plugins/color/gsd-color-state.c
# and Edid::deviceId in colord-kde/colord-kded/Edid.cpp respectively
if device_id := device_id_from_edid_hash(edid=edid, query=query):
return device_id
return generate_device_id(
edid, quirk, use_serial_32, truncate_edid_strings, omit_manufacturer
)
def generate_device_id(
edid: dict,
quirk: bool = False,
use_serial_32: bool = True,
truncate_edid_strings: bool = False,
omit_manufacturer: bool = False,
) -> None | str:
"""Generate a device ID from EDID data.
Args:
edid (dict): EDID data containing keys like 'manufacturer',
'monitor_name', 'serial_ascii', and optionally 'hash'.
quirk (bool): Whether to apply manufacturer name quirks.
use_serial_32 (bool): Whether to include the 32-bit serial number.
truncate_edid_strings (bool): Whether to truncate EDID strings to 12 characters.
omit_manufacturer (bool): Whether to omit the manufacturer from the device ID.
Returns:
str: A string representing the device ID based on the EDID data.
"""
parts = ["xrandr"]
edid_keys = ["monitor_name", "serial_ascii"]
if not omit_manufacturer:
edid_keys.insert(0, "manufacturer")
if use_serial_32:
edid_keys.append("serial_32")
for name in edid_keys:
if not (value := edid.get(name)):
continue
if name == "serial_32" and "serial_ascii" in edid:
# Only add numeric serial if no ascii serial
continue
if name == "manufacturer":
value = quirk_manufacturer(value) if quirk else value
elif isinstance(value, str) and truncate_edid_strings:
# Older versions of colord used only the first 12 bytes
value = value[:12]
parts.append(str(value))
return "-".join(parts) if len(parts) > 1 else None
def device_id_from_edid_hash(edid: dict, query: bool = False) -> None | str:
"""Generate a device ID from EDID hash.
Args:
edid (dict): EDID data containing 'hash' key.
query (bool): Whether to query colord for the device ID.
Returns:
None | str: A string representing the device ID based on the EDID hash.
"""
if "hash" not in edid:
return None
# Placeholder implementation, replace with actual logic as needed
if device_id := device_ids.get(edid["hash"]):
return device_id
if (
sys.platform not in ("darwin", "win32")
and query
and isinstance(Colord, DBusObject)
):
try:
device = Device(find("device-by-property", ["OutputEdidMd5", edid["hash"]]))
device_id = device.properties.get("DeviceId")
except CDError as exception:
warnings.warn(safe_str(exception), Warning, stacklevel=2)
else:
if device_id:
device_ids[edid["hash"]] = device_id
return device_id
return None
def find(what: str, search: str | list) -> str:
"""Find device or profile and return object path.
Args:
what (str): Type of object to search for, e.g., "profile-by-id" or
"device-by-property".
search (list or str): Search criteria, e.g., profile ID or device ID.
Raises:
CDError: If colord API is not available or if there is an error
querying the object.
CDObjectNotFoundError: If the object could not be found.
CDObjectQueryError: If there is an error querying the object.
Returns:
str: Object path of the found object.
"""
if not isinstance(Colord, DBusObject):
raise CDError("colord API not available")
if not isinstance(search, list):
search = [search]
method_name = "_".join(part for part in what.split("-"))
try:
return getattr(Colord, "find_" + method_name)(*search)
except Exception as exception:
if hasattr(exception, "get_dbus_name"):
if exception.get_dbus_name() == "org.freedesktop.ColorManager.NotFound":
raise CDObjectNotFoundError(safe_str(exception)) from exception
raise CDObjectQueryError(safe_str(exception)) from exception
raise CDError(safe_str(exception)) from exception
def get_default_profile(device_id: str) -> str:
"""Get default profile for device.
Args:
device_id (str): Device ID to search for.
Returns:
str: Default profile ID for the device.
"""
# Find device object path
device = Device(get_object_path(device_id, "device"))
# Get default profile
try:
properties = device.properties
except Exception as exception:
raise CDError(safe_str(exception)) from exception
else:
if properties.get("ProfilingInhibitors"):
return None
profiles = properties.get("Profiles")
if profiles:
return profiles[0]
raise CDError(f"Couldn't get default profile for device ID {device_id!r}")
def get_devices_by_kind(kind: str) -> list:
"""Get devices by kind.
Args:
kind (str): Kind of device to search for.
Returns:
list: List of devices of the specified kind.
"""
if not isinstance(Colord, DBusObject):
return []
return [
Device(str(object_path)) for object_path in Colord.get_devices_by_kind(kind)
]
def get_display_devices() -> list:
"""Get display devices.
Returns:
list: List of display devices.
"""
return get_devices_by_kind("display")
def get_display_device_ids() -> list:
"""Get display device IDs.
Returns:
list: List of display device IDs.
"""
return [
_f
for _f in (
display.properties.get("DeviceId") for display in get_display_devices()
)
if _f
]
def get_object_path(search: str, object_type: str) -> str:
"""Get object path for profile or device ID.
Args:
search (str): Profile or device ID to search for.
object_type (str): Type of object to search for, e.g., "profile" or
"device".
Raises:
CDObjectNotFoundError: If the object path could not be found.
Returns:
str: Object path for the specified profile or device ID.
"""
result = find(f"{object_type}-by-id", search)
if not result:
raise CDObjectNotFoundError(f"Could not find object path for {search}")
return result
def install_profile(
device_id: str,
profile: Profile,
timeout: float = CD_CLIENT_IMPORT_DAEMON_TIMEOUT / 1000.0,
logfn: None | Callable = None,
) -> None:
"""Install profile for device.
Args:
device_id (str): Device ID to install the profile for.
profile (Profile): Profile object to install.
timeout (float): Time to allow for colord to pick up new profiles (recommended
not below 2 secs).
logfn (callable, optional): Function to log messages. Defaults to None.
"""
if Colord and not isinstance(Colord, DBusObject):
install_profile_with_colord(device_id, profile, timeout=timeout, logfn=logfn)
else:
install_profile_with_dbus(device_id, profile, timeout=timeout, logfn=logfn)
def get_profile_install_parameters(
profile: Profile, logfn: None | Callable = None
) -> tuple[str, bool, str]:
"""Get parameters for profile installation.
Args:
profile (Profile): Profile object to install.
logfn (callable, optional): Function to log messages. Defaults to None.
Returns:
tuple: A tuple containing the profile installation name, whether the
profile already exists, and the profile ID.
"""
profile_install_name = os.path.join(
XDG_DATA_HOME, "icc", os.path.basename(profile.filename)
)
profile_exists = os.path.isfile(profile_install_name)
if profile.filename != profile_install_name and profile_exists:
if logfn:
logfn("About to overwrite existing", profile_install_name)
profile.filename = None
if profile.ID == "\0" * 16:
profile.calculate_id()
profile.filename = None
profile_id = "icc-" + hexlify(profile.ID).decode()
return profile_install_name, profile_exists, profile_id
def write_profile_to_destination(
profile: Profile,
profile_install_name: str,
profile_exists: bool,
logfn: None | Callable = None,
) -> None:
"""Write profile to destination.
Args:
profile (Profile): Profile object to write.
profile_install_name (str): Path where the profile should be installed.
profile_exists (bool): Whether the profile already exists at the
destination.
logfn (callable, optional): Function to log messages. Defaults to None.
"""
profile_install_dir = os.path.dirname(profile_install_name)
if not os.path.isdir(profile_install_dir):
os.makedirs(profile_install_dir)
# colormgr seems to have a bug where the first attempt at importing a
# specific profile can time out. This seems to be work-aroundable by
# writing the profile ourself first, and then importing.
if not profile.filename or not profile_exists:
if logfn:
logfn("Writing", profile_install_name)
profile.filename = profile_install_name
profile.write()
def install_profile_with_colord(
device_id: str,
profile: Profile,
timeout: float = CD_CLIENT_IMPORT_DAEMON_TIMEOUT / 1000.0,
logfn: None | Callable = None,
) -> None:
"""Install profile for device.
Args:
device_id (str): Device ID to install the profile for.
profile (Profile): Profile object to install.
timeout (float): Time to allow for colord to pick up new profiles (recommended
not below 2 secs).
logfn (callable, optional): Function to log messages. Defaults to None.
Raises:
CDError: If there is an error connecting to colord or if the profile
could not be made default for the device.
CDTimeoutError: If querying for the profile takes too long.
"""
profile_install_name, profile_exists, profile_id = get_profile_install_parameters(
profile, logfn
)
write_profile_to_destination(profile, profile_install_name, profile_exists, logfn)
client = client_connect()
cdprofile = query_colord_for_newly_added_profile(profile_id, timeout=timeout)
# Connect to profile
if not cdprofile.connect_sync(cancellable):
raise CDError("Could not connect to profile")
# Connect to existing device
device = device_connect(client, device_id)
# Add profile to device
try:
device.add_profile_sync(Colord.DeviceRelation.HARD, cdprofile, cancellable)
except Exception as exception:
# Profile may already have been added
warnings.warn(safe_str(exception), Warning, stacklevel=2)
# Make profile default for device
if not device.make_profile_default_sync(cdprofile, cancellable):
raise CDError(
f"Could not make profile {profile_id} default for device {device_id}"
)
def install_profile_with_dbus(
device_id: str,
profile: Profile,
timeout: float = CD_CLIENT_IMPORT_DAEMON_TIMEOUT / 1000.0,
logfn: None | Callable = None,
) -> None:
"""Install profile for device with DBusObject.
Args:
device_id (str): Device ID to install the profile for.
profile (Profile): Profile object to install.
timeout (float): Time to allow for colord to pick up new profiles (recommended
not below 2 secs).
logfn (callable, optional): Function to log messages. Defaults to None.
"""
if not logfn:
# let's reduce complexity a bit
def logfn(*args, **kwargs) -> None:
"""Dummy log function that does nothing."""
profile_install_name, profile_exists, profile_id = get_profile_install_parameters(
profile, logfn
)
write_profile_to_destination(profile, profile_install_name, profile_exists, logfn)
cdprofile = None
# Query colord for profile
with contextlib.suppress(CDObjectQueryError):
cdprofile = get_object_path(profile_id, "profile")
# If profile not found, it will raise a CDObjectQueryError
if not (colormgr := which("colormgr")):
raise CDError("'colormgr' helper program not found!")
cmd = str(colormgr)
if not cdprofile:
cdprofile = import_profile(
cmd, profile, profile_install_name, profile_id, timeout=timeout, logfn=logfn
)
# Find device object path
device = get_object_path(device_id, "device")
add_profile_to_device(cmd, device, cdprofile, logfn)
make_profile_default_for_device(
cmd, profile_id, device_id, device, cdprofile, logfn=logfn
)
def import_profile(
cmd: str,
profile: Profile,
profile_install_name: str,
profile_id: str,
timeout: float = CD_CLIENT_IMPORT_DAEMON_TIMEOUT / 1000.0,
logfn: None | Callable = None,
) -> None | str:
"""Import profile using colormgr.
Args:
cmd (str): Command to run, e.g., "colormgr".
profile (Profile): Profile object to import.
profile_install_name (str): Path where the profile should be installed.
profile_id (str): ID of the profile.
timeout (float): Time to allow for colord to pick up new profiles
(recommended not below 2 secs).
logfn (callable, optional): Function to log messages. Defaults to None.
Raises:
CDError: If there is an error running the command or if the command
fails.
CDTimeoutError: If querying for the profile takes too long.
Returns:
None | str: Object path of the imported profile.
"""
# Import profile
if not logfn:
# let's reduce complexity a bit
def logfn(*args, **kwargs) -> None:
"""Dummy log function that does nothing."""
logfn("-" * 80)
logfn(lang.getstr("commandline"))
args = [cmd, "import-profile", safe_str(profile.filename)]
from DisplayCAL.worker import printcmdline
printcmdline(args[0], args[1:], fn=logfn)
logfn("")
maxtries = 3
for n in range(1, maxtries + 1):
logfn(f"Trying to import profile, attempt {n}...")
try:
process = sp.Popen(args, stdout=sp.PIPE, stderr=sp.STDOUT)
stdout, _ = process.communicate()
except Exception as exception:
raise CDError(safe_str(exception)) from exception
if stdout.strip():
logfn(stdout.strip())
if process.returncode == 0 or os.path.isfile(profile_install_name):
logfn("...ok")
break
logfn("...failed!")
if process.returncode != 0 and not os.path.isfile(profile_install_name):
raise CDTimeoutError(
f"Trying to import profile '{profile.filename}' failed after {n} tries."
)
return query_colord_for_newly_added_profile(profile_id, timeout=timeout)
def query_colord_for_newly_added_profile(
profile_id: str, timeout: float = CD_CLIENT_IMPORT_DAEMON_TIMEOUT / 1000.0
) -> str:
"""Query colord for newly added profile.
Args:
profile_id (str): ID of the profile to query for.
timeout (float): Time to allow for colord to pick up new profiles
(recommended not below 2 secs).
Raises:
CDTimeoutError: If querying for the profile takes too long.
Returns:
str: Object path of the queried profile.
"""
cdprofile = None
for _ in range(int(timeout / 1.0)):
# Profile might not be found so suppress the error
with contextlib.suppress(CDObjectQueryError):
cdprofile = get_object_path(profile_id, "profile")
if cdprofile:
break
# Give colord time to pick up the profile
sleep(1)
if not cdprofile:
raise CDTimeoutError(
f"Querying for profile {profile_id!r} returned no result for {timeout} secs"
)
return cdprofile
def add_profile_to_device(
cmd: str, device: str, cdprofile: str, logfn: None | Callable = None
) -> None:
"""Add profile to device.
Ignore returncode as profile may already have been added.
Args:
cmd (str): Command to run, e.g., "colormgr".
device (str): Device object path.
cdprofile (str): Profile object path.
logfn (callable, optional): Function to log messages. Defaults to None.
Raises:
CDError: If there is an error running the command or if the command
fails.
"""
from DisplayCAL.worker import printcmdline
logfn("-" * 80)
logfn(lang.getstr("commandline"))
args = [cmd, "device-add-profile", device, cdprofile]
printcmdline(args[0], args[1:], fn=logfn)
logfn("")
try:
p = sp.Popen(args, stdout=sp.PIPE, stderr=sp.STDOUT)
stdout, _ = p.communicate()
except Exception as exception:
raise CDError(safe_str(exception)) from exception
if stdout.strip():
logfn(stdout.strip())
def make_profile_default_for_device(
cmd: str,
profile_id: str,
device_id: str,
device: str,
cdprofile: str,
logfn: None | Callable = None,
) -> None:
"""Make profile default for device.
Args:
cmd (str): Command to run, e.g., "colormgr".
profile_id (str): ID of the profile to make default.
device_id (str): ID of the device to make the profile default for.
device (str): Device object path.
cdprofile (str): Profile object path.
logfn (callable, optional): Function to log messages. Defaults to None.
Raises:
CDError: If there is an error running the command or if the command
fails.
"""
from DisplayCAL.worker import printcmdline
logfn("")
logfn(lang.getstr("commandline"))
# Make profile default for device
args = [cmd, "device-make-profile-default", device, cdprofile]
printcmdline(args[0], args[1:], fn=logfn)
logfn("")
try:
p = sp.Popen(args, stdout=sp.PIPE, stderr=sp.STDOUT)
stdout, stderr = p.communicate()
except Exception as exception:
raise CDError(safe_str(exception)) from exception
else:
if p.returncode != 0:
raise CDError(
stdout.strip()
or f"Could not make profile {profile_id} default for device {device_id}"
)
if stdout.strip():
logfn(stdout.strip())
def quirk_manufacturer(manufacturer: str) -> str:
"""Correct manufacturer name for colord.
Args:
manufacturer (str): Manufacturer name to correct.
Returns:
str: Corrected manufacturer name.
"""
if (
Colord
and not isinstance(Colord, DBusObject)
and hasattr(Colord, "quirk_vendor_name")
):
return Colord.quirk_vendor_name(manufacturer)
# Correct some company names
for old, new in quirk_cache["vendor_names"].items():
if manufacturer.startswith(old):
manufacturer = new
break
# Get rid of suffixes
for suffix in quirk_cache["suffixes"]:
if manufacturer.endswith(suffix):
manufacturer = manufacturer[0 : len(manufacturer) - len(suffix)]
return manufacturer.rstrip()
class Object(DBusObject):
"""Base class for colord objects.
Args:
object_path (str): D-Bus object path of the colord object.
object_type (str): Type of the colord object, e.g., "Device" or
"Profile".
"""
def __init__(self, object_path: str, object_type: str) -> None:
try:
super().__init__(
BUSTYPE_SYSTEM,
"org.freedesktop.ColorManager",
object_path,
object_type,
)
except DBusException as exception:
raise CDError(safe_str(exception)) from exception
self._object_type = object_type
_properties = DBusObject.properties
@property
def properties(self) -> dict:
"""Get properties of the object.
Raises:
CDError: If there is an error retrieving the properties.
Returns:
dict: Dictionary of properties of the object.
"""
try:
properties = {}
for key in self._properties:
value = self._properties[key]
if key == "Profiles":
value = [Profile(object_path) for object_path in value]
properties[key] = value
return properties
except DBusException as exception:
raise CDError(safe_str(exception)) from exception
class Device(Object):
"""Device object.
Args:
object_path (str): D-Bus object path of the colord device.
"""
def __init__(self, object_path: str) -> None:
super().__init__(object_path, "Device")
class Profile(Object):
"""Profile object.
Args:
object_path (str): D-Bus object path of the colord profile.
"""
def __init__(self, object_path: str) -> None:
super().__init__(object_path, "Profile")
class CDError(Exception):
"""Base class for colord errors."""
class CDObjectQueryError(CDError):
"""Object query error."""
class CDObjectNotFoundError(CDObjectQueryError):
"""Object not found error."""
class CDTimeoutError(CDError):
"""Timeout error."""
if __name__ == "__main__":
import sys
for arg in sys.argv[1:]:
print(get_default_profile(arg))
displaycal-py3-3.9.19/DisplayCAL/colormath.py 000664 000000 000000 00000666722 15225167330 020751 0 ustar 00root root 000000 000000 """Diverse color mathematical functions.
Note:
In most cases, unless otherwise stated RGB is R'G'B' (gamma-compressed)
"""
from __future__ import annotations
import colorsys
import logging
import math
import sys
import warnings
from typing import TYPE_CHECKING, Any, Callable, overload
import numpy
from DisplayCAL.debughelpers import DEBUG
if TYPE_CHECKING:
if sys.version_info >= (3, 11):
from typing import Self
else:
from typing_extensions import Self
logger = logging.getLogger(__name__)
if DEBUG:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
def cache(f: Callable) -> Callable[..., Any]:
"""Decorator to convert list arguments to tuples and cache.
Args:
f (Callable): The function to wrap.
"""
def wrapper(*args, **kwargs) -> Any: # noqa: ANN401
cache_hash = (
((tuple(arg) if isinstance(arg, (list, tuple)) else arg for arg in args)),
(
(key, tuple(kwargs[key]))
if isinstance(kwargs[key], (list, tuple))
else kwargs[key]
for key in kwargs
),
)
if not hasattr(f, "cache"):
f.cache = {}
if cache_hash in f.cache:
return f.cache[cache_hash]
result = f(*args, **kwargs)
f.cache[cache_hash] = result
return result
return wrapper
def get_transfer_function_phi(alpha: float, gamma: float) -> float:
"""Get transfer function phi.
Args:
alpha (float): Alpha value.
gamma (float): Gamma value.
Returns:
float: Transfer function phi value.
"""
return (math.pow(1 + alpha, gamma) * math.pow(gamma - 1, gamma - 1)) / (
math.pow(alpha, gamma - 1) * math.pow(gamma, gamma)
)
LSTAR_E = 216.0 / 24389.0 # Intent of CIE standard, actual CIE standard = 0.008856
LSTAR_K = 24389.0 / 27.0 # Intent of CIE standard, actual CIE standard = 903.3
REC709_K0 = 0.081 # 0.099 / (1.0 / 0.45 - 1)
REC709_P = 4.5 # get_transfer_function_phi(0.099, 1.0 / 0.45)
SMPTE240M_K0 = 0.0913 # 0.1115 / (1.0 / 0.45 - 1)
SMPTE240M_P = 4.0 # get_transfer_function_phi(0.1115, 1.0 / 0.45)
SMPTE2084_M1 = (2610.0 / 4096) * 0.25
SMPTE2084_M2 = (2523.0 / 4096) * 128
SMPTE2084_C1 = 3424.0 / 4096
SMPTE2084_C2 = (2413.0 / 4096) * 32
SMPTE2084_C3 = (2392.0 / 4096) * 32
SRGB_K0 = 0.04045 # 0.055 / (2.4 - 1)
SRGB_P = 12.92 # get_transfer_function_phi(0.055, 2.4)
def special_pow(a: float, b: float, slope_limit: float = 0) -> float:
"""Wrapper for power, Rec. 601/709, SMPTE 240M, sRGB and L* functions.
Positive b = power, -2.4 = sRGB, -3.0 = L*, -240 = SMPTE 240M,
-601 = Rec. 601, -709 = Rec. 709 (Rec. 601 and 709 transfer functions are
identical)
Args:
a (float): Input value.
b (float): Exponent, transfer function or gamma.
slope_limit (float, optional): Slope limit for power curve, defaults to
0.
Returns:
float: Output value.
"""
if b >= 0.0:
# Power curve
if a < 0.0:
if slope_limit:
return min(-math.pow(-a, b), a / slope_limit)
return -math.pow(-a, b)
if slope_limit:
return max(math.pow(a, b), a / slope_limit)
return math.pow(a, b)
sign_scale = -1.0 if a < 0.0 else 1.0
a = abs(a)
v = {
1.0 / -601:
# XYZ -> RGB, Rec. 601/709 TRC
(a * REC709_P)
if (a < REC709_K0 / REC709_P)
else (1.099 * math.pow(a, 0.45) - 0.099),
1.0 / -709:
# XYZ -> RGB, Rec. 601/709 TRC
(a * REC709_P)
if (a < REC709_K0 / REC709_P)
else (1.099 * math.pow(a, 0.45) - 0.099),
1.0 / -240:
# XYZ -> RGB, SMPTE 240M TRC
(a * SMPTE240M_P)
if (a < SMPTE240M_K0 / SMPTE240M_P)
else (1.1115 * math.pow(a, 0.45) - 0.1115),
1.0 / -3.0:
# XYZ -> RGB, L* TRC
0.01 * a * LSTAR_K if a <= LSTAR_E else 1.16 * math.pow(a, 1.0 / 3.0) - 0.16,
1.0 / -2.4:
# XYZ -> RGB, sRGB TRC
(a * SRGB_P)
if (a <= SRGB_K0 / SRGB_P)
else (1.055 * math.pow(a, 1.0 / 2.4) - 0.055),
1.0 / -2084:
# XYZ -> RGB, SMPTE 2084 (PQ)
((2413.0 * (a**SMPTE2084_M1) + 107) / (2392.0 * (a**SMPTE2084_M1) + 128))
** SMPTE2084_M2,
-2.4:
# RGB -> XYZ, sRGB TRC
a / SRGB_P if a <= SRGB_K0 else math.pow((a + 0.055) / 1.055, 2.4),
-3.0:
# RGB -> XYZ, L* TRC
# E * K * 0.01
100.0 * a / LSTAR_K if a <= 0.08 else math.pow((a + 0.16) / 1.16, 3.0),
-240:
# RGB -> XYZ, SMPTE 240M TRC
(
a / SMPTE240M_P
if a < SMPTE240M_K0
else math.pow((0.1115 + a) / 1.1115, 1.0 / 0.45)
),
-601:
# RGB -> XYZ, Rec. 601/709 TRC
a / REC709_P if a < REC709_K0 else math.pow((a + 0.099) / 1.099, 1.0 / 0.45),
-709:
# RGB -> XYZ, Rec. 601/709 TRC
a / REC709_P if a < REC709_K0 else math.pow((a + 0.099) / 1.099, 1.0 / 0.45),
-2084:
# RGB -> XYZ, SMPTE 2084 (PQ)
# See https://www.smpte.org/sites/default/files/2014-05-06-EOTF-Miller-1-2-handout.pdf
(
max(a ** (1.0 / SMPTE2084_M2) - SMPTE2084_C1, 0)
/ (SMPTE2084_C2 - SMPTE2084_C3 * a ** (1.0 / SMPTE2084_M2))
)
** (1.0 / SMPTE2084_M1),
}.get(b)
if v is None:
raise ValueError(f"Invalid gamma {b!r}")
return v * sign_scale
def DICOM(j: float, inverse: bool = False) -> float: # noqa: N802
"""DICOM TRC.
Args:
j (float): Input value.
inverse (bool): If True, apply inverse DICOM TRC.
Returns:
float: Output value.
"""
if inverse:
log10y = math.log10(j)
a = 71.498068
b = 94.593053
c = 41.912053
d = 9.8247004
e = 0.28175407
f = -1.1878455
g = -0.18014349
h = 0.14710899
i = -0.017046845
return (
a
+ b * log10y
+ c * math.pow(log10y, 2)
+ d * math.pow(log10y, 3)
+ e * math.pow(log10y, 4)
+ f * math.pow(log10y, 5)
+ g * math.pow(log10y, 6)
+ h * math.pow(log10y, 7)
+ i * math.pow(log10y, 8)
)
logj = math.log(j)
a = -1.3011877
b = -2.5840191e-2
c = 8.0242636e-2
d = -1.0320229e-1
e = 1.3646699e-1
f = 2.8745620e-2
g = -2.5468404e-2
h = -3.1978977e-3
k = 1.2992634e-4
m = 1.3635334e-3
return (
a
+ c * logj
+ e * math.pow(logj, 2)
+ g * math.pow(logj, 3)
+ m * math.pow(logj, 4)
) / (
1
+ b * logj
+ d * math.pow(logj, 2)
+ f * math.pow(logj, 3)
+ h * math.pow(logj, 4)
+ k * math.pow(logj, 5)
)
class HLG:
"""Hybrid Log Gamma (HLG) as defined in Rec BT.2100 and BT.2390-4.
Args:
black_cdm2 (float): Black level in cd/m², defaults to 0.0.
white_cdm2 (float): White level in cd/m², defaults to 1000.0.
system_gamma (float): System gamma for nominal peak luminance and
ambient, defaults to 1.2.
ambient_cdm2 (float): Ambient luminance in cd/m², defaults to 5.
rgb_space (str): RGB color space, defaults to "Rec. 2020".
"""
def __init__(
self,
black_cdm2: float = 0.0,
white_cdm2: float = 1000.0,
system_gamma: float = 1.2,
ambient_cdm2: float = 5,
rgb_space: str = "Rec. 2020",
) -> None:
self.black_cdm2 = black_cdm2
self.white_cdm2 = white_cdm2
self.rgb_space = get_rgb_space(rgb_space)
self.system_gamma = system_gamma
self.ambient_cdm2 = ambient_cdm2
@property
def gamma(self) -> float:
"""System gamma for nominal peak luminance and ambient.
Returns:
float: Adjusted system gamma based on peak luminance and ambient
luminance.
"""
# Adjust system gamma for peak luminance != 1000 cd/m2 (extended model
# described in BT.2390-4)
k = 1.111
gamma = self.system_gamma * k ** math.log(self.white_cdm2 / 1000.0, 2)
if self.ambient_cdm2 > 0:
# Adjust system gamma for ambient surround != 5 cd/m2 (BT.2390-4)
u = 0.98
gamma *= u ** math.log(self.ambient_cdm2 / 5.0, 2)
return gamma
def oetf(self, v: float, inverse: bool = False) -> float:
"""Hybrid Log Gamma (HLG) OETF.
Relative scene linear light to non-linear HLG signal, or inverse
Input domain 0..1
Output range 0..1
Args:
v (float): Relative scene linear light or non-linear HLG signal.
inverse (bool): If True, apply inverse OETF.
Returns:
float: Non-linear HLG signal if inverse is False, or relative scene
linear light if inverse is True.
"""
if v == 1:
return 1.0
a = 0.17883277
b = 1 - 4 * a
c = 0.5 - a * math.log(4 * a)
if inverse:
# Non-linear HLG signal to relative scene linear light
if 0 <= v <= 1 / 2.0:
v = v**2 / 3.0
else:
v = (math.exp((v - c) / a) + b) / 12.0
else:
# Relative scene linear light to non-linear HLG signal
v = math.sqrt(3 * v) if 0 <= v <= 1 / 12.0 else a * math.log(12 * v - b) + c
return v
@overload
def eotf(
self,
RGB: float, # noqa: N803
inverse: bool = False,
apply_black_offset: bool = True,
) -> float: ...
@overload
def eotf(
self,
RGB: tuple[float, float, float], # noqa: N803
inverse: bool = False,
apply_black_offset: bool = True,
) -> tuple[float, float, float]: ...
def eotf(
self,
RGB: float | tuple[float, float, float], # noqa: N803
inverse: bool = False,
apply_black_offset: bool = True,
) -> float | tuple[float, float, float]:
"""Hybrid Log Gamma (HLG) EOTF.
Non-linear HLG signal to display light, or inverse
Input domain 0..1
Output range 0..1
Args:
RGB (float | tuple[float, float, float]): R, G, B components of the
non-linear HLG signal or display light.
inverse (bool): If True, apply inverse EOTF.
apply_black_offset (bool): Whether to apply black offset, defaults
to True.
Returns:
float | tuple[float, float, float]: G component of the display
light if RGB is a float, or R, G, B components of the display
light if RGB is a tuple.
"""
if isinstance(RGB, (float, int)):
r, g, b = (RGB,) * 3
else:
r, g, b = RGB
if inverse:
# Display light -> relative scene linear light -> HLG signal
r, g, b = (
self.oetf(v) for v in self.ootf((r, g, b), True, apply_black_offset)
)
else:
# HLG signal -> relative scene linear light -> display light
r, g, b = self.ootf(
[self.oetf(v, True) for v in (r, g, b)], False, apply_black_offset
)
return g if isinstance(RGB, (float, int)) else (r, g, b)
@overload
def ootf(
self,
RGB: float, # noqa: N803
inverse: bool = False,
apply_black_offset: bool = True,
) -> float: ...
@overload
def ootf(
self,
RGB: tuple[float, float, float], # noqa: N803
inverse: bool = False,
apply_black_offset: bool = True,
) -> tuple[float, float, float]: ...
def ootf(
self,
RGB: float | tuple[float, float, float], # noqa: N803
inverse: bool = False,
apply_black_offset: bool = True,
) -> float | tuple[float, float, float]:
"""Hybrid Log Gamma (HLG) OOTF.
Relative scene linear light to display light, or inverse
Input domain 0..1
Output range 0..1
Args:
RGB (float | tuple[float, float, float]): R, G, B components of the
relative scene linear light or non-linear HLG signal.
inverse (bool): If True, apply inverse OOTF.
apply_black_offset (bool): Whether to apply black offset, defaults
to True.
Returns:
float | tuple[float, float, float]: G component of the display
light if RGB is a float, or R, G, B components of the display
light if RGB is a tuple.
"""
r, g, b = (RGB,) * 3 if isinstance(RGB, (float, int)) else RGB
black_cdm2 = float(self.black_cdm2) if apply_black_offset else 0
alpha = (self.white_cdm2 - black_cdm2) / self.white_cdm2
beta = black_cdm2 / self.white_cdm2
y = 0.2627 * r + 0.6780 * g + 0.0593 * b
if inverse:
if beta < y:
r, g, b = (
((y - beta) / alpha) ** ((1 - self.gamma) / self.gamma)
* ((v - beta) / alpha)
for v in (r, g, b)
)
else:
r, g, b = 0, 0, 0
else:
if y:
y **= self.gamma - 1
r, g, b = (alpha * y * e + beta for e in (r, g, b))
return g if isinstance(RGB, (float, int)) else (r, g, b)
def RGB2XYZ( # noqa: N802
self,
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
apply_black_offset: bool = True,
) -> tuple[float, float, float]:
"""Non-linear HLG signal to display XYZ.
Args:
R (float): R component of the non-linear HLG signal.
G (float): G component of the non-linear HLG signal.
B (float): B component of the non-linear HLG signal.
apply_black_offset (bool): Whether to apply black offset, defaults
to True.
Returns:
tuple[float, float, float]: X, Y, Z components of the display XYZ.
"""
x, y, z = self.rgb_space[-1] * [self.oetf(v, True) for v in (R, G, B)]
x, y, z = (max(v, 0) for v in (x, y, z))
yy = self.ootf(y, apply_black_offset=False)
if y:
x, y, z = (v / y * yy for v in (x, y, z))
else:
x, y, z = (v * yy for v in self.rgb_space[1])
if apply_black_offset:
beta = self.ootf(0)
bp_out = [v * beta for v in self.rgb_space[1]]
x, y, z = apply_bpc(x, y, z, (0, 0, 0), bp_out, self.rgb_space[1])
return x, y, z
def XYZ2RGB( # noqa: N802
self,
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
apply_black_offset: bool = True,
) -> tuple[float, float, float]:
"""Display XYZ to non-linear HLG signal.
Args:
X (float): X component of the XYZ color value.
Y (float): Y component of the XYZ color value.
Z (float): Z component of the XYZ color value.
apply_black_offset (bool): Whether to apply black offset, defaults
to True.
Returns:
tuple[float, float, float]: R, G, B components of the non-linear
HLG signal.
"""
if apply_black_offset:
beta = self.ootf(0)
bp_in = [v * beta for v in self.rgb_space[1]]
X, Y, Z = apply_bpc(X, Y, Z, bp_in, (0, 0, 0), self.rgb_space[1]) # noqa: N806
yy = self.ootf(Y, True, apply_black_offset=False)
if Y:
X, Y, Z = (v / Y * yy for v in (X, Y, Z)) # noqa: N806
r, g, b = self.rgb_space[-1].inverted() * (X, Y, Z)
r, g, b = (max(v, 0) for v in (r, g, b))
r, g, b = [self.oetf(v) for v in (r, g, b)]
return r, g, b
rgb_spaces = {
"ACES": (
1.0,
(0.95265, 1.0, 1.00883),
(0.7347, 0.2653, 0.343961),
(0.0000, 1.0000, 0.728164),
(0.0001, -0.0770, -0.072125),
),
"ACEScg": (
1.0,
(0.95265, 1.0, 1.00883),
(0.7130, 0.2930, 0.272230),
(0.1650, 0.8300, 0.674080),
(0.1280, 0.0440, 0.053690),
),
"Adobe RGB (1998)": (
2 + 51 / 256.0,
"D65",
(0.6400, 0.3300, 0.297361),
(0.2100, 0.7100, 0.627355),
(0.1500, 0.0600, 0.075285),
),
"Apple RGB": (
1.8,
"D65",
(0.6250, 0.3400, 0.244634),
(0.2800, 0.5950, 0.672034),
(0.1550, 0.0700, 0.083332),
),
"Best RGB": (
2.2,
"D50",
(0.7347, 0.2653, 0.228457),
(0.2150, 0.7750, 0.737352),
(0.1300, 0.0350, 0.034191),
),
"Beta RGB": (
2.2,
"D50",
(0.6888, 0.3112, 0.303273),
(0.1986, 0.7551, 0.663786),
(0.1265, 0.0352, 0.032941),
),
"Bruce RGB": (
2.2,
"D65",
(0.6400, 0.3300, 0.240995),
(0.2800, 0.6500, 0.683554),
(0.1500, 0.0600, 0.075452),
),
"CIE RGB": (
2.2,
"E",
(0.7350, 0.2650, 0.176204),
(0.2740, 0.7170, 0.812985),
(0.1670, 0.0090, 0.010811),
),
"ColorMatch RGB": (
1.8,
"D50",
(0.6300, 0.3400, 0.274884),
(0.2950, 0.6050, 0.658132),
(0.1500, 0.0750, 0.066985),
),
# "DCDM X'Y'Z'": (
# 2.6,
# "E",
# (1.0000, 0.0000, 0.000000),
# (0.0000, 1.0000, 1.000000),
# (0.0000, 0.0000, 0.000000)
# ),
"DCI P3": (
2.6,
(0.89459, 1.0, 0.95442),
(0.6800, 0.3200, 0.209475),
(0.2650, 0.6900, 0.721592),
(0.1500, 0.0600, 0.068903),
),
"DCI P3 D65": (
2.6,
"D65",
(0.6800, 0.3200, 0.209475),
(0.2650, 0.6900, 0.721592),
(0.1500, 0.0600, 0.068903),
),
"Don RGB 4": (
2.2,
"D50",
(0.6960, 0.3000, 0.278350),
(0.2150, 0.7650, 0.687970),
(0.1300, 0.0350, 0.033680),
),
"ECI RGB": (
1.8,
"D50",
(0.6700, 0.3300, 0.320250),
(0.2100, 0.7100, 0.602071),
(0.1400, 0.0800, 0.077679),
),
"ECI RGB v2": (
-3.0,
"D50",
(0.6700, 0.3300, 0.320250),
(0.2100, 0.7100, 0.602071),
(0.1400, 0.0800, 0.077679),
),
"Ekta Space PS5": (
2.2,
"D50",
(0.6950, 0.3050, 0.260629),
(0.2600, 0.7000, 0.734946),
(0.1100, 0.0050, 0.004425),
),
"NTSC 1953": (
2.2,
"C",
(0.6700, 0.3300, 0.298839),
(0.2100, 0.7100, 0.586811),
(0.1400, 0.0800, 0.114350),
),
"PAL/SECAM": (
2.2,
"D65",
(0.6400, 0.3300, 0.222021),
(0.2900, 0.6000, 0.706645),
(0.1500, 0.0600, 0.071334),
),
"ProPhoto RGB": (
1.8,
"D50",
(0.7347, 0.2653, 0.288040),
(0.1596, 0.8404, 0.711874),
(0.0366, 0.0001, 0.000086),
),
"Rec. 709": (
-709,
"D65",
(0.6400, 0.3300, 0.212656),
(0.3000, 0.6000, 0.715158),
(0.1500, 0.0600, 0.072186),
),
"Rec. 2020": (
-709,
"D65",
(0.7080, 0.2920, 0.262694),
(0.1700, 0.7970, 0.678009),
(0.1310, 0.0460, 0.059297),
),
"SMPTE-C": (
2.2,
"D65",
(0.6300, 0.3400, 0.212395),
(0.3100, 0.5950, 0.701049),
(0.1550, 0.0700, 0.086556),
),
"SMPTE 240M": (
-240,
"D65",
(0.6300, 0.3400, 0.212395),
(0.3100, 0.5950, 0.701049),
(0.1550, 0.0700, 0.086556),
),
"sRGB": (
-2.4,
"D65",
(0.6400, 0.3300, 0.212656),
(0.3000, 0.6000, 0.715158),
(0.1500, 0.0600, 0.072186),
),
"Wide Gamut RGB": (
2.2,
"D50",
(0.7350, 0.2650, 0.258187),
(0.1150, 0.8260, 0.724938),
(0.1570, 0.0180, 0.016875),
),
}
"""
http://brucelindbloom.com/WorkingSpaceInfo.html
ACES: https://github.com/ampas/aces-dev/blob/master/docs/ACES_1.0.1.pdf?raw=true
Adobe RGB: http://www.adobe.com/digitalimag/pdfs/AdobeRGB1998.pdf
DCI P3: http://www.hp.com/united-states/campaigns/workstations/pdfs/lp2480zx-dci--p3-emulation.pdf
http://dcimovies.com/specification/DCI_DCSS_v12_with_errata_2012-1010.pdf
Rec. 2020: http://en.wikipedia.org/wiki/Rec._2020
name gamma white primaries
point Rx Ry RY Gx Gy GY Bx By BY
""" # noqa: E501
@cache
def get_cat_matrix(
cat: str | bytes | list | tuple | Matrix3x3 = "Bradford",
) -> Matrix3x3:
"""Get chromatic adaption matrix.
Args:
cat (bytes | str | list | tuple | Matrix3x3): Chromatic adaption matrix
name or instance. Defaults to "Bradford".
Returns:
Matrix3x3: Chromatic adaption matrix.
"""
if isinstance(cat, str):
cat = CAT_MATRICES[cat]
elif isinstance(cat, bytes):
cat = CAT_MATRICES[cat.decode()]
if not isinstance(cat, Matrix3x3):
cat = Matrix3x3(cat)
return cat
def cbrt(x: float) -> float:
"""Cube root.
Args:
x (float): Input value.
Returns:
float: Cube root of x.
"""
return math.pow(x, 1.0 / 3.0) if x >= 0 else -math.pow(-x, 1.0 / 3.0)
def var(a: list[float]) -> float:
"""Variance.
Args:
a (list[float]): List of numbers.
Returns:
float: Variance of the numbers in the list.
"""
s = 0.0
l = len(a)
while l:
l -= 1
s += a[l]
l = len(a)
m = s / l
s = 0.0
while l:
l -= 1
s += (a[l] - m) ** 2
return s / len(a)
def XYZ2LMS( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
cat: str = "Bradford",
) -> tuple[float, float, float]:
"""Convert from XYZ to cone response domain.
Args:
X (float): X component of the XYZ color value.
Y (float): Y component of the XYZ color value.
Z (float): Z component of the XYZ color value.
cat (str): Chromatic adaptation transform, defaults to 'Bradford'.
Returns:
tuple[float, float, float]: L, M, S components of the LMS color value.
"""
cat = get_cat_matrix(cat)
p, y, b = cat * [X, Y, Z]
return p, y, b
def LMS_wp_adaption_matrix( # noqa: N802
whitepoint_source: None | float | str | list | tuple = None,
whitepoint_destination: None | float | str | list | tuple = None,
cat: str = "Bradford",
) -> Matrix3x3:
"""Prepare a matrix to match the whitepoints in cone response domain.
Args:
whitepoint_source (None | float | str | list | tuple): Source white
point, defaults to None.
whitepoint_destination (None | float | str | list | tuple): Destination
white point, defaults to None.
cat (str): Chromatic adaptation transform, defaults to 'Bradford'.
Returns:
Matrix3x3: Matrix to adapt source whitepoint to destination in LMS.
"""
# chromatic adaption
# based on formula http://brucelindbloom.com/Eqn_ChromAdapt.html
# cat = adaption matrix or predefined choice ('CAT02', 'Bradford',
# 'Von Kries', 'XYZ Scaling', see CAT_MATRICES), defaults to 'Bradford'
cat = get_cat_matrix(cat)
xyz_ws = get_whitepoint(whitepoint_source)
xyz_wd = get_whitepoint(whitepoint_destination)
if xyz_ws[1] <= 1.0 < xyz_wd[1]:
# make sure the scaling is identical
xyz_wd = [v / xyz_wd[1] * xyz_ws[1] for v in xyz_wd]
if xyz_wd[1] <= 1.0 < xyz_ws[1]:
# make sure the scaling is identical
xyz_ws = [v / xyz_ws[1] * xyz_wd[1] for v in xyz_ws]
ls, ms, ss = XYZ2LMS(xyz_ws[0], xyz_ws[1], xyz_ws[2], cat)
ld, md, dd = XYZ2LMS(xyz_wd[0], xyz_wd[1], xyz_wd[2], cat)
return Matrix3x3([[ld / ls, 0, 0], [0, md / ms, 0], [0, 0, dd / ss]])
@cache
def wp_adaption_matrix(
whitepoint_source: None | float | str | list | tuple = None,
whitepoint_destination: None | float | str | list | tuple = None,
cat: str = "Bradford",
) -> Matrix3x3:
"""Return matrix to adapt source whitepoint to destination in XYZ.
Args:
whitepoint_source (None | float | str | list | tuple): Source white
point, defaults to None.
whitepoint_destination (None | float | str | list | tuple): Destination
white point, defaults to None.
cat (str): Chromatic adaptation transform, defaults to 'Bradford'.
Returns:
Matrix3x3: Matrix to adapt source whitepoint to destination.
"""
# chromatic adaption
# based on formula http://brucelindbloom.com/Eqn_ChromAdapt.html
# cat = adaption matrix or predefined choice ('CAT02', 'Bradford',
# 'Von Kries', 'XYZ Scaling', see CAT_MATRICES), defaults to 'Bradford'
cat = get_cat_matrix(cat)
return (
cat.inverted()
* LMS_wp_adaption_matrix(whitepoint_source, whitepoint_destination, cat)
* cat
)
def adapt(
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint_source: None | float | str | list | tuple = None,
whitepoint_destination: None | float | str | list | tuple = None,
cat: str = "Bradford",
) -> tuple[float, float, float]:
"""Transform XYZ under source illuminant to XYZ under destination illuminant.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint_source (None | float | str | list | tuple): Source white
point, defaults to None.
whitepoint_destination (None | float | str | list | tuple): Destination
white point, defaults to None.
cat (str): Chromatic adaptation transform, defaults to 'Bradford'.
Returns:
tuple[float, float, float]: Adapted X, Y, Z values.
"""
# chromatic adaption
# based on formula http://brucelindbloom.com/Eqn_ChromAdapt.html
# cat = adaption matrix or predefined choice ('CAT02', 'Bradford',
# 'Von Kries', 'XYZ Scaling', see CAT_MATRICES), defaults to 'Bradford'
return wp_adaption_matrix(whitepoint_source, whitepoint_destination, cat) * (
X,
Y,
Z,
)
def apply_bpc(
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
bp_in: None | tuple = None,
bp_out: None | tuple = None,
wp_out: None | float | str | list | tuple = "D50",
weight: bool = False,
pin_chromaticity: bool = False,
) -> tuple[float, float, float]:
"""Apply black point compensation.
Args:
X (float): X value
Y (float): Y value
Z (float): Z value
bp_in (tuple): Input black point
bp_out (tuple): Output black point
wp_out (str or tuple): Output white point
weight (bool): Whether to apply weight
pin_chromaticity (bool): Whether to pin chromaticity
Returns:
tuple[float, float, float]: Adjusted X, Y, Z values.
"""
if not bp_in:
bp_in = (0, 0, 0)
if not bp_out:
bp_out = (0, 0, 0)
wp_out = get_whitepoint(wp_out)
if weight:
l = XYZ2Lab(*[v * 100 for v in (X, Y, Z)])[0]
bp_in_lab = XYZ2Lab(*[v * 100 for v in bp_in])
bp_out_lab = XYZ2Lab(*[v * 100 for v in bp_out])
vv = (l - bp_in_lab[0]) / (100.0 - bp_in_lab[0]) # 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, min(40.0, 40.0 / (max(bp_in_lab[0], bp_out_lab[0]) or 1.0)))
bp_in = Lab2XYZ(*[v * vv for v in bp_in_lab])
bp_out = Lab2XYZ(*[v * vv for v in bp_out_lab])
if pin_chromaticity:
XYZ = [Y] # noqa: N806
x, y = XYZ2xyY(X, Y, Z, wp_out)[:2]
bp_in = bp_in[1:2]
bp_out = bp_out[1:2]
wp_out = wp_out[1:2]
else:
XYZ = [X, Y, Z] # noqa: N806
for i, v in enumerate(XYZ):
XYZ[i] = ((wp_out[i] - bp_out[i]) * v - wp_out[i] * (bp_in[i] - bp_out[i])) / ( # noqa: N806
wp_out[i] - bp_in[i]
)
if pin_chromaticity:
XYZ = xyY2XYZ(x, y, XYZ[0]) # noqa: N806
return XYZ
def avg(*args: list[float]) -> float:
"""Average of a list of numbers.
Args:
*args (list[float]): A list of numbers.
Returns:
float: Average of the numbers.
"""
return float(sum(args)) / len(args)
def blend_ab(
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
bp: tuple,
wp: tuple,
power: float = 40.0,
signscale: float = 1,
) -> tuple[float, float, float]:
"""Blend to destination black as L approaches black.
Args:
X (float): X value
Y (float): Y value
Z (float): Z value
bp (tuple): Black point
wp (tuple): White point
power (float): Power for blending
signscale (int): Sign scale for blending
Returns:
tuple[float, float, float]: Blended X, Y, Z values
"""
if Y < 0:
return 0, 0, 0
l, a, b = XYZ2Lab(X, Y, Z, whitepoint=wp)
bpl, bpa, bpb = XYZ2Lab(*bp, whitepoint=wp)
if bpl == 100:
raise ValueError("Black L* is 100!")
vv = (l - bpl) / (100.0 - bpl) # 0 at bp, 1 at wp
vv = 1.0 - vv # 1 at bp, 0 at wp
if vv < 0.0:
vv = 0.0
elif vv > 1.0:
vv = 1.0
vv = math.pow(vv, power) * signscale
a += vv * bpa
b += vv * bpb
return Lab2XYZ(l, a, b, whitepoint=wp)
def blend_blackpoint(
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
bp_in: None | tuple = None,
bp_out: None | tuple = None,
wp: None | float | str | list | tuple = None,
power: float = 40.0,
pin_chromaticity: bool = False,
) -> tuple[float, float, float]:
"""Blend to destination black as L approaches black, with optional input black compensation.
Args:
X (float): X value
Y (float): Y value
Z (float): Z value
bp_in (tuple): Input black point
bp_out (tuple): Output black point
wp (str or tuple): White point, defaults to "D50"
power (float): Power for blending, defaults to 40.0
pin_chromaticity (bool): Whether to pin chromaticity, defaults to False.
Returns:
tuple[float, float, float]: Adjusted X, Y, Z values.
""" # noqa: E501
wp = get_whitepoint(wp)
for i, bp in enumerate((bp_in, bp_out)):
if not bp or tuple(bp) == (0, 0, 0):
continue
bp_wp = tuple(v / wp[1] * bp[1] for v in wp)
if i == 0:
X, Y, Z = blend_ab(X, Y, Z, bp, wp, power, -1) # noqa: N806
X, Y, Z = apply_bpc(X, Y, Z, bp_wp, None, wp, pin_chromaticity) # noqa: N806
else:
X, Y, Z = apply_bpc(X, Y, Z, None, bp_wp, wp, pin_chromaticity) # noqa: N806
X, Y, Z = blend_ab(X, Y, Z, bp, wp, power, 1) # noqa: N806
return X, Y, Z
def interp_old(
x: float,
xp: list,
fp: list,
left: None | float = None,
right: None | float = None,
) -> float:
"""One-dimensional linear interpolation similar to numpy.interp.
Values do NOT have to be monotonically increasing
interp(0, [0, 0], [0, 1]) will return 0.
Args:
x (float): The x value to interpolate.
xp (list): The x-coordinates of the data points.
fp (list): The y-coordinates of the data points.
left (float, optional): Value to return for x < xp[0]. Defaults to None.
right (float, optional): Value to return for x > xp[-1]. Defaults to None.
Returns:
float: Interpolated value.
"""
if not isinstance(x, (int, float, complex)):
return [interp_old(n, xp, fp, left, right) for n in x]
if x in xp:
return fp[xp.index(x)]
if x < xp[0]:
return fp[0] if left is None else left
if x > xp[-1]:
return fp[-1] if right is None else right
# Interpolate
lower = 0
higher = len(fp) - 1
for i, v in enumerate(xp):
if v < x and i > lower:
lower = i
elif v > x and i < higher:
higher = i
step = float(x - xp[lower])
steps = (xp[higher] - xp[lower]) / step
return fp[lower] + (fp[higher] - fp[lower]) / steps
# This is much faster than the old implementation
def interp(
x: float | list,
xp: list,
fp: list,
left: None | float = None,
right: None | float = None,
period: None | float = None,
) -> float | list:
"""One-dimensional linear interpolation similar to numpy.interp.
Values do NOT have to be monotonically increasing
interp(0, [0, 0], [0, 1]) will return 0
Args:
x (float or list): The x value(s) to interpolate.
xp (list): The x-coordinates of the data points.
fp (list): The y-coordinates of the data points.
left (float, optional): Value to return for x < xp[0]. Defaults to None.
right (float, optional): Value to return for x > xp[-1]. Defaults to None.
period (float, optional): Periodicity of the interpolation. Defaults to None.
Returns:
float | list: Interpolated value(s).
"""
# TODO: This function overrides the class implementation (Interp) and forces to use
# numpy.interp all the time, and it is kind of rude in that manner.
# Please respect the previous implementation, but use nump.interp again.
return numpy.interp(x, xp, fp, left, right, period)
def interp_resize(iterable: list, new_size: int, use_numpy: bool = False) -> list:
"""Change size of iterable through linear interpolation.
Args:
iterable (list): A list of float values.
new_size (int): New size of the list
use_numpy (bool): Use numpy for interpolation. Defaults to False.
Returns:
list: Interpolated values.
"""
# interp = Interp(list(range(len(iterable))), iterable, use_numpy=use_numpy)
return [
interp(
i / (new_size - 1.0) * (len(iterable) - 1.0),
list(range(len(iterable))),
iterable,
)
for i in range(new_size)
]
def interp_fill(xp: list, fp: list, new_size: int, use_numpy: bool = False) -> list:
"""Fill missing points by interpolation.
Args:
xp (list): X values
fp (list): Y values
new_size (int): New size of the list
use_numpy (bool): Use numpy for interpolation. Defaults to False.
Returns:
list: Interpolated values.
"""
# interp = Interp(xp, fp, use_numpy=use_numpy)
return [interp(i / (new_size - 1.0) * xp[-1], xp, fp) for i in range(new_size)]
def smooth_avg_old(
values: list,
passes: int = 1,
window: None | tuple | list = None,
protect: None | list = None,
) -> list:
"""Smooth values (moving average).
Args:
values (list): A list of float values.
passes (int): Number of passes
window (tuple/list): Tuple or list containing weighting factors. Its length
determines the size of the window to use. Defaults to (1.0, 1.0, 1.0)
protect (list): A list of indices to protect. The values related to these
indices will be protected.
Returns:
list: Smoothed values.
"""
if not window or len(window) < 3 or len(window) % 2 != 1:
if window:
warnings.warn(
f"Invalid window {window!r}, size {len(window)} "
"- using default (1, 1, 1)",
Warning,
stacklevel=2,
)
window = (1.0, 1.0, 1.0)
for _x in range(passes):
data = []
for j, v in enumerate(values):
tmp_window = window
if not protect or j not in protect:
while 0 < j < len(values) - 1 and len(tmp_window) >= 3:
tl = (len(tmp_window) - 1) / 2
# print j, tl, tmp_window
if tl > 0 and j - tl >= 0 and j + tl <= len(values) - 1:
windowslice = values[int(j - tl) : int(j + tl + 1)]
windowsize = 0
for k, weight in enumerate(tmp_window):
windowsize += float(weight) * windowslice[k]
v = windowsize / sum(tmp_window)
break
tmp_window = tmp_window[1:-1]
data.append(v)
values = data
return values
def smooth_avg(
values: list,
passes: int = 1,
window: None | tuple[float, float, float] | list = None,
protect: None | list = None,
) -> list:
"""Smooth values fast (moving average).
This is (should be) the fast implementation of the ``smooth_avg``. Inputs are the
same.
Args:
values (list): A list of float values.
passes (int): Number of passes
window (tuple/list): Tuple or list containing weighting factors. Its length
determines the size of the window to use. Defaults to (1.0, 1.0, 1.0)
protect (list): A list of indices to protect. The values related to these
indices will be restored after each pass.
Returns:
list: Smoothed values.
"""
if not window or len(window) < 3 or len(window) % 2 != 1:
if window:
warnings.warn(
f"Invalid window {window!r}, size {len(window)} "
"- using default (1, 1, 1)",
Warning,
stacklevel=2,
)
window = (1, 1, 1)
# fix the window values
window_length = float(len(window))
window_weight = sum(window)
window = tuple([i / window_weight for i in window])
# extend the array by ceil(window_size / 2)
extend_amount = math.ceil(window_length / 2)
# protect start and end values by adding the first and last values by the half of
# the window length
values = values[0:1] * extend_amount + values + values[-1:] * extend_amount
protection_extension = 1
protected_start = values[: extend_amount + protection_extension]
protected_end = values[-extend_amount - protection_extension :]
protected_values = {}
if protect is not None:
for index in protect:
# offset the values with ``extend_amount``
protected_values[index + extend_amount] = values[index + extend_amount]
for _ in range(passes):
values = list(numpy.convolve(values, window, mode="same"))
# Protect start and end values
values[: extend_amount + protection_extension] = protected_start
values[-extend_amount - protection_extension :] = protected_end
# restore protected values
if protect is not None:
for k in protected_values:
v = protected_values[k]
values[k] = v
# return the non-extended portion
return values[extend_amount:-extend_amount]
def compute_bpc(
bp_in: tuple[float, float, float],
bp_out: tuple[float, float, float],
) -> tuple[Matrix3x3, list]:
"""Black point compensation. Implemented as a linear scaling in XYZ.
Black points should come relative to the white point. Fills and
returns a matrix/offset element.
[matrix]*bp_in + offset = bp_out
[matrix]*D50 + offset = D50
Args:
bp_in (tuple[float, float, float]): Input black point in XYZ.
bp_out (tuple[float, float, float]): Output black point in XYZ.
Returns:
tuple[Matrix, list]: A tuple containing a Matrix3x3 and an offset list.
The matrix is used to scale the input black point to the output
black point, and the offset is used to adjust the output black
point to the desired value.
"""
# This is a linear scaling in the form ax+b, where
# a = (bp_out - D50) / (bp_in - D50)
# b = - D50* (bp_out - bp_in) / (bp_in - D50)
d50 = get_standard_illuminant("D50")
tx = bp_in[0] - d50[0]
ty = bp_in[1] - d50[1]
tz = bp_in[2] - d50[2]
ax = (bp_out[0] - d50[0]) / tx
ay = (bp_out[1] - d50[1]) / ty
az = (bp_out[2] - d50[2]) / tz
bx = -d50[0] * (bp_out[0] - bp_in[0]) / tx
by = -d50[1] * (bp_out[1] - bp_in[1]) / ty
bz = -d50[2] * (bp_out[2] - bp_in[2]) / tz
matrix = Matrix3x3([[ax, 0, 0], [0, ay, 0], [0, 0, az]])
offset = [bx, by, bz]
return matrix, offset
def delta(
L1: float, # noqa: N803
a1: float,
b1: float,
L2: float, # noqa: N803
a2: float,
b2: float,
method: str = "1976",
p1: None | float = None,
p2: None | float = None,
p3: None | float = None,
cie94_use_symmetric_chrominance: bool = True,
) -> dict:
"""Compute the delta of two samples.
- CIE 1994 & CMC calculation code derived from formulas on
www.brucelindbloom.com
- CIE 1994 code uses some alterations seen on
www.farbmetrik-gall.de/cielab/korrcielab/cie94.html
(see notes in code below)
- CIE 2000 calculation code derived from Excel spreadsheet available at
www.ece.rochester.edu/~gsharma/ciede2000
p1, p2, p3 arguments have different meaning for each calculation method:
CIE 1994: If p1 is not None, calculation will be adjusted for
textiles, otherwise graphics arts (default if p1 is not set)
CMC(l:c): p1 equals l (lightness) weighting factor and p2 equals c
(chroma) weighting factor.
Commonly used values are CMC(1:1) for perceptability
(default if p1 and p2 are not set) and CMC(2:1) for
acceptability
CIE 2000: p1 becomes kL (lightness) weighting factor, p2 becomes
kC (chroma) weighting factor and p3 becomes kH (hue)
weighting factor (all three default to 1 if not set)
Args:
L1 (float): Lightness of first sample
a1 (float): a* value of first sample
b1 (float): b* value of first sample
L2 (float): Lightness of second sample
a2 (float): a* value of second sample
b2 (float): b* value of second sample
method (str): Method to use for delta calculation.
Can be "CIE94", "CMC", "CIE2K" or "CIE76". Defaults to "CIE76".
p1 (float): Parameter 1
- for CIE94, if not None, adjusts calculation for textiles,
otherwise for graphics arts (default if p1 is not set)
- for CMC, equals l (lightness) weighting factor (default if p1 is
not set)
- for CIE2K, equals kL (lightness) weighting factor (default if p1
is not set)
p2 (float): Parameter 2
- for CIE94, not used (default if p2 is not set)
- for CMC, equals c (chroma) weighting factor (default if p2 is not
set)
- for CIE2K, equals kC (chroma) weighting factor (default if p2 is
not set)
p3 (float): Parameter 3
- for CIE94, not used (default if p3 is not set)
- for CMC, not used (default if p3 is not set)
- for CIE2K, equals kH (hue) weighting factor (default if p3 is not
set)
cie94_use_symmetric_chrominance (bool):
If True, CIE94 will use symmetric chrominance calculation.
If False, it will use asymmetric chrominance calculation.
Defaults to True.
Returns:
dict: A dictionary containing the delta E value and the method used.
The dictionary will have the following keys:
- "E": The calculated delta E value.
- "L": The difference in lightness between the two samples.
- "C": The difference in chroma between the two samples.
- "H": The difference in hue between the two samples.
- "a": The a* value of the first sample.
- "b": The b* value of the first sample.
- "Lw": The lightness difference adjusted for the method used.
- "Cw": The chroma difference adjusted for the method used.
- "Hw": The hue difference adjusted for the method used.
"""
method = method.lower() if isinstance(method, str) else str(int(method))
if method in ("94", "1994", "cie94", "cie1994"):
textiles = p1
dl = L2 - L1
c1 = math.sqrt(math.pow(a1, 2) + math.pow(b1, 2))
c2 = math.sqrt(math.pow(a2, 2) + math.pow(b2, 2))
dc = c2 - c1
dh2 = math.pow(a1 - a2, 2) + math.pow(b1 - b2, 2) - math.pow(dc, 2)
dh = math.sqrt(dh2) if dh2 > 0 else 0
sl = 1.0
k1 = 0.048 if textiles else 0.045
k2 = 0.014 if textiles else 0.015
c_ = math.sqrt(c1 * c2) if cie94_use_symmetric_chrominance else c1
sc = 1.0 + k1 * c_
sh = 1.0 + k2 * c_
kl = 2.0 if textiles else 1.0
kc = 1.0
kh = 1.0
dlw, dcw, dhw = dl / (kl * sl), dc / (kc * sc), dh / (kh * sh)
de = math.sqrt(math.pow(dlw, 2) + math.pow(dcw, 2) + math.pow(dhw, 2))
elif method in ("cmc(2:1)", "cmc21", "cmc(1:1)", "cmc11", "cmc"):
if method in ("cmc(2:1)", "cmc21"):
p1 = 2.0
l = p1 if isinstance(p1, (float, int)) else 1.0
c = p2 if isinstance(p2, (float, int)) else 1.0
dl = L2 - L1
c1 = math.sqrt(math.pow(a1, 2) + math.pow(b1, 2))
c2 = math.sqrt(math.pow(a2, 2) + math.pow(b2, 2))
dc = c2 - c1
dh2 = math.pow(a1 - a2, 2) + math.pow(b1 - b2, 2) - math.pow(dc, 2)
dh = math.sqrt(dh2) if dh2 > 0 else 0
sl = 0.511 if L1 < 16 else (0.040975 * L1) / (1 + 0.01765 * L1)
sc = (0.0638 * c1) / (1 + 0.0131 * c1) + 0.638
f = math.sqrt(math.pow(c1, 4) / (math.pow(c1, 4) + 1900.0))
h1 = math.degrees(math.atan2(b1, a1)) + (0 if b1 >= 0 else 360.0)
t = (
0.56 + abs(0.2 * math.cos(math.radians(h1 + 168.0)))
if 164 <= h1 <= 345
else 0.36 + abs(0.4 * math.cos(math.radians(h1 + 35)))
)
sh = sc * (f * t + 1 - f)
dlw, dcw, dhw = dl / (l * sl), dc / (c * sc), dh / sh
de = math.sqrt(math.pow(dlw, 2) + math.pow(dcw, 2) + math.pow(dhw, 2))
elif method in ("00", "2k", "2000", "cie00", "cie2k", "cie2000"):
pow25_7 = math.pow(25, 7)
k_l = p1 if isinstance(p1, (float, int)) else 1.0
k_c = p2 if isinstance(p2, (float, int)) else 1.0
k_h = p3 if isinstance(p3, (float, int)) else 1.0
c1 = math.sqrt(math.pow(a1, 2) + math.pow(b1, 2))
c2 = math.sqrt(math.pow(a2, 2) + math.pow(b2, 2))
c_avg = avg(c1, c2)
g = 0.5 * (1 - math.sqrt(math.pow(c_avg, 7) / (math.pow(c_avg, 7) + pow25_7)))
l1_ = L1
a1_ = (1 + g) * a1
b1_ = b1
l2_ = L2
a2_ = (1 + g) * a2
b2_ = b2
c1_ = math.sqrt(math.pow(a1_, 2) + math.pow(b1_, 2))
c2_ = math.sqrt(math.pow(a2_, 2) + math.pow(b2_, 2))
h1_ = (
0
if a1_ == 0 and b1_ == 0
else math.degrees(math.atan2(b1_, a1_)) + (0 if b1_ >= 0 else 360.0)
)
h2_ = (
0
if a2_ == 0 and b2_ == 0
else math.degrees(math.atan2(b2_, a2_)) + (0 if b2_ >= 0 else 360.0)
)
dh_cond = 1.0 if h2_ - h1_ > 180 else (2.0 if h2_ - h1_ < -180 else 0)
dh_ = (
h2_ - h1_
if dh_cond == 0
else (h2_ - h1_ - 360.0 if dh_cond == 1 else h2_ + 360.0 - h1_)
)
dl_ = l2_ - l1_
dl = dl_
dc_ = c2_ - c1_
dc = dc_
dhh_ = 2 * math.sqrt(c1_ * c2_) * math.sin(math.radians(dh_ / 2.0))
dh = dhh_
l__avg = avg(l1_, l2_)
c__avg = avg(c1_, c2_)
h__avg_cond = (
3.0
if c1_ * c2_ == 0
else (0 if abs(h2_ - h1_) <= 180 else (1.0 if h2_ + h1_ < 360 else 2.0))
)
h__avg = (
h1_ + h2_
if h__avg_cond == 3
else (
avg(h1_, h2_)
if h__avg_cond == 0
else (
avg(h1_, h2_) + 180.0 if h__avg_cond == 1 else avg(h1_, h2_) - 180.0
)
)
)
ab = math.pow(l__avg - 50.0, 2) # (L'_ave-50)^2
s_l = 1 + 0.015 * ab / math.sqrt(20.0 + ab)
s_c = 1 + 0.045 * c__avg
t = (
1
- 0.17 * math.cos(math.radians(h__avg - 30.0))
+ 0.24 * math.cos(math.radians(2.0 * h__avg))
+ 0.32 * math.cos(math.radians(3.0 * h__avg + 6.0))
- 0.2 * math.cos(math.radians(4 * h__avg - 63.0))
)
s_h = 1 + 0.015 * c__avg * t
dtheta = 30.0 * math.exp(-1 * math.pow((h__avg - 275.0) / 25.0, 2))
r_c = 2.0 * math.sqrt(math.pow(c__avg, 7) / (math.pow(c__avg, 7) + pow25_7))
r_t = -math.sin(math.radians(2.0 * dtheta)) * r_c
aj = dl_ / s_l / k_l # dL' / k_L / S_L
ak = dc_ / s_c / k_c # dC' / k_C / S_C
al = dhh_ / s_h / k_h # dH' / k_H / S_H
dlw, dcw, dhw = aj, ak, al
de = math.sqrt(
math.pow(aj, 2) + math.pow(ak, 2) + math.pow(al, 2) + r_t * ak * al
)
else:
# dE 1976
dl = L2 - L1
c1 = math.sqrt(math.pow(a1, 2) + math.pow(b1, 2))
c2 = math.sqrt(math.pow(a2, 2) + math.pow(b2, 2))
dc = c2 - c1
dh2 = math.pow(a1 - a2, 2) + math.pow(b1 - b2, 2) - math.pow(dc, 2)
dh = math.sqrt(dh2) if dh2 > 0 else 0
dlw, dcw, dhw = dl, dc, dh
de = math.sqrt(math.pow(dl, 2) + math.pow(a1 - a2, 2) + math.pow(b1 - b2, 2))
return {
"E": de,
"L": dl,
"C": dc,
"H": dh,
"a": a1 - a2,
"b": b1 - b2,
# Weighted
"Lw": dlw,
"Cw": dcw,
"Hw": dhw,
}
def XYZ2Lab_delta( # noqa: N802
X1: float, # noqa: N803
Y1: float, # noqa: N803
Z1: float, # noqa: N803
X2: float, # noqa: N803
Y2: float, # noqa: N803
Z2: float, # noqa: N803
method: str = "76",
whitepoint1: None | float | str | list | tuple = "D50",
whitepoint2: None | float | str | list | tuple = "D50",
whitepoint_reference: None | float | str | tuple = "D50",
cat: str = "Bradford",
) -> dict:
"""Compute the delta of two samples in XYZ space.
Args:
X1 (float): XYZ values of the first sample.
Y1 (float): XYZ values of the first sample.
Z1 (float): XYZ values of the first sample.
X2 (float): XYZ values of the second sample.
Y2 (float): XYZ values of the second sample.
Z2 (float): XYZ values of the second sample.
method (str): Method to use for delta calculation. Defaults to "76".
whitepoint1 (None | float | str | list | tuple): Whitepoint of
the first sample. Defaults to "D50".
whitepoint2 (None | float | str | list | tuple): Whitepoint of
the second sample. Defaults to "D50".
whitepoint_reference (None | float | str | list | tuple): Reference
whitepoint. Defaults to "D50".
cat (str): Chromatic adaptation transform. Defaults to "Bradford".
Returns:
dict: Dictionary containing the delta values.
"""
whitepoint1 = get_whitepoint(whitepoint1)
whitepoint2 = get_whitepoint(whitepoint2)
whitepoint_reference = get_whitepoint(whitepoint_reference)
if whitepoint1 != whitepoint_reference:
X1, Y1, Z1 = adapt(X1, Y1, Z1, whitepoint1, whitepoint_reference, cat) # noqa: N806
if whitepoint2 != whitepoint_reference:
X2, Y2, Z2 = adapt(X2, Y2, Z2, whitepoint2, whitepoint_reference, cat) # noqa: N806
l1, a1, b1 = XYZ2Lab(X1, Y1, Z1, whitepoint_reference)
l2, a2, b2 = XYZ2Lab(X2, Y2, Z2, whitepoint_reference)
logger.debug(
f"L*a*b*[1] {l1:.4f} {a1:.4f} {b1:.4f} L*a*b*[2] {l2:.4f} {a2:.4f} {b2:.4f}"
)
return delta(l1, a1, b1, l2, a2, b2, method)
def is_similar_matrix(
matrix1: Matrix3x3, matrix2: Matrix3x3, digits: float = 3
) -> bool:
"""Check if two matrices are equal up to n decimal digits.
Args:
matrix1 (Matrix3x3): First matrix to compare.
matrix2 (Matrix3x3): Second matrix to compare.
digits (int): Number of decimal digits to consider for equality.
Defaults to 3.
Returns:
bool: True if the matrices are equal up to the specified number of
digits, False otherwise.
"""
return matrix1.rounded(digits) == matrix2.rounded(digits)
def is_equal(
values1: list[float],
values2: list[float],
quantizer: None | Callable = None,
) -> bool:
"""Check if two value sets are equal after quantization.
Args:
values1 (list): First list of float values.
values2 (list): Second list of float values.
quantizer (callable, optional): Function to quantize the values. If None,
defaults to rounding to 4 decimal places.
Returns:
bool: True if the quantized values are equal, False otherwise.
"""
if quantizer is None:
def quantizer(v: float) -> float:
"""Default quantizer that rounds to 4 decimal places.
Args:
v (float): The value to quantize.
Returns:
float: The quantized value rounded to 4 decimal places.
"""
return round(v, 4)
return [quantizer(v) for v in values1] == [quantizer(v) for v in values2]
def four_color_matrix(
xrr: float, # noqa: N803
yrr: float, # noqa: N803
zrr: float, # noqa: N803
xrg: float, # noqa: N803
yrg: float, # noqa: N803
zrg: float, # noqa: N803
xrb: float, # noqa: N803
yrb: float, # noqa: N803
zrb: float, # noqa: N803
xrw: float, # noqa: N803
yrw: float, # noqa: N803
zrw: float, # noqa: N803
xmr: float, # noqa: N803
ymr: float, # noqa: N803
zmr: float, # noqa: N803
xmg: float, # noqa: N803
ymg: float, # noqa: N803
zmg: float, # noqa: N803
xmb: float, # noqa: N803
ymb: float, # noqa: N803
zmb: float, # noqa: N803
xmw: float, # noqa: N803
ymw: float, # noqa: N803
zmw: float, # noqa: N803
y_correction: bool = True, # noqa: N803
) -> Matrix3x3:
"""Four-Color Matrix Method for Correction of Tristimulus Colorimeters.
Based on paper published in Proc., IS&T Fifth Color Imaging Conference,
301-305 (1997) and IS&T Sixth Color Imaging Conference (1998).
Args:
xrr (float): Reference RGB values for red.
yrr (float): Reference RGB values for red.
zrr (float): Reference RGB values for red.
xrg (float): Reference RGB values for green.
yrg (float): Reference RGB values for green.
zrg (float): Reference RGB values for green.
xrb (float): Reference RGB values for blue.
yrb (float): Reference RGB values for blue.
zrb (float): Reference RGB values for blue.
xrw (float): Reference RGB values for white.
yrw (float): Reference RGB values for white.
zrw (float): Reference RGB values for white.
xmr (float): Measured RGB values for red.
ymr (float): Measured RGB values for red.
zmr (float): Measured RGB values for red.
xmg (float): Measured RGB values for green.
ymg (float): Measured RGB values for green.
zmg (float): Measured RGB values for green.
xmb (float): Measured RGB values for blue.
ymb (float): Measured RGB values for blue.
zmb (float): Measured RGB values for blue.
xmw (float): Measured RGB values for white.
ymw (float): Measured RGB values for white.
zmw (float): Measured RGB values for white.
y_correction (bool): If True, apply Y correction. Defaults to True.
Returns:
Matrix3x3: The four-color matrix.
"""
components = {
"XrR": xrr,
"YrR": yrr,
"ZrR": zrr,
"XrG": xrg,
"YrG": yrg,
"ZrG": zrg,
"XrB": xrb,
"YrB": yrb,
"ZrB": zrb,
"XrW": xrw,
"YrW": yrw,
"ZrW": zrw,
"XmR": xmr,
"YmR": ymr,
"ZmR": zmr,
"XmG": xmg,
"YmG": ymg,
"ZmG": zmg,
"XmB": xmb,
"YmB": ymb,
"ZmB": zmb,
"XmW": xmw,
"YmW": ymw,
"ZmW": zmw,
}
xyz = {}
m = {}
k = {}
for s in "mr":
xyz[s] = {}
for color in "RGBW":
x, y, _ = XYZ2xyY(
*(components[f"{component}{s}{color}"] for component in "XYZ")
)
xyz[s][color] = x, y, 1 - x - y
m[s] = Matrix3x3([xyz[s][color] for color in "RGB"]).transposed()
k[s] = m[s].inverted() * xyz[s]["W"]
m[f"{s}RGB"] = m[s] * Matrix3x3(
[[k[s][0], 0, 0], [0, k[s][1], 0], [0, 0, k[s][2]]]
)
r = m["rRGB"] * m["mRGB"].inverted()
if y_correction:
# The Y calibration factor kY is obtained as the ratio of the reference
# luminance value to the matrix-corrected Y value, as defined in
# Four-Color Matrix Method for Correction of Tristimulus Colorimeters -
# Part 2
mw = xmw, ymw, zmw
ky = yrw / (r * mw)[1]
r[:] = [[ky * v for v in row] for row in r]
return r
def get_gamma(
values: list | tuple,
scale: float = 1.0,
vmin: float = 0.0,
vmax: float = 1.0,
average: bool = True,
least_squares: bool = False,
) -> float | list:
"""Return average or least squares gamma or a list of gamma values.
Args:
values (list): A list of tuples containing x and y values.
scale (float): The scale factor. Defaults to 1.0.
vmin (float): Minimum value. Defaults to 0.0.
vmax (float): Maximum value. Defaults to 1.0.
average (bool): If True, return the average gamma. Defaults to True.
least_squares (bool): If True, return the least squares gamma. Defaults
to False.
Returns:
float | list: The average or least squares gamma, or a list of gamma
values.
"""
if least_squares:
logxy = []
logx2 = []
else:
gammas = []
vmin /= scale
vmax /= scale
for x, y in values:
x /= scale
y = (y / scale - vmin) * (vmax + vmin)
if 0 < x < 1 and y > 0:
if least_squares:
logxy.append(math.log(x) * math.log(y))
logx2.append(math.pow(math.log(x), 2))
else:
gammas.append(math.log(y) / math.log(x))
if average or least_squares:
if least_squares:
if not logxy or not logx2:
return 0
return sum(logxy) / sum(logx2)
if not gammas:
return 0
return sum(gammas) / len(gammas)
return gammas
def guess_cat(
chad: Matrix3x3,
whitepoint_source: None | float | str | list | tuple = None,
whitepoint_destination: None | float | str | list | tuple = None,
) -> None | str:
"""Guess the chromatic adaption transform used in a chromatic adaption matrix.
...as found in an ICC profile's 'chad' tag
Args:
chad (Matrix3x3): The chromatic adaption matrix.
whitepoint_source (tuple): The source whitepoint.
whitepoint_destination (tuple): The destination whitepoint.
Returns:
None | str: The guessed chromatic adaption transform.
"""
if chad == [[1, 0, 0], [0, 1, 0], [0, 0, 1]]:
# Cannot figure out CAT from identity chad
return None
for cat in CAT_MATRICES:
if is_similar_matrix(
(
chad
* CAT_MATRICES[cat].inverted()
* LMS_wp_adaption_matrix(whitepoint_destination, whitepoint_source, cat)
).inverted(),
CAT_MATRICES[cat],
2,
):
return cat
return None
def CIEDCCT2xyY(T: float, scale: float = 1.0) -> tuple[float, float, float]: # noqa: N802, N803
"""Convert from CIE correlated daylight temperature to xyY.
Based on formula from http://brucelindbloom.com/Eqn_T_to_xy.html
Args:
T (float): The temperature in Kelvin.
scale (float): The scale factor. Defaults to 1.0.
Returns:
tuple[float, float, float]: The xyY values.
"""
if isinstance(T, str):
# Assume standard illuminant, e.g. "D50"
return XYZ2xyY(*get_standard_illuminant(T, scale=scale))
if not (2500 <= T <= 25000):
# Lower limit of 2500 is consistent with Argyll xicc/xspect.c daylight_il
# Actual usable lower limit lies at roughly 2244
return None
if T < 4000:
# Only accurate down to about 4000
warnings.warn(
"Daylight CCT is only accurate down to about 4000 K",
Warning,
stacklevel=2,
)
if T <= 7000:
xd = (
((-4.607 * math.pow(10, 9)) / math.pow(T, 3))
+ ((2.9678 * math.pow(10, 6)) / math.pow(T, 2))
+ ((0.09911 * math.pow(10, 3)) / T)
+ 0.244063
)
else:
xd = (
((-2.0064 * math.pow(10, 9)) / math.pow(T, 3))
+ ((1.9018 * math.pow(10, 6)) / math.pow(T, 2))
+ ((0.24748 * math.pow(10, 3)) / T)
+ 0.237040
)
yd = -3 * math.pow(xd, 2) + 2.87 * xd - 0.275
return xd, yd, scale
def CIEDCCT2XYZ(T: float, scale: float = 1.0) -> tuple[float, float, float]: # noqa: N802, N803
"""Convert from CIE correlated daylight temperature to XYZ.
Args:
T (float): The temperature in Kelvin.
scale (float): The scale factor. Defaults to 1.0.
Returns:
tuple[float, float, float]: The XYZ values.
"""
xyY = CIEDCCT2xyY(T, scale) # noqa: N806
return xyY2XYZ(*xyY) if xyY else None # noqa: N806
def cLUT65_to_VidRGB(v: float, size: int = 65) -> float: # noqa: N802
"""cLUT65 to VidRGB conversion.
cLUT Input value tweaks to make Video encoded black land on
65 res grid nodes, which should help 33 and 17 res cLUTs too.
Args:
v (float): The value to convert.
size (int): The size of the LUT. Defaults to 65.
Returns:
float: The converted value.
"""
if v <= 236.0 / 256:
# Scale up to near black point
return v * 256.0 / 255
return 1 - (1 - v) * (1 - 236.0 / 255) / (1 - 236.0 / 256)
def VidRGB_to_cLUT65(v: float, size: int = 65) -> float: # noqa: N802
"""Convert from VidRGB to cLUT65.
Args:
v (float): The value to convert.
size (int): The size of the LUT. Defaults to 65.
Returns:
float: The converted value.
"""
if v <= 236.0 / 255.0:
return v * 255.0 / 256
return 1 - (1 - v) * (1 - 236.0 / 256) / (1 - 236.0 / 255)
def VidRGB_to_eeColor(v: float) -> float: # noqa: N802
"""Convert from VidRGB to eeColor.
Args:
v (float): The value to convert.
Returns:
float: The converted value.
"""
return v * 255.0 / 256.0
def eeColor_to_VidRGB(v: float) -> float: # noqa: N802
"""Convert from eeColor to VidRGB.
Args:
v (float): The value to convert.
Returns:
float: The converted value.
"""
return v * 256.0 / 255.0
def DIN992Lab( # noqa: N802
l99: float,
a99: float,
b99: float,
kCH: float = 1.0, # noqa: N803
kE: float = 1.0, # noqa: N803
) -> tuple[float, float, float]:
"""Convert from DIN99 to Lab.
Args:
l99 (float): The L value of the color.
a99 (float): The a value of the color.
b99 (float): The b value of the color.
kCH (float, optional): The kCH value of the color. Defaults to 1.0.
kE (float, optional): The kE value of the color. Defaults to 1.0.
Returns:
tuple[float, float, float]: The L, a, b values.
"""
c99, h99 = DIN99familyab2DIN99CH(a99, b99)
return DIN99familyLCH2Lab(
l99, c99, h99, 0, 105.51, 0.0158, 16, 0.7, 1 / (0.045 * kCH * kE), 0.045, kE, 0
)
def DIN99b2Lab(l99: float, a99: float, b99: float) -> tuple[float, float, float]: # noqa: N802, N803
"""Convert from DIN99b to Lab.
Args:
l99 (float): The L value of the color.
a99 (float): The a value of the color.
b99 (float): The b value of the color.
Returns:
tuple[float, float, float]: The L, a, b values.
"""
c99, h99 = DIN99familyab2DIN99CH(a99, b99)
return DIN99familyLCH2Lab(l99, c99, h99, 0, 303.67, 0.0039, 26, 0.83, 23, 0.075)
def DIN99o2Lab( # noqa: N802
l99: float,
a99: float,
b99: float,
kCH: float = 1.0, # noqa: N803
kE: float = 1.0, # noqa: N803
) -> tuple[float, float, float]:
"""Convert from DIN99o to Lab.
Args:
l99 (float): The L value of the color.
a99 (float): The a value of the color.
b99 (float): The b value of the color.
kCH (float, optional): The kCH value of the color. Defaults to 1.0.
kE (float, optional): The kE value of the color. Defaults to 1.0.
Returns:
tuple[float, float, float]: The L, a, b values.
"""
c99, h99 = DIN99familyab2DIN99CH(a99, b99)
return DIN99familyLCH2Lab(
l99, c99, h99, 0, 303.67, 0.0039, 26, 0.83, 1 / (0.0435 * kCH * kE), 0.075, kE
)
def DIN99bLCH2Lab(l99: float, c99: float, h99: float) -> tuple[float, float, float]: # noqa: N802, N803
"""Convert from DIN99bLCH to Lab.
Args:
l99 (float): The L value of the color.
c99 (float): The C value of the color.
h99 (float): The H value of the color.
Returns:
tuple[float, float, float]: The L, a, b values.
"""
return DIN99familyLCH2Lab(l99, c99, h99, 0, 303.67, 0.0039, 26, 0.83, 23, 0.075)
def DIN99c2Lab( # noqa: N802
l99: float, # noqa: N803
a99: float,
b99: float,
whitepoint: None | float | str | list | tuple = None,
) -> tuple[float, float, float]:
"""Convert from DIN99c to Lab.
Args:
l99 (float): The L value of the color.
a99 (float): The a value of the color.
b99 (float): The b value of the color.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
Returns:
tuple[float, float, float]: The L, a, b values.
"""
c99, h99 = DIN99familyab2DIN99CH(a99, b99)
return DIN99familyLCH2Lab(
l99, c99, h99, 0.1, 317.651, 0.0037, 0, 0.94, 23, 0.066, whitepoint
)
def DIN99d2Lab( # noqa: N802
l99: float, # noqa: N803
a99: float,
b99: float,
whitepoint: None | float | str | list | tuple = None,
) -> tuple[float, float, float]:
"""Convert from DIN99d to Lab.
Args:
l99 (float): The L value of the color.
a99 (float): The a value of the color.
b99 (float): The b value of the color.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
Returns:
tuple[float, float, float]: The L, a, b values.
"""
c99, h99 = DIN99familyab2DIN99CH(a99, b99)
return DIN99familyLCH2Lab(
l99, c99, h99, 0.12, 325.221, 0.0036, 50, 1.14, 22.5, 0.06, whitepoint
)
def DIN99dLCH2Lab( # noqa: N802
l99: float, # noqa: N803
c99: float, # noqa: N803
h99: float, # noqa: N803
whitepoint: None | float | str | list | tuple = None,
) -> tuple[float, float, float]:
"""Convert from DIN99dLCH to Lab.
Args:
l99 (float): The L value of the color.
c99 (float): The C value of the color.
h99 (float): The H value of the color.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
Returns:
tuple[float, float, float]: The L, a, b values.
"""
return DIN99familyLCH2Lab(
l99, c99, h99, 0.12, 325.221, 0.0036, 50, 1.14, 22.5, 0.06, whitepoint
)
def DIN99familyLCH2Lab( # noqa: N802
l99: float, # noqa: N803
c99: float, # noqa: N803
h99: float, # noqa: N803
x: float,
l1: float,
l2: float,
deg: float,
f1: float,
c1: float,
c2: float,
whitepoint: None | float | str | list | tuple = None,
kE: float = 1.0, # noqa: N803
hdeg: None | float = None,
) -> tuple[float, float, float]:
"""Convert from DIN99LCH to Lab.
Args:
l99 (float): The L value of the color.
c99 (float): The C value of the color.
h99 (float): The H value of the color.
x (float): The x value of the color.
l1 (float): The l1 value of the color.
l2 (float): The l2 value of the color.
deg (float): The degree value of the color.
f1 (float): The f1 value of the color.
c1 (float): The c1 value of the color.
c2 (float): The c2 value of the color.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
kE (float, optional): The kE value of the color. Defaults to 1.0.
hdeg (None | float, optional): The hdeg value of the color. Defaults to
None.
Returns:
tuple[float, float, float]: The L, a, b values.
"""
g = (math.exp(c99 / c1) - 1) / c2
if hdeg is None:
hdeg = deg
h99 -= hdeg
l, a, b = DIN99familyLHCG2Lab(l99, h99, c99, g, kE, l1, l2, deg, f1)
if x:
whitepoint99d = XYZ2DIN99cdXYZ(*get_whitepoint(whitepoint, 100), x=x)
X, Y, Z = Lab2XYZ(l, a, b, whitepoint99d, scale=100) # noqa: N806
X, Y, Z = DIN99cdXYZ2XYZ(X, Y, Z, x) # noqa: N806
l, a, b = XYZ2Lab(X, Y, Z, whitepoint)
return l, a, b
def DIN99cdXYZ2XYZ( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
x: float,
) -> tuple[float, float, float]:
"""Convert from DIN99cdXYZ to XYZ.
Args:
X (float): The X value of the color.
Y (float): The Y value of the color.
Z (float): The Z value of the color.
x (float): The x value of the color.
Returns:
tuple[float, float, float]: The X, Y, Z values.
"""
X = (X + x * Z) / (1 + x) # noqa: N806
return X, Y, Z
def DIN99familyLHCG2Lab( # noqa: N802
l99: float, # noqa: N803
h99: float, # noqa: N803
c99: float, # noqa: N803
G: float, # noqa: N803
kE: float, # noqa: N803
l1: float,
l2: float,
deg: float,
f1: float,
) -> tuple[float, float, float]:
"""Convert from DIN99LCH to Lab.
Args:
l99 (float): The L value of the color.
h99 (float): The H value of the color.
c99 (float): The C value of the color.
G (float): The G value of the color.
kE (float): The kE value of the color.
l1 (float): The l1 value of the color.
l2 (float): The l2 value of the color.
deg (float): The degree value of the color.
f1 (float): The f1 value of the color.
Returns:
tuple[float, float, float]: The L, a, b values.
"""
l = (math.exp((l99 * kE) / l1) - 1) / l2
h99ef = h99 * math.pi / 180
e = G * math.cos(h99ef)
f = G * math.sin(h99ef)
rad = deg * math.pi / 180
a = e * math.cos(rad) - (f / f1) * math.sin(rad)
b = e * math.sin(rad) + (f / f1) * math.cos(rad)
return l, a, b
def DIN99familyCH2DIN99ab(c99: float, h99: float) -> tuple[float, float]: # noqa: N802, N803
"""Convert from DIN99CH to DIN99ab.
Args:
c99 (float): The C value of the color.
h99 (float): The H value of the color.
Returns:
tuple[float, float]: The a99 and b99 values.
"""
h99ef = h99 * math.pi / 180
return c99 * math.cos(h99ef), c99 * math.sin(h99ef)
def DIN99familyab2DIN99CH(a99: float, b99: float) -> tuple[float, float]: # noqa: N802
"""Convert from DIN99ab to DIN99CH.
Args:
a99 (float): The a value of the color.
b99 (float): The b value of the color.
Returns:
tuple[float, float]: The c99 and h99 values.
"""
c99 = math.sqrt(math.pow(a99, 2) + math.pow(b99, 2))
if a99 > 0:
h99ef = math.atan2(b99, a99) if b99 >= 0 else 2 * math.pi + math.atan2(b99, a99)
elif a99 < 0:
h99ef = math.atan2(b99, a99)
elif b99 > 0:
h99ef = math.pi / 2
elif b99 < 0:
h99ef = (3 * math.pi) / 2
else:
h99ef = 0.0
h99 = h99ef * 180 / math.pi
return c99, h99
def HSI2RGB( # noqa: N802
H: float, # noqa: N803
S: float, # noqa: N803
I: float, # noqa: N803
scale: float = 1.0,
) -> tuple[float, float, float]:
"""Convert from HSI to RGB.
Args:
H (float): The hue value of the color.
S (float): The saturation value of the color.
I (float): The intensity value of the color.
scale (float): The scale factor to apply to the RGB values.
Returns:
tuple[float, float, float]: The R, G, B values.
"""
H *= 360 # noqa: N806
h = H
if 120 < H <= 240:
h -= 120
elif 240 < H <= 360:
h -= 240
f = math.cos(math.radians(h)) / math.cos(math.radians(60 - h))
a = I + I * S * f
b = I + I * S * (1 - f)
c = I - I * S
if H <= 120:
r = a
g = b
b = c
elif H <= 240:
g = a
b = b
r = c
else:
b = a
r = b
g = c
return tuple(v * scale for v in (r, g, b))
def HSL2RGB( # noqa: N802
H: float, # noqa: N803
S: float, # noqa: N803
L: float, # noqa: N803
scale: float = 1.0,
) -> tuple[float, float, float]:
"""Convert from HSL to RGB.
Args:
H (float): The hue value of the color.
S (float): The saturation value of the color.
L (float): The lightness value of the color.
scale (float): The scale factor to apply to the RGB values.
Returns:
tuple[float, float, float]: The R, G, B values.
"""
return tuple(v * scale for v in colorsys.hls_to_rgb(H, L, S))
def HSV2RGB( # noqa: N802
H: float, # noqa: N803
S: float, # noqa: N803
V: float, # noqa: N803
scale: float = 1.0,
) -> tuple[float, float, float]:
"""Convert from HSV to RGB.
Args:
H (float): The hue value of the color.
S (float): The saturation value of the color.
V (float): The value (brightness) of the color.
scale (float): The scale factor to apply to the RGB values.
Returns:
tuple[float, float, float]: The R, G, B values.
"""
return tuple(v * scale for v in colorsys.hsv_to_rgb(H, S, V))
def get_dbl_min() -> float:
"""Get the smallest positive normalized double value.
Returns:
float: The smallest positive normalized double value.
"""
t = "0.0"
i = 10
n = 0
dbl_min = 0.0
while True:
if i > 1:
i -= 1
else:
t += "0"
i = 9
if float(t + str(i)) == 0.0:
if n > 1:
break
n += 1
t += str(i)
i = 10
else:
if n > 1:
n -= 1
dbl_min = float(t + str(i))
return dbl_min
DBL_MIN = get_dbl_min()
def LCHab2Lab(L: float, C: float, H: float) -> tuple[float, float, float]: # noqa: N802, N803
"""Convert from LCHab to Lab.
Args:
L (float): The L value of the color.
C (float): The C value of the color.
H (float): The H value of the color.
Returns:
tuple[float, float, float]: The L, a, b values.
"""
a = C * math.cos(H * math.pi / 180.0)
b = C * math.sin(H * math.pi / 180.0)
return L, a, b
def Lab2DIN99( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
kCH: float = 1.0, # noqa: N803
kE: float = 1.0, # noqa: N803
) -> tuple[float, float, float]:
"""Convert from Lab to DIN99.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
kCH (float): The kCH value. Defaults to 1.0.
kE (float): The kE value. Defaults to 1.0.
Returns:
tuple[float, float, float]: The l99, a99, b99 values.
"""
l99, c99, h99 = Lab2DIN99LCH(L, a, b, kCH, kE)
a99, b99 = DIN99familyCH2DIN99ab(c99, h99)
return l99, a99, b99
def Lab2DIN99b( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
kE: float = 1.0, # noqa: N803
) -> tuple[float, float, float]:
"""Convert from Lab to DIN99b.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
kE (float): The kE value. Defaults to 1.0.
Returns:
tuple[float, float, float]: The l99, a99, b99 values.
"""
l99, c99, h99 = Lab2DIN99bLCH(L, a, b, kE)
a99, b99 = DIN99familyCH2DIN99ab(c99, h99)
return l99, a99, b99
def Lab2DIN99o( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
kCH: float = 1.0, # noqa: N803
kE: float = 1.0, # noqa: N803
) -> tuple[float, float, float]:
"""Convert from Lab to DIN99o.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
kCH (float): The kCH value.
kE (float): The kE value.
Returns:
tuple[float, float, float]: The l99, a99, b99 values.
"""
l99, c99, h99 = Lab2DIN99oLCH(L, a, b, kCH, kE)
a99, b99 = DIN99familyCH2DIN99ab(c99, h99)
return l99, a99, b99
def Lab2DIN99c( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
kE: float = 1.0, # noqa: N803
whitepoint: None | float | str | list | tuple = None,
) -> tuple[float, float, float]:
"""Convert from Lab to DIN99c.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
kE (float): The kE value. Defaults to 1.0. Unused, but kept for
compatibility.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
Returns:
tuple[float, float, float]: The l99, a99, b99 values.
"""
return XYZ2DIN99c(*Lab2XYZ(L, a, b, whitepoint, scale=100), whitepoint)
def Lab2DIN99d( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
kE: float = 1.0, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from Lab to DIN99d.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
kE (float, optional): The kE value. Currently not used.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
Returns:
tuple[float, float, float]: The l99, a99, b99 values.
"""
return XYZ2DIN99d(*Lab2XYZ(L, a, b, whitepoint, scale=100), whitepoint)
def Lab2DIN99LCH( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
kCH: float = 1.0, # noqa: N803
kE: float = 1.0, # noqa: N803
) -> tuple[float, float, float]:
"""Convert from Lab to DIN99 LCH.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
kCH (float): The kCH value.
kE (float): The kE value.
Returns:
tuple[float, float, float]: The l99, c99, h99 values.
"""
return Lab2DIN99familyLCH(
L, a, b, 105.51, 0.0158, 16, 0.7, 1 / (0.045 * kCH * kE), 0.045, kE, 0
)
def Lab2DIN99bLCH( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
kE: float = 1.0, # noqa: N803
) -> tuple[float, float, float]:
"""Convert from Lab to DIN99b LCH.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
kE (float): The kE value. Unused, but kept for compatibility.
Returns:
tuple[float, float, float]: The l99, c99, h99 values.
"""
return Lab2DIN99familyLCH(L, a, b, 303.67, 0.0039, 26, 0.83, 23, 0.075)
def Lab2DIN99oLCH( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
kCH: float = 1.0, # noqa: N803
kE: float = 1.0, # noqa: N803
) -> tuple[float, float, float]:
"""Convert from Lab to DIN99o LCH.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
kCH (float, optional): The kCH value. Defaults to 1.0.
kE (float, optional): The kE value. Defaults to 1.0.
Returns:
tuple[float, float, float]: The l99, c99, h99 values.
"""
return Lab2DIN99familyLCH(
L, a, b, 303.67, 0.0039, 26, 0.83, 1 / (0.0435 * kCH * kE), 0.075, kE
)
def Lab2DIN99familyLCH( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
l1: float,
l2: float,
deg: float,
f1: float,
c1: float,
c2: float,
kE: float = 1.0, # noqa: N803
hdeg: None | float = None,
) -> tuple[float, float, float]:
"""Convert from Lab to DIN99 family LCH.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
l1 (float): The l1 value.
l2 (float): The l2 value.
deg (float): The degree value.
f1 (float): The f1 value.
c1 (float): The c1 value.
c2 (float): The c2 value.
kE (float): The kE value.
hdeg (None | float): The hdeg value. Defaults to None.
Returns:
tuple[float, float, float]: The l99, c99, h99 values.
"""
l99, g, h99ef, _ = Lab2DIN99familyLGhrad(L, a, b, kE, l1, l2, deg, f1)
c99 = c1 * math.log(1 + c2 * g)
if hdeg is None:
hdeg = deg
h99 = h99ef * 180 / math.pi + hdeg
return l99, c99, h99
def Lab2DIN99familyLGhrad( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
kE: float, # noqa: N803
l1: float,
l2: float,
deg: float,
f1: float,
) -> tuple[float, float, float, float]:
"""Convert from Lab to DIN99 family LCH.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
kE (float): The kE value.
l1 (float): The l1 value.
l2 (float): The l2 value.
deg (float): The degree value.
f1 (float): The f1 value.
Returns:
tuple[float, float, float, float]: The l99, G, h99ef values.
"""
l99 = (1.0 / kE) * l1 * math.log(1 + l2 * L)
rad = deg * math.pi / 180
if rad != 0:
ar = math.cos(rad) # a rotation term
br = math.sin(rad) # b rotation term
e = a * ar + b * br
f = f1 * (b * ar - a * br)
else:
e = a
f = f1 * b
g = math.sqrt(math.pow(e, 2) + math.pow(f, 2))
h99ef = math.atan2(f, e)
return l99, g, h99ef, rad
def Lab2LCHab(L: float, a: float, b: float) -> tuple[float, float, float]: # noqa: N802, N803
"""Convert from Lab to LCHab.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
Returns:
tuple[float, float, float]: The LCHab values.
"""
c = math.sqrt(math.pow(a, 2) + math.pow(b, 2))
h = 180.0 * math.atan2(b, a) / math.pi
if h < 0.0:
h += 360.0
return L, c, h
def Lab2Luv( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
whitepoint: None | float | str | list | tuple = None,
scale: float = 100,
) -> tuple[float, float, float]:
"""Convert from Lab to Luv.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
scale (float): The scale factor to apply to the output values.
Defaults to 100.
Returns:
tuple[float, float, float]: The Luv values.
"""
return XYZ2Luv(*Lab2XYZ(L, a, b, whitepoint, scale), whitepoint)
def Lab2RGB( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
rgb_space: None | str | list | tuple = None,
scale: float = 1.0,
round_: bool = False,
clamp: bool = True,
whitepoint: None | float | str | list | tuple = None,
whitepoint_source: None | float | str | list | tuple = None,
noadapt: bool = False,
cat: str = "Bradford",
) -> list[float]:
"""Convert from Lab to RGB.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
rgb_space (str or tuple): The RGB space to use. Defaults to sRGB.
scale (float): The scale factor to apply to the output values.
Defaults to 1.0.
round_ (bool): Whether to round the output values. Defaults to False.
clamp (bool): Whether to clamp the output values. Defaults to True.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
whitepoint_source (None | float | str | list | tuple): The source
whitepoint to use. Defaults to D50.
noadapt (bool): Whether to skip chromatic adaptation. Defaults to False.
cat (str): The chromatic adaptation transform to use. Defaults to
"Bradford".
Returns:
list[float]: The RGB values.
"""
x, y, z = Lab2XYZ(L, a, b, whitepoint)
if not noadapt:
rgb_space = get_rgb_space(rgb_space)
x, y, z = adapt(x, y, z, whitepoint_source, rgb_space[1], cat)
return XYZ2RGB(x, y, z, rgb_space, scale, round_, clamp)
def Lab2XYZ( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
whitepoint: None | float | str | list | tuple = None,
scale: float = 1.0,
) -> tuple[float, float, float]:
"""Convert from Lab to XYZ.
The input L value needs to be in the nominal range [0.0, 100.0] and
other input values scaled accordingly.
The output XYZ values are in the nominal range [0.0, scale].
whitepoint can be string (e.g. "D50"), a tuple of XYZ coordinates or
color temperature as float or int. Defaults to D50 if not set.
Based on formula from http://brucelindbloom.com/Eqn_Lab_to_XYZ.html
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
scale (float): The scale factor to apply to the output values.
Defaults to 1.0.
Returns:
tuple[float, float, float]: The XYZ values.
"""
fy = (L + 16) / 116.0
fx = a / 500.0 + fy
fz = fy - b / 200.0
if math.pow(fx, 3.0) > LSTAR_E:
xr = math.pow(fx, 3.0)
else:
xr = (116.0 * fx - 16) / LSTAR_K
yr = math.pow((L + 16) / 116.0, 3.0) if L > LSTAR_K * LSTAR_E else L / LSTAR_K
zr = (
math.pow(fz, 3.0)
if math.pow(fz, 3.0) > LSTAR_E
else (116.0 * fz - 16) / LSTAR_K
)
Xr, Yr, Zr = get_whitepoint(whitepoint, scale) # noqa: N806
return (xr * Xr), (yr * Yr), (zr * Zr)
def Lab2xyY( # noqa: N802
L: float, # noqa: N803
a: float,
b: float,
whitepoint: None | float | str | list | tuple = None,
scale: float = 1.0,
) -> tuple[float, float, float]:
"""Convert from Lab to xyY.
Args:
L (float): The L value of the color.
a (float): The a value of the color.
b (float): The b value of the color.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
scale (float): The scale factor to apply to the output values.
Defaults to 1.0.
Returns:
tuple[float, float, float]: The xyY values.
"""
return XYZ2xyY(*Lab2XYZ(L, a, b, whitepoint, scale), whitepoint)
def Luv2LCHuv(L: float, u: float, v: float) -> tuple[float, float, float]: # noqa: N802, N803
"""Convert from Luv to LCHuv.
Args:
L (float): The L value of the color.
u (float): The u' value of the color.
v (float): The v' value of the color.
Returns:
tuple[float, float, float]: The LCHuv values.
"""
c = math.sqrt(math.pow(u, 2) + math.pow(v, 2))
h = 180.0 * math.atan2(v, u) / math.pi
if h < 0.0:
h += 360.0
return L, c, h
def Luv2RGB( # noqa: N802
L: float, # noqa: N803
u: float,
v: float,
rgb_space: None | str | list | tuple = None,
scale: float = 1.0,
round_: bool = False,
clamp: bool = True,
whitepoint: None | float | str | list | tuple = None,
) -> list[float]:
"""Convert from Luv to RGB.
Args:
L (float): The L value of the color.
u (float): The u' value of the color.
v (float): The v' value of the color.
rgb_space (str or tuple): The RGB space to use. Defaults to sRGB.
scale (float): The scale factor to apply to the output values.
Defaults to 1.0.
round_ (bool): Whether to round the output values. Defaults to False.
clamp (bool): Whether to clamp the output values. Defaults to True.
whitepoint (None | float | str | list | tuple): The whitepoint to
use. Defaults to D50.
Returns:
tuple[float, float, float]: The RGB values.
"""
return XYZ2RGB(*Luv2XYZ(L, u, v, whitepoint), rgb_space, scale, round_, clamp)
def u_v_2xy(u: float, v: float) -> tuple[float, float]:
"""Convert from u'v' to xy.
Args:
u (float): The u' value of the color.
v (float): The v' value of the color.
Returns:
tuple[float, float]: The xy values.
"""
x = (9.0 * u) / (6 * u - 16 * v + 12)
y = (4 * v) / (6 * u - 16 * v + 12)
return x, y
def Luv2XYZ( # noqa: N802
L: float, # noqa: N803
u: float,
v: float,
whitepoint: None | str | float | list | tuple = None,
scale: float = 1.0,
) -> tuple[float, float, float]:
"""Convert from Luv to XYZ.
Args:
L (float): The L value of the color.
u (float): The u' value of the color.
v (float): The v' value of the color.
whitepoint (str or tuple): The whitepoint to use. Defaults to D50.
scale (float): The scale factor to apply to the output values.
Defaults to 1.0.
Returns:
tuple[float, float, float]: The XYZ values.
"""
xr, yr, zr = get_whitepoint(whitepoint)
y = math.pow((L + 16.0) / 116.0, 3) if L > LSTAR_K * LSTAR_E else L / LSTAR_K
uo = (4.0 * xr) / (xr + 15.0 * yr + 3.0 * zr)
vo = (9.0 * yr) / (xr + 15.0 * yr + 3.0 * zr)
a = (1.0 / 3.0) * (((52.0 * L) / (u + 13 * L * uo)) - 1)
b = -5.0 * y
c = -(1.0 / 3.0)
d = y * (((39.0 * L) / (v + 13 * L * vo)) - 5)
x = (d - b) / (a - c)
z = x * a + b
return tuple([v * scale for v in (x, y, z)])
def RGB2HSI( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
scale: float = 1.0,
) -> tuple[float, float, float]:
"""Convert from RGB to HSI.
The input RGB values need to be in the nominal range [0.0, 1.0] and
the output HSI values are in the nominal range [0.0, scale].
Args:
R (float): The red value of the color.
G (float): The green value of the color.
B (float): The blue value of the color.
scale (float): The scale factor to apply to the output values.
Defaults to 1.0.
Returns:
tuple[float, float, float]: The HSI values.
"""
i = (R + G + B) / 3.0
s = 1 - min(R, G, B) / i if i else 0
if not R == G == B:
h = math.atan2(math.sqrt(3) * (G - B), 2 * R - G - B) / math.pi / 2
if h < 0:
h += 1.0
if h > 1:
h -= 1.0
else:
h = 0
return h * scale, s * scale, i * scale
def RGB2HSL( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
scale: float = 1.0,
) -> tuple[float, float, float]:
"""Convert from RGB to HSL.
The input RGB values need to be in the nominal range [0.0, 1.0] and
the output HSL values are in the nominal range [0.0, scale].
Args:
R (float): The red value of the color.
G (float): The green value of the color.
B (float): The blue value of the color.
scale (float): The scale factor to apply to the output values.
Defaults to 1.0.
Returns:
tuple[float, float, float]: The HSL values.
"""
h, l, s = colorsys.rgb_to_hls(R, G, B)
return tuple(v * scale for v in (h, s, l))
def RGB2HSV( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
scale: float = 1.0,
) -> tuple[float, float, float]:
"""Convert from RGB to HSV.
The input RGB values need to be in the nominal range [0.0, 1.0] and
the output HSV values are in the nominal range [0.0, scale].
Args:
R (float): The red value of the color.
G (float): The green value of the color.
B (float): The blue value of the color.
scale (float): The scale factor to apply to the output values.
Defaults to 1.0.
Returns:
tuple[float, float, float]: The HSV values.
"""
return tuple(v * scale for v in colorsys.rgb_to_hsv(R, G, B))
def LinearRGB2ICtCp( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
oetf: None | Callable = None,
) -> tuple[float, float, float]:
"""Rec. 2020 linear RGB to non-linear ICtCp.
http://www.dolby.com/us/en/technologies/dolby-vision/ICtCp-white-paper.pdf
"""
if oetf is None:
def oetf(FD: float) -> float: # noqa: N803
"""Default OETF for Rec. 2020.
Args:
FD (float): The value to apply the OETF to.
Returns:
float: The transformed value.
"""
return special_pow(FD, 1.0 / -2084)
lms = LinearRGB2LMS_matrix * (R, G, B)
l_, m_, s_ = (oetf(FD) for FD in lms)
i, ct, cp = L_M_S_2ICtCp_matrix * (l_, m_, s_)
return i, ct, cp
def ICtCp2LinearRGB( # noqa: N802
I: float, # noqa: N803
Ct: float, # noqa: N803
Cp: float, # noqa: N803
eotf: None | Callable = None,
) -> tuple[float, float, float]:
"""Non-linear ICtCp to Rec. 2020 linear RGB.
http://www.dolby.com/us/en/technologies/dolby-vision/ICtCp-white-paper.pdf
Args:
I (float): The I value of the color.
Ct (float): The Ct value of the color.
Cp (float): The Cp value of the color.
eotf (function): The electro-optical transfer function to use.
Defaults to the Rec. 2020 EOTF.
This function should take a single argument and return a float.
The default function is the Rec. 2020 OETF.
See the `special_pow` function for more details.
Returns:
tuple[float, float, float]: The RGB values.
"""
if eotf is None:
def eotf(v: float) -> float:
"""Default EOTF for Rec. 2020.
Args:
v (float): The value to apply the EOTF to.
Returns:
float: The transformed value.
"""
return special_pow(v, -2084)
l_m_s_ = ICtCp2L_M_S__matrix * (I, Ct, Cp)
l, m, s = (eotf(v) for v in l_m_s_)
return LMS2LinearRGB_matrix * (l, m, s)
def RGB2ICtCp( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
rgb_space: None | str | list | tuple = "Rec. 2020",
eotf: None | Callable = None,
clamp: bool = False,
oetf: None | Callable = None,
) -> tuple[float, float, float]:
"""R'G'B' to ICtCp.
Args:
R (float): The R' value of the color.
G (float): The G' value of the color.
B (float): The B' value of the color.
rgb_space (str): The RGB space to use for conversion. Defaults to
"Rec. 2020".
eotf (None | callable): The electro-optical transfer function to use.
Defaults to the Rec. 2020 EOTF.
This function should take a single argument and return a float.
The default function is the inverse of the Rec. 2020 EOTF.
See the `special_pow` function for more details.
clamp (bool): If True, clamp the output values to [0, 1].
Defaults to False.
oetf (None | callable): The opto-electrical transfer function to use.
Defaults to the Rec. 2020 OETF.
This function should take a single argument and return a float.
The default function is the Rec. 2020 OETF.
See the `special_pow` function for more details.
Returns:
tuple[float, float, float]: The ICtCp values.
"""
if eotf is None:
def eotf(v: float) -> float:
"""Default EOTF for Rec. 2020.
Args:
v (float): The value to apply the EOTF to.
Returns:
float: The transformed value.
"""
return special_pow(v, -2084)
if oetf is None:
def oetf(E: float) -> float: # noqa: N803
"""Default OETF for Rec. 2020.
Args:
E (float): The value to apply the OETF to.
Returns:
float: The transformed value.
"""
return special_pow(E, 1.0 / -2084)
return XYZ2ICtCp(*RGB2XYZ(R, G, B, rgb_space, eotf=eotf), clamp, oetf)
def ICtCp2RGB( # noqa: N802
I: float, # noqa: N803
Ct: float, # noqa: N803
Cp: float, # noqa: N803
rgb_space: None | str | list | tuple = "Rec. 2020",
eotf: None | Callable = None,
clamp: bool = False,
oetf: None | Callable = None,
) -> list[float]:
"""ICtCp to R'G'B'.
Args:
I (float): The I value of the color.
Ct (float): The Ct value of the color.
Cp (float): The Cp value of the color.
rgb_space (str): The RGB space to use for conversion. Defaults to
"Rec. 2020".
eotf (None | callable): The electro-optical transfer function to use.
Defaults to the Rec. 2020 EOTF.
This function should take a single argument and return a float.
The default function is the inverse of the Rec. 2020 EOTF.
See the `special_pow` function for more details.
clamp (bool): If True, clamp the output values to [0, 1].
Defaults to False.
oetf (None | callable): The opto-electrical transfer function to use.
Defaults to the Rec. 2020 OETF.
This function should take a single argument and return a float.
The default function is the Rec. 2020 OETF.
See the `special_pow` function for more details.
Returns:
tuple: The RGB values.
"""
if eotf is None:
def eotf(v: float) -> float:
"""Default EOTF for Rec. 2020.
Args:
v (float): The value to apply the EOTF to.
Returns:
float: The transformed value.
"""
return special_pow(v, -2084)
if oetf is None:
def oetf(E: float) -> float: # noqa: N803
"""Default OETF for Rec. 2020.
Args:
E (float): The value to apply the OETF to.
Returns:
float: The transformed value.
"""
return special_pow(E, 1.0 / -2084)
return XYZ2RGB(*ICtCp2XYZ(I, Ct, Cp, eotf), rgb_space, clamp=clamp, oetf=oetf)
def XYZ2ICtCp( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
clamp: bool = False,
oetf: None | Callable = None,
) -> tuple[float, float, float]:
"""XYZ to ICtCp.
Args:
X (float): The X value of the color.
Y (float): The Y value of the color.
Z (float): The Z value of the color.
clamp (bool): If True, clamp the output values to [0, 1].
Defaults to False.
oetf (function): The opto-electrical transfer function to use.
Defaults to the Rec. 2020 OETF.
This function should take a single argument and return a float.
The default function is the Rec. 2020 OETF.
See the `special_pow` function for more details.
Returns:
tuple: The ICtCp values.
"""
if oetf is None:
def oetf(E: float) -> float: # noqa: N803
"""Default OETF for Rec. 2020.
Args:
E (float): The value to apply the OETF to.
Returns:
float: The transformed value.
"""
return special_pow(E, 1.0 / -2084)
return LinearRGB2ICtCp(
*XYZ2RGB(X, Y, Z, "Rec. 2020", clamp=clamp, oetf=lambda v: v), oetf
)
def ICtCp2XYZ(I: float, Ct: float, Cp: float, eotf: None | Callable = None) -> tuple: # noqa: N802, N803
"""ICtCp to XYZ.
Args:
I (float): The I value of the color.
Ct (float): The Ct value of the color.
Cp (float): The Cp value of the color.
eotf (function): The electro-optical transfer function to use.
Defaults to the Rec. 2020 EOTF.
This function should take a single argument and return a float.
The default function is the inverse of the Rec. 2020 EOTF.
See the `special_pow` function for more details.
Returns:
tuple: The XYZ values.
"""
if eotf is None:
def eotf(v: float) -> float:
"""Default EOTF for Rec. 2020.
Args:
v (float): The value to apply the EOTF to.
Returns:
float: The transformed value.
"""
return special_pow(v, -2084)
return RGB2XYZ(*ICtCp2LinearRGB(I, Ct, Cp, eotf), "Rec. 2020", eotf=lambda v: v)
def RGB2Lab( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
rgb_space: None | str | list | tuple = None,
whitepoint: None | float | str | list | tuple = None,
noadapt: bool = False,
cat: str = "Bradford",
) -> tuple[float, float, float]:
"""Convert from RGB to Lab.
Args:
R (float): The R' value of the color.
G (float): The G' value of the color.
B (float): The B' value of the color.
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or
int). The gamma should be a float. The RGB primaries red,
green, blue should be lists or tuples of xyY coordinates
(only x and y will be used, so Y can be zero or None).
whitepoint (None | str | tuple): The whitepoint to use for conversion.
If None, the whitepoint of the RGB space will be used.
If a string is given, it must be a valid whitepoint name.
If a tuple is given, it must be in the format (X, Y, Z).
The whitepoint can also be a color temperature in degrees K
(float or int).
noadapt (bool): If True, no chromatic adaptation will be applied.
Defaults to False.
cat (str): The chromatic adaptation transform to use. Defaults to
"Bradford". Other options include "VonKries" and "CAT02".
See the `adapt` function for more details.
Returns:
tuple[float, float, float]: The Lab values.
"""
x, y, z = RGB2XYZ(R, G, B, rgb_space, scale=100)
if not noadapt:
rgb_space = get_rgb_space(rgb_space)
x, y, z = adapt(x, y, z, rgb_space[1], whitepoint, cat)
return XYZ2Lab(x, y, z, whitepoint=whitepoint)
def RGB2XYZ( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
rgb_space: None | str | list | tuple = None,
scale: float = 1.0,
eotf: None | Callable = None,
) -> tuple[float, float, float]:
"""Convert from RGB to XYZ.
Use optional RGB colorspace definition, which can be a named colorspace
(e.g. "CIE RGB") or must be a tuple in the following format:
(gamma, whitepoint, red, green, blue)
whitepoint can be a string (e.g. "D50"), a tuple of XYZ coordinates,
or a color temperatur in degrees K (float or int). Gamma should be a float.
The RGB primaries red, green, blue should be lists or tuples of xyY
coordinates (only x and y will be used, so Y can be zero or None).
If no colorspace is given, it defaults to sRGB.
Based on formula from http://brucelindbloom.com/Eqn_RGB_to_XYZ.html
Implementation Notes:
1. The transformation matrix [M] is calculated from the RGB reference
primaries as discussed here:
http://brucelindbloom.com/Eqn_RGB_XYZ_Matrix.html
2. The gamma values for many common RGB color spaces may be found here:
http://brucelindbloom.com/WorkingSpaceInfo.html#Specifications
3. Your input RGB values may need to be scaled before using the above.
For example, if your values are in the range [0, 255], you must first
divide each by 255.0.
4. The output XYZ values are in the nominal range [0.0, scale].
5. The XYZ values will be relative to the same reference white as the
RGB system. If you want XYZ relative to a different reference white,
you must apply a chromatic adaptation transform
[http://brucelindbloom.com/Eqn_ChromAdapt.html] to the XYZ color to
convert it from the reference white of the RGB system to the desired
reference white.
6. Sometimes the more complicated special case of sRGB shown above is
replaced by a "simplified" version using a straight gamma function
with gamma = 2.2.
Args:
R (float): The R' value of the color.
G (float): The G' value of the color.
B (float): The B' value of the color.
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or
int). The gamma should be a float. The RGB primaries red,
green, blue should be lists or tuples of xyY coordinates
(only x and y will be used, so Y can be zero or None).
scale (float): The scale factor for the output values. Defaults to 1.0.
eotf (function): A function to apply to the RGB values before conversion.
If not set, the RGB values will be treated as linear RGB values.
This function should take a single argument and return a float.
The default function is the inverse of the Rec. 2020 EOTF.
See the `special_pow` function for more details.
Returns:
tuple[float, float, float]: The XYZ values.
"""
trc, _, _, _, _, matrix = get_rgb_space(rgb_space)
rgb = [R, G, B]
is_trc = isinstance(trc, (list, tuple))
for i, v in enumerate(rgb):
gamma = trc[i] if is_trc else trc
if eotf:
rgb[i] = eotf(v)
elif isinstance(gamma, (list, tuple)):
rgb[i] = interp(
v, [n / float(len(gamma) - 1) for n in range(len(gamma))], gamma
)
else:
rgb[i] = special_pow(v, gamma)
xyz = matrix * rgb
return tuple(v * scale for v in xyz)
def RGB2xyY( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
rgb_space: None | str | list | tuple = None,
scale: float = 1.0,
eotf: None | Callable = None,
) -> tuple[float, float, float]:
"""Convert RGB to xyY.
Args:
R (float): The R' value of the color.
G (float): The G' value of the color.
B (float): The B' value of the color.
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or
int). The gamma should be a float. The RGB primaries red,
green, blue should be lists or tuples of xyY coordinates
(only x and y will be used, so Y can be zero or None).
scale (float): The scale factor for the output values. Defaults to 1.0.
eotf (function): A function to apply to the RGB values before conversion.
Returns:
tuple[float, float, float]: The xyY values.
"""
return XYZ2xyY(
*RGB2XYZ(R, G, B, rgb_space, scale, eotf),
whitepoint=RGB2XYZ(1, 1, 1, rgb_space, scale, eotf),
)
def RGB2YCbCr( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
rgb_space: None | str | list | tuple = "NTSC 1953",
bits: int = 8,
fullrange: bool = False,
) -> tuple[float, float, float]:
"""R'G'B' to Y'CbCr quantized to n bits.
Args:
R (float): The R' value of the color.
G (float): The G' value of the color.
B (float): The B' value of the color.
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or
int). The gamma should be a float. The RGB primaries red,
green, blue should be lists or tuples of xyY coordinates
(only x and y will be used, so Y can be zero or None).
bits (int): The number of bits to quantize to. Defaults to 8.
fullrange (bool): Whether to use full range or limited range. Defaults to False.
Returns:
tuple: The Y'CbCr values.
"""
return YPbPr2YCbCr(*RGB2YPbPr(R, G, B, rgb_space), bits=bits, fullrange=fullrange)
def RGB2YPbPr( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
rgb_space: None | str | list | tuple = "NTSC 1953",
) -> tuple[float, float, float]:
"""R'G'B' to Y'PbPr.
Args:
R (float): The R' value of the color.
G (float): The G' value of the color.
B (float): The B' value of the color.
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or int).
The gamma should be a float. The RGB primaries red, green,
blue should be lists or tuples of xyY coordinates (only x and
y will be used, so Y can be zero or None).
Returns:
tuple: The Y'PbPr values.
"""
return RGB2YPbPr_matrix(rgb_space) * (R, G, B)
def RGB2YPbPr_matrix(rgb_space: None | str | list | tuple = "NTSC 1953") -> Matrix3x3: # noqa: N802
"""Get the RGB to Y'PbPr matrix for the given RGB space.
Args:
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or int).
The gamma should be a float. The RGB primaries red, green,
blue should be lists or tuples of xyY coordinates (only x and
y will be used, so Y can be zero or None).
Returns:
Matrix3x3: The RGB to Y'PbPr matrix.
"""
matrix = get_rgb_space(rgb_space)[-1]
ndigits = 3 if matrix == get_rgb_space("NTSC 1953")[-1] else 4
kr = round((matrix * (1, 0, 0))[1], ndigits)
kb = round((matrix * (0, 0, 1))[1], ndigits)
kg = 1.0 - kr - kb
pb_scale = (1 - kb) / 0.5
pr_scale = (1 - kr) / 0.5
return Matrix3x3(
[
[kr, kg, kb],
[-kr / pb_scale, -kg / pb_scale, 0.5],
[0.5, -kg / pr_scale, -kb / pr_scale],
]
)
def YCbCr2YPbPr( # noqa: N802
Y: float, # noqa: N803
Cb: float, # noqa: N803
Cr: float, # noqa: N803
bits: int = 8,
fullrange: bool = False,
) -> tuple[float, float, float]:
"""Y'CbCr to Y'PbPr.
Args:
Y (float): The Y value of the color.
Cb (float): The Cb value of the color.
Cr (float): The Cr value of the color.
bits (int, optional): The number of bits to quantize to. Defaults to 8.
fullrange (bool, optional): Whether to use full range or limited range.
Defaults to False.
Returns:
tuple[float, float, float]: The Y'PbPr values.
"""
bitlevels = 2**bits
if not fullrange:
yblack = 16
ywhite = 235
cmax = 240
else:
yblack = 0
ywhite = 255
cmax = 255
yscale = (ywhite - yblack) / 256.0 * bitlevels
Y -= yblack / 256.0 * bitlevels # noqa: N806
Y /= yscale # noqa: N806
cneutral = 128 / 256.0 * bitlevels
cscale = (cmax - yblack) / 256.0 * bitlevels
pb = Cb - cneutral
pb /= cscale
pr = Cr - cneutral
pr /= cscale
return Y, pb, pr
def YCbCr2RGB( # noqa: N802
Y: float, # noqa: N803
Cb: float, # noqa: N803
Cr: float, # noqa: N803
rgb_space: None | str | list | tuple = "NTSC 1953",
bits: int = 8,
fullrange: bool = False,
scale: float = 1.0,
round_: bool = False,
clamp: bool = True,
) -> list[float]:
"""Y'CbCr to R'G'B'.
Args:
Y (float): The Y value of the color.
Cb (float): The Cb value of the color.
Cr (float): The Cr value of the color.
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or int).
The gamma should be a float. The RGB primaries red, green,
blue should be lists or tuples of xyY coordinates (only x and
y will be used, so Y can be zero or None).
bits (int): The number of bits to quantize to. Defaults to 8.
fullrange (bool): Whether to use full range or limited range. Defaults to False.
scale (float): The scale factor to apply to the output values.
round_ (int | bool): The number of decimal places to round to.
If False, no rounding is applied. Defaults to False.
clamp (bool): Whether to clamp the output values to [0.0, 1.0].
Defaults to True.
Returns:
list[float]: The R'G'B' values.
"""
return YPbPr2RGB(
*YCbCr2YPbPr(Y, Cb, Cr, bits, fullrange), rgb_space, scale, round_, clamp
)
def YPbPr2RGB( # noqa: N802
Y: float, # noqa: N803
Pb: float, # noqa: N803
Pr: float, # noqa: N803
rgb_space: None | str | list | tuple = "NTSC 1953",
scale: float = 1.0,
round_: bool = False,
clamp: bool = True,
) -> list[float]:
"""Y'PbPr to R'G'B'.
Args:
Y (float): The Y value of the color.
Pb (float): The Pb value of the color.
Pr (float): The Pr value of the color.
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or int).
The gamma should be a float. The RGB primaries red, green,
blue should be lists or tuples of xyY coordinates (only x and
y will be used, so Y can be zero or None).
scale (float): The scale factor to apply to the output values.
round_ (int | bool): The number of decimal places to round to.
If False, no rounding is applied. Defaults to False.
clamp (bool): Whether to clamp the output values to [0.0, 1.0].
Defaults to True.
Returns:
list[float]: The R'G'B' values.
"""
rgb = RGB2YPbPr_matrix(rgb_space).inverted() * (Y, Pb, Pr)
for i in range(3):
if clamp:
rgb[i] = min(1.0, max(0.0, rgb[i]))
rgb[i] *= scale
if round_ is not False:
rgb[i] = round(rgb[i], round_)
return rgb
def YPbPr2YCbCr( # noqa: N802
Y: float, # noqa: N803
Pb: float, # noqa: N803
Pr: float, # noqa: N803
bits: int = 8,
fullrange: bool = False,
) -> tuple[float, float, float]:
"""Y'PbPr to Y'CbCr quantized to n bits.
Args:
Y (float): The Y value of the color.
Pb (float): The Pb value of the color.
Pr (float): The Pr value of the color.
bits (int): The number of bits to quantize to. Defaults to 8.
fullrange (bool): Whether to use full range or limited range. Defaults to False.
Returns:
tuple[float, float, float]: The Y'CbCr values.
"""
bitlevels = 2**bits
if not fullrange:
yblack = 16
ywhite = 235
cmax = 240
else:
yblack = 0
ywhite = 255
cmax = 255
yscale = (ywhite - yblack) / 256.0 * bitlevels
Y = yblack / 256.0 * bitlevels + yscale * Y # noqa: N806
cneutral = 128 / 256.0 * bitlevels
cscale = (cmax - yblack) / 256.0 * bitlevels
cb = cneutral + cscale * Pb # noqa: N806
cr = cneutral + cscale * Pr # noqa: N806
# In fullrange mode, Cb and Cr can reach 255.5, so we need to clamp
# Follow ITU-T Rec. T.871 (JPEG)
return (min(max(round(v), 0), bitlevels - 1) for v in (Y, cb, cr))
def RGBsaturation( # noqa: N802
R: float, # noqa: N803
G: float, # noqa: N803
B: float, # noqa: N803
saturation: float,
rgb_space: None | str | list | tuple = None,
) -> tuple[float, float, float]:
"""(De)saturate a RGB color in CIE xy and return the RGB and xyY values.
Args:
R (float): The red value of the color.
G (float): The green value of the color.
B (float): The blue value of the color.
saturation (float): The saturation factor.
0.0 = grayscale, 1.0 = original color, >1.0 = oversaturated.
<0.0 = undersaturated.
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or int).
The gamma should be a float. The RGB primaries red, green,
blue should be lists or tuples of xyY coordinates (only x and
y will be used, so Y can be zero or None).
Returns:
tuple: The new RGB values after saturation adjustment.
tuple: The new xyY values after saturation adjustment.
"""
whitepoint = RGB2XYZ(1, 1, 1, rgb_space=rgb_space)
X, Y, Z = RGB2XYZ(R, G, B, rgb_space=rgb_space) # noqa: N806
XYZ, xyY = XYZsaturation(X, Y, Z, saturation, whitepoint) # noqa: N806
return XYZ2RGB(*XYZ, rgb_space=rgb_space), xyY
def XYZsaturation( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
saturation: float,
whitepoint: None | float | str | list | tuple = None,
) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
"""(De)saturate a XYZ color in CIE xy and return the RGB and xyY values.
Args:
X (float): The X value of the color.
Y (float): The Y value of the color.
Z (float): The Z value of the color.
saturation (float): The saturation factor.
0.0 = grayscale, 1.0 = original color, >1.0 = oversaturated.
<0.0 = undersaturated.
whitepoint (None | float | str | list | tuple): The white point
to use for conversion. Defaults to D65 if not set.
Returns:
tuple[tuple[float, float, float], tuple[float, float, float]]: The new
XYZ values after saturation adjustment.
"""
wx, wy, wY = XYZ2xyY(*get_whitepoint(whitepoint)) # noqa: N806
x, y, Y = XYZ2xyY(X, Y, Z) # noqa: N806
x, y, Y = xyYsaturation(x, y, Y, wx, wy, saturation) # noqa: N806
return xyY2XYZ(x, y, Y), (x, y, Y)
def xyYsaturation( # noqa: N802
x: float,
y: float,
Y: float, # noqa: N803
wx: float,
wy: float,
saturation: float,
) -> tuple[float, float, float]:
"""(De)saturate a color in CIE xy and return the RGB and xyY values.
Args:
x (float): The x coordinate of the color.
y (float): The y coordinate of the color.
Y (float): The Y value of the color.
wx (float): The x coordinate of the white point.
wy (float): The y coordinate of the white point.
saturation (float): The saturation factor.
0.0 = grayscale, 1.0 = original color, >1.0 = oversaturated.
<0.0 = undersaturated.
Returns:
tuple[float, float, float]: The new x, y, and Y values after saturation
adjustment.
"""
return wx + (x - wx) * saturation, wy + (y - wy) * saturation, Y
def convert_range(
v: float, oldmin: float = 0, oldmax: float = 1, newmin: float = 0, newmax: float = 1
) -> float:
"""Convert a value from one range to another.
Args:
v (float): The value to convert.
oldmin (float): The minimum of the old range.
oldmax (float): The maximum of the old range.
newmin (float): The minimum of the new range.
newmax (float): The maximum of the new range.
Returns:
float: The converted value in the new range.
"""
oldrange = float(oldmax - oldmin)
newrange = newmax - newmin
return (((v - oldmin) * newrange) / oldrange) + newmin
def rgb_to_xyz_matrix(
rx: float,
ry: float,
gx: float,
gy: float,
bx: float,
by: float,
whitepoint: None | float | str | list | tuple = None,
scale: float = 1.0,
) -> Matrix3x3:
"""Create and return an RGB to XYZ matrix.
Args:
rx (float): The x coordinate of the red primary.
ry (float): The y coordinate of the red primary.
gx (float): The x coordinate of the green primary.
gy (float): The y coordinate of the green primary.
bx (float): The x coordinate of the blue primary.
by (float): The y coordinate of the blue primary.
whitepoint (None | float | str | list | tuple): The white point
to use for conversion. If None, the default white point will be
used.
scale (float): The scale factor for the XYZ values. Defaults to 1.0.
Returns:
Matrix3x3: The RGB to XYZ matrix.
"""
whitepoint = get_whitepoint(whitepoint, scale)
Xr, Yr, Zr = xyY2XYZ(rx, ry, scale) # noqa: N806
Xg, Yg, Zg = xyY2XYZ(gx, gy, scale) # noqa: N806
Xb, Yb, Zb = xyY2XYZ(bx, by, scale) # noqa: N806
Sr, Sg, Sb = ( # noqa: N806
Matrix3x3(((Xr, Xg, Xb), (Yr, Yg, Yb), (Zr, Zg, Zb))).inverted() * whitepoint
)
return Matrix3x3(
(
(Sr * Xr, Sg * Xg, Sb * Xb),
(Sr * Yr, Sg * Yg, Sb * Yb),
(Sr * Zr, Sg * Zg, Sb * Zb),
)
)
def find_primaries_wp_xy_rgb_space_name(
xy: list | tuple, rgb_space_names: None | list | tuple = None, digits: int = 4
) -> None | str:
"""Find the RGB space name matching given primaries and whitepoint xy.
Args:
xy (list | tuple): The xy coordinates of the primaries and whitepoint.
rgb_space_names (None | list | tuple): A list of RGB space names to
search in. If None, all RGB spaces will be searched.
Defaults to None.
digits (int): The number of digits to round to. Defaults to 4.
Returns:
None | str: The name of the RGB space matching the given xy
coordinates, or None if no match is found.
"""
for _i, rgb_space_name in enumerate(rgb_space_names or iter(rgb_spaces.keys())):
if not rgb_space_names and rgb_space_name in (
"ECI RGB",
"ECI RGB v2",
"SMPTE 240M",
"sRGB",
):
# Skip in favor of base color space (i.e. NTSC 1953, SMPTE-C and
# Rec. 709)
continue
if get_rgb_space_primaries_wp_xy(rgb_space_name, digits)[: len(xy)] == xy:
return rgb_space_name
return None
@cache
def get_rgb_space(
rgb_space: None | str | list | tuple = None, scale: float = 1.0
) -> tuple[float,]:
"""Return gamma, whitepoint, primaries and RGB -> XYZ matrix.
Args:
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or int).
The gamma should be a float. The RGB primaries red, green,
blue should be lists or tuples of xyY coordinates (only x and
y will be used, so Y can be zero or None).
scale (float): Scale factor for the XYZ values. Defaults to 1.0.
Returns:
tuple: A tuple containing the gamma, whitepoint, red, green, blue
primaries in xyY format, and the RGB to XYZ matrix.
"""
if not rgb_space:
rgb_space = "sRGB"
if isinstance(rgb_space, str):
rgb_space = rgb_spaces[rgb_space]
gamma = rgb_space[0] or rgb_spaces["sRGB"][0]
whitepoint = get_whitepoint(rgb_space[1] or rgb_spaces["sRGB"][1], scale)
rx, ry, rY = rxyY = rgb_space[2] or rgb_spaces["sRGB"][2] # noqa: N806
gx, gy, gY = gxyY = rgb_space[3] or rgb_spaces["sRGB"][3] # noqa: N806
bx, by, bY = bxyY = rgb_space[4] or rgb_spaces["sRGB"][4] # noqa: N806
matrix = rgb_to_xyz_matrix(rx, ry, gx, gy, bx, by, whitepoint, scale)
return gamma, whitepoint, rxyY, gxyY, bxyY, matrix
def get_rgb_space_primaries_wp_xy(
rgb_space: None | str | list | tuple = None, digits: int = 4
) -> list:
"""Return primaries and whitepoint xy for a given RGB space, rounded to n digits.
Args:
rgb_space (None | str | list | tuple): The RGB space
to use for conversion. Defaults to sRGB if not set.
If a string is given, it must be a valid RGB space name.
If a list or tuple is given, it must be in the format
(gamma, whitepoint, red, green, blue).
The whitepoint can be a string (e.g. "D50"), a tuple of XYZ
coordinates, or a color temperature in degrees K (float or int).
The gamma should be a float. The RGB primaries red, green,
blue should be lists or tuples of xyY coordinates (only x and
y will be used, so Y can be zero or None).
digits (int): The number of digits to round to. Defaults to 4.
Returns:
list: A list of xy coordinates for the RGB primaries and whitepoint,
rounded to the specified number of digits.
"""
rgb_space = get_rgb_space(rgb_space)
xy = []
for i in range(3):
xy.extend(rgb_space[2:][i][:2])
xy.extend(XYZ2xyY(*get_whitepoint(rgb_space[1]))[:2])
if digits:
xy = [round(v, digits) for v in xy]
return xy
@cache
def get_standard_illuminant(
illuminant_name: str = "D50",
priority: tuple = (
"ISO 11664-2:2007",
"ICC",
"ASTM E308-01",
"Wyszecki & Stiles",
None,
),
scale: float = 1.0,
) -> tuple[float, float, float]:
"""Return a standard illuminant as XYZ coordinates.
Args:
illuminant_name (str): The name of the standard illuminant to return.
Defaults to "D50".
priority (tuple): A tuple of standard names to search for the
illuminant. The first one found will be returned.
Defaults to ("ISO 11664-2:2007", "ICC", "ASTM E308-01",
"Wyszecki & Stiles", None).
scale (float): Scale factor for the XYZ values. Defaults to 1.0.
Raises:
ValueError: If the illuminant name is not recognized or if no
illuminant is found in the given priority list.
Returns:
tuple[float, float, float]: A tuple of XYZ coordinates scaled by the
given scale factor.
"""
illuminant = None
for standard_name in priority:
if standard_name not in standard_illuminants:
raise ValueError(f'Unrecognized standard "{standard_name}"')
illuminant = standard_illuminants.get(standard_name).get(
illuminant_name.upper(), None
)
if illuminant:
return illuminant["X"] * scale, 1.0 * scale, illuminant["Z"] * scale
raise ValueError(f'Unrecognized illuminant "{illuminant_name}"')
@overload
def get_whitepoint(
whitepoint: list,
scale: float = 1.0,
planckian: bool = False,
) -> list[float]: ...
@overload
def get_whitepoint(
whitepoint: None | float | str | tuple,
scale: float = 1.0,
planckian: bool = False,
) -> tuple[float, float, float]: ...
@cache
def get_whitepoint(
whitepoint: None | float | str | list | tuple = None,
scale: float = 1.0,
planckian: bool = False,
) -> tuple[float, float, float]:
"""Return a whitepoint as XYZ coordinates.
Args:
whitepoint: A string (e.g. "D50"), a tuple of XYZ coordinates, or a
color temperature in degrees K (float or int). Defaults to D50 if
not set.
scale: Scale factor for the XYZ values. Defaults to 1.0.
planckian: If True, interpret the whitepoint as a Planckian color
temperature. Defaults to False.
Returns:
tuple: A tuple of XYZ coordinates scaled by the given scale factor.
"""
if isinstance(whitepoint, (list, tuple)):
return whitepoint
if not whitepoint:
whitepoint = "D50"
if isinstance(whitepoint, str):
whitepoint = get_standard_illuminant(whitepoint)
elif isinstance(whitepoint, (float, int)):
cct = whitepoint
if planckian:
whitepoint = planckianCT2XYZ(cct)
if not whitepoint:
raise ValueError(
f"Planckian color temperature {cct} out of range (1667, 25000)"
)
else:
whitepoint = CIEDCCT2XYZ(cct)
if not whitepoint:
raise ValueError(
f"Daylight color temperature {cct} out of range (2500, 25000)"
)
if scale > 1.0 and whitepoint[1] == 100:
scale = 1.0
return tuple(v * scale for v in whitepoint)
def make_monotonically_increasing(
iterable: tuple | list | dict,
passes: int = 0,
window: None | int = None,
) -> list | dict:
"""Make values in iterable strictly monotonically increasing by linear interpolation.
If iterable is a dict, keep the keys of the original.
If passes is non-zero, apply moving average smoothing to the values
before making them monotonically increasing.
Args:
iterable (tuple | list | dict): The input iterable or sequence.
passes (int): The number of smoothing passes to apply.
Defaults to 0 (no smoothing).
window (int): The window size for smoothing. Defaults to None.
If None, the window size is set to 3.
If passes is 0, this argument is ignored.
Returns:
list: A list of tuples containing the original keys and the
monotonically increasing values.
""" # noqa: E501
if isinstance(iterable, dict):
keys = list(iterable.keys())
values = list(iterable.values())
else:
values = list(iterable) if hasattr(iterable, "next") else iterable
keys = range(len(values))
if passes:
values = smooth_avg(values, passes, window)
sequence = list(zip(keys, values))
numvalues = len(sequence)
s_new = []
y_min = sequence[0][1]
while sequence:
x, y = sequence.pop()
if (not s_new or y < s_new[0][1]) and (y > y_min or not sequence):
s_new.insert(0, (x, y))
sequence = s_new
# Interpolate to original size
x_new = [item[0] for item in sequence]
y = [item[1] for item in sequence]
values = []
for i in range(numvalues):
values.append(interp(i, x_new, y))
if isinstance(iterable, dict):
# Add in original keys
return iterable.__class__(list(zip(keys, values)))
return values
def matmul(
XYZ: tuple[float, float, float], # noqa: N803
m1: Matrix3x3,
m2: Matrix3x3,
) -> tuple[float, float, float]:
"""Matrix multiplication of two matrices.
Args:
XYZ (tuple[float, float, float]): A tuple of XYZ coordinates (X, Y, Z).
m1 (Matrix3x3): The first matrix.
m2 (Matrix3x3): The second matrix.
Returns:
tuple[float, float, float]: A tuple of the resulting coordinates
(X', Y', Z').
"""
return m1 * (m2 * XYZ)
def planckianCT2XYZ(T: float, scale: float = 1.0) -> None | tuple[float, float, float]: # noqa: N802, N803
"""Convert from planckian temperature to XYZ.
T = temperature in Kelvin.
Args:
T (float): Temperature in Kelvin.
scale (float): Scale factor for the XYZ values.
Defaults to 1.0.
Returns:
None | tuple[float, float, float]: A tuple of XYZ coordinates (X, Y, Z)
if xyY is not None, None otherwise.
"""
xyY = planckianCT2xyY(T, scale) # noqa: N806
return xyY2XYZ(*xyY) if xyY else None
def planckianCT2xyY(T: float, scale: float = 1.0) -> tuple[float, float, float]: # noqa: N802, N803
"""Convert from planckian temperature to xyY.
T = temperature in Kelvin.
Formula from http://en.wikipedia.org/wiki/Planckian_locus
Args:
T (float): Temperature in Kelvin.
scale (float, optional): Scale factor for the xyY values.
Defaults to 1.0.
Returns:
tuple[float, float, float]: A tuple of xyY coordinates (x, y, Y).
"""
if 1667 <= T <= 4000:
x = (
-0.2661239 * (math.pow(10, 9) / math.pow(T, 3))
- 0.2343580 * (math.pow(10, 6) / math.pow(T, 2))
+ 0.8776956 * (math.pow(10, 3) / T)
+ 0.179910
)
elif 4000 <= T <= 25000:
x = (
-3.0258469 * (math.pow(10, 9) / math.pow(T, 3))
+ 2.1070379 * (math.pow(10, 6) / math.pow(T, 2))
+ 0.2226347 * (math.pow(10, 3) / T)
+ 0.24039
)
else:
return None
if 1667 <= T <= 2222:
y = (
-1.1063814 * math.pow(x, 3)
- 1.34811020 * math.pow(x, 2)
+ 2.18555832 * x
- 0.20219683
)
elif 2222 <= T <= 4000:
y = (
-0.9549476 * math.pow(x, 3)
- 1.37418593 * math.pow(x, 2)
+ 2.09137015 * x
- 0.16748867
)
elif 4000 <= T <= 25000:
y = (
3.0817580 * math.pow(x, 3)
- 5.87338670 * math.pow(x, 2)
+ 3.75112997 * x
- 0.37001483
)
return x, y, scale
def xyY2CCT(x: float, y: float, Y: float = 1.0) -> None | float: # noqa: N802, N803
"""Convert from xyY to correlated color temperature.
Args:
x (float): x coordinate in xyY color space.
y (float): y coordinate in xyY color space.
Y (float, optional): Y coordinate in xyY color space.
Returns:
None | float: Correlated color temperature in Kelvin.
"""
return XYZ2CCT(*xyY2XYZ(x, y, Y))
def xyY2Lab( # noqa: N802
x: float,
y: float,
Y: float = 1.0, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from xyY to Lab color space.
Args:
x (float): x coordinate in xyY color space.
y (float): y coordinate in xyY color space.
Y (float, optional): Y coordinate in xyY color space.
whitepoint ( None | float | str | tuple | list): Whitepoint to
use for conversion. Defaults to D50 if not set.
Returns:
tuple[float, float, float]: A tuple of Lab coordinates (L, a, b).
"""
return XYZ2Lab(*xyY2XYZ(x, y, Y), whitepoint)
def xyY2Lu_v_( # noqa: N802
x: float,
y: float,
Y: float = 1.0, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from xyY to Lu'v' color space.
Args:
x (float): x coordinate in xyY color space.
y (float): y coordinate in xyY color space.
Y (float, optional): Y coordinate in xyY color space.
whitepoint ( None | float | str | tuple | list): Whitepoint to
use for conversion. Defaults to D50 if not set.
Returns:
tuple[float, float, float]: A tuple of Lu'v' coordinates (L, u', v').
"""
return XYZ2Lu_v_(*xyY2XYZ(x, y, Y), whitepoint)
def xyY2RGB( # noqa: N802
x: float, # noqa: N803
y: float, # noqa: N803
Y: float, # noqa: N803
rgb_space: None | str | list | tuple = None,
scale: float = 1.0,
round_: bool = False,
clamp: bool = True,
) -> tuple[float, float, float]:
"""Convert from xyY to RGB.
Args:
x (float): x coordinate in xyY color space.
y (float): y coordinate in xyY color space.
Y (float): Y coordinate in xyY color space.
rgb_space (str | tuple): RGB color space to use for conversion.
scale (float): Scale factor for the RGB values.
round_ (bool): If True, round the RGB values to integers.
clamp (bool): If True, clamp the RGB values to [0, 1].
Returns:
tuple: A tuple of RGB coordinates (R, G, B).
"""
return XYZ2RGB(*xyY2XYZ(x, y, Y), rgb_space, scale, round_, clamp)
def xyY2XYZ(x: float, y: float, Y: float = 1.0) -> tuple[float, float, float]: # noqa: N802, N803
"""Convert from xyY to XYZ.
Based on formula from http://brucelindbloom.com/Eqn_xyY_to_XYZ.html
Implementation Notes:
1. Watch out for the case where y = 0. In that case, X = Y = Z = 0 is
returned.
2. The output XYZ values are in the nominal range [0.0, Y[xyY]].
Args:
x (float): x coordinate in xyY color space.
y (float): y coordinate in xyY color space.
Y (float, optional): Y coordinate in xyY color space. The default is 1.0.
Returns:
tuple[float, float, float]: A tuple of XYZ coordinates (X, Y, Z).
"""
if y == 0:
return 0, 0, 0
return (float(x * Y) / y), Y, (float((1 - x - y) * Y) / y)
def LERP(a: float, b: float, c: float) -> float: # noqa: N802
"""Linear interpolation macro.
Is 'a' when c == 0.0 and 'b' when c == 1.0
Args:
a (float): Start value.
b (float): End value.
c (float): Interpolation factor (0.0 to 1.0).
Returns:
float: Interpolated value.
"""
return (b - a) * c + a
def XYZ2CCT(X: float, Y: float, Z: float) -> None | float: # noqa: N802, N803
"""Convert from XYZ to correlated color temperature.
Derived from ANSI C implementation by Bruce Lindbloom
http://brucelindbloom.com/Eqn_XYZ_to_T.html
Return: correlated color temperature if successful, else None.
Description:
This is an implementation of Robertson's method of computing the
correlated color temperature of an XYZ color. It can compute correlated
color temperatures in the range [1666.7K, infinity].
Reference:
"Color Science: Concepts and Methods, Quantitative Data and Formulae",
Second Edition, Gunter Wyszecki and W. S. Stiles, John Wiley & Sons,
1982, pp. 227, 228.
Args:
X (float): X coordinate in XYZ color space.
Y (float): Y coordinate in XYZ color space.
Z (float): Z coordinate in XYZ color space.
Returns:
None | float: Correlated color temperature in Kelvin if successful,
else None.
"""
rt = [ # reciprocal temperature (K)
DBL_MIN,
10.0e-6,
20.0e-6,
30.0e-6,
40.0e-6,
50.0e-6,
60.0e-6,
70.0e-6,
80.0e-6,
90.0e-6,
100.0e-6,
125.0e-6,
150.0e-6,
175.0e-6,
200.0e-6,
225.0e-6,
250.0e-6,
275.0e-6,
300.0e-6,
325.0e-6,
350.0e-6,
375.0e-6,
400.0e-6,
425.0e-6,
450.0e-6,
475.0e-6,
500.0e-6,
525.0e-6,
550.0e-6,
575.0e-6,
600.0e-6,
]
uvt = [
[0.18006, 0.26352, -0.24341],
[0.18066, 0.26589, -0.25479],
[0.18133, 0.26846, -0.26876],
[0.18208, 0.27119, -0.28539],
[0.18293, 0.27407, -0.30470],
[0.18388, 0.27709, -0.32675],
[0.18494, 0.28021, -0.35156],
[0.18611, 0.28342, -0.37915],
[0.18740, 0.28668, -0.40955],
[0.18880, 0.28997, -0.44278],
[0.19032, 0.29326, -0.47888],
[0.19462, 0.30141, -0.58204],
[0.19962, 0.30921, -0.70471],
[0.20525, 0.31647, -0.84901],
[0.21142, 0.32312, -1.0182],
[0.21807, 0.32909, -1.2168],
[0.22511, 0.33439, -1.4512],
[0.23247, 0.33904, -1.7298],
[0.24010, 0.34308, -2.0637],
[0.24792, 0.34655, -2.4681], # Note: 0.24792 is a corrected value
# for the error found in W&S as 0.24702
[0.25591, 0.34951, -2.9641],
[0.26400, 0.35200, -3.5814],
[0.27218, 0.35407, -4.3633],
[0.28039, 0.35577, -5.3762],
[0.28863, 0.35714, -6.7262],
[0.29685, 0.35823, -8.5955],
[0.30505, 0.35907, -11.324],
[0.31320, 0.35968, -15.628],
[0.32129, 0.36011, -23.325],
[0.32931, 0.36038, -40.770],
[0.33724, 0.36051, -116.45],
]
if (X < 1.0e-20 and Y < 1.0e-20 and Z < 1.0e-20) or X + 15.0 * Y + 3.0 * Z == 0:
return None # protect against possible divide-by-zero failure
us = (4.0 * X) / (X + 15.0 * Y + 3.0 * Z)
vs = (6.0 * Y) / (X + 15.0 * Y + 3.0 * Z)
dm = 0.0
i = 0
while i < 31:
di = (vs - uvt[i][1]) - uvt[i][2] * (us - uvt[i][0])
if i > 0 and ((di < 0.0 <= dm) or (di >= 0.0 > dm)):
break # found lines bounding (us, vs) : i-1 and i
dm = di
i += 1
if i == 31:
# bad XYZ input, color temp would be less than minimum of 1666.7
# degrees, or too far towards blue
return None
di = di / math.sqrt(1.0 + uvt[i][2] * uvt[i][2])
dm = dm / math.sqrt(1.0 + uvt[i - 1][2] * uvt[i - 1][2])
p = dm / (dm - di) # p = interpolation parameter, 0.0 : i-1, 1.0 : i
p = 1.0 / (LERP(rt[i - 1], rt[i], p))
return p # noqa: RET504
def XYZ2DIN99( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to DIN99.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float, float, float]: DIN99 values.
"""
return Lab2DIN99(*XYZ2Lab(*(max(v, 0) for v in (X, Y, Z)), whitepoint))
def XYZ2DIN99b( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to DIN99b.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float, float, float]: DIN99b values.
"""
return Lab2DIN99b(*XYZ2Lab(X, Y, Z, whitepoint))
def XYZ2DIN99o( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to DIN99o.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float]: DIN99o values.
"""
return Lab2DIN99o(*XYZ2Lab(X, Y, Z, whitepoint))
def XYZ2DIN99bLCH( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to DIN99b LCH.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float, float, float]: DIN99b LCH values.
"""
return Lab2DIN99bLCH(*XYZ2Lab(X, Y, Z, whitepoint))
def XYZ2DIN99oLCH( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to DIN99o LCH.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float, float, float]: DIN99o LCH values.
"""
return Lab2DIN99oLCH(*XYZ2Lab(X, Y, Z, whitepoint))
def XYZ2DIN99c( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to DIN99c.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float, float, float]: DIN99c values.
"""
return XYZ2DIN99cd(X, Y, Z, 0.1, 317.651, 0.0037, 0, 0.94, 23, 0.066, whitepoint)
def XYZ2DIN99cd( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
x: float,
l1: float,
l2: float,
deg: float,
f1: float,
c1: float,
c2: float,
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to DIN99cd.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
x (float): Chromatic adaptation factor.
l1 (float): L1 parameter.
l2 (float): L2 parameter.
deg (float): Deg parameter.
f1 (float): F1 parameter.
c1 (float): C1 parameter.
c2 (float): C2 parameter.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float]: DIN99cd values.
"""
l99, c99, h99 = XYZ2DIN99cdLCH(X, Y, Z, x, l1, l2, deg, f1, c1, c2, whitepoint)
a99, b99 = DIN99familyCH2DIN99ab(c99, h99)
return l99, a99, b99
def XYZ2DIN99cdLCH( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
x: float,
l1: float,
l2: float,
deg: float,
f1: float,
c1: float,
c2: float,
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to DIN99cd LCH.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
x (float): Chromatic adaptation factor.
l1 (float): L1 parameter.
l2 (float): L2 parameter.
deg (float): Deg parameter.
f1 (float): F1 parameter.
c1 (float): C1 parameter.
c2 (float): C2 parameter.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float, float, float]: DIN99cd LCH values.
"""
X, Y, Z = XYZ2DIN99cdXYZ(X, Y, Z, x) # noqa: N806
whitepoint99d = XYZ2DIN99cdXYZ(*get_whitepoint(whitepoint, 100), x=x)
l, a, b = XYZ2Lab(X, Y, Z, whitepoint99d)
return Lab2DIN99familyLCH(l, a, b, l1, l2, deg, f1, c1, c2)
def XYZ2DIN99cdXYZ( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
x: float,
) -> tuple[float, float, float]:
"""Convert from XYZ to DIN99cd.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
x (float): Chromatic adaptation factor.
Returns:
tuple[float]: DIN99cd values.
"""
X = (1 + x) * X - x * Z # noqa: N806
return X, Y, Z
def XYZ2DIN99d( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to DIN99d.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float, float, float]: DIN99d values.
"""
return XYZ2DIN99cd(X, Y, Z, 0.12, 325.221, 0.0036, 50, 1.14, 22.5, 0.06, whitepoint)
def XYZ2DIN99dLCH( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float]:
"""Convert from XYZ to DIN99d LCH.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float]: DIN99d LCH values.
"""
return XYZ2DIN99cdLCH(
X, Y, Z, 0.12, 325.221, 0.0036, 50, 1.14, 22.5, 0.06, whitepoint
)
def XYZ2IPT(X: float, Y: float, Z: float) -> Matrix3x3: # noqa: N802, N803
"""Convert from XYZ to IPT.
The input Y value needs to be in the nominal range [0.0, 100.0] and
other input values scaled accordingly.
The output I value is in the nominal range [0.0, 100.0].
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
Returns:
Matrix3x3: IPT values.
"""
xyz2lms_matrix = get_cat_matrix("IPT")
lms = xyz2lms_matrix * (X, Y, Z)
for i, component in enumerate(lms):
if component >= 0:
lms[i] **= 0.43
else:
lms[i] = -((-component) ** 0.43)
return LMS2IPT_matrix * lms
def IPT2XYZ(I: float, P: float, T: float) -> Matrix3x3: # noqa: N802, N803
"""Convert from IPT to XYZ.
Args:
I (float): I value.
P (float): P value.
T (float): T value.
Returns:
Matrix3x3: XYZ values.
"""
xyz2lms_matrix = get_cat_matrix("IPT")
lms2xyz_matrix = xyz2lms_matrix.inverted()
lms = IPT2LMS_matrix * (I, P, T)
for i, component in enumerate(lms):
if component >= 0:
lms[i] **= 1 / 0.43
else:
lms[i] = -((-component) ** (1 / 0.43))
return lms2xyz_matrix * lms
def XYZ2Lab( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
scale: float = 100,
) -> tuple[float, float, float]:
"""Convert from XYZ to Lab.
The input Y value needs to be in the nominal range [0.0, scale] and
other input values scaled accordingly.
The output L value is in the nominal range [0.0, 100.0].
whitepoint can be string (e.g. "D50"), a tuple of XYZ coordinates or
color temperature as float or int. Defaults to D50 if not set.
Based on formula from http://brucelindbloom.com/Eqn_XYZ_to_Lab.html
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
scale (float): Scale factor. Defaults to 100.
Returns:
tuple[float, float, float]: L, a, b values.
"""
Xr, Yr, Zr = get_whitepoint(whitepoint, scale) # noqa: N806
xr = X / Xr
yr = Y / Yr
zr = Z / Zr
fx = cbrt(xr) if xr > LSTAR_E else (LSTAR_K * xr + 16) / 116.0
fy = cbrt(yr) if yr > LSTAR_E else (LSTAR_K * yr + 16) / 116.0
fz = cbrt(zr) if zr > LSTAR_E else (LSTAR_K * zr + 16) / 116.0
l = 116 * fy - 16
a = 500 * (fx - fy)
b = 200 * (fy - fz)
return l, a, b
def XYZ2Lpt( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> Matrix3x3:
"""Convert from XYZ to Lpt.
This is a modern update to L*a*b*, based on IPT space.
Differences to L*a*b* and IPT:
- Using inverse CIE 2012 2degree LMS to XYZ matrix instead of
Hunt-Pointer-Estevez Von Kries chromatic adapation in LMS space.
- Using L* compression rather than IPT pure 0.43 power.
- Tweaked LMS' to IPT matrix to account for change in XYZ to LMS matrix.
- Output scaled to L*a*b* type ranges, to maintain 1 JND scale.
- L* value is not a non-linear Y value.
The input Y value needs to be in the nominal range [0.0, 100.0] and
other input values scaled accordingly.
The output L value is in the nominal range [0.0, 100.0].
whitepoint can be string (e.g. "D50"), a tuple of XYZ coordinates or
color temperature as float or int. Defaults to D50 if not set.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
Matrix3x3: Lpt values.
"""
# Adapted from Argyll/icc/icc.c
from DisplayCAL import argyll
if argyll.get_argyll_version("dispwin") < [3, 4, 0]:
observer_name = "CIE2012_2"
else:
observer_name = "CIE2015_2"
xyz2lms = get_cat_matrix(observer_name)
wlms = xyz2lms * get_whitepoint(whitepoint, 100)
lms = xyz2lms * (X, Y, Z)
for j in range(3):
lms[j] /= wlms[j]
if lms[j] > 0.008856451586:
lms[j] = pow(lms[j], 1.0 / 3.0)
else:
lms[j] = 7.787036979 * lms[j] + 16.0 / 116.0
lms[j] = 116.0 * lms[j] - 16.0
return LMS2Lpt_matrix * lms
def Lpt2XYZ( # noqa: N802
L: float, # noqa: N803
p: float,
t: float,
whitepoint: None | float | str | tuple | list = None,
scale: float = 1.0,
) -> Matrix3x3:
"""Convert from Lpt to XYZ.
This is a modern update to L*a*b*, based on IPT space.
Differences to L*a*b* and IPT:
- Using inverse CIE 2012 2degree LMS to XYZ matrix instead of
Hunt-Pointer-Estevez Von Kries chromatic adapation in LMS space.
- Using L* compression rather than IPT pure 0.43 power.
- Tweaked LMS' to IPT matrix to account for change in XYZ to LMS matrix.
- Output scaled to L*a*b* type ranges, to maintain 1 JND scale.
- L* value is not a non-linear Y value.
The input L* value needs to be in the nominal range [0.0, 100.0] and
other input values scaled accordingly.
The output XYZ values are in the nominal range [0.0, 1.0].
whitepoint can be string (e.g. "D50"), a tuple of XYZ coordinates or
color temperature as float or int. Defaults to D50 if not set.
Args:
L (float): L* value.
p (float): p value.
t (float): t value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
scale (float): Scale factor for the XYZ values. Defaults to 1.0.
Returns:
Matrix3x3: XYZ values.
"""
# Adapted from Argyll/icc/icc.c
from DisplayCAL import argyll
if argyll.get_argyll_version("dispwin") < [3, 4, 0]:
observer_name = "CIE2012_2"
else:
observer_name = "CIE2015_2"
xyz2lms = get_cat_matrix(observer_name)
lms2xyz = xyz2lms.inverted()
wlms = xyz2lms * get_whitepoint(whitepoint, scale)
lms = Lpt2LMS_matrix * (L, p, t)
for j in range(3):
lms[j] = (lms[j] + 16.0) / 116.0
if lms[j] > 24.0 / 116.0:
lms[j] = pow(lms[j], 3.0)
else:
lms[j] = (lms[j] - 16.0 / 116.0) / 7.787036979
lms[j] *= wlms[j]
return lms2xyz * lms
def XYZ2Lu_v_( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to CIE Lu'v'.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint to
use for conversion. Defaults to D50 if not set.
Returns:
tuple[float, float, float]: A tuple of Lu'v' coordinates (L, u', v').
"""
if X + Y + Z == 0:
# We can't check for X == Y == Z == 0 because they may actually add up
# to 0, thus resulting in ZeroDivisionError later
l, u_, v_ = XYZ2Lu_v_(*get_whitepoint(whitepoint))
return 0.0, u_, v_
Xr, Yr, Zr = get_whitepoint(whitepoint, 100) # noqa: N806
yr = Y / Yr
l = 116.0 * cbrt(yr) - 16.0 if yr > LSTAR_E else LSTAR_K * yr
u_ = (4.0 * X) / (X + 15.0 * Y + 3.0 * Z)
v_ = (9.0 * Y) / (X + 15.0 * Y + 3.0 * Z)
return l, u_, v_
def XYZ2Luv( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to Luv.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint to use
for conversion. Defaults to D50 if not set.
Returns:
tuple[float, float, float]: A tuple of Luv coordinates (L, u, v).
"""
if X + Y + Z == 0: # noqa: N806
# We can't check for X == Y == Z == 0 because they may actually add up
# to 0, thus resulting in ZeroDivisionError later
l, u, v = XYZ2Luv(*get_whitepoint(whitepoint))
return 0.0, u, v
Xr, Yr, Zr = get_whitepoint(whitepoint, 100) # noqa: N806
yr = Y / Yr
l = 116.0 * cbrt(yr) - 16.0 if yr > LSTAR_E else LSTAR_K * yr
u_ = (4.0 * X) / (X + 15.0 * Y + 3.0 * Z)
v_ = (9.0 * Y) / (X + 15.0 * Y + 3.0 * Z)
u_r = (4.0 * Xr) / (Xr + 15.0 * Yr + 3.0 * Zr)
v_r = (9.0 * Yr) / (Xr + 15.0 * Yr + 3.0 * Zr)
u = 13.0 * l * (u_ - u_r)
v = 13.0 * l * (v_ - v_r)
return l, u, v
def XYZ2RGB( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
rgb_space: None | str | list | tuple = None,
scale: float = 1.0,
round_: bool = False,
clamp: bool = True,
oetf: None | Callable = None,
) -> list[float]:
"""Convert from XYZ to RGB.
Use optional RGB colorspace definition, which can be a named colorspace
(e.g. "CIE RGB") or must be a tuple in the following format:
(gamma, whitepoint, red, green, blue)
whitepoint can be a string (e.g. "D50"), a tuple of XYZ coordinates,
or a color temperatur in degrees K (float or int). Gamma should be a float.
The RGB primaries red, green, blue should be lists or tuples of xyY
coordinates (only x and y will be used, so Y can be zero or None).
If no colorspace is given, it defaults to sRGB.
Based on formula from http://brucelindbloom.com/Eqn_XYZ_to_RGB.html
Implementation Notes:
1. The transformation matrix [M] is calculated from the RGB reference
primaries as discussed here:
http://brucelindbloom.com/Eqn_RGB_XYZ_Matrix.html
2. gamma is the gamma value of the RGB color system used. Many common ones
may be found here:
http://brucelindbloom.com/WorkingSpaceInfo.html#Specifications
3. The output RGB values are in the nominal range [0.0, scale].
4. If the input XYZ color is not relative to the same reference white as
the RGB system, you must first apply a chromatic adaptation transform
[http://brucelindbloom.com/Eqn_ChromAdapt.html] to the XYZ color to
convert it from its own reference white to the reference white of the
RGB system.
5. Sometimes the more complicated special case of sRGB shown above is
replaced by a "simplified" version using a straight gamma function with
gamma = 2.2.
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
rgb_space (None | str | list | tuple): RGB colorspace definition.
Defaults to sRGB.
scale (float): Scale factor for RGB output. Defaults to 1.0.
round_ (int | bool): Number of decimal places to round the output to.
If False, no rounding is applied. Defaults to False.
clamp (bool): If True, clamps the RGB values to the range [0.0, 1.0].
Defaults to True.
oetf (None | callable): Optional opto-electronic transfer function
to apply to the RGB values. If None, no OETF is applied.
Defaults to None.
Returns:
list[float]: RGB values in the range [0.0, scale].
"""
trc, _whitepoint, _rxyY, _gxyY, _bxyY, matrix = get_rgb_space(rgb_space) # noqa: N806
rgb = matrix.inverted() * [X, Y, Z]
is_trc = isinstance(trc, (list, tuple))
for i, v in enumerate(rgb):
gamma = trc[i] if is_trc else trc
if clamp:
v = min(1.0, max(0.0, v))
if oetf:
rgb[i] = oetf(v)
elif isinstance(gamma, (list, tuple)):
key = id(gamma)
if key not in XYZ2RGB.interp:
ginterp = Interp(
gamma,
[n / float(len(gamma) - 1) for n in range(len(gamma))],
use_numpy=True,
)
XYZ2RGB.interp[key] = ginterp
else:
ginterp = XYZ2RGB.interp[key]
rgb[i] = ginterp(v)
else:
rgb[i] = special_pow(v, 1.0 / gamma)
rgb[i] *= scale
if round_ is not False:
rgb[i] = round(rgb[i], round_)
return rgb
XYZ2RGB.interp = {}
def XYZ2xyY( # noqa: N802
X: float, # noqa: N803
Y: float, # noqa: N803
Z: float, # noqa: N803
whitepoint: None | float | str | tuple | list = None,
) -> tuple[float, float, float]:
"""Convert from XYZ to xyY.
Based on formula from http://brucelindbloom.com/Eqn_XYZ_to_xyY.html
Implementation Notes:
1. Watch out for black, where X = Y = Z = 0. In that case, x and y are set
to the chromaticity coordinates of the reference whitepoint.
2. The output Y value is in the nominal range [0.0, Y[XYZ]].
Args:
X (float): X value.
Y (float): Y value.
Z (float): Z value.
whitepoint (None | float | str | tuple | list): Whitepoint.
Defaults to D50.
Returns:
tuple[float, float, float]: x, y, Y values.
"""
if X + Y + Z == 0:
# We can't check for X == Y == Z == 0 because they may actually add up
# to 0, thus resulting in ZeroDivisionError later
x, y, Y = XYZ2xyY(*get_whitepoint(whitepoint)) # noqa: N806
return x, y, 0.0
x = X / float(X + Y + Z)
y = Y / float(X + Y + Z)
return x, y, Y
def xy_CCT_delta( # noqa: N802
x: float, y: float, daylight: bool = True, method: int = 2000
) -> tuple[float, float]:
"""Return CCT and delta to locus.
Args:
x (float): x chromaticity coordinate
y (float): y chromaticity coordinate
daylight (bool): True for daylight locus, False for planckian locus
method (int): Method to use for delta calculation
Returns:
tuple[float, float]: CCT and delta to locus.
"""
cct = xyY2CCT(x, y)
d = None
if cct:
locus = None
if daylight:
# Daylight locus
if 2500 <= cct <= 25000:
locus = CIEDCCT2XYZ(cct, 100.0)
# Planckian locus
elif 1667 <= cct <= 25000:
locus = planckianCT2XYZ(cct, 100.0)
if locus:
l2, a2, b2 = xyY2Lab(x, y, 100.0, locus)
d = delta(l2, 0, 0, l2, a2, b2, method)
return cct, d
def dmatrixz(nrl: int, nrh: int, ncl: int, nch: int) -> dict:
"""Create a 2D matrix of dictionaries.
Adapted from ArgyllCMS numlib/numsup.c
Args:
nrl (int): Row low index
nrh (int): Row high index
ncl (int): Col low index
nch (int): Col high index
Returns:
dict: A dictionary containing the matrix.
"""
m = {}
nrh = max(nrh, nrl) # Prevent failure for 0 dimension
nch = max(nch, ncl)
rows = nrh - nrl + 1
cols = nch - ncl + 1
for i in range(rows):
m[i + nrl] = {}
for j in range(cols):
m[i][j + ncl] = 0
return m
def dvector(nl: int, nh: int) -> dict:
"""Adapted from ArgyllCMS numlib/numsup.c.
Args:
nl: Lowest index
nh: Highest index
Returns:
dict: Empty dictionary.
"""
return {}
def gam_fit(gf: GammaFits, v: list[float]) -> float:
"""Gamma + input offset function handed to powell().
Adapted from ArgyllCMS xicc/xicc.c
Args:
gf (GammaFits): Gamma fit object containing parameters.
v (list[float]): List of gamma values to fit.
Returns:
float: Squared error value for the fit.
"""
gamma = v[0]
rv = 0.0
if gamma < 0.0:
rv += 100.0 * -gamma
gamma = 1e-4
t1 = math.pow(gf.bp, 1.0 / gamma)
t2 = math.pow(gf.wp, 1.0 / gamma)
b = t1 / (t2 - t1) # Offset
a = math.pow(t2 - t1, gamma) # Gain
# Comput 50% output for this technical gamma
# (All values are without output offset being added in)
t1 = a * math.pow(0.5 + b, gamma)
t1 = t1 - gf.thyr
rv += t1 * t1
return rv
def linmin(
cp: list[float],
xi: list[float],
di: int,
ftol: float,
func: Callable,
fdata: Any, # noqa: ANN401
) -> float:
"""Line bracketing and minimisation routine.
Return value at minimum.
Adapted from ArgyllCMS numlib/powell.c
Args:
cp (list[float]): Start point, and returned value.
xi (list[float]): Search vector.
di (int): Dimensionality.
ftol (float): Tolerance to stop on.
func (callable): Error function to evaluate.
fdata: Opaque data for func().
Returns:
float: Value at minimum.
"""
# ax, xx, bx # Search vector multipliers
# af, xf, bf # Function values at those points
# xt # Trial point
xt = {} if di <= 10 else dvector(0, di - 1) # Vector for trial point
# --------------------------
# First bracket the solution
ax, xx, bx, af, xf, bf = _linmin_bracket_solution(cp, xi, xt, di, func, fdata)
# ---------------------------------------
# Now use brent minimiser bewteen a and b
return _linmin_use_brent_minimiser(
ax,
xx,
bx,
af,
xf,
bf,
cp,
xi,
di,
ftol,
func,
fdata,
xt,
)
def _linmin_bracket_solution( # noqa: C901
cp: list[float],
xi: list[float],
xt: dict | list[float], # Vector for trial point
di: int,
func: Callable,
fdata: Any, # noqa: ANN401
) -> tuple[float, float, float, float, float, float]:
"""Bracket the solution for the line minimisation.
Args:
cp (list[float]): Start point, and returned value.
xi (list[float]): Search vector.
xt (dict | list[float]): Vector for trial point.
di (int): Dimensionality.
func (callable): Error function to evaluate.
fdata: Opaque data for func().
Returns:
tuple[float, float, float, float, float, float]: ax, xx, bx, af, xf,
bf - Search vector multipliers and function values at those points.
"""
powell_gold = 1.618034
logger.debug("linmin: Bracketing solution")
# The line is measured as startpoint + offset * search vector.
# (Search isn't symetric, but it seems to depend on cp being
# best current solution ?)
ax = 0.0
for i in range(di):
xt[i] = cp[i] + ax * xi[i]
af = func(fdata, xt)
# xx being vector offset 0.618
xx = 1.0 / powell_gold
for i in range(di):
xt[i] = cp[i] + xx * xi[i]
xf = func(fdata, xt)
logger.debug(f"linmin: Initial points a:{ax:f}:{af:f} -> b:{xx:f}:{xf:f}")
# Fix it so that we are decreasing from point a -> x
if xf > af:
tt = ax
ax = xx
xx = tt
tt = af
af = xf
xf = tt
logger.debug(f"linmin: Ordered Initial points a:{ax:f}:{af:f} -> b:{xx:f}:{xf:f}")
bx = xx + powell_gold * (xx - ax) # Guess b beyond a -> x
for i in range(di):
xt[i] = cp[i] + bx * xi[i]
bf = func(fdata, xt)
logger.debug(
f"linmin: Initial bracket a:{ax:f}:{af:f} x:{xx:f}:{xf:f} b:{bx:f}:{bf:f}"
)
# While not bracketed
while xf > bf:
logger.debug(f"linmin: Not bracketed because xf {xf:f} > bf {bf:f}")
logger.debug(f" ax = {ax:f}, xx = {xx:f}, bx = {bx:f}")
# Compute ux by parabolic interpolation from a, x & b
q = (xx - bx) * (xf - af)
r = (xx - ax) * (xf - bf)
tt = q - r
if 0.0 <= tt < 1e-20: # If +ve too small
tt = 1e-20
elif 0.0 >= tt > -1e-20: # If -ve too small
tt = -1e-20
ux = xx - ((xx - bx) * q - (xx - ax) * r) / (2.0 * tt)
ulim = xx + 100.0 * (bx - xx) # Extrapolation limit
if (xx - ux) * (ux - bx) > 0.0: # u is between x and b
for i in range(di): # Evaluate u
xt[i] = cp[i] + ux * xi[i]
uf = func(fdata, xt)
if uf < bf: # Minimum is between x and b
ax = xx
af = xf
xx = ux
xf = uf
break
if uf > xf: # Minimum is between a and u
bx = ux
bf = uf
break
# Parabolic fit didn't work, look further out in direction of b
ux = bx + powell_gold * (bx - xx)
elif (bx - ux) * (ux - ulim) > 0.0: # u is between b and limit
for i in range(di): # Evaluate u
xt[i] = cp[i] + ux * xi[i]
uf = func(fdata, xt)
if uf > bf: # Minimum is between x and u
ax = xx
af = xf
xx = bx
xf = bf
bx = ux
bf = uf
break
xx = bx
xf = bf # Continue looking
bx = ux
bf = uf
ux = bx + powell_gold * (bx - xx) # Test beyond b
elif (ux - ulim) * (ulim - bx) >= 0.0: # u is beyond limit
ux = ulim
else: # u is to left side of x ?
ux = bx + powell_gold * (bx - xx)
# Evaluate u, and move into place at b
for i in range(di):
xt[i] = cp[i] + ux * xi[i]
uf = func(fdata, xt)
ax = xx
af = xf
xx = bx
xf = bf
bx = ux
bf = uf
logger.debug(f"linmin: Got bracket a:{ax:f}:{af:f} x:{xx:f}:{xf:f} b:{bx:f}:{bf:f}")
# Got bracketed minimum between a -> x -> b
return ax, xx, bx, af, xf, bf # noqa: N806
def _linmin_use_brent_minimiser( # noqa: C901
ax: float,
xx: float,
bx: float,
af: float,
xf: float,
bf: float,
cp: list[float],
xi: list[float],
di: int,
ftol: float,
func: Callable,
fdata: Any, # noqa: ANN401
xt: dict | list[float], # Vector for trial point
) -> float:
"""Use Brent's method to find the minimum between a and b.
Adapted from ArgyllCMS numlib/powell.c
Args:
ax (float): Lower bound of the bracket.
xx (float): Current best point.
bx (float): Upper bound of the bracket.
af (float): Function value at ax.
xf (float): Function value at xx.
bf (float): Function value at bx.
cp (list[float]): Current point.
xi (list[float]): Search vector.
di (int): Dimensionality of the problem.
ftol (float): Tolerance for convergence.
func (Callable): Function to minimize.
fdata (Any): Opaque data for func().
xt (dict | list[float]): Vector for trial point.
Returns:
float: Value at minimum.
"""
powell_cgold = 0.3819660
powell_max_iterations = 100
# a and b bracket solution
# x is best function value so far
# w is second best function value so far
# v is previous second best, or third best
# u is most recently tested point
# wx, vx, ux # Search vector multipliers
# wf
vf = 0.0
# uf # Function values at those points
de = 0.0 # Distance moved on previous step
e = 0.0 # Distance moved on 2nd previous step
# Make sure a and b are in ascending order
if ax > bx:
tt = ax
ax = bx
bx = tt
tt = af
af = bf
bf = tt
wx = vx = xx # Initial values of other center points
wf = xf = xf
for _iter in range(1, powell_max_iterations + 1):
mx = 0.5 * (ax + bx) # m is center of bracket values
# if ABSTOL:
# tol1 = ftol # Absolute tollerance
# else:
tol1 = ftol * abs(xx) + 1e-10
tol2 = 2.0 * tol1
logger.debug(
f"linmin: Got bracket a:{ax:f}:{af:f} x:{xx:f}:{xf:f} b:{bx:f}:{bf:f}"
)
# See if we're done
if abs(xx - mx) <= (tol2 - 0.5 * (bx - ax)):
logger.debug(
"linmin: We're done because "
f"{abs(xx - mx):f} <= {tol2 - 0.5 * (bx - ax):f}"
)
break
if abs(e) > tol1: # Do a trial parabolic fit
r = (xx - wx) * (xf - vf)
q = (xx - vx) * (xf - wf)
p = (xx - vx) * q - (xx - wx) * r
q = 2.0 * (q - r)
if q > 0.0:
p = -p
else:
q = -q
te = e # Save previous e value
e = de # Previous steps distance moved
logger.debug("linmin: Trial parabolic fit")
if abs(p) >= abs(0.5 * q * te) or p <= q * (ax - xx) or p >= q * (bx - xx):
# Give up on the parabolic fit, and use the golden section search
e = (
ax - xx if xx >= mx else bx - xx
) # Override previous distance moved */
de = powell_cgold * e
logger.debug("linmin: Moving to golden section search")
else: # Use parabolic fit
de = p / q # Change in xb
ux = xx + de # Trial point according to parabolic fit
if (ux - ax) < tol2 or (bx - ux) < tol2:
# Don't use parabolic, use tol1 if (mx - xx) > 0.0: tol1 is +ve
de = tol1 if (mx - xx) > 0.0 else -tol1
logger.debug("linmin: Using parabolic fit")
else: # Keep using the golden section search
e = ax - xx if xx >= mx else bx - xx # Override previous distance moved
de = powell_cgold * e
logger.debug("linmin: Continuing golden section search")
if abs(de) >= tol1: # If de moves as much as tol1 would
ux = xx + de # use it
logger.debug(f"linmin: ux = {ux:f} = xx {xx:f} + de {de:f}")
elif de > 0.0:
ux = xx + tol1
logger.debug(f"linmin: ux = {ux:f} = xx {xx:f} + tol1 {tol1:f}")
else:
ux = xx - tol1
logger.debug(f"linmin: ux = {ux:f} = xx {xx:f} - tol1 {tol1:f}")
# Evaluate function
for i in range(di):
xt[i] = cp[i] + ux * xi[i]
uf = func(fdata, xt)
if uf <= xf: # Found new best solution
if ux >= xx:
ax = xx
af = xf # New lower bracket
else:
bx = xx
bf = xf # New upper bracket
vx = wx
vf = wf # New previous 2nd best solution
wx = xx
wf = xf # New 2nd best solution from previous best
xx = ux
xf = uf # New best solution from latest
logger.debug("linmin: found new best solution")
else: # Found a worse solution
if ux < xx:
ax = ux
af = uf # New lower bracket
else:
bx = ux
bf = uf # New upper bracket
if uf <= wf or wx == xx: # New 2nd best solution, or equal best
vx = wx
vf = wf # New previous 2nd best solution
wx = ux
wf = uf # New 2nd best from latest
elif uf <= vf or vx in [xx, wx]: # New 3rd best, or equal 1st & 2nd
vx = ux
vf = uf # New previous 2nd best from latest
logger.debug("linmin: found new worse solution")
# !!! should do something if iter > POWELL_MAXIT !!!!
# Solution is at xx, xf
# Compute solution vector
for i in range(di):
cp[i] += xx * xi[i]
return xf # Return value at minimum
def powell( # noqa: C901
di: int,
cp: list[float],
s: list[float],
ftol: float,
maxit: int,
func: Callable,
fdata: list,
prog: None | Callable = None,
pdata: None | list = None,
) -> bool:
"""Standard interface for powell function.
Adapted from ArgyllCMS `powell.c`.
Args:
di (int): Dimensionality of the problem.
cp (list[float]): Initial starting point, will be modified to the
solution.
s (list[float]): Size of initial search area, must be same length as
cp.
ftol (float): Tolerance of error change to stop on.
maxit (int): Maximum iterations allowed.
func (Callable): Error function to evaluate.
fdata (list): Opaque data needed by function.
prog (Callable | None): Optional progress percentage callback.
pdata: Opaque data needed by prog().
Returns:
bool: True on sucess, False on failure due to excessive iterions, result
will be in cp
"""
if prog is None:
def prog(*args, **kwargs) -> None:
"""Dummy progress function."""
dbl_epsilon = 2.2204460492503131e-016
# dmtx # Direction vector
# sp # Sarting point before exploring all the directions
# xpt # Extrapolated point
# svec # Search vector
# retv # Returned function value at p
# stopth # Current stop threshold */
startdel = -1.0 # Initial change in function value
# curdel # Current change in function value
pc = 0 # Percentage complete
dmtx = dmatrixz(0, di - 1, 0, di - 1) # Zero filled
spt = dvector(0, di - 1)
xpt = dvector(0, di - 1)
svec = dvector(0, di - 1)
# Create initial direction matrix by
# placing search start on diagonal
for i in range(di):
dmtx[i][i] = s[i]
# Save the starting point
spt[i] = cp[i]
# Report initial progress
prog(pdata, pc)
# Initial function evaluation
retv = func(fdata, cp)
# Iterate untill we converge on a solution, or give up.
for iter_ in range(1, maxit):
# lretv # Last function return value
ibig = 0 # Index of biggest delta
del_ = 0.0 # Biggest function value decrease
# pretv # Previous function return value
pretv = retv # Save return value at top of iteration
# Loop over all directions in the set
for i in range(di):
logger.debug(f"Looping over direction {i}")
for j in range(di): # Extract this direction to make search vector
svec[j] = dmtx[j][i]
# Minimize in that direction
lretv = retv
retv = linmin(cp, svec, di, ftol, func, fdata)
# Record bigest function decrease, and dimension it occurred on
if abs(lretv - retv) > del_:
del_ = abs(lretv - retv)
ibig = i
# if ABSTOL:
# stopth = ftol # Absolute tollerance
# else
stopth = ftol * 0.5 * (abs(pretv) + abs(retv) + dbl_epsilon)
curdel = abs(pretv - retv)
if startdel < 0.0:
startdel = curdel
elif curdel > 0 and startdel > 0:
tt = (
100.0
* math.pow(
(math.log(curdel) - math.log(startdel))
/ (math.log(stopth) - math.log(startdel)),
4.0,
)
+ 0.5
)
if pc < tt < 100:
pc = tt
# Report initial progress
prog(pdata, pc)
# If we have had at least one change of direction and
# reached a suitable tollerance, then finish
if iter_ > 1 and curdel <= stopth:
logger.debug(
f"Reached stop tollerance because curdel {curdel:f} <= stopth "
f"{stopth:f}"
)
break
logger.debug(f"Not stopping because curdel {curdel:f} > stopth {stopth:f}")
for i in range(di):
svec[i] = cp[i] - spt[i] # Average direction moved after minimization round
xpt[i] = cp[i] + svec[i] # Extrapolated point after round of minimization
spt[i] = cp[i] # New start point for next round
# Function value at extrapolated point
lretv = func(fdata, xpt)
if lretv >= pretv: # If extrapolation is not an improvement
continue
t1 = pretv - retv - del_
t2 = pretv - lretv
t = 2.0 * (pretv - 2.0 * retv + lretv) * t1 * t1 - del_ * t2 * t2
if t >= 0.0:
continue
# Move to the minimum of the new direction
retv = linmin(cp, svec, di, ftol, func, fdata)
for i in range(di): # Save the new direction
dmtx[i][ibig] = svec[i] # by replacing best previous
# Report final progress
prog(pdata, 100)
if iter_ < maxit:
return True
logger.debug("powell: returning False due to excessive iterations")
return False # Failed due to execessive iterations
def xicc_tech_gamma(
egamma: float, input_offset: float, output_offset: float = 0.0
) -> float:
"""Compute technical gamma for correct 50% response.
Adapted from ArgyllCMS xicc.c
Args:
egamma (float): The effective gamma.
input_offset (float): The input offset.
output_offset (float, optional): The output offset. Defaults to 0.0.
Returns:
float: The technical gamma.
"""
gf = GammaFits()
op = {}
sa = {}
if input_offset <= 0.0:
return egamma
# We set up targets without outo being added
outo = input_offset * output_offset # Offset acounted for in output
gf.bp = input_offset - outo # Black value for 0 % input
gf.wp = 1.0 - outo # White value for 100% input
gf.thyr = math.pow(0.5, egamma) - outo # Advetised 50% target
op[0] = egamma
sa[0] = 0.1
if not powell(1, op, sa, 1e-6, 500, gam_fit, gf):
logger.warning("Computing effective gamma and input offset is inaccurate!")
return op[0]
class GammaFits:
"""Gamma fits class for xicc technical gamma computation.
Adapted from ArgyllCMS xicc/xicc.c.
Args:
wp (float): 100% input target.
thyr (float): 50% input target.
bp (float): 0% input target.
"""
def __init__(self, wp: float = 1.0, thyr: float = 0.2, bp: float = 0.0) -> None:
self.wp = wp # 100% input target
self.thyr = thyr # 50% input target
self.bp = bp # 0% input target
class Interp:
"""Interpolation class.
Args:
xp (list): x values for interpolation.
fp (list): f(x) values for interpolation.
left (float, optional): Value to return for x < min(xp). Defaults to
None.
right (float, optional): Value to return for x > max(xp). Defaults to
None.
use_numpy (bool, optional): Use numpy for speed. Defaults to False.
"""
def __init__(
self,
xp: list[float],
fp: list[float],
left: None | float = None,
right: None | float = None,
use_numpy: bool = False,
) -> None:
if use_numpy:
# Use numpy for speed
xp = numpy.array(xp)
fp = numpy.array(fp)
self.xp = xp
self.fp = fp
self.left = left
self.right = right
self.lookup = {}
self.use_numpy = use_numpy
def __call__(self, x: float) -> float:
"""Return the interpolated value for x.
Args:
x (float): The x value to interpolate.
Returns:
float: The interpolated value at x.
"""
if x not in self.lookup:
self.lookup[x] = self._interp(x)
return self.lookup[x]
def _interp(self, x: float) -> float:
"""Perform the interpolation.
Args:
x (float): The x value to interpolate.
Returns:
float: The interpolated value at x.
"""
if self.use_numpy:
return numpy.interp(x, self.xp, self.fp, self.left, self.right)
return interp(x, self.xp, self.fp, self.left, self.right)
class BT1886:
"""BT.1886 like transfer function.
Adapted from ArgyllCMS xicc/xicc.c
Args:
matrix (Matrix): Matrix to use for forward and backward transformations.
XYZbp (tuple[float, float, float]): Black point in XYZ coordinates.
outoffset (float): Output offset. Defaults to 0.0.
gamma (float): Gamma value. Defaults to 2.4.
apply_trc (bool): Whether to apply the transfer curve. Defaults to True.
"""
def __init__(
self,
matrix: Matrix3x3,
XYZbp: tuple[float, float, float], # noqa: N803
outoffset: float = 0.0,
gamma: float = 2.4,
apply_trc: bool = True,
) -> None:
"""Setup BT.1886 for the given target.
If apply_trc is False, apply only the black point blending portion of
BT.1886 mapping. Note that this will only work correctly for an output
offset of 1.0
"""
if not apply_trc and outoffset < 1:
raise ValueError("Output offset must be 1.0 when not applying gamma")
self.bwd_matrix = matrix.inverted()
self.fwd_matrix = matrix
self.gamma = gamma
lab = XYZ2Lab(*[v * 100 for v in XYZbp])
# For bp blend
self.outL = lab[0]
# a* b* correction needed
self.tab = list(lab)
self.tab[0] = 0 # 0 because bt1886 maps L to target
if XYZbp[1] < 0:
XYZbp = list(XYZbp) # noqa: N806
XYZbp[1] = 0.0
# Offset acounted for in output
self.outo = XYZbp[1] * outoffset
# Balance of offset accounted for in input
ino = XYZbp[1] - self.outo
# Input offset black to 1/pow
bkipow = math.pow(ino, 1.0 / self.gamma)
# Input offset white to 1/pow
wtipow = math.pow(1.0 - self.outo, 1.0 / self.gamma)
# non-linear Y that makes input offset proportion of black point
self.ingo = bkipow / (wtipow - bkipow)
# Scale to make input of 1 map to 1.0 - self.outo
self.outsc = pow(wtipow - bkipow, self.gamma)
self.apply_trc = apply_trc
def apply(self, X: float, Y: float, Z: float) -> tuple[float, float, float]: # noqa: N803
"""Apply BT.1886 black offset + gamma curve to the XYZ out of the input profile.
Do this in the colorspace defined by the input profile matrix lookup,
so it will be relative XYZ. We assume that BT.1886 does a Rec709 to gamma
viewing adjustment, on top of any source profile transfer curve
(i.e. BT.1886 viewing adjustment is assumed to be the mismatch between
Rec709 curve and the output offset pure 2.4 gamma curve)
Args:
X (float): X value in XYZ
Y (float): Y value in XYZ
Z (float): Z value in XYZ
Returns:
tuple[float, float, float]: Adjusted XYZ values as a tuple (X, Y, Z).
"""
logger.debug(f"bt1886 XYZ in {X:f} {Y:f} {Z:f}")
out = self.bwd_matrix * (X, Y, Z)
logger.debug(f"bt1886 RGB in {out[0]:f} {out[1]:f} {out[2]:f}")
for j in range(3):
vv = out[j]
if self.apply_trc:
# Convert linear light to Rec709 transfer curve
vv = 4.5 * vv if vv < 0.018 else 1.099 * math.pow(vv, 0.45) - 0.099
# Apply input offset
vv = vv + self.ingo
# Apply power and scale
if vv > 0.0:
if self.apply_trc:
vv = self.outsc * math.pow(vv, self.gamma)
else:
vv *= self.outsc
# Apply output portion of offset
vv += self.outo
out[j] = vv
out = self.fwd_matrix * out
logger.debug(f"bt1886 RGB bt.1886 {out[0]:f} {out[1]:f} {out[2]:f}")
out = list(XYZ2Lab(*[v * 100 for v in out]))
logger.debug(f"bt1886 Lab after Y adj. {out[0]:f} {out[1]:f} {out[2]:f}")
# Blend ab to required black point offset self.tab[] as L approaches black.
vv = (out[0] - self.outL) / (100.0 - self.outL) # 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)
out[0] += vv * self.tab[0]
out[1] += vv * self.tab[1]
out[2] += vv * self.tab[2]
logger.debug(f"bt1886 Lab after wp adj. {out[0]:f} {out[1]:f} {out[2]:f}")
out = Lab2XYZ(*out)
logger.debug(f"bt1886 XYZ out {out[0]:f} {out[1]:f} {out[2]:f}")
return out
class BT2390:
"""Roll-off for SMPTE 2084 (PQ) according to Report ITU-R BT.2390-2 HDR TV.
Args:
black_cdm2 (float): Black level in cd/m^2.
white_cdm2 (float): White level in cd/m^2.
master_black_cdm2 (float, optional): Mastering black level in cd/m^2.
Defaults to 0.
master_white_cdm2 (float, optional): Mastering white level in cd/m^2.
Defaults to 10000.
use_alternate_master_white_clip (bool, optional): If True, use an
alternate method for mastering white clipping. Defaults to True.
"""
def __init__(
self,
black_cdm2: float,
white_cdm2: float,
master_black_cdm2: float = 0,
master_white_cdm2: float = 10000,
use_alternate_master_white_clip: bool = True,
) -> None:
"""Master black and white level are used to tweak the roll-off and clip.
If use_alternate_master_white_clip is True, do not follow BT.2390 for
the mastering white adjustment (allows to preserve more detail in
rolled-off highlights)
Args:
black_cdm2 (float): Black level in cd/m^2.
white_cdm2 (float): White level in cd/m^2.
master_black_cdm2 (float, optional): Mastering black level in
cd/m^2. Defaults to 0.
master_white_cdm2 (float, optional): Mastering white level in
cd/m^2. Defaults to 10000.
use_alternate_master_white_clip (bool, optional): If True, use an
alternate method for mastering white clipping. Defaults to
True.
"""
self.black_cdm2 = black_cdm2
self.white_cdm2 = white_cdm2
self.master_black_cdm2 = master_black_cdm2
self.master_white_cdm2 = master_white_cdm2
self.ominv = black_cdm2 / 10000.0 # Lmin
self.omini = special_pow(self.ominv, 1.0 / -2084) # Original minLum
self.omaxv = white_cdm2 / 10000.0 # Lmax
self.omaxi = special_pow(self.omaxv, 1.0 / -2084) # Original maxLum
self.oKS = 1.5 * self.omaxi - 0.5
# BT.2390-2
self.mminv = master_black_cdm2 / 10000.0 # LB
self.mmini = special_pow(self.mminv, 1.0 / -2084)
self.mmaxv = master_white_cdm2 / 10000.0 # LW
mmaxi = special_pow(self.mmaxv, 1.0 / -2084)
if use_alternate_master_white_clip:
self.maxci = (mmaxi - self.mmini) / (1 - self.mmini)
self.mmaxi = 1.0
else:
self.maxci = 1.0
self.mmaxi = mmaxi
self.mini = (self.omini - self.mmini) / (
self.mmaxi - self.mmini
) # Normalized minLum
self.minv = special_pow(self.mini, -2084)
self.maxi = (self.omaxi - self.mmini) / (
self.mmaxi - self.mmini
) # Normalized maxLum
self.maxv = special_pow(self.maxi, -2084)
self.KS = 1.5 * self.maxi - 0.5
if self.maxi <= self.maxci < 1:
e2 = self.P(self.maxci, self.KS, self.maxi)
diff = self.maxci - e2
self.s = (self.maxci - self.maxi) / diff
def P(self, B: float, KS: float, maxi: float, maxci: float = 1.0) -> float: # noqa: N802, N803
"""Apply the roll-off function P(E1) to the input value E1.
Args:
B (float): Input value E1 to apply the roll-off to.
KS (float): The KS value.
maxi (float): The maximum input value.
maxci (float, optional): The maximum clip input value. Defaults to
1.0.
Returns:
float: The output value after applying the roll-off.
""" # noqa: D402
t = (B - KS) / (1 - KS)
e2 = (
(2 * t**3 - 3 * t**2 + 1) * KS
+ (t**3 - 2 * t**2 + t) * (1 - KS)
+ (-2 * t**3 + 3 * t**2) * maxi
)
if maxci < 1:
# (Old) Clipping for better target display peak luminance usage
# XXX: Only kept for backwards compatibility
s = min(((B - KS) / (maxci - KS)) ** 4, 1)
e2 = e2 * (1 - s) + maxi * s
return e2
def apply(
self,
v: float,
KS: None | float = None, # noqa: N803
maxi: None | float = None,
maxci: None | float = None,
mini: None | float = None,
mmaxi: None | float = None,
mmini: None | float = None,
bpc: bool = False,
normalize: bool = True,
) -> float:
"""Apply roll-off (E' in, E' out) maxci if < 1.0 applies alterante clip.
Args:
v (float): Input value to apply roll-off to.
KS (float, optional): The KS value. Defaults to self.KS.
maxi (float, optional): The maximum input value. Defaults to
self.maxi.
maxci (float, optional): The maximum clip input value. Defaults to
self.maxci.
mini (float, optional): The minimum input value. Defaults to
self.mini.
mmaxi (float, optional): The mastering maximum input value.
Defaults to self.mmaxi.
mmini (float, optional): The mastering minimum input value.
Defaults to self.mmini.
bpc (bool, optional): If True, apply black point compensation.
Defaults to False.
normalize (bool, optional): If True, normalize PQ values based on
mastering display black/white levels. Defaults to True.
Returns:
float: The output value after applying the roll-off.
"""
KS = self.KS if KS is None else KS # noqa: N806
maxi = self.maxi if maxi is None else maxi
mini = self.mini if mini is None else mini
mmaxi = self.mmaxi if mmaxi is None else mmaxi
mmini = self.mmini if mmini is None else mmini
maxci = self.maxci if maxci is None else maxci
if normalize and mmini is not None and mmaxi is not None:
# Normalize PQ values based on mastering display black/white levels
e1 = min(max((v - mmini) / (mmaxi - mmini), 0), 1.0)
else:
e1 = v
# BT.2390-3 suggests P[E1] if KS <= E1 <=1, but this results in
# division by zero if KS = 1. The correct way is to check for
# KS < E1 <=1
if KS < e1 <= 1:
e2 = self.P(e1, KS, maxi)
if maxi <= maxci < 1:
# (New) Clipping for better target display peak luminance usage
s = self.s
diff = e1 - e2
e2 = min(e1 - diff * s, maxi)
elif maxci < 1:
e2 = min(e1, maxci)
else:
e2 = e1
# BT.2390-3 suggests 0 <= E2 <= 1, but this results in a discontinuity
# if KS < 0 (high LB > Lmin, low Lmax, high LW). To avoid this, check
# for E2 <= 1 instead
if mini and e2 <= 1:
# Apply black level lift
min_lum = mini
# maxLum = maxi
b = min_lum
# BT.2390-3 suggests E2 + b * (1 - E2) ** 4, but this clips, if
# minLum > 0.25, due to a 'dip' in the function. The solution is to
# adjust the exponent according to minLum. For minLum <= 0.25
# (< 5.15 cd/m2), this will give the same result as 'pure' BT.2390-3
# Only for positive b i.e. minLum >= LB if b >= 0,
# otherwise for negative b i.e. minLum < LB
p = min(1.0 / b, 4) if b >= 0 else 4
e3 = e2 + b * (1 - e2) ** p
# If maxLum < 1, and the input value reaches maxLum, the resulting
# output value will be higher than maxLum after applying the black
# level lift (note that this is *not* a side effect of the above
# exponent adjustment). Undo this by re-scaling to the nominal output
# range [minLum, maxLum].
if maxi < 1:
# Only re-scale if maxLum < 1. Note that maxLum can be > 1
# if Lmax > LW despite E2 <= 1
e3 = convert_range(e3, b, maxi + b * (1 - maxi) ** p, b, maxi)
else:
e3 = e2
if bpc:
e3 = convert_range(e3, mini, maxi, 0, maxi)
if normalize and mmini is not None and mmaxi is not None:
# Invert the normalization of the PQ values
e3 = e3 * (mmaxi - mmini) + mmini
return max(e3, 0)
class Matrix3x3(list):
"""Simple 3x3 matrix.
Args:
matrix (list tuple, optional): A 3x3 matrix to initialize with.
Defaults to None.
"""
def __init__(self, matrix: None | list | tuple = None) -> None:
super().__init__()
self._reset()
# TODO: Matrix should initialize to identity matrix if None or empty.
# if matrix is None or (isinstance(matrix, (list, tuple)) and len(matrix) == 0):
# matrix = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
if matrix:
self.update(matrix)
def update(self, matrix: list | tuple) -> None:
"""Update the matrix with a new 3x3 matrix.
Args:
matrix (list | tuple): A 3x3 matrix to update with.
Raises:
ValueError: If the matrix is not 3x3.
ValueError: If the rows or columns of the matrix are not of length 3.
"""
if len(matrix) != 3:
raise ValueError(f"Invalid number of rows for 3x3 matrix: {len(matrix)}")
self._reset()
while len(self):
self.pop()
for row in matrix:
if len(row) != 3:
raise ValueError(
f"Invalid number of columns for 3x3 matrix: {len(row)}"
)
self.append([])
for column in row:
self[-1].append(column)
def _reset(self) -> None:
self._inverted = None
self._transposed = None
self._rounded = {}
self._applied = {}
def __add__(self, matrix: list | tuple | Matrix3x3) -> Matrix3x3:
"""Matrix addition.
Args:
matrix (Matrix3x3 or list or tuple): The matrix to add.
Returns:
Matrix3x3: The result of the addition.
"""
instance = self.__class__()
instance.update(
[
[
self[0][0] + matrix[0][0],
self[0][1] + matrix[0][1],
self[0][2] + matrix[0][2],
],
[
self[1][0] + matrix[1][0],
self[1][1] + matrix[1][1],
self[1][2] + matrix[1][2],
],
[
self[2][0] + matrix[2][0],
self[2][1] + matrix[2][1],
self[2][2] + matrix[2][2],
],
]
)
return instance
def __iadd__(self, matrix: list | tuple | Matrix3x3) -> Self:
"""Matrix addition in place."""
# inplace
self.update(self.__add__(matrix))
return self
@overload
def __imul__(
self, matrix: list[float, float, float]
) -> list[float, float, float]: ...
@overload
def __imul__(
self, matrix: tuple[float, float, float]
) -> list[float, float, float]: ...
@overload
def __imul__(self, matrix: Matrix3x3) -> Self: ...
def __imul__(self, matrix) -> Self:
"""Matrix multiplication.
Args:
matrix (Matrix3x3 or list or tuple): The matrix to multiply with.
"""
# inplace
self.update(self.__mul__(matrix))
return self
@overload
def __mul__(
self, matrix: list[float, float, float]
) -> list[float, float, float]: ...
@overload
def __mul__(
self, matrix: tuple[float, float, float]
) -> list[float, float, float]: ...
@overload
def __mul__(self, matrix: Matrix3x3) -> Matrix3x3: ...
def __mul__(self, matrix):
"""Matrix multiplication.
Args:
matrix (Matrix3x3 or list or tuple): The matrix to multiply with.
"""
if not isinstance(matrix[0], (list, tuple)):
return [
self[0][0] * matrix[0]
+ self[0][1] * matrix[1]
+ self[0][2] * matrix[2],
self[1][0] * matrix[0]
+ self[1][1] * matrix[1]
+ self[1][2] * matrix[2],
self[2][0] * matrix[0]
+ self[2][1] * matrix[1]
+ self[2][2] * matrix[2],
]
instance = self.__class__()
instance.update(
[
[
self[0][0] * matrix[0][0]
+ self[0][1] * matrix[1][0]
+ self[0][2] * matrix[2][0],
self[0][0] * matrix[0][1]
+ self[0][1] * matrix[1][1]
+ self[0][2] * matrix[2][1],
self[0][0] * matrix[0][2]
+ self[0][1] * matrix[1][2]
+ self[0][2] * matrix[2][2],
],
[
self[1][0] * matrix[0][0]
+ self[1][1] * matrix[1][0]
+ self[1][2] * matrix[2][0],
self[1][0] * matrix[0][1]
+ self[1][1] * matrix[1][1]
+ self[1][2] * matrix[2][1],
self[1][0] * matrix[0][2]
+ self[1][1] * matrix[1][2]
+ self[1][2] * matrix[2][2],
],
[
self[2][0] * matrix[0][0]
+ self[2][1] * matrix[1][0]
+ self[2][2] * matrix[2][0],
self[2][0] * matrix[0][1]
+ self[2][1] * matrix[1][1]
+ self[2][2] * matrix[2][1],
self[2][0] * matrix[0][2]
+ self[2][1] * matrix[1][2]
+ self[2][2] * matrix[2][2],
],
]
)
return instance
def adjoint(self) -> Matrix3x3:
"""Return adjoint matrix.
Returns:
Matrix3x3: Adjoint matrix.
"""
return self.cofactors().transposed()
def applied(self, fn: Callable) -> Matrix3x3:
"""Apply function to every element, return new matrix.
Args:
fn (callable): Function to apply to each element of the matrix.
Returns:
Matrix3x3: A new Matrix3x3 with the function applied to each element.
"""
if fn in self._applied:
return self._applied[fn]
matrix = self.__class__()
for row in self:
matrix.append([])
for column in row:
matrix[-1].append(fn(column))
self._applied[fn] = matrix
return matrix
def cofactors(self) -> Matrix3x3:
"""Return cofactor matrix.
Returns:
Matrix3x3: Cofactor matrix.
"""
instance = self.__class__()
instance.update(
[
[
(self[1][1] * self[2][2] - self[1][2] * self[2][1]),
-1 * (self[1][0] * self[2][2] - self[1][2] * self[2][0]),
(self[1][0] * self[2][1] - self[1][1] * self[2][0]),
],
[
-1 * (self[0][1] * self[2][2] - self[0][2] * self[2][1]),
(self[0][0] * self[2][2] - self[0][2] * self[2][0]),
-1 * (self[0][0] * self[2][1] - self[0][1] * self[2][0]),
],
[
(self[0][1] * self[1][2] - self[0][2] * self[1][1]),
-1 * (self[0][0] * self[1][2] - self[1][0] * self[0][2]),
(self[0][0] * self[1][1] - self[0][1] * self[1][0]),
],
]
)
return instance
def determinant(self) -> float:
"""Return determinant of the matrix.
Returns:
float: Determinant of the matrix.
"""
return (
self[0][0] * self[1][1] * self[2][2]
+ self[1][0] * self[2][1] * self[0][2]
+ self[0][1] * self[1][2] * self[2][0]
) - (
self[2][0] * self[1][1] * self[0][2]
+ self[1][0] * self[0][1] * self[2][2]
+ self[2][1] * self[1][2] * self[0][0]
)
def invert(self) -> None:
"""Invert the matrix in place."""
# inplace
self.update(self.inverted())
def inverted(self) -> Matrix3x3:
"""Return inverted matrix.
Returns:
Matrix3x3: Inverted matrix.
"""
if self._inverted:
return self._inverted
determinant = self.determinant()
matrix = self.adjoint()
instance = self.__class__()
instance.update(
[
[
matrix[0][0] / determinant,
matrix[0][1] / determinant,
matrix[0][2] / determinant,
],
[
matrix[1][0] / determinant,
matrix[1][1] / determinant,
matrix[1][2] / determinant,
],
[
matrix[2][0] / determinant,
matrix[2][1] / determinant,
matrix[2][2] / determinant,
],
]
)
self._inverted = instance
return instance
def rounded(self, digits: int = 3) -> Matrix3x3:
"""Round each element of the matrix to the specified number of digits.
Args:
digits (int): Number of digits to round to. Default is 3.
Returns:
Matrix3x3: A new Matrix3x3 with each element rounded to the
specified number of digits.
"""
if digits in self._rounded:
return self._rounded[digits]
matrix = self.__class__()
for row in self:
matrix.append([])
for column in row:
matrix[-1].append(round(column, digits))
self._rounded[digits] = matrix
return matrix
def transpose(self) -> None:
"""Transpose the matrix in place."""
self.update(self.transposed())
def transposed(self) -> Matrix3x3:
"""Return transposed matrix.
Returns:
Matrix3x3: Transposed matrix.
"""
if self._transposed:
return self._transposed
instance = self.__class__()
instance.update(
[
[self[0][0], self[1][0], self[2][0]],
[self[0][1], self[1][1], self[2][1]],
[self[0][2], self[1][2], self[2][2]],
]
)
self._transposed = instance
return instance
def __hash__(self) -> int:
"""Make the Matrix3x3 hashable."""
return hash(
f"{self[0][0]},{self[1][0]},{self[2][0]},"
f"{self[0][1]},{self[1][1]},{self[2][1]},"
f"{self[0][2]},{self[1][2]},{self[2][2]}"
)
def __eq__(self, other: list | tuple | Matrix3x3) -> bool:
"""Check if two matrices are equal.
Args:
other (Matrix3x3): The other matrix to compare with.
Returns:
bool: True if the matrices are equal, False otherwise.
"""
if not isinstance(other, (list, tuple, Matrix3x3)):
return False
return (
self[0][0] == other[0][0]
and self[0][1] == other[0][1]
and self[0][2] == other[0][2]
and self[1][0] == other[1][0]
and self[1][1] == other[1][1]
and self[1][2] == other[1][2]
and self[2][0] == other[2][0]
and self[2][1] == other[2][1]
and self[2][2] == other[2][2]
)
class NumberTuple(tuple):
"""Simple tuple with a few extra methods."""
__slots__ = ()
def __repr__(self) -> str:
"""Return a string representation of the tuple.
Returns:
str: String representation of the tuple.
"""
return "({})".format(", ".join(str(value) for value in self))
def round(self, digits: int = 4) -> NumberTuple:
"""Round each element of the tuple to the specified number of digits.
Args:
digits (int): Number of digits to round to. Default is 4.
Returns:
NumberTuple: A new NumberTuple with each element rounded to the
specified number of digits.
"""
return self.__class__(round(value, digits) for value in self)
# Chromatic adaption transform matrices
# Bradford, von Kries (= HPE normalized to D65) from http://brucelindbloom.com/Eqn_ChromAdapt.html
# CAT02 from http://en.wikipedia.org/wiki/CIECAM02#CAT02
# HPE normalized to illuminant E, CAT97s from http://en.wikipedia.org/wiki/LMS_color_space#CAT97s
# CMCCAT2000, Sharp from 'Computational colour science using MATLAB'
# ISBN 0470845627, http://books.google.com/books?isbn=0470845627
# Cross-verification of the matrix numbers has been done using various sources,
# most notably 'Chromatic Adaptation Performance of Different RGB Sensors'
# http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.14.918&rep=rep1&type=pdf
CAT_MATRICES = {
"Bradford": Matrix3x3(
[
[0.89510, 0.26640, -0.16140],
[-0.75020, 1.71350, 0.03670],
[0.03890, -0.06850, 1.02960],
]
),
"CAT02": Matrix3x3(
[[0.7328, 0.4296, -0.1624], [-0.7036, 1.6975, 0.0061], [0.0030, 0.0136, 0.9834]]
),
# Brill & Süsstrunk modification also found in ArgyllCMS
"CAT02BS": Matrix3x3(
[[0.7328, 0.4296, -0.1624], [-0.7036, 1.6975, 0.0061], [0.0000, 0.0000, 1.0000]]
),
"CAT97s": Matrix3x3(
[
[0.8562, 0.3372, -0.1934],
[-0.8360, 1.8327, 0.0033],
[0.0357, -0.0469, 1.0112],
]
),
"CMCCAT2000": Matrix3x3(
[[0.7982, 0.3389, -0.1371], [-0.5918, 1.5512, 0.0406], [0.0008, 0.0239, 0.9753]]
),
# Hunt-Pointer-Estevez, equal-energy illuminant
"HPE E": Matrix3x3(
[
[0.38971, 0.68898, -0.07868],
[-0.22981, 1.18340, 0.04641],
[0.00000, 0.00000, 1.00000],
]
),
# Süsstrunk et al.15 optimized spectrally sharpened matrix
"Sharp": Matrix3x3(
[
[1.2694, -0.0988, -0.1706],
[-0.8364, 1.8006, 0.0357],
[0.0297, -0.0315, 1.0018],
]
),
# 'Von Kries' as found on Bruce Lindbloom's site:
# Hunt-Pointer-Estevez normalized to D65
# (maybe I should call it that instead of 'Von Kries'
# to avoid ambiguity?)
"HPE D65": Matrix3x3(
[
[0.40024, 0.70760, -0.08081],
[-0.22630, 1.16532, 0.04570],
[0.00000, 0.00000, 0.91822],
]
),
"XYZ scaling": Matrix3x3([[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
"IPT": Matrix3x3(
[[0.4002, 0.7075, -0.0807], [-0.2280, 1.1500, 0.0612], [0.0000, 0.0000, 0.9184]]
),
# Inverse CIE 2012 2deg LMS to XYZ matrix from Argyll/icc/icc.c
"CIE2012_2": Matrix3x3(
[
[0.2052445519046028, 0.8334486497310412, -0.0386932016356441],
[-0.4972221301804286, 1.4034846060306130, 0.0937375241498157],
[0.0000000000000000, 0.0000000000000000, 1.0000000000000000],
]
),
# Inverse CIE 2015 2deg LMS to XYZ matrix from Argyll/icc/icc.c
"CIE2015_2": Matrix3x3(
[
[0.2052445519046028, 0.8334486497310412, -0.0386932016356441],
[-0.4972221301804286, 1.4034846060306130, 0.0937375241498157],
[0.0000000000000000, 0.0000000000000000, 1.0000000000000000],
]
),
# Bianco and Schettini (2010)
"BS": Matrix3x3(
[
[0.8752, 0.2787, -0.1539],
[-0.8904, 1.8709, 0.0195],
[-0.0061, 0.0162, 0.9899],
]
),
# Bianco and Schettini (2010) with positivity constraint
"BS-PC": Matrix3x3(
[
[0.6489, 0.3915, -0.0404],
[-0.3775, 1.3055, 0.0720],
[-0.0271, 0.0888, 0.9383],
]
),
}
LMS2IPT_matrix = Matrix3x3(
[[0.4000, 0.4000, 0.2000], [4.4550, -4.8510, 0.3960], [0.8056, 0.3572, -1.1628]]
)
IPT2LMS_matrix = LMS2IPT_matrix.inverted()
LinearRGB2LMS_matrix = Matrix3x3(
[
[1688 / 4096.0, 2146 / 4096.0, 262 / 4096.0],
[683 / 4096.0, 2951 / 4096.0, 462 / 4096.0],
[99 / 4096.0, 309 / 4096.0, 3688 / 4096.0],
]
)
LMS2LinearRGB_matrix = LinearRGB2LMS_matrix.inverted()
L_M_S_2ICtCp_matrix = Matrix3x3(
[
[0.5, 0.5, 0],
[6610 / 4096.0, -13613 / 4096.0, 7003 / 4096.0],
[17933 / 4096.0, -17390 / 4096.0, -543 / 4096.0],
]
)
ICtCp2L_M_S__matrix = L_M_S_2ICtCp_matrix.inverted()
# Tweaked LMS to IPT matrix to account for CIE 2012 2deg XYZ to LMS matrix
# From Argyll/icc/icc.c
LMS2Lpt_matrix = Matrix3x3(
[
[0.6585034777870502, 0.1424555300344579, 0.1990409921784920],
[5.6413505933276049, -6.1697985811414187, 0.5284479878138138],
[1.6370552576322106, 0.0192823194340315, -1.6563375770662419],
]
)
Lpt2LMS_matrix = LMS2Lpt_matrix.inverted()
standard_illuminants = {
# 1st level is the standard name => illuminant definitions
# 2nd level is the illuminant name => CIE XYZ coordinates
# (Y should always assumed to be 1.0 and is not explicitly defined)
None: {"E": {"X": 1.00000, "Z": 1.00000}},
"ASTM E308-01": {
"A": {"X": 1.09850, "Z": 0.35585},
"C": {"X": 0.98074, "Z": 1.18232},
"D50": {"X": 0.96422, "Z": 0.82521},
"D55": {"X": 0.95682, "Z": 0.92149},
"D65": {"X": 0.95047, "Z": 1.08883},
"D75": {"X": 0.94972, "Z": 1.22638},
"F2": {"X": 0.99186, "Z": 0.67393},
"F7": {"X": 0.95041, "Z": 1.08747},
"F11": {"X": 1.00962, "Z": 0.64350},
},
"ICC": {"D50": {"X": 0.9642, "Z": 0.8249}, "D65": {"X": 0.9505, "Z": 1.0890}},
"ISO 11664-2:2007": {
"D65": {"X": xyY2XYZ(0.3127, 0.329)[0], "Z": xyY2XYZ(0.3127, 0.329)[2]}
},
"Wyszecki & Stiles": {
"A": {"X": 1.09828, "Z": 0.35547},
"B": {"X": 0.99072, "Z": 0.85223},
"C": {"X": 0.98041, "Z": 1.18103},
"D55": {"X": 0.95642, "Z": 0.92085},
"D65": {"X": 0.95017, "Z": 1.08813},
"D75": {"X": 0.94939, "Z": 1.22558},
},
}
# CIE 1931 2-deg chromaticity coordinates
# http://www.cvrl.org/offercsvccs.php
cie1931_2_xy = [
(0.175560, 0.005294),
(0.175161, 0.005256),
(0.174821, 0.005221),
(0.174510, 0.005182),
(0.174112, 0.004964),
(0.174008, 0.004981),
(0.173801, 0.004915),
(0.173560, 0.004923),
(0.173337, 0.004797),
(0.173021, 0.004775),
(0.172577, 0.004799),
(0.172087, 0.004833),
(0.171407, 0.005102),
(0.170301, 0.005789),
(0.168878, 0.006900),
(0.166895, 0.008556),
(0.164412, 0.010858),
(0.161105, 0.013793),
(0.156641, 0.017705),
(0.150985, 0.022740),
(0.143960, 0.029703),
(0.135503, 0.039879),
(0.124118, 0.057803),
(0.109594, 0.086843),
(0.091294, 0.132702),
(0.068706, 0.200723),
(0.045391, 0.294976),
(0.023460, 0.412703),
(0.008168, 0.538423),
(0.003859, 0.654823),
(0.013870, 0.750186),
(0.038852, 0.812016),
(0.074302, 0.833803),
(0.114161, 0.826207),
(0.154722, 0.805864),
(0.192876, 0.781629),
(0.229620, 0.754329),
(0.265775, 0.724324),
(0.301604, 0.692308),
(0.337363, 0.658848),
(0.373102, 0.624451),
(0.408736, 0.589607),
(0.444062, 0.554714),
(0.478775, 0.520202),
(0.512486, 0.486591),
(0.544787, 0.454434),
(0.575151, 0.424232),
(0.602933, 0.396497),
(0.627037, 0.372491),
(0.648233, 0.351395),
(0.665764, 0.334011),
(0.680079, 0.319747),
(0.691504, 0.308342),
(0.700606, 0.299301),
(0.707918, 0.292027),
(0.714032, 0.285929),
(0.719033, 0.280935),
(0.723032, 0.276948),
(0.725992, 0.274008),
(0.728272, 0.271728),
(0.729969, 0.270031),
(0.731089, 0.268911),
(0.731993, 0.268007),
(0.732719, 0.267281),
(0.733417, 0.266583),
(0.734047, 0.265953),
(0.734390, 0.265610),
(0.734592, 0.265408),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734548, 0.265452),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
(0.734690, 0.265310),
]
OPTIMAL_COLORS_LAB = [
(52.40, 95.40, 10.58),
(52.33, 91.23, 38.56),
(52.31, 89.09, 65.80),
(52.30, 88.24, 89.93),
(59.11, 84.13, 101.46),
(66.02, 75.66, 113.09),
(72.36, 64.33, 123.65),
(78.27, 50.88, 132.94),
(83.64, 36.33, 140.63),
(88.22, 22.05, 145.02),
(92.09, 8.49, 143.95),
(90.38, -4.04, 141.05),
(87.54, -23.02, 136.16),
(85.18, -37.06, 132.16),
(82.10, -52.65, 126.97),
(85.53, -65.59, 122.51),
(82.01, -81.46, 116.55),
(77.35, -97.06, 108.72),
(74.76, -122.57, 90.91),
(68.33, -134.27, 80.11),
(63.07, -152.99, 56.41),
(54.57, -159.74, 42.75),
(44.43, -162.58, 27.45),
(46.92, -162.26, 13.87),
(48.53, -144.04, -4.73),
(49.50, -115.82, -25.38),
(59.18, -85.50, -47.00),
(59.33, -68.64, -58.79),
(59.41, -52.73, -69.57),
(50.80, -25.33, -84.08),
(42.05, 8.67, -98.57),
(33.79, 43.74, -111.63),
(26.63, 74.31, -121.90),
(20.61, 98.44, -128.77),
(14.87, 117.34, -131.97),
(9.74, 127.16, -129.59),
(5.20, 125.79, -120.43),
(7.59, 122.01, -116.33),
(10.21, 117.89, -111.81),
(26.35, 115.11, -100.95),
(40.68, 115.59, -87.47),
(39.37, 115.48, -78.51),
(46.49, 114.84, -66.24),
(53.49, 111.63, -54.17),
(52.93, 107.54, -38.16),
(52.58, 101.53, -16.45),
(52.40, 95.40, 10.58),
]
def debug_caches() -> None:
"""Debug caches for duplicate entries."""
for cache_name in (
"XYZ2RGB.interp",
"wp_adaption_matrix.cache",
"get_rgb_space.cache",
"get_standard_illuminant.cache",
"get_whitepoint.cache",
):
cn, ck = cache_name.split(".")
c = getattr(globals()[cn], ck)
count = 0
seen = {}
for k in c:
v = c[k]
for kk in c:
vv = c[kk]
# Check for equality, not identity
if k != kk and v == vv and kk not in seen:
count += 1
seen[kk] = True
print(cache_name, len(c), "entries", max(count - 1, 0), "duplicates")
if count > 1:
for k in c:
v = c[k]
print(k, v)
if "--debug-caches" in sys.argv[1:]:
import atexit
atexit.register(debug_caches)
displaycal-py3-3.9.19/DisplayCAL/colorspace_to_vrml.py 000664 000000 000000 00000133215 15225167330 022637 0 ustar 00root root 000000 000000 """Colorspace to VRML conversion for DisplayCAL."""
from __future__ import annotations
import math
import os
from enum import Enum
from typing import TYPE_CHECKING
from DisplayCAL import colormath, x3dom
from DisplayCAL.log import safe_print
from DisplayCAL.util_io import GzipFileProper
if TYPE_CHECKING:
from pathlib import Path
from DisplayCAL.cgats import CGATS
class CAT(Enum):
"""Chromatic adaptation transform (CAT) enumeration."""
Bradford = "Bradford"
BS = "BS"
BS_PC = "BS-PC"
CAT02 = "CAT02"
CAT02BS = "CAT02BS"
CAT97s = "CAT97s"
CIE2012_2 = "CIE2012_2"
CMCCAT2000 = "CMCCAT2000"
HPE_D65 = "HPE D65"
HPE_E = "HPE E"
IPT = "IPT"
Sharp = "Sharp"
XYZ_Scaling = "XYZ scaling"
def __str__(self) -> str:
"""Get the string representation of the CAT."""
return self.value
@classmethod
def to_cat(cls, cat: str | CAT) -> CAT:
"""Convert the given cat value to a CAT enum.
Args:
cat (str | CAT): The value to convert to a CAT.
Raises:
TypeError: Input value type is invalid.
ValueError: Input value is invalid.
Returns:
CAT: The enum.
"""
valid_values = sorted(set([c.name for c in cls] + [c.value for c in cls]))
if not isinstance(cat, (str, CAT)):
raise TypeError(
f"cat should be a CAT enum value or one of {valid_values}, "
f"not {cat.__class__.__name__}: '{cat}'"
)
if isinstance(cat, str):
cat_name_lut = {c.name.lower(): c.name for c in cls}
cat_name_lut.update({c.value.lower(): c.name for c in cls})
cat_lower_case = cat.lower()
if cat_lower_case not in cat_name_lut:
raise ValueError(
f"cat should be a CAT enum value or one of {valid_values}, "
f"not '{cat}'"
)
return cls.__members__[cat_name_lut[cat_lower_case]]
return cat
class ColorSpace(Enum):
"""Color space enumeration."""
DIN99 = "DIN99"
DIN99b = "DIN99b"
DIN99c = "DIN99c"
DIN99d = "DIN99d"
HSI = "HSI"
HSL = "HSL"
HSV = "HSV"
ICtCp = "ICtCp"
IPT = "IPT"
Lab = "Lab"
LCHab = "LCH(ab)"
LCHuv = "LCH(uv)"
Lpt = "Lpt"
LuvPrime = "Lu'v'"
Luv = "Luv"
RGB = "RGB"
xyY = "xyY" # noqa: N815
def __str__(self) -> str:
"""Get the string representation of the ColorSpace."""
return self.value
@classmethod
def to_colorspace(cls, colorspace: str | ColorSpace) -> ColorSpace:
"""Convert the given colorspace value to a ColorSpace enum.
Args:
colorspace (str | ColorSpace): The value to convert to a ColorSpace.
Raises:
TypeError: Input value type is invalid.
ValueError: Input value is invalid.
Returns:
ColorSpace: The enum.
"""
valid_values = sorted(set([c.name for c in cls] + [c.value for c in cls]))
if not isinstance(colorspace, (str, ColorSpace)):
raise TypeError(
"colorspace should be a ColorSpace enum value or one of "
f"{valid_values}, not {colorspace.__class__.__name__}: '{colorspace}'"
)
if isinstance(colorspace, str):
colorspace_name_lut = {c.name.lower(): c.name for c in cls}
colorspace_name_lut.update({c.value.lower(): c.name for c in cls})
colorspace_lower_case = colorspace.lower()
if colorspace_lower_case not in colorspace_name_lut:
raise ValueError(
"colorspace should be a ColorSpace enum value or one of "
f"{valid_values}, not '{colorspace}'"
)
return cls.__members__[colorspace_name_lut[colorspace_lower_case]]
return colorspace
def __eq__(self, other: object) -> bool:
"""Check equality with another ColorSpace or string.
Args:
other (object): The object to compare with.
Returns:
bool: True if equal, False otherwise.
"""
if isinstance(other, str):
return (
self.value.lower() == other.lower()
or self.name.lower() == other.lower()
)
if isinstance(other, ColorSpace):
return self.value == other.value
return False
class ColorSpaceToVRML:
"""Color space class for easy VRML.
Args:
data (dict | CGATS): The color data to be processed, could be a
dictionary or a CGATS instance containing color values ("DATA").
white_point (tuple[float, float, float]): The white point for the color
space.
cat (str): The chromatic adaptation transform to use. Defaults to
"Bradford".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to
40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to
False.
"""
sqrt3_100 = math.sqrt(3) * 100
sqrt3_50 = math.sqrt(3) * 50
VALID_COLOR_SPACE_NAMES = tuple(c.value for c in ColorSpace)
VRML_TEMPLATE = """#VRML V2.0 utf8
Transform {{
children [
NavigationInfo {{
type "EXAMINE"
}}
DirectionalLight {{
direction 0 0 -1
direction 0 -1 0
}}
Viewpoint {{
fieldOfView {fov}
position 0 0 {offset_z}
}}
{axes}
{children}
]
}}
"""
VRML_CHILD_TEMPLATE = """ # Sphere
Transform {{
translation {offset_x:.6f} {offset_y:.6f} {offset_z:.6f}
children [
Shape{{
geometry Sphere {{ radius {radius:.6f} }}
appearance Appearance {{ material Material {{ diffuseColor {R:.6f} {G:.6f} {B:.6f} }} }}
}}
]
}}
""" # noqa: E501
VRML_AXES_TEMPLATE = """ Transform {{
translation {hundredth_scale:.1f} {hundredth_scale:.1f} -50.0
children [
Shape {{
geometry Text {{
string ["{colorspace}"]
fontStyle FontStyle {{ family "SANS" style "BOLD" size {tenth_scale:.1f} }}
}}
appearance Appearance {{
material Material {{ diffuseColor 0.7 0.7 0.7 }}
}}
}}
]
}}
""" # noqa: E501
VRML_AXES_TEMPLATE2 = """ # L* axis
Transform {{
translation 0.0 0.0 0.0
children [
Shape {{
geometry Box {{ size {wh:.1f} {wh:.1f} 100.0 }}
appearance Appearance {{
material Material {{ diffuseColor 0.7 0.7 0.7 }}
}}
}}
]
}}
# L* axis label
Transform {{
translation -{Ln:.1f} -{wh:.1f} 55.0
children [
Shape {{
geometry Text {{
string [{pllabel}]
fontStyle FontStyle {{ family "SANS" style "BOLD" size {fontsize:.1f} }}
}}
appearance Appearance {{
material Material {{ diffuseColor 0.7 0.7 0.7}}
}}
}}
]
}}
# +x axis
Transform {{
translation {aboffset:.1f} 0.0 -50.0
children [
Shape {{
geometry Box {{ size {ab:.1f} {wh:.1f} {wh:.1f} }}
appearance Appearance {{
material Material {{ diffuseColor {pxcolor} }}
}}
}}
]
}}
# +x axis label
Transform {{
translation {ap:.1f} -{wh:.1f} -50.0
children [
Shape {{
geometry Text {{
string [{pxlabel}]
fontStyle FontStyle {{ family "SANS" style "BOLD" size {fontsize:.1f} }}
}}
appearance Appearance {{
material Material {{ diffuseColor {pxcolor} }}
}}
}}
]
}}
# -x axis
Transform {{
translation -{aboffset:.1f} 0.0 -50.0
children [
Shape {{
geometry Box {{ size {ab:.1f} {wh:.1f} {wh:.1f} }}
appearance Appearance {{
material Material {{ diffuseColor {nxcolor} }}
}}
}}
]
}}
# -x axis label
Transform {{
translation -{an:.1f} -{wh:.1f} -50.0
children [
Shape {{
geometry Text {{
string [{nxlabel}]
fontStyle FontStyle {{ family "SANS" style "BOLD" size {fontsize:.1f} }}
}}
appearance Appearance {{
material Material {{ diffuseColor {nxcolor} }}
}}
}}
]
}}
# +y axis
Transform {{
translation 0.0 {aboffset:.1f} -50.0
children [
Shape {{
geometry Box {{ size {wh:.1f} {ab:.1f} {wh:.1f} }}
appearance Appearance {{
material Material {{ diffuseColor {pycolor} }}
}}
}}
]
}}
# +y axis label
Transform {{
translation -{bp0:.1f} {bp1:.1f} -50.0
children [
Shape {{
geometry Text {{
string [{pylabel}]
fontStyle FontStyle {{ family "SANS" style "BOLD" size {fontsize:.1f} }}
}}
appearance Appearance {{
material Material {{ diffuseColor {pycolor} }}
}}
}}
]
}}
# -y axis
Transform {{
translation 0.0 -{aboffset:.1f} -50.0
children [
Shape {{
geometry Box {{ size {wh:.1f} {ab:.1f} {wh:.1f} }}
appearance Appearance {{
material Material {{ diffuseColor {nycolor} }}
}}
}}
]
}}
# -y axis label
Transform {{
translation -{bn0:.1f} -{bn1:.1f} -50.0
children [
Shape {{
geometry Text {{
string [{nylabel}]
fontStyle FontStyle {{ family "SANS" style "BOLD" size {fontsize:.1f} }}
}}
appearance Appearance {{
material Material {{ diffuseColor {nycolor} }}
}}
}}
]
}}
# Zero
Transform {{
translation -{Ln:.1f} -{wh:.1f} -55.0
children [
Shape {{
geometry Text {{
string ["0"]
fontStyle FontStyle {{ family "SANS" style "BOLD" size {fontsize:.1f} }}
}}
appearance Appearance {{
material Material {{ diffuseColor 0.7 0.7 0.7}}
}}
}}
]
}}
""" # noqa: E501
def __init__(
self,
data: dict | CGATS,
white_point: tuple[float, float, float],
cat: str | CAT = CAT.Bradford,
rgb_black_offset: float = 40,
normalize_rgb_white: bool = False,
) -> None:
self._data = None
self._cat = None
self.X = None
self.Y = None
self.Z = None
self.L = None
self.a = None
self.b = None
self.white_point = white_point
self.cat = cat
self.data = data
self.extra_offset_x = 0.0
self.extra_offset_y = 0.0
self.scale = 1.0
self.radius = 15.0 / (len(self.data) ** (1.0 / 3.0))
self.max_z = 1.0
self.max_xy = 200
self.axes = ""
self.vrml = ""
self.children = []
self.rgb_black_offset = rgb_black_offset
self.normalize_rgb_white = normalize_rgb_white
self.fov = 45
self.offset_z = 340
@property
def colorspace(self) -> str:
"""Get the name of the color space.
Returns:
str: The name of the color space.
"""
return ColorSpace.to_colorspace(self.__class__.__name__.replace("ToVRML", ""))
@property
def data(self) -> list:
"""Get the color data.
Returns:
list: The color data.
"""
return self._data
@data.setter
def data(self, data: list) -> None:
"""Set the color data.
Args:
data (list): The color data to be set.
"""
from DisplayCAL.cgats import CGATS
if not isinstance(data, (dict, CGATS)):
raise TypeError(
f"{self.__class__.__name__}.data must be a dictionary or a "
f"CGATS instance, not {data.__class__.__name__}: {data}"
)
self._data = data
@property
def cat(self) -> CAT:
"""Get the chromatic adaptation transform (CAT).
Returns:
CAT: The CAT enum.
"""
return self._cat
@cat.setter
def cat(self, cat: str | CAT) -> None:
"""Set the chromatic adaptation transform (CAT).
Args:
cat (str | CAT): The CAT to be set.
"""
self._cat = CAT.to_cat(cat)
def calculate_xyz_and_lab(self, entry: dict) -> None:
"""Calculate XYZ and Lab values from the white point and CAT info.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
"""
self.X, self.Y, self.Z = colormath.adapt(
entry["XYZ_X"],
entry["XYZ_Y"],
entry["XYZ_Z"],
self.white_point,
"D65" if isinstance(self, (ICtCpToVRML, IPTToVRML)) else "D50",
cat=str(self.cat),
)
self.L, self.a, self.b = colormath.XYZ2Lab(self.X, self.Y, self.Z)
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
raise NotImplementedError("This method should be overridden in subclasses.")
def generate_vrml_axes(self) -> None:
"""Get the VRML axis representation for the color space."""
def generate_vrml_children(self) -> None:
"""Generate VRML children for the color space."""
self.children = []
for entry in self.data.values():
self.calculate_xyz_and_lab(entry)
offset_x, offset_y, offset_z = self.get_offsets(entry)
h_ref = s_ref = 0.0
if self.rgb_black_offset != 40:
# Keep reference hue and saturation
# Lab to sRGB using reference black offset of 40 like Argyll CMS
r, g, b = colormath.Lab2RGB(
self.L * (100.0 - 40.0) / 100.0 + 40.0,
self.a,
self.b,
scale=0.7,
noadapt=not self.normalize_rgb_white,
)
h_ref, s_ref, _ = colormath.RGB2HSV(r, g, b)
# Lab to sRGB using actual black offset
r, g, b = colormath.Lab2RGB(
self.L * (100.0 - self.rgb_black_offset) / 100.0
+ self.rgb_black_offset,
self.a,
self.b,
scale=0.7,
noadapt=not self.normalize_rgb_white,
)
if self.rgb_black_offset != 40:
_, _, v = colormath.RGB2HSV(r, g, b)
# Use reference H and S to go back to RGB
r, g, b = colormath.HSV2RGB(h_ref, s_ref, v)
child = self.VRML_CHILD_TEMPLATE.format(
offset_x=offset_x,
offset_y=offset_y,
offset_z=offset_z,
R=r + 0.05,
G=g + 0.05,
B=b + 0.05,
radius=self.radius,
)
self.children.append(child)
def generate_vrml(self) -> str:
"""Generate the VRML representation for the color space.
Returns:
str: The VRML representation of the color space.
"""
self.generate_vrml_axes()
self.generate_vrml_children()
self.vrml = self.VRML_TEMPLATE.format(
children="".join(self.children),
axes=self.axes,
fov=math.radians(self.fov),
offset_z=self.offset_z,
)
def write_vrml(
self, file_format: str, filename: str | Path, compress: bool = True
) -> None:
"""Write the VRML representation to a file.
Args:
file_format (str): The format of the output file, e.g., 'VRML'.
filename (str): The name of the file to export to.
compress (bool): Whether to compress the output file.
"""
if file_format != "VRML":
print("Generating", file_format)
x3d = x3dom.vrml2x3dom(self.vrml)
if file_format == "HTML":
out = x3d.html(title=os.path.basename(filename))
else:
out = x3d.x3d()
else:
out = self.vrml
writer = GzipFileProper if compress else open
safe_print("Writing", filename)
with writer(filename, "wb") as outfile:
outfile.write(out.encode("utf-8"))
class RGBToVRML(ColorSpaceToVRML):
"""RGB color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
return (
entry["RGB_G"] - 50,
entry["RGB_B"] - 50,
entry["RGB_R"] - 50,
)
class HSIToVRML(ColorSpaceToVRML):
"""HSI color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
h, s, offset_z = colormath.RGB2HSI(
entry["RGB_R"] / 100.0,
entry["RGB_G"] / 100.0,
entry["RGB_B"] / 100.0,
)
radian = math.radians(h * 360)
offset_x, offset_y = (
s * offset_z * math.cos(radian),
s * offset_z * math.sin(radian),
)
# Fudge device locations into Lab space
return (
offset_x * self.sqrt3_100,
offset_y * self.sqrt3_100,
offset_z * self.sqrt3_100 - self.sqrt3_50,
)
class HSLToVRML(ColorSpaceToVRML):
"""HSL color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
h, s, offset_z = colormath.RGB2HSL(
entry["RGB_R"] / 100.0,
entry["RGB_G"] / 100.0,
entry["RGB_B"] / 100.0,
)
radian = math.radians(h * 360)
s *= (1 - offset_z) if offset_z > 0.5 else (offset_z)
offset_x, offset_y = s * math.cos(radian), s * math.sin(radian)
# Fudge device locations into Lab space
return (
offset_x * self.sqrt3_100,
offset_y * self.sqrt3_100,
offset_z * self.sqrt3_100 - self.sqrt3_50,
)
class HSVToVRML(ColorSpaceToVRML):
"""HSV color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
h, s, offset_z = colormath.RGB2HSV(
entry["RGB_R"] / 100.0,
entry["RGB_G"] / 100.0,
entry["RGB_B"] / 100.0,
)
radian = math.radians(h * 360)
offset_x, offset_y = (
s * offset_z * math.cos(radian),
s * offset_z * math.sin(radian),
)
# Fudge device locations into Lab space
return (
offset_x * self.sqrt3_50,
offset_y * self.sqrt3_50,
offset_z * self.sqrt3_100 - self.sqrt3_50,
)
class LabToVRML(ColorSpaceToVRML):
"""Lab color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
l, a, b = colormath.XYZ2Lab(self.X, self.Y, self.Z)
# Fudge device locations into Lab space
return a, b, l - 50
class DIN99ToVRML(ColorSpaceToVRML):
"""DIN99 color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def __init__(
self,
data: list,
white_point: tuple[float, float, float],
cat: str = "XYZ scaling",
rgb_black_offset: float = 40,
normalize_rgb_white: bool = False,
) -> None:
super().__init__(data, white_point, cat, rgb_black_offset, normalize_rgb_white)
self.scale = 100.0 / 40 # Scale factor for DIN99 axes
self.radius /= self.scale
self.fov /= self.scale
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
l, a, b = colormath.XYZ2Lab(self.X, self.Y, self.Z)
l99, a99, b99 = colormath.Lab2DIN99(l, a, b)
return a99, b99, l99 - 50
def generate_vrml_axes(self) -> None:
"""Get the VRML axis representation for the color space."""
self.axes = ""
pxcolor = "1.0 0.0 0.0"
nxcolor = "0.0 1.0 0.0"
pycolor = "1.0 1.0 0.0"
nycolor = "0.0 0.0 1.0"
self.axes += self.VRML_AXES_TEMPLATE.format(
hundredth_scale=100.0 / self.scale,
tenth_scale=10.0 / self.scale,
colorspace=str(self.colorspace),
)
(pxlabel, nxlabel, pylabel, nylabel, pllabel) = (
f'"a", "+{int(100 / self.scale)}"',
f'"a", "-{int(100 / self.scale)}"',
f'"b +{int(100 / self.scale)}"',
f'"b -{int(100 / self.scale)}"',
'"L", "+100"',
)
self.axes += self.VRML_AXES_TEMPLATE2.format(
wh=2.0 / self.scale,
ab=100.0 / self.scale,
aboffset=50.0 / self.scale,
fontsize=10.0 / self.scale,
ap=102.0 / self.scale,
an=108.0 / self.scale,
Ln=3.0,
bp0=3.0,
bp1=103.0 / self.scale,
bn0=3.0,
bn1=107.0 / self.scale,
pxlabel=pxlabel,
nxlabel=nxlabel,
pylabel=pylabel,
nylabel=nylabel,
pllabel=pllabel,
pxcolor=pxcolor,
nxcolor=nxcolor,
pycolor=pycolor,
nycolor=nycolor,
)
class DIN99bToVRML(DIN99ToVRML):
"""DIN99b color space class.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
extra_offset_x (float, optional): Extra offset in the X direction.
Defaults to 0.0.
extra_offset_y (float, optional): Extra offset in the Y direction.
Defaults to 0.0.
scale (float, optional): Scale factor for the offsets. Defaults to 1.0.
max_z (float, optional): Maximum Z value for scaling. Defaults to 100.0.
"""
def __init__(
self,
data: list,
white_point: tuple[float, float, float],
cat: str = "XYZ scaling",
rgb_black_offset: float = 40,
normalize_rgb_white: bool = False,
) -> None:
super().__init__(data, white_point, cat, rgb_black_offset, normalize_rgb_white)
self.scale = 100.0 / 50 # Scale factor for DIN99b axes
self.radius /= self.scale
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
l, a, b = colormath.XYZ2Lab(self.X, self.Y, self.Z)
l99, a99, b99 = colormath.Lab2DIN99b(l, a, b)
return a99, b99, l99 - 50
class DIN99cToVRML(DIN99ToVRML):
"""DIN99c color space class.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
extra_offset_x (float, optional): Extra offset in the X direction.
Defaults to 0.0.
extra_offset_y (float, optional): Extra offset in the Y direction.
Defaults to 0.0.
scale (float, optional): Scale factor for the offsets. Defaults to 1.0.
max_z (float, optional): Maximum Z value for scaling. Defaults to 100.0.
"""
def __init__(
self,
data: list,
white_point: tuple[float, float, float],
cat: str = "XYZ scaling",
rgb_black_offset: float = 40,
normalize_rgb_white: bool = False,
) -> None:
super().__init__(data, white_point, cat, rgb_black_offset, normalize_rgb_white)
self.scale = 100.0 / 50 # Scale factor for DIN99c axes
self.radius /= self.scale
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
l99, a99, b99 = colormath.XYZ2DIN99c(self.X, self.Y, self.Z)
return a99, b99, l99 - 50
class DIN99dToVRML(DIN99ToVRML):
"""DIN99d color space class.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
extra_offset_x (float, optional): Extra offset in the X direction.
Defaults to 0.0.
extra_offset_y (float, optional): Extra offset in the Y direction.
Defaults to 0.0.
scale (float, optional): Scale factor for the offsets. Defaults to 1.0.
max_z (float, optional): Maximum Z value for scaling. Defaults to 100.0.
"""
def __init__(
self,
data: list,
white_point: tuple[float, float, float],
cat: str = "XYZ scaling",
rgb_black_offset: float = 40,
normalize_rgb_white: bool = False,
) -> None:
super().__init__(data, white_point, cat, rgb_black_offset, normalize_rgb_white)
self.scale = 100.0 / 50 # Scale factor for DIN99d axes
self.radius /= self.scale
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
l99, a99, b99 = colormath.XYZ2DIN99d(self.X, self.Y, self.Z)
return a99, b99, l99 - 50
class LCHabToVRML(ColorSpaceToVRML):
"""LCH(ab) color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def __init__(
self,
data: list,
white_point: tuple[float, float, float],
cat: str = "XYZ scaling",
rgb_black_offset: float = 40,
normalize_rgb_white: bool = False,
) -> None:
super().__init__(data, white_point, cat, rgb_black_offset, normalize_rgb_white)
self.fov /= 16.0
self.offset_z *= 16
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
l, c, h = colormath.Lab2LCHab(self.L, self.a, self.b)
return h - 180, c - 100, l - 50
def generate_vrml_axes(self) -> None:
"""Get the VRML axis representation for the color space."""
self.axes = ""
self.max_z = 1.0
self.extra_offset_x = 0.0
self.extra_offset_y = 0.0
xlabel, ylabel, zlabel = "H(ab)", "C(ab)", "L*"
self.axes = x3dom.get_vrml_axes(
xlabel, ylabel, zlabel, -180, -100, 0, 360, 200, 100, False
)
class LCHuvToVRML(ColorSpaceToVRML):
"""LCH(uv) color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def __init__(
self,
data: list,
white_point: tuple[float, float, float],
cat: str = "XYZ scaling",
rgb_black_offset: float = 40,
normalize_rgb_white: bool = False,
) -> None:
super().__init__(data, white_point, cat, rgb_black_offset, normalize_rgb_white)
self.fov /= 16.0
self.offset_z *= 16
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
l, c, h = colormath.Luv2LCHuv(*colormath.XYZ2Luv(self.X, self.Y, self.Z))
return h - 180, c - 100, l - 50
def generate_vrml_axes(self) -> None:
"""Get the VRML axis representation for the color space."""
self.axes = ""
self.max_z = 1.0
self.extra_offset_x = 0.0
self.extra_offset_y = 0.0
xlabel, ylabel, zlabel = "H(uv)", "C(uv)", "L*"
self.axes = x3dom.get_vrml_axes(
xlabel, ylabel, zlabel, -180, -100, 0, 360, 200, 100, False
)
class LuvToVRML(ColorSpaceToVRML):
"""Luv color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
l, u, v = colormath.XYZ2Luv(self.X, self.Y, self.Z)
return u, v, l - 50
def generate_vrml_axes(self) -> None:
"""Get the VRML axis representation for the color space."""
self.axes = ""
pxcolor = "1.0 0.0 0.0"
nxcolor = "0.0 1.0 0.0"
pycolor = "1.0 1.0 0.0"
nycolor = "0.0 0.0 1.0"
x = "u"
y = "v"
(pxlabel, nxlabel, pylabel, nylabel, pllabel) = (
f'"{x}*", "+100"',
f'"{x}*", "-100"',
f'"{y}* +100"',
f'"{y}* -100"',
'"L*", "+100"',
)
self.axes += self.VRML_AXES_TEMPLATE2.format(
wh=2.0 / self.scale,
ab=100.0 / self.scale,
aboffset=50.0 / self.scale,
fontsize=10.0 / self.scale,
ap=102.0 / self.scale,
an=108.0 / self.scale,
Ln=3.0,
bp0=3.0,
bp1=103.0 / self.scale,
bn0=3.0,
bn1=107.0 / self.scale,
pxlabel=pxlabel,
nxlabel=nxlabel,
pylabel=pylabel,
nylabel=nylabel,
pllabel=pllabel,
pxcolor=pxcolor,
nxcolor=nxcolor,
pycolor=pycolor,
nycolor=nycolor,
)
class LuvPrimeToVRML(ColorSpaceToVRML):
"""Lu'v' color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
l, u_, v_ = colormath.XYZ2Lu_v_(self.X, self.Y, self.Z)
return (
(u_ + self.extra_offset_x) * self.scale,
(v_ + self.extra_offset_y) * self.scale,
l / 100.0 * self.max_z - 50,
)
def generate_vrml_axes(self) -> None:
"""Get the VRML axis representation for the color space."""
self.axes = ""
self.max_z = self.scale = 100
self.radius /= 2.0
xlabel, ylabel, zlabel = "x 0.8", "y 0.8", "Y 100"
self.extra_offset_x, self.extra_offset_y = -0.4, -0.4
self.scale = self.max_xy / 0.8
xlabel, ylabel, zlabel = "u' 0.6", "v' 0.6", "L* 100"
self.extra_offset_x, self.extra_offset_y = -0.3, -0.3
self.scale = self.max_xy / 0.6
self.axes = x3dom.get_vrml_axes(
xlabel,
ylabel,
zlabel,
self.extra_offset_x * self.scale,
self.extra_offset_y * self.scale,
0,
self.max_xy,
self.max_xy,
self.max_z,
)
class xyYToVRML(ColorSpaceToVRML): # noqa: N801
"""xyY color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
offset_x, offset_y, self.Y = colormath.XYZ2xyY(self.X, self.Y, self.Z)
return (
(offset_x + self.extra_offset_x) * self.scale,
(offset_y + self.extra_offset_y) * self.scale,
self.Y / 100.0 * self.max_z - 50,
)
def generate_vrml_axes(self) -> None:
"""Get the VRML axis representation for the color space."""
self.axes = ""
self.max_z = 1.0
self.extra_offset_x = 0.0
self.extra_offset_y = 0.0
self.max_z = self.scale = 100
self.radius /= 2.0
xlabel, ylabel, zlabel = "x 0.8", "y 0.8", "Y 100"
self.extra_offset_x, self.extra_offset_y = -0.4, -0.4
self.scale = self.max_xy / 0.8
self.axes = x3dom.get_vrml_axes(
xlabel,
ylabel,
zlabel,
self.extra_offset_x * self.scale,
self.extra_offset_y * self.scale,
0,
self.max_xy,
self.max_xy,
self.max_z,
)
class ICtCpToVRML(ColorSpaceToVRML):
"""ICtCp color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
i, ct, cp = colormath.XYZ2ICtCp(
self.X / 100.0, self.Y / 100.0, self.Z / 100.0, clamp=False
)
return ct * 100, cp * 100, i * 100 - 50
def generate_vrml_axes(self) -> None:
"""Get the VRML axis representation for the color space."""
self.axes = ""
pxcolor = "1.0 0.0 0.0"
nxcolor = "0.0 1.0 0.0"
pycolor = "1.0 1.0 0.0"
nycolor = "0.0 0.0 1.0"
self.scale = 2.0
self.radius /= 2.0
(pxlabel, nxlabel, pylabel, nylabel, pllabel) = (
'"Ct", "+0.5"',
'"Ct", "-0.5"',
'"Cp +0.5"',
'"Cp -0.5"',
'"I"',
)
pxcolor = "0.5 0.0 1.0"
nxcolor = "0.8 1.0 0.0"
pycolor = "1.0 0.0 0.25"
nycolor = "0.0 1.0 1.0"
self.axes += self.VRML_AXES_TEMPLATE2.format(
wh=2.0 / self.scale,
ab=100.0 / self.scale,
aboffset=50.0 / self.scale,
fontsize=10.0 / self.scale,
ap=102.0 / self.scale,
an=108.0 / self.scale,
Ln=3.0,
bp0=3.0,
bp1=103.0 / self.scale,
bn0=3.0,
bn1=107.0 / self.scale,
pxlabel=pxlabel,
nxlabel=nxlabel,
pylabel=pylabel,
nylabel=nylabel,
pllabel=pllabel,
pxcolor=pxcolor,
nxcolor=nxcolor,
pycolor=pycolor,
nycolor=nycolor,
)
class IPTToVRML(ColorSpaceToVRML):
"""IPT color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
i, p, t = colormath.XYZ2IPT(self.X / 100.0, self.Y / 100.0, self.Z / 100.0)
return p * 100, t * 100, i * 100 - 50
def generate_vrml_axes(self) -> None:
"""Get the VRML axis representation for the color space."""
self.axes = ""
pxcolor = "1.0 0.0 0.0"
nxcolor = "0.0 1.0 0.0"
pycolor = "1.0 1.0 0.0"
nycolor = "0.0 0.0 1.0"
(pxlabel, nxlabel, pylabel, nylabel, pllabel) = (
'"P", "+1.0',
'"P", "-1.0"',
'"T +1.0"',
'"T -1.0"',
'"I"',
)
self.axes += self.VRML_AXES_TEMPLATE2.format(
wh=2.0 / self.scale,
ab=100.0 / self.scale,
aboffset=50.0 / self.scale,
fontsize=10.0 / self.scale,
ap=102.0 / self.scale,
an=108.0 / self.scale,
Ln=3.0,
bp0=3.0,
bp1=103.0 / self.scale,
bn0=3.0,
bn1=107.0 / self.scale,
pxlabel=pxlabel,
nxlabel=nxlabel,
pylabel=pylabel,
nylabel=nylabel,
pllabel=pllabel,
pxcolor=pxcolor,
nxcolor=nxcolor,
pycolor=pycolor,
nycolor=nycolor,
)
class LptToVRML(ColorSpaceToVRML):
"""Lpt color space class.
Args:
data (list): The color data to be processed.
white_point (tuple[float, float, float]): The white point for the color space.
cat (str): The CAT for the color space. Defaults to "XYZ scaling".
rgb_black_offset (float, optional): Offset for RGB black. Defaults to 40.
normalize_rgb_white (bool, optional): Normalize RGB white. Defaults to False.
"""
def get_offsets(self, entry: dict) -> tuple[float, float, float]:
"""Get the offset for the color space.
Args:
entry (dict): The color data entry containing RGB and XYZ values.
Returns:
tuple[float, float, float]: Offset values for X, Y, Z.
"""
l, p, t = colormath.XYZ2Lpt(self.X, self.Y, self.Z)
return p, t, l - 50
def generate_vrml_axes(self) -> None:
"""Get the VRML axis representation for the color space."""
self.axes = ""
pxcolor = "1.0 0.0 0.0"
nxcolor = "0.0 1.0 0.0"
pycolor = "1.0 1.0 0.0"
nycolor = "0.0 0.0 1.0"
x = "p"
y = "t"
(pxlabel, nxlabel, pylabel, nylabel, pllabel) = (
f'"{x}*", "+100"',
f'"{x}*", "-100"',
f'"{y}* +100"',
f'"{y}* -100"',
'"L*", "+100"',
)
self.axes += self.VRML_AXES_TEMPLATE2.format(
wh=2.0 / self.scale,
ab=100.0 / self.scale,
aboffset=50.0 / self.scale,
fontsize=10.0 / self.scale,
ap=102.0 / self.scale,
an=108.0 / self.scale,
Ln=3.0,
bp0=3.0,
bp1=103.0 / self.scale,
bn0=3.0,
bn1=107.0 / self.scale,
pxlabel=pxlabel,
nxlabel=nxlabel,
pylabel=pylabel,
nylabel=nylabel,
pllabel=pllabel,
pxcolor=pxcolor,
nxcolor=nxcolor,
pycolor=pycolor,
nycolor=nycolor,
)
COLORSPACE_NAME_TO_VRML_MAP = {
"DIN99": DIN99ToVRML,
"DIN99b": DIN99bToVRML,
"DIN99c": DIN99cToVRML,
"DIN99d": DIN99dToVRML,
"HSI": HSIToVRML,
"HSL": HSLToVRML,
"HSV": HSVToVRML,
"ICtCp": ICtCpToVRML,
"IPT": IPTToVRML,
"Lab": LabToVRML,
"LCH(ab)": LCHabToVRML,
"LCH(uv)": LCHuvToVRML,
"Lpt": LptToVRML,
"Lu'v'": LuvPrimeToVRML,
"Luv": LuvToVRML,
"RGB": RGBToVRML,
"xyY": xyYToVRML,
}
displaycal-py3-3.9.19/DisplayCAL/config.py 000664 000000 000000 00000337654 15225167330 020225 0 ustar 00root root 000000 000000 """Runtime configuration and user settings parser."""
# Standard Library Imports
from __future__ import annotations
import configparser
import contextlib
import locale
import math
import os
import re
import string
import sys
import tempfile
import time
from decimal import Decimal
from enum import IntEnum
from typing import TYPE_CHECKING, Any
# Local Imports
import DisplayCAL
from DisplayCAL import colormath
from DisplayCAL.argyll_names import INTENTS, OBSERVERS, VIDEO_ENCODINGS, VIEWCONDS
if sys.platform == "win32":
from DisplayCAL.defaultpaths import COMMON_PROGRAM_FILES
elif sys.platform == "darwin":
from DisplayCAL.defaultpaths import LIBRARY, LIBRARY_HOME, PREFS, PREFS_HOME
else:
from DisplayCAL.defaultpaths import (
XDG_CONFIG_DIR_DEFAULT,
XDG_CONFIG_HOME,
XDG_DATA_DIRS,
XDG_DATA_HOME,
XDG_DATA_HOME_DEFAULT,
)
from DisplayCAL.defaultpaths import ( # noqa: F401
APPDATA,
AUTOSTART, # don't remove this, imported by other modules
AUTOSTART_HOME, # don't remove this, imported by other modules
COMMONAPPDATA,
HOME, # don't remove this, imported by other modules
ICCPROFILES,
ICCPROFILES_HOME,
)
from DisplayCAL.meta import VERSION_STRING
from DisplayCAL.meta import NAME as APPNAME
from DisplayCAL.options import DEBUG
from DisplayCAL.safe_print import ( # noqa: F401
ENC, # don't remove this, imported by other modules
FS_ENC,
)
from DisplayCAL.util_io import StringIOu as StringIO
from DisplayCAL.util_os import (
FileLock,
expanduseru,
getenvu,
is_superuser,
listdir_re,
which,
)
from DisplayCAL.util_str import create_replace_function, strtr
if TYPE_CHECKING:
from DisplayCAL.icc_profile import ICCProfile
from DisplayCAL.worker import Worker
from DisplayCAL.wx_addons import wx # noqa: TC004
configparser.DEFAULTSECT = "Default" # Sadly, this line needs to be here.
EXE = sys.executable
EXEDIR = os.path.dirname(EXE)
EXENAME = os.path.basename(EXE)
ISEXE = sys.platform != "darwin" and getattr(sys, "frozen", False)
if ISEXE and (_meipass2 := os.getenv("_MEIPASS2")):
os.environ["_MEIPASS2"] = _meipass2.replace("/", os.path.sep)
PYFILE = (
EXE
if ISEXE
else (os.path.isfile(sys.argv[0]) and sys.argv[0])
or os.path.join(os.path.dirname(__file__), "main.py")
)
PYPATH = EXE if ISEXE else os.path.abspath(PYFILE)
# Mac OS X: isapp should only be true for standalone, not 0install
ISAPP = (
sys.platform == "darwin"
and EXE.split(os.path.sep)[-3:-1] == ["Contents", "MacOS"]
and os.path.exists(os.path.join(EXEDIR, "..", "Resources", "xrc"))
)
if ISAPP:
PYNAME, PYEXT = os.path.splitext(EXE.split(os.path.sep)[-4])
PYDIR = os.path.normpath(os.path.join(EXEDIR, "..", "Resources"))
else:
PYNAME, PYEXT = os.path.splitext(os.path.basename(PYPATH))
PYDIR = os.path.dirname(
EXE if ISEXE else os.path.abspath(os.path.dirname(__file__))
)
# TODO: Modifying ``data_dirs`` here was not an elegant solution,
# and it is not solving the problem either.
DATA_DIRS = [
# venv/share/DisplayCAL
os.path.join(os.path.dirname(os.path.dirname(PYPATH)), "share", "DisplayCAL"),
# venv/lib/python3.x/site-packages/DisplayCAL
PYDIR,
# venv/share
os.path.join(os.path.dirname(PYDIR), "share"),
# venv/lib/python3.x/site-packages/DisplayCAL-*.egg/share/DisplayCAL
os.path.join(os.path.dirname(PYDIR), "share", "DisplayCAL"),
]
EXTRA_DATA_DIRS = []
# Search directories on PATH for data directories so Argyll reference files can
# be found automatically if Argyll directory not explicitly configured
for dir_ in getenvu("PATH", "").split(os.pathsep):
dir_parent = os.path.dirname(dir_)
if os.path.isdir(os.path.join(dir_parent, "ref")):
EXTRA_DATA_DIRS.append(dir_parent)
APPBASENAME = APPNAME
# If old user data directory exists, use its basename
if os.path.isdir(os.path.join(APPDATA, "dispcalGUI")):
APPBASENAME = "dispcalGUI"
DATA_DIRS.append(os.path.join(APPDATA, APPNAME))
DATA_HOME = os.path.join(APPDATA, APPBASENAME)
if sys.platform == "win32":
if PYDIR.lower().startswith(EXEDIR.lower()) and PYDIR != EXEDIR:
# We are installed in a subfolder of the executable directory
# (e.g. C:\Python26\Lib\site-packages\DisplayCAL)
# we need to add the executable directory to the data directories so
# files in subfolders of the executable directory which are not in
# Lib\site-packages\DisplayCAL can be found
# (e.g. Scripts\displaycal-apply-profiles)
DATA_DIRS.append(EXEDIR)
SCRIPT_EXT = ".cmd"
SCALE_ADJUSTMENT_FACTOR = 1.0
CONFIG_SYS = os.path.join(COMMONAPPDATA[0], APPBASENAME)
CONFIG_HOME = os.path.join(APPDATA, APPBASENAME)
LOGDIR = os.path.join(DATA_HOME, "logs")
if APPBASENAME != APPNAME:
DATA_DIRS.extend(os.path.join(dir_, APPNAME) for dir_ in COMMONAPPDATA)
DATA_DIRS.append(os.path.join(COMMON_PROGRAM_FILES, APPNAME))
DATA_DIRS.append(DATA_HOME)
DATA_DIRS.extend(os.path.join(dir_, APPBASENAME) for dir_ in COMMONAPPDATA)
DATA_DIRS.append(os.path.join(COMMON_PROGRAM_FILES, APPBASENAME))
EXE_EXT = ".exe"
PROFILE_EXT = ".icm"
elif sys.platform == "darwin":
SCRIPT_EXT = ".command"
MAC_CREATE_APP = True
SCALE_ADJUSTMENT_FACTOR = 1.0
CONFIG_SYS = os.path.join(PREFS, APPBASENAME)
CONFIG_HOME = os.path.join(PREFS_HOME, APPBASENAME)
LOGDIR = os.path.join(expanduseru("~"), "Library", "Logs", APPBASENAME)
if APPBASENAME != APPNAME:
DATA_DIRS.append(os.path.join(COMMONAPPDATA[0], APPNAME))
DATA_DIRS.append(DATA_HOME)
DATA_DIRS.append(os.path.join(COMMONAPPDATA[0], APPBASENAME))
EXE_EXT = ""
PROFILE_EXT = ".icc"
else: # Linux
SCRIPT_EXT = ".sh"
SCALE_ADJUSTMENT_FACTOR = 1.0
CONFIG_SYS = os.path.join(XDG_CONFIG_DIR_DEFAULT, APPBASENAME)
CONFIG_HOME = os.path.join(XDG_CONFIG_HOME, APPBASENAME)
LOGDIR = os.path.join(DATA_HOME, "logs")
if APPBASENAME != APPNAME:
DATA_HOME_DEFAULT = os.path.join(XDG_DATA_HOME_DEFAULT, APPNAME)
if DATA_HOME_DEFAULT not in DATA_DIRS:
DATA_DIRS.append(DATA_HOME_DEFAULT)
DATA_DIRS.extend(os.path.join(dir_, APPNAME) for dir_ in XDG_DATA_DIRS)
DATA_DIRS.append(DATA_HOME)
DATA_HOME_DEFAULT = os.path.join(XDG_DATA_HOME_DEFAULT, APPBASENAME)
if DATA_HOME_DEFAULT not in DATA_DIRS:
DATA_DIRS.append(DATA_HOME_DEFAULT)
DATA_DIRS.extend(os.path.join(dir_, APPBASENAME) for dir_ in XDG_DATA_DIRS)
EXTRA_DATA_DIRS.extend(os.path.join(dir_, "argyllcms") for dir_ in XDG_DATA_DIRS)
EXTRA_DATA_DIRS.extend(
os.path.join(dir_, "color", "argyll") for dir_ in XDG_DATA_DIRS
)
EXE_EXT = ""
PROFILE_EXT = ".icc"
STORAGE = os.path.join(DATA_HOME, "storage")
RES_FILES = [
# Only essentials
"lang/en.yaml",
"beep.wav",
"camera_shutter.wav",
"linear.cal",
"test.cal",
"ref/ClayRGB1998.gam",
"ref/sRGB.gam",
"ref/verify_extended.ti1",
"ti1/d3-e4-s2-g28-m0-b0-f0.ti1",
"ti1/d3-e4-s3-g52-m3-b0-f0.ti1",
"ti1/d3-e4-s4-g52-m4-b0-f0.ti1",
"ti1/d3-e4-s5-g52-m5-b0-f0.ti1",
"xrc/extra.xrc",
"xrc/gamap.xrc",
"xrc/main.xrc",
"xrc/mainmenu.xrc",
"xrc/report.xrc",
"xrc/synthicc.xrc",
]
BITMAPS = {}
# Does the device not support iterative calibration?
UNCALIBRATABLE_DISPLAYS = ("Untethered$",)
# Can the device generate patterns of its own?
PATTERN_GENERATORS = ("madVR$", "Resolve$", "Chromecast ", "Prisma ", "Prisma$")
NON_ARGYLL_DISPLAYS = (*UNCALIBRATABLE_DISPLAYS, "Resolve$")
# Is the device directly connected or e.g. driven via network?
# (note that madVR can technically be both, but the endpoint is always directly
# connected to a display so we have videoLUT access via madVR's API.
# Only devices which don't support that are considered 'untethered' in this context)
UNTETHERED_DISPLAYS = (
*NON_ARGYLL_DISPLAYS,
"Web$",
"Chromecast ",
"Prisma ",
"Prisma$",
)
# Is the device not an actual display device (i.e. is it not a TV or monitor)?
VIRTUAL_DISPLAYS = (*UNTETHERED_DISPLAYS, "madVR$")
DPISET = False
class BitmapSizeType(IntEnum):
"""Enum for bitmap size types."""
HighDPI_Normal = 0
HighDPI_4x = 1
HighDPI_2x = 2
HighDPI_2x_Original = 3
Original = 4
def __repr__(self) -> str:
"""Return the enum name for str().
Returns:
str: The name as the string representation of this
ScheduleConstraint.
"""
return self.name if self.name != "NONE" else "None"
__str__ = __repr__
@classmethod
def to_type(cls, type_: int | str | BitmapSizeType) -> BitmapSizeType:
"""Convert the given type value to a BitmapSizeType enum.
Args:
type_ (int | str | BitmapSizeType]): The value to convert to a
BitmapSizeType to.
Raises:
TypeError: Input value type is invalid.
ValueError: Input value is invalid.
Returns:
BitmapSizeType: The enum.
"""
acceptable_type_values = [t.name for t in cls] + [t.value for t in cls]
if not isinstance(type_, (int, str, BitmapSizeType)):
raise TypeError(
"type_ should be a BitmapSizeType enum value or one of "
f"{acceptable_type_values}, not {type_.__class__.__name__}: '{type_}'"
)
if isinstance(type_, str):
type_name_lut = {t.name.lower(): t.name for t in cls}
type_name_lut.update({t.value: t.name for t in cls})
type_lower_case = type_.lower()
if type_lower_case not in type_name_lut:
raise ValueError(
"type_ should be a BitmapSizeType enum value or one of "
f"{acceptable_type_values}, not '{type_}'"
)
return cls.__members__[type_name_lut[type_lower_case]]
return type_
def debug_print(*args: Any, **kwargs: Any) -> None: # noqa: ANN401
"""Print debug messages if DEBUG is enabled."""
if DEBUG:
print(*args, **kwargs)
def is_special_display(
display: None | str = None, tests: list[str] = VIRTUAL_DISPLAYS
) -> bool:
"""Check if the display is a special display.
Args:
display (str): The display name.
tests (list): List of special display patterns.
Returns:
bool: True if the display is special, False otherwise.
"""
if not isinstance(display, str):
display = get_display_name(display)
return any(re.match(test, display) for test in tests)
def is_uncalibratable_display(display: None | str = None) -> bool:
"""Check if the display is uncalibratable.
Args:
display (None | str): The display name.
Returns:
bool: True if the display is uncalibratable, False otherwise.
"""
return is_special_display(display, UNCALIBRATABLE_DISPLAYS)
def is_patterngenerator(display: None | str = None) -> bool:
"""Check if the display is a pattern generator.
Args:
display (None | str): The display name.
Returns:
bool: True if the display is a pattern generator, False otherwise.
"""
return is_special_display(display, PATTERN_GENERATORS)
def is_non_argyll_display(display: None | str = None) -> bool:
"""Check if the display is a non-Argyll display.
Args:
display (None | str): The display name.
Returns:
bool: True if the display is a non-Argyll display, False otherwise.
"""
return is_special_display(display, NON_ARGYLL_DISPLAYS)
def is_untethered_display(display: None | str = None) -> bool:
"""Check if the display is untethered.
Args:
display (None | str): The display name.
Returns:
bool: True if the display is untethered, False otherwise.
"""
return is_special_display(display, UNTETHERED_DISPLAYS)
def is_virtual_display(display: None | str = None) -> bool:
"""Check if the display is virtual.
Args:
display (None | str): The display name.
Returns:
bool: True if the display is virtual, False otherwise.
"""
return is_special_display(display, VIRTUAL_DISPLAYS)
def check_3dlut_format(devicename: str) -> bool:
"""Check the 3D LUT format for the given device.
Args:
devicename (str): The name of the device.
Returns:
bool: True if the 3D LUT format is correct, False otherwise.
"""
if get_display_name(None, True) == devicename and devicename == "Prisma":
return (
getcfg("3dlut.format") == "3dl"
and getcfg("3dlut.size") == 17
and getcfg("3dlut.bitdepth.input") == 10
and getcfg("3dlut.bitdepth.output") == 12
)
return False
def get_bitmap(
name: str,
display_missing_icon: bool = True,
scale: bool = True,
use_mask: bool = False,
) -> wx.Bitmap:
"""Create (if necessary) and return a named bitmap.
Args:
name (str): Has to be a relative path to a png file, omitting the extension,
e.g. 'theme/mybitmap' or 'theme/icons/16x16/myicon', which is searched
for in the data directories. If a matching file is not found, a
placeholder bitmap is returned. The special name 'empty' will always
return a transparent bitmap of the given size, e.g. '16x16/empty'
or just 'empty' (size defaults to 16x16 if not given).
display_missing_icon (bool): Whether to display a missing icon if the bitmap.
scale (bool): Whether to scale the bitmap.
use_mask (bool): Whether to use a mask for the bitmap.
Returns:
wx.Bitmap: The bitmap.
"""
if name not in BITMAPS:
BITMAPS[name] = create_bitmap(name, display_missing_icon, scale, use_mask)
return BITMAPS[name]
def create_bitmap(
name: str, display_missing_icon: bool, scale: bool, use_mask: bool
) -> wx.Bitmap:
"""Create a bitmap with the specified name and dimensions.
Args:
name (str): The name of the bitmap.
display_missing_icon (bool): Whether to display a missing icon if the
bitmap is not found.
scale (bool): Whether to scale the bitmap.
use_mask (bool): Whether to use a mask for the bitmap.
Returns:
wx.Bitmap: The created bitmap.
"""
parts = name.split("/")
width = 16
height = 16
size = []
if len(parts) > 1:
size = parts[-2].split("x")
if len(size) == 2:
try:
width, height = list(map(int, size))
except ValueError:
size = []
orig_width, orig_height = width, height
set_default_app_dpi()
scale = getcfg("app.dpi") / get_default_dpi() if scale else 1
if scale > 1:
# HighDPI support
width = round(width * scale)
height = round(height * scale)
if parts[-1] == "empty":
return create_empty_bitmap(width, height, use_mask)
return load_bitmap(
name,
parts,
orig_width,
orig_height,
width,
height,
scale,
display_missing_icon,
)
def create_empty_bitmap(w: int, h: int, use_mask: bool) -> wx.Bitmap:
"""Create an empty bitmap with the specified dimensions.
Args:
w (int): Width of the bitmap.
h (int): Height of the bitmap.
use_mask (bool): Whether to use a mask for the bitmap.
Returns:
wx.Bitmap: The created empty bitmap.
"""
from DisplayCAL.wx_addons import wx
if wx.VERSION[0] < 3:
use_mask = True
if use_mask and sys.platform == "win32":
bmp = wx.EmptyBitmap(w, h)
bmp.SetMaskColour(wx.Colour(0, 0, 0))
else:
bmp = wx.EmptyBitmapRGBA(w, h, 255, 0, 255, 0)
return bmp
def load_bitmap(
name: str,
parts: list[str],
orig_width: int,
orig_height: int,
width: int,
height: int,
scale: float,
display_missing_icon: bool = True,
) -> wx.Bitmap:
"""Load a bitmap from the specified parts and dimensions.
Args:
name (str): The name of the bitmap.
parts (list): A list of parts representing the path to the bitmap.
orig_width (int): Original width of the bitmap.
orig_height (int): Original height of the bitmap.
width (int): New width of the bitmap.
height (int): New height of the bitmap.
scale (float): Scale factor for the bitmap.
display_missing_icon (bool): Whether to display a missing icon if the
bitmap is not found.
Returns:
wx.Bitmap: The loaded bitmap.
"""
from DisplayCAL.wx_addons import wx
bmp = None
width, height, orig_name, name2x, name4x, color, inverted, size = (
extract_image_properties(parts)
)
path, bitmap_size_type = get_scaled_image_path(
parts,
orig_name,
orig_width,
orig_height,
width,
height,
scale,
name2x,
name4x,
size,
)
if path:
bmp = wx.Bitmap(path)
if not bmp.IsOk():
path = None
if path:
width, height, path, bmp = resize_and_adjust_bitmap(
path,
parts,
orig_name,
orig_width,
orig_height,
scale,
color,
inverted,
size,
bitmap_size_type,
bmp,
)
if not path:
print(f"Warning: Missing bitmap '{name}'")
img = wx.Image(width, height)
img.SetMaskColour(0, 0, 0)
img.InitAlpha()
bmp = img.ConvertToBitmap()
dc = wx.MemoryDC()
dc.SelectObject(bmp)
if display_missing_icon:
art = wx.ArtProvider.GetBitmap(wx.ART_MISSING_IMAGE, size=(width, height))
dc.DrawBitmap(art, 0, 0, True)
dc.SelectObject(wx.NullBitmap)
return bmp
def extract_image_properties(
parts: list[str],
) -> tuple[int, int, str, str, str, bool, list[str]]:
"""Extract image properties from the parts list.
Args:
parts (list): A list of parts representing the path to the bitmap.
Returns:
tuple[int, int, str, str, bool, list]: A tuple containing width,
height, original name, color, inverted flag, and size.
"""
width = None
height = None
if parts[-1].startswith(APPNAME):
parts[-1] = parts[-1].lower()
orig_name = parts[-1]
if "#" in orig_name:
# Hex format, RRGGBB or RRGGBBAA
orig_name, color = orig_name.split("#", 1)
parts[-1] = orig_name
else:
color = None
if inverted := orig_name.endswith("-inverted"):
orig_name = parts[-1] = orig_name.split("-inverted")[0]
size = []
if len(parts) > 1:
size = parts[-2].split("x")
if len(size) == 2:
try:
width, height = list(map(int, size))
except ValueError:
size = []
name2x = f"{orig_name}@2x"
name4x = f"{orig_name}@4x"
return width, height, orig_name, name2x, name4x, color, inverted, size
def get_non_scaled_image_path(parts: list[str]) -> tuple[str | None, BitmapSizeType]:
"""Get the path for a non-scaled image.
Args:
parts (list): A list of parts representing the path to the bitmap.
Returns:
tuple[str | None, BitmapSizeType]: A tuple containing the path to the
bitmap and the BitmapSizeType.
"""
path = None
if sys.platform not in ("darwin", "win32") and parts[-1].startswith(
APPNAME.lower()
):
# Search /usr/share/icons on Linux first
path = get_data_path(
"{}.png".format(os.path.join(parts[-2], "apps", parts[-1]))
)
if not path:
path = get_data_path(f"{os.path.sep.join(parts)}.png")
return path, BitmapSizeType.Original
def get_scaled_image_path(
parts: list[str],
orig_name: str,
orig_width: int,
orig_height: int,
width: int,
height: int,
scale: float,
name2x: str,
name4x: str,
size: list[str],
) -> tuple[None | str, BitmapSizeType]:
"""Get the path for a scaled image.
Args:
parts (list[str]): A list of parts representing the path to the bitmap.
orig_name (str): Original name of the bitmap.
orig_width (int): Original width of the bitmap.
orig_height (int): Original height of the bitmap.
width (int): New width of the bitmap.
height (int): New height of the bitmap.
scale (float): Scale factor for the bitmap.
name2x (str): Name for the 2x scaled version.
name4x (str): Name for the 4x scaled version.
size (list[str]): Size information from parts.
Returns:
tuple[None | str, BitmapSizeType]: A tuple containing the path to the
bitmap and the BitmapSizeType.
"""
path = None
bitmap_size_type = BitmapSizeType.Original
if scale == 1:
return get_non_scaled_image_path(parts)
for i in range(5):
bitmap_size_type = BitmapSizeType.to_type(i)
if len(size) == 2:
result = get_scaled_icon_path(
parts,
orig_name,
orig_width,
orig_height,
width,
height,
scale,
name2x,
name4x,
bitmap_size_type,
)
if not result:
continue
else:
result = get_scaled_theme_path(
parts,
orig_name,
scale,
name2x,
name4x,
bitmap_size_type,
)
if not result:
continue
if sys.platform not in ("darwin", "win32") and parts[-1].startswith(
APPNAME.lower()
):
# Search /usr/share/icons on Linux first
path = get_data_path(
"{}.png".format(os.path.join(parts[-2], "apps", parts[-1]))
)
if not path:
path = get_data_path(f"{os.path.sep.join(parts)}.png")
if path:
break
return path, bitmap_size_type
def get_scaled_icon_path(
parts: list[str],
orig_name: str,
orig_width: int,
orig_height: int,
width: int,
height: int,
scale: float,
name2x: str,
name4x: str,
bitmap_size_type: BitmapSizeType,
) -> bool:
"""Get the path for a scaled icon.
Args:
parts (list): A list of parts representing the path to the bitmap.
orig_name (str): Original name of the bitmap.
orig_width (int): Original width of the bitmap.
orig_height (int): Original height of the bitmap.
width (int): New width of the bitmap.
height (int): New height of the bitmap.
scale (float): Scale factor for the bitmap.
name2x (str): Name for the 2x scaled version.
name4x (str): Name for the 4x scaled version.
bitmap_size_type (BitmapSizeType): The bitmap size type.
Returns:
bool: True if the path was successfully set, False otherwise.
"""
# Icon
if bitmap_size_type == BitmapSizeType.HighDPI_Normal:
# HighDPI support. Try scaled size
parts[-2] = f"{width:d}x{height:d}"
elif bitmap_size_type == BitmapSizeType.HighDPI_4x:
if scale < 1.75 or scale == 2:
return False
# HighDPI support. Try @4x version
parts[-2] = f"{orig_width:d}x{orig_height:d}"
parts[-1] = name4x
elif bitmap_size_type == BitmapSizeType.HighDPI_2x:
# HighDPI support. Try @2x version
parts[-2] = f"{orig_width:d}x{orig_height:d}"
parts[-1] = name2x
elif bitmap_size_type == BitmapSizeType.HighDPI_2x_Original:
# HighDPI support. Try original size times two
parts[-2] = f"{orig_width * 2:d}x{orig_height * 2: d}"
parts[-1] = orig_name
else:
# Try original size
parts[-2] = f"{orig_width:d}x{orig_height:d}"
return True
def get_scaled_theme_path(
parts: list[str],
orig_name: str,
scale: float,
name2x: str,
name4x: str,
bitmap_size_type: BitmapSizeType,
) -> bool:
"""Get the path for a scaled theme image.
Args:
parts (list): A list of parts representing the path to the bitmap.
orig_name (str): Original name of the bitmap.
scale (float): Scale factor for the bitmap.
name2x (str): Name for the 2x scaled version.
name4x (str): Name for the 4x scaled version.
bitmap_size_type (BitmapSizeType): The bitmap size type.
Returns:
bool: True if the path was successfully set, False otherwise.
"""
# Theme graphic
if bitmap_size_type in (
BitmapSizeType.HighDPI_Normal,
BitmapSizeType.HighDPI_2x_Original,
):
return False
if bitmap_size_type == BitmapSizeType.HighDPI_4x:
if scale < 1.75 or scale == 2:
return False
# HighDPI support. Try @4x version
parts[-1] = name4x
elif bitmap_size_type == BitmapSizeType.HighDPI_2x:
# HighDPI support. Try @2x version
parts[-1] = name2x
else:
# Try original size
parts[-1] = orig_name
return True
def resize_and_adjust_bitmap(
path: str,
parts: list[str],
orig_name: str,
orig_width: int,
orig_height: int,
scale: float,
color: None | str,
inverted: bool,
size: list[str],
bitmap_size_type: BitmapSizeType,
bmp: wx.Bitmap,
) -> tuple[int, int, None | str]:
"""Resize and adjust the bitmap based on the given parameters.
Args:
path (str): The path to the bitmap.
parts (list): A list of parts representing the path to the bitmap.
orig_name (str): Original name of the bitmap.
orig_width (int): Original width of the bitmap.
orig_height (int): Original height of the bitmap.
scale (float): Scale factor for the bitmap.
color (None | str): Color in hex format, RRGGBB or RRGGBBAA.
inverted (bool): Whether the bitmap should be inverted.
size (list): Size information from parts.
bitmap_size_type (BitmapSizeType): The bitmap size type.
bmp (wx.Bitmap): The original bitmap.
Returns:
tuple[int, int, None | str]: A tuple containing the width, height,
and path to the bitmap.
"""
from DisplayCAL.wx_addons import wx
img = None
img, width, height = adjust_bitmap_size(
scale, orig_name, size, bitmap_size_type, bmp
)
if (
not inverted
and len(parts) > 2
and parts[-3] == "icons"
and (orig_width, orig_height) != (10, 10)
and orig_name not in ("black_luminance", "check_all", "contrast", "luminance")
and max(wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOW)[:3]) < 102
):
# Automatically invert B&W image if background is dark (exceptions do apply)
if not img:
img = bmp.ConvertToImage()
if img.IsBW():
inverted = True
# Invert after resize (avoids jaggies)
if inverted or color:
img = configure_image_channels(orig_name, color, inverted, bmp, img)
if img:
bmp = img.ConvertToBitmap()
if not bmp.IsOk():
path = None
return width, height, path, bmp
def adjust_bitmap_size(
scale: float,
orig_name: str,
size: list[str],
bitmap_size_type: BitmapSizeType,
bmp: wx.Bitmap,
) -> tuple[None | wx.Image, None | int, None | int]:
"""Adjust the bitmap size based on the scale and bitmap size type.
Args:
scale (float): Scale factor for the bitmap.
orig_name (str): Original name of the bitmap.
size (list[str]): Size information from parts.
bitmap_size_type (BitmapSizeType): The bitmap size type.
bmp (wx.Bitmap): The original bitmap.
Returns:
tuple[None | wx.Image, None | int, None | int]: A tuple containing
the image, width, and height of the bitmap.
"""
img = None
w = None
h = None
if scale == 1 or bitmap_size_type == BitmapSizeType.HighDPI_Normal:
return img, w, h
rescale = False
if bitmap_size_type in (BitmapSizeType.HighDPI_4x, BitmapSizeType.HighDPI_2x):
# HighDPI support. 4x/2x version, determine scaled size
w, h = [round(v / (2 * (3 - bitmap_size_type)) * scale) for v in bmp.Size]
rescale = True
elif len(size) == 2:
# HighDPI support. Icon
rescale = True
if rescale and (bmp.Size[0] != w or bmp.Size[1] != h):
from DisplayCAL.wx_addons import wx
# HighDPI support. Rescale
img = bmp.ConvertToImage()
if not hasattr(wx, "IMAGE_QUALITY_BILINEAR") or orig_name == "list-add":
# In case bilinear is not supported,
# and to prevent black borders after resizing for some images
quality = wx.IMAGE_QUALITY_NORMAL
elif orig_name in ():
# Hmm. Everything else looks great with bicubic,
# but this one gets jaggy unless we use bilinear
quality = wx.IMAGE_QUALITY_BILINEAR
elif scale < 1.5 or bitmap_size_type == BitmapSizeType.HighDPI_4x:
quality = wx.IMAGE_QUALITY_BICUBIC
else:
quality = wx.IMAGE_QUALITY_BILINEAR
img.Rescale(w, h, quality=quality)
return img, w, h
def configure_image_channels(
orig_name: str,
color: None | str,
inverted: bool,
bmp: None | wx.Image,
img: None | wx.Image,
) -> wx.Image:
"""Configure image channels based on the given parameters.
Args:
orig_name (str): The original name of the bitmap.
color (None | str): Color in hex format, RRGGBB or RRGGBBAA.
inverted (bool): Whether the bitmap should be inverted.
bmp (wx.Bitmap): The original bitmap.
img (wx.Image | None): The image to adjust.
Returns:
wx.Image: The adjusted image.
"""
from DisplayCAL.wx_addons import wx
factors = None
if not img:
img = bmp.ConvertToImage()
alpha = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNTEXT).alpha
if orig_name in [
"applications-system",
"color",
"document-open",
"document-save-as",
"edit-delete",
"image-x-generic",
"info",
"install",
"list-add",
"package-x-generic",
"question",
"rgbsquares",
"stock_3d-color-picker",
"stock_lock",
"stock_lock-open",
"stock_refresh",
"web",
"window-center",
"zoom-best-fit",
"zoom-in",
"zoom-original",
"zoom-out",
]:
# Scale 85 to 255 and adjust alpha
factors = (3, 3, 3, alpha / 255.0)
else:
if inverted:
img.Invert()
if alpha != 255:
# Only adjust alpha
factors = (1, 1, 1, alpha / 255.0)
if factors:
r, g, b = factors[:3]
alpha = factors[3] if len(factors) > 3 else 1.0
img = img.AdjustChannels(r, g, b, alpha)
if color:
# Hex format, RRGGBB or RRGGBBAA
r = int(color[0:2], 16) / 255.0
g = int(color[2:4], 16) / 255.0
b = int(color[4:6], 16) / 255.0
alpha = int(color[6:8], 16) / 255.0 if len(color) > 6 else 1.0
img = img.AdjustChannels(r, g, b, alpha)
return img
def get_bitmap_as_icon(size: int, name: str, scale: bool = True) -> wx.Icon:
"""Return a wx.Icon instance.
This is like get_icon(), but returns a wx.Icon instance instead of a
wx.Bitmap instance.
Get a bitmap as an icon with the specified size and name.
Args:
size (int): The size of the icon.
name (str): The name of the icon.
scale (bool): Whether to scale the icon.
Returns:
wx.Icon: The (created) icon (instance).
"""
from DisplayCAL.wx_addons import wx
icon = wx.EmptyIcon()
if sys.platform == "darwin" and wx.VERSION >= (2, 9) and size > 128:
# FIXME: wxMac 2.9 doesn't support icon sizes above 128
size = 128
bmp = get_icon(size, name, scale)
icon.CopyFromBitmap(bmp)
return icon
def get_argyll_data_dir() -> str:
"""Return ArgyllCMS data dir.
Returns:
str: The ArgyllCMS data dir.
"""
argyll_version = getcfg("argyll.version")
if isinstance(argyll_version, str):
argyll_version = list(map(int, argyll_version.split(".")))
argyll_data_dirname = "color" if argyll_version < [1, 5, 0] else "ArgyllCMS"
if sys.platform == "darwin" and argyll_version < [1, 5, 0]:
return os.path.join(
LIBRARY if is_superuser() else LIBRARY_HOME, argyll_data_dirname
)
return os.path.join(
COMMONAPPDATA[0] if is_superuser() else APPDATA, argyll_data_dirname
)
def get_display_name(
disp_index: None | int = None, include_geometry: bool = False
) -> str:
"""Return name of currently configured display.
Args:
disp_index (None | int): The index of the display.
include_geometry (bool): Whether to include geometry in the display name.
Returns:
str: The name of the display.
"""
if disp_index is None:
disp_index = getcfg("display.number") - 1
displays = getcfg("displays")
if 0 <= disp_index < len(displays):
return (
displays[disp_index]
if include_geometry
else split_display_name(displays[disp_index])
)
return ""
def split_display_name(display: str) -> str:
"""Split and return name part of display.
Args:
display (str): The display name.
Returns:
str: The name part of the display.
E.g.
'LCD2690WUXi @ 0, 0, 1920x1200' -> 'LCD2690WUXi'
'madVR' -> 'madVR'
"""
if "@" in display and not display.startswith("Chromecast "):
display = "@".join(display.split("@")[:-1])
return display.strip()
def get_argyll_display_number(geometry: tuple[int, int, int, int]) -> None | int:
"""Translate from wx display geometry to Argyll display index.
Args:
geometry (tuple[int, int, int, int]): The geometry of the display.
Returns:
None | int: The Argyll display index.
"""
geometry = f"{geometry[0]}, {geometry[1]}, {geometry[2]}x{geometry[3]}"
for i, display in enumerate(getcfg("displays")):
if display.find(f"@ {geometry}") > -1:
debug_print(f"[D] Found display {geometry} at index {i}")
return i
return None
def get_display_number(display_no: int) -> int:
"""Translate from Argyll display index to wx display index.
Args:
display_no (int): The Argyll display index.
Returns:
int: The wx display index.
"""
if is_virtual_display(display_no):
return 0
from DisplayCAL.wx_addons import wx
try:
display = getcfg("displays")[display_no]
except IndexError:
return 0
else:
if display.endswith(" [PRIMARY]"):
display = " ".join(display.split(" ")[:-1])
for i in range(wx.Display.GetCount()):
geometry = "{:d}, {:d}, {:d}x{:d}".format(*wx.Display(i).Geometry)
if display.endswith(f"@ {geometry}"):
debug_print(f"[D] Found display {geometry} at index {i}")
return i
return 0
def get_display_rects() -> list[tuple[int, int, int, int]]:
"""Return the Argyll enumerated display coordinates and sizes.
Returns:
list[tuple[int, int, int, int]]: A list of wx.Rect objects representing
the display coordinates and sizes.
"""
from DisplayCAL.wx_addons import wx
display_rects = []
for _i, display in enumerate(getcfg("displays")):
match = re.search(r"@ (-?\d+), (-?\d+), (\d+)x(\d+)", display)
if match:
display_rects.append(wx.Rect(*[int(item) for item in match.groups()]))
return display_rects
def get_icon_bundle(sizes: list[int], name: str) -> wx.IconBundle:
"""Return a wx.IconBundle with given icon sizes.
Args:
sizes (list[int]): A list of icon sizes.
name (str): The name of the icon.
Returns:
wx.IconBundle: The icon bundle.
"""
from DisplayCAL.wx_addons import wx
iconbundle = wx.IconBundle()
if not sizes:
# Assume ICO format
pth = get_data_path(f"theme/icons/{name}.ico")
if pth:
ico = wx.Icon(pth)
if ico.IsOk():
iconbundle.AddIcon(ico)
return iconbundle
sizes = [16]
for size in sizes:
iconbundle.AddIcon(get_bitmap_as_icon(size, name, False))
return iconbundle
def get_instrument_name() -> str:
"""Return name of currently configured instrument.
Returns:
str: The name of the instrument.
"""
n = getcfg("comport.number") - 1
instrument_names = getcfg("instruments")
if 0 <= n < len(instrument_names):
return instrument_names[n]
return ""
def get_measureframe_dimensions(
dimensions_measureframe: None | str = None, percent: int = 10
) -> str:
"""Return measurement area size adjusted for percentage of screen area.
Args:
dimensions_measureframe (str): The dimensions of the measure frame.
percent (int): The percentage of screen area.
Returns:
str: The coma separated measurement frame size.
"""
if not dimensions_measureframe:
dimensions_measureframe = getcfg("dimensions.measureframe")
dimensions_measureframe = [float(n) for n in dimensions_measureframe.split(",")]
dimensions_measureframe[2] *= DEFAULTS["size.measureframe"]
dimensions_measureframe[2] /= get_display_rects()[0][2]
dimensions_measureframe[2] *= percent
return ",".join([str(min(n, 50)) for n in dimensions_measureframe])
def get_icon(
size: int, name: str, scale: bool = True, use_mask: bool = False
) -> wx.Bitmap:
"""Convenience function for get_bitmap('theme/icons//').
Args:
size (int): The size of the icon.
name (str): The name of the icon.
scale (bool): Whether to scale the icon.
use_mask (bool): Whether to use a mask for the icon.
Returns:
wx.Bitmap: The icon bitmap.
"""
return get_bitmap(
f"theme/icons/{size}x{size}/{name}",
scale=scale,
use_mask=use_mask,
)
def get_data_path(relpath: str, regex: None | str = None) -> None | str | list[str]:
"""Search data_dirs for relpath and return the path or a file list.
If relpath is a file, return the full path, if relpath is a directory,
return a list of files in the intersection of searched directories.
Args:
relpath (str): The relative path to search for.
regex (None | str): A regular expression to filter files.
Returns:
None | str | list[str]: The full path if a file is found, or a list of
files if a directory is found, or None if nothing was found.
"""
if (
not relpath
or relpath.endswith(os.path.sep)
or (isinstance(os.path.altsep, str) and relpath.endswith(os.path.altsep))
):
return None
dirs = list(DATA_DIRS)
argyll_dir = getcfg("argyll.dir") or os.path.dirname(
os.path.realpath(which(f"dispcal{EXE_EXT}") or "")
)
if argyll_dir and os.path.isdir(os.path.join(argyll_dir, "..", "ref")):
dirs.append(os.path.dirname(argyll_dir))
dirs.extend(EXTRA_DATA_DIRS)
intersection = []
paths = []
for dir_ in dirs:
curpath = os.path.join(dir_, relpath)
if (
dir_.endswith("/argyll")
and f"{relpath}/".startswith("ref/")
and not os.path.exists(curpath)
):
# Work-around distribution-specific differences for location of
# Argyll reference files
# Fedora and Ubuntu: /usr/share/color/argyll/ref
# openSUSE: /usr/share/color/argyll
pth = relpath.split("/", 1)[-1]
curpath = os.path.join(dir_, pth) if pth != "ref" else dir_
if os.path.exists(curpath):
curpath = os.path.normpath(curpath)
if os.path.isdir(curpath):
try:
filelist = listdir_re(curpath, regex)
except Exception as exception:
print(f"Error - directory '{curpath}' listing failed: {exception}")
else:
for filename in filelist:
if filename not in intersection:
intersection.append(filename)
paths.append(os.path.join(curpath, filename))
else:
return curpath
if paths:
paths.sort(key=lambda path: os.path.basename(path).lower())
return None if len(paths) == 0 else paths
def get_default_dpi() -> float:
"""Return default DPI depending on the current platform.
Returns:
float: The DPI value.
"""
return 72.0 if sys.platform == "darwin" else 96.0
def runtimeconfig(pyfile: str) -> str:
"""Configure remaining runtime options and return runtype.
You need to pass in a path to the calling script (e.g. use the __file__
attribute).
Args:
pyfile (str): The path to the calling script.
Returns:
str: The runtime type.
"""
# global safe_log
from DisplayCAL.log import setup_logging
setup_logging(LOGDIR, PYNAME, PYEXT, confighome=CONFIG_HOME)
debug_print("[D] pydir:", PYDIR)
if ISAPP:
runtype = ".app"
elif ISEXE:
debug_print("[D] _MEIPASS2 or pydir:", getenvu("_MEIPASS2", EXEDIR))
if getenvu("_MEIPASS2", EXEDIR) not in DATA_DIRS:
DATA_DIRS.insert(1, getenvu("_MEIPASS2", EXEDIR))
runtype = EXE_EXT
else:
pydir_parent = os.path.dirname(PYDIR)
debug_print(
"[D] dirname(os.path.abspath(sys.argv[0])):",
os.path.dirname(os.path.abspath(sys.argv[0])),
)
debug_print("[D] pydir parent:", pydir_parent)
if (
os.path.dirname(os.path.abspath(sys.argv[0])) == pydir_parent
and pydir_parent not in DATA_DIRS
):
# Add the parent directory of the package directory to our list of
# data directories if it is the directory containing the currently
# run script (e.g. when running from source)
DATA_DIRS.insert(1, pydir_parent)
runtype = PYEXT
for dir_ in sys.path:
if not isinstance(dir_, str):
dir_ = dir_.encode(FS_ENC)
dir_ = os.path.abspath(os.path.join(dir_, APPNAME))
if dir_ not in DATA_DIRS and os.path.isdir(dir_):
DATA_DIRS.append(dir_)
debug_print("[D] from sys.path:", dir_)
if sys.platform not in ("darwin", "win32"):
DATA_DIRS.extend(
[
os.path.join(dir_, "doc", f"{APPNAME}-{VERSION_STRING}")
for dir_ in [*XDG_DATA_DIRS, XDG_DATA_HOME]
]
)
DATA_DIRS.extend(
[
os.path.join(dir_, "doc", "packages", APPNAME)
for dir_ in [*XDG_DATA_DIRS, XDG_DATA_HOME]
]
)
DATA_DIRS.extend(
[
os.path.join(dir_, "doc", APPNAME)
for dir_ in [*XDG_DATA_DIRS, XDG_DATA_HOME]
]
)
DATA_DIRS.extend(
[
os.path.join(dir_, "doc", APPNAME.lower()) # Debian
for dir_ in [*XDG_DATA_DIRS, XDG_DATA_HOME]
]
)
DATA_DIRS.extend(
[
os.path.join(dir_, "icons", "hicolor")
for dir_ in [*XDG_DATA_DIRS, XDG_DATA_HOME]
]
)
debug_print("[D] Data files search paths:\n[D]", "\n[D] ".join(DATA_DIRS))
DEFAULTS["calibration.file"] = get_data_path("presets/default.icc") or ""
DEFAULTS["measurement_report.chart"] = (
get_data_path(os.path.join("ref", "verify_extended.ti1")) or ""
)
return runtype
class CaseSensitiveConfigParser(configparser.RawConfigParser):
"""Case sensitive config parser."""
def optionxform(self, optionstr: str) -> str:
"""Return the option string as is, preserving case sensitivity.
Args:
optionstr (str): The option string to be processed.
"""
return optionstr
# User settings
CFG = CaseSensitiveConfigParser()
CFG["Default"] = {}
VALID_RANGES = {
"3dlut.hdr_peak_luminance": [100.0, 10000.0],
"3dlut.hdr_minmll": [0.0, 0.1],
"3dlut.hdr_maxmll": [100.0, 10000.0],
"3dlut.trc_gamma": [0.000001, 10],
"3dlut.hdr_sat": [0.0, 1.0],
"3dlut.hdr_hue": [0.0, 1.0],
"3dlut.trc_output_offset": [0.0, 1.0],
"app.port": [1, 65535],
"gamma": [0.000001, 10],
"trc": [0.000001, 10],
# 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.
"calibration.ambient_viewcond_adjust.lux": [0.0, sys.maxsize / 5.0],
"calibration.black_luminance": [0.000001, 10],
"calibration.black_output_offset": [0, 1],
"calibration.black_point_correction": [0, 1],
"calibration.black_point_rate": [0.05, 20],
"calibration.luminance": [20, 100000],
"iccgamut.surface_detail": [1.0, 50.0],
"measurement_report.trc_gamma": [0.01, 10],
"measurement_report.trc_output_offset": [0.0, 1.0],
"measure.display_settle_time_mult": [0.000001, 10000.0],
"measure.min_display_update_delay_ms": [20, 60000],
"multiprocessing.max_cpus": [0, 65],
"patterngenerator.apl": [0.0, 1.0],
"patterngenerator.ffp_insertion.duration": [0.1, 60.0],
"patterngenerator.ffp_insertion.interval": [0.0, 3600.0],
"patterngenerator.ffp_insertion.level": [0.0, 1.0],
"patterngenerator.quantize_bits": [0, 32],
"patterngenerator.resolve.port": [1, 65535],
"profile_loader.quantize_bits": [8, 16],
"synthprofile.trc_gamma": [0.01, 10],
"synthprofile.trc_output_offset": [0.0, 1.0],
"tc_export_repeat_patch_max": [1, 1000],
"tc_export_repeat_patch_min": [1, 1000],
"tc_vrml_black_offset": [0, 40],
"webserver.portnumber": [1, 65535],
"whitepoint.colortemp": [1000, 15000],
"whitepoint.visual_editor.bg_v": [0, 255],
"whitepoint.visual_editor.b": [0, 255],
"whitepoint.visual_editor.g": [0, 255],
"whitepoint.visual_editor.r": [0, 255],
}
VALID_VALUES = {
"3d.format": ["HTML", "VRML", "X3D"],
"3dlut.bitdepth.input": [8, 10, 12, 14, 16],
"3dlut.bitdepth.output": [8, 10, 12, 14, 16],
"3dlut.encoding.input": list(VIDEO_ENCODINGS),
# collink: xvYCC output encoding is not supported
"3dlut.encoding.output": [v for v in VIDEO_ENCODINGS if v not in ("T", "x", "X")],
"3dlut.format": [
"3dl",
"cube",
"dcl",
"eeColor",
"icc",
"madVR",
"mga",
"png",
"ReShade",
"spi3d",
],
"3dlut.hdr_display": [0, 1],
"3dlut.image.layout": ["h", "v"],
"3dlut.image.order": ["rgb", "bgr"],
"3dlut.rendering_intent": INTENTS,
"3dlut.size": [5, 9, 16, 17, 24, 32, 33, 64, 65],
"3dlut.trc": [
"bt1886",
"customgamma",
"gamma2.2",
"smpte2084.hardclip",
"smpte2084.rolloffclip",
"hlg",
],
"3dlut.trc_gamma_type": ["b", "B"],
"calibration.quality": ["v", "l", "m", "h", "u"],
"colorimeter_correction.observer": OBSERVERS,
"colorimeter_correction.observer.reference": OBSERVERS,
"colorimeter_correction.type": ["matrix", "spectral"],
# Measurement modes as supported by Argyll -y parameter
# 'l' = 'n' (non-refresh-type display, e.g. LCD)
# 'c' = 'r' (refresh-type display, e.g. CRT)
# We map 'l' and 'c' to "n" and "r" in
# worker.Worker.add_measurement_features if using Argyll >= 1.5
# See http://www.argyllcms.com/doc/instruments.html for description of
# per-instrument supported modes
"measurement_mode": [None, "auto", *list(string.digits[1:] + string.ascii_letters)],
"gamap_default_intent": ["a", "r", "p", "s"],
"gamap_perceptual_intent": INTENTS,
"gamap_saturation_intent": INTENTS,
"gamap_src_viewcond": VIEWCONDS,
"gamap_out_viewcond": ["mt", "mb", "md", "jm", "jd"],
"measurement_report.trc_gamma_type": ["b", "B"],
"observer": OBSERVERS,
"patterngenerator.detect_video_levels": [0, 1],
"patterngenerator.prisma.preset": [
"Movie",
"Sports",
"Game",
"Animation",
"PC/Mac",
"Black+White",
"Custom-1",
"Custom-2",
],
"patterngenerator.use_video_levels": [0, 1],
"profile.black_point_compensation": [0, 1],
"profile.install_scope": ["l", "u"],
"profile.quality": ["l", "m", "h", "u"],
"profile.quality.b2a": ["l", "m", "h", "u", "n", None],
"profile.b2a.hires.size": [-1, 9, 17, 33, 45, 65],
"profile.type": ["g", "G", "l", "s", "S", "x", "X"],
"profile_loader.tray_icon_animation_quality": [0, 1, 2],
"synthprofile.black_point_compensation": [0, 1],
"synthprofile.trc_gamma_type": ["g", "G"],
"tc_algo": ["", "t", "r", "R", "q", "Q", "i", "I"], # Q = Argyll >= 1.1.0
"tc_vrml_use_D50": [0, 1],
"tc_vrml_cie_colorspace": [
"DIN99",
"DIN99b",
"DIN99c",
"DIN99d",
"ICtCp",
"IPT",
"LCH(ab)",
"LCH(uv)",
"Lab",
"Lpt",
"Luv",
"Lu'v'",
"xyY",
],
"tc_vrml_device_colorspace": ["HSI", "HSL", "HSV", "RGB"],
"testchart.auto_optimize": list(range(19)),
"testchart.patch_sequence": [
"optimize_display_response_delay",
"maximize_lightness_difference",
"maximize_rec709_luma_difference",
"maximize_RGB_difference",
"vary_RGB_difference",
],
"trc": ["240", "709", "l", "s", ""],
"trc.type": ["g", "G"],
"uniformity.cols": [3, 5, 7, 9],
"uniformity.rows": [3, 5, 7, 9],
"whitepoint.colortemp.locus": ["t", "T"],
}
CONTENT_RGB_SPACE = colormath.get_rgb_space("DCI P3 D65")
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]
DEFAULTS = {
"3d.format": "HTML",
"3dlut.apply_black_offset": 0,
"3dlut.apply_trc": 1,
"3dlut.bitdepth.input": 10,
"3dlut.bitdepth.output": 12,
"3dlut.content.colorspace.blue.x": CBX,
"3dlut.content.colorspace.blue.y": CBY,
"3dlut.content.colorspace.green.x": CGX,
"3dlut.content.colorspace.green.y": CGY,
"3dlut.content.colorspace.red.x": CRX,
"3dlut.content.colorspace.red.y": CRY,
"3dlut.content.colorspace.white.x": CWX,
"3dlut.content.colorspace.white.y": CWY,
"3dlut.create": 0,
"3dlut.trc": "bt1886",
"3dlut.trc_gamma": 2.4,
"3dlut.trc_gamma.backup": 2.4,
"3dlut.trc_gamma_type": "B",
"3dlut.trc_output_offset": 0.0,
"3dlut.encoding.input": "n",
"3dlut.encoding.input.backup": "n",
"3dlut.encoding.output": "n",
"3dlut.encoding.output.backup": "n",
"3dlut.format": "cube",
"3dlut.gamap.use_b2a": 0,
"3dlut.hdr_display": 0,
"3dlut.hdr_minmll": 0.0,
"3dlut.hdr_maxmll": 10000.0,
"3dlut.hdr_maxmll_alt_clip": 1,
"3dlut.hdr_peak_luminance": 480.0,
"3dlut.hdr_ambient_luminance": 5.0,
"3dlut.hdr_sat": 0.5,
"3dlut.hdr_hue": 0.5,
"3dlut.image.layout": "h",
"3dlut.image.order": "rgb",
"3dlut.input.profile": "",
"3dlut.abstract.profile": "",
"3dlut.enable": 1,
"3dlut.output.profile": "",
"3dlut.output.profile.apply_cal": 1,
"3dlut.preserve_sync": 0,
"3dlut.rendering_intent": "aw",
"3dlut.use_abstract_profile": 0,
"3dlut.size": 65,
"3dlut.size.backup": 65,
"3dlut.tab.enable": 0,
"3dlut.tab.enable.backup": 0,
"3dlut.whitepoint.x": 0.3127,
"3dlut.whitepoint.y": 0.329,
"allow_skip_sensor_cal": 0,
"app.allow_network_clients": 0,
"app.dpi": get_default_dpi(),
"app.port": 15411,
"argyll.debug": 0,
"argyll.dir": None,
"argyll.version": "0.0.0",
"argyll.domain": "https://github.com/eoyilmaz/argyllcms-binaries",
"drift_compensation.blacklevel": 0,
"drift_compensation.whitelevel": 0,
"calibration.ambient_viewcond_adjust": 0,
"calibration.ambient_viewcond_adjust.lux": 32.0,
"calibration.autoload": 0,
"calibration.black_luminance": 0.000001,
"calibration.black_luminance.backup": 0.000001,
"calibration.black_output_offset": 1.0,
"calibration.black_output_offset.backup": 1.0,
"calibration.black_point_correction": 0.0,
"calibration.black_point_correction.auto": 0,
"calibration.black_point_correction_choice.show": 1,
"calibration.black_point_hack": 0,
"calibration.black_point_rate": 4.0,
"calibration.black_point_rate.enabled": 0,
"calibration.continue_next": 0,
"calibration.file": "",
"calibration.file.previous": None,
"calibration.interactive_display_adjustment": 1,
"calibration.interactive_display_adjustment.backup": 1,
"calibration.luminance": 120.0,
"calibration.luminance.backup": 120.0,
"calibration.quality": "l",
"calibration.update": 0,
"calibration.use_video_lut": 1,
"calibration.use_video_lut.backup": 1,
"ccmx.use_four_color_matrix_method": 0,
"colorimeter_correction.instrument": None,
"colorimeter_correction.instrument.reference": None,
"colorimeter_correction.measurement_mode": "l",
"colorimeter_correction.measurement_mode.reference.adaptive": 1,
"colorimeter_correction.measurement_mode.reference.highres": 1,
"colorimeter_correction.measurement_mode.reference.projector": 0,
"colorimeter_correction.measurement_mode.reference": "l",
"colorimeter_correction.observer": "1931_2",
"colorimeter_correction.observer.reference": "1931_2",
"colorimeter_correction.testchart": "ccxx.ti1",
"colorimeter_correction_matrix_file": "AUTO:",
"colorimeter_correction.type": "matrix",
"comport.number": 1,
"comport.number.backup": 1,
# Note: worker.Worker.enumerate_displays_and_ports() overwrites copyright
"copyright": f"No copyright. Created with {APPNAME} {VERSION_STRING} and ArgyllCMS",
"dimensions.measureframe": "0.5,0.5,1.0",
"dimensions.measureframe.unzoomed": "0.5,0.5,1.0",
"dimensions.measureframe.whitepoint.visual_editor": "0.5,0.5,1.0",
"display.number": 1,
"display_lut.link": 1,
"display_lut.number": 1,
"display.technology": "LCD",
"displays": "",
"dry_run": 0,
"enumerate_ports.auto": 0,
"extra_args.collink": "",
"extra_args.colprof": "",
"extra_args.dispcal": "",
"extra_args.dispread": "",
"extra_args.specplot": "",
"extra_args.spotread": "",
"extra_args.targen": "",
"gamap_default_intent": "p",
"gamap_out_viewcond": None,
"gamap_profile": "",
"gamap_perceptual": 0,
"gamap_perceptual_intent": "p",
"gamap_saturation": 0,
"gamap_saturation_intent": "s",
"gamap_src_viewcond": None,
"gamma": 2.2,
"iccgamut.surface_detail": 10.0,
"instruments": "",
"last_3dlut_path": "",
"last_archive_save_path": "",
"last_cal_path": "",
"last_cal_or_icc_path": "",
"last_colorimeter_ti3_path": "",
"last_testchart_export_path": "",
"last_filedialog_path": "",
"last_icc_path": "",
"last_launch": "99", # Version
"last_reference_ti3_path": "",
"last_specplot_path": "",
"last_ti1_path": "",
"last_ti3_path": "",
"last_vrml_path": "",
"log.autoshow": 0,
"log.show": 0,
"lang": "en",
# The last_[...]_path defaults are set in localization.py
"lut_viewer.show": 0,
"lut_viewer.show_actual_lut": 0,
"madtpg.host": "localhost",
"madtpg.native": 1,
"madtpg.port": 60562,
"measurement_mode": "l",
"measurement_mode.adaptive": 1,
"measurement_mode.backup": "l",
"measurement_mode.highres": 1,
"measurement_mode.projector": 0,
"measurement_report.apply_black_offset": 0,
"measurement_report.apply_trc": 0,
"measurement_report.trc_gamma": 2.4,
"measurement_report.trc_gamma.backup": 2.4,
"measurement_report.trc_gamma_type": "B",
"measurement_report.trc_output_offset": 0.0,
"measurement_report.chart": "",
"measurement_report.chart.fields": "RGB",
"measurement_report.devlink_profile": "",
"measurement_report.output_profile": "",
"measurement_report.whitepoint.simulate": 0,
"measurement_report.whitepoint.simulate.relative": 0,
"measurement_report.simulation_profile": "",
"measurement_report.use_devlink_profile": 0,
"measurement_report.use_simulation_profile": 0,
"measurement_report.use_simulation_profile_as_output": 0,
"measurement.name.expanded": "",
"measurement.play_sound": 1,
"measurement.save_path": expanduseru("~"),
"measure.darken_background": 0,
"measure.darken_background.show_warning": 1,
"measure.display_settle_time_mult": 1.0,
"measure.display_settle_time_mult.backup": 1.0,
"measure.min_display_update_delay_ms": 20,
"measure.min_display_update_delay_ms.backup": 20,
"measure.override_display_settle_time_mult": 0,
"measure.override_display_settle_time_mult.backup": 0,
"measure.override_min_display_update_delay_ms": 0,
"measure.override_min_display_update_delay_ms.backup": 0,
"multiprocessing.max_cpus": 0,
"observer": "1931_2",
"observer.backup": "1931_2",
"patterngenerator.apl": 0.22,
"patterngenerator.detect_video_levels": 1,
"patterngenerator.ffp_insertion": 0,
"patterngenerator.ffp_insertion.duration": 5.0,
"patterngenerator.ffp_insertion.interval": 5.0,
"patterngenerator.ffp_insertion.level": 0.15,
"patterngenerator.prisma.argyll": 0,
"patterngenerator.prisma.host": "",
"patterngenerator.prisma.preset": "Custom-1",
"patterngenerator.prisma.port": 80,
"patterngenerator.quantize_bits": 0,
"patterngenerator.resolve": "CM",
"patterngenerator.resolve.port": 20002,
"patterngenerator.use_pattern_window": 0,
"patterngenerator.use_video_levels": 0,
"position.x": 50,
"position.y": 50,
"position.info.x": 50,
"position.info.y": 50,
"position.lut_viewer.x": 50,
"position.lut_viewer.y": 50,
"position.lut3dframe.x": 50,
"position.lut3dframe.y": 50,
"position.profile_info.x": 50,
"position.profile_info.y": 50,
"position.progress.x": 50,
"position.progress.y": 50,
"position.reportframe.x": 50,
"position.reportframe.y": 50,
"position.scripting.x": 50,
"position.scripting.y": 50,
"position.synthiccframe.x": 50,
"position.synthiccframe.y": 50,
"position.tcgen.x": 50,
"position.tcgen.y": 50,
# Force black point compensation due to OS X bugs with non BPC profiles
"profile.black_point_compensation": 0 if sys.platform != "darwin" else 1,
"profile.black_point_correction": 0.0,
"profile.create_gamut_views": 1,
"profile.install_scope": (
"l" if (sys.platform != "win32" and os.geteuid() == 0) else "u" # Linux, OSX
),
"profile.license": "Public Domain",
"profile.load_on_login": 1,
"profile.name": "_".join( # noqa: FLY002
[
"%dns",
"%out",
"%Y-%m-%d_%H-%M",
"%cb",
"%wp",
"%cB",
"%ck",
"%cg",
"%cq-%pq",
"%pt",
]
),
"profile.name.expanded": "",
"profile.quality": "h",
"profile.quality.b2a": "h",
"profile.b2a.hires": 1,
"profile.b2a.hires.diagpng": 2,
"profile.b2a.hires.size": -1,
"profile.b2a.hires.smooth": 1,
"profile.save_path": STORAGE, # directory
# Force profile type to single shaper + matrix due to OS X bugs with cLUT
# profiles and matrix profiles with individual shaper curves
"profile.type": "X" if sys.platform != "darwin" else "S",
"profile.update": 0,
"profile_loader.buggy_video_drivers": "*",
"profile_loader.check_gamma_ramps": 1,
"profile_loader.error.show_msg": 1,
"profile_loader.exceptions": "",
"profile_loader.fix_profile_associations": 1,
"profile_loader.ignore_unchanged_gamma_ramps": 1,
"profile_loader.known_apps": ";".join( # noqa: FLY002
[
"basiccolor display.exe",
"calclient.exe",
"coloreyes display pro.exe",
"colorhcfr.exe",
"colormunkidisplay.exe",
"colornavigator.exe",
"cpkeeper.exe",
"dell ultrasharp calibration solution.exe",
"hp_dreamcolor_calibration_solution.exe",
"i1profiler.exe",
"icolordisplay.exe",
"spectraview.exe",
"spectraview profiler.exe",
"spyder3elite.exe",
"spyder3express.exe",
"spyder3pro.exe",
"spyder4elite.exe",
"spyder4express.exe",
"spyder4pro.exe",
"spyder5elite.exe",
"spyder5express.exe",
"spyder5pro.exe",
"spyderxelite.exe",
"spyderxpro.exe",
"dispcal.exe",
"dispread.exe",
"dispwin.exe",
"flux.exe",
"dccw.exe",
]
),
"profile_loader.known_window_classes": "CalClient.exe",
# Number of times to (re)try loading calibration when a load doesn't
# verify as loaded (e.g. macOS intermittently clobbering the VideoLUT to
# black right after loading). See profile_loader.apply_profiles().
"profile_loader.load_retries": 3,
# macOS only: keep the apply-profiles process running and periodically
# re-load calibration if the OS (WindowServer) has clobbered the VideoLUT
# (the "black screen" bug). See profile_loader.ProfileLoader._macos_watch().
"profile_loader.macos_reapply_watch": 1,
"profile_loader.macos_reapply_watch_interval": 5,
# Maximum number of scan/reload passes the macOS watch will run in a
# single tick to converge all displays before giving up until the next
# tick. Re-loading one display's calibration can itself trigger the OS to
# clobber a *different* display (issue #824), so each pass re-scans and
# re-loads every clobbered display together rather than reacting to one
# display at a time, which could ping-pong between displays forever. See
# profile_loader.ProfileLoader._reload_clobbered_displays().
"profile_loader.macos_reapply_watch_max_passes": 5,
# Some multi-display Macs never converge (reloading one display
# deterministically clobbers another's VideoLUT and vice-versa, issue
# #824). After this many consecutive watch ticks without converging, back
# off instead of retrying forever. See
# profile_loader.ProfileLoader._macos_watch().
"profile_loader.macos_reapply_watch_unstable_threshold": 3,
# How long (in seconds) to stop touching the displays after the unstable
# threshold above is hit, before trying again.
"profile_loader.macos_reapply_watch_backoff_seconds": 300,
# VideoLUT verify discrepancy (in percent) above which the loaded
# calibration is considered clobbered/degenerate (e.g. a black screen)
# rather than just quantization noise. dispwin's own "is loaded" tolerance
# (~0.4%) is far too tight for this purpose, so we use the reported
# discrepancy with this much more lenient threshold to avoid needlessly
# re-loading (and thereby re-triggering the bug). See
# profile_loader.ProfileLoader._calibration_load_discrepancy().
"profile_loader.clobbered_discrepancy_threshold": 25,
# VideoLUT maximum output value (0.0 - 1.0) below which the macOS
# background watch considers a display's calibration clobbered/black.
# Checked directly via CoreGraphics rather than by running `dispwin -V`,
# since spawning any dispwin subprocess - even a read-only verify - can
# itself trigger the OS to clobber a *different* display (issue #824).
# See profile_loader.ProfileLoader._clobbered_displays() and
# worker.get_macos_videolut_maxima().
"profile_loader.macos_videolut_black_threshold": 0.05,
"profile_loader.quantize_bits": 16,
"profile_loader.reset_gamma_ramps": 0,
"profile_loader.show_notifications": 0,
"profile_loader.smooth_bits": "8",
"profile_loader.track_other_processes": 1,
"profile_loader.tray_icon_animation_quality": 2,
"profile_loader.use_madhcnet": 0,
"profile_loader.verify_calibration": 0,
"recent_cals": "",
"report.pack_js": 1,
"settings.changed": 0,
"show_advanced_options": 0,
"show_donation_message": 1,
"size.info.w": 512,
"size.info.h": 384,
"size.lut3dframe.w": 512,
"size.lut3dframe.h": 384,
"size.measureframe": 300,
"size.profile_info.w": 432,
"size.profile_info.split.w": 960,
"size.profile_info.h": 552,
"size.lut_viewer.w": 432,
"size.lut_viewer.h": 552,
"size.reportframe.w": 512,
"size.reportframe.h": 256,
"size.scripting.w": 512,
"size.scripting.h": 384,
"size.synthiccframe.w": 512,
"size.synthiccframe.h": 384,
"size.tcgen.w": 0,
"size.tcgen.h": 0,
"skip_legacy_serial_ports": 1,
"skip_scripts": 1,
"splash.zoom": 0,
"splash.simple": 0,
"startup_sound.enable": 1,
"sudo.preserve_environment": 1,
"synthprofile.black_luminance": 0.0,
"synthprofile.luminance": 120.0,
"synthprofile.trc_gamma": 2.4,
"synthprofile.trc_gamma_type": "G",
"synthprofile.trc_output_offset": 0.0,
"tc_adaption": 0.1,
"tc_add_ti3_relative": 1,
"tc_algo": "",
"tc_angle": 0.3333,
"tc_black_patches": 4,
"tc_export_repeat_patch_max": 1,
"tc_export_repeat_patch_min": 1,
"tc_filter": 0,
"tc_filter_L": 50,
"tc_filter_a": 0,
"tc_filter_b": 0,
"tc_filter_rad": 255,
"tc_fullspread_patches": 0,
"tc_gamma": 1.0,
"tc_gray_patches": 9,
"tc_multi_bcc": 0,
"tc_multi_bcc_steps": 0,
"tc_multi_steps": 3,
"tc_neutral_axis_emphasis": 0.5,
"tc_dark_emphasis": 0.0,
"tc_precond": 0,
"tc_precond_profile": "",
"tc.saturation_sweeps": 5,
"tc.saturation_sweeps.custom.R": 0.0,
"tc.saturation_sweeps.custom.G": 0.0,
"tc.saturation_sweeps.custom.B": 0.0,
"tc_single_channel_patches": 0,
"tc_vrml_black_offset": 40,
"tc_vrml_cie": 0,
"tc_vrml_cie_colorspace": "Lab",
"tc_vrml_device_colorspace": "RGB",
"tc_vrml_device": 1,
"tc_vrml_use_D50": 0,
"tc_white_patches": 4,
"tc.show": 0,
# Profile type forced to matrix due to OS X bugs with cLUT profiles.
# Set smallest testchart.
"testchart.auto_optimize": 4 if sys.platform != "darwin" else 1,
"testchart.file": "auto",
"testchart.file.backup": "auto",
"testchart.patch_sequence": "optimize_display_response_delay",
"testchart.reference": "",
"ti3.check_sanity.auto": 0,
"trc": 2.2,
"trc.backup": 2.2,
"trc.should_use_viewcond_adjust.show_msg": 1,
"trc.type": "g",
"trc.type.backup": "g",
"uniformity.cols": 5,
"uniformity.measure.continuous": 0,
"uniformity.rows": 5,
"untethered.measure.auto": 1,
"untethered.measure.manual.delay": 0.75,
"untethered.max_delta.chroma": 0.5,
"untethered.min_delta": 1.5,
"untethered.min_delta.lightness": 1.0,
"update_check": 1,
"use_fancy_progress": 1,
"use_separate_lut_access": 0,
"vrml.compress": 1,
"webserver.portnumber": 8080,
"whitepoint.colortemp": 6500,
"whitepoint.colortemp.backup": 6500,
"whitepoint.colortemp.locus": "t",
"whitepoint.visual_editor.bg_v": 255,
"whitepoint.visual_editor.b": 255,
"whitepoint.visual_editor.g": 255,
"whitepoint.visual_editor.r": 255,
"whitepoint.x": 0.3127,
"whitepoint.x.backup": 0.3127,
"whitepoint.y": 0.3290,
"whitepoint.y.backup": 0.3290,
"x3dom.cache": 1,
"x3dom.embed": 0,
}
LCODE, LENC = locale.getlocale()
if LCODE:
DEFAULTS["lang"] = LCODE.split("_")[0].lower()
TESTCHART_DEFAULTS = {
"s": {None: "auto"}, # shaper + matrix
"l": {None: "auto"}, # lut
"g": {None: "auto"}, # gamma + matrix
}
def _init_testcharts() -> None:
RES_FILES.extend(
os.path.join("ti1", chart)
for testcharts in list(TESTCHART_DEFAULTS.values())
for chart in [value for value in list(testcharts.values()) if value != "auto"]
)
TESTCHART_DEFAULTS["G"] = TESTCHART_DEFAULTS["g"]
TESTCHART_DEFAULTS["S"] = TESTCHART_DEFAULTS["s"]
for key in ("X", "x"):
TESTCHART_DEFAULTS[key] = TESTCHART_DEFAULTS["l"]
def getcfg(
name: str,
fallback: bool = True,
raw: bool = False,
cfg: configparser.ConfigParser = CFG,
) -> Any: # noqa: ANN401
"""Get and return an option value from the configuration.
If fallback evaluates to True and the option is not set, return its default
value.
Args:
name (str): The name of the option to get.
fallback (bool): Whether to return the default value if the option is
not set.
raw (bool): If True, return the raw value without type conversion.
cfg (configparser.ConfigParser): The configuration parser instance.
Returns:
Any: The value of the option, converted to the appropriate type if
necessary, or the default value if the option is not set and
fallback is True.
"""
if name == "profile.name.expanded" and is_ccxx_testchart():
name = "measurement.name.expanded"
value = None
has_default = name in DEFAULTS
defval = DEFAULTS.get(name)
value = get_config_value(name, raw, cfg)
if value is None:
if has_default and fallback:
value = defval
if defval is not None:
debug_print(name, "- falling back to", value)
elif DEBUG and not has_default:
print("Warning - unknown option:", name)
if raw:
return value
if (
value
and isinstance(value, str)
and name.endswith("file")
and name != "colorimeter_correction_matrix_file"
and (name != "testchart.file" or value != "auto")
and (not os.path.isabs(value) or not os.path.exists(value))
):
value = get_corrected_colorimeter_path(name, value)
elif name in ("displays", "instruments"):
if not value:
return []
value = [
strtr(
v,
[
(f"%{hex(ord(os.pathsep))[2:].upper()}", os.pathsep),
("%25", "%"),
],
)
for v in value.split(os.pathsep)
]
return value
def get_config_value(
name: str,
raw: bool,
cfg: configparser.ConfigParser,
) -> Any: # noqa: ANN401
"""Helper function to get the configuration value.
Args:
name (str): The name of the configuration option.
raw (bool): If True, return the raw value without type conversion.
cfg (configparser.ConfigParser): The configuration parser instance.
defval: The default value for the option.
deftype: The type of the default value.
Returns:
Any: The value of the configuration option, or None if not found.
"""
if not cfg.has_option(configparser.DEFAULTSECT, name):
return None
try:
value = cfg.get(configparser.DEFAULTSECT, name)
except UnicodeDecodeError:
pass
else:
if not raw:
value = validate_value_type(name, value)
return value
def get_corrected_colorimeter_path(
name: str = "colorimeter_correction_matrix_file",
value: str | None = None,
) -> str:
"""Get the corrected path for a colorimeter correction matrix file.
This function checks if the provided path exists and normalizes it.
If the path does not exist, it attempts to find a fallback path based on
the application's data directories or returns a default value if specified.
Args:
name (str): The name of the configuration option.
value (str | None): The path to check. If None, the function will not
attempt to normalize or check the path.
Returns:
str: The corrected path if it exists, or a default value if specified.
"""
has_default = name in DEFAULTS
defval = DEFAULTS.get(name)
# colorimeter_correction_matrix_file is special
# because it's not (only) a path
debug_print(f"{name} does not exist: {value}", end=" ")
# Normalize path (important, this turns altsep into sep under Windows)
value = os.path.normpath(value)
# Check if this is a relative path covered by data_dirs
splits = value.split(os.path.sep)
if (splits[-3:-2] == [APPNAME] or not os.path.isabs(value)) and (
splits[-2:-1] == ["presets"]
or splits[-2:-1] == ["ref"]
or splits[-2:-1] == ["ti1"]
):
value = os.path.join(*splits[-2:])
value = get_data_path(value)
elif has_default:
value = None
if not value and has_default:
value = defval
if DEBUG > 1:
print(name, "- falling back to", value)
return value
def hascfg(
name: str,
fallback: bool = True,
cfg: configparser.ConfigParser = CFG,
) -> bool:
"""Check if an option name exists in the configuration.
Returns a boolean value.
If fallback evaluates to True and the name does not exist, check defaults
also.
Args:
name (str): The name of the configuration option.
fallback (bool, optional): If True, check the DEFAULTS dictionary if
the option is not found in the configuration. Defaults to True.
cfg (configparser.ConfigParser, optional): The configuration object to
check. Defaults to CFG.
Returns:
bool: True if the option exists in the configuration, False otherwise.
"""
if cfg.has_option(configparser.DEFAULTSECT, name):
return True
if fallback:
return name in DEFAULTS
return False
def get_ccxx_testchart() -> str:
"""Get the path to the default chart for CCMX/CCSS creation.
Returns:
str: The path to the default test chart file.
"""
return get_data_path(
os.path.join("ti1", DEFAULTS["colorimeter_correction.testchart"])
)
def get_current_profile(include_display_profile: bool = False) -> None | ICCProfile:
"""Get the currently selected profile (if any).
Args:
include_display_profile (bool, optional): If True, also return the display
profile if no calibration file is set. Defaults to False.
Returns:
None | ICCProfile: The ICC profile if available, otherwise None.
"""
path = getcfg("calibration.file", False)
if path:
from DisplayCAL.icc_profile import ICCProfile, ICCProfileInvalidError
try:
profile = ICCProfile(path, use_cache=True)
except (OSError, ICCProfileInvalidError):
return None
return profile
if include_display_profile:
return get_display_profile()
return None
def get_display_profile(display_no: None | int = None) -> None | ICCProfile:
"""Get the display profile for the specified display number.
Args:
display_no (int, optional): The display number. If None, use the
configured display number. Defaults to None.
Returns:
None | ICCProfile: The display profile if available, otherwise None.
"""
if display_no is None:
display_no = max(getcfg("display.number") - 1, 0)
if is_virtual_display(display_no):
return None
from DisplayCAL.icc_profile import get_display_profile
try:
return get_display_profile(display_no)
except Exception:
from DisplayCAL.log import LOG
print(f"DisplayCAL.icc_profile.get_display_profile({display_no}):", file=LOG)
STANDARD_PROFILES = []
def get_standard_profiles(paths_only: bool = False) -> list:
"""Get a list of standard ICC profiles.
Args:
paths_only (bool, optional): If True, return only the file paths of the
profiles. Defaults to False.
Returns:
list: A list of standard ICC profiles or their file paths.
"""
if not STANDARD_PROFILES:
from DisplayCAL.icc_profile import ICCProfile
# Reference profiles (Argyll + DisplayCAL)
ref_icc = get_data_path("ref", r"\.ic[cm]$") or []
# Other profiles installed on the system
other_icc = []
regex = re.compile(r"\.ic[cm]$", re.IGNORECASE)
for icc_dir in set(ICCPROFILES + ICCPROFILES_HOME):
for dirpath, _dirnames, basenames in os.walk(icc_dir):
for basename in filter(regex.search, basenames):
filename, ext = os.path.splitext(basename.lower())
if (
filename.endswith(("_bas", "_eci", "adobergb1998"))
or filename.startswith(
(
"eci-rgb",
"ecirgb",
"ekta space",
"ektaspace",
"fogra",
"gracol",
"iso",
"lstar-",
"pso",
"prophoto",
"psr_",
"psrgravure",
"snap",
"srgb",
"swop",
)
)
or filename
in (
"applergb",
"bestrgb",
"betargb",
"brucergb",
"ciergb",
"cie-rgb",
"colormatchrgb",
"donrgb",
"widegamutrgb",
)
):
other_icc.append(os.path.join(dirpath, basename))
# Ensure ref_icc is a list
ref_icc = ref_icc if isinstance(ref_icc, list) else [ref_icc]
for path in ref_icc + other_icc:
try:
profile = ICCProfile(path, load=False, use_cache=True)
except OSError:
pass
except Exception as exception:
print(exception)
else:
if (
profile.version < 4
and profile.profileClass != b"nmcl"
and profile.colorSpace != b"GRAY"
and profile.connectionColorSpace in (b"Lab", b"XYZ")
):
STANDARD_PROFILES.append(profile)
if paths_only:
return [profile.filename for profile in STANDARD_PROFILES]
return STANDARD_PROFILES
def get_total_patches(
white_patches: None | int = None,
black_patches: None | int = None,
single_channel_patches: None | int = None,
gray_patches: None | int = None,
multi_steps: None | int = None,
multi_bcc_steps: None | int = None,
fullspread_patches: None | int = None,
) -> int:
"""Calculate the total number of patches in a test chart.
Args:
white_patches (int, optional): Number of white patches. Defaults to None.
black_patches (int, optional): Number of black patches. Defaults to None.
single_channel_patches (int, optional): Number of single channel patches.
Defaults to None.
gray_patches (int, optional): Number of gray patches. Defaults to None.
multi_steps (int, optional): Number of multi steps. Defaults to None.
multi_bcc_steps (int, optional): Number of multi BCC steps. Defaults to
None.
fullspread_patches (int, optional): Number of full spread patches.
Defaults to None.
Returns:
int: Total number of patches.
"""
white_patches = (
getcfg("tc_white_patches") if white_patches is None else white_patches
)
black_patches = (
getcfg("tc_black_patches")
if (black_patches is None and getcfg("argyll.version") >= "1.6")
else black_patches
)
single_channel_patches = (
getcfg("tc_single_channel_patches")
if single_channel_patches is None
else single_channel_patches
)
single_channel_patches_total = single_channel_patches * 3
gray_patches = getcfg("tc_gray_patches") if gray_patches is None else gray_patches
gray_patches = (
2
if (gray_patches == 0 and single_channel_patches > 0 and white_patches > 0)
else gray_patches
)
multi_steps = getcfg("tc_multi_steps") if multi_steps is None else multi_steps
multi_bcc_steps = (
getcfg("tc_multi_bcc_steps")
if (multi_bcc_steps is None and getcfg("argyll.version") >= "1.6")
else multi_bcc_steps
)
fullspread_patches = (
getcfg("tc_fullspread_patches")
if fullspread_patches is None
else fullspread_patches
)
total_patches = 0
if multi_steps > 1:
(
gray_patches,
white_patches,
single_channel_patches_total,
total_patches,
) = adjust_gray_patches_count(
single_channel_patches,
single_channel_patches_total,
gray_patches,
white_patches,
total_patches,
multi_steps,
multi_bcc_steps,
)
elif gray_patches > 1:
white_patches -= 1 # white always in gray patches
single_channel_patches_total -= 3 # black always in gray patches
elif single_channel_patches_total:
# black always only once in single channel patches
single_channel_patches_total -= 2
total_patches += (
max(0, white_patches)
+ max(0, single_channel_patches_total)
+ max(0, gray_patches)
+ fullspread_patches
)
if black_patches:
if gray_patches > 1 or single_channel_patches_total or multi_steps:
black_patches -= 1 # black always in other patches
total_patches += black_patches
return total_patches
def adjust_gray_patches_count(
single_channel_patches: int,
single_channel_patches_total: int,
gray_patches: int,
white_patches: int,
total_patches: int,
multi_steps: int,
multi_bcc_steps: int,
) -> tuple[int, int]:
"""Adjust gray patches count based on multi steps and single channel patches.
Args:
single_channel_patches (int): Number of single channel patches.
single_channel_patches_total (int): Total number of single channel
patches.
white_patches (int): Number of white patches.
gray_patches (int): Number of gray patches.
total_patches (int): Total number of patches.
multi_steps (int): Number of multi steps.
multi_bcc_steps (int): Number of multi BCC steps.
Returns:
tupel[int, int, int, int]: A tuple containing the adjusted number of
gray patches, the white patches, the total number of single channel
patches and the total number of patches.
"""
multi_patches = int(math.pow(multi_steps, 3))
if multi_bcc_steps > 1:
multi_patches += int(math.pow(multi_bcc_steps - 1, 3))
total_patches += multi_patches
white_patches -= 1 # white always in multi channel patches
multi_step = 255.0 / (multi_steps - 1)
multi_values = []
multi_bcc_values = []
if multi_bcc_steps > 1:
multi_bcc_step = multi_step
multi_values.extend(str(multi_bcc_step * i) for i in range(multi_bcc_steps))
multi_bcc_values.extend(
str(multi_bcc_step / 2.0 * i) for i in range(multi_bcc_steps * 2 - 1)
)
else:
multi_values.extend(str(multi_step * i) for i in range(multi_steps))
if single_channel_patches > 1:
single_channel_step = 255.0 / (single_channel_patches - 1)
for i in range(single_channel_patches):
if str(single_channel_step * i) in multi_values:
single_channel_patches_total -= 3
if gray_patches > 1:
gray_step = 255.0 / (gray_patches - 1)
for i in range(gray_patches):
if (
str(gray_step * i) in multi_values
or str(gray_step * i) in multi_bcc_values
):
gray_patches -= 1
return (
gray_patches,
white_patches,
single_channel_patches_total,
total_patches,
)
def get_verified_path(cfg_item_name: str, path: None | str = None) -> tuple[str, str]:
"""Verify and return directory and filename for a user cfg path or given path.
Args:
cfg_item_name (str): Config item name to retrieve the path.
path (str, optional): Path to verify. Defaults to None.
Returns:
tuple[str, str]: A tuple containing the directory and filename.
"""
default_path = path or getcfg(cfg_item_name)
default_dir = expanduseru("~")
default_file = ""
if default_path:
if os.path.exists(default_path):
default_dir, default_file = (
os.path.dirname(default_path),
os.path.basename(default_path),
)
elif DEFAULTS.get(cfg_item_name) and os.path.exists(DEFAULTS[cfg_item_name]):
default_dir, default_file = (
os.path.dirname(DEFAULTS[cfg_item_name]),
os.path.basename(DEFAULTS[cfg_item_name]),
)
elif os.path.exists(os.path.dirname(default_path)):
default_dir = os.path.dirname(default_path)
return default_dir, default_file
def is_ccxx_testchart(testchart: None | str = None) -> bool:
"""Check whether the testchart is the default chart for CCMX/CCSS creation.
Args:
testchart (None | str): The testchart to check.
If not provided, the default testchart will be used.
Returns:
bool: True if the testchart is the default chart for CCMX/CCSS creation,
False otherwise.
"""
testchart = testchart or getcfg("testchart.file")
return testchart == get_ccxx_testchart()
def is_profile(
filename: None | str = None, include_display_profile: bool = False
) -> bool:
"""Check if the given filename is a valid ICC profile.
Args:
filename (None | str): The filename to check.
If not provided, the default calibration file will be used.
include_display_profile (bool): Whether to include the display profile
in the check. Defaults to False.
Returns:
bool: True if the filename is a valid ICC profile,
False otherwise.
"""
filename = filename or getcfg("calibration.file", False)
if filename:
if os.path.exists(filename):
from DisplayCAL.icc_profile import ICCProfile, ICCProfileInvalidError
try:
ICCProfile(filename, use_cache=True)
except (OSError, ICCProfileInvalidError):
pass
else:
return True
elif include_display_profile:
return bool(get_display_profile())
return False
def makecfgdir(which: None | str = None, worker: None | Worker = None) -> bool:
"""Create the configuration directory.
Args:
which (None | str): The type of configuration directory to create.
Can be "user" or "system". Defaults to "user".
worker (None | Worker): The worker instance to use for executing
commands. Defaults to None.
Returns:
bool: True if the configuration directory was created successfully,
False otherwise.
"""
if which is None:
which = "user"
if which == "user":
if not os.path.exists(CONFIG_HOME):
try:
os.makedirs(CONFIG_HOME)
except Exception as exception:
print(
"Warning - could not create configuration directory "
f"'{CONFIG_HOME}': {exception}"
)
return False
elif not os.path.exists(CONFIG_SYS):
try:
if sys.platform == "win32":
os.makedirs(CONFIG_SYS)
else:
result = worker.exec_cmd(
"mkdir",
["-p", CONFIG_SYS],
capture_output=True,
low_contrast=False,
skip_scripts=True,
silent=True,
asroot=True,
)
if isinstance(result, Exception):
raise result
except Exception as exception:
print(
"Warning - could not create configuration directory "
f"'{CONFIG_SYS}': {exception}"
)
return False
return True
CFGINITED = {}
# A legitimate config file is a few KB at most. Anything past this is
# treated as corrupted rather than risking an out-of-memory parse (issue
# #828).
MAX_CFG_FILE_SIZE = 10 * 1024 * 1024
def initcfg(
module: None | str = None,
cfg: configparser.ConfigParser = CFG,
force_load: bool = False,
) -> None:
"""Initialize the configuration.
Read in settings if the configuration file exists, else create the
settings directory if nonexistent.
Args:
module (None | str): The module name to use for the configuration.
If None, use the default application name.
Defaults to None.
cfg (configparser.ConfigParser): The configuration parser instance.
Defaults to the global CFG instance.
force_load (bool): If True, force reloading the configuration files.
Defaults to False.
"""
cfgbasename = f"{APPBASENAME}-{module}" if module else APPBASENAME
makecfgdir()
cfg_full_path = os.path.join(CONFIG_HOME, f"{cfgbasename}.ini")
if os.path.exists(CONFIG_HOME) and not os.path.exists(cfg_full_path):
if not cfg.has_section(configparser.DEFAULTSECT):
# No Default section, add it...
cfg.add_section(configparser.DEFAULTSECT)
# Set default preset
setcfg("calibration.file", DEFAULTS["calibration.file"], cfg=cfg)
# Read cfg
cfgnames = (
[APPBASENAME, cfgbasename]
if module
else [APPBASENAME, f"{APPBASENAME}-testchart-editor"]
)
cfgroots = (
[CONFIG_HOME] if module == "apply-profiles" else [CONFIG_HOME, CONFIG_SYS]
)
cfgfiles = fetch_config_files(cfgnames, cfgroots, force_load)
if not cfgfiles:
return
if not module:
# Make most recent file take precedence
cfgfiles.sort(key=lambda cfgfile: CFGINITED.get(cfgfile))
try:
# writecfg() always writes UTF-8 (str.encode() defaults to it
# regardless of locale). Without an explicit encoding here, read()
# falls back to the OS locale's preferred encoding, which on
# Windows without the "Beta: UTF-8" system-locale option is the
# legacy ANSI codepage (e.g. cp1252). That mismatch mis-decodes
# any non-ASCII option value on every read, and since writecfg()
# then re-encodes the already-garbled string as UTF-8, the mojibake
# compounds on every read/write cycle (issue #828).
cfg.read(cfgfiles, encoding="utf-8")
# This won't raise an exception if the file does not exist,
# only if it can't be parsed
except Exception:
print(
"Warning - could not parse configuration files:\n{}".format(
"\n".join(cfgfiles)
)
)
# Fix Python 2.7 ConfigParser option values being lists instead of
# strings in case of a ParsingError. http://bugs.python.org/issue24142
all_sections = [configparser.DEFAULTSECT]
all_sections.extend(cfg.sections())
for section in all_sections:
for name, val in cfg.items(section):
if isinstance(val, list):
cfg.set(section, name, "\n".join(val))
finally:
if not module:
if getcfg("lang", fallback=False, cfg=cfg) is None:
setcfg("lang", DEFAULTS["lang"], cfg=cfg)
if getcfg("calibration.ambient_viewcond_adjust", fallback=False, cfg=cfg) is None:
setcfg(
"calibration.ambient_viewcond_adjust",
DEFAULTS["calibration.ambient_viewcond_adjust"],
cfg=cfg,
)
if not getcfg("calibration.ambient_viewcond_adjust", cfg=cfg):
# Reset to default
setcfg("calibration.ambient_viewcond_adjust.lux", None, cfg=cfg)
if getcfg("profile.save_path", fallback=False, cfg=cfg) is None:
setcfg("profile.save_path", STORAGE, cfg=cfg)
def fetch_config_files(
cfgnames: list[str],
cfgroots: list[str],
force_load: bool = False,
) -> list[str]:
"""Fetch configuration files based on the provided names and roots.
Args:
cfgnames (list): List of configuration names to look for.
cfgroots (list): List of directories to search for configuration files.
force_load (bool): Whether to force reloading the configuration files.
Returns:
list[str]: A list of configuration file paths that were found and
successfully loaded.
"""
cfgfiles = []
for cfgname in cfgnames:
for cfgroot in cfgroots:
cfgfile = os.path.join(cfgroot, f"{cfgname}.ini")
if not os.path.isfile(cfgfile):
continue
try:
stat = os.stat(cfgfile)
mtime = stat.st_mtime
except OSError as exception:
print(f"Warning - os.stat('{cfgfile}') failed: {exception}")
break
if stat.st_size > MAX_CFG_FILE_SIZE:
# A config file this large can only be the result of
# corruption -- some option value grew unbounded, e.g. by
# repeated appends of mis-decoded text (issue #828).
# Parsing it would blow up memory and likely crash, so
# quarantine it instead of loading it.
quarantined = f"{cfgfile}.corrupt-{int(time.time())}"
print(
f"Warning - '{cfgfile}' is {stat.st_size} bytes, "
f"which looks corrupted. Moving it to '{quarantined}' "
"and falling back to defaults."
)
with contextlib.suppress(OSError):
os.replace(cfgfile, quarantined)
break
last_checked = CFGINITED.get(cfgfile)
if force_load or mtime != last_checked:
CFGINITED[cfgfile] = mtime
cfgfiles.append(cfgfile)
msg = (
"Force loading"
if force_load
else "Reloading"
if last_checked
else "Loading"
)
print(msg, cfgfile)
# Make user config take precedence
break
return cfgfiles
def validate_value_type(
name: str,
value: Any, # noqa: ANN401
) -> Any: # noqa: ANN401
"""Check for invalid types and return default if wrong type.
Args:
name (str): The name of the configuration option.
value (Any): The value of the configuration option.
Returns:
Any: The value of the configuration option, or the default value if the
option is not set or has an invalid type.
"""
if (name != "trc" or value not in VALID_VALUES["trc"]) and isinstance(
DEFAULTS.get(name), (int, float, Decimal)
):
value = validate_numeric_value(name, value)
elif name.startswith("dimensions.measureframe"):
value = validate_measureframe_dimensions_value(name, value)
elif name == "profile.quality" and getcfg("profile.type") in ("g", "G"):
# default to high quality for gamma + matrix
value = "h"
elif name == "trc.type" and getcfg("trc") in VALID_VALUES["trc"]:
value = "g"
elif name in VALID_VALUES and value not in VALID_VALUES[name]:
debug_print(f"Invalid config value for {name}: {value}", end=" ")
value = None
elif name == "copyright":
value = validate_copyright_value(name, value)
elif name == "measurement_mode":
value = validate_measurement_mode_value(name, value)
return value
def validate_numeric_value(
name: str,
value: int | float | Decimal, # noqa: PYI041
) -> int | float | Decimal:
"""Validate a numeric value against its default and valid ranges.
Args:
name (str): The name of the configuration option.
value (int | float | Decimal): The numeric value to validate.
Returns:
int | float | Decimal: The validated value, or the default value if
validation fails.
"""
defval = DEFAULTS.get(name)
deftype = type(defval)
try:
value = deftype(value)
except (ValueError, TypeError):
value = defval
else:
valid_range = VALID_RANGES.get(name)
if valid_range:
value = min(max(valid_range[0], value), valid_range[1])
elif name in VALID_VALUES and value not in VALID_VALUES[name]:
value = defval
return value
def validate_measureframe_dimensions_value(name: str, value: str) -> str:
"""Validate the measure frame dimensions value.
Args:
name (str): The name of the configuration option.
value (str): The value of the configuration option.
Returns:
str: The validated measure frame dimensions value.
"""
try:
value = [max(0, float(n)) for n in value.split(",")]
if len(value) != 3:
raise ValueError
except ValueError:
value = DEFAULTS[name]
else:
value[0] = min(value[0], 1)
value[1] = min(value[1], 1)
value[2] = min(value[2], 50)
value = ",".join([str(n) for n in value])
return value
def validate_copyright_value(name: str, value: str) -> str:
"""Validate the copyright value.
Args:
name (str): The name of the configuration option.
value (str): The value of the configuration option.
Returns:
str: The validated copyright value.
"""
if name != "copyright":
return value
# Make sure DisplayCAL and Argyll version are up-to-date
defval = DEFAULTS.get(name)
pattern = re.compile(rf"({APPNAME}(?:\s*v(?:ersion|\.)?)?\s*)\d+(?:\.\d+)*", re.I)
repl = create_replace_function("\\1%s", VERSION_STRING)
value = re.sub(pattern, repl, value)
if APPBASENAME != APPNAME:
pattern = re.compile(
rf"({APPBASENAME}(?:\s*v(?:ersion|\.)?)?\s*)\d+(?:\.\d+)*",
re.I,
)
repl = create_replace_function("\\1%s", VERSION_STRING)
value = re.sub(pattern, repl, value)
pattern = re.compile(
r"(Argyll(?:\s*CMS)?)((?:\s*v(?:ersion|\.)?)?\s*)\d+(?:\.\d+)*",
re.I,
)
repl = (
create_replace_function("\\1\\2%s", defval.split()[-1])
if defval.split()[-1] != "CMS"
else "\\1"
)
return re.sub(pattern, repl, value)
def validate_measurement_mode_value(name: str, value: str) -> str:
"""Validate the measurement mode value.
Args:
name (str): The name of the configuration option.
value (str): The value of the configuration option.
Returns:
str: The validated measurement mode value.
"""
if name == "measurement_mode":
# Map n and r measurement modes to canonical l and c
# the inverse mapping happens per-instrument in
# Worker.add_measurement_features().
# That way we can have compatibility with old and current
# Argyll CMS
value = {"n": "l", "r": "c"}.get(value, value)
return value
def set_default_app_dpi() -> None:
"""Set application DPI."""
# Only call this after creating the wx.App object!
global DPISET
if DPISET or getcfg("app.dpi", False):
DPISET = True
return
# HighDPI support
from DisplayCAL.wx_addons import wx
DPISET = True
if sys.platform in ("darwin", "win32"):
# Determine screen DPI
dpi = wx.ScreenDC().GetPPI()[0]
else:
# Linux
from DisplayCAL.util_os import which
txt_scale = None
# XDG_CURRENT_DESKTOP delimiter is colon (':')
desktop = os.getenv("XDG_CURRENT_DESKTOP", "").split(":")
if "gtk2" in wx.PlatformInfo:
txt_scale = get_hidpi_scaling_factor()
elif desktop[0] == "KDE":
pass
# Nothing to do
elif which("gsettings"):
import subprocess as sp
p = sp.Popen(
[ # noqa: S607
"gsettings",
"get",
"org.gnome.desktop.interface",
"text-scaling-factor",
],
stdin=sp.PIPE,
stdout=sp.PIPE,
stderr=sp.PIPE,
)
factor, stderr = p.communicate()
with contextlib.suppress(ValueError):
txt_scale = float(factor)
dpi = get_default_dpi()
if txt_scale:
dpi = round(dpi * txt_scale)
DEFAULTS["app.dpi"] = dpi
DPISET = True
def get_hidpi_scaling_factor() -> float:
"""Get the scaling factor for high DPI displays.
Returns:
float: The scaling factor for high DPI displays.
"""
if sys.platform in ("darwin", "win32"):
return 1.0 # Handled via app DPI
# Linux
from DisplayCAL.util_os import which
dpi = get_hidpi_scaling_factor_from_xrdb()
if dpi is not None:
return dpi
factor = None
# XDG_CURRENT_DESKTOP delimiter is colon (':')
desktop = os.getenv("XDG_CURRENT_DESKTOP", "").split(":")
if desktop[0] == "KDE":
factor = get_hidpi_scaling_factor_from_kde()
if not factor and which("gsettings"):
factor = get_hidpi_scaling_factor_from_gnome()
if factor is not None:
try:
factor = float(factor)
except ValueError:
factor = None
return factor
def get_hidpi_scaling_factor_from_xrdb() -> float:
"""Get the scaling factor for high DPI displays from xrdb.
Returns:
float: The scaling factor for high DPI displays.
"""
from DisplayCAL.util_os import which
if not which("xrdb"):
return None
import subprocess as sp
p = sp.Popen(
["xrdb", "-query"], # noqa: S607
stdin=sp.PIPE,
stdout=sp.PIPE,
stderr=sp.PIPE,
)
# Format: 'Xft.dpi: 192'
stdout, _ = p.communicate()
for line in stdout.splitlines():
line = line.decode()
if line.startswith("Xft.dpi:"):
split = line.split()
dpi = split[-1]
try:
return float(dpi) / get_default_dpi()
except ValueError:
pass
return None
def get_hidpi_scaling_factor_from_kde() -> None | str:
"""Get the scaling factor for high DPI displays from KDE settings.
Returns:
None | str: The scaling factor for high DPI displays as a string if
found, otherwise None.
"""
# Two env-vars exist: QT_SCALE_FACTOR and QT_SCREEN_SCALE_FACTORS.
# According to documentation[1], the latter is 'mainly useful for debugging'
# that's not how it is used by KDE though.
# Changing display scaling via KDE settings GUI only sets
# QT_SCREEN_SCALE_FACTORS. We are thus currently ignoring QT_SCALE_FACTOR.
# [1] https://doc.qt.io/qt-5/highdpi.html
# QT_SCREEN_SCALE_FACTORS delimiter is semicolon (';')
# Format: Mapping of XrandR display names to scale factor
# e.g. 'VGA-1=1.5;VGA-2=2.0;'
# or just list of scale factors e.g. '1.5;2.0;'
screen_scale_factors = os.getenv("QT_SCREEN_SCALE_FACTORS", "").split(";")
if not screen_scale_factors:
return None
from DisplayCAL.wx_addons import wx
factor = None
match = False
app = wx.GetApp()
if not app:
# Use first one
return screen_scale_factors[0].split("=")[-1]
from DisplayCAL import real_display_size_mm
if not real_display_size_mm._displays:
real_display_size_mm.enumerate_displays()
top = app.TopWindow
if top:
tmp = False
else:
# Create temp frame if no topwindow
top = wx.Frame(None)
# Move to main window location (and thus screen)
x, y = (
getcfg("position.x", False),
getcfg("position.y", False),
)
if None not in (x, y):
top.SetSaneGeometry(x, y)
tmp = True
# Get wx display
wx_display = top.GetDisplay()
if tmp:
# No longer need our temp frame
top.Destroy()
# Search for matching display based on geometry
pos = wx_display.Geometry[:2]
size = wx_display.Geometry[2:]
for item in screen_scale_factors:
if not item:
break
name, factor = item.split("=", 1) if "=" in item else (None, item)
for display in real_display_size_mm._displays:
if (display.get("pos") != pos or display.get("size") != size) or (
name and display.get("xrandr_name") != name
):
# No match
continue
# Match found
match = True
break
if match:
break
# Use first one
return screen_scale_factors[0].split("=")[-1] if not match else factor
def get_hidpi_scaling_factor_from_gnome() -> None | str:
"""Get the scaling factor for high DPI displays from gsettings.
Returns:
None | str: The scaling factor for high DPI displays as a string.
"""
# GNOME
import subprocess as sp
factor = None
p = sp.Popen(
["gsettings", "get", "org.gnome.desktop.interface", "scaling-factor"], # noqa: S607
stdin=sp.PIPE,
stdout=sp.PIPE,
stderr=sp.PIPE,
)
# Format: 'unint32 1'
stdout, _ = p.communicate()
split = stdout.split()
if split:
factor = split[-1]
return factor
def setcfg(name: str, value: Any, cfg: configparser.ConfigParser = CFG) -> None: # noqa: ANN401
"""Set an option value in the configuration.
Args:
name (str): Configuration option name.
value (Any): Value to set for the configuration option.
cfg (configparser.ConfigParser): Configuration instance.
"""
if value is None:
cfg.remove_option(configparser.DEFAULTSECT, name)
else:
if name in ("displays", "instruments") and isinstance(value, (list, tuple)):
value = os.pathsep.join(
strtr(
v,
[
("%", "%25"),
(os.pathsep, f"%{hex(ord(os.pathsep))[2:].upper()}"),
],
)
for v in value
)
cfg.set(configparser.DEFAULTSECT, name, value)
def setcfg_cond(
condition: bool,
name: str,
value: Any, # noqa: ANN401
set_if_backup_exists: bool = False,
restore: bool = True,
) -> bool:
"""Set configuration conditionally.
If , backup configuration option if not yet backed up
and set option to if backup did not previously exist or
set_if_backup_exists evaluates to True.
If not and backed up option , restore option to
backed up value and discard backup if evaluates to True
Return whether or not configuration was changed
Args:
condition (bool): Condition to check.
name (str): Configuration option name.
value (Any): Value to set if condition is True.
set_if_backup_exists (bool): If True, set the value even if a backup exists
and the condition is True.
restore (bool): If True, restore the value from the backup if the condition
is False and a backup exists.
Returns:
bool: True if the configuration was changed, False otherwise.
"""
changed = False
backup = getcfg(f"{name}.backup", False)
if condition:
if backup is None:
setcfg(f"{name}.backup", getcfg(name))
if backup is None or set_if_backup_exists:
setcfg(name, value)
changed = True
elif backup is not None and restore:
setcfg(name, getcfg(f"{name}.backup"))
setcfg(f"{name}.backup", None)
changed = True
return changed
def writecfg(
which: str = "user",
worker: None | Worker = None,
module: None | str = None,
options: tuple[str] = (),
cfg: configparser.ConfigParser = CFG,
) -> bool:
"""Write configuration file.
Args:
which (str): 'user' or 'system'
worker (DisplayCAL.worker.Worker): worker instance if ``which == 'system'``
module (None | str): module name.
options (tuple[str]): options to write.
cfg (configparser.ConfigParser): configuration instance.
Returns:
bool: True if successful, False otherwise.
"""
cfgbasename = f"{APPBASENAME}-{module}" if module else APPBASENAME
# Remove unknown options
for name, _val in cfg.items(configparser.DEFAULTSECT):
if name not in DEFAULTS:
print("Removing unknown option:", name)
setcfg(name, None)
if which == "user":
# user config - stores everything and overrides system-wide config
cfgfilename = os.path.join(CONFIG_HOME, f"{cfgbasename}.ini")
lockfilename = cfgfilename + ".lock"
try:
io = StringIO()
cfg.write(io)
io.seek(0)
lines = io.read().strip("\n").split("\n")
if options:
optionlines = [
optionline
for optionline in lines[1:]
for option in options
if optionline.startswith(option)
]
else:
optionlines = lines[1:]
# Sorting works as long as config has only one section
lines = lines[:1] + sorted(optionlines)
data = (os.linesep.join(lines) + os.linesep).encode()
# Take an exclusive lock and write to a temp file, then
# atomically replace the real config file. Without this, two
# processes writing the config at the same time (e.g. the
# profile loader and the main app running concurrently) could
# interleave their writes and corrupt the file.
with open(lockfilename, "a+b") as lockfile:
with FileLock(lockfile, exclusive=True, blocking=True):
fd, tmpfilename = tempfile.mkstemp(
dir=CONFIG_HOME, prefix=f"{cfgbasename}.", suffix=".tmp"
)
with os.fdopen(fd, "wb") as cfgfile:
cfgfile.write(data)
os.replace(tmpfilename, cfgfilename)
except Exception as exception:
print(
"Warning - could not write user configuration file "
f"'{cfgfilename}': {exception}"
)
return False
else:
# system-wide config - only stores essentials ie. Argyll directory
cfgfilename1 = os.path.join(CONFIG_HOME, f"{cfgbasename}.local.ini")
cfgfilename2 = os.path.join(CONFIG_SYS, f"{cfgbasename}.ini")
if sys.platform == "win32":
cfgfilename = cfgfilename2
else:
cfgfilename = cfgfilename1
try:
if getcfg("argyll.dir"):
with open(cfgfilename, "wb") as cfgfile:
cfgfile.write(
(
"{}{}".format(
os.linesep.join(
[
"[Default]",
f"argyll.dir = {getcfg('argyll.dir')}",
]
),
os.linesep,
)
).encode()
)
if sys.platform != "win32":
# on Linux and OS X, we write the file to the user's config dir
# then 'su mv' it to the system-wide config dir
result = worker.exec_cmd(
"mv",
["-f", cfgfilename1, cfgfilename2],
capture_output=True,
low_contrast=False,
skip_scripts=True,
silent=True,
asroot=True,
)
if isinstance(result, Exception):
raise result
except Exception as exception:
print(
"Warning - could not write system-wide configuration file "
f"'{cfgfilename2}': {exception}"
)
return False
return True
_init_testcharts()
RUNTYPE = runtimeconfig(PYFILE)
if sys.platform in ("darwin", "win32") and not os.getenv("SSL_CERT_FILE"):
try:
import certifi
except ImportError:
CAFILE = None
else:
CAFILE = certifi.where()
if CAFILE and not os.path.isfile(CAFILE):
CAFILE = None
if not CAFILE:
# Use our bundled CA file
CAFILE = get_data_path("cacert.pem")
if CAFILE and isinstance(CAFILE, str):
os.environ["SSL_CERT_FILE"] = CAFILE
displaycal-py3-3.9.19/DisplayCAL/cubeiterator.py 000664 000000 000000 00000015643 15225167330 021437 0 ustar 00root root 000000 000000 """Classes for working with and iterating over 3D data cubes.
It includes functionality to define a cube, access its elements, and iterate
through its contents.
"""
from __future__ import annotations
import sys
from typing import TYPE_CHECKING
if TYPE_CHECKING:
if sys.version_info >= (3, 11):
from typing import Self
else:
from typing_extensions import Self
class Cube3D:
"""A 3D cube of data.
This class provides functionality to define a cube, access its elements,
and iterate through its contents. It allows for specifying the size of the
cube and the range of indices to be used.
Args:
size (int): The size of the cube along each dimension. Default is 65.
start (int): The starting index for the cube. Default is 0.
end (None | int, optional): The ending index for the cube. If not
specified, it defaults to the total number of entries in the cube,
which is `size**3`. If specified, it must be greater than or equal
to `start`. Default is None.
Raises:
TypeError: If `start` or `end` is not an integer.
ValueError: If `start` or `end` is out of range or if `end` is less
than `start`.
"""
def __init__(self, size: int = 65, start: int = 0, end: None | int = None) -> None:
num_entries = size**3
if end is None:
end = num_entries
if not isinstance(start, int):
raise TypeError(
f"integer start argument expected, got {start.__class__.__name__}"
)
if not isinstance(end, int):
raise TypeError(
f"integer end argument expected, got {end.__class__.__name__}"
)
start = self._clamp(start, 0, num_entries, -1)
end = self._clamp(end, 0, num_entries, -1)
if start == -1:
raise ValueError(f"start argument {start:.0f} out of range")
if end == -1:
raise ValueError(f"end argument {end:.0f} out of range")
self._size = size
self._start = start
self._len = end - start
def get(
self, i: int, default: None | tuple[int, int, int] = None
) -> None | tuple[int, int, int]:
"""Return the item at the specified index or a default value.
Args:
i (int): The index of the item to return.
default (None, optional)): The value to return if the index is out
of range.
Returns:
None | tuple[int, int, int]: The item at the specified index or the
default value if the index is out of range.
"""
if i < 0:
i = self._len + i
if i < 0 or i > self._len - 1:
return default
return self[i]
def index(self, item: tuple[int, int, int]) -> int:
"""Return the index of the specified item in the cube.
Args:
item (tuple[int, int, int]): The item to find the index of.
Raises:
ValueError: If the item is not found in the cube.
Returns:
int: The index of the item in the cube.
"""
(c0, c1, c2) = item
if (c0, c1, c2) not in self:
raise ValueError(f"{(c0, c1, c2)!r} not in {self!r}")
i = c0 * self._size**2 + c1 * self._size + c2
return int(i) - self._start
def _clamp(
self,
v: int,
lower: int = 0,
upper: None | int = None,
fallback: None | int = None,
) -> int:
"""Clamp a value to a specified range.
Args:
v (int): The value to clamp.
lower (int): The lower bound of the range. Default is 0.
upper (None | int, optional): The upper bound of the range. If not
specified, it defaults to the length of the cube.
fallback (None | int, optional): A fallback value to use if `v` is
out of range. If not specified, it defaults to `lower` if `v`
is less than `lower`, or `upper` if `v` is greater than
`upper`.
Returns:
int: The clamped value.
"""
if not upper:
upper = self._len
if v < lower:
v = fallback or lower if v < -upper else upper + v
elif v > upper:
v = fallback or upper
return v
def __contains__(self, other: tuple[int, int, int]) -> bool:
"""Check if the cube contains the specified item.
Args:
other (tuple): The item to check.
Returns:
bool: True if the cube contains the item, False otherwise.
"""
(c0, c1, c2) = other
return (
c0 == int(c0)
and c1 == int(c1)
and c2 == int(c2)
and max(c0, c1, c2) < self._size
and self._start
<= c0 * self._size**2 + c1 * self._size + c2
< self._len + self._start
)
def __getitem__(self, i: int) -> tuple[int, int, int]:
"""Return the item at the specified index.
Args:
i (int): The index of the item to return.
Raises:
IndexError: If the index is out of range.
Returns:
tuple[int, int, int]: The item at the specified index.
"""
oi = i
if i < 0:
i = self._len + i
if i < 0 or i > self._len - 1:
raise IndexError(f"index {oi} out of range")
i += self._start
return (
i // self._size // self._size,
i // self._size % self._size,
i % self._size,
)
def __len__(self) -> int:
"""Return the length of the cube.
Returns:
int: The length of the cube.
"""
return self._len
def __repr__(self) -> str:
"""Return the string representation of the object.
Returns:
str: The string representation of the object.
"""
return "{}(size={:.0f}, start={:.0f}, end={:.0f})".format( # noqa: UP032
self.__class__.__name__,
self._size,
self._start,
self._start + self._len,
)
class Cube3DIterator(Cube3D):
"""An iterator for the Cube3D class.
This iterator is actually slightly slower especially with large cubes
than using iter().
"""
def __init__(self, *args, **kwargs) -> None:
Cube3D.__init__(self, *args, **kwargs)
self._next = 0
def __iter__(self) -> Self:
"""Return the object itself as an iterator."""
return self
def __next__(self) -> tuple[int, int, int]:
"""Return the next item in the iteration.
Raises:
StopIteration: If there are no more items to iterate over.
Returns:
tuple[int, int, int]: The next item in the iteration.
"""
if self._next == self._len:
raise StopIteration
result = self[self._next]
self._next += 1
return result
displaycal-py3-3.9.19/DisplayCAL/debughelpers.py 000664 000000 000000 00000015326 15225167330 021416 0 ustar 00root root 000000 000000 """Utility functions and exceptions for debugging and error handling in DisplayCAL.
It includes functionality for retrieving event object names and types, handling
errors with optional logging and user notifications, and printing call stacks
for debugging purposes.
"""
from __future__ import annotations
import traceback
from typing import TYPE_CHECKING
from DisplayCAL.meta import WX_RECVERSION
from DisplayCAL.options import DEBUG
from DisplayCAL.util_str import box
if TYPE_CHECKING:
from types import TracebackType
from DisplayCAL.wx_addons import wx # noqa: TC004
WX_EVENT_TYPES = {}
def getevtobjname(event: wx.Event, window: None | wx.Window = None) -> None | str:
"""Get and return the event object's name.
Args:
event (wx.Event): The event object to get the name from.
window (None | wx.Window, optional): Optional window to search for the
event object.
Returns:
None | str: The name of the event object, or None if it cannot be
determined.
"""
try:
event_object = event.GetEventObject()
if not event_object and window:
event_object = window.FindWindowById(event.GetId())
if event_object and hasattr(event_object, "GetName"):
return event_object.GetName()
except Exception:
pass
def getevttype(event: wx.Event) -> None | str:
"""Get and return the event object's type.
Args:
event: The event object to get the type from.
Returns:
None | str: The name of the event type, or None if it cannot be
determined.
"""
if not WX_EVENT_TYPES:
from DisplayCAL.wx_addons import wx
try:
for name in dir(wx):
if name.find("EVT_") == 0:
attr = getattr(wx, name)
if hasattr(attr, "evtType"):
WX_EVENT_TYPES[attr.evtType[0]] = name
except Exception:
pass
type_id = event.GetEventType()
if type_id in WX_EVENT_TYPES:
return WX_EVENT_TYPES[type_id]
return None
def handle_error(
error: tuple[type, str, TracebackType] | Exception,
parent: None | wx.Window = None,
silent: bool = False,
tb: bool = True,
) -> None:
"""Log an error string and show an error dialog.
Args:
error (tuple[type, str, TracebackType] | Exception): The error to handle,
which can be a tuple containing the exception type, value, and
traceback, or an Exception instance.
parent (None | wx.Window): The parent window for the error dialog.
silent (bool): If True, suppresses the dialog display.
tb (bool): If True, includes the traceback in the error message.
"""
traceback.print_exc()
msg = ""
if isinstance(error, tuple):
# We got a tuple. Assume (etype, value, tb)
tbstr = "".join(traceback.format_exception(*error))
error = error[1]
else:
tbstr = traceback.format_exc()
if (
tb
and tbstr.strip() != "None"
and isinstance(error, Exception)
and (
DEBUG
or not isinstance(error, OSError)
or not getattr(error, "filename", None)
)
):
# Print a traceback if in debug mode, for non OS errors,
# and for OS errors not related to files
errstr, tbstr = (str(v) for v in (error, tbstr))
msg = f"{errstr}\n\n{tbstr}"
if msg.startswith(errstr):
print(box(tbstr))
else:
print(box(msg))
else:
msg = str(error)
print(box(msg))
if silent:
return
try:
show_error_dialog(error, msg, parent)
except Exception as exception:
traceback.print_exc()
print("Warning: handle_error():", str(exception))
def show_error_dialog(
error: Exception,
msg: str,
parent: None | wx.Window = None,
) -> None:
"""Show an error dialog.
Args:
error (Exception): The error to display.
msg (str): The message to display in the dialog.
parent (None | wx.Window): The parent window for the dialog.
"""
from DisplayCAL.wx_addons import wx
if wx.VERSION < WX_RECVERSION: # noqa: SIM300
msg += (
"\n\nWARNING: Your version of wxPython ({}) is outdated "
"and no longer supported. You should consider updating "
"to wxPython {} or newer.".format(
wx.__version__, ".".join(str(n) for n in WX_RECVERSION)
)
)
app = wx.GetApp()
if app is None and parent is None:
app = wx.App(redirect=False)
# wxPython 3 bugfix: We also need a toplevel window
frame = wx.Frame(None)
parent = False
else:
frame = None
parent = wx.GetActiveWindow() if parent is None else parent
if parent:
try:
parent.IsShownOnScreen()
except Exception:
# If the parent is still being constructed, we can't use it
parent = None
icon = wx.ICON_INFORMATION
if not isinstance(error, Info):
if isinstance(error, Warning):
icon = wx.ICON_WARNING
elif isinstance(error, Exception):
icon = wx.ICON_ERROR
dlg = wx.MessageDialog(
(parent if parent not in (False, None) and parent.IsShownOnScreen() else None),
msg,
app.AppName,
wx.OK | icon,
)
if frame:
# wxPython 3 bugfix: We need to use CallLater and MainLoop
wx.CallLater(1, dlg.ShowModal)
wx.CallLater(1, frame.Close)
app.MainLoop()
else:
dlg.ShowModal()
dlg.Destroy()
def print_callstack() -> None:
"""Print call stack."""
import inspect
stack = inspect.stack()
indent = ""
for _frame, filename, linenum, funcname, line, _exc in reversed(stack[1:]):
print(indent, funcname, filename, linenum, repr("".join(line).strip()))
indent += " "
class ResourceError(Exception):
"""Error class for resource errors."""
class Error(Exception):
"""Error class for fatal errors."""
class Info(UserWarning):
"""Info class for non-fatal errors."""
class UnloggedError(Error):
"""Error class for non-fatal errors that should not be logged."""
class UnloggedInfo(Info):
"""Info class for non-fatal errors that should not be logged."""
class UnloggedWarning(UserWarning):
"""Warning class for non-fatal errors that should not be logged."""
class DownloadError(Error):
"""Error class for download errors."""
def __init__(self, *args) -> None:
Error.__init__(self, *args[:-1])
self.url = args[1]
class UntracedError(Error):
"""Error class for errors that should not be logged."""
class Warn(UserWarning):
"""Warning class for non-fatal errors."""
displaycal-py3-3.9.19/DisplayCAL/defaultpaths.py 000664 000000 000000 00000016741 15225167330 021433 0 ustar 00root root 000000 000000 """Platform-specific default paths for DisplayCAL.
It provides a unified way to access system paths such as application data
directories, cache directories, and ICC profile locations across different
operating systems (Windows, macOS, and Linux).
"""
import os
import sys
if sys.platform not in ("darwin", "win32"): # Linux
LOCALEDIR = os.path.join(sys.prefix, "share", "locale")
elif sys.platform == "win32":
try:
from win32comext.shell.shell import SHGetSpecialFolderPath
from win32comext.shell.shellcon import (
CSIDL_APPDATA,
CSIDL_COMMON_APPDATA,
CSIDL_COMMON_PROGRAMS,
CSIDL_COMMON_STARTUP,
CSIDL_LOCAL_APPDATA,
CSIDL_PROFILE,
CSIDL_PROGRAM_FILES_COMMON,
CSIDL_PROGRAMS,
CSIDL_STARTUP,
CSIDL_SYSTEM,
)
except ImportError:
import ctypes
(
CSIDL_APPDATA,
CSIDL_COMMON_APPDATA,
CSIDL_COMMON_STARTUP,
CSIDL_LOCAL_APPDATA,
CSIDL_PROFILE,
CSIDL_PROGRAMS,
CSIDL_COMMON_PROGRAMS,
CSIDL_PROGRAM_FILES_COMMON,
CSIDL_STARTUP,
CSIDL_SYSTEM,
) = (26, 35, 24, 28, 40, 43, 2, 23, 7, 37)
MAX_PATH = 260
def SHGetSpecialFolderPath( # noqa: N802
hwndOwner: int, # noqa: N803
nFolder: int, # noqa: N803
create: bool = False,
) -> str:
"""Ctypes wrapper around shell32.SHGetSpecialFolderPathW."""
buffer = ctypes.create_unicode_buffer("\0" * MAX_PATH)
ctypes.windll.shell32.SHGetSpecialFolderPathW(0, buffer, nFolder, create)
return buffer.value
from DisplayCAL.util_os import expanduseru, expandvarsu, getenvu
HOME = expanduseru("~")
if sys.platform == "win32":
# Always specify create=1 for SHGetSpecialFolderPath so we don't get an
# exception if the folder does not yet exist
try:
LIBRARY_HOME = APPDATA = SHGetSpecialFolderPath(0, CSIDL_APPDATA, 1)
except Exception as exception:
raise Exception(
f"FATAL - Could not get/create user application data folder: {exception}"
) from exception
try:
LOCALAPPDATA = SHGetSpecialFolderPath(0, CSIDL_LOCAL_APPDATA, 1)
except Exception:
LOCALAPPDATA = os.path.join(APPDATA, "Local")
CACHE = LOCALAPPDATA
# Argyll CMS uses ALLUSERSPROFILE for local system wide app related data
# Note: On Windows Vista and later, ALLUSERSPROFILE and COMMON_APPDATA
# are actually the same ('C:\ProgramData'), but under Windows XP the former
# points to 'C:\Documents and Settings\All Users' while COMMON_APPDATA
# points to 'C:\Documents and Settings\All Users\Application Data'
ALLUSERSPROFILE = getenvu("ALLUSERSPROFILE")
if ALLUSERSPROFILE:
COMMONAPPDATA = [ALLUSERSPROFILE]
else:
try:
COMMONAPPDATA = [SHGetSpecialFolderPath(0, CSIDL_COMMON_APPDATA, 1)]
except Exception as exception:
raise Exception(
"FATAL - Could not get/create common application data folder: "
f"{exception}"
) from exception
LIBRARY = COMMONAPPDATA[0]
try:
COMMON_PROGRAM_FILES = SHGetSpecialFolderPath(0, CSIDL_PROGRAM_FILES_COMMON, 1)
except Exception as exception:
raise Exception(
f"FATAL - Could not get/create common program files folder: {exception}"
) from exception
try:
AUTOSTART = SHGetSpecialFolderPath(0, CSIDL_COMMON_STARTUP, 1)
except Exception:
AUTOSTART = None
try:
AUTOSTART_HOME = SHGetSpecialFolderPath(0, CSIDL_STARTUP, 1)
except Exception:
AUTOSTART_HOME = None
try:
ICCPROFILES = [
os.path.join(
SHGetSpecialFolderPath(0, CSIDL_SYSTEM), "spool", "drivers", "color"
)
]
except Exception as exception:
raise Exception(
f"FATAL - Could not get system folder: {exception}"
) from exception
ICCPROFILES_HOME = ICCPROFILES
try:
PROGRAMS = SHGetSpecialFolderPath(0, CSIDL_PROGRAMS, 1)
except Exception:
PROGRAMS = None
try:
COMMON_PROGRAMS = [SHGetSpecialFolderPath(0, CSIDL_COMMON_PROGRAMS, 1)]
except Exception:
COMMON_PROGRAMS = []
elif sys.platform == "darwin":
LIBRARY_HOME = os.path.join(HOME, "Library")
CACHE = os.path.join(LIBRARY_HOME, "Caches")
LIBRARY = os.path.join(os.path.sep, "Library")
PREFS = os.path.join(os.path.sep, "Library", "Preferences")
PREFS_HOME = os.path.join(HOME, "Library", "Preferences")
APPDATA = os.path.join(HOME, "Library", "Application Support")
COMMONAPPDATA = [os.path.join(os.path.sep, "Library", "Application Support")]
AUTOSTART = AUTOSTART_HOME = None
ICCPROFILES = [
os.path.join(os.path.sep, "Library", "ColorSync", "Profiles"),
os.path.join(os.path.sep, "System", "Library", "ColorSync", "Profiles"),
]
ICCPROFILES_HOME = [os.path.join(HOME, "Library", "ColorSync", "Profiles")]
PROGRAMS = os.path.join(os.path.sep, "Applications")
COMMON_PROGRAMS = []
else:
# Linux
XDG_CACHE_HOME = getenvu("XDG_CACHE_HOME", expandvarsu("$HOME/.cache"))
XDG_CONFIG_HOME = getenvu("XDG_CONFIG_HOME", expandvarsu("$HOME/.config"))
XDG_CONFIG_DIR_DEFAULT = "/etc/xdg"
XDG_CONFIG_DIRS = list(
map(
os.path.normpath,
getenvu("XDG_CONFIG_DIRS", XDG_CONFIG_DIR_DEFAULT).split(os.pathsep),
)
)
if XDG_CONFIG_DIR_DEFAULT not in XDG_CONFIG_DIRS:
XDG_CONFIG_DIRS.append(XDG_CONFIG_DIR_DEFAULT)
XDG_DATA_HOME_DEFAULT = expandvarsu("$HOME/.local/share")
XDG_DATA_HOME = getenvu("XDG_DATA_HOME", XDG_DATA_HOME_DEFAULT)
XDG_DATA_DIRS_DEFAULT = "/usr/local/share:/usr/share:/var/lib"
XDG_DATA_DIRS = list(
map(
os.path.normpath,
getenvu("XDG_DATA_DIRS", XDG_DATA_DIRS_DEFAULT).split(os.pathsep),
)
)
XDG_DATA_DIRS.extend(
list(
filter(
lambda data_dir, data_dirs=XDG_DATA_DIRS: data_dir not in data_dirs,
XDG_DATA_DIRS_DEFAULT.split(os.pathsep),
)
)
)
CACHE = XDG_CACHE_HOME
LIBRARY_HOME = APPDATA = XDG_DATA_HOME
COMMONAPPDATA = XDG_DATA_DIRS
LIBRARY = COMMONAPPDATA[0]
AUTOSTART = None
for dir_ in XDG_CONFIG_DIRS:
if os.path.isdir(dir_):
AUTOSTART = os.path.join(dir_, "autostart")
break
if not AUTOSTART:
AUTOSTART = os.path.join(XDG_CONFIG_DIR_DEFAULT, "autostart")
AUTOSTART_HOME = os.path.join(XDG_CONFIG_HOME, "autostart")
ICCPROFILES = []
for dir_ in XDG_DATA_DIRS:
if os.path.isdir(dir_):
ICCPROFILES.append(os.path.join(dir_, "color", "icc"))
ICCPROFILES.append("/var/lib/color")
ICCPROFILES_HOME = [
os.path.join(XDG_DATA_HOME, "color", "icc"),
os.path.join(XDG_DATA_HOME, "icc"),
expandvarsu("$HOME/.color/icc"),
]
PROGRAMS = os.path.join(XDG_DATA_HOME, "applications")
COMMON_PROGRAMS = [os.path.join(dir_, "applications") for dir_ in XDG_DATA_DIRS]
if sys.platform in ("darwin", "win32"):
ICCPROFILES_DISPLAY = ICCPROFILES
ICCPROFILES_DISPLAY_HOME = ICCPROFILES_HOME
else:
ICCPROFILES_DISPLAY = [
os.path.join(dir_, "devices", "display") for dir_ in ICCPROFILES
]
ICCPROFILES_DISPLAY_HOME = [
os.path.join(dir_, "devices", "display") for dir_ in ICCPROFILES_HOME
]
del dir_
displaycal-py3-3.9.19/DisplayCAL/demjson_compat.py 000664 000000 000000 00000016577 15225167330 021760 0 ustar 00root root 000000 000000 """demjson 1.3 compatibility module."""
from __future__ import annotations
import json
import sys
from io import StringIO
from typing import Any
DEBUG = False
def debug_print(*args: list, **kwargs: dict) -> None:
"""Print debug information if DEBUG is enabled."""
if DEBUG:
sys.stdout.write(*args, **kwargs)
def decode(txt: str, strict: bool = False, encoding: None | str = None, **kw) -> Any: # noqa: ANN401
"""Decode a JSON-encoded string into a Python object.
If 'strict' is set to True, then only strictly-conforming JSON
output will be produced. Note that this means that some types
of values may not be convertible and will result in a
JSONEncodeError exception.
The input string can be either a python string or a python unicode
string. If it is already a unicode string, then it is assumed
that no character set decoding is required.
However, if you pass in a non-Unicode text string (i.e., a python
type 'str') then an attempt will be made to auto-detect and decode
the character encoding. This will be successful if the input was
encoded in any of UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE),
and of course plain ASCII works too.
Note though that if you know the character encoding, then you
should convert to a unicode string yourself, or pass it the name
of the 'encoding' to avoid the guessing made by the auto
detection, as with
python_object = demjson.decode( input_bytes, encoding='utf8' )
Optional keywords arguments are ignored.
Args:
txt (str): The JSON-encoded string to decode.
strict (bool): If True, only strictly conforming JSON is accepted.
encoding (str, optional): The character encoding of the input string.
Defaults to None.
**kw: Additional keyword arguments (ignored).
Returns:
Any: The decoded Python object.
"""
if strict:
return json.loads(txt, strict=strict)
dem_json_preprocessor = DEMJSONPreprocessor()
txt = dem_json_preprocessor.process(txt)
return json.loads(txt)
class DEMJSONPreprocessor:
"""A JSON preprocessor that is compatible with demjson 1.3."""
def __init__(self) -> None:
self.prev = None
self.escape = False
self.expect_comment = False
self.in_comment = False
self.comment_multiline = False
self.in_quote = False
self.write = True
def process(self, txt: str) -> Any: # noqa: ANN401
"""Process the input JSON string to remove comments.
Args:
txt (str): The JSON string to process.
Returns:
str: The processed JSON string with comments removed.
"""
# Remove comments
io = StringIO()
for c in txt:
debug_print(c)
self.write = True
self.process_character(c)
if self.write and not self.expect_comment and not self.in_comment:
io.write(c)
self.prev = c
txt = io.getvalue()
debug_print("\n")
if DEBUG:
print("JSON:", txt)
return txt
def process_character(self, c: str) -> None:
"""Process a character in the JSON string for comment handling.
Args:
c (str): The current character being processed.
"""
if c == "\\":
debug_print("")
self.escape = True
elif self.escape:
debug_print("")
self.escape = False
else:
if not self.in_quote:
if c == "/":
self.handle_forward_slash_char()
elif c == "*":
self.handle_multiline_comment()
elif self.expect_comment:
debug_print("")
self.expect_comment = False
if c == "\n":
self.handle_newline_char()
elif c == '"' and not self.in_comment:
self.handle_quote_status()
def handle_forward_slash_char(self) -> None:
"""Handle the forward slash character in comment processing."""
if self.expect_comment:
debug_print("")
self.in_comment = True
self.comment_multiline = False
self.expect_comment = False
elif self.in_comment and self.prev == "*":
debug_print("")
self.in_comment = False
self.comment_multiline = False
self.write = False
elif not self.in_comment:
debug_print("")
self.expect_comment = True
def handle_multiline_comment(self) -> None:
"""Handle the start of a multiline comment."""
if self.expect_comment:
debug_print("")
self.in_comment = True
self.comment_multiline = True
self.expect_comment = False
def handle_newline_char(self) -> None:
"""Handle newline character in comment processing."""
if self.in_comment and not self.comment_multiline:
debug_print("")
self.in_comment = False
self.write = False
def handle_quote_status(self) -> None:
"""Toggle the in_quote status and print debug information."""
if self.in_quote:
debug_print("")
self.in_quote = False
else:
debug_print("")
self.in_quote = True
def encode(
obj: Any, # noqa: ANN401
strict: bool = False,
compactly: bool = True,
escape_unicode: bool = False,
encoding: None | str = None,
) -> str:
"""Encode a Python object into a JSON-encoded string.
'strict' is ignored.
If 'compactly' is set to True, then the resulting string will
have all extraneous white space removed; if False then the
string will be "pretty printed" with whitespace and indentation
added to make it more readable.
If 'escape_unicode' is set to True, then all non-ASCII characters
will be represented as a unicode escape sequence; if False then
the actual real unicode character will be inserted.
If no encoding is specified (encoding=None) then the output will
either be a Python string (if entirely ASCII) or a Python unicode
string type.
However if an encoding name is given then the returned value will
be a python string which is the byte sequence encoding the JSON
value. As the default/recommended encoding for JSON is UTF-8,
you should almost always pass in encoding='utf8'.
Args:
obj (Any): The Python object to encode.
strict (bool): Ignored, for compatibility.
compactly (bool): If True, the output will be compact; if False, it
will be pretty-printed with indentation.
escape_unicode (bool): If True, non-ASCII characters will be escaped;
if False, they will be included as actual characters.
encoding (str, optional): The character encoding for the output string.
Defaults to None.
Returns:
str: The JSON-encoded string.
"""
if compactly:
indent = None
separators = (",", ":")
else:
indent = 2
separators = (",", ": ")
ensure_ascii = escape_unicode or encoding is not None
return json.dumps(
obj,
ensure_ascii=ensure_ascii,
indent=indent,
separators=separators,
)
displaycal-py3-3.9.19/DisplayCAL/dev/ 000775 000000 000000 00000000000 15225167330 017142 5 ustar 00root root 000000 000000 displaycal-py3-3.9.19/DisplayCAL/dev/__init__.py 000664 000000 000000 00000000015 15225167330 021247 0 ustar 00root root 000000 000000 # noqa: N999
displaycal-py3-3.9.19/DisplayCAL/dev/mocks.py 000664 000000 000000 00000013226 15225167330 020634 0 ustar 00root root 000000 000000 """Generic mock functions for unit-tests.
Use `check_call` as a context manager to mock calls and their return values as
well to check if the method was called (or not).
"""
from __future__ import annotations
import contextlib
from typing import TYPE_CHECKING, Any, overload
from _pytest.monkeypatch import MonkeyPatch
if TYPE_CHECKING:
from collections.abc import Generator
from types import ModuleType
Call = tuple[tuple[Any, ...], dict[str, Any]]
CallList = list[Call]
@overload
@contextlib.contextmanager
def _mp_call(
monkeypatch: MonkeyPatch,
mock_class: type[Any] | ModuleType,
method: str,
return_value: Any, # noqa: ANN401
as_property: bool,
) -> CallList: ...
@overload
@contextlib.contextmanager
def _mp_call(
monkeypatch: MonkeyPatch,
mock_class: str,
method: Any, # return value in this case # noqa: ANN401
return_value: bool, # as_property in this case
) -> CallList: ...
def _mp_call(
monkeypatch: MonkeyPatch,
mock_class: type[Any] | ModuleType | str,
method: str | Any,
return_value: Any,
as_property: bool = False,
) -> CallList:
"""Mock a method in a class and record the calls to it.
If the given return_value is an Exception, it will be raised.
If not, the value will be returned from the mocked function/method.
"""
calls: CallList = []
def func_call(*a: Any, **k: Any) -> Any: # noqa: ANN401
"""Mock the function call."""
calls.append((a, k))
if isinstance(return_value, Exception):
# bug in pylint https://www.logilab.org/ticket/3207
raise return_value # pylint: disable-msg=raising-bad-type
if callable(return_value):
# Handle the case that a function was passed
return return_value(*a, **k)
return return_value
# first case handles class + method, second one mock as str
if as_property or (isinstance(mock_class, str) and return_value):
callback = property(func_call)
else:
callback = func_call
if isinstance(mock_class, str):
return_value = method
monkeypatch.setattr(mock_class, callback)
else:
monkeypatch.setattr(mock_class, method, callback)
return calls
@contextlib.contextmanager
def check_call( # pylint: disable=too-many-arguments
mock_class: type[Any] | ModuleType,
method: str,
return_value: Any = None, # noqa: ANN401
call_args_list: None | list[tuple[Any, ...]] = None,
call_kwargs_list: None | list[dict[str, Any]] = None,
call_count: int = 1,
as_property: bool = False,
) -> Generator[CallList, None, None]:
"""Context manager for mocking and checking a call to a method.
If called is greater 0, and call_args and call_kwargs are given, the context manager
will check that the mocked method was called with those arguments. Also, it will
assert that the mock was called exactly once.
If called is False, it will assert that the mock was not called.
If a return_value is given, the mock will return this value. One can pass an
exception that will be raised by the mocked method instead of returning a value.
If a Callable is passed, it will be called and its return value returned.
"""
assert (call_args_list is not None and call_kwargs_list is not None) or ( # noqa: S101
call_args_list is None and call_kwargs_list is None
), "call_args and call_kwargs must be None or have a value (list/dict if empty)"
monkeypatch = MonkeyPatch()
calls = _mp_call(monkeypatch, mock_class, method, return_value, as_property)
try:
yield calls
finally:
m_name = f"{mock_class.__name__}.{method}"
monkeypatch.undo()
assert_calls(call_count, call_args_list, call_kwargs_list, calls, m_name)
# Duplicate the code because overloading is a mess due to this bug:
# https://github.com/python/mypy/issues/11373
@contextlib.contextmanager
def check_call_str( # pylint: disable=too-many-arguments
mock_class: str,
return_value: Any = None, # noqa: ANN401
call_args_list: None | list[tuple[Any, ...]] = None,
call_kwargs_list: None | list[dict[str, Any]] = None,
call_count: int = 1,
as_property: bool = False,
) -> Generator[CallList, None, None]:
"""Context manager for mocking and checking a call to a method.
See `check_call` documentation.
"""
assert (call_args_list is not None and call_kwargs_list is not None) or ( # noqa: S101
call_args_list is None and call_kwargs_list is None
), "call_args and call_kwargs must be None or have a value (list/dict if empty)"
monkeypatch = MonkeyPatch()
calls = _mp_call(monkeypatch, mock_class, return_value, as_property)
yield calls
m_name = mock_class
monkeypatch.undo()
assert_calls(call_count, call_args_list, call_kwargs_list, calls, m_name)
def assert_calls(
call_count: int,
call_args_list: None | list[tuple[Any, ...]],
call_kwargs_list: None | list[dict[str, Any]],
calls: CallList,
m_name: str,
) -> None:
"""Check that the calls made to the mocked function are correct."""
if call_count != -1:
assert len(calls) == call_count, ( # noqa: S101
f"Expected {call_count} calls to {m_name} but got: {len(calls)}"
)
if call_args_list and call_kwargs_list:
for idx, call_args in enumerate(call_args_list):
assert call_args == calls[idx][0], ( # noqa: S101
f"Args to {m_name}: {call_args} expected: {call_args}"
)
for idx, call_kwargs in enumerate(call_kwargs_list):
assert call_kwargs == calls[idx][1], ( # noqa: S101
f"Kwargs to {m_name}: {call_kwargs} expected: {call_kwargs}"
)
displaycal-py3-3.9.19/DisplayCAL/display_cal.py 000664 000000 000000 00003453662 15225167330 021245 0 ustar 00root root 000000 000000 """DisplayCAL - display calibration and characterization powered by ArgyllCMS.
Copyright (C) 2008, 2009 Florian Hoech
This program is free software;
you can redistribute it and/or modify it under the terms of the GNU General
Public License as published by the Free Software Foundation;
either version 3 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program; if not, see
"""
# Standard modules
from __future__ import annotations
import contextlib
import datetime
import io
import json as json_module
import math
import os
import platform
import re
import shutil
import socket
import subprocess as sp
import sys
import threading
import requests
import traceback
import urllib.error
import urllib.parse
import urllib.request
import webbrowser # Import the webbrowser module for platform-independent results
import zipfile
from decimal import Decimal
from hashlib import md5
from io import BytesIO, StringIO
from time import localtime, sleep, strftime, strptime, struct_time
from typing import TYPE_CHECKING, Callable
from zlib import crc32
from send2trash import send2trash
# wxPython
from wx import xrc
from wx.lib import delayedresult, platebtn
from wx.lib.art import flagart
from wx.lib.scrolledpanel import ScrolledPanel
# Local Imports
from DisplayCAL import (
audio,
ccmx,
colord,
colormath,
config,
floatspin,
madvr,
report,
util_x,
xh_bitmapctrls,
xh_fancytext,
xh_filebrowsebutton,
xh_floatspin,
xh_hstretchstatbmp,
)
from DisplayCAL import localization as lang
from DisplayCAL.argyll import (
check_set_argyll_bin,
get_argyll_instrument_config,
get_argyll_latest_version,
get_argyll_util,
get_argyll_version,
make_argyll_compatible_path,
set_argyll_bin,
)
from DisplayCAL.argyll_cgats import (
cal_to_fake_profile,
can_update_cal,
extract_cal_from_profile,
ti3_to_ti1,
verify_ti1_rgb_xyz,
)
from DisplayCAL.argyll_instruments import get_canonical_instrument_name, instruments
from DisplayCAL.argyll_names import VIEWCONDS
from DisplayCAL.cgats import (
CGATS,
CGATSError,
CGATSInvalidError,
CGATSInvalidOperationError,
CGATSKeyError,
CGATSTypeError,
CGATSValueError,
)
from DisplayCAL.colormath import (
XYZ2CCT,
CIEDCCT2xyY,
XYZ2Lab,
XYZ2xyY,
planckianCT2xyY,
xyY2CCT,
)
from DisplayCAL.config import (
AUTOSTART,
AUTOSTART_HOME,
DEFAULTS,
ENC,
EXE,
EXE_EXT,
FS_ENC,
ISEXE,
PROFILE_EXT,
PYDIR,
RES_FILES,
SCRIPT_EXT,
get_bitmap,
get_ccxx_testchart,
get_current_profile,
get_data_path,
get_display_profile,
get_icon,
get_total_patches,
get_verified_path,
getcfg,
hascfg,
initcfg,
is_ccxx_testchart,
is_profile,
setcfg,
setcfg_cond,
writecfg,
)
from DisplayCAL.debughelpers import (
getevtobjname,
getevttype,
handle_error,
)
from DisplayCAL.edid import PNP_ID_CACHE, get_manufacturer_name
from DisplayCAL.icc_profile import (
GAMUT_VOLUME_ADOBERGB,
GAMUT_VOLUME_SMPTE431_P3,
GAMUT_VOLUME_SRGB,
ChromaticAdaptionTag,
CurveType,
DictType,
ICCProfile,
ICCProfileInvalidError,
ICCProfileTag,
LUT16Type,
TextDescriptionType,
TextType,
VideoCardGammaTableType,
VideoCardGammaType,
XYZType,
)
from DisplayCAL.log import LOGBUFFER
from DisplayCAL.meta import (
AUTHOR,
DEVELOPMENT_HOME_PAGE,
DOMAIN,
VERSION_STRING,
VERSION_TUPLE,
GITHUB_API_URL,
get_latest_changelog_entry,
)
from DisplayCAL.meta import (
NAME as APPNAME,
)
from DisplayCAL.options import (
DEBUG,
FORCE_SKIP_INITIAL_INSTRUMENT_DETECTION,
TEST,
TEST_UPDATE,
VERBOSE,
)
from DisplayCAL.patterngenerators import WebWinHTTPPatternGeneratorServer
from DisplayCAL.util_decimal import float2dec, stripzeros
from DisplayCAL.util_dict import dict_sort, swap_dict_keys_values
from DisplayCAL.util_io import LineCache, TarFileProper
from DisplayCAL.util_list import index_fallback_ignorecase, intlist, natsort
from DisplayCAL.util_os import (
dlopen,
expanduseru,
get_program_file,
getenvu,
is_superuser,
launch_file,
listdir_re,
safe_glob,
waccess,
which,
)
from DisplayCAL.util_str import (
ellipsis_,
make_filename_safe,
safe_str,
strtr,
universal_newlines,
wrap,
)
from DisplayCAL.worker import (
Error,
FilteredStream,
Info,
UnloggedError,
UnloggedInfo,
UnloggedWarning,
Warn,
Worker,
_applycal_bug_workaround,
check_argyll_bin,
check_create_dir,
check_file_isfile,
check_ti3,
check_ti3_criteria1,
check_ti3_criteria2,
get_arg,
get_argyll_util,
get_cfg_option_from_args,
get_current_profile_path,
get_options_from_cal,
get_options_from_profile,
get_options_from_ti3,
http_request,
parse_argument_string,
reload_black_videoluts,
show_result_dialog,
)
from DisplayCAL.wx_addons import (
CustomEvent,
CustomGridCellEvent,
IdFactory,
PopupMenu,
wx,
)
from DisplayCAL.wx_display_uniformity_frame import DisplayUniformityFrame
from DisplayCAL.wx_fixes import (
BitmapWithThemedButton,
PlateButton,
TempXmlResource,
ThemedGenButton,
get_bitmap_disabled,
set_bitmap_labels,
set_maxsize,
wx_Panel,
)
from DisplayCAL.wx_lut_3d_frame import LUT3DFrame, LUT3DMixin
from DisplayCAL.wx_measure_frame import MeasureFrame, get_default_size
from DisplayCAL.wx_report_frame import ReportFrame
from DisplayCAL.wx_synth_icc_frame import SynthICCFrame
from DisplayCAL.wx_testchart_editor import TestchartEditor
from DisplayCAL.wx_visual_whitepoint_editor import VisualWhitepointEditor
from DisplayCAL.wx_windows import (
AboutDialog,
AuiBetterTabArt,
BaseApp,
BaseFrame,
BitmapBackgroundPanel,
BitmapBackgroundPanelText,
BorderGradientButton,
ConfirmDialog,
CustomCellBoolRenderer,
CustomGrid,
FileBrowseBitmapButtonWithChoiceHistory,
FileDrop,
HtmlWindow,
HyperLinkCtrl,
InfoDialog,
LogWindow,
TabButton,
TooltipWindow,
get_dialogs,
)
if sys.platform == "win32":
import winreg
from DisplayCAL import util_win
elif sys.platform == "darwin":
from DisplayCAL import util_mac
try:
from DisplayCAL.chromecast_pattern_generator import ChromeCastPatternGenerator
except ImportError:
from types import NoneType
ChromeCastPatternGenerator = NoneType
try:
from DisplayCAL.wx_ccxx_plot import CCXXPlot
except ImportError:
CCXXPlot = None
try:
from DisplayCAL.wx_lut_viewer import LUTFrame
except ImportError:
LUTFrame = None
try:
from DisplayCAL.wx_profile_info import ProfileInfoFrame
except ImportError:
ProfileInfoFrame = None
# wxPython
try:
# Only wx.lib.aui.AuiNotebook looks reasonable across _all_ platforms.
# Other tabbed book controls like wx.Notebook or wx.aui.AuiNotebook are
# impossible to get to look right under GTK because there's no way to set
# the correct background color for the pages.
from wx.lib.agw import aui
except ImportError:
# Fall back to wx.aui under ancient wxPython versions
from wx import aui
if TYPE_CHECKING:
from pathlib import Path
# Set no delay time to open the web page
webbrowser.PROCESS_CREATION_DELAY = 0
APP_IS_UP_TO_DATE = True
RELEASE_DATA: dict | None = None
COMPRESSED_FILE_EXTENSIONS = (".7z", ".tar.gz", ".tgz", ".zip")
ICCPROFILE_FILE_EXTENSIONS = (".icc", ".icm")
# Use conservative UI paths by default unless explicitly disabled.
SAFE_WX_UI = os.getenv("DISPLAYCAL_UNSAFE_WX_UI", "").strip() != "1"
def debug_print(*args, **kwargs) -> None:
"""Print debug messages if DEBUG is enabled."""
if DEBUG:
print(*args, **kwargs)
def verbose_print(*args, **kwargs) -> None:
"""Print verbose messages if VERBOSE is enabled."""
if kwargs.pop("level", 1) <= VERBOSE:
print(*args, **kwargs)
def set_platebutton_bitmaps(
button: PlateButton, icon_name: str, size: int = 16
) -> None:
"""Set normal/hover/disabled bitmaps with crash-safe hover color lookup."""
hover_suffix = ""
if not SAFE_WX_UI:
try:
hover_suffix = button._color["htxt"].GetAsString(wx.C2S_HTML_SYNTAX)
except Exception:
hover_suffix = ""
button.SetBitmapHover(get_icon(size, icon_name + hover_suffix))
button.SetBitmapDisabled(get_bitmap_disabled(get_icon(size, icon_name)))
def show_ccxx_error_dialog(exception: Exception, path: str, parent: wx.Window) -> None:
"""Show a dialog with the error message from CGATS exception.
Args:
exception (Exception): The CGATS exception that was raised.
path (str): The path to the CGATS file.
parent (wx.Window): The parent window to show the dialog.
"""
msg = str(exception)
if msg.startswith("Malformed"):
fn, ext = os.path.splitext(path)
msg = lang.getstr("error.malformed_cgats", (ext[1:].upper(), path))
show_result_dialog(msg, parent)
def get_download_url(newversion: str) -> str | None:
"""Return the GitHub release asset download URL for the current platform."""
if RELEASE_DATA is None:
return None
if sys.platform == "win32":
machine = platform.machine().lower()
if machine in ("arm64", "aarch64"):
filename = f"{APPNAME}-{newversion}-Windows-arm64.exe"
else:
filename = f"{APPNAME}-{newversion}-Windows-x64.exe"
elif sys.platform == "darwin":
machine = platform.machine().lower()
if machine in ("arm64", "aarch64"):
filename = f"{APPNAME}-{newversion}-macOS-arm64.dmg"
else:
filename = f"{APPNAME}-{newversion}-macOS-x86.dmg"
else:
filename = f"{APPNAME.lower()}-{newversion}.tar.gz"
for asset in RELEASE_DATA["assets"]:
if asset["name"] == filename:
return asset["browser_download_url"]
return None
def is_new_update() -> bool | tuple:
"""Check for new updates on GitHub.
Returns:
bool | tuple: The latest version tuple if a new update is available,
False otherwise.
"""
global RELEASE_DATA
print("Checking for updates...")
headers = {"User-Agent": "DisplayCAL-updater"}
try:
response = requests.get(
f"{GITHUB_API_URL}/releases/latest", headers=headers, timeout=10
)
response.raise_for_status()
except requests.RequestException as e:
print(f"Error checking for updates: Network error - {str(e)}")
return False
try:
data = response.json()
RELEASE_DATA = data
latest_version_tuple = tuple(int(n) for n in data["tag_name"].split("."))
except (KeyError, ValueError, IndexError) as e:
print(f"Error checking for updates: Parsing error - {str(e)}")
return False
current_version = VERSION_TUPLE[:3]
if latest_version_tuple > current_version:
print("New updates available!")
return latest_version_tuple
print("No new updates available.")
return False
def app_update_check(
parent: None | wx.Window = None,
silent: bool = False,
snapshot: bool = False,
argyll: bool = False,
) -> None:
"""Check for application update. Show an error dialog if a failure occurs.
Args:
parent (None | wx.Window, optional): The parent window for the dialog.
silent (bool, optional): If True, suppresses dialog display and
only performs the update check.
snapshot (bool, optional): If True, the application is a snapshot build.
argyll (bool, optional): If True, check for ArgyllCMS update.
"""
global APP_IS_UP_TO_DATE
if argyll:
if TEST_UPDATE:
argyll_version = [0, 0, 0]
elif parent and hasattr(parent, "worker"):
argyll_version = parent.worker.argyll_version
else:
argyll_version = intlist(getcfg("argyll.version").split("."))
curversion_tuple = tuple(argyll_version)
chglog_file = "Argyll/ChangesSummary.html"
# Fetch the latest ArgyllCMS version from argyllcms.com
latest_argyll_str = get_argyll_latest_version()
try:
new_version_tuple = tuple(int(n) for n in latest_argyll_str.split("."))
except (ValueError, AttributeError):
print(lang.getstr("update_check.fail.version", "ArgyllCMS"))
if not silent:
wx.CallAfter(
InfoDialog,
parent,
msg=lang.getstr("update_check.fail.version", "ArgyllCMS"),
ok=lang.getstr("ok"),
bitmap=get_icon(32, "dialog-error"),
log=False,
)
return
new_version_tuple = (0, 0, 0, 0)
if not wx.GetApp():
return
elif snapshot:
# Snapshot — fetch the version file directly from the project domain
curversion_tuple = VERSION_TUPLE
chglog_file = "SNAPSHOT_CHANGES.html"
resp = http_request(
parent,
DOMAIN,
"GET",
"/SNAPSHOT_VERSION",
failure_msg=lang.getstr("update_check.fail"),
silent=silent,
)
if resp is False:
if silent:
# Check if we need to run instrument setup
wx.CallAfter(
parent.check_instrument_setup, check_donation, (parent, snapshot)
)
return
data = resp.read()
if not wx.GetApp():
return
try:
new_version_tuple = tuple(int(n) for n in data.decode().split("."))
except ValueError:
print(lang.getstr("update_check.fail.version", DOMAIN))
if not silent:
wx.CallAfter(
InfoDialog,
parent,
msg=lang.getstr("update_check.fail.version", DOMAIN),
ok=lang.getstr("ok"),
bitmap=get_icon(32, "dialog-error"),
log=False,
)
return
new_version_tuple = (0, 0, 0, 0)
else:
# Stable
print(lang.getstr("update_check"))
curversion_tuple = VERSION_TUPLE
chglog_file = "CHANGES.html"
resp = is_new_update()
if resp is False:
if silent:
# Check if we need to run instrument setup
wx.CallAfter(
parent.check_instrument_setup, check_donation, (parent, snapshot)
)
return
# Non-silent with no update available: fall through to the
# "up to date" branches below using the current version.
resp = curversion_tuple
if not wx.GetApp():
return
new_version_tuple = resp
if not argyll:
APP_IS_UP_TO_DATE = new_version_tuple <= curversion_tuple
if new_version_tuple > curversion_tuple:
# Get changelog
resp = http_request(parent, DOMAIN, "GET", "/" + chglog_file, silent=True)
chglog = None
if resp:
readme = str(resp.read())
if argyll:
chglog = readme
else:
chglog = get_latest_changelog_entry(readme)
if chglog:
chglog = f"""
{chglog}
"""
if chglog:
chglog = re.sub(
re.compile(r"(.+?)", flags=re.I | re.S),
r"
\n?', "", changelog)
changelog = re.sub(r"\s*\n?", "", changelog)
changelog = re.sub(r"\s*<(h[23])>.+?\n?", "", changelog)
return changelog
def script2pywname(script: str) -> str:
"""Convert all-lowercase script name to mixed-case pyw name."""
a2b = {
f"{NAME}-3dlut-maker": f"{NAME}-3DLUT-maker",
f"{NAME}-vrml-to-x3d-converter": f"{NAME}-VRML-to-X3D-converter",
f"{NAME}-eecolor-to-madvr-converter": f"{NAME}-eeColor-to-madVR-converter",
}
if script.lower().startswith(NAME.lower()):
pyw = f"{NAME}{script[len(NAME) :]}"
return a2b.get(pyw, pyw)
return script
displaycal-py3-3.9.19/DisplayCAL/mscms.py 000664 000000 000000 00000101151 15225167330 020057 0 ustar 00root root 000000 000000 """Provides a thread-safe interface for the Windows Color System API.
This isolates the actual communication with WinAPI to separate process.
Windows only.
References and useful info:
According to https://learn.microsoft.com/en-us/previous-versions/troubleshoot/windows/win32/geticmprofile-might-leak-one-more-handles-windows-10 and
https://learn.microsoft.com/en-us/troubleshoot/windows/win32/geticmprofile-might-leak-one-or-more-handles-on-windows10
(in case one of those breaks eventually) Microsoft couldn't be bothered to fix
leaking handles in mscms.dll in Windows 10. That causes issues for applications
which do frequent calls to the leaking API calls:
+ GetICMProfile
+ EnumICMProfiles
+ WcsGetDefaultColorProfile
+ WcsGetDefaultColorProfileSize
+ WcsGetUsePerUserProfiles
Other mitigation tactics possible:
+ closing suspicious reg handles to specific keys
(https://gist.github.com/AySz88/7a233d84632498a8de382c1199f859f2 and
DisplayCal has its own implementation in _win10_1903_close_leaked_regkey_handles()).
+ using said APIs less (caching, etc)
+ restarting once in a while (profile loader, according to the changelog 3.8.7,
restarts each day at 4.00 due to leaks in SetDeviceGammaRamp).
+ calling such APIs in separate processes
""" # noqa: E501
from __future__ import annotations
import atexit
import builtins
import logging
import multiprocessing
import sys
import threading
import uuid
from functools import wraps
from logging.handlers import QueueHandler, QueueListener
from multiprocessing import Process, Queue
from queue import Empty
from threading import Lock, Thread
from time import sleep
from typing import (
Any,
Callable,
Literal,
TypeVar,
Union,
)
import psutil
if sys.version_info >= (3, 11):
from typing import NotRequired, ParamSpec, TypedDict
else:
from typing_extensions import NotRequired, ParamSpec, TypedDict
from DisplayCAL.mscms_types import (
COLORPROFILESUBTYPE,
COLORPROFILETYPE,
WCS_PROF_SCOPE,
dwDeviceClass,
)
if sys.platform == "win32":
from DisplayCAL.mscms_wrapper import WCS
else:
class WCS:
"""Placeholder class for non-Windows platforms."""
def __getattribute__(self, name: str) -> None:
"""Placeholder method."""
raise NotImplementedError("Windows only")
def __setattr__(self, name: str, value: Any) -> None: # noqa: ANN401
"""Placeholder method."""
raise NotImplementedError("Windows only")
def __delattr__(self, name: str) -> None:
"""Placeholder method."""
raise NotImplementedError("Windows only")
def __call__(self, *args, **kwargs) -> None:
"""Placeholder method."""
raise NotImplementedError("Windows only")
default_logging_level = logging.INFO
logger = logging.getLogger(__name__ + ".manager")
logger.setLevel(default_logging_level)
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
# Only attach a real stderr handler when stderr is an interactive console.
# A frozen windowed exe (py2exe) replaces sys.stderr with a lazily-opening
# log-file shim that pops up an "Errors in ..." dialog on exit for ANY
# write, even plain INFO messages, so stay silent there (see #804).
if hasattr(sys.stderr, "isatty") and sys.stderr.isatty():
ch = logging.StreamHandler()
else:
ch = logging.NullHandler()
ch.setFormatter(formatter)
logger.addHandler(ch)
logger.propagate = False
check_handles_call_num = 100 # check leaking handles every of calls
open_handles_threshold = 3000 # worker process open handle limit
FILE_NOT_FOUND_ERRNO = 2
class RequestType(TypedDict):
"""Represents a request sent to the worker process."""
id: str
method: str
args: Any
kwargs: Any
class ErrorType(TypedDict):
"""Represents an error response from the worker process."""
type: str
message: str
errno: NotRequired[Any]
class SuccessResponseType(TypedDict):
"""Represents a successful response from the worker process."""
type: Literal["resp_success"]
id: str
result: Any
class FailureResponseType(TypedDict):
"""Represents an error response from the worker process."""
type: Literal["resp_error"]
id: str
error: ErrorType
ResponseType = Union[SuccessResponseType, FailureResponseType]
class PendingType(TypedDict):
"""Represents a pending request in the WCSManager."""
event: threading.Event
result: NotRequired[Any]
error: NotRequired[ErrorType]
class WCSError(Exception):
"""Base class for WCS-related errors."""
class WCSManagerShutdownError(WCSError):
"""Error type for operations attempted while WCSManager is shutting down."""
class WCSWorkerError(WCSError):
"""Generic error type for exceptions raised during remote execution."""
F_Spec = ParamSpec("F_Spec")
F_Return = TypeVar("F_Return")
def retry(
retries: int = 5,
base_delay: float = 0.1,
retry_on: tuple[type[Exception], ...] = (Exception,),
) -> Callable[[Callable[F_Spec, F_Return]], Callable[F_Spec, F_Return]]:
"""A simple retry decorator with exponential backoff for specified exceptions."""
def real_retry(func: Callable[F_Spec, F_Return]) -> Callable[F_Spec, F_Return]:
@wraps(func)
def wrapper(*args: F_Spec.args, **kwargs: F_Spec.kwargs) -> F_Return:
if retries < 0:
raise ValueError("Retries must be non-negative")
if base_delay < 0:
raise ValueError("Base delay must be non-negative")
attempt = 0
last_exception: None | Exception = None
while attempt <= retries:
if attempt > 0: # logging as retry after first attempt
logger.debug(
f"Retrying {func.__name__}: "
f"attempt {attempt}/{retries} after {last_exception}"
)
try:
return func(*args, **kwargs)
except retry_on as e:
attempt += 1
last_exception = e
if attempt <= retries:
delay = base_delay * (
2 ** (attempt - 1)
) # exponential backoff with no jitter
logger.debug(
f"Retryable error caught in {func.__name__}: {e}. "
f"Retrying in {delay:.3f}s..."
)
sleep(delay)
else:
raise last_exception from e
except Exception as e:
logger.debug(f"Stopping retry in {func.__name__} on exception: {e}")
raise
raise RuntimeError("General retry decorator error")
return wrapper
return real_retry
def _wcs_worker_process(
request_queue: Queue[RequestType | None],
response_queue: Queue[ResponseType],
log_queue: Queue[Any],
) -> None:
wcs_instance = None
log_queue_handler = QueueHandler(log_queue)
logger = logging.getLogger(__name__ + ".wcsworker")
logger.setLevel(default_logging_level)
logger.addHandler(log_queue_handler)
logger.propagate = False
logger.info("WCSWorker process started")
try:
wcs_instance = WCS()
logger.debug("WCS instance initialized in worker")
while True:
try:
request: None | RequestType = request_queue.get(timeout=1.0)
except Empty:
continue
if request is None:
logger.info("WCSWorker received poison pill")
break
request_id = request.get("id")
method_name: str = request.get("method")
args = request.get("args", ())
kwargs = request.get("kwargs", {})
logger.debug(f"WCSWorker processing request ID {request_id}: {method_name}")
try:
method = getattr(wcs_instance, method_name)
result = method(*args, **kwargs)
response: ResponseType = {
"type": "resp_success",
"id": request_id,
"result": result,
}
except Exception as e:
response: ResponseType = {
"type": "resp_error",
"id": request_id,
"error": {
"type": type(e).__name__,
"message": str(e),
"errno": getattr(e, "errno", None), # if present
},
}
try:
response_queue.put(response)
logger.debug(f"WCSWorker sent response for request ID {request_id}")
except Exception as e:
logger.error(f"Failed to send response for request {request_id}: {e}")
except Exception as e:
logger.critical(f"Unexpected error in WCSWorker process: {e}", exc_info=True)
finally:
logger.info("WCSWorker process shutting down")
if wcs_instance:
del wcs_instance
# Potential logger reuse handling
for handler in logger.handlers[:]:
handler.close()
logger.removeHandler(handler)
class WCSManager:
"""WCSManager class.
Note: can only be initialized once.
Args:
handle_threshold (int, optional): Maximum open handles limit.
Defaults to 10000.
request_timeout (float, optional): Timeout for an individual request
(note the retry logic and compound requests). Defaults to 10.0.
"""
def __init__(
self,
handle_threshold: int = open_handles_threshold, # will restart once in a while
request_timeout: float = 10.0,
) -> None:
if hasattr(self, "_initialized"):
return
self.handle_threshold = handle_threshold
self.request_timeout = request_timeout
self._lock = Lock()
self._worker_process: None | Process = None
self._request_queue: None | RequestType = Queue()
self._response_queue: None | ResponseType = Queue()
self._log_queue: Queue[Any] = Queue()
self._log_listener: None | QueueListener = None
self._pending_requests: dict[str, PendingType] = {}
self._shutdown_event = threading.Event()
self._wcs_calls_made = 0
self._response_listener_thread: None | Thread = None
handlers = logger.handlers if logger.handlers else [logging.StreamHandler()]
self._log_listener = QueueListener(
self._log_queue, *handlers, respect_handler_level=True
)
self._log_listener.start()
logger.debug("QueueListener for worker logs started")
self._start_worker()
self._initialized = True
atexit.register(self._atexit_shutdown)
logger.info("WCSManager initialized")
def _start_worker(self) -> None:
"""Start the worker process and response listener thread."""
with self._lock:
if self._worker_process and self._worker_process.is_alive():
logger.warning("Worker is already running")
return
self._shutdown_event.clear()
self._worker_process = multiprocessing.Process(
target=_wcs_worker_process,
args=(self._request_queue, self._response_queue, self._log_queue),
)
self._worker_process.start()
logger.info(
f"WCSWorker process started with PID {self._worker_process.pid}"
)
self._response_listener_thread = Thread(
target=self._listen_for_responses, daemon=True
)
self._response_listener_thread.start()
logger.debug("Response listener thread started")
def _stop_worker(self) -> None:
"""Stop the worker process with timeout and forceful termination if needed."""
with self._lock:
if not self._worker_process or not self._worker_process.is_alive():
logger.debug("Worker is not running")
return
logger.info("Sending shutdown signal to WCSWorker")
try:
# Poison Pill
self._request_queue.put(None)
except Exception as e:
logger.error(f"Failed to send shutdown signal: {e}")
# Waiting for process completion
self._worker_process.join(timeout=5.0)
if self._worker_process.is_alive():
logger.warning(
"WCSWorker did not terminate gracefully, terminating forcefully."
)
self._worker_process.terminate()
self._worker_process.join(timeout=2.0)
if self._worker_process.is_alive():
logger.error("Failed to terminate WCSWorker process")
else:
logger.info("WCSWorker process terminated")
self._shutdown_event.set() # Closing down listener and call functionality
def _handle_check_worker(self) -> None:
logger.info("Performing worker process open handle check")
p = None
num_handles = 0
try:
if self._worker_process:
p = psutil.Process(self._worker_process.pid)
num_handles = p.num_handles()
else:
logger.warning("No running worker process discovered")
except Exception as e:
logger.warning(
"Failed to get handle count for process "
f"{p.pid if p else 'unknown'}: {e}"
)
return
if num_handles > self.handle_threshold:
logger.debug(
"Open handle number exceeded: "
f"{num_handles}>{self.handle_threshold}. "
"Restarting worker process"
)
self._stop_worker()
self._start_worker()
logger.info("WCSWorker restarted successfully")
else:
logger.debug(f"Current child process open handles: {num_handles}")
def _listen_for_responses(self) -> None:
logger.debug("Response listener thread main loop started")
while not self._shutdown_event.is_set():
try:
# Short timeout to be able to stop the thread
response = self._response_queue.get(timeout=1.0)
except Empty:
continue
except Exception as e:
if not self._shutdown_event.is_set():
logger.error(f"Error getting response from queue: {e}")
continue
# Regular path
request_id = response.get("id")
logger.debug(f"Received response for request ID {request_id}")
with self._lock:
if request_id in self._pending_requests:
req_data = self._pending_requests.pop(request_id)
event = req_data.get("event")
if event:
req_data["result"] = response.get("result")
if "error" in response:
req_data["error"] = response.get("error")
self._pending_requests[request_id] = req_data
event.set() # signal _call_wcs_method
else:
logger.warning(
f"Received response for unknown request ID {request_id}"
)
logger.debug("Response listener thread loop finished")
@retry(retry_on=(RuntimeError, TimeoutError))
def _call_wcs_method(self, method_name: str, *args: Any, **kwargs: Any) -> Any: # noqa: ANN401
if self._shutdown_event.is_set():
raise WCSManagerShutdownError("WCSManager is set to shut down")
request_id = str(uuid.uuid4())
request: RequestType = {
"id": request_id,
"method": method_name,
"args": args,
"kwargs": kwargs,
}
event = threading.Event()
with self._lock:
logger.debug(f"Request ID {request_id} added to the pending requests")
self._pending_requests[request_id] = {"event": event}
try:
self._request_queue.put(request)
logger.debug(f"Sent request ID {request_id} for method {method_name}")
except Exception as e:
with self._lock:
self._pending_requests.pop(request_id, None)
logger.debug(
f"Request ID {request_id} removed from pending requests: "
"cancellation"
)
raise RuntimeError(f"Failed to send request to worker: {e}") from e
with self._lock:
self._wcs_calls_made += 1
if self._wcs_calls_made % check_handles_call_num == 0:
logger.debug("Worker process open handle check triggered")
# Launch in other thread to not block the listener
threading.Thread(target=self._handle_check_worker, daemon=True).start()
# Waiting for an answer to be received
if not event.wait(timeout=self.request_timeout):
with self._lock:
self._pending_requests.pop(request_id, None)
logger.debug(
f"Request ID {request_id} removed from pending requests: timeout"
)
raise TimeoutError(f"Timeout waiting for response to request {request_id}")
# Processing the result
with self._lock:
req_data = self._pending_requests.pop(request_id, {})
logger.debug(
f"Request ID {request_id} removed from pending requests: success"
)
if "error" in req_data: # error path
error_response = req_data.get("error")
if error_response:
error_type = error_response.get("type")
error_message = error_response.get("message")
error_errno = error_response.get("errno")
# Recreating exceptions
try:
exc_class = getattr(builtins, error_type)
except Exception:
exc_class = WCSWorkerError
if issubclass(exc_class, OSError):
exc = exc_class(error_message)
if error_errno is not None:
exc.errno = error_errno
raise exc
# Something else might have happened
raise exc_class(f"{error_type}: {error_message}")
# normal path
return req_data.get("result")
def shutdown(self) -> None:
"""Shutdowns the worker process and listener thread."""
if self._shutdown_event.is_set():
logger.debug("WCSManager is already set to shut down")
return
logger.info("Shutting down WCSManager...")
self._shutdown_event.set()
logger.debug("Stopping worker process and threads")
self._stop_worker()
if self._response_listener_thread and self._response_listener_thread.is_alive():
self._response_listener_thread.join(timeout=2.0)
logger.info("WCSManager shut down complete")
def _atexit_shutdown(self) -> None:
"""Shutdown handler for atexit to ensure cleanup on normal interpreter exit."""
if not self._shutdown_event.is_set():
logger.info("WCSManager: atexit triggered shutdown")
self.shutdown()
def associate_color_profile_with_device(
self, scope: WCS_PROF_SCOPE, profile_name: str, device_key: str
) -> None:
"""Associate a specified WCS color profile with a specified device.
This API does not support "advanced color" profiles for HDR monitors.
Note: this API makes the added profile also be the default one.
Args:
scope (WCS_PROF_SCOPE): specifies the scope of this profile management
operation, which could be system-wide or for the current user.
profile_name (str): file name of the profile to associate.
device_key (str): device key of the device with which to associate
the profile.
Raises:
OSError: in case of Win API errors.
TimeoutError: if timeout occurs while waiting for worker response.
WCSManagerShutdownError: if manager is shutting down.
WCSWorkerError: in case of some unspecified error during remote execution.
RuntimeError: in case of unrecoverable IPC errors.
"""
self._call_wcs_method(
"AssociateColorProfileWithDevice", scope, profile_name, device_key
)
def disassociate_color_profile_from_device(
self, scope: WCS_PROF_SCOPE, profile_name: str, device_key: str
) -> None:
"""Disassociate a specified WCS color profile from a specified device.
This API does not support "advanced color" profiles for HDR monitors.
Note: very unreliable due to quirks, the actual result should be
double-checked with profile listing.
Args:
scope (WCS_PROF_SCOPE): specifies the scope of this profile
management operation, which could be system-wide or for the
current user.
profile_name (str): file name of the profile to disassociate.
device_key (str): device key of the device from which to
disassociate the profile.
Raises:
OSError: in case of Win API errors.
TimeoutError: if timeout occurs while waiting for worker response.
WCSManagerShutdownError: if manager is shutting down.
WCSWorkerError: in case of some unspecified error during remote execution.
RuntimeError: in case of unrecoverable IPC errors.
"""
self._call_wcs_method(
"DisassociateColorProfileFromDevice", scope, profile_name, device_key
)
def get_device_color_profile_list(
self,
scope: WCS_PROF_SCOPE,
device_key: str,
device_class: dwDeviceClass = dwDeviceClass.CLASS_MONITOR,
) -> list[str]:
"""Enumerate color profiles associated with a device.
This API does not support "advanced color" profiles for HDR monitors.
Args:
scope (WCS_PROF_SCOPE): specifies the scope of this profile
management operation, which could be system-wide or for the
current user.
device_key (str): device key of the device.
device_class (dwDeviceClass, optional): device class. Defaults to
dwDeviceClass.CLASS_MONITOR.
Raises:
OSError: in case of Win API errors.l
TimeoutError: if timeout occurs while waiting for worker response.
WCSManagerShutdownError: if manager is shutting down.
WCSWorkerError: in case of some unspecified error during remote execution.
RuntimeError: in case of unrecoverable IPC errors.
ValueError: on parsing errors.
Returns:
list[str]: array of profile names
"""
prof_list: list[str] = self._call_wcs_method(
"getDeviceColorProfileList", scope, device_key, device_class
)
return prof_list
def get_calibration_management_state(self) -> bool:
"""Determine if system management of the display calibration state is enabled.
Raises:
OSError: in case of Win API errors.
TimeoutError: if timeout occurs while waiting for worker response.
WCSManagerShutdownError: if manager is shutting down.
WCSWorkerError: in case of some unspecified error during remote execution.
RuntimeError: in case of unrecoverable IPC errors.
Returns:
bool: True if system management of the display calibration state is
enabled; otherwise, False
"""
return self._call_wcs_method("GetCalibrationManagementState")
def set_calibration_management_state(self, new_state: bool) -> None:
"""Enable or disables system management of the display calibration state.
Args:
new_state (bool): True to enable system management of the display
calibration state. False to disable it.
Raises:
OSError: in case of Win API errors.
TimeoutError: if timeout occurs while waiting for worker response.
WCSManagerShutdownError: if manager is shutting down.
WCSWorkerError: in case of some unspecified error during remote execution.
RuntimeError: in case of unrecoverable IPC errors.
"""
return self._call_wcs_method("SetCalibrationManagementState", new_state)
def get_default_color_profile(
self,
scope: WCS_PROF_SCOPE,
device_key: str,
c_prof_type: COLORPROFILETYPE = COLORPROFILETYPE.CPT_ICC,
c_prof_subtype: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE.CPST_NONE,
profile_id: int = 0,
) -> None | str:
"""Retrieve the default color profile for a device.
This API does not support "advanced color" profiles for HDR monitors.
Note: If HDR is enabled on a device, it causes OSError.
Args:
scope (WCS_PROF_SCOPE): specifies the scope of this profile
management operation, which could be system-wide or for the
current user.
device_key (str): device key of the device for which the default
color profile is obtained. If empty string, a device-independent
default is obtained.
c_prof_type (COLORPROFILETYPE, optional): value specifying the
color profile type. Defaults to `COLORPROFILETYPE.CPT_ICC`.
c_prof_subtype (COLORPROFILESUBTYPE, optional): Value specifying
the color profile subtype. Defaults to `COLORPROFILESUBTYPE.CPST_NONE`.
profile_id (int, optional): ID of the color space that the color
profile represents. Defaults to 0.
Raises:
OSError: If a Win API error occurs.
TimeoutError: If a timeout occurs while waiting for worker response.
WCSManagerShutdownError: If the manager is shutting down.
WCSWorkerError: In case of some unspecified error during remote execution.
RuntimeError: If unrecoverable IPC errors occur.
Returns:
str: the name of the default color profile for the device (or None
if not set)
"""
try:
size = self._call_wcs_method(
"GetDefaultColorProfileSize",
scope,
device_key,
c_prof_type,
c_prof_subtype,
profile_id,
)
return self._call_wcs_method(
"GetDefaultColorProfile",
scope,
device_key,
size,
c_prof_type,
c_prof_subtype,
profile_id,
)
except FileNotFoundError: # no default profile
pass
return None
def set_default_color_profile(
self,
scope: WCS_PROF_SCOPE,
device_key: str,
profile_name: str,
c_prof_type: COLORPROFILETYPE = COLORPROFILETYPE.CPT_ICC,
c_prof_subtype: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE.CPST_NONE,
profile_id: int = 0,
) -> None:
"""Set the default color profile name for the specified profile type.
This API does not support "advanced color" profiles for HDR monitors.
Args:
scope (WCS_PROF_SCOPE): Specifies the scope of this profile management
operation, which could be system-wide or for the current user.
device_key (str): Device key of the device for which the default
color profile is to be set. If empty string, a device-independent
default profile is set.
profile_name (str): File name of the profile.
c_prof_type (COLORPROFILETYPE, optional): Value specifying the color
profile type. Defaults to `COLORPROFILETYPE.CPT_ICC`.
c_prof_subtype (COLORPROFILESUBTYPE, optional): Value specifying
the color profile subtype. Defaults to
`COLORPROFILESUBTYPE.CPST_NONE`.
profile_id (int, optional): ID of the color space that the color
profile represents. Defaults to 0.
Raises:
OSError: If Win API error is raised.
TimeoutError: If timeout occurs while waiting for worker response.
WCSManagerShutdownError: If manager is shutting down.
WCSWorkerError: If some unspecified error occurs during remote execution.
RuntimeError: If unrecoverable IPC errors occur.
"""
self._call_wcs_method(
"SetDefaultColorProfile",
scope,
device_key,
profile_name,
c_prof_type,
c_prof_subtype,
profile_id,
)
def get_use_per_user_profiles(
self, device_key: str, device_class: dwDeviceClass = dwDeviceClass.CLASS_MONITOR
) -> bool:
"""Determine if per-user profile association is enabled for the device.
Args:
device_key (str): Device key of the device.
device_class (dwDeviceClass, optional): The class of the device.
Defaults to `dwDeviceClass.CLASS_MONITOR`.
Raises:
OSError: If Win API error is raised.
TimeoutError: If timeout occurs while waiting for worker response.
WCSManagerShutdownError: If manager is shutting down.
WCSWorkerError: If some unspecified error occurs during remote execution.
RuntimeError: If unrecoverable IPC errors occur.
Returns:
bool: True if the user chose to use a per-user profile association
list for the specified device; otherwise False
"""
return self._call_wcs_method("GetUsePerUserProfiles", device_key, device_class)
def set_use_per_user_profiles(
self,
device_key: str,
new_state: bool,
device_class: dwDeviceClass = dwDeviceClass.CLASS_MONITOR,
) -> None:
"""Enable or disable per-user profile association for a device.
Args:
device_key (str): Device key of the device.
new_state (bool): True if the user wants to use a per-user profile
association list for the specified device; otherwise False.
device_class (dwDeviceClass, optional): The class of the device.
Defaults to dwDeviceClass.CLASS_MONITOR
Raises:
OSError: If Win API error is raised.
TimeoutError: If timeout occurs while waiting for worker response.
WCSManagerShutdownError: If manager is shutting down.
WCSWorkerError: If some unspecified error occurs during remote execution.
RuntimeError: If unrecoverable IPC errors occur.
"""
self._call_wcs_method(
"SetUsePerUserProfiles", device_key, new_state, device_class
)
class WCSManagerProxy:
"""Proxy class for WCSManager to ensure single instance and lazy initialization."""
_instance = None
_lock = Lock()
def _ensure_instance(self) -> None:
"""Ensure that the WCSManager instance is created."""
if WCSManagerProxy._instance is None:
with WCSManagerProxy._lock:
if WCSManagerProxy._instance is None:
WCSManagerProxy._instance = WCSManager()
def __getattr__(self, name: str) -> Any: # noqa: ANN401
"""Ensure instance exists before getting attributes."""
self._ensure_instance()
return getattr(WCSManagerProxy._instance, name)
def __setattr__(self, name: str, value: Any) -> None: # noqa: ANN401
"""Ensure instance exists before setting attributes."""
self._ensure_instance()
setattr(WCSManagerProxy._instance, name, value)
def __delattr__(self, name: str) -> None:
"""Ensure instance exists before deleting attributes."""
self._ensure_instance()
delattr(WCSManagerProxy._instance, name)
def __call__(self, *args, **kwargs) -> WCSManager:
"""Make the proxy callable."""
self._ensure_instance()
if callable(WCSManagerProxy._instance):
return WCSManagerProxy._instance(*args, **kwargs)
raise TypeError(
f"'{type(WCSManagerProxy._instance).__name__}' object is not callable"
)
def __repr__(self) -> str:
"""String representation of the proxy instance."""
if WCSManagerProxy._instance is None:
return ""
return f""
displaycal-py3-3.9.19/DisplayCAL/mscms_types.py 000664 000000 000000 00000004012 15225167330 021301 0 ustar 00root root 000000 000000 """Classes for the various enums used in the Windows Color System API.
There are also some helper functions to convert between enum values and their
string representations.
"""
from enum import IntEnum, IntFlag, auto
class dwDeviceClass(IntEnum): # noqa: N801
"""Available device classes to be used in the dwDeviceClass field."""
CLASS_SCANNER = int.from_bytes(b"scnr", byteorder="big")
CLASS_MONITOR = int.from_bytes(b"mntr", byteorder="big")
CLASS_PRINTER = int.from_bytes(b"prtr", byteorder="big")
class dwFieldsUsed(IntFlag): # noqa: N801
"""Available fields to be used in the ENUMTYPEW structure."""
ET_DEVICENAME = 0x00000001
ET_MEDIATYPE = 0x00000002
ET_DITHERMODE = 0x00000004
ET_RESOLUTION = 0x00000008
ET_CMMTYPE = 0x00000010
ET_CLASS = 0x00000020
ET_DATACOLORSPACE = 0x00000040
ET_CONNECTIONSPACE = 0x00000080
ET_SIGNATURE = 0x00000100
ET_PLATFORM = 0x00000200
ET_PROFILEFLAGS = 0x00000400
ET_MANUFACTURER = 0x00000800
ET_MODEL = 0x00001000
ET_ATTRIBUTES = 0x00002000
ET_RENDERINGINTENT = 0x00004000
ET_CREATOR = 0x00008000
ET_DEVICECLASS = 0x00010000
class WCS_PROF_SCOPE(IntEnum): # noqa: N801
"""Available profile scopes to be used in the WCS API."""
SYSTEM_WIDE = 0
CURRENT_USER = 1
class COLORPROFILETYPE(IntEnum):
"""Available color profile types to be used in the COLORPROFILETYPE field."""
CPT_ICC = 0
CPT_DMP = auto()
CPT_CAMP = auto()
CPT_GMMP = auto()
class COLORPROFILESUBTYPE(IntEnum):
"""Available color profile subtypes to be used in the COLORPROFILESUBTYPE field."""
# intent
CPST_PERCEPTUAL = 0
CPST_RELATIVE_COLORIMETRIC = auto()
CPST_SATURATION = auto()
CPST_ABSOLUTE_COLORIMETRIC = auto()
# working space
CPST_NONE = auto() # makes the API deduct profile subtype from the profile itself
CPST_RGB_WORKING_SPACE = auto()
CPST_CUSTOM_WORKING_SPACE = auto()
CPST_STANDARD_DISPLAY_COLOR_MODE = auto()
CPST_EXTENDED_DISPLAY_COLOR_MODE = auto()
displaycal-py3-3.9.19/DisplayCAL/mscms_wrapper.py 000664 000000 000000 00000057222 15225167330 021630 0 ustar 00root root 000000 000000 """Wrapper for WCS API calls."""
from __future__ import annotations
import ctypes
import sys
from ctypes import (
POINTER,
WINFUNCTYPE,
Structure,
WinError,
c_wchar_p,
create_unicode_buffer,
wstring_at,
)
from ctypes.wintypes import BOOL, DWORD, LPWSTR
from typing import Any, Callable
if sys.version_info >= (3, 11):
from typing import Self
else:
from typing_extensions import Self
from DisplayCAL.mscms_types import (
COLORPROFILESUBTYPE,
COLORPROFILETYPE,
WCS_PROF_SCOPE,
dwDeviceClass,
dwFieldsUsed,
)
# mscms calls used:
# + WcsAssociateColorProfileWithDevice
# + WcsDisassociateColorProfileFromDevice
# + WcsEnumColorProfiles
# + WcsEnumColorProfilesSize
# + WcsGetCalibrationManagementState
# + WcsSetCalibrationManagementState
# + WcsGetDefaultColorProfile (leaks)
# + WcsGetDefaultColorProfileSize (leaks)
# + WcsGetUsePerUserProfiles (leaks)
# + WcsSetUsePerUserProfiles
dwResolutionArray = DWORD * 2 # noqa: N816
dwAttributesArray = DWORD * 2 # noqa: N816
WCS_PROF_SCOPE_t = DWORD
COLORPROFILETYPE_t = DWORD
COLORPROFILESUBTYPE_t = DWORD
PCWSTR = c_wchar_p
ENUM_TYPE_VERSION = DWORD(0x0300) # Profile enumeration marker
WIN_ERRNO_SUCCESS = 0
WIN_ERRNO_PROFILE_NOT_ASSOCIATED = 2015
class ENUMTYPEW(Structure):
"""The ENUMTYPEW structure specifies the criteria for enumerating color profiles."""
_fields_ = [
("dwSize", DWORD), # size of structure
("dwVersion", DWORD), # should be equal to ENUM_TYPE_VERSION
(
"dwFields",
DWORD,
), # indicates which fields in this structure are being used.
# Can be set to any combination of the dwFieldsUsed enum.
("pDeviceName", LPWSTR),
("dwMediaType", DWORD),
("dwDitheringMode", DWORD),
("dwResolution", dwResolutionArray),
("dwCMMType", DWORD),
("dwClass", DWORD),
("dwDataColorSpace", DWORD),
("dwConnectionSpace", DWORD),
("dwSignature", DWORD),
("dwPlatform", DWORD),
("dwProfileFlags", DWORD),
("dwManufacturer", DWORD),
("dwModel", DWORD),
("dwAttributes", dwAttributesArray),
("dwRenderingIntent", DWORD),
("dwCreator", DWORD),
("dwDeviceClass", DWORD),
]
def __init__(self) -> None:
self.dwSize = ctypes.sizeof(ENUMTYPEW)
self.dwVersion = ENUM_TYPE_VERSION
@classmethod
def create_monitor_profile_filter(
cls, device_key: str, device_class: dwDeviceClass = dwDeviceClass.CLASS_MONITOR
) -> Self:
"""Create an ENUMTYPEW structure for monitor profile filtering.
This is used for profile enumeration for a monitor device.
Args:
device_key (str): Device key of the monitor device for which to
filter.
device_class (dwDeviceClass, optional): The class of the device.
Defaults to dwDeviceClass.CLASS_MONITOR.
Returns:
ENUMTYPEW: An initialized ENUMTYPEW structure for monitor profile
filtering.
"""
enum_desc = cls()
enum_desc.dwDeviceClass = device_class
enum_desc.pDeviceName = device_key
enum_desc.dwFields = dwFieldsUsed.ET_DEVICECLASS | dwFieldsUsed.ET_DEVICENAME
return enum_desc
def _errcheck_simple_bool(result: Any, func: Callable[..., Any], args: Any) -> Any: # noqa: ANN401
if not result:
raise WinError()
return result
def _errcheck_args_ret(result: Any, func: Callable[..., Any], args: Any) -> Any: # noqa: ANN401
errno = ctypes.GetLastError()
if not result and errno != WIN_ERRNO_SUCCESS:
raise WinError(errno)
return args
def _wrap_wcsAssociateColorProfileWithDevice() -> Callable[..., Any]: # noqa: ANN401, N802
proto = WINFUNCTYPE(BOOL, WCS_PROF_SCOPE_t, LPWSTR, LPWSTR)
paramflags = (
(1, "scope"),
(1, "pProfileName"),
(1, "pDeviceName"),
)
associate_color_profile_with_device = proto(
("WcsAssociateColorProfileWithDevice", ctypes.windll.mscms),
paramflags,
)
associate_color_profile_with_device.errcheck = _errcheck_simple_bool
return associate_color_profile_with_device
def _wrap_wcsDisassociateColorProfileFromDevice() -> Callable[..., Any]: # noqa: N802
proto = WINFUNCTYPE(BOOL, WCS_PROF_SCOPE_t, LPWSTR, LPWSTR)
paramflags = (
(1, "scope"),
(1, "pProfileName"),
(1, "pDeviceName"),
)
disassociate_color_profile_from_device = proto(
("WcsDisassociateColorProfileFromDevice", ctypes.windll.mscms),
paramflags,
)
disassociate_color_profile_from_device.errcheck = _errcheck_simple_bool
return disassociate_color_profile_from_device
def _wrap_wcsEnumColorProfiles() -> Callable[..., Any]: # noqa: N802
proto = WINFUNCTYPE(
BOOL, WCS_PROF_SCOPE_t, POINTER(ENUMTYPEW), LPWSTR, DWORD, POINTER(DWORD)
)
paramflags = (
(1, "scope"),
(1, "pEnumRecord"),
(3, "pBuffer"),
(1, "dwSize"),
(2, "pnProfiles", DWORD(0)),
)
enum_color_profiles = proto(
("WcsEnumColorProfiles", ctypes.windll.mscms), paramflags
)
enum_color_profiles.errcheck = _errcheck_args_ret
return enum_color_profiles
def _wrap_wcsEnumColorProfilesSize() -> Callable[..., Any]: # noqa: N802
proto = WINFUNCTYPE(BOOL, WCS_PROF_SCOPE_t, POINTER(ENUMTYPEW), POINTER(DWORD))
paramflags = (
(1, "scope"),
(1, "pEnumRecord"),
(2, "pdwSize", DWORD(0)),
)
get_enum_color_profiles_size = proto(
("WcsEnumColorProfilesSize", ctypes.windll.mscms), paramflags
)
get_enum_color_profiles_size.errcheck = _errcheck_args_ret
return get_enum_color_profiles_size
def _wrap_wcsGetCalibrationManagementState() -> Callable[..., Any]: # noqa: N802
proto = WINFUNCTYPE(BOOL, POINTER(BOOL))
paramflags = ((2, "pbIsEnabled", BOOL(False)),)
get_calibration_management_state = proto(
("WcsGetCalibrationManagementState", ctypes.windll.mscms),
paramflags,
)
get_calibration_management_state.errcheck = _errcheck_args_ret
return get_calibration_management_state
def _wrap_wcsSetCalibrationManagementState() -> Callable[..., Any]: # noqa: N802
proto = WINFUNCTYPE(BOOL, BOOL)
paramflags = ((1, "pbIsEnabled"),)
set_calibration_management_state = proto(
("WcsSetCalibrationManagementState", ctypes.windll.mscms),
paramflags,
)
set_calibration_management_state.errcheck = _errcheck_simple_bool
return set_calibration_management_state
def _wrap_wcsGetDefaultColorProfile() -> Callable[..., Any]: # noqa: N802
proto = WINFUNCTYPE(
BOOL,
WCS_PROF_SCOPE_t,
PCWSTR,
COLORPROFILETYPE_t,
COLORPROFILESUBTYPE_t,
DWORD,
DWORD,
LPWSTR,
)
paramflags = (
(1, "scope"),
(1, "pDeviceName"),
(1, "cptColorProfileType"),
(1, "cpstColorProfileSubType"),
(1, "dwProfileID"),
(1, "cbProfileName"),
(3, "pProfileName"),
)
get_default_color_profile = proto(
("WcsGetDefaultColorProfile", ctypes.windll.mscms), paramflags
)
get_default_color_profile.errcheck = _errcheck_args_ret
return get_default_color_profile
def _wrap_wcsGetDefaultColorProfileSize() -> Callable[..., Any]: # noqa: N802
proto = WINFUNCTYPE(
BOOL,
WCS_PROF_SCOPE_t,
PCWSTR,
COLORPROFILETYPE_t,
COLORPROFILESUBTYPE_t,
DWORD,
POINTER(DWORD),
)
paramflags = (
(1, "scope"),
(1, "pDeviceName"),
(1, "cptColorProfileType"),
(1, "cpstColorProfileSubType"),
(1, "dwProfileID"),
(2, "pcbProfileName", DWORD(0)),
)
get_default_color_profile_size = proto(
("WcsGetDefaultColorProfileSize", ctypes.windll.mscms),
paramflags,
)
get_default_color_profile_size.errcheck = _errcheck_args_ret
return get_default_color_profile_size
def _wrap_wcsSetDefaultColorProfile() -> Callable[..., Any]: # noqa: N802
proto = WINFUNCTYPE(
BOOL,
WCS_PROF_SCOPE_t,
PCWSTR,
COLORPROFILETYPE_t,
COLORPROFILESUBTYPE_t,
DWORD,
LPWSTR,
)
paramflags = (
(1, "scope"),
(1, "pDeviceName"),
(1, "cptColorProfileType"),
(1, "cpstColorProfileSubType"),
(1, "dwProfileID"),
(1, "pProfileName"),
)
set_default_color_profile = proto(
("WcsSetDefaultColorProfile", ctypes.windll.mscms), paramflags
)
set_default_color_profile.errcheck = _errcheck_simple_bool
return set_default_color_profile
def _wrap_wcsGetUsePerUserProfiles() -> Callable[..., Any]: # noqa: N802
proto = WINFUNCTYPE(BOOL, LPWSTR, DWORD, POINTER(BOOL))
paramflags = (
(1, "pDeviceName"),
(1, "dwDeviceClass"),
(2, "pUsePerUserProfiles", BOOL(False)),
)
get_use_per_user_profiles = proto(
("WcsGetUsePerUserProfiles", ctypes.windll.mscms),
paramflags,
)
get_use_per_user_profiles.errcheck = _errcheck_args_ret
return get_use_per_user_profiles
def _wrap_wcsSetUsePerUserProfiles() -> Callable[..., Any]: # noqa: N802
set_use_per_user_proto = WINFUNCTYPE(BOOL, LPWSTR, DWORD, BOOL)
set_use_per_user_paramflags = (
(1, "pDeviceName"),
(1, "dwDeviceClass"),
(1, "pUsePerUserProfiles"),
)
set_use_per_user_profiles = set_use_per_user_proto(
("WcsSetUsePerUserProfiles", ctypes.windll.mscms),
set_use_per_user_paramflags,
)
set_use_per_user_profiles.errcheck = _errcheck_simple_bool
return set_use_per_user_profiles
class WCS:
"""Wrapper for WCS API calls."""
def __init__(self) -> None:
self._wcsAssociateColorProfileWithDevice = (
_wrap_wcsAssociateColorProfileWithDevice()
)
self._wcsDisassociateColorProfileFromDevice = (
_wrap_wcsDisassociateColorProfileFromDevice()
)
self._wcsEnumColorProfiles = _wrap_wcsEnumColorProfiles()
self._wcsEnumColorProfilesSize = _wrap_wcsEnumColorProfilesSize()
self._wcsGetCalibrationManagementState = (
_wrap_wcsGetCalibrationManagementState()
)
self._wcsSetCalibrationManagementState = (
_wrap_wcsSetCalibrationManagementState()
)
self._wcsGetDefaultColorProfile = _wrap_wcsGetDefaultColorProfile()
self._wcsGetDefaultColorProfileSize = _wrap_wcsGetDefaultColorProfileSize()
self._wcsSetDefaultColorProfile = _wrap_wcsSetDefaultColorProfile()
self._wcsGetUsePerUserProfiles = _wrap_wcsGetUsePerUserProfiles()
self._wcsSetUsePerUserProfiles = _wrap_wcsSetUsePerUserProfiles()
def AssociateColorProfileWithDevice( # noqa: N802
self, scope: WCS_PROF_SCOPE, profile_name: str, device_key: str
) -> None:
"""Associate a specified WCS color profile with a specified device.
This API does not support "advanced color" profiles for HDR monitors
Note: this API makes the added profile also be the default one
Args:
scope (WCS_PROF_SCOPE): The scope of this profile management
operation, which could be system-wide or for the current user.
profile_name (str): File name of the profile to associate.
device_key (str): Device key of the device with which to
associate the profile.
Raises:
OSError: If a Win API error occurs.
"""
self._wcsAssociateColorProfileWithDevice(scope, profile_name, device_key)
def DisassociateColorProfileFromDevice( # noqa: N802
self, scope: WCS_PROF_SCOPE, profile_name: str, device_key: str
) -> None:
"""Disassociate a specified WCS color profile from a specified device.
This API does not support "advanced color" profiles for HDR monitors.
Note: very unreliable due to quirks, the actual result should be
double-checked with profile listing
Args:
scope (WCS_PROF_SCOPE): The scope of this profile management
operation, which could be system-wide or for the current user.
profile_name (str): File name of the profile to disassociate.
device_key (str): Device key of the device from which to
disassociate the profile.
Raises:
OSError: If a Win API error occurs (apart from the ones caught
during handling its quirks).
"""
try:
self._wcsDisassociateColorProfileFromDevice(scope, profile_name, device_key)
except OSError as e:
# quirks: very very quirky: either returns error with errno success
# or errno profile not associated with device. Why? Because Windows,
# that's why.
if e.winerror not in (WIN_ERRNO_SUCCESS, WIN_ERRNO_PROFILE_NOT_ASSOCIATED):
raise
def EnumColorProfiles( # noqa: N802
self, scope: WCS_PROF_SCOPE, enum_record: ENUMTYPEW, prof_size: int
) -> list[str]:
"""Enumerate color profiles associated with any device, in the specified scope.
This API does not support "advanced color" profiles for HDR monitors
Args:
scope (WCS_PROF_SCOPE): The scope of this profile management
operation, which could be system-wide or for the current user.
enum_record (ENUMTYPEW): Structure specifying the enumeration
criteria.
prof_size (int): Size, in bytes, of the buffer that is needed to
enumerate color profiles.
Raises:
ValueError: On parsing errors.
OSError: If a Win API error occurs.
Returns:
list[str]: Array of profile names.
"""
wchar_size = ctypes.sizeof(ctypes.c_wchar)
char_count = max(1, (prof_size + wchar_size - 1) // wchar_size)
buf = create_unicode_buffer(char_count)
profiles, p_num = self._wcsEnumColorProfiles(scope, enum_record, buf, prof_size)
if p_num == 0:
return []
prof_arr = wstring_at(profiles, char_count).strip("\x00").split("\x00")
if len(prof_arr) != p_num:
raise ValueError(
"Parsing error: profile number mismatch: "
f"reported {p_num} != {len(prof_arr)} got"
)
return prof_arr
def EnumColorProfilesSize( # noqa: N802
self, scope: WCS_PROF_SCOPE, enum_record: ENUMTYPEW
) -> int:
"""Get the size in bytes of the buffer needed to enumerate color profiles.
This API does not support "advanced color" profiles for HDR monitors
Args:
scope (WCS_PROF_SCOPE): The scope of this profile management
operation, which could be system-wide or for the current user.
enum_record (ENUMTYPEW): Structure specifying the enumeration criteria.
Raises:
OSError: In case of Win API errors.
Returns:
int: Size, in bytes, of the buffer that is needed to enumerate
color profiles.
"""
return self._wcsEnumColorProfilesSize(scope, enum_record)
def GetCalibrationManagementState(self) -> bool: # noqa: N802
"""Check if system management of the display calibration state is enabled.
Raises:
OSError: If a Win API error occurs.
Returns:
bool: True if system management of the display calibration state is
enabled; otherwise False.
"""
return bool(self._wcsGetCalibrationManagementState())
def SetCalibrationManagementState(self, new_state: bool) -> None: # noqa: N802
"""Enable or disable system management of the display calibration state.
Args:
new_state (bool): True to enable system management of the display
calibration state. False to disable system management of the
display calibration state.
Raises:
OSError: If a Win API error occurs.
"""
self._wcsSetCalibrationManagementState(new_state)
def GetDefaultColorProfile( # noqa: N802
self,
scope: WCS_PROF_SCOPE,
device_key: str,
prof_size: int,
c_prof_type: COLORPROFILETYPE = COLORPROFILETYPE.CPT_ICC,
c_prof_subtype: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE.CPST_NONE,
profile_id: int = 0,
) -> str:
"""Get the default color profile for a device.
This API does not support "advanced color" profiles for HDR monitors.
Note: if HDR enabled on a device causes OSError
Args:
scope (WCS_PROF_SCOPE): The scope of this profile management
operation, which could be system-wide or for the current user.
device_key (str): Device key of the device for which the default
color profile is obtained. If None, a device-independent
default profile is obtained.
prof_size (int): Size, in bytes, of the buffer that is sufficient
to contain the profile name.
c_prof_type (COLORPROFILETYPE, optional): Value specifying the
color profile type. Defaults to COLORPROFILETYPE.CPT_ICC.
c_prof_subtype (COLORPROFILESUBTYPE, optional): Value specifying
the color profile subtype. Defaults to
COLORPROFILESUBTYPE.CPST_NONE.
profile_id (int, optional): ID of the color space that the color
profile represents. Defaults to 0.
Raises:
OSError: In case of Win API errors.
Returns:
str: The name of the default color profile for a device.
"""
wchar_size = ctypes.sizeof(ctypes.c_wchar)
char_count = max(1, (prof_size + wchar_size - 1) // wchar_size)
buf = create_unicode_buffer(char_count)
self._wcsGetDefaultColorProfile(
scope, device_key, c_prof_type, c_prof_subtype, profile_id, prof_size, buf
)
return buf.value
def GetDefaultColorProfileSize( # noqa: N802
self,
scope: WCS_PROF_SCOPE,
device_key: str,
c_prof_type: COLORPROFILETYPE = COLORPROFILETYPE.CPT_ICC,
c_prof_subtype: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE.CPST_NONE,
profile_id: int = 0,
) -> int:
"""Get the size in bytes of the default color profile name for a device.
This API does not support "advanced color" profiles for HDR monitors.
Note: if HDR enabled on a device returns 0.
Args:
scope (WCS_PROF_SCOPE): The scope of this profile management
operation, which could be system-wide or for the current user.
device_key (str): Device key of the device for which the default
color profile is obtained. If None, a device-independent
default profile is obtained.
c_prof_type (COLORPROFILETYPE, optional): Value specifying the
color profile type. Defaults to COLORPROFILETYPE.CPT_ICC.
c_prof_subtype (COLORPROFILESUBTYPE, optional): Value specifying
the color profile subtype. Defaults to COLORPROFILESUBTYPE.CPST_NONE.
profile_id (int, optional): ID of the color space that the color
profile represents. Defaults to 0.
Raises:
OSError: If a Win API error occurs.
Returns:
int: size, in bytes, of the buffer that is sufficient to contain
profile name.
"""
return self._wcsGetDefaultColorProfileSize(
scope, device_key, c_prof_type, c_prof_subtype, profile_id
)
def SetDefaultColorProfile( # noqa: N802
self,
scope: WCS_PROF_SCOPE,
device_key: str,
profile_name: str,
c_prof_type: COLORPROFILETYPE = COLORPROFILETYPE.CPT_ICC,
c_prof_subtype: COLORPROFILESUBTYPE = COLORPROFILESUBTYPE.CPST_NONE,
profile_id: int = 0,
) -> None:
"""Set the default color profile for the specified device.
This API does not support "advanced color" profiles for HDR monitors.
Args:
scope (WCS_PROF_SCOPE): The scope of this profile management
operation, which could be system-wide or for the current user.
device_key (str): Device key of the device for which the default
color profile is to be set. If None, a device-independent
default profile is set.
profile_name (str): File name of the profile.
c_prof_type (COLORPROFILETYPE, optional): Value specifying the
color profile type. Defaults to COLORPROFILETYPE.CPT_ICC.
c_prof_subtype (COLORPROFILESUBTYPE, optional): Value specifying
the color profile subtype. Defaults to
COLORPROFILESUBTYPE.CPST_NONE.
profile_id (int, optional): ID of the color space that the color
profile represents. Defaults to 0.
Raises:
OSError: If a Win API error occurs.
"""
self._wcsSetDefaultColorProfile(
scope, device_key, c_prof_type, c_prof_subtype, profile_id, profile_name
)
def GetUsePerUserProfiles( # noqa: N802
self, device_key: str, device_class: dwDeviceClass = dwDeviceClass.CLASS_MONITOR
) -> bool:
"""Determine if per-user profile association is enabled for the device.
Args:
device_key (str): Device key of the device.
device_class (dwDeviceClass, optional): The class of the device.
Defaults to dwDeviceClass.CLASS_MONITOR.
Raises:
OSError: If a Win API error occurs.
Returns:
bool: True if the user chose to use a per-user profile association
list for the specified device; otherwise False
"""
return bool(self._wcsGetUsePerUserProfiles(device_key, device_class))
def SetUsePerUserProfiles( # noqa: N802
self,
device_key: str,
new_state: bool,
device_class: dwDeviceClass = dwDeviceClass.CLASS_MONITOR,
) -> None:
"""Enable or disable per-user profile association for the specified device.
Args:
device_key (str): Device key of the device.
new_state (bool): True if the user wants to use a per-user profile
association list for the specified device; otherwise False.
device_class (dwDeviceClass, optional): The class of the device.
Defaults to dwDeviceClass.CLASS_MONITOR.
Raises:
OSError: If a Win API error occurs.
"""
self._wcsSetUsePerUserProfiles(device_key, device_class, new_state)
def getDeviceColorProfileList( # noqa: N802
self,
scope: WCS_PROF_SCOPE,
device_key: str,
device_class: dwDeviceClass = dwDeviceClass.CLASS_MONITOR,
) -> list[str]:
"""Higher abstraction level function to get color profile list for a device.
Also dodges the issue with serialization of some ctypes structures in
multiprocess context.
Args:
scope (WCS_PROF_SCOPE): The scope of this profile management
operation, which could be system-wide or for the current user.
device_key (str): Device key of the device.
device_class (dwDeviceClass, optional): The class of the device.
Defaults to dwDeviceClass.CLASS_MONITOR.
Raises:
OSError: If a Win API error occurs.
ValueError: If a parsing error occurs.
Returns:
list[str]: array of color profile names
"""
enum_record = ENUMTYPEW.create_monitor_profile_filter(device_key)
size = self.EnumColorProfilesSize(scope, enum_record)
return self.EnumColorProfiles(scope, enum_record, size)
displaycal-py3-3.9.19/DisplayCAL/multiprocess.py 000664 000000 000000 00000060430 15225167330 021472 0 ustar 00root root 000000 000000 """Utilities for parallel processing with multiprocessing.
It includes functions and classes to manage worker pools, handle task
distribution, and process data slices efficiently.
"""
from __future__ import annotations
import contextlib
import errno
import logging
import math
import multiprocessing as mp
import multiprocessing.pool
import sys
import threading
from queue import Empty
from typing import TYPE_CHECKING, Any, Callable, TextIO
if TYPE_CHECKING:
from collections.abc import Iterable
# BUG #715 : Limiting the total workers/CPUs to 32
MAX_CPUS = 32
def cpu_count(limit_by_total_vmem: bool = True) -> int:
"""Return the number of CPUs in the system.
If psutil is installed, the number of reported CPUs is limited according to
total RAM by assuming 1 GB for each CPU + 1 GB for the system, unless
limit_by_total_vmem is False, to allow a reasonable amount of memory for
each CPU.
Return fallback value of 1 if CPU count cannot be determined.
Args:
limit_by_total_vmem (bool, optional): If True, limit the reported CPU
count according to total RAM. Defaults to True.
Returns:
int: The number of CPUs in the system, limited by total RAM if
specified.
"""
max_cpus = min(sys.maxsize, MAX_CPUS)
if limit_by_total_vmem:
try:
import psutil
except (ImportError, RuntimeError):
pass
else:
# Limit reported CPUs according to total RAM.
# We use total instead of available because we assume the system is
# smart enough to swap memory used by inactive processes to disk to
# free up more physical RAM for active processes.
with contextlib.suppress(Exception):
max_cpus = min(
int(psutil.virtual_memory().total / (1024**3) - 1), MAX_CPUS
)
try:
return max(min(mp.cpu_count(), max_cpus), 1)
except Exception:
return 1
def pool_slice(
func: Callable,
data_in: Iterable,
args: None | tuple = None,
kwds: None | dict = None,
num_workers: None | int = None,
thread_abort: None | threading.Thread = None,
logfile: None | TextIO = None,
num_batches: int = 1,
progress: float = 0,
) -> list:
"""Process data in slices using a pool of workers and return the results.
The individual worker results are returned in the same order as the
original input data, irrespective of the order in which the workers
finished (FIFO).
Progress percentage is written to optional logfile using a background
thread that monitors a queue.
Note that 'func' is supposed to periodically check thread_abort.event which
is passed as the first argument to 'func', and put its progress percentage
into the queue which is passed as the second argument to 'func'.
Args:
func (Callable): The function to be applied to each slice of data.
data_in (Iterable): The input data to be processed.
args (None | tuple, optional): Additional positional arguments to pass
to 'func'. Defaults to None.
kwds (None | dict, optional): Additional keyword arguments to pass to
'func'. Defaults to None.
num_workers (None | int, optional): The number of worker processes to
use. If None, it will be set to the number of CPUs in the system.
Defaults to None.
thread_abort (None | threading.Thread, optional): A thread with an
'event' attribute (threading.Event) that can be used to signal
abortion of processing. Defaults to None.
logfile (None | TextIO, optional): A file-like object to write progress
percentage to. If None, progress will not be logged. Defaults to
None.
num_batches (int, optional): The number of batches to split the work
into. This can be used to limit memory usage when processing a
large amount of data. Defaults to 1.
progress (float, optional): Initial progress percentage. Defaults to
0.
Returns:
list: A list of results from processing each slice of data.
"""
if args is None:
args = ()
if kwds is None:
kwds = {}
num_workers, num_batches, chunk_size = determine_worker_count(
data_in, num_workers, num_batches
)
pool_class, manager, event, thread_abort_event, progress_queue = (
initialize_pool_manager(num_workers, thread_abort)
)
# don't remove "_thread" to keep the thread alive to log the progress.
_thread = start_progress_logging(
num_workers,
num_batches,
progress,
progress_queue,
logfile,
)
pool, results = execute_worker_pool(
func,
data_in,
args,
kwds,
num_workers,
num_batches,
chunk_size,
pool_class,
thread_abort_event,
progress_queue,
)
return get_results(results, pool, manager, event, thread_abort)
def determine_worker_count(
data_in: Iterable,
num_workers: None | int,
num_batches: int,
) -> tuple[int, int, float]:
"""Determine the number of workers, batches, and chunk size.
Args:
data_in (Iterable): The input data to be processed.
num_workers (None | int): The number of worker processes to use.
If None, it will be set to the number of CPUs in the system.
num_batches (int): The number of batches to split the work into.
Returns:
tuple[int, int, float]: A tuple containing:
- The number of worker processes to use.
- The number of batches to split the work into.
- The size of each chunk to process.
"""
from DisplayCAL.config import getcfg
num_workers = cpu_count() if num_workers is None else min(num_workers, MAX_CPUS)
num_workers = max(min(int(num_workers), len(data_in)), 1)
max_workers = getcfg("multiprocessing.max_cpus")
num_workers = min(num_workers, max_workers) if max_workers else num_workers
# Splitting the workload into batches only makes sense if there are
# multiple workers
num_batches = 1 if (num_workers == 1 or not num_batches) else num_workers
chunk_size = float(len(data_in)) / (num_workers * num_batches)
if chunk_size < 1:
num_batches = 1
chunk_size = float(len(data_in)) / num_workers
return num_workers, num_batches, chunk_size
def initialize_pool_manager(
num_workers: int,
thread_abort: None | threading.Thread,
) -> tuple[
type,
None | mp.Manager,
None | threading.Event,
None | threading.Event,
mp.Queue,
]:
"""Initialize the worker pool and manager for inter-process communication.
Args:
num_workers (int): The number of worker processes to use.
thread_abort (None | threading.Thread): A thread with an 'event'
attribute (threading.Event) that can be used to signal abortion
of processing. Defaults to None.
Returns:
tuple[
type,
None | multiprocessing.Manager,
None | threading.Event,
None | threading.Event,
multiprocessing.Queue
]: A tuple containing:
- The class to use for the worker pool.
- The manager for inter-process communication, or None if not used.
- The original event from thread_abort, or None if not used.
- The event to signal thread abort, or None if not used.
- The queue to send progress updates.
"""
# Do it all in in the main thread of the current instance, by default
pool_class = FakePool
manager = None
event = None
queue_class = FakeQueue
if num_workers > 1:
pool_class = NonDaemonicPool
manager = mp.Manager()
if thread_abort is not None and not isinstance(
thread_abort.event, mp.managers.EventProxy
):
# Replace the event with a managed instance that is compatible
# with pool
event = thread_abort.event
thread_abort.event = manager.Event()
if event.is_set():
thread_abort.event.set()
else:
event = None
queue_class = manager.Queue
thread_abort_event = thread_abort.event if thread_abort is not None else None
progress_queue = queue_class()
return pool_class, manager, event, thread_abort_event, progress_queue
def start_progress_logging(
num_workers: int,
num_batches: int,
progress: float,
progress_queue: mp.Queue,
logfile: None | TextIO,
) -> None | threading.Thread:
"""Start a background thread to log progress percentage to logfile.
Args:
num_workers (int): Number of worker processes.
num_batches (int): The number of batches to split the work into.
progress (float): Initial progress percentage.
progress_queue (mp.Queue): Queue to send progress updates.
logfile (None | TextIO): A file-like object to write progress
percentage to. If None, progress will not be logged.
Returns:
None | threading.Thread: The thread that logs progress, or None if
logfile is None.
"""
if not logfile:
return None
def progress_logger(num_workers: int, progress: float = 0.0) -> None:
"""Log progress percentage to logfile.
Args:
num_workers (int): Number of worker processes.
progress (float, optional): Initial progress percentage.
Defaults to 0.0.
"""
eof_count = 0
prevperc = -1
while progress < 100 * num_workers:
try:
inc = progress_queue.get(True, 0.1)
if isinstance(inc, Exception):
raise inc
progress += inc
except Empty:
continue
except OSError:
break
except EOFError:
eof_count += 1
if eof_count == num_workers:
break
perc = round(progress / num_workers)
if perc > prevperc:
logfile.write(f"\r{perc}%")
prevperc = perc
thread = threading.Thread(
target=progress_logger,
args=(num_workers * num_batches, progress * num_workers * num_batches),
name="ProcessProgressLogger",
group=None,
)
thread.start()
return thread
def execute_worker_pool(
func: Callable,
data_in: Iterable,
args: tuple,
kwds: dict,
num_workers: int,
num_batches: int,
chunk_size: float,
poll_class: type,
thread_abort_event: threading.Event,
progress_queue: mp.Queue,
) -> tuple[NonDaemonicPool | FakePool, list]:
"""Execute worker pool to process data slices.
Args:
func (Callable): The function to be applied to each slice of data.
data_in (Iterable): The input data to be processed.
args (tuple): Additional positional arguments to pass to 'func'.
kwds (dict): Additional keyword arguments to pass to 'func'.
num_workers (int): The number of worker processes to use.
num_batches (int): The number of batches to split the work into.
chunk_size (float): The size of each chunk to process.
poll_class (type): The class to use for the worker pool.
thread_abort_event (threading.Event): Event to signal thread abort.
progress_queue (mp.Queue): Queue to send progress updates.
Returns:
tuple[NonDaemonicPool | FakePool, list]: The worker pool and a list of
results from processing each slice of data.
"""
pool = poll_class(num_workers)
results = []
start = 0
for batch in range(num_batches):
for i in range(batch * num_workers, (batch + 1) * num_workers):
end = math.ceil(chunk_size * (i + 1))
results.append(
pool.apply_async(
WorkerFunc(func, batch == num_batches - 1),
(data_in[start:end], thread_abort_event, progress_queue, *args),
kwds,
)
)
start = end
return pool, results
def get_results(
results: list,
pool: NonDaemonicPool | FakePool,
manager: None | multiprocessing.Manager,
event: None | threading.Event,
thread_abort: None | threading.Thread,
) -> list:
"""Get results from worker pool and clean up resources.
Args:
results (list): List of results from worker pool.
pool (NonDaemonicPool | FakePool): The worker pool.
manager (None | multiprocessing.Manager): The manager used for
inter-process communication.
event (None | threading.Event): The original event from thread_abort.
thread_abort (None | threading.Thread): The thread with the event
attribute.
Raises:
Exception: If any of the worker processes raised an exception.
Returns:
list: A list of results from the worker processes.
"""
# Get results
exception = None
data_out = []
for result in results:
result = result.get()
if isinstance(result, Exception):
exception = result
continue
data_out.append(result)
pool.close()
pool.join()
if manager:
# Need to shutdown manager so it doesn't hold files in use
if event:
# Restore original event
if thread_abort.event.is_set():
event.set()
thread_abort.event = event
manager.shutdown()
if exception:
raise exception
return data_out
class WorkerFunc:
"""Wrap 'func' with optional arguments.
Args:
func (Callable): The function to wrap.
exit_ (bool, optional): If True, the worker process will exit after
processing the data. This is useful for cleaning up resources in
worker processes, especially on Windows where atexit handlers may
not run automatically.
"""
def __init__(self, func: Callable, exit_: bool = False) -> None:
self.func = func
self.exit = exit_
def __call__(
self,
data: Iterable,
thread_abort_event: threading.Event,
progress_queue: mp.Queue,
*args,
**kwds,
) -> Any | Exception: # noqa: ANN401
"""Call the wrapped function with the given data and arguments.
Args:
data (Iterable): The data to process.
thread_abort_event (threading.Event): Event to signal thread abort.
progress_queue (multiprocessing.Queue): Queue to send progress updates.
*args: Positional arguments to pass to the wrapped function.
**kwds: Keyword arguments to pass to the wrapped function.
Returns:
Exception | result: The result of the function call, or an exception
if one occurred.
"""
try:
return self.func(data, thread_abort_event, progress_queue, *args, **kwds)
except Exception as exception:
if (
not getattr(sys, "_sigbreak", False)
or not isinstance(exception, IOError)
or exception.args[0] != errno.EPIPE
):
import traceback
print(traceback.format_exc())
return exception
finally:
progress_queue.put(EOFError())
if mp.current_process().name != "MainProcess":
print("Exiting worker process", mp.current_process().name)
if sys.platform == "win32" and self.exit:
# Exit handlers registered with atexit will not normally
# run when a multiprocessing subprocess exits. We are only
# interested in our own exit handler though.
# Note all of this only applies to Windows, as it doesn't
# have fork().
# This is not working with Ptyhon 3 as atexit is reimplemented in C
# and atexit._exithandlers are not available.
# for func, targs, kargs in atexit._exithandlers:
# # Find our lockfile removal exit handler
# if (
# targs
# and isinstance(targs[0], str)
# and targs[0].endswith(".lock")
# ):
# print("Removing lockfile", targs[0])
# try:
# func(*targs, **kargs)
# except Exception as exception:
# print("Could not remove lockfile:", exception)
# Logging is normally shutdown by atexit, as well. Do
# it explicitly instead.
logging.shutdown()
class Mapper:
"""Wrap 'func' with optional arguments.
To be used as function argument for Pool.map
Args:
func (Callable): The function to wrap.
*args: Positional arguments to pass to the wrapped function.
**kwds: Keyword arguments to pass to the wrapped function.
"""
def __init__(self, func: Callable, *args, **kwds) -> None:
self.func = WorkerFunc(func)
self.args = args
self.kwds = kwds
def __call__(self, iterable: Iterable) -> list:
"""Call the wrapped function with the given iterable.
Args:
iterable (Iterable): The iterable to process with the wrapped function.
Returns:
list: The result of applying the wrapped function to the iterable.
"""
return self.func(iterable, *self.args, **self.kwds)
class NonDaemonicProcess(mp.Process):
"""Process that is not daemonic.
This is needed for Windows, as daemonic processes cannot have
children. This is a problem when using multiprocessing.Pool,
as the worker processes are daemonic and they create child
processes when they call the function.
"""
@property
def daemon(self) -> bool:
"""Return False, as this process is always non-daemonic.
Returns:
bool: Always False, indicating that this process is non-daemonic.
"""
return False
@daemon.setter
def daemon(self, daemonic: bool) -> None:
"""Set the process as non-daemonic.
Args:
daemonic (bool): This is ignored, as this process is always
non-daemonic.
"""
return
class NonDaemonicPool(mp.pool.Pool):
"""Pool that has non-daemonic workers."""
def Process(self, *args, **kwargs) -> NonDaemonicProcess: # noqa: N802
"""Return a non-daemonic process.
This is needed for Windows, as daemonic processes cannot have
children. This is a problem when using multiprocessing.Pool,
as the worker processes are daemonic and they create child
processes when they call the function.
Returns:
NonDaemonicProcess: A non-daemonic process.
"""
# Process is a function after Python 3.7+
# Process = NonDaemonicProcess -- This will not work with Python3.7+
proc = super().Process(*args, **kwargs)
proc.__class__ = NonDaemonicProcess # TODO: This is not cool, find a better way
# of doing it.
return proc
class FakeManager:
"""Fake manager."""
def Queue(self) -> FakeQueue: # noqa: N802
"""Return a fake queue.
Returns:
FakeQueue: A fake queue that does not use multiprocessing.
"""
return FakeQueue()
def Value(self, typecode: str, *args, **kwds) -> mp.managers.Value: # noqa: N802
"""Return a fake Value.
Args:
typecode (str): The type code for the value.
*args: Positional arguments to pass to the Value constructor.
**kwds: Keyword arguments to pass to the Value constructor.
Returns:
mp.managers.Value: A fake Value that does not use multiprocessing.
"""
return mp.managers.Value(typecode, *args, **kwds)
def shutdown(self) -> None:
"""Shutdown the fake manager."""
class FakePool:
"""Fake pool.
This is a fake pool that does not use multiprocessing. It is used for
testing purposes or when multiprocessing is not available or not needed.
It does not create worker processes and runs the function in the main
thread. It is a drop-in replacement for multiprocessing.Pool.
It does not support any of the advanced features of multiprocessing.Pool,
such as process management, task tracking, or error handling.
It is only suitable for simple use cases where the function can be run
synchronously in the main thread without any parallelism.
Args:
processes (None | int, optional): Number of worker processes to use.
Not used in this fake pool.
initializer (None | callable, optional): Function to run when a worker
process starts. Not used in this fake pool.
initargs (tuple, optional): Arguments to pass to the initializer
function. Not used in this fake pool.
maxtasksperchild (None | int, optional): Maximum number of tasks a
worker can complete before it is replaced. Not used in this fake
pool.
"""
def __init__(
self,
processes: None | int = None,
initializer: None | Callable = None,
initargs: tuple = (),
maxtasksperchild: None | int = None,
) -> None:
pass
def apply_async(self, func: Callable, args: tuple, kwds: dict) -> Result:
"""Apply function asynchronously.
Args:
func (Callable): The function to apply.
args (tuple): The positional arguments to pass to the function.
kwds (dict): The keyword arguments to pass to the function.
Returns:
Result: A Result instance containing the result of the function call.
"""
return Result(func(*args, **kwds))
def close(self) -> NonDaemonicPool:
"""Close the pool."""
def join(self) -> None:
"""Wait for the worker processes to finish."""
def map(
self, func: Callable, iterable: Iterable, chunksize: None | int = None
) -> list:
"""Map function over iterable using the given function.
Args:
func (Callable): The function to apply to each item in the
iterable.
iterable (Iterable): The iterable to process.
chunksize (None | int, optional): The size of each chunk to
process. Not used in this fake pool.
Returns:
list: A list of results from applying the function to each item
in the iterable.
"""
return func(iterable)
def terminate(self) -> None:
"""Terminate the pool."""
class FakeQueue:
"""Fake queue."""
def __init__(self) -> None:
self.queue = []
def get(self, block: bool = True, timeout: None | float = None) -> None | Any: # noqa: ANN401
"""Get an item from the queue.
Args:
block (bool): If True, block until an item is available.
timeout (None | float): Timeout for blocking, not used in this fake
queue.
Raises:
Empty: If the queue is empty.
Returns:
None | Any: The item from the queue, or None if the queue is empty.
"""
try:
return self.queue.pop()
except Exception as e:
raise Empty from e
def join(self) -> None:
"""Wait until all items in the queue have been processed."""
def put(self, item: Any, block: bool = True, timeout: None | float = None) -> None: # noqa: ANN401
"""Put an item into the queue.
Args:
item (Any): The item to be added to the queue.
block (bool): If True, block until the item is added.
timeout (None | float): Timeout for blocking, not used in this fake
queue.
"""
self.queue.append(item)
class Result:
"""Result proxy.
Args:
result (Any): The result to be returned by the get() method.
"""
def __init__(self, result: Any) -> None: # noqa: ANN401
self.result = result
def get(self) -> WorkerFunc:
"""Return result.
Returns:
WorkerFunc: WorkerFunc instance as the result.
"""
return self.result
displaycal-py3-3.9.19/DisplayCAL/network.py 000664 000000 000000 00000020675 15225167330 020441 0 ustar 00root root 000000 000000 """Network utilities: hostname resolution, address retrieval, and custom sockets.
It also includes HTTP redirect handlers for logging or preventing redirections.
"""
from __future__ import annotations
import errno
import os
import socket
import sys
import urllib.error
import urllib.request
from typing import TYPE_CHECKING, BinaryIO
from DisplayCAL import localization as lang
from DisplayCAL.util_str import safe_str
if TYPE_CHECKING:
from types import TracebackType
if sys.version_info >= (3, 11):
from typing import Self
else:
from typing_extensions import Self
DNS_SERVER_IP_ADDR = "8.8.8.8"
"""Google's public DNS server IP address."""
DNS_SERVER_PORT = 53
"""Port number for DNS server."""
def get_network_addr() -> str:
"""Try to get the local machine's network address."""
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Opening a connection on a UDP socket does nothing except give the socket
# the network address of the (local) machine. We use Google's DNS server
# as remote address, but could use any valid non-local address (doesn't
# matter if it is actually reachable)
try:
s.connect((DNS_SERVER_IP_ADDR, DNS_SERVER_PORT))
return s.getsockname()[0] # Return network address
finally:
s.close()
def get_valid_host(hostname: None | str = None) -> tuple[str, str]:
"""Try to verify the hostname by resolving to an IPv4 address.
Both hostname with and without .local suffix will be tried if necessary.
Returns:
tuple[str, str]: A tuple of hostname, addr
"""
if hostname is None:
hostname = socket.gethostname()
hostnames = [hostname]
if hostname.endswith(".local"):
hostnames.insert(0, os.path.splitext(hostname)[0])
elif "." not in hostname:
hostnames.insert(0, f"{hostname}.local")
while hostnames:
hostname = hostnames.pop()
try:
addr = socket.gethostbyname(hostname)
except OSError as e:
if not hostnames:
raise e
else:
return hostname, addr
return None, None
class LoggingHTTPRedirectHandler(urllib.request.HTTPRedirectHandler):
"""Like urllib2.HTTPRedirectHandler, but logs redirections.
Args:
req (urllib.request.Request): The request object.
fp (file-like object): The file-like object containing the response.
code (int): The HTTP status code.
msg (str): The HTTP status message.
headers (dict): The response headers.
"""
# maximum number of redirections to any single URL
# this is needed because of the state that cookies introduce
max_repeats = 4
# maximum total number of redirections (regardless of URL) before
# assuming we're in a loop
max_redirections = 10
def http_error_302(
self,
req: urllib.request.Request,
fp: BinaryIO,
code: int,
msg: str,
headers: dict,
) -> None | urllib.request.HTTPRedirectHandler:
"""Handle HTTP 302 redirection error.
Args:
req (urllib.request.Request): The request object.
fp (BinaryIO): The file-like object containing the
response.
code (int): The HTTP status code.
msg (str): The HTTP status message.
headers (dict): The response headers.
Returns:
None | urllib.request.HTTPRedirectHandler: The HTTP redirect
handler instance, or None if no redirection is needed.
"""
# Some servers (incorrectly) return multiple Location headers
# (so probably same goes for URI). Use first header.
if "location" in headers:
newurl = headers.get("location")
elif "uri" in headers:
newurl = headers.get("uri")
else:
return None
# Keep reference to new URL
LoggingHTTPRedirectHandler.newurl = newurl
if not hasattr(req, "redirect_dict"):
# First redirect in this chain. Log original URL
print(req.get_full_url(), end=" ")
print("\u2192", newurl)
return urllib.request.HTTPRedirectHandler.http_error_302(
self, req, fp, code, msg, headers
)
http_error_301 = http_error_303 = http_error_307 = http_error_302
inf_msg = urllib.request.HTTPRedirectHandler.inf_msg
class NoHTTPRedirectHandler(urllib.request.HTTPRedirectHandler):
"""Like urllib2.HTTPRedirectHandler, but does not allow redirections.
Args:
req (urllib.request.Request): The request object.
fp (file-like object): The file-like object containing the response.
code (int): The HTTP status code.
msg (str): The HTTP status message.
headers (dict): The response headers.
"""
def http_error_302(
self,
req: urllib.request.Request,
fp: BinaryIO,
code: int,
msg: str,
headers: dict,
) -> None:
"""Handle HTTP 302 redirection error.
Args:
req (urllib.request.Request): The request object.
fp (BinaryIO): The file-like object containing the
response.
code (int): The HTTP status code.
msg (str): The HTTP status message.
headers (dict): The response headers.
Raises:
urllib.error.HTTPError: If redirection is not allowed, raises an
HTTPError with the new URL and the original error message.
"""
# Some servers (incorrectly) return multiple Location headers
# (so probably same goes for URI). Use first header.
if "location" in headers:
newurl = headers.get("location")
elif "uri" in headers:
newurl = headers.get("uri")
else:
return
raise urllib.error.HTTPError(
newurl,
code,
msg + f" - Redirection to url '{newurl}' is not allowed",
headers,
fp,
)
http_error_301 = http_error_303 = http_error_307 = http_error_302
class ScriptingClientSocket(socket.socket):
"""A socket class for handling scripting client connections."""
def __init__(self) -> None:
socket.socket.__init__(self)
self.recv_buffer = b""
def __del__(self) -> None:
"""Destructor for the ScriptingClientSocket class."""
self.disconnect()
def __enter__(self) -> Self:
"""Enter method for context manager.
Returns:
ScriptingClientSocket: The instance of the socket.
"""
return self
def __exit__(
self,
exc_type: None | type[BaseException],
exc_value: None | BaseException,
tb: None | TracebackType,
) -> None:
"""Exit method for context manager.
Args:
exc_type (type): The type of the exception raised, if any.
exc_value (None | BaseException): The exception instance, if any.
tb (None | TracebackType): The traceback object, if any.
Returns:
None
"""
self.disconnect()
def disconnect(self) -> None:
"""Disconnect the socket and clean up resources."""
try:
# Will fail if the socket isn't connected, i.e. if there was an
# error during the call to connect()
self.shutdown(socket.SHUT_RDWR)
except OSError as exception:
if exception.errno != errno.ENOTCONN:
print(exception)
self.close()
def get_single_response(self) -> bytes:
"""Receive a single response from the socket.
Returns:
bytes: The single response received from the socket.
"""
# Buffer received data until EOT (response end marker) and return
# single response (additional data will still be in the buffer)
while b"\4" not in self.recv_buffer:
incoming = self.recv(4096)
if incoming == b"":
raise OSError(lang.getstr("connection.broken"))
self.recv_buffer += incoming
end = self.recv_buffer.find(b"\4")
single_response = self.recv_buffer[:end]
self.recv_buffer = self.recv_buffer[end + 1 :]
return single_response
def send_command(self, command: str) -> None:
"""Send a command to the socket.
Args:
command (str): The command to send.
"""
# Automatically append newline (command end marker)
self.sendall((safe_str(command, "utf-8") + "\n").encode("utf-8"))
displaycal-py3-3.9.19/DisplayCAL/options.py 000664 000000 000000 00000004435 15225167330 020437 0 ustar 00root root 000000 000000 """Parse commandline options.
Note that none of these are advertised, as they solely exist for testing and development
purposes.
"""
import sys
# Use only ascii? (DON'T)
ASCII = "--ascii" in sys.argv[1:]
# Debug level (default: 0 = off). >= 1 prints debug messages
if "-d2" in sys.argv[1:] or "--debug=2" in sys.argv[1:]:
DEBUG = 2
elif (
"-d1" in sys.argv[1:]
or "--debug=1" in sys.argv[1:]
or "-d" in sys.argv[1:]
or "--debug" in sys.argv[1:]
):
DEBUG = 1
else:
DEBUG = 0
# Debug localization
DEBUG_LOCALIZATION = "-dl" in sys.argv[1:] or "--debug-localization" in sys.argv[1:]
# Use alternate patch preview in the testchart editor?
TC_USE_ALTERNATE_PREVIEW = (
"-ap" in sys.argv[1:] or "--alternate-preview" in sys.argv[1:]
)
# Test some features even if they are not available normally
TEST = "-t" in sys.argv[1:] or "--test" in sys.argv[1:]
EECOLOR65 = "--ee65" in sys.argv[1:]
# Test sensor calibration
TEST_REQUIRE_SENSOR_CAL = (
"-s" in sys.argv[1:] or "--test_require_sensor_cal" in sys.argv[1:]
)
# Test update functionality
TEST_UPDATE = "-tu" in sys.argv[1:] or "--test-update" in sys.argv[1:]
# Test SSL connection using badssl.com
TEST_BADSSL = False
for arg in sys.argv[1:]:
if arg.startswith("--test-badssl="):
TEST_BADSSL = arg.split("=", 1)[-1]
# Always fail download
ALWAYS_FAIL_DOWNLOAD = "--always-fail-download" in sys.argv[1:]
# HDR input profile generation: Test input curve clipping
TEST_INPUT_CURVE_CLIPPING = "--test-input-curve-clipping" in sys.argv[1:]
# Enable experimental features
EXPERIMENTAL = "-x" in sys.argv[1:] or "--experimental" in sys.argv[1:]
# Verbosity level (default: 1). >= 1 prints some status information
if "-v4" in sys.argv[1:] or "--verbose=4" in sys.argv[1:]:
VERBOSE = 4
elif "-v3" in sys.argv[1:] or "--verbose=3" in sys.argv[1:]:
VERBOSE = 3
elif "-v2" in sys.argv[1:] or "--verbose=2" in sys.argv[1:]:
VERBOSE = 2
elif "-v0" in sys.argv[1:] or "--verbose=0" in sys.argv[1:]:
VERBOSE = 0 # Off
else:
VERBOSE = 1
# Use Colord GObject introspection interface (otherwise, use D-Bus)
USE_COLORD_GI = "--use-colord-gi" in sys.argv[1:]
# Skip initial instrument/port detection on startup
FORCE_SKIP_INITIAL_INSTRUMENT_DETECTION = (
"--force-skip-initial-instrument-detection" in sys.argv[1:]
)
displaycal-py3-3.9.19/DisplayCAL/patterngenerators.py 000664 000000 000000 00000121165 15225167330 022513 0 ustar 00root root 000000 000000 """Pattern generator clients and servers for HTTP and TCP devices.
It supports sending RGB patterns, managing connections, and handling events for
various pattern generator devices.
"""
from __future__ import annotations
import contextlib
import errno
import http.client
import json
import select
import struct
import sys
import threading
import urllib.parse
from socket import (
AF_INET,
SHUT_RDWR,
SO_BROADCAST,
SO_REUSEADDR,
SOCK_DGRAM,
SOCK_STREAM,
SOL_SOCKET,
gethostbyname,
gethostname,
socket,
timeout,
)
from socketserver import TCPServer, ThreadingMixIn
from time import sleep
from typing import TYPE_CHECKING, Any, Callable, TextIO
from DisplayCAL import localization as lang
from DisplayCAL import webwin
from DisplayCAL.network import get_network_addr
from DisplayCAL.util_http import encode_multipart_formdata
if TYPE_CHECKING:
from http.client import HTTPResponse
from urllib.request import Request
_lock = threading.RLock()
PRISMA_DEFAULT_PORT = 80
RESOLVE_LS_DEFAULT_BITS = 8
RESOLVE_DEFAULT_PORT = 20002
RESOLVE_DEFAULT_BITS = 10
def _eintr_retry(func: Callable, *args) -> Any: # noqa: ANN401
"""Restart a system call interrupted by EINTR.
Args:
func (Callable): The function to call.
*args: Arguments to pass to the function.
Returns:
Any: The result of the function call.
"""
while True:
try:
return func(*args)
except OSError as e:
if e.args[0] != errno.EINTR:
raise
def _shutdown(sock: socket, addr: str) -> None:
"""Shutdown and close a socket.
Args:
sock (socket): The socket to shut down and close.
addr (str): The address associated with the socket, for logging.
"""
try:
# Will fail if the socket isn't connected, i.e. if there
# was an error during the call to connect()
sock.shutdown(SHUT_RDWR)
except OSError as exception:
if exception.errno != errno.ENOTCONN:
print(f"PatternGenerator: SHUT_RDWR for {addr[:2]}:{exception} failed:")
sock.close()
class GenHTTPPatternGeneratorClient:
"""Generic pattern generator client using HTTP REST interface.
Args:
host (str): The hostname or IP address of the pattern generator server.
port (int): The port number to connect to.
bits (int): Number of bits per channel.
use_video_levels (bool, optional): Use video levels for RGB values.
Defaults to False.
logfile (None | TextIO, optional): A file-like object to log messages.
Defaults to None.
"""
def __init__(
self,
host: str,
port: int,
bits: int,
use_video_levels: bool = False,
logfile: None | TextIO = None,
) -> None:
self.host = host
self.port = port
self.bits = bits
self.use_video_levels = use_video_levels
self.logfile = logfile
def wait(self) -> None:
"""Wait for the pattern generator server to be available."""
self.connect()
def __del__(self) -> None:
"""Clean up the connection and socket."""
self.disconnect_client()
def _request(
self,
method: str,
url: str,
params: None | bytes | str = None,
headers: None | dict = None,
validate: None | str | dict = None,
) -> str | dict:
"""Make an HTTP request to the pattern generator server.
Args:
method (str): The HTTP method to use (e.g., 'GET', 'POST').
url (str): The URL to request.
params (None | bytes | str, optional): The request body for POST
requests. Defaults to None.
headers (None | dict, optional): Additional headers to include in
the request. Defaults to None.
validate (None | str | dict, optional): Expected response format or
value. Defaults to None.
Returns:
str | dict: The response from the server, validated against the
expected format or value.
"""
try:
self.conn.request(method, url, params, headers or {})
resp = self.conn.getresponse()
except (OSError, http.client.HTTPException) as exception:
# TODO: What is the point of having the except clause here?
raise exception
else:
if resp.status == http.client.OK:
return self._validate(resp, url, validate)
raise http.client.HTTPException(f"{resp.status} {resp.reason}")
def _shutdown(self) -> None:
"""Shutdown the pattern generator device connection."""
# Override this method in subclass!
def _validate(self, resp: HTTPResponse, url: str, validate: str | dict) -> None:
"""Validate the response from the server.
Args:
resp (HTTPResponse): The HTTP response object.
url (str): The URL that was requested.
validate (str | dict): The expected response format or value.
"""
# Override this method in subclass!
def connect(self) -> None:
"""Connect to the pattern generator server."""
self.ip = gethostbyname(self.host)
self.conn = http.client.HTTPConnection(self.ip, self.port)
try:
self.conn.connect()
except (OSError, http.client.HTTPException):
del self.conn
raise
def disconnect_client(self) -> None:
"""Disconnect the current client and clean up resources."""
self.listening = False
if hasattr(self, "conn"):
self._shutdown()
self.conn.close()
del self.conn
def send(
self,
rgb: tuple[float, float, float] = (0, 0, 0),
bgrgb: tuple[float, float, float] = (0, 0, 0),
bits: None | int = None,
use_video_levels: None | bool = None,
x: float = 0,
y: float = 0,
w: float = 1,
h: float = 1,
) -> None:
"""Send an RGB color to the pattern generator.
Args:
rgb (tuple[float, float, float], optional): RGB color values in the
range 0..1. Defaults to (0, 0, 0).
bgrgb (tuple[float, float, float], optional): Background RGB color
values in the range 0..1. Defaults to (0, 0, 0).
bits (None | int, optional): Number of bits per channel. Defaults
to None.
use_video_levels (None | bool, optional): Use video levels for RGB
values. Defaults to None.
x (float, optional): X position of the rectangle. Defaults to 0.
y (float, optional): Y position of the rectangle. Defaults to 0.
w (float, optional): Width of the rectangle. Defaults to 1.
h (float, optional): Height of the rectangle. Defaults to 1.
"""
rgb, bgrgb, bits = self._get_rgb(rgb, bgrgb, bits, use_video_levels)
# Override this method in subclass!
# raise NotImplementedError
class GenTCPSockPatternGeneratorServer:
"""Generic pattern generator server using TCP sockets.
Args:
port (int): The port number to listen on.
bits (int): Number of bits per channel.
use_video_levels (bool, optional): Use video levels for RGB values.
Defaults to False.
logfile (None | TextIO, optional): A file-like object to log messages.
Defaults to None.
"""
def __init__(
self,
port: int,
bits: int,
use_video_levels: bool = False,
logfile: None | TextIO = None,
) -> None:
self.port = port
self.bits = bits
self.use_video_levels = use_video_levels
self.socket = socket(AF_INET, SOCK_STREAM)
self.socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.socket.settimeout(1)
self.socket.bind(("", port))
self.socket.listen(1)
self.listening = False
self.logfile = logfile
def wait(self) -> None:
"""Wait for a client to connect."""
self.listening = True
if self.logfile:
try:
host = get_network_addr()
except OSError:
host = gethostname()
self.logfile.write(
"{} {}:{}\n".format(lang.getstr("connection.waiting"), host, self.port)
)
while self.listening:
try:
self.conn, addr = self.socket.accept()
except timeout:
continue
self.conn.settimeout(1)
break
if self.listening:
print(lang.getstr("connection.established"))
def __del__(self) -> None:
"""Clean up the connection and socket."""
self.disconnect_client()
self.socket.close()
def _get_rgb(
self,
rgb: tuple[float, float, float],
bgrgb: tuple[float, float, float],
bits: None | int = None,
use_video_levels: None | bool = None,
) -> tuple[int, int, int]:
"""The RGB range should be 0..1.
Args:
rgb (tuple[float, float, float]): RGB color values in the range
0..1.
bgrgb (tuple[float, float, float]): Background RGB color values in
the range 0..1.
bits (int, optional): Number of bits per channel. Defaults to None.
use_video_levels (bool, optional): Use video levels for RGB values.
Defaults to None.
Returns:
tuple[int, int, int]: A tuple containing the RGB and BGRGB values
encoded for the TCP socket interface, and the number of bits
per channel.
"""
if not bits:
bits = self.bits
if use_video_levels is None:
use_video_levels = self.use_video_levels
bitv = 2**bits - 1
if use_video_levels:
minv = 16.0 / 255.0
maxv = 235.0 / 255.0 - minv
if bits > 8:
# 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.
minv = (minv * 255.0 * (1 << (bits - 8))) / bitv
maxv = (maxv * 255.0 * (1 << (bits - 8))) / bitv
else:
minv = 0.0
maxv = 1.0
rgb = [round(minv * bitv + v * bitv * maxv) for v in rgb]
bgrgb = [round(minv * bitv + v * bitv * maxv) for v in bgrgb]
return rgb, bgrgb, bits
def disconnect_client(self) -> None:
"""Disconnect the current client and clean up resources."""
self.listening = False
if hasattr(self, "conn"):
try:
self.conn.shutdown(SHUT_RDWR)
except OSError as exception:
if exception.errno != errno.ENOTCONN:
print(
"Warning - could not shutdown pattern generator connection:",
exception,
)
self.conn.close()
del self.conn
def send(
self,
rgb: tuple[float, float, float] = (0, 0, 0),
bgrgb: tuple[float, float, float] = (0, 0, 0),
use_video_levels: None | bool = None,
x: float = 0,
y: float = 0,
w: float = 1,
h: float = 1,
) -> None:
"""Send an RGB color to the pattern generator.
Args:
rgb (tuple, optional): RGB color values in the range 0..1. Defaults
to (0, 0, 0).
bgrgb (tuple, optional): Background RGB color values in the range
0..1. Defaults to (0, 0, 0).
use_video_levels (None | bool, optional): Use video levels for RGB
values. Defaults to None.
x (float, optional): X position of the rectangle. Defaults to 0.
y (float, optional): Y position of the rectangle. Defaults to 0.
w (float, optional): Width of the rectangle. Defaults to 1.
h (float, optional): Height of the rectangle. Defaults to 1.
"""
for server, bits in (
(ResolveLSPatternGeneratorServer, 8),
(ResolveCMPatternGeneratorServer, 10),
):
server.__dict__["send"](
self, rgb, bgrgb, bits, use_video_levels, x, y, w, h
)
class PrismaPatternGeneratorClient(GenHTTPPatternGeneratorClient):
"""Prisma HTTP REST interface.
Args:
host (str): The hostname or IP address of the Prisma device.
port (int, optional): The port number to connect to. Defaults to 80.
use_video_levels (bool, optional): Use video levels for RGB values.
Defaults to False.
logfile (file-like object, optional): A file-like object to log
messages. Defaults to None.
"""
def __init__(
self,
host: str,
port: int = PRISMA_DEFAULT_PORT,
use_video_levels: bool = False,
logfile: None | TextIO = None,
) -> None:
GenHTTPPatternGeneratorClient.__init__(
self, host, port, 8, use_video_levels=use_video_levels, logfile=logfile
)
self.prod_prisma = 2
self.oem_qinc = 1024
self.prod_oem = struct.pack(" None:
"""Start listening for Prisma devices on the local network."""
self.listening = True
port = self.broadcast_response_port
if (self.broadcast_ip, port) in self._cast_sockets:
return
sock = socket(AF_INET, SOCK_DGRAM)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
sock.settimeout(0)
try:
sock.bind(("", port))
thread = threading.Thread(
target=self._cast_receive_handler,
name=(
"PrismaPatternGeneratorClient.BroadcastHandler["
f"{self.broadcast_ip}:{port}]"
),
args=(sock, self.broadcast_ip, port),
)
self._threads.append(thread)
thread.start()
except OSError as exception:
print(f"PrismaPatternGeneratorClient: UDP Port {port:d}: {exception:s}")
def _cast_receive_handler(self, sock: socket, host: str, port: int) -> None:
"""Receive broadcast messages from Prisma devices.
Args:
sock (socket): The UDP socket to listen on.
host (str): The host IP address.
port (int): The port number to listen on.
"""
cast = "broadcast"
if self.debug:
print(
"PrismaPatternGeneratorClient: Entering receiver thread for "
f"{cast:s} port {port:d}"
)
self._cast_sockets[(host, port)] = sock
while getattr(self, "listening", False):
try:
data, addr = sock.recvfrom(4096)
except timeout as exception:
print(
"PrismaPatternGeneratorClient: In receiver thread for "
f"{cast:s} port {port:d}:",
exception,
)
continue
except OSError as exception:
if exception.errno == errno.EWOULDBLOCK:
sleep(0.05)
continue
if exception.errno != errno.ECONNRESET or self.debug:
print(
"PrismaPatternGeneratorClient: In receiver thread for "
f"{cast:s} port {port:d}:",
exception,
)
break
else:
with _lock:
if self.debug:
print(
"PrismaPatternGeneratorClient: Received "
f"{cast} from {addr[0]}:{addr[1]}: {data}"
)
if data.startswith(self.prod_oem):
name = data[8:32].rstrip(b"\0")
serial = data[32:].rstrip(b"\0")
self.prismas[addr[0]] = {"serial": serial, "name": name}
self._dispatch_event(
"on_client_added", (addr, self.prismas[addr[0]])
)
self._cast_sockets.pop((host, port))
_shutdown(sock, (host, port))
if self.debug:
print(
f"PrismaPatternGeneratorClient: Exiting {cast:s} "
f"receiver thread for port {port:d}"
)
def announce(self) -> None:
"""Anounce ourselves."""
port = self.broadcast_request_port
sock = socket(AF_INET, SOCK_DGRAM)
sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
sock.settimeout(1)
sock.connect((self.broadcast_ip, port))
addr = sock.getsockname()
if self.debug:
print(
"PrismaPatternGeneratorClient: Sending broadcast from "
f"{addr[0]}:{addr[1]} to port {port:d}"
)
sock.sendall(self.prod_oem)
sock.close()
def bind(self, event_name: str, handler: Callable) -> None:
"""Bind a handler to an event.
Args:
event_name (str): The name of the event to bind to.
handler (Callable): The handler to bind to the event.
"""
if event_name not in self._event_handlers:
self._event_handlers[event_name] = []
self._event_handlers[event_name].append(handler)
def unbind(
self, event_name: str, handler: None | Callable = None
) -> None | Callable:
"""Unbind (remove) a handler from an event.
If handler is None, remove all handlers for the event.
Args:
event_name (str): The name of the event to unbind from.
handler (None | Callable, optional): The handler to remove. If
None, remove all handlers for the event. Defaults to None.
Returns:
None | Callable: The removed handler if it was found, or None if no
handler was found for the event.
"""
if event_name not in self._event_handlers:
return None
if handler in self._event_handlers[event_name]:
self._event_handlers[event_name].remove(handler)
return handler
return self._event_handlers.pop(event_name)
def _dispatch_event(self, event_name: str, event_data: None | Any = None) -> None: # noqa: ANN401
"""Dispatch events.
Args:
event_name (str): The name of the event to dispatch.
event_data (any, optional): Data associated with the event.
Defaults to None.
"""
if self.debug:
print("PrismaPatternGeneratorClient: Dispatching", event_name)
for handler in self._event_handlers.get(event_name, []):
handler(event_data)
def _get_rgb(
self,
rgb: tuple[float, float, float],
bgrgb: tuple[float, float, float],
bits: int = 8,
use_video_levels: None | bool = None,
) -> tuple[int, int, int]:
"""The RGB range should be 0..1.
Args:
rgb (tuple[float, float, float]): RGB color values in the range
0..1.
bgrgb (tuple[float, float, float]): Background RGB color values in
the range 0..1.
bits (int, optional): Number of bits per channel. Defaults to 8.
use_video_levels (bool, optional): Use video levels for RGB values.
Defaults to None.
Returns:
tuple[int, int, int]: A tuple containing the RGB and BGRGB values
encoded for the Prisma HTTP REST interface, and the number of
bits per channel.
"""
rgb, bgrgb, bits = GenTCPSockPatternGeneratorServer._get_rgb(
self, rgb, bgrgb, 8, use_video_levels
)
# Encode RGB values for Prisma HTTP REST interface
# See prisma-sdk/prisma.cpp, PrismaIo::wincolor
rgb = [round(v) for v in rgb]
bgrgb = [round(v) for v in bgrgb]
rgb = (rgb[0] & 0xFF) << 16 | (rgb[1] & 0xFF) << 8 | (rgb[2] & 0xFF) << 0
bgrgb = (
(bgrgb[0] & 0xFF) << 16 | (bgrgb[1] & 0xFF) << 8 | (bgrgb[2] & 0xFF) << 0
)
return rgb, bgrgb, bits
def invoke(
self,
api: str,
method: None | str = None,
params: None | dict = None,
validate: None | str | dict = None,
) -> str | dict:
"""Invoke a method on the Prisma device.
Args:
api (str): The API endpoint to call.
method (None | str, optional): The method to invoke. Defaults to
None.
params (None | dict, optional): Parameters to pass to the method.
Defaults to None.
validate (None | str | dict, optional): Expected response format or
value.
Returns:
str | dict: The response from the server, validated against the
expected format or value.
"""
url = "/" + api
if method:
url += "?m=" + method
if params:
url += "&" + urllib.parse.unquote_plus(urllib.parse.urlencode(params))
if not validate:
validate = {method: "Ok"}
return self._request("GET", url, validate=validate)
def _shutdown(self) -> None:
"""Shutdown the Prisma device connection."""
with contextlib.suppress(Exception):
self.invoke("window", "off", {"sz": 10})
def _validate(
self, resp: HTTPResponse, url: str, validate: str | dict
) -> str | dict:
"""Validate the response from the server.
Args:
resp (HTTPResponse): The HTTP response object.
url (str): The URL that was requested.
validate (str | dict): The expected response format or value.
Raises:
http.client.HTTPException: If the response does not match the
expected format or value.
Returns:
str | dict: The validated response data, either as a dictionary or
raw string.
"""
raw = resp.read()
if isinstance(validate, dict):
data = json.loads(raw)
components = urllib.parse.urlparse(url)
# api = components.path[1:]
query = urllib.parse.parse_qs(components.query)
if b"m" in query:
method = query[b"m"][0]
if data.get(method) == "Error" and "msg" in data:
raise http.client.HTTPException(f"{self.host}: {data['msg']}")
for key in validate:
value = validate[key]
if key not in data:
raise http.client.HTTPException(
lang.getstr(
"response.invalid.missing_key", (self.host, key, raw)
)
)
if value is not None and data[key] != value:
raise http.client.HTTPException(
lang.getstr(
"response.invalid.value", (self.host, key, value, raw)
)
)
data["raw"] = raw
return data
if validate and raw != validate:
raise http.client.HTTPException(
lang.getstr("response.invalid", (self.host, raw))
)
return raw
def disable_processing(self, size: int = 10) -> None:
"""Disable processing on the Prisma device.
Args:
size (int, optional): The size of the window to set. Defaults to
10.
"""
self.enable_processing(False, size)
def enable_processing(self, enable: bool = True, size: int = 10) -> None:
"""Enable or disable processing on the Prisma device.
Args:
enable (bool, optional): If True, processing is enabled; if False,
it is disabled. Defaults to True.
size (int, optional): The size of the window to set. Defaults to
10.
"""
win = 1 if enable else 2
self.invoke("Window", f"win{win}", {"sz": size})
def get_config(self) -> dict:
"""Get the current configuration of the Prisma device.
Returns:
dict: A dictionary containing the current configuration settings.
"""
return self.invoke("Prisma", "settings", validate={"v": None, "settings": "Ok"})
def get_installed_3dluts(self) -> dict:
"""Get a list of installed 3D LUTs.
Returns:
dict: A dictionary containing the list of installed 3D LUTs.
"""
return self.invoke("Cube", "list", validate={"list": "Ok", "v": None})
def load_preset(self, presetname: str) -> None:
"""Load a preset by name.
Args:
presetname (str): The name of the preset to load.
"""
return self.invoke(
"Prisma", "loadPreset", {"n": presetname}, validate={"v": None}
)
def load_3dlut_file(self, path: str, filename: str) -> None:
"""Load a 3D LUT file.
Args:
path (str): The path to the 3D LUT file.
filename (str): The name of the 3D LUT file to upload.
"""
with open(path, "rb") as lut3d:
data = lut3d.read()
files = [("cubeFile", filename, data)]
content_type, params = encode_multipart_formdata([], files)
headers = {"Content-Type": content_type, "Content-Length": str(len(params))}
# Upload 3D LUT
self._request("POST", "/fwupload", params, headers)
def remove_3dlut(self, filename: str) -> None:
"""Remove a 3D LUT by name.
Args:
filename (str): The name of the 3D LUT file to remove.
"""
self.invoke("Cube", "remove", {"n": filename})
def set_3dlut(self, filename: str) -> None:
"""Set the 3D LUT by name.
Args:
filename (str): The name of the 3D LUT file to set.
"""
# Select 3D LUT
self.invoke("Prisma", "setCube", {"n": filename, "f": "null"})
def set_prismavue(self, value: str) -> None:
"""Set the PrismaVue mode.
Args:
value (str): The PrismaVue mode to set. Can be "on", "off", or
"null".
"""
self.invoke("Prisma", "setPrismaVue", {"a": value, "t": "null"})
def send(
self,
rgb: tuple[float, float, float] = (0, 0, 0),
bgrgb: tuple[float, float, float] = (0, 0, 0),
bits: None | int = None,
use_video_levels: None | bool = None,
x: float = 0,
y: float = 0,
w: float = 1,
h: float = 1,
) -> None:
"""Send an RGB color to the pattern generator.
The RGB range should be 0..1.
Args:
rgb (tuple[float, float, float], optional): RGB color values in the
range 0..1.
bgrgb (tuple[float, float, float], optional): Background RGB color
values in the range 0..1.
bits (None | int, optional): Number of bits per channel. Defaults
to None.
use_video_levels (None | bool, optional): Use video levels for RGB
values. Defaults to None.
x (float, optional): X position of the rectangle. Defaults to 0.
y (float, optional): Y position of the rectangle. Defaults to 0.
w (float, optional): Width of the rectangle. Defaults to 1.
h (float, optional): Height of the rectangle. Defaults to 1.
"""
rgb, bgrgb, bits = self._get_rgb(rgb, bgrgb, bits, use_video_levels)
self.invoke("Window", "color", {"bg": bgrgb, "fg": rgb})
size = (w + h) / 2.0 * 100
if size != self._size:
self._size = size
self.enable_processing(self._enable_processing, size)
class ResolveLSPatternGeneratorServer(GenTCPSockPatternGeneratorServer):
"""Resolve LS pattern generator server using TCP sockets.
Args:
port (int): The port number to listen on. Defaults to 20002.
bits (int): Number of bits per channel. Defaults to 8.
use_video_levels (bool): Use video levels for RGB values. Defaults to
False.
logfile (None | TextIO, optional): A file-like object to log messages.
Defaults to None.
"""
def __init__(
self,
port: int = RESOLVE_DEFAULT_PORT,
bits: int = RESOLVE_LS_DEFAULT_BITS,
use_video_levels: bool = False,
logfile: None | TextIO = None,
) -> None:
GenTCPSockPatternGeneratorServer.__init__(
self, port, bits, use_video_levels, logfile
)
def send(
self,
rgb: tuple[float, float, float] = (0, 0, 0),
bgrgb: tuple[float, float, float] = (0, 0, 0),
bits: None | int = None,
use_video_levels: None | bool = None,
x: float = 0,
y: float = 0,
w: float = 1,
h: float = 1,
) -> None:
"""Send an RGB color to the pattern generator.
The RGB range should be 0..1.
Args:
rgb (tuple, optional): RGB color values in the range 0..1.
bgrgb (tuple, optional): Background RGB color values in the range 0..1.
bits (None | int, optional): Number of bits per channel. Defaults
to None.
use_video_levels (None | bool, optional): Use video levels for RGB
values. Defaults to None.
x (float, optional): X position of the rectangle. Defaults to 0.
y (float, optional): Y position of the rectangle. Defaults to 0.
w (float, optional): Width of the rectangle. Defaults to 1.
h (float, optional): Height of the rectangle. Defaults to 1.
"""
rgb, bgrgb, bits = self._get_rgb(rgb, bgrgb, bits, use_video_levels)
xml = (
''
""
f''
f''
""
""
)
self.conn.sendall(struct.pack(">I", len(xml)) + xml.encode("utf-8"))
class ResolveCMPatternGeneratorServer(GenTCPSockPatternGeneratorServer):
"""Resolve Colorimeter pattern generator server using TCP sockets.
Args:
port (int, optional): The port number to listen on. Defaults to 20002.
bits (int, optional): Number of bits per channel. Defaults to 10.
use_video_levels (bool, optional): Use video levels for RGB values.
Defaults to False.
logfile (None | TextIO, optional): A file-like object to log messages.
Defaults to None.
"""
def __init__(
self,
port: int = RESOLVE_DEFAULT_PORT,
bits: int = RESOLVE_DEFAULT_BITS,
use_video_levels: bool = False,
logfile: None | TextIO = None,
) -> None:
GenTCPSockPatternGeneratorServer.__init__(
self, port, bits, use_video_levels, logfile
)
def send(
self,
rgb: tuple[float, float, float] = (0, 0, 0),
bgrgb: tuple[float, float, float] = (0, 0, 0),
bits: None | int = None,
use_video_levels: None | bool = None,
x: float = 0,
y: float = 0,
w: float = 1,
h: float = 1,
) -> None:
"""Send an RGB color to the pattern generator.
The RGB range should be 0..1.
Args:
rgb (tuple, optional): RGB color values in the range 0..1.
bgrgb (tuple, optional): Background RGB color values in the range
0..1.
bits (None | int, optional): Number of bits per channel. Defaults
to None.
use_video_levels (None | bool, optional): Use video levels for RGB
values. Defaults to None.
x (float, optional): X position of the rectangle. Defaults to 0.
y (float, optional): Y position of the rectangle. Defaults to 0.
w (float, optional): Width of the rectangle. Defaults to 1.
h (float, optional): Height of the rectangle. Defaults to 1.
"""
rgb, bgrgb, bits = self._get_rgb(rgb, bgrgb, bits, use_video_levels)
xml = (
''
f''
f''
f''
""
)
self.conn.sendall(struct.pack(">I", len(xml)) + xml.encode("utf-8"))
class WebWinHTTPPatternGeneratorServer(ThreadingMixIn, TCPServer):
"""WebWin pattern generator server using HTTP REST interface.
Args:
port (int): The port number to listen on.
logfile (None | TextIO, optional): A file-like object to log messages.
Defaults to None.
"""
def __init__(self, port: int, logfile: None | TextIO = None) -> None:
# Handle each HTTP client request in its own thread so multiple
# remote browser devices can stay connected simultaneously.
self.daemon_threads = True
self.block_on_close = False
self.port = port
TCPServer.__init__(self, ("", port), webwin.WebWinHTTPRequestHandler)
self.timeout = 1
self.patterngenerator = self
self._listening = threading.Event()
self._pattern_lock = threading.Lock()
self._pattern_changed = threading.Condition(self._pattern_lock)
self._pattern_seq = 0
self.logfile = logfile
self.pattern = "#808080|#808080|0|0|1|1"
def disconnect_client(self) -> None:
"""Disconnect the current client and clean up resources."""
self.listening = False
def handle_error(self, request: Request, client_address: str) -> None:
"""Handle errors that occur during request processing.
Args:
request (Request): The request object that caused the error.
client_address (str): The address of the client that made the
request.
"""
print(
"Exception happened during processing of request from "
f"{client_address}:{sys.exc_info()[1]}:"
)
@property
def listening(self) -> bool:
"""Check if the server is currently listening for requests.
Returns:
bool: True if the server is listening, False otherwise.
"""
return self._listening.is_set()
@listening.setter
def listening(self, value: bool) -> None:
"""Set the listening state of the server.
Args:
value (bool): If True, the server starts listening for requests.
If False, it stops listening and cleans up any existing
connections.
"""
if value:
self._listening.set()
return
self._listening.clear()
with self._pattern_changed:
# Wake any long-poll requests so they can terminate quickly.
self._pattern_changed.notify_all()
if hasattr(self, "conn"):
self.shutdown_request(self.conn)
del self.conn
if hasattr(self, "_thread") and self._thread.is_alive():
self.shutdown()
def send(
self,
rgb: tuple[float, float, float] = (0, 0, 0),
bgrgb: tuple[float, float, float] = (0, 0, 0),
bits: None | int = None,
use_video_levels: None | bool = None,
x: float = 0,
y: float = 0,
w: float = 1,
h: float = 1,
) -> None:
"""Send an RGB color to the pattern generator. The RGB range should be 0..1.
Args:
rgb (tuple[float, float, float], optional): RGB color values in the
range 0..1.
bgrgb (tuple[float, float, float], optional): Background RGB color
values in the range 0..1.
bits (None | int, optional): Number of bits per channel. Defaults
to None.
use_video_levels (None | bool, optional): Use video levels for RGB
values. Defaults to None.
x (float, optional): X position of the rectangle. Defaults to 0.
y (float, optional): Y position of the rectangle. Defaults to 0.
w (float, optional): Width of the rectangle. Defaults to 1.
h (float, optional): Height of the rectangle. Defaults to 1.
"""
# Convert normalized RGB values to 8-bit CSS hex colors.
pattern = [
"#{:02x}{:02x}{:02x}".format(
*tuple(max(0, min(255, round(v * 255))) for v in rgb)
),
"#{:02x}{:02x}{:02x}".format(
*tuple(max(0, min(255, round(v * 255))) for v in bgrgb)
),
f"{x:.4f}|{y:.4f}|{w:.4f}|{h:.4f}",
]
with self._pattern_changed:
self.pattern = "|".join(pattern)
self._pattern_seq += 1
self._pattern_changed.notify_all()
def wait_for_pattern_change(self, curpat: str, timeout: float = 25.0) -> str:
"""Return current pattern, waiting until it changes or times out."""
with self._pattern_changed:
current = self.pattern
start_seq = self._pattern_seq
if self._listening.is_set() and current == curpat:
self._pattern_changed.wait_for(
lambda: (
not self._listening.is_set()
or self._pattern_seq != start_seq
or self.pattern != curpat
),
timeout=timeout,
)
current = self.pattern
return current
def serve_forever(self, poll_interval: float = 0.5) -> None:
"""Handle one request at a time until shutdown.
Polls for shutdown every poll_interval seconds. Ignores
self.timeout. If you need to do periodic tasks, do them in
another thread.
"""
try:
while self._listening.is_set():
# XXX: Consider using another file descriptor or
# connecting to the socket to wake this up instead of
# polling. Polling reduces our responsiveness to a
# shutdown request and wastes cpu at all other times.
r, w, e = _eintr_retry(select.select, [self], [], [], poll_interval)
if self in r:
self._handle_request_noblock()
except Exception as exception:
print(
"Exception in WebWinHTTPPatternGeneratorServer.serve_forever:",
exception,
)
self._listening.clear()
def shutdown(self) -> None:
"""Stop the serve_forever loop.
Blocks until the loop has finished. This must be called while
serve_forever() is running in another thread.
"""
self._listening.clear()
while self._thread.is_alive():
sleep(0.05)
def wait(self) -> None:
"""Wait for a client to connect and process the request."""
self.listening = True
if self.logfile:
try:
host = get_network_addr()
except OSError:
host = gethostname()
self.logfile.write(
"{} {}:{}\n".format(lang.getstr("webserver.waiting"), host, self.port)
)
self.socket.settimeout(1)
while self.listening:
try:
self.conn, addr = self.get_request()
except timeout:
continue
self.conn.settimeout(1)
break
self.socket.settimeout(None)
if not self.listening:
return
try:
self.process_request(self.conn, addr)
except Exception:
self.handle_error(self.conn, addr)
self.disconnect_client()
else:
self._thread = threading.Thread(
target=self.serve_forever,
name="WebWinHTTPPatternGeneratorServerThread",
)
self._thread.start()
print(lang.getstr("connection.established"))
if __name__ == "__main__":
patterngenerator = GenTCPSockPatternGeneratorServer()
displaycal-py3-3.9.19/DisplayCAL/pnp.ids 000664 000000 000000 00000172645 15225167330 017701 0 ustar 00root root 000000 000000 ? Unknown
AAA Avolites Ltd
AAE Anatek Electronics Inc.
AAM Aava Mobile Oy
AAN AAEON Technology Inc.
AAT Ann Arbor Technologies
ABA ABBAHOME INC.
ABC AboCom System Inc.
ABD Allen Bradley Company
ABE Alcatel Bell
ABO D-Link Systems Inc
ABS Abaco Systems, Inc.
ABT Anchor Bay Technologies, Inc.
ABV Advanced Research Technology
ACA Ariel Corporation
ACB Aculab Ltd
ACC Accton Technology Corporation
ACD AWETA BV
ACE Actek Engineering Pty Ltd
ACG A&R Cambridge Ltd.
ACH Archtek Telecom Corporation
ACI Ancor Communications Inc
ACK Acksys
ACL Apricot Computers
ACM Acroloop Motion Control Systems Inc
ACO Allion Computer Inc.
ACP Aspen Tech Inc
ACR Acer Technologies
ACS Altos Computer Systems
ACT Applied Creative Technology
ACU Acculogic
ACV ActivCard S.A
ADA Addi-Data GmbH
ADB Aldebbaron
ADC Acnhor Datacomm
ADD Advanced Peripheral Devices Inc
ADE Arithmos, Inc.
ADH Aerodata Holdings Ltd
ADI ADI Systems Inc
ADK Adtek System Science Company Ltd
ADL ASTRA Security Products Ltd
ADM Ad Lib MultiMedia Inc
ADN Analog & Digital Devices Tel. Inc
ADP Adaptec Inc
ADR Nasa Ames Research Center
ADS Analog Devices Inc
ADT Adtek
ADV Advanced Micro Devices Inc
ADX Adax Inc
ADZ ADDER TECHNOLOGY LTD
AEC Antex Electronics Corporation
AED Advanced Electronic Designs, Inc.
AEI Actiontec Electric Inc
AEJ Alpha Electronics Company
AEM ASEM S.p.A.
AEN Avencall
AEP Aetas Peripheral International
AET Aethra Telecomunicazioni S.r.l.
AFA Alfa Inc
AGC Beijing Aerospace Golden Card Electronic Engineering Co.,Ltd.
AGI Artish Graphics Inc
AGL Argolis
AGM Advan Int'l Corporation
AGO AlgolTek, Inc.
AGT Agilent Technologies
AHC Advantech Co., Ltd.
AHQ Astro HQ LLC
AHS Beijing AnHeng SecoTech Information Technology Co., Ltd.
AIC Arnos Insturments & Computer Systems
AIE Altmann Industrieelektronik
AII Amptron International Inc.
AIK Dongguan Alllike Electronics Co., Ltd.
AIL Altos India Ltd
AIM AIMS Lab Inc
AIR Advanced Integ. Research Inc
AIS Alien Internet Services
AIW Aiwa Company Ltd
AIX ALTINEX, INC.
AJA AJA Video Systems, Inc.
AKB Akebia Ltd
AKE AKAMI Electric Co.,Ltd
AKI AKIA Corporation
AKL AMiT Ltd
AKM Asahi Kasei Microsystems Company Ltd
AKP Atom Komplex Prylad
AKR Anker Innovations Limited
AKY Askey Computer Corporation
ALA Alacron Inc
ALC Altec Corporation
ALD In4S Inc
ALE Alenco BV
ALG Realtek Semiconductor Corp.
ALH AL Systems
ALI Acer Labs
ALJ Altec Lansing
ALK Acrolink Inc
ALL Alliance Semiconductor Corporation
ALM Acutec Ltd.
ALN Alana Technologies
ALO Algolith Inc.
ALP ALPS ALPINE CO., LTD.
ALR Advanced Logic
ALS Avance Logic Inc
ALT Altra
ALV AlphaView LCD
ALX ALEXON Co.,Ltd.
AMA Asia Microelectronic Development Inc
AMB Ambient Technologies, Inc.
AMC Attachmate Corporation
AMD Amdek Corporation
AMI American Megatrends Inc
AML Anderson Multimedia Communications (HK) Limited
AMN Amimon LTD.
AMO Amino Technologies PLC and Amino Communications Limited
AMP AMP Inc
AMR AmTRAN Technology Co., Ltd.
AMS ARMSTEL, Inc.
AMT AMT International Industry
AMX AMX LLC
ANA Anakron
ANC Ancot
AND Adtran Inc
ANI Anigma Inc
ANK Anko Electronic Company Ltd
ANL Analogix Semiconductor, Inc
ANO Anorad Corporation
ANP Andrew Network Production
ANR ANR Ltd
ANS Ansel Communication Company
ANT Ace CAD Enterprise Company Ltd
ANV Beijing ANTVR Technology Co., Ltd.
ANW Analog Way SAS
ANX Acer Netxus Inc
AOA AOpen Inc.
AOE Advanced Optics Electronics, Inc.
AOM Atomos
AOL America OnLine
AOT Alcatel
APC American Power Conversion
APD AppliAdata
APE ALPS ALPINE CO., LTD.
APG Horner Electric Inc
API A Plus Info Corporation
APL Aplicom Oy
APM Applied Memory Tech
APN Appian Tech Inc
APP Apple Computer Inc
APR Aprilia s.p.a.
APS Autologic Inc
APT Audio Processing Technology Ltd
APV A+V Link
APX AP Designs Ltd
ARC Alta Research Corporation
ARD AREC Inc.
ARE ICET S.p.A.
ARG Argus Electronics Co., LTD
ARI Argosy Research Inc
ARK Ark Logic Inc
ARL Arlotto Comnet Inc
ARM Arima
ARO Poso International B.V.
ARR ARRIS Group, Inc.
ARS Arescom Inc
ART Corion Industrial Corporation
ASC Ascom Strategic Technology Unit
ASD USC Information Sciences Institute
ASE AseV Display Labs
ASH Ashton Bentley Concepts
ASI Ahead Systems
ASK Ask A/S
ASL AccuScene Corporation Ltd
ASM ASEM S.p.A.
ASN Asante Tech Inc
ASP ASP Microelectronics Ltd
AST AST Research Inc
ASU Asuscom Network Inc
ASX AudioScience
ASY Rockwell Collins / Airshow Systems
ATA Allied Telesyn International (Asia) Pte Ltd
ATC Ably-Tech Corporation
ATD Alpha Telecom Inc
ATE Innovate Ltd
ATH Athena Informatica S.R.L.
ATI Allied Telesis KK
ATJ ArchiTek Corporation
ATK Allied Telesyn Int'l
ATL Arcus Technology Ltd
ATM ATM Ltd
ATN Athena Smartcard Solutions Ltd.
ATO ASTRO DESIGN, INC.
ATP Alpha-Top Corporation
ATT AT&T
ATU Avocor Technologies USA, Inc
ATV Office Depot, Inc.
ATX Athenix Corporation
AUD AudioControl
AUG August Home, Inc.
AUI ALPS ALPINE CO., LTD.
AUR Aureal Semiconductor
AUS ASUSTek COMPUTER INC
AUT Autotime Corporation
AUV Auvidea GmbH
AVA Avaya Communication
AVC Auravision Corporation
AVD Avid Electronics Corporation
AVE Add Value Enterpises (Asia) Pte Ltd
AVG Avegant Corporation
AVI Nippon Avionics Co.,Ltd
AVJ Atelier Vision Corporation
AVL Avalue Technology Inc.
AVM AVM GmbH
AVN Advance Computer Corporation
AVO Avocent Corporation
AVR AVer Information Inc.
AVS Avatron Software Inc.
AVT Avtek (Electronics) Pty Ltd
AVV SBS Technologies (Canada), Inc. (was Avvida Systems, Inc.)
AVX A/Vaux Electronics
AWC Access Works Comm Inc
AWL Aironet Wireless Communications, Inc
AWS Wave Systems
AXB Adrienne Electronics Corporation
AXC AXIOMTEK CO., LTD.
AXE Axell Corporation
AXI American Magnetics
AXL Axel
AXO Axonic Labs LLC
AXP American Express
AXT Axtend Technologies Inc
AXX Axxon Computer Corporation
AXY AXYZ Automation Services, Inc
AYD Aydin Displays
AYR Airlib, Inc
AZH Shenzhen three Connaught Information Technology Co., Ltd. (3nod Group)
AZM AZ Middelheim - Radiotherapy
AZT Aztech Systems Ltd
BAC Biometric Access Corporation
BAN Banyan
BBB an-najah university
BBH B&Bh
BBL Brain Boxes Limited
BBV BlueBox Video Limited
BBX Black Box Corporation
BCC Beaver Computer Corporaton
BCD Barco GmbH
BCI Broadata Communications Inc.
BCK Beck GmbH & Co. Elektronik Bauelemente KG
BCM Broadcom
BCQ Deutsche Telekom Berkom GmbH
BCS Booria CAD/CAM systems
BDO Brahler ICS
BDR Blonder Tongue Labs, Inc.
BDS Barco Display Systems
BEC Beckhoff Automation
BEI Beckworth Enterprises Inc
BEK Beko Elektronik A.S.
BEL Beltronic Industrieelektronik GmbH
BEO Baug & Olufsen
BFE B.F. Engineering Corporation
BGB Barco Graphics N.V
BGT Budzetron Inc
BHZ BitHeadz, Inc.
BIA Biamp Systems Corporation
BIC Big Island Communications
BIG Bigscreen, Inc.
BII Boeckeler Instruments Inc
BIL Billion Electric Company Ltd
BIO BioLink Technologies International, Inc.
BIT Bit 3 Computer
BLD BILD INNOVATIVE TECHNOLOGY LLC
BLI Busicom
BLN BioLink Technologies
BLP Bloomberg L.P.
BMD Blackmagic Design
BMI Benson Medical Instruments Company
BML BIOMED Lab
BMS BIOMEDISYS
BNE Bull AB
BNK Banksia Tech Pty Ltd
BNO Bang & Olufsen
BNS Boulder Nonlinear Systems
BOB Rainy Orchard
BOE BOE
BOI NINGBO BOIGLE DIGITAL TECHNOLOGY CO.,LTD
BOS BOS
BPD Micro Solutions, Inc.
BPS Barco, N.V.
BPU Best Power
BRA Braemac Pty Ltd
BRC BARC
BRG Bridge Information Co., Ltd
BRI Boca Research Inc
BRL Brainlab AG
BRM Braemar Inc
BRO BROTHER INDUSTRIES,LTD.
BSE Bose Corporation
BSG Robert Bosch GmbH
BSL Biomedical Systems Laboratory
BSN BRIGHTSIGN, LLC
BST BodySound Technologies, Inc.
BTC Bit 3 Computer
BTE Brilliant Technology
BTF Bitfield Oy
BTI BusTech Inc
BTO BioTao Ltd
BUF Yasuhiko Shirai Melco Inc
BUG B.U.G., Inc.
BUJ ATI Tech Inc
BUL Bull
BUR B&R Industrial Automation GmbH
BUS BusTek
BUT 21ST CENTURY ENTERTAINMENT
BWK Bitworks Inc.
BXE Buxco Electronics
BYD byd:sign corporation
CAA Castles Automation Co., Ltd
CAC CA & F Elettronica
CAG CalComp
CAI Canon Inc.
CAL Acon
CAM Cambridge Audio
CAN Canopus Company Ltd
CAR Cardinal Company Ltd
CAS CASIO COMPUTER CO.,LTD
CAT Consultancy in Advanced Technology
CAV Cavium Networks, Inc
CBI ComputerBoards Inc
CBR Cebra Tech A/S
CBT Cabletime Ltd
CBX Cybex Computer Products Corporation
CCC C-Cube Microsystems
CCI Cache
CCJ CONTEC CO.,LTD.
CCL CCL/ITRI
CCP Capetronic USA Inc
CDC Core Dynamics Corporation
CDD Convergent Data Devices
CDE Colin.de
CDG Christie Digital Systems Inc
CDI Concept Development Inc
CDK Cray Communications
CDN Codenoll Technical Corporation
CDP CalComp
CDS Computer Diagnostic Systems
CDT IBM Corporation
CDV Convergent Design Inc.
CEA Consumer Electronics Association
CEC Chicony Electronics Company Ltd
CED Cambridge Electronic Design Ltd
CEF Cefar Digital Vision
CEI Crestron Electronics, Inc.
CEM MEC Electronics GmbH
CEN Centurion Technologies P/L
CEP C-DAC
CER Ceronix
CET TEC CORPORATION
CFG Atlantis
CFR Meta View, Inc.
CGA Chunghwa Picture Tubes, LTD
CGS Chyron Corp
CGT congatec AG
CHA Chase Research PLC
CHD ChangHong Electric Co.,Ltd
CHE Acer Inc
CHG Sichuan Changhong Electric CO, LTD.
CHI Chrontel Inc
CHL Chloride-R&D
CHM CHIC TECHNOLOGY CORP.
CHO Sichuang Changhong Corporation
CHP CH Products
CHR christmann informationstechnik + medien GmbH & Co. KG
CHS Agentur Chairos
CHT Chunghwa Picture Tubes,LTD.
CHY Cherry GmbH
CIC Comm. Intelligence Corporation
CIE Convergent Engineering, Inc.
CII Cromack Industries Inc
CIL Citicom Infotech Private Limited
CIN Citron GmbH
CIP Ciprico Inc
CIR Cirrus Logic Inc
CIS Cisco Systems Inc
CIT Citifax Limited
CKC The Concept Keyboard Company Ltd
CKJ Carina System Co., Ltd.
CLA Clarion Company Ltd
CLD COMMAT L.t.d.
CLE Classe Audio
CLG CoreLogic
CLI Cirrus Logic Inc
CLM CrystaLake Multimedia
CLO Clone Computers
CLR Clover Electronics
CLT automated computer control systems
CLV Clevo Company
CLX CardLogix
CMC CMC Ltd
CMD Colorado MicroDisplay, Inc.
CMG Chenming Mold Ind. Corp.
CMI C-Media Electronics
CMK Comark LLC
CMM Comtime GmbH
CMN Chimei Innolux Corporation
CMO Chi Mei Optoelectronics corp.
CMR Cambridge Research Systems Ltd
CMS CompuMaster Srl
CMX Comex Electronics AB
CNB American Power Conversion
CNC Alvedon Computers Ltd
CND Micro-Star Int'l Co., Ltd.
CNE Cine-tal
CNI Connect Int'l A/S
CNN Canon Inc
CNT COINT Multimedia Systems
COB COBY Electronics Co., Ltd
COD CODAN Pty. Ltd.
COI Codec Inc.
COL Rockwell Collins, Inc.
COM Comtrol Corporation
CON Contec Company Ltd
COO coolux GmbH
COR Corollary Inc
COS CoStar Corporation
COT Core Technology Inc
COW Polycow Productions
COX Comrex
CPC Ciprico Inc
CPD CompuAdd
CPI Computer Peripherals Inc
CPL Compal Electronics Inc
CPM Capella Microsystems Inc.
CPP Compound Photonics
CPQ Compaq Computer Company
CPT cPATH
CPX Powermatic Data Systems
CRA CRALTECH ELECTRONICA, S.L.
CRC CONRAC GmbH
CRD Cardinal Technical Inc
CRE Creative Labs Inc
CRH Contemporary Research Corp.
CRI Crio Inc.
CRL Creative Logic
CRM CORSAIR MEMORY Inc.
CRN Cornerstone Imaging
CRO Extraordinary Technologies PTY Limited
CRQ Cirque Corporation
CRS Crescendo Communication Inc
CRV Cerevo Inc.
CRW Cammegh Limited
CRX Cyrix Corporation
CSB Transtex SA
CSC Crystal Semiconductor
CSD Cresta Systems Inc
CSE Concept Solutions & Engineering
CSI Cabletron System Inc
CSL Cloudium Systems Ltd.
CSM Cosmic Engineering Inc.
CSO California Institute of Technology
CSS CSS Laboratories
CST CSTI Inc
CSW China Star Optoelectronics Technology Co., Ltd
CTA CoSystems Inc
CTC CTC Communication Development Company Ltd
CTE Chunghwa Telecom Co., Ltd.
CTL Creative Technology Ltd
CTM Computerm Corporation
CTN Computone Products
CTP Computer Technology Corporation
CTR Control4 Corporation
CTS Comtec Systems Co., Ltd.
CTX Creatix Polymedia GmbH
CUB Cubix Corporation
CUK Calibre UK Ltd
CVA Covia Inc.
CVI Colorado Video, Inc.
CVP Chromatec Video Products Ltd
CVS Clarity Visual Systems
CWC Curtiss-Wright Controls, Inc.
CWR Connectware Inc
CXT Conexant Systems
CYB CyberVision
CYC Cylink Corporation
CYD Cyclades Corporation
CYL Cyberlabs
CYP CYPRESS SEMICONDUCTOR CORPORATION
CYT Cytechinfo Inc
CYV Cyviz AS
CYW Cyberware
CYX Cyrix Corporation
CZC Shenzhen ChuangZhiCheng Technology Co., Ltd.
CZE Carl Zeiss AG
DAC Digital Acoustics Corporation
DAE Digatron Industrie Elektronik GmbH
DAI DAIS SET Ltd.
DAK Daktronics
DAL Digital Audio Labs Inc
DAN Danelec Marine A/S
DAS DAVIS AS
DAT Datel Inc
DAU Daou Tech Inc
DAV Davicom Semiconductor Inc
DAW DA2 Technologies Inc
DAX Data Apex Ltd
DBD Diebold Inc.
DBI DigiBoard Inc
DBK Databook Inc
DBL Doble Engineering Company
DBN DB Networks Inc
DCA Digital Communications Association
DCC Dale Computer Corporation
DCD Datacast LLC
DCE dSPACE GmbH
DCI Concepts Inc
DCL Dynamic Controls Ltd
DCM DCM Data Products
DCO Dialogue Technology Corporation
DCR Decros Ltd
DCS Diamond Computer Systems Inc
DCT Dancall Telecom A/S
DCV Datatronics Technology Inc
DDA DA2 Technologies Corporation
DDD Danka Data Devices
DDE Datasat Digital Entertainment
DDI Data Display AG
DDS Barco, N.V.
DDT Datadesk Technologies Inc
DDV Delta Information Systems, Inc
DEC Digital Equipment Corporation
DEI Deico Electronics
DEL Dell, Inc.
DEM DemoPad Software Ltd
DEN Densitron Computers Ltd
DEX idex displays
DFI DFI
DFK SharkTec A/S
DFT DEI Holdings dba Definitive Technology
DGA Digiital Arts Inc
DGC Data General Corporation
DGI DIGI International
DGK DugoTech Co., LTD
DGP Digicorp European sales S.A.
DGS Diagsoft Inc
DGT Dearborn Group Technology
DHD Dension Audio Systems
DHP DH Print
DHQ Quadram
DHT Projectavision Inc
DIA Diadem
DIG Digicom S.p.A.
DII Dataq Instruments Inc
DIM dPict Imaging, Inc.
DIN Daintelecom Co., Ltd
DIS Diseda S.A.
DIT Dragon Information Technology
DJE Capstone Visua lProduct Development
DJP Maygay Machines, Ltd
DKY Datakey Inc
DLB Dolby Laboratories Inc.
DLC Diamond Lane Comm. Corporation
DLD Delem
DLG Digital-Logic GmbH
DLK D-Link Systems Inc
DLL Dell Inc
DLM DLOGIC Ltd.
DLO Shenzhen Dlodlo Technologies Co., Ltd.
DLT Digitelec Informatique Park Cadera
DMB Digicom Systems Inc
DMC Dune Microsystems Corporation
DMG Monoprice.Inc
DMM Dimond Multimedia Systems Inc
DMN Dimension Engineering LLC
DMO Data Modul AG
DMP D&M Holdings Inc, Professional Business Company
DMS DOME imaging systems
DMT Distributed Management Task Force, Inc. (DMTF)
DMV NDS Ltd
DNA DNA Enterprises, Inc.
DNG Apache Micro Peripherals Inc
DNI Deterministic Networks Inc.
DNT Dr. Neuhous Telekommunikation GmbH
DNV DiCon
DOL Dolman Technologies Group Inc
DOM Dome Imaging Systems
DON DENON, Ltd.
DOT Dotronic Mikroelektronik GmbH
DPA DigiTalk Pro AV
DPC Delta Electronics Inc
DPH Delphi Automotive LLP
DPI DocuPoint
DPL Digital Projection Limited
DPM ADPM Synthesis sas
DPN Shanghai Lexiang Technology Limited
DPS Digital Processing Systems
DPT DPT
DPX DpiX, Inc.
DQB Datacube Inc
DRB Dr. Bott KG
DRC Data Ray Corp.
DRD DIGITAL REFLECTION INC.
DRI Data Race Inc
DRS DRS Defense Solutions, LLC
DSA Display Solution AG
DSD DS Multimedia Pte Ltd
DSG Disguise Technologies
DSI Digitan Systems Inc
DSJ VR Technology Holdings Limited
DSM DSM Digital Services GmbH
DSP Domain Technology Inc
DTA DELTATEC
DTC DTC Tech Corporation
DTE Dimension Technologies, Inc.
DTI Diversified Technology, Inc.
DTK Dynax Electronics (HK) Ltd
DTL e-Net Inc
DTN Datang Telephone Co
DTO Deutsche Thomson OHG
DTT Design & Test Technology, Inc.
DTX Data Translation
DUA Dosch & Amand GmbH & Company KG
DUN NCR Corporation
DVD Dictaphone Corporation
DVL Devolo AG
DVS Digital Video System
DVT Data Video
DWE Daewoo Electronics Company Ltd
DXC Digipronix Control Systems
DXD DECIMATOR DESIGN PTY LTD
DXL Dextera Labs Inc
DXN Dixon Technologies (India) Limited
DXP Data Expert Corporation
DXS Signet
DYC Dycam Inc
DYM Dymo-CoStar Corporation
DYN Askey Computer Corporation
DYX Dynax Electronics (HK) Ltd
EAC Emotiva Audio Corp.
EAG ELTEC Elektronik AG
EAS Evans and Sutherland Computer
EBH Data Price Informatica
EBS EBS Euchner Büro- und Schulsysteme GmbH
EBT HUALONG TECHNOLOGY CO., LTD
ECA Electro Cam Corp.
ECC ESSential Comm. Corporation
ECH EchoStar Corporation
ECI Enciris Technologies
ECK Eugene Chukhlomin Sole Proprietorship, d.b.a.
ECL Excel Company Ltd
ECM E-Cmos Tech Corporation
ECO Echo Speech Corporation
ECP Elecom Company Ltd
ECS Elitegroup Computer Systems Company Ltd
ECT Enciris Technologies
EDC e.Digital Corporation
EDG Electronic-Design GmbH
EDI Edimax Tech. Company Ltd
EDM EDMI
EDT Emerging Display Technologies Corp
EEE ET&T Technology Company Ltd
EEH EEH Datalink GmbH
EEI ELARABY COMPANY FOR ENGINEERING INDUSTRIES
EEP E.E.P.D. GmbH
EES EE Solutions, Inc.
EGA Elgato Systems LLC
EGD EIZO GmbH Display Technologies
EGL Eagle Technology
EGN Egenera, Inc.
EGO Ergo Electronics
EHJ Epson Research
EHN Enhansoft
EIC Eicon Technology Corporation
EIN Elegant Invention
EKA MagTek Inc.
EKC Eastman Kodak Company
EKS EKSEN YAZILIM
ELA ELAD srl
ELC Electro Scientific Ind
ELD Express Luck, Inc.
ELE Elecom Company Ltd
ELG Elmeg GmbH Kommunikationstechnik
ELI Edsun Laboratories
ELL Electrosonic Ltd
ELM Elmic Systems Inc
ELO Elo TouchSystems Inc
ELS ELSA GmbH
ELT Element Labs, Inc.
ELU Express Industrial, Ltd.
ELX Elonex PLC
EMB Embedded computing inc ltd
EMC eMicro Corporation
EMD Embrionix Design Inc.
EME EMiNE TECHNOLOGY COMPANY, LTD.
EMG EMG Consultants Inc
EMI Ex Machina Inc
EMK Emcore Corporation
EMO ELMO COMPANY, LIMITED
EMR ICC Intelligent Platforms GmbH
EMU Emulex Corporation
ENC Eizo Nanao Corporation
END ENIDAN Technologies Ltd
ENE ENE Technology Inc.
ENI Efficient Networks
ENS Ensoniq Corporation
ENT Enterprise Comm. & Computing Inc
EON Eon Instrumentation, Inc.
EPC Empac
EPH Epiphan Systems Inc.
EPI Envision Peripherals, Inc
EPN EPiCON Inc.
EPS KEPS
EQP Equipe Electronics Ltd.
EQX Equinox Systems Inc
ERG Ergo System
ERI Ericsson Mobile Communications AB
ERN Ericsson, Inc.
ERP Euraplan GmbH
ERS Eizo Rugged Solutions
ERT Escort Insturments Corporation
ESA Elbit Systems of America
ESB ScioTeq
ESC Eden Sistemas de Computacao S/A
ESD Ensemble Designs, Inc
ESG ELCON Systemtechnik GmbH
ESI Extended Systems, Inc.
ESK ES&S
ESL Esterline Technologies
ESN eSATURNUS
ESS ESS Technology Inc
EST Embedded Solution Technology
ESY E-Systems Inc
ETC Everton Technology Company Ltd
ETD ELAN MICROELECTRONICS CORPORATION
ETG Eizo Technologies GmbH
ETH Etherboot Project
ETI Eclipse Tech Inc
ETK eTEK Labs Inc.
ETL Evertz Microsystems Ltd.
ETS Electronic Trade Solutions Ltd
ETT E-Tech Inc
EUT Ericsson Mobile Networks B.V.
EVE Advanced Micro Peripherals Ltd
EVI eviateg GmbH
EVP EverPro Technologies Company Limited
EVX Everex
EXA Exabyte
EXC Excession Audio
EXI Exide Electronics
EXN RGB Systems, Inc. dba Extron Electronics
EXP Data Export Corporation
EXR Explorer Inc.
EXT Exatech Computadores & Servicos Ltda
EXX Exxact GmbH
EXY Exterity Ltd
EYE eyevis GmbH
EYF eyefactive Gmbh
EZE EzE Technologies
EZP Storm Technology
FAN Fantalooks Co., Ltd.
FAR Farallon Computing
FBI Interface Corporation
FCB Furukawa Electric Company Ltd
FCG First International Computer Ltd
FCS Focus Enhancements, Inc.
FDC Future Domain
FDD Forth Dimension Displays Ltd
FDI Future Designs, Inc.
FDT Fujitsu Display Technologies Corp.
FDX Findex, Inc.
FEC FURUNO ELECTRIC CO., LTD.
FEL Fellowes & Questec
FEN Fen Systems Ltd.
FER Ferranti Int'L
FFC FUJIFILM Corporation
FFI Fairfield Industries
FGD Lisa Draexlmaier GmbH
FGL Fujitsu General Limited.
FHL FHLP
FIC Formosa Industrial Computing Inc
FIL Forefront Int'l Ltd
FIN Finecom Co., Ltd.
FIR Chaplet Systems Inc
FIS FLY-IT Simulators
FIT Feature Integration Technology Inc.
FJC FCL COMPONENTS LIMITED
FJS Fujitsu Spain
FJT F.J. Tieman BV
FLE ADTI Media, Inc
FLD Flanders Scientific, Inc.
FLI Faroudja Laboratories
FLY Butterfly Communications
FMA Fast Multimedia AG
FMC Ford Microelectronics Inc
FMI Fellowes, Inc.
FML Fujitsu Microelect Ltd
FMZ Formoza-Altair
FNC Fanuc LTD
FNI Funai Electric Co., Ltd.
FOA FOR-A Company Limited
FOK Fokus Technologies GmbH
FOS Foss Tecator
FOV FOVE INC
FOX HON HAI PRECISON IND.CO.,LTD.
FPC Fingerprint Cards AB
FPE Fujitsu Peripherals Ltd
FPS Deltec Corporation
FPX Cirel Systemes
FRC Force Computers
FRD Freedom Scientific BLV
FRE Forvus Research Inc
FRI Fibernet Research Inc
FRO FARO Technologies
FRS South Mountain Technologies, LTD
FSC Future Systems Consulting KK
FSI Fore Systems Inc
FST Modesto PC Inc
FTC Futuretouch Corporation
FTE Frontline Test Equipment Inc.
FTG FTG Data Systems
FTI FastPoint Technologies, Inc.
FTL FUJITSU TEN LIMITED
FTN Fountain Technologies Inc
FTR Mediasonic
FTS FocalTech Systems Co., Ltd.
FTW MindTribe Product Engineering, Inc.
FUJ Fujitsu Ltd
FUL Fun Technology Innovation INC.
FUN sisel muhendislik
FUS Fujitsu Siemens Computers GmbH
FVC First Virtual Corporation
FVX C-C-C Group Plc
FWA Attero Tech, LLC
FWR Flat Connections Inc
FXX Fuji Xerox
FZC Founder Group Shenzhen Co.
FZI FZI Forschungszentrum Informatik
GAC GreenArrays, Inc.
GAG Gage Applied Sciences Inc
GAL Galil Motion Control
GAU Gaudi Co., Ltd.
GBT GIGA-BYTE TECHNOLOGY CO., LTD.
GCC GCC Technologies Inc
GCI Gateway Comm. Inc
GCS Grey Cell Systems Ltd
GDC General Datacom
GDI G. Diehl ISDN GmbH
GDS GDS
GDT Vortex Computersysteme GmbH
GEC Gechic Corporation
GED General Dynamics C4 Systems
GEF GE Fanuc Embedded Systems
GEH Abaco Systems, Inc.
GEM Gem Plus
GEN Genesys ATE Inc
GEO GEO Sense
GER GERMANEERS GmbH
GES GES Singapore Pte Ltd
GET Getac Technology Corporation
GFM GFMesstechnik GmbH
GFN Gefen Inc.
GGL Google Inc.
GGT G2TOUCH KOREA
GIC General Inst. Corporation
GIM Guillemont International
GIP GI Provision Ltd
GIS AT&T Global Info Solutions
GJN Grand Junction Networks
GLD Goldmund - Digital Audio SA
GLE AD electronics
GLM Genesys Logic
GLS Gadget Labs LLC
GMK GMK Electronic Design GmbH
GML General Information Systems
GMM GMM Research Inc
GMN GEMINI 2000 Ltd
GMX GMX Inc
GND Gennum Corporation
GNN GN Nettest Inc
GNZ Gunze Ltd
GOE GOEPEL electronic GmbH
GPR GoPro, Inc.
GRA Graphica Computer
GRE GOLD RAIN ENTERPRISES CORP.
GRH Granch Ltd
GRM Garmin International
GRV Advanced Gravis
GRY Robert Gray Company
GSB NIPPONDENCHI CO,.LTD
GSC General Standards Corporation
GSM Goldstar Company Ltd
GSN Grandstream Networks, Inc.
GST Graphic SystemTechnology
GSY Grossenbacher Systeme AG
GTC Graphtec Corporation
GTI Goldtouch
GTK G-Tech Corporation
GTM Garnet System Company Ltd
GTS Geotest Marvin Test Systems Inc
GTT General Touch Technology Co., Ltd.
GUD Guntermann & Drunck GmbH
GUP GoUp Co.,Ltd
GUZ Guzik Technical Enterprises
GVC GVC Corporation
GVL Global Village Communication
GVS G.VISION
GWI GW Instruments
GWK Gateworks Corporation
GWY Gateway 2000
GXL Galaxy Microsystems Ltd.
GZE GUNZE Limited
HAE Haider electronics
HAI Haivision Systems Inc.
HAL Halberthal
HAN Hanchang System Corporation
HAR Harris Corporation
HAY Hayes Microcomputer Products Inc
HCA DAT
HCE Hitachi Consumer Electronics Co., Ltd
HCL HCL America Inc
HCM HCL Peripherals
HCP Hitachi Computer Products Inc
HCW Hauppauge Computer Works Inc
HDC HardCom Elektronik & Datateknik
HDI HD-INFO d.o.o.
HDV Holografika kft.
HEC Hisense Electric Co., Ltd.
HEL Hitachi Micro Systems Europe Ltd
HER Ascom Business Systems
HET HETEC Datensysteme GmbH
HHC HIRAKAWA HEWTECH CORP.
HHI Fraunhofer Heinrich-Hertz-Institute
HHT Hitevision Group
HIB Hibino Corporation
HIC Hitachi Information Technology Co., Ltd.
HII Harman International Industries, Inc
HIK Hikom Co., Ltd.
HIL Hilevel Technology
HIQ Kaohsiung Opto Electronics Americas, Inc.
HIS Hope Industrial Systems, Inc.
HIT Hitachi America Ltd
HJI Harris & Jeffries Inc
HKA HONKO MFG. CO., LTD.
HKC HKC OVERSEAS LIMITED
HKG Josef Heim KG
HLG China Hualu Group Co., Ltd.
HMC Hualon Microelectric Corporation
HMK hmk Daten-System-Technik BmbH
HMX HUMAX Co., Ltd.
HNM HONOR Device Co., Ltd.
HNS Hughes Network Systems
HOB HOB Electronic GmbH
HOE Hosiden Corporation
HOL Holoeye Photonics AG
HON Sonitronix
HPA Zytor Communications
HPC Hewlett-Packard Co.
HPD Hewlett Packard
HPE Hewlett Packard Enterprise
HPI Headplay, Inc.
HPK HAMAMATSU PHOTONICS K.K.
HPN HP Inc.
HPQ Hewlett-Packard Co.
HPR H.P.R. Electronics GmbH
HRC Hercules
HRE Qingdao Haier Electronics Co., Ltd.
HRI Hall Research
HRL Herolab GmbH
HRS Harris Semiconductor
HRT HERCULES
HSC Hagiwara Sys-Com Company Ltd
HSD HannStar Display Corp
HSM AT&T Microelectronics
HSN Hansung Co., Ltd
HSP HannStar Display Corp
HST Horsent Technology Co., Ltd.
HTC Hitachi Ltd
HTI Hampshire Company, Inc.
HTK Holtek Microelectronics Inc
HTL HTBLuVA Mödling
HTR Shenzhen ZhuoYi HengTong Computer Technology Limited
HTX Hitex Systementwicklung GmbH
HUB GAI-Tronics, A Hubbell Company
HUK Hoffmann + Krippner GmbH
HUM IMP Electronics Ltd.
HVR HTC Corportation
HWA Harris Canada Inc
HWC DBA Hans Wedemeyer
HWD Highwater Designs Ltd
HWP Hewlett Packard
HWV Huawei Technologies Co., Inc.
HXM Hexium Ltd.
HYC Hypercope Gmbh Aachen
HYD Hydis Technologies.Co.,LTD
HYL Shanghai Chai Ming Huang Info&Tech Co, Ltd
HYO HYC CO., LTD.
HYP Hyphen Ltd
HYR Hypertec Pty Ltd
HYT Heng Yu Technology (HK) Limited
HYV Hynix Semiconductor
IAD IAdea Corporation
IAF Institut f r angewandte Funksystemtechnik GmbH
IAI Integration Associates, Inc.
IAT IAT Germany GmbH
IBC Integrated Business Systems
IBI INBINE.CO.LTD
IBM IBM Brasil
IBP IBP Instruments GmbH
IBR IBR GmbH
ICA ICA Inc
ICC BICC Data Networks Ltd
ICD ICD Inc
ICE IC Ensemble
ICI Infotek Communication Inc
ICM Intracom SA
ICN Sanyo Icon
ICO Intel Corp
ICP ICP Electronics, Inc./iEi Technology Corp.
ICR Icron
ICS Integrated Circuit Systems
ICV Inside Contactless
ICX ICCC A/S
IDC International Datacasting Corporation
IDE IDE Associates
IDK IDK Corporation
IDN Idneo Technologies
IDO IDEO Product Development
IDP Integrated Device Technology, Inc.
IDS Interdigital Sistemas de Informacao
IDT International Display Technology
IDX IDEXX Labs
IEC Interlace Engineering Corporation
IEE IEE
IEI Interlink Electronics
IFS In Focus Systems Inc
IFT Informtech
IFX Infineon Technologies AG
IFZ Infinite Z
IGC Intergate Pty Ltd
IGM IGM Communi
IHE InHand Electronics
IIC ISIC Innoscan Industrial Computers A/S
III Intelligent Instrumentation
IIN IINFRA Co., Ltd
IIT Informatik Information Technologies
IKE Ikegami Tsushinki Co. Ltd.
IKS Ikos Systems Inc
ILC Image Logic Corporation
ILS Innotech Corporation
IMA Imagraph
IMB ART s.r.l.
IMC IMC Networks
IMD ImasDe Canarias S.A.
IME Imagraph
IMF Immersive Audio Technologies France
IMG IMAGENICS Co., Ltd.
IMI International Microsystems Inc
IMM Immersion Corporation
IMN Impossible Production
IMP Impinj
IMT Inmax Technology Corporation
IMX arpara Technology Co., Ltd.
INA Inventec Corporation
INC Home Row Inc
IND ILC
INE Inventec Electronics (M) Sdn. Bhd.
INF Inframetrics Inc
ING Integraph Corporation
INI Initio Corporation
INK Indtek Co., Ltd.
INL InnoLux Display Corporation
INM InnoMedia Inc
INN Innovent Systems, Inc.
INO Innolab Pte Ltd
INP Interphase Corporation
INS Ines GmbH
INT Interphase Corporation
INU Inovatec S.p.A.
INV Inviso, Inc.
INX Communications Supply Corporation (A division of WESCO)
INZ Best Buy
IOA CRE Technology Corporation
IOC Guangxi Century Innovation Display Electronics Co., Ltd
IOD I-O Data Device Inc
IOM Iomega
ION Inside Out Networks
IOS i-O Display System
IOT I/OTech Inc
IPC IPC Corporation
IPD Industrial Products Design, Inc.
IPI Intelligent Platform Management Interface (IPMI) forum (Intel, HP, NEC, Dell)
IPM IPM Industria Politecnica Meridionale SpA
IPN Performance Technologies
IPP IP Power Technologies GmbH
IPQ IP3 Technology Ltd.
IPR Ithaca Peripherals
IPS IPS, Inc. (Intellectual Property Solutions, Inc.)
IPT International Power Technologies
IPW IPWireless, Inc
IQI IneoQuest Technologies, Inc
IQT IMAGEQUEST Co., Ltd
IRD Irdata
ISA Symbol Technologies
ISC Id3 Semiconductors
ISG Insignia Solutions Inc
ISI Interface Solutions
ISL Isolation Systems
ISM Image Stream Medical
ISP IntreSource Systems Pte Ltd
ISR INSIS Co., LTD.
ISS ISS Inc
IST Intersolve Technologies
ISY International Integrated Systems,Inc.(IISI)
ITA Itausa Export North America
ITC Intercom Inc
ITD Internet Technology Corporation
ITE Integrated Tech Express Inc
ITI VanErum Group
ITK ITK Telekommunikation AG
ITL Inter-Tel
ITM ITM inc.
ITN The NTI Group
ITP IT-PRO Consulting und Systemhaus GmbH
ITR Infotronic America, Inc.
ITS IDTECH
ITT I&T Telecom.
ITX integrated Technology Express Inc
IUC ICSL
IVI Intervoice Inc
IVM Iiyama North America
IVO InfoVision Optoelectronics (Kunshan) Co.,Ltd China
IVR Inlife-Handnet Co., Ltd.
IVS Intevac Photonics Inc.
IWR Icuiti Corporation
IWX Intelliworxx, Inc.
IXD Intertex Data AB
IXN Shenzhen Inet Mobile Internet Technology Co., LTD
JAC Astec Inc
JAE Japan Aviation Electronics Industry, Limited
JAS Janz Automationssysteme AG
JAT Jaton Corporation
JAZ Carrera Computer Inc
JCE Jace Tech Inc
JDI Japan Display Inc.
JDL Japan Digital Laboratory Co.,Ltd.
JEM Japan E.M.Solutions Co., Ltd.
JEN N-Vision
JET JET POWER TECHNOLOGY CO., LTD.
JFX Jones Futurex Inc
JGD University College
JIC Jaeik Information & Communication Co., Ltd.
JKC JVC KENWOOD Corporation
JLK UNIONMAN TECHNOLOGY CO., LTD
JMT Micro Technical Company Ltd
JPC JPC Technology Limited
JPW Wallis Hamilton Industries
JQE CNet Technical Inc
JSD JS DigiTech, Inc
JSI Jupiter Systems, Inc.
JSK SANKEN ELECTRIC CO., LTD
JTS JS Motorsports
JTY jetway security micro,inc
JUK Janich & Klass Computertechnik GmbH
JUP Jupiter Systems
JVC JVC
JWD Video International Inc.
JWL Jewell Instruments, LLC
JWS JWSpencer & Co.
JWY Jetway Information Co., Ltd
KAR Karna
KBI Kidboard Inc
KBL Kobil Systems GmbH
KCD Chunichi Denshi Co.,LTD.
KCL Keycorp Ltd
KDE KDE
KDK Kodiak Tech
KDM Korea Data Systems Co., Ltd.
KDS KDS USA
KDT KDDI Technology Corporation
KEC Kyushu Electronics Systems Inc
KEM Kontron Embedded Modules GmbH
KES Kesa Corporation
KEU Kontron Europe GmbH
KEY Key Tech Inc
KFC SCD Tech
KFE Komatsu Forest
KFX Kofax Image Products
KGI Klipsch Group, Inc
KGL KEISOKU GIKEN Co.,Ltd.
KGN KOGAN AUSTRALIA PTY LTD
KIO Kionix, Inc.
KIS KiSS Technology A/S
KLT Colorlight
KMC Mitsumi Company Ltd
KME KIMIN Electronics Co., Ltd.
KML Kensington Microware Ltd
KMR Kramer Electronics Ltd. International
KNC Konica corporation
KNX Nutech Marketing PTL
KOB Kobil Systems GmbH
KOD Eastman Kodak Company
KOE KOLTER ELECTRONIC
KOL Kollmorgen Motion Technologies Group
KOM Kontron GmbH
KOP Kopin Corporation
KOU KOUZIRO Co.,Ltd.
KOW KOWA Company,LTD.
KPC King Phoenix Company
KPT TPK Holding Co., Ltd
KRL Krell Industries Inc.
KRM Kroma Telecom
KRY Kroy LLC
KSC Kinetic Systems Corporation
KSG KUPA China Shenzhen Micro Technology Co., Ltd. Gold Institute
KSL Karn Solutions Ltd.
KSX King Tester Corporation
KTC Kingston Tech Corporation
KTD Takahata Electronics Co.,Ltd.
KTE K-Tech
KTG Kayser-Threde GmbH
KTI Konica Technical Inc
KTK Key Tronic Corporation
KTN Katron Tech Inc
KTS Kyokko Communication System Co., Ltd.
KUR Kurta Corporation
KVA Kvaser AB
KVX KeyView
KWD Kenwood Corporation
KYC Kyocera Corporation
KYE KYE Syst Corporation
KYK Samsung Electronics America Inc
KYN KEYENCE CORPORATION
KZI K-Zone International co. Ltd.
KZN K-Zone International
LAB ACT Labs Ltd
LAC LaCie
LAF Microline
LAG Laguna Systems
LAN Sodeman Lancom Inc
LAS LASAT Comm. A/S
LAV Lava Computer MFG Inc
LBO Lubosoft
LCC LCI
LCD Toshiba Matsushita Display Technology Co., Ltd
LCE La Commande Electronique
LCI Lite-On Communication Inc
LCM Latitude Comm.
LCN LEXICON
LCP Silent Power Electronics GmbH
LCS Longshine Electronics Company
LCT Labcal Technologies
LDN Laserdyne Technologies
LDT LogiDataTech Electronic GmbH
LEC Lectron Company Ltd
LED Long Engineering Design Inc
LEG Legerity, Inc
LEN Lenovo Group Limited
LEO First International Computer Inc
LEX Lexical Ltd
LGC Logic Ltd
LGD LG Display
LGI Logitech Inc
LGS LG Semicom Company Ltd
LGX Lasergraphics, Inc.
LHA Lars Haagh ApS
LHC Beihai Century Joint Innovation Technology Co.,Ltd
LHE Lung Hwa Electronics Company Ltd
LHT Lighthouse Technologies Limited
LIN Lenovo Beijing Co. Ltd.
LIP Linked IP GmbH
LIS Life is Style Inc.
LIT Lithics Silicon Technology
LJX Datalogic Corporation
LKM Likom Technology Sdn. Bhd.
LLL L-3 Communications
LLT LUMINO Licht Elektronik GmbH
LMG Lucent Technologies
LMI Lexmark Int'l Inc
LMP Leda Media Products
LMS Lumens Digital Optics Inc.
LMT Laser Master
LNC Lincoln Technology Solutions
LND Land Computer Company Ltd
LNK Link Tech Inc
LNR Linear Systems Ltd.
LNT LANETCO International
LNV Lenovo
LNX The Linux Foundation
LOC Locamation B.V.
LOE Loewe Opta GmbH
LOG Logicode Technology Inc
LOL Litelogic Operations Ltd
LPE El-PUSK Co., Ltd.
LPI Design Technology
LSC LifeSize Communications
LSD Intersil Corporation
LSI Loughborough Sound Images
LSJ LSI Japan Company Ltd
LSL Logical Solutions
LSP Lightspace Technologies
LSY LSI Systems Inc
LTC Labtec Inc
LTI Jongshine Tech Inc
LTK Lucidity Technology Company Ltd
LTN Litronic Inc
LTS LTS Scale LLC
LTV Leitch Technology International Inc.
LTW Lightware, Inc
LUC Lucent Technologies
LUM Lumagen, Inc.
LUX Luxxell Research Inc
LVI LVI Low Vision International AB
LWC Labway Corporation
LWR Lightware Visual Engineering
LWW Lanier Worldwide
LXC LXCO Technologies AG
LXN Luxeon
LXS ELEA CardWare
LZX Lightwell Company Ltd
MAC MAC System Company Ltd
MAD Xedia Corporation
MAE Maestro Pty Ltd
MAG MAG InnoVision
MAI Mutoh America Inc
MAL Meridian Audio Ltd
MAN LGIC
MAS Mass Inc.
MAT Panasonic Connect Co.,Ltd.
MAX Rogen Tech Distribution Inc
MAY Maynard Electronics
MAZ MAZeT GmbH
MBC MBC
MBD Microbus PLC
MBM Marshall Electronics
MBV Moreton Bay
MCA American Nuclear Systems Inc
MCC Micro Industries
MCD McDATA Corporation
MCE Metz-Werke GmbH & Co KG
MCG Motorola Computer Group
MCI Micronics Computers
MCJ Medicaroid Corporation
MCL Motorola Communications Israel
MCM Metricom Inc
MCN Micron Electronics Inc
MCO Motion Computing Inc.
MCP Magni Systems Inc
MCQ Mat's Computers
MCR Marina Communicaitons
MCS Micro Computer Systems
MCT Microtec
MCX Millson Custom Solutions Inc.
MDA Media4 Inc
MDC Midori Electronics
MDD MODIS
MDF MILDEF AB
MDG Madge Networks
MDI Micro Design Inc
MDK Mediatek Corporation
MDO Panasonic
MDR Medar Inc
MDS Micro Display Systems Inc
MDT Magus Data Tech
MDV MET Development Inc
MDX MicroDatec GmbH
MDY Microdyne Inc
MEC Mega System Technologies Inc
MED Messeltronik Dresden GmbH
MEE Mitsubishi Electric Engineering Co., Ltd.
MEG Abeam Tech Ltd.
MEI Panasonic Industry Company
MEJ Mac-Eight Co., LTD.
MEK Mediaedge Corporation
MEL Mitsubishi Electric Corporation
MEN MEN Mikroelectronik Nueruberg GmbH
MEP Meld Technology
MEQ Matelect Ltd.
MET Metheus Corporation
MEU MPL AG, Elektronik-Unternehmen
MEX MSC Vertriebs GmbH
MFG MicroField Graphics Inc
MFI Micro Firmware
MFR MediaFire Corp.
MGA Mega System Technologies, Inc.
MGC Mentor Graphics Corporation
MGE Schneider Electric S.A.
MGL M-G Technology Ltd
MGT Megatech R & D Company
MHQ Moxa Inc.
MIC Micom Communications Inc
MID miro Displays
MII Mitec Inc
MIL Marconi Instruments Ltd
MIM Mimio – A Newell Rubbermaid Company
MIN Minicom Digital Signage
MIP micronpc.com
MIR Miro Computer Prod.
MIS Modular Industrial Solutions Inc
MIT MCM Industrial Technology GmbH
MIV MicroImage Video Systems
MJI MARANTZ JAPAN, INC.
MJS MJS Designs
MKC Media Tek Inc.
MKS MK Seiko Co., Ltd.
MKT MICROTEK Inc.
MKV Trtheim Technology
MLC MILCOTS
MLD Deep Video Imaging Ltd
MLG Micrologica AG
MLI McIntosh Laboratory Inc.
MLL Millogic Ltd.
MLM Millennium Engineering Inc
MLN Mark Levinson
MLP Magic Leap
MLS Milestone EPE
MLT Wanlida Group Co., Ltd.
MLX Mylex Corporation
MMA Micromedia AG
MMD Micromed Biotecnologia Ltd
MMF Minnesota Mining and Manufacturing
MMI Multimax
MMM Electronic Measurements
MMN MiniMan Inc
MMS MMS Electronics
MMT MIMO Monitors
MNC Mini Micro Methods Ltd
MNI Marseille, Inc.
MNL Monorail Inc
MNP Microcom
MNS Maxnerva Technology Services Limited
MOC Matrix Orbital Corporation
MOD Modular Technology
MOM Momentum Data Systems
MOS Moses Corporation
MOT Motorola UDS
MPC M-Pact Inc
MPI Mediatrix Peripherals Inc
MPJ Microlab
MPL Maple Research Inst. Company Ltd
MPN Mainpine Limited
MPS mps Software GmbH
MPV Megapixel Visual Realty
MPX Micropix Technologies, Ltd.
MQP MultiQ Products AB
MRA Miranda Technologies Inc
MRC Marconi Simulation & Ty-Coch Way Training
MRD MicroDisplay Corporation
MRG Nreal
MRK Maruko & Company Ltd
MRL Miratel
MRO Medikro Oy
MRT Merging Technologies
MSA Micro Systemation AB
MSC Mouse Systems Corporation
MSD Datenerfassungs- und Informationssysteme
MSF M-Systems Flash Disk Pioneers
MSG MSI GmbH
MSH Microsoft
MSI Microstep
MSK Megasoft Inc
MSL MicroSlate Inc.
MSM Advanced Digital Systems
MSP Mistral Solutions [P] Ltd.
MSR MASPRO DENKOH Corp.
MST MS Telematica
MSU motorola
MSV Mosgi Corporation
MSX Micomsoft Co., Ltd.
MSY MicroTouch Systems Inc
MTA Meta Watch Ltd
MTB Media Technologies Ltd.
MTC Mars-Tech Corporation
MTD MindTech Display Co. Ltd
MTE MediaTec GmbH
MTH Micro-Tech Hearing Instruments
MTI MaxCom Technical Inc
MTJ MicroTechnica Co.,Ltd.
MTK Microtek International Inc.
MTL Mitel Corporation
MTM Motium
MTN Mtron Storage Technology Co., Ltd.
MTR Mitron computer Inc
MTS Multi-Tech Systems
MTT Moore Threads Virtual Display
MTU Mark of the Unicorn Inc
MTX Matrox
MUD Multi-Dimension Institute
MUK Mainpine Limited
MVD Microvitec PLC
MVI Media Vision Inc
MVM SOBO VISION
MVN Meta Company
MVR MediCapture, Inc.
MVS Microvision
MVX COM 1
MWI Multiwave Innovation Pte Ltd
MWR mware
MWY Microway Inc
MXD MaxData Computer GmbH & Co.KG
MXI Macronix Inc
MXL Hitachi Maxell, Ltd.
MXM C&T Solution Inc.
MXP Maxpeed Corporation
MXT Maxtech Corporation
MXV MaxVision Corporation
MYA Monydata
MYR Myriad Solutions Ltd
MYX Micronyx Inc
NAC Ncast Corporation
NAD NAD Electronics
NAF NAFASAE INDIA Pvt. Ltd
NAK Nakano Engineering Co.,Ltd.
NAL Network Alchemy
NAT NaturalPoint Inc.
NAV Navigation Corporation
NAX Naxos Tecnologia
NBL N*Able Technologies Inc
NBS National Key Lab. on ISN
NBT NingBo Bestwinning Technology CO., Ltd
NCA Nixdorf Company
NCC NCR Corporation
NCE Norcent Technology, Inc.
NCI NewCom Inc
NCL NetComm Ltd
NCP Najing CEC Panda FPD Technology CO. ltd
NCR NCR Electronics
NCS Northgate Computer Systems
NCT NEC CustomTechnica, Ltd.
NCV NewCoSemi (Beijing) Technology CO.,Ltd.
NDC National DataComm Corporaiton
NDF NDF Special Light Products B.V.
NDI National Display Systems
NDK Naitoh Densei CO., LTD.
NDL Network Designers
NDS Nokia Data
NEC NEC Corporation
NEO NEO TELECOM CO.,LTD.
NES INNES
NET Mettler Toledo
NEU NEUROTEC - EMPRESA DE PESQUISA E DESENVOLVIMENTO EM BIOMEDICINA
NEX Nexgen Mediatech Inc.,
NFC BTC Korea Co., Ltd
NFS Number Five Software
NGC Network General
NGS A D S Exports
NHC New H3C Technology Co., Ltd.
NHT Vinci Labs
NIC National Instruments Corporation
NIS Nissei Electric Company
NIT Network Info Technology
NIX Seanix Technology Inc
NLC Next Level Communications
NME Navico, Inc.
NMP Nokia Mobile Phones
NMS Natural Micro System
NMV NEC-Mitsubishi Electric Visual Systems Corporation
NMX Neomagic
NNC NNC
NOD 3NOD Digital Technology Co. Ltd.
NOE NordicEye AB
NOI North Invent A/S
NOK Nokia Display Products
NOR Norand Corporation
NOT Not Limited Inc
NPA Arvanics
NPI Network Peripherals Inc
NRI Noritake Itron Corporation
NRL U.S. Naval Research Lab
NRT Beijing Northern Radiantelecom Co.
NRV Taugagreining hf
NSA NeuroSky, Inc.
NSC National Semiconductor Corporation
NSI NISSEI ELECTRIC CO.,LTD
NSP Nspire System Inc.
NSS Newport Systems Solutions
NST Network Security Technology Co
NTC NeoTech S.R.L
NTI New Tech Int'l Company
NTK NewTek
NTL National Transcomm. Ltd
NTN Nuvoton Technology Corporation
NTR N-trig Innovative Technologies, Inc.
NTS Nits Technology Inc.
NTT NTT Advanced Technology Corporation
NTW Networth Inc
NTX Netaccess Inc
NUG NU Technology, Inc.
NUI NU Inc.
NVC NetVision Corporation
NVD Nvidia
NVI NuVision US, Inc.
NVL Novell Inc
NVO Netvio Ltd.
NVR NOLO CO., LTD.
NVT Navatek Engineering Corporation
NWC NW Computer Engineering
NWL Newline Interactive Inc.
NWP NovaWeb Technologies Inc
NWS Newisys, Inc.
NXC NextCom K.K.
NXE Norxe AS
NXG Nexgen
NXP NXP Semiconductors bv.
NXQ Nexiq Technologies, Inc.
NXR Nextorage Corporation
NXS Technology Nexus Secure Open Systems AB
NXT NZXT (PNP same EDID)_
NYC Nakayo Relecommunications, Inc.
OAK Oak Tech Inc
OAS Oasys Technology Company
OBS Optibase Technologies
OCD Macraigor Systems Inc
OCN Olfan
OCS Open Connect Solutions
ODM ODME Inc.
ODR Odrac
OEC ORION ELECTRIC CO.,LTD
OEI Optum Engineering Inc.
OFI Jiangxi Jinghao Optical Co., Ltd.
OHW M-Labs Limited
OIC Option Industrial Computers
OIM Option International
OIN Option International
OKI OKI Electric Industrial Company Ltd
OLC Olicom A/S
OLD Olidata S.p.A.
OLI Olivetti
OLT Olitec S.A.
OLV Olitec S.A.
OLY OLYMPUS CORPORATION
OMC OBJIX Multimedia Corporation
OMG RODE
OMN Omnitel
OMR Omron Corporation
ONE Oneac Corporation
ONK ONKYO Corporation
ONL OnLive, Inc
ONS On Systems Inc
ONW OPEN Networks Ltd
ONX SOMELEC Z.I. Du Vert Galanta
OOS OSRAM
OPC Opcode Inc
OPI D.N.S. Corporation
OPP OPPO Digital, Inc.
OPT OPTi Inc
OPV Optivision Inc
OQI Oksori Company Ltd
ORG ORGA Kartensysteme GmbH
ORI OSR Open Systems Resources, Inc.
ORN ORION ELECTRIC CO., LTD.
OSA OSAKA Micro Computer, Inc.
OSD Optical Systems Design Pty Ltd
OSE Osee
OSI Open Stack, Inc.
OSP OPTI-UPS Corporation
OSR Oksori Company Ltd
OTB outsidetheboxstuff.com
OTI Orchid Technology
OTK OmniTek
OTM Optoma Corporation
OTT OPTO22, Inc.
OUK OUK Company Ltd
OVR Oculus VR, Inc.
OWL Mediacom Technologies Pte Ltd
OXU Oxus Research S.A.
OYO Shadow Systems
OZC OZ Corporation
OZD OZO Co.Ltd
OZO Tribe Computer Works Inc
PAC Pacific Avionics Corporation
PAD Promotion and Display Technology Ltd.
PAE PreSonus Audio Electronics
PAK Many CNC System Co., Ltd.
PAM Peter Antesberger Messtechnik
PAN The Panda Project
PAR Parallan Comp Inc
PBI Pitney Bowes
PBL Packard Bell Electronics
PBN Packard Bell NEC
PBV Pitney Bowes
PCA Philips BU Add On Card
PCB OCTAL S.A.
PCC PowerCom Technology Company Ltd
PCG First Industrial Computer Inc
PCI Pioneer Computer Inc
PCK PCBANK21
PCL pentel.co.,ltd
PCM PCM Systems Corporation
PCO Performance Concepts Inc.,
PCP Procomp USA Inc
PCS TOSHIBA PERSONAL COMPUTER SYSTEM CORPRATION
PCT PC-Tel Inc
PCW Pacific CommWare Inc
PCX PC Xperten
PDM Psion Dacom Plc.
PDN AT&T Paradyne
PDR Pure Data Inc
PDS PD Systems International Ltd
PDT PDTS - Prozessdatentechnik und Systeme
PDV Prodrive B.V.
PEC POTRANS Electrical Corp.
PEG Pegatron Corporation
PEI PEI Electronics Inc
PEL Primax Electric Ltd
PEN Interactive Computer Products Inc
PEP Peppercon AG
PER Perceptive Signal Technologies
PET Practical Electronic Tools
PFT Telia ProSoft AB
PGI PACSGEAR, Inc.
PGM Paradigm Advanced Research Centre
PGP propagamma kommunikation
PGS Princeton Graphic Systems
PHC Pijnenburg Beheer N.V.
PHE Philips Medical Systems Boeblingen GmbH
PHL Philips Consumer Electronics Company
PHO Photonics Systems Inc.
PHS Philips Communication Systems
PHY Phylon Communications
PIC Picturall Ltd.
PIE Pacific Image Electronics Company Ltd
PIM Prism, LLC
PIO Pioneer Electronic Corporation
PIR Pico Technology Inc.
PIS TECNART CO.,LTD.
PIX Pixie Tech Inc
PJA Projecta
PJD Projectiondesign AS
PJT Pan Jit International Inc.
PKA Acco UK Ltd.
PLC Pro-Log Corporation
PLF Panasonic Avionics Corporation
PLM PROLINK Microsystems Corp.
PLT PT Hartono Istana Teknologi
PLV PLUS Vision Corp.
PLX Parallax Graphics
PLY Polycom Inc.
PMC PMC Consumer Electronics Ltd
PMD TDK USA Corporation
PMM Point Multimedia System
PMS Pabian Embedded Systems
PMT Promate Electronic Co., Ltd.
PMX Photomatrix
PNG Microsoft
PNL Panelview, Inc.
PNP Microsoft
PNR Planar Systems, Inc.
PNS PanaScope
PNT HOYA Corporation PENTAX Lifecare Division
PNX Phoenix Technologies, Ltd.
POL PolyComp (PTY) Ltd.
PON Perpetual Technologies, LLC
POR Portalis LC
POS Positivo Tecnologia S.A.
POT Parrot
PPC Phoenixtec Power Company Ltd
PPD MEPhI
PPI Practical Peripherals
PPM Clinton Electronics Corp.
PPP Purup Prepress AS
PPR PicPro
PPX Perceptive Pixel Inc.
PQI Pixel Qi
PRA PRO/AUTOMATION
PRC PerComm
PRD Praim S.R.L.
PRF Schneider Electric Japan Holdings, Ltd.
PRG The Phoenix Research Group Inc
PRI Priva Hortimation BV
PRK Portkeys
PRM Prometheus
PRO Proteon
PRP UEFI Forum
PRS Leutron Vision
PRT Parade Technologies, Ltd.
PRX Proxima Corporation
PSA Advanced Signal Processing Technologies
PSC Philips Semiconductors
PSD Peus-Systems GmbH
PSE Practical Solutions Pte., Ltd.
PSI PSI-Perceptive Solutions Inc
PSL Perle Systems Limited
PSM Prosum
PST Global Data SA
PSY Prodea Systems Inc.
PTA PAR Tech Inc.
PTC PS Technology Corporation
PTG Cipher Systems Inc
PTH Pathlight Technology Inc
PTI Promise Technology Inc
PTL Pantel Inc
PTS Plain Tree Systems Inc
PTX Printronix LLC
PUL Pulse-Eight Ltd
PVG Proview Global Co., Ltd
PVI Prime view international Co., Ltd
PVM Penta Studiotechnik GmbH
PVN Pixel Vision
PVP Klos Technologies, Inc.
PVR Pimax Tech. CO., LTD
PXC Phoenix Contact
PXE PIXELA CORPORATION
PXL The Moving Pixel Company
PXM Proxim Inc
PXN PixelNext Inc
PXO Pixio USA
QCC QuakeCom Company Ltd
QCH Metronics Inc
QCI Quanta Computer Inc
QCK Quick Corporation
QCL Quadrant Components Inc
QCP Qualcomm Inc
QDI Quantum Data Incorporated
QDL QD Laser, Inc.
QDM Quadram
QDS Quanta Display Inc.
QFF Padix Co., Inc.
QFI Quickflex, Inc
QLC Q-Logic
QQQ Chuomusen Co., Ltd.
QSC QSC, LLC
QSI Quantum Solutions, Inc.
QTD Quantum 3D Inc
QTH Questech Ltd
QTI Quicknet Technologies Inc
QTM Quantum
QTR Qtronix Corporation
QUA Quatographic AG
QUE Questra Consulting
QVU Quartics
RAC Racore Computer Products Inc
RAD Radisys Corporation
RAI Rockwell Automation/Intecolor
RAN Rancho Tech Inc
RAR Raritan, Inc.
RAS RAScom Inc
RAT Rent-A-Tech
RAY Raylar Design, Inc.
RCE Parc d'Activite des Bellevues
RCH Reach Technology Inc
RCI RC International
RCN Radio Consult SRL
RCO Rockwell Collins
RDI Rainbow Displays, Inc.
RDL Riedel Communications Canada Inc.
RDM Tremon Enterprises Company Ltd
RDN RADIODATA GmbH
RDS Radius Inc
REA Real D
REC ReCom
RED Research Electronics Development Inc
REF Reflectivity, Inc.
REH Rehan Electronics Ltd.
REL Reliance Electric Ind Corporation
REM SCI Systems Inc.
REN Renesas Technology Corp.
RES ResMed Pty Ltd
RET Resonance Technology, Inc.
REV Revolution Display, Inc.
REX RATOC Systems, Inc.
RFI RAFI GmbH & Co. KG
RFX Redfox Technologies Inc.
RGB RGB Spectrum
RGL Robertson Geologging Ltd
RHD RightHand Technologies
RHM Rohm Company Ltd
RHT Red Hat, Inc.
RIC RICOH COMPANY, LTD.
RII Racal Interlan Inc
RIO Rios Systems Company Ltd
RIT Ritech Inc
RIV Rivulet Communications
RJA Roland Corporation
RJS Advanced Engineering
RKC Reakin Technolohy Corporation
RLD MEPCO
RLN RadioLAN Inc
RMC Raritan Computer, Inc
RMP Research Machines
RMS Shenzhen Ramos Digital Technology Co., Ltd
RMT Roper Mobile
RNB Rainbow Technologies
RNL Reonel Oy
ROB Robust Electronics GmbH
ROH Rohm Co., Ltd.
ROK Rockwell International
ROP Roper International Ltd
ROS Rohde & Schwarz
RPI RoomPro Technologies
RPT R.P.T.Intergroups
RRI Radicom Research Inc
RRO AVARRO
RSC PhotoTelesis
RSH ADC-Centre
RSI Rampage Systems Inc
RSN Radiospire Networks, Inc.
RSQ R Squared
RSR Zhong Shan City Richsound Electronic Industrial Ltd.
RSS Rockwell Semiconductor Systems
RSV Ross Video Ltd
RSX Rapid Tech Corporation
RTC Relia Technologies
RTI Rancho Tech Inc
RTL Realtek Semiconductor Company Ltd
RTS Raintree Systems
RUN RUNCO International
RUP Ups Manufactoring s.r.l.
RVC RSI Systems Inc
RVI Realvision Inc
RVL Reveal Computer Prod
RWC Red Wing Corporation
RXT Tectona SoftSolutions (P) Ltd.,
RZR Razer Taiwan Co. Ltd.
RZS Rozsnyó, s.r.o.
SAA Sanritz Automation Co.,Ltd.
SAE Saab Aerotech
SAG Sedlbauer
SAI Sage Inc
SAK Saitek Ltd
SAM Samsung Electric Company
SAN Sanyo Electric Co.,Ltd.
SAS Stores Automated Systems Inc
SAT Shuttle Tech
SBC Shanghai Bell Telephone Equip Mfg Co
SBD Softbed - Consulting & Development Ltd
SBI SMART Technologies Inc.
SBS SBS-or Industrial Computers GmbH
SBT Senseboard Technologies AB
SCA Schneider Consumer Group
SCB SeeCubic B.V.
SCC SORD Computer Corporation
SCD Sanyo Electric Company Ltd
SCE Sun Corporation
SCG Seco S.p.A.
SCH Schlumberger Cards
SCI System Craft
SCL Sigmacom Co., Ltd.
SCM SCM Microsystems Inc
SCN Scanport, Inc.
SCO SORCUS Computer GmbH
SCP Scriptel Corporation
SCR Systran Corporation
SCS Nanomach Anstalt
SCT Smart Card Technology
SCX Socionext Inc.
SDA SAT (Societe Anonyme)
SDC Samsung Display Corp.
SDD Intrada-SDD Ltd
SDE Sherwood Digital Electronics Corporation
SDF SODIFF E&T CO., Ltd.
SDH Communications Specialies, Inc.
SDI Samtron Displays Inc
SDK SAIT-Devlonics
SDR SDR Systems
SDS SunRiver Data System
SDT Siemens AG
SDX SDX Business Systems Ltd
SEA Seanix Technology Inc.
SEB system elektronik GmbH
SEC Seiko Epson Corporation
SEE SeeColor Corporation
SEI Seitz & Associates Inc
SEL Way2Call Communications
SEM Samsung Electronics Company Ltd
SEN Sencore
SEO SEOS Ltd
SEP SEP Eletronica Ltda.
SER Sony Ericsson Mobile Communications Inc.
SES Session Control LLC
SET SendTek Corporation
SFL Shiftall Inc.
SFM TORNADO Company
SFT Mikroforum Ring 3
SGC Spectragraphics Corporation
SGD Sigma Designs, Inc.
SGE Kansai Electric Company Ltd
SGI Scan Group Ltd
SGL Super Gate Technology Company Ltd
SGM SAGEM
SGN Shenzhen Soogeen Electronics Co., LTD.
SGO Logos Design A/S
SGT Stargate Technology
SGW Shanghai Guowei Science and Technology Co., Ltd.
SGX Silicon Graphics Inc
SGZ Systec Computer GmbH
SHC ShibaSoku Co., Ltd.
SHD SmallHD
SHG Soft & Hardware development Goldammer GmbH
SHI Jiangsu Shinco Electronic Group Co., Ltd
SHP Sharp Corporation
SHR Digital Discovery
SHT Shin Ho Tech
SIA SIEMENS AG
SIB Sanyo Electric Company Ltd
SIC Sysmate Corporation
SID Seiko Instruments Information Devices Inc
SIE Siemens
SIG Sigma Designs Inc
SII Silicon Image, Inc.
SIL Silicon Laboratories, Inc
SIM S3 Inc
SIN Singular Technology Co., Ltd.
SIR Sirius Technologies Pty Ltd
SIS Silicon Integrated Systems Corporation
SIT Sitintel
SIU Seiko Instruments USA Inc
SIX Zuniq Data Corporation
SJE Sejin Electron Inc
SKD Schneider & Koch
SKG Shenzhen KTC Technology Group
SKI LLC SKTB “SKIT”
SKM Guangzhou Teclast Information Technology Limited
SKT Samsung Electro-Mechanics Company Ltd
SKW Skyworth
SKY SKYDATA S.P.A.
SLA Systeme Lauer GmbH&Co KG
SLB Shlumberger Ltd
SLC Syslogic Datentechnik AG
SLF StarLeaf
SLH Silicon Library Inc.
SLI Symbios Logic Inc
SLK Silitek Corporation
SLM Solomon Technology Corporation
SLR Schlumberger Technology Corporate
SLS Schnick-Schnack-Systems GmbH
SLT Salt Internatioinal Corp.
SLX Specialix
SMA SMART Modular Technologies
SMB Schlumberger
SMC Standard Microsystems Corporation
SME Sysmate Company
SMI SpaceLabs Medical Inc
SMK SMK CORPORATION
SML Sumitomo Metal Industries, Ltd.
SMM Shark Multimedia Inc
SMN Somnium Space Ltd.
SMO STMicroelectronics
SMP Simple Computing
SMR B.& V. s.r.l.
SMS Silicom Multimedia Systems Inc
SMT Silcom Manufacturing Tech Inc
SNC Sentronic International Corp.
SNI Siemens Microdesign GmbH
SNK S&K Electronics
SNN SUNNY ELEKTRONIK
SNO SINOSUN TECHNOLOGY CO., LTD
SNP Siemens Nixdorf Info Systems
SNS Cirtech (UK) Ltd
SNT SuperNet Inc
SNV SONOVE GmbH
SNW Snell & Wilcox
SNX Sonix Comm. Ltd
SNY Sony
SOC Santec Corporation
SOI Silicon Optix Corporation
SOL Solitron Technologies Inc
SON Sony
SOR Sorcus Computer GmbH
SOT Sotec Company Ltd
SOY SOYO Group, Inc
SPC SpinCore Technologies, Inc
SPE SPEA Software AG
SPH G&W Instruments GmbH
SPI SPACE-I Co., Ltd.
SPK SpeakerCraft
SPL Smart Silicon Systems Pty Ltd
SPN Sapience Corporation
SPO SAMPO CORPORATION
SPR pmns GmbH
SPS Synopsys Inc
SPT Sceptre Tech Inc
SPU SIM2 Multimedia S.P.A.
SPX Simplex Time Recorder Co.
SQT Sequent Computer Systems Inc
SRC Integrated Tech Express Inc
SRD Setred
SRF Surf Communication Solutions Ltd
SRG Intuitive Surgical, Inc.
SRS SR-Systems e.K.
SRT SeeReal Technologies GmbH
SSC Sierra Semiconductor Inc
SSD FlightSafety International
SSE Samsung Electronic Co.
SSG Steelseries ApS
SSI S-S Technology Inc
SSJ Sankyo Seiki Mfg.co., Ltd
SSL Shenzhen South-Top Computer Co., Ltd.
SSP Spectrum Signal Proecessing Inc
SSS S3 Inc
SST SystemSoft Corporation
STA ST Electronics Systems Assembly Pte Ltd
STB STB Systems Inc
STC STAC Electronics
STD STD Computer Inc
STE SII Ido-Tsushin Inc
STF Starflight Electronics
STG StereoGraphics Corp.
STH Semtech Corporation
STI Smart Tech Inc
STK SANTAK CORP.
STL SigmaTel Inc
STM SGS Thomson Microelectronics
STN Samsung Electronics America
STO Stollmann E+V GmbH
STP StreamPlay Ltd
STQ Synthetel Corporation
STR Starlight Networks Inc
STS SITECSYSTEM CO., LTD.
STT Star Paging Telecom Tech (Shenzhen) Co. Ltd.
STU Sentelic Corporation
STV Beijing Guochengwantong Information Technology Co., Ltd.
STW Starwin Inc.
STX ST-Ericsson
STY SDS Technologies
SUB Subspace Comm. Inc
SUM Summagraphics Corporation
SUN Sun Electronics Corporation
SUP Supra Corporation
SUR Surenam Computer Corporation
SVA SGEG
SVC Intellix Corp.
SVD SVD Computer
SVI Sun Microsystems
SVR Sensics, Inc.
SVS SVSI
SVT SEVIT Co., Ltd.
SWC Software Café
SWI Sierra Wireless Inc.
SWL Sharedware Ltd
SWO Guangzhou Shirui Electronics Co., Ltd.
SWS Static
SWT Software Technologies Group,Inc.
SXB Syntax-Brillian
SXD Silex technology, Inc.
SXG SELEX GALILEO
SXI Silex Inside
SXL SolutionInside
SXT SHARP TAKAYA ELECTRONIC INDUSTRY CO.,LTD.
SYC Sysmic
SYE SY Electronics Ltd
SYK Stryker Communications
SYL Sylvania Computer Products
SYM Symicron Computer Communications Ltd.
SYN Synaptics Inc
SYP SYPRO Co Ltd
SYS Sysgration Ltd
SYT Seyeon Tech Company Ltd
SYV SYVAX Inc
SYX Prime Systems, Inc.
SZM Shenzhen MTC Co., Ltd
TAA Tandberg
TAB Todos Data System AB
TAG Teles AG
TAI Toshiba America Info Systems Inc
TAM Tamura Seisakusyo Ltd
TAS Taskit Rechnertechnik GmbH
TAT Teleliaison Inc
TAV Thales Avionics
TAX Taxan (Europe) Ltd
TBB Triple S Engineering Inc
TBC Turbo Communication, Inc
TBS Turtle Beach System
TCC Tandon Corporation
TCD Taicom Data Systems Co., Ltd.
TCE Century Corporation
TCF Televic Conference
TCH Interaction Systems, Inc
TCI Tulip Computers Int'l B.V.
TCJ TEAC America Inc
TCL Technical Concepts Ltd
TCM 3Com Corporation
TCN Tecnetics (PTY) Ltd
TCO Thomas-Conrad Corporation
TCR Thomson Consumer Electronics
TCS Tatung Company of America Inc
TCT Telecom Technology Centre Co. Ltd.
TCX FREEMARS Heavy Industries
TDC Teradici
TDD Tandberg Data Display AS
TDG Six15 Technologies
TDM Tandem Computer Europe Inc
TDP 3D Perception
TDS Tri-Data Systems Inc
TDT TDT
TDV TDVision Systems, Inc.
TDY Tandy Electronics
TEA TEAC System Corporation
TEC Tecmar Inc
TEK Tektronix Inc
TEL Promotion and Display Technology Ltd.
TEN Tencent
TER TerraTec Electronic GmbH
TET TETRADYNE CO., LTD.
TEV Televés, S.A.
TEZ Tech Source Inc.
TGC Toshiba Global Commerce Solutions, Inc.
TGI TriGem Computer Inc
TGM TriGem Computer,Inc.
TGS Torus Systems Ltd
TGV Grass Valley Germany GmbH
TGW TECHNOGYM S.p.A.
THN Thundercom Holdings Sdn. Bhd.
TIC Trigem KinfoComm
TIL Technical Illusions Inc.
TIP TIPTEL AG
TIV OOO Technoinvest
TIX Tixi.Com GmbH
TKC Taiko Electric Works.LTD
TKG Tek Gear
TKN Teknor Microsystem Inc
TKO TouchKo, Inc.
TKS TimeKeeping Systems, Inc.
TLA Ferrari Electronic GmbH
TLD Telindus
TLE Zhejiang Tianle Digital Electric Co., Ltd.
TLF Teleforce.,co,ltd
TLG TVLogic
TLI TOSHIBA TELI CORPORATION
TLK Telelink AG
TLL Thinklogical
TLN Techlogix Networx
TLS Teleste Educational OY
TLT Dai Telecom S.p.A.
TLV S3 Inc
TLX Telxon Corporation
TLY Truly Semiconductors Ltd.
TMA Tianma Microelectronics Ltd.
TMC Techmedia Computer Systems Corporation
TME AT&T Microelectronics
TMI Texas Microsystem
TMM Time Management, Inc.
TMO Terumo Corporation
TMR Taicom International Inc
TMS Trident Microsystems Ltd
TMT T-Metrics Inc.
TMV TeamViewer Germany GmbH
TMX Thermotrex Corporation
TNC TNC Industrial Company Ltd
TNM TECNIMAGEN SA
TNY Tennyson Tech Pty Ltd
TOE TOEI Electronics Co., Ltd.
TOG The OPEN Group
TOL TCL Corporation
TOM Ceton Corporation
TON TONNA
TOP Orion Communications Co., Ltd.
TOS Dynabook Inc.
TOU Touchstone Technology
TPC Touch Panel Systems Corporation
TPD Times (Shanghai) Computer Co., Ltd.
TPE Technology Power Enterprises Inc
TPJ Junnila
TPK TOPRE CORPORATION
TPR Topro Technology Inc
TPS Teleprocessing Systeme GmbH
TPT Thruput Ltd
TPV Top Victory Electronics ( Fujian ) Company Ltd
TPZ Ypoaz Systems Inc
TRA TriTech Microelectronics International
TRB Triumph Board a.s.
TRC Trioc AB
TRD Trident Microsystem Inc
TRE Tremetrics
TRI Tricord Systems
TRL Royal Information
TRM Tekram Technology Company Ltd
TRN Datacommunicatie Tron B.V.
TRP TRAPEZE GROUP
TRS Torus Systems Ltd
TRT Tritec Electronic AG
TRU Aashima Technology B.V.
TRV Trivisio Prototyping GmbH
TRX Trex Enterprises
TSB Toshiba America Info Systems Inc
TSC Sanyo Electric Company Ltd
TSD TechniSat Digital GmbH
TSE Tottori Sanyo Electric
TSF Racal-Airtech Software Forge Ltd
TSG The Software Group Ltd
TSH ELAN MICROELECTRONICS CORPORATION
TSI TeleVideo Systems
TSL Tottori SANYO Electric Co., Ltd.
TSP U.S. Navy
TST Transtream Inc
TSV TRANSVIDEO
TSW VRSHOW Technology Limited
TSY TouchSystems
TTA Topson Technology Co., Ltd.
TTB National Semiconductor Japan Ltd
TTC Telecommunications Techniques Corporation
TTE TTE, Inc.
TTI Trenton Terminals Inc
TTK Totoku Electric Company Ltd
TTL 2-Tel B.V
TTP Toshiba Corporation
TTR Hubei Century Joint Innovation Technology Co.Ltd
TTS TechnoTrend Systemtechnik GmbH
TTX Taitex Corporation
TTY TRIDELITY Display Solutions GmbH
TUA T+A elektroakustik GmbH
TUT Tut Systems
TVD Tecnovision
TVI Truevision
TVL Total Vision LTD
TVM Taiwan Video & Monitor Corporation
TVO TV One Ltd
TVR TV Interactive Corporation
TVS TVS Electronics Limited
TVV TV1 GmbH
TWA Tidewater Association
TWE Kontron Electronik
TWH Twinhead International Corporation
TWI Easytel oy
TWK TOWITOKO electronics GmbH
TWX TEKWorx Limited
TXL Trixel Ltd
TXN Texas Instruments
TXT Textron Defense System
TYN Tyan Computer Corporation
UAS Ultima Associates Pte Ltd
UBI Ungermann-Bass Inc
UBL Ubinetics Ltd.
UBU Canonical Ltd.
UDN Uniden Corporation
UEC Ultima Electronics Corporation
UEG Elitegroup Computer Systems Company Ltd
UEI Universal Electronics Inc
UET Universal Empowering Technologies
UFG UNIGRAF-USA
UFO UFO Systems Inc
UHB XOCECO
UIC Uniform Industrial Corporation
UJR Ueda Japan Radio Co., Ltd.
ULT Ultra Network Tech
UMC United Microelectr Corporation
UMG Umezawa Giken Co.,Ltd
UMM Universal Multimedia
UMT UltiMachine
UNA Unisys DSD
UNB Unisys Corporation
UNC Unisys Corporation
UNI Uniform Industry Corp.
UNM Unisys Corporation
UNO Unisys Corporation
UNP Unitop
UNS Unisys Corporation
UNT Unisys Corporation
UNY Unicate
UPP UPPI
UPS Systems Enhancement
URD Video Computer S.p.A.
USA Utimaco Safeware AG
USD U.S. Digital Corporation
USE U. S. Electronics Inc.
USI Universal Scientific Industrial Co., Ltd.
USR U.S. Robotics Inc
UTC Unicompute Technology Co., Ltd.
UTD Up to Date Tech
UWC Uniwill Computer Corp.
VAD Vaddio, LLC
VAI VAIO Corporation
VAL Valence Computing Corporation
VAR Varian Australia Pty Ltd
VAT VADATECH INC
VAV aviica
VBR VBrick Systems Inc.
VBT Valley Board Ltda
VCC Virtual Computer Corporation
VCE VARCem
VCI VistaCom Inc
VCJ Victor Company of Japan, Limited
VCM Vector Magnetics, LLC
VCX VCONEX
VDA Victor Data Systems
VDC VDC Display Systems
VDM Vadem
VDO Video & Display Oriented Corporation
VDS Vidisys GmbH & Company
VDT Viditec, Inc.
VEC Vector Informatik GmbH
VEK Vektrex
VES Vestel Elektronik Sanayi ve Ticaret A. S.
VFI VeriFone Inc
VHI Macrocad Development Inc.
VIA VIA Tech Inc
VIB Tatung UK Ltd
VIC Victron B.V.
VID Ingram Macrotron Germany
VIK Viking Connectors
VIM Via Mons Ltd.
VIN Vine Micros Ltd
VIO Zake IP Holdings LLC (3B tech)
VIR Visual Interface, Inc
VIS Visioneer
VIT Visitech AS
VIZ VIZIO, Inc
VLB ValleyBoard Ltda.
VLC VersaLogic Corporation
VLK Vislink International Ltd
VLM LENOVO BEIJING CO. LTD.
VLT VideoLan Technologies
VLV Valve Corporation
VMI Vermont Microsystems
VML Vine Micros Limited
VMW VMware Inc.,
VNC Vinca Corporation
VNX Venetex Corporation
VOB MaxData Computer AG
VPI Video Products Inc
VPR Best Buy
VPX VPixx Technologies Inc.
VQ@ Vision Quest
VRC Virtual Resources Corporation
VRG VRgineers, Inc.
VRM VRmagic Holding AG
VRS VRstudios, Inc.
VRT Varjo Technologies
VSC ViewSonic Corporation
VSD 3M
VSI VideoServer
VSN Ingram Macrotron
VSP Vision Systems GmbH
VSR V-Star Electronics Inc.
VTB Videotechnik Breithaupt
VTC VTel Corporation
VTG Voice Technologies Group Inc
VTI VLSI Tech Inc
VTK Viewteck Co., Ltd.
VTL Vivid Technology Pte Ltd
VTM Miltope Corporation
VTN VIDEOTRON CORP.
VTS VTech Computers Ltd
VTV VATIV Technologies
VTX Vestax Corporation
VUT Vutrix (UK) Ltd
VVI VITEC
VWB Vweb Corp.
WAC Wacom Tech
WAL Wave Access
WAV Wavephore
WBN MicroSoftWare
WBS WB Systemtechnik GmbH
WCI Wisecom Inc
WCS Woodwind Communications Systems Inc
WDC Western Digital
WDE Westinghouse Digital Electronics
WEB WebGear Inc
WEC Winbond Electronics Corporation
WEL W-DEV
WEY WEY Design AG
WHI Whistle Communications
WII Innoware Inc
WIL WIPRO Information Technology Ltd
WIN Wintop Technology Inc
WIP Wipro Infotech
WKH Uni-Take Int'l Inc.
WLD Wildfire Communications Inc
WLF WOLF Advanced Technology
WMI Weidmuller Interface GmbH & Co. KG
WML Wolfson Microelectronics Ltd
WMO Westermo Teleindustri AB
WMT Winmate Communication Inc
WNI WillNet Inc.
WNV Winnov L.P.
WNX Diebold Nixdorf Systems GmbH
WPA Matsushita Communication Industrial Co., Ltd.
WPI Wearnes Peripherals International (Pte) Ltd
WRC WiNRADiO Communications
WSC CIS Technology Inc
WSP Wireless And Smart Products Inc.
WST Wistron Corporation
WTC ACC Microelectronics
WTI WorkStation Tech
WTK Wearnes Thakral Pte
WTS Restek Electric Company Ltd
WVM Wave Systems Corporation
WVV WolfVision GmbH
WWP Wipotec Wiege- und Positioniersysteme GmbH
WWV World Wide Video, Inc.
WXT Woxter Technology Co. Ltd
WYR WyreStorm Technologies LLC
WYS Myse Technology
WYT Wooyoung Image & Information Co.,Ltd.
XAC XAC Automation Corp
XAD Alpha Data
XDM XDM Ltd.
XES Extreme Engineering Solutions, Inc.
XFG Jan Strapko - FOTO
XFO EXFO Electro Optical Engineering
XIN Xinex Networks Inc
XIO Xiotech Corporation
XIR Xirocm Inc
XIT Xitel Pty ltd
XLX Xilinx, Inc.
XMM C3PO S.L.
XNT XN Technologies, Inc.
XQU SHANGHAI SVA-DAV ELECTRONICS CO., LTD
XRC Xircom Inc
XRO XORO ELECTRONICS (CHENGDU) LIMITED
XSN Xscreen AS
XST XS Technologies Inc
XSY XSYS
XTD Icuiti Corporation
XTE X2E GmbH
XTL Crystal Computer
XTN X-10 (USA) Inc
XYC Xycotec Computer GmbH
XYE Shenzhen Zhuona Technology Co., Ltd.
YED Y-E Data Inc
YHQ Yokogawa Electric Corporation
YHW Exacom SA
YMH Yamaha Corporation
YOW American Biometric Company
ZAN Zandar Technologies plc
ZAX Zefiro Acoustics
ZAZ ZeeVee, Inc.
ZBR Zebra Technologies International, LLC
ZBX Zebax Technologies
ZCT ZeitControl cardsystems GmbH
ZDS Zenith Data Systems
ZEN ZENIC Inc.
ZGT Zenith Data Systems
ZIC Nationz Technologies Inc.
ZMC HangZhou ZMCHIVIN
ZMT Zalman Tech Co., Ltd.
ZMZ Z Microsystems
ZNI Zetinet Inc
ZNX Znyx Adv. Systems
ZOW Zowie Intertainment, Inc
ZRN Zoran Corporation
ZSE Zenith Data Systems
ZTC ZyDAS Technology Corporation
ZTE ZTE Corporation
ZTI Zoom Telephonics Inc
ZTM ZT Group Int'l Inc.
ZTT Z3 Technology
ZWE Shenzhen Zowee Technology Co., LTD
ZYD Zydacron Inc
ZYP Zypcom Inc
ZYT Zytex Computers
ZYX Zyxel
ZZZ Boca Research Inc displaycal-py3-3.9.19/DisplayCAL/postinstall.py 000664 000000 000000 00000045362 15225167330 021324 0 ustar 00root root 000000 000000 """Post-install and uninstall tasks for DisplayCAL on Windows, macOS, and Linux.
It includes functions to create shortcuts, manage installed files, and update
system resources such as icons and desktop menu entries.
"""
from __future__ import annotations
import contextlib
import os
import shutil
import sys
import traceback
from io import StringIO
from os.path import basename, splitext
from subprocess import call
from DisplayCAL.meta import NAME
from DisplayCAL.util_os import safe_glob, which
RECORD_FILE_NAME = "INSTALLED_FILES"
if sys.stdout and hasattr(sys.stdout, "isatty") and not sys.stdout.isatty():
sys.stdout = StringIO()
if sys.platform == "win32":
if "create_shortcut" not in globals():
# this function is only available within bdist_wininst installers
try:
import win32con
from pythoncom import (
CLSCTX_INPROC_SERVER,
CoCreateInstance,
IID_IPersistFile,
)
from win32com.shell import shell
except ImportError:
def create_shortcut(*args) -> None:
"""Dummy function to create a Windows shortcut."""
else:
def create_shortcut(*args) -> None:
"""Create a Windows shortcut."""
shortcut = CoCreateInstance(
shell.CLSID_ShellLink,
None,
CLSCTX_INPROC_SERVER,
shell.IID_IShellLink,
)
shortcut.SetPath(args[0])
shortcut.SetDescription(args[1])
if len(args) > 3:
shortcut.SetArguments(args[3])
if len(args) > 4:
shortcut.SetWorkingDirectory(args[4])
if len(args) > 5:
shortcut.SetIconLocation(args[5], args[6] if len(args) > 6 else 0)
shortcut.SetShowCmd(win32con.SW_SHOWNORMAL)
shortcut.QueryInterface(IID_IPersistFile).Save(args[2], 0)
if "directory_created" not in globals():
# this function is only available within bdist_wininst installers
def directory_created(path: str) -> None:
"""Dummy function to record directory creation.
Args:
path (str): The path of the directory that was created.
"""
if "file_created" not in globals():
# this function is only available within bdist_wininst installers
try:
import win32api
except ImportError:
def file_created(path: str) -> None:
"""Dummy function to record file creation.
Args:
path (str): The path of the file that was created.
"""
else:
def file_created(path: str) -> None:
"""Record the file creation in the installed files record.
Args:
path (str): The path of the file that was created.
"""
if not os.path.exists(RECORD_FILE_NAME):
return
installed_files = []
if os.path.exists(RECORD_FILE_NAME):
with open(RECORD_FILE_NAME) as record_file:
installed_files.extend(
line.rstrip("\n") for line in record_file
)
try:
path.encode("ASCII")
except (UnicodeDecodeError, UnicodeEncodeError):
# the contents of the record file used by distutils
# must be ASCII GetShortPathName allows us to avoid
# any issues with encoding because it returns the
# short path as 7-bit string (while still being a
# valid path)
path = win32api.GetShortPathName(path)
installed_files.append(path)
with open(RECORD_FILE_NAME, "w") as record_file:
record_file.write("\n".join(installed_files))
if "get_special_folder_path" not in globals():
# this function is only available within bdist_wininst installers
try:
from win32com.shell import shell, shellcon
except ImportError:
def get_special_folder_path(csidl_string: str) -> None:
"""Implement the dummy version of getting the path to a special folder.
Args:
csidl_string (str): The CSIDL string representing the
special folder.
Returns:
None: Returns None.
"""
else:
def get_special_folder_path(csidl_string: str) -> str:
"""Get the path to a special folder.
Args:
csidl_string (str): The CSIDL string representing the
special folder.
Returns:
str: The path to the special folder.
"""
return shell.SHGetSpecialFolderPath(
0, getattr(shellcon, csidl_string), 1
)
def postinstall_macos(prefix: None | str = None) -> None:
"""Do postinstall actions for macOS.
Args:
prefix (None | str, optional): The installation prefix. Defaults to None.
"""
# TODO: implement
def postinstall_windows(prefix: str) -> None:
"""Do postinstall actions for Windows.
Args:
prefix (str): The installation prefix.
"""
# assume we are running from bdist_wininst installer if prefix is None,
# otherwise assume we are running from source dir, or from install dir
module_path = (
os.path.dirname(os.path.abspath(__file__)) if prefix is None else prefix
)
if not os.path.exists(module_path):
print("warning - '{}' not found".format(module_path.encode("MBCS", "replace")))
return
create_installed_files_record(module_path)
main_icon = get_main_icon(module_path)
if not main_icon:
return
try:
start_menu_programs_common = get_special_folder_path("CSIDL_COMMON_PROGRAMS")
start_menu_programs = get_special_folder_path("CSIDL_PROGRAMS")
start_menu_common = get_special_folder_path("CSIDL_COMMON_start_menu")
start_menu = get_special_folder_path("CSIDL_start_menu")
except OSError:
traceback.print_exc()
return
create_start_menu_shortcuts(
module_path,
main_icon,
start_menu_programs_common,
start_menu_programs,
start_menu_common,
start_menu,
)
def create_installed_files_record(module_path: str) -> None:
"""Create the installed files record.
Args:
module_path (str): The module path.
"""
if not os.path.exists(RECORD_FILE_NAME):
return
installed_record_file_path = os.path.join(module_path, RECORD_FILE_NAME)
# touch - create the file
with open(installed_record_file_path, "w"):
pass
file_created(installed_record_file_path)
shutil.copy2(RECORD_FILE_NAME, installed_record_file_path)
def get_main_icon(module_path: str) -> None | str:
"""Get the main icon for the application.
Args:
module_path (str): The module path.
Returns:
None | str: The path to the main icon, or None if not found.
"""
main_icon = os.path.join(module_path, "theme", "icons", f"{NAME}.ico")
if not os.path.exists(main_icon):
print("warning - '{}' not found".format(main_icon.encode("MBCS", "replace")))
return None
return main_icon
def create_start_menu_shortcuts(
module_path: str,
main_icon: str,
start_menu_programs_common: str,
start_menu_programs: str,
start_menu_common: str,
start_menu: str,
) -> None:
"""Create start menu shortcuts for the application.
Args:
module_path (str): The module path.
main_icon (str): The path to the main icon.
start_menu_programs_common (str): The path to the common programs
start menu.
start_menu_programs (str): The path to the user's programs start menu.
start_menu_common (str): The path to the common start menu.
start_menu (str): The path to the user's start menu.
"""
filenames = [
filename
for filename in safe_glob(os.path.join(sys.prefix, "Scripts", f"{NAME}*"))
if not filename.endswith("-script.py")
and not filename.endswith("-script.pyw")
and not filename.endswith(".manifest")
and not filename.endswith(".pyc")
and not filename.endswith(".pyo")
and not filename.endswith("_postinstall.py")
] + ["LICENSE.txt", "README.html", "Uninstall"]
installed_shortcuts = []
for path in (start_menu_programs_common, start_menu_programs):
if not path:
continue
group, group_path = create_group_path(
path,
start_menu_programs,
start_menu_common,
start_menu,
)
if not group_path:
continue
directory_created(group_path)
create_shortcut_files(
filenames, group, group_path, module_path, main_icon, installed_shortcuts
)
if installed_shortcuts == filenames:
break
def create_group_path(
path: str, start_menu_programs: str, start_menu_common: str, start_menu: str
) -> tuple[str, None | str]:
"""Create the group path for the start menu.
Args:
path (str): The path to create the group in.
start_menu_programs (str): The path to the user's programs start menu.
start_menu_common (str): The path to the common start menu.
start_menu (str): The path to the user's start menu.
Returns:
tuple[str, None | str]: The group name and the group path, or None if
creation failed.
"""
group_path = os.path.join(path, NAME)
if path == start_menu_programs:
group = os.path.relpath(group_path, start_menu)
else:
group = os.path.relpath(group_path, start_menu_common)
if not os.path.exists(group_path):
with contextlib.suppress(Exception):
os.makedirs(group_path)
# maybe insufficient privileges?
if os.path.exists(group_path):
print(
("Created start menu group '{}' in {}").format(
NAME,
(
str(path, "MBCS", "replace") if not isinstance(path, str) else path
).encode("MBCS", "replace"),
)
)
else:
print(
("Failed to create start menu group '{}' in {}").format(
NAME,
(
str(path, "MBCS", "replace") if not isinstance(path, str) else path
).encode("MBCS", "replace"),
)
)
return group_path, None
return group, group_path
def create_shortcut_files(
filenames: list,
group: str,
group_path: str,
module_path: str,
main_icon: str,
installed_shortcuts: list,
) -> None:
"""Create shortcut files in the specified group path.
Args:
filenames (list): List of filenames to create shortcuts for.
group (str): The name of the group.
group_path (str): The path to the group directory.
module_path (str): The module path.
main_icon (str): The path to the main icon.
installed_shortcuts (list): List to store installed shortcuts.
"""
for filename in filenames:
link_name = splitext(basename(filename))[0]
link_path = os.path.join(group_path, f"{link_name}.lnk")
if os.path.exists(link_path):
try:
os.remove(link_path)
except Exception:
# maybe insufficient privileges?
print(
("Failed to create start menu entry '{}' in {}").format(
link_name,
(
str(group_path, "MBCS", "replace")
if not isinstance(group_path, str)
else group_path
).encode("MBCS", "replace"),
)
)
continue
if os.path.exists(link_path):
file_created(link_path)
installed_shortcuts.append(filename)
continue
if link_name != "Uninstall":
target_path = os.path.join(module_path, filename)
try:
if link_name == "Uninstall":
uninstaller = os.path.join(sys.prefix, f"Remove{NAME}.exe")
if os.path.exists(uninstaller):
create_shortcut(
uninstaller,
link_name,
link_path,
f'-u "{os.path.join(sys.prefix, NAME)}-wininst.log"',
sys.prefix,
os.path.join(
module_path,
"theme",
"icons",
f"{NAME}-uninstall.ico",
),
)
else:
# When running from a bdist_wininst or bdist_msi installer,
# sys.executable points to the installer executable,
# not python.exe
create_shortcut(
os.path.join(sys.prefix, "python.exe"),
link_name,
link_path,
'"{}" uninstall --record="{}"'.format(
os.path.join(module_path, "setup.py"),
os.path.join(module_path, RECORD_FILE_NAME),
),
sys.prefix,
os.path.join(
module_path,
"theme",
"icons",
f"{NAME}-uninstall.ico",
),
)
elif link_name.startswith(NAME):
# When running from a bdist_wininst or bdist_msi installer,
# sys.executable points to the installer executable,
# not python.exe
icon = os.path.join(
module_path,
"theme",
"icons",
f"{link_name}.ico",
)
icon = main_icon if not os.path.isfile(icon) else icon
if filename.endswith(".exe"):
exe = filename
args = ""
else:
exe = os.path.join(sys.prefix, "pythonw.exe")
args = f'"{target_path}"'
create_shortcut(
exe,
link_name,
link_path,
args,
module_path,
icon,
)
else:
create_shortcut(target_path, link_name, link_path, "", module_path)
except Exception:
# maybe insufficient privileges?
print(
("Failed to create start menu entry '{}' in {}").format(
link_name,
(
str(group_path, "MBCS", "replace")
if not isinstance(group_path, str)
else group_path
).encode("MBCS", "replace"),
)
)
continue
print(
("Installed start menu entry '{}' to {}").format(
link_name,
(
str(group, "MBCS", "replace")
if not isinstance(group, str)
else group
).encode("MBCS", "replace"),
)
)
file_created(link_path)
installed_shortcuts.append(filename)
def postinstall_linux(prefix: None | str = None) -> None:
"""Do postinstall actions for Linux.
Args:
prefix (None | str, optional): The installation prefix. Defaults to
None.
"""
# Linux/Unix
if prefix is None:
prefix = sys.prefix
if which("touch"):
call(["touch", "--no-create", f"{prefix}/share/icons/hicolor"]) # noqa: S607
if which("xdg-icon-resource"):
# print("installing icon resources...")
# for size in [16, 22, 24, 32, 48, 256]:
# call([
# "xdg-icon-resource",
# "install",
# "--noupdate",
# "--novendor",
# "--size",
# str(size),
# f"{prefix}/share/{name}/theme/icons/{size}x{size}/{name}.png"
# ])
call(["xdg-icon-resource", "forceupdate"]) # noqa: S607
if which("xdg-desktop-menu"):
# print("installing desktop menu entry...")
# call([
# "xdg-desktop-menu",
# "install",
# "--novendor",
# f"{prefix}/share/{name}/{name}.desktop"
# ])
call(["xdg-desktop-menu", "forceupdate"]) # noqa: S607
def postinstall(prefix: None | str = None) -> None:
"""Do postinstall actions.
Args:
prefix (None | str, optional): The installation prefix. Defaults to
None.
"""
if sys.platform == "darwin":
postinstall_macos()
elif sys.platform == "win32":
postinstall_windows(prefix)
else:
postinstall_linux(prefix)
def postuninstall(prefix: None | str = None) -> None:
"""Do postuninstall actions.
Args:
prefix (None | str, optional): The installation prefix. Defaults to
None.
"""
if sys.platform == "darwin":
# TODO: implement
pass
elif sys.platform == "win32":
# nothing to do
pass
else:
# Linux/Unix
if prefix is None:
prefix = sys.prefix
if which("xdg-desktop-menu"):
# print("uninstalling desktop menu entry...")
# call(["xdg-desktop-menu", "uninstall", prefix +
# (f"/share/applications/{name}.desktop")])
call(["xdg-desktop-menu", "forceupdate"]) # noqa: S607
if which("xdg-icon-resource"):
# print("uninstalling icon resources...")
# for size in [16, 22, 24, 32, 48, 256]:
# call(["xdg-icon-resource", "uninstall", "--noupdate", "--size",
# str(size), name])
call(["xdg-icon-resource", "forceupdate"]) # noqa: S607
def main() -> None:
"""Main function to handle post-installation and uninstallation tasks."""
prefix = None
for arg in sys.argv[1:]:
arg = arg.split("=")
if len(arg) == 2 and arg[0] == "--prefix":
prefix = arg[1]
try:
if "-remove" in sys.argv[1:]:
postuninstall(prefix)
else:
postinstall(prefix)
except Exception:
traceback.print_exc()
if __name__ == "__main__":
main()
displaycal-py3-3.9.19/DisplayCAL/presets/ 000775 000000 000000 00000000000 15225167330 020051 5 ustar 00root root 000000 000000 displaycal-py3-3.9.19/DisplayCAL/presets/default.icc 000664 000000 000000 00000047420 15225167330 022164 0 ustar 00root root 000000 000000 Oargl mntrRGB XYZ ; acspMSFT -argl'orl
desc cprt /wtpt bkpt vcgt rXYZ gXYZ $ bXYZ 8 rTRC L gTRC L bTRC L targ
X Darts N ,desc 'DisplayCAL calibration preset: Default text Created with DisplayCAL and Argyll CMS XYZ Q XYZ vcgt
!!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~
!!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~
!!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~ XYZ o 8 XYZ b XYZ $ curv * 5 A O ^ o +Jj%O{ >s Y]3lk {
:
h ;
n^VV_p?nD- ~ * : !_""#$Y% %&'v(C))*+,f-A. ./0123{4h5W6H7<829+:%;"<"=$>(?.@7ABBOC_DqEFGHIKL3MXNOPRS5TiUVXYOZ[]^\_`b?cdf8ghjGkmnloq
'
]);
// Warn when the profile white point differs significantly from the measured
// display white point (> 300 K). This typically means the profile was built
// from uncalibrated measurements, e.g. the calibration video LUT was not
// active during profiling or no colorimeter correction file was applied.
if (profile_colortemp && colortemp && Math.abs(profile_colortemp - colortemp) > 300) {
this.report_html.push(
'
Warning: The profile white point (' + profile_colortemp + ' K) ' +
'differs significantly from the measured display white point (' + colortemp + ' K). ' +
'The display profile was likely built from uncalibrated measurements. ' +
'Common causes: the calibration video LUT was not active during profiling, ' +
'or no colorimeter correction file was applied. ' +
'Re-calibrating and re-profiling the display should fix this.
');
for (var i = start - rstep; i >= end; i -= rstep) {
gamma_tracking.push('
' + (i / 10).toFixed(1) + '
');
}
gamma_tracking.push('
%
');
for (var i = 0; i < grayscale_values.length; i ++) {
if (!grayscale_values[i][1].gamma || !grayscale_values[i][2].gamma) continue;
gamma_tracking.push('
`J$i #I 'K8Đ..eK(l
LdzcD Y狍?SOd(saSR.t%T6 \3A aJkugCZe3
SXcph]F0MO2>d=9?E
F[dkYp&K.hV919]M2~HB%19Bqd눼S
aPGO6io e7=VGBҌH kFMڥO$ ֻ6 1ȥ`۔CZ-/o"acK ?P-xGbT~ϊLqӥ71[=xi29"WȈAlRɜq 05@/ ټR$&;5P y⬾lm d`ɴc l!^ Ϣ&rC?Gz S%LaL[#݇ n|1 qVR#'o[ump?'^q!q9Ú µb^)vB%VZ$c]1;ߖt;`0tF7˟PC&7RrIQw5a3C .:&upӟ)dh'Qk{d7 Θ=]Ջg&PbHaĞ![z'q<F Q}4 lIdȖ`IQ-) YRfM3<
wO_u Y g =M qW4rR]5}ߦhfl}T@dJ
?ΩKRȖ &oX+"dЬr
x}fn
_nvNp$ 6`=v.k9/"Q]W:}[jB8m` /kQ\9FòmBVpY}$bJ\+fؾo3O70Ĵs ஞ }TICrB`G,: I 0c42UWN- "b 1)tZ"-6S9rFB91 [xɺF7{ م1Kr8-XÐÆ`KkdGt9jN8R(ɢV~+,{1/
=j ^Ƙm~g^ك
aN-CM@XRc@/QY A(^sѰe3[rLO7!(`: ss|'Md|`O,y SK?6dJ6Դ>s -+m0=$){S~O(4f طlڮ{
nyt.dЎYexC =
8 dRK?Ta>
i DMuVeC[
) .дN n㤉E؞V&FP! &:b.h pL?Y P
. ƤKX2 8++ S$k BNǜ_
5,+(\xȿm]
?%Y#2N(. @aH a^qA"]: ;S
y~Pdx|bbb#[7 ߂}mǹ(:yl1
/K9,', k O1&ɠgf3_Ʊ)L54 TbMZiT S}Ǎ'x`!߁ߊŠTǙЧ:#agJ K8~5s(5pKrP̐(@NMb@>TDrM z~-灉( 0[o7 ؊w}- "՟=!8u1.LvPjm P if.Zj
;c8z6IDM/$l{6aIµpBYSrJ`kU1DXk"LZ&BTSCfvLpQ#~ l8DH6n%~~sS/_R9|cR9TIEŕS`9pjHeV"$+ i p<e?|dVɆ깟a o:~l;n#eCBRMLIdU_BV,_fa,z\}"aB,zr 69g)KVë ߉ MY -7ۇ8p Y<-
t)tv! _BD%EG" A.I:J(A q K_ҡlQoX.tUoJ"LI:!IhJUd~40ß!ma~R,8
oɶ ᡉ_}K?,9
a)c ~Q) >vP9B$:zF Y&Թ81oG<6y {p8`N!: v;iyT@L@Qe(0z ^F $, Y0Po ih8ؓ\;m{xpE w0[F߉OVliJ:}%ܺ?֤YiBZW2$WNa@H%[n.*|q@3bO"̐ȊMW"t ')A(
A&l?M]+.;\} odh!c~)}l>YBהGx U*d@.4DSnW|p>{`ߋW JYHk_kkxm]Q&K$F{2T15ɜ3T)A?3᫇9,9w:N:h: `sL=qﳤ6LG2eRmˀSSJ&I.S<č=?^fk; Qc -؊v$G 0;y19z=\
!zd K1i*e\+ŖwكC:r$G 0|Ƨ6 z5e&xy!)T#UJ51%NGPfA\sݿj7}G9zDsqub^Ō^K@ØdNYcF Saݲl8+1{:Y$`c C6Զiz33ǍD@ O#kq]}dߌ] qI3A
hrI#.xDp 'Acr,ɉDn GYWS[xv#Wm{19Rlْ-U,JZ}nOS'g[
J%<ݜE_=ɩwFnJ%Ů"dGT9oE!t
~ k
% Y=Tl˨[&k%s̈ bk/=SnO볨mk0U|t/l4Г`̪ %s)hCZEhILk [볠.8
ଁvhNXcs f> 0`kY' %} k]=gů4p볮D]Zspz N &V0uKmI= @ns ޓv?c&pnf
e{ é=8-)}xF?˯ǚC#Q`L 2 i1 w {;Aܾ9pSm8 OyrΨ'{z0^ ί0'=-U=W7d h89&rە~2dG~{[~h~/ܝW2F
zzKoY[zVo50f[
zzYoVj`[[
zVoVmn_ quyz IENDB` displaycal-py3-3.9.19/DisplayCAL/theme/cross-2px-12x12-fff.png 000664 000000 000000 00000000264 15225167330 023350 0 ustar 00root root 000000 000000 PNG
IHDR a tEXtSoftware Adobe ImageReadyqe< PLTEfff Ɔ{ tRNS S *IDATxb`f&0 0adB Ff`FF0` >.> IENDB` displaycal-py3-3.9.19/DisplayCAL/theme/dashed-16x2-666.png 000664 000000 000000 00000000223 15225167330 022436 0 ustar 00root root 000000 000000 PNG
IHDR f3 tEXtSoftware Adobe ImageReadyqe< PLTEfff s tRNS 0J IDATxb` F0`@ $
IENDB` displaycal-py3-3.9.19/DisplayCAL/theme/dropdown-arrow.png 000664 000000 000000 00000000406 15225167330 023160 0 ustar 00root root 000000 000000 PNG
IHDR ڛg` tEXtSoftware Adobe ImageReadyqe< IDATxb[ `S1{3i~ U ɏWn3:x)_ O>ϫ W3<#}/߿{
AL?g0
v=k[}1AV$8j&Yaa;k DV IENDB` displaycal-py3-3.9.19/DisplayCAL/theme/dropdown-arrow@2x.png 000664 000000 000000 00000000766 15225167330 023543 0 ustar 00root root 000000 000000 PNG
IHDR "L tEXtSoftware Adobe ImageReadyqe< IDATxڬSKKQf""ئEm "\$DڃТhղ ;{(jDR>M;s'2,+qΜ}ߝaΑ= p
IQdþJ9C$ ˄_p| ɏZ:̀G)weX4E+
hjk4.2$Bd-.rMNO F.T[!-y(Wз22
$^ #HCZ[YJEn(ބj#NړPxR(;5_|QN52* Fm3l!wu|rQS8 uq ߮&^*ú4ŗ5Lܧ8LHs]w55]l˳ aP[3y IENDB` displaycal-py3-3.9.19/DisplayCAL/theme/engine_hum_loop.wav 000664 000000 000000 00002224054 15225167330 023365 0 ustar 00root root 000000 000000 RIFF$( WAVEfmt "V X data ( lgJ@%rwLS$0
RtP(Oz-VYR k{4 w`2J3x'T?=Ru -7&KVUkddd!]]8dUV4F'%+ @x8<$Ab IE7Ei\i~wfx/2zVTu3+sIj b 0fQ{ A"Mx%w:J1ub OYE D,:<_O~f&heI
=Uu zx1GJMp83V~2hfJI{s^W?X)lNR8>{/ { 7McxoUd "8 A A - U Lx
@ ]>I)ot,`]"f +-Y`GiuAUl , 8Oa TAW^AT*T/jY' f ~^|W`:;n [ M # sA !:J g Sg l V
+
R w | Ax c| A EXqB`}A/ A ; ]fBopta5Ep7 y3iW5k+r+t%_)_ozq _ $<.[ rt =tDd6e&n 2/oSRV%qCt+d=[$TPP1nI Q;p rIZ E(-:IzV:uf
##xi5$CT >w J _sSP:"tRTvii(|\8;A%
Bf/Kl( >< t'S7wxY mw ' n 2 p;+ _oc2m1 ,
L j % 7
D5
~K
d
%
H
8 N
~ TLmG#3u"|PNCO<0QCFGRK-* MHm*w0 [U^;gz6a[;Q:8
(
!
?{
A
4 Q c
k L /
!Z
+
Q Q
0h w X'}RY wly s,U6[ f
3 ; b = , M '
HX
9K E S
2
n 7 *
>
:
q #
E[
q
O
'
.d
yj
P
tI
.R
h
w
_
u
+
V
z
p W Y
W
R 1
r M W=
{tVY\70n$Q6
Xw` @#|J C%'h,^ 8g,oCY;/'Fo?8T}O=(@
CxtN& -
O]AJ*PGfstG 5L "C LN6Ol""Jd4e;YDn{^%a:S#6La?'C`s(\ * = *9grgKK|e
f{1rR9A Lza5 ; R+>E.QMUUF_FZ7hi[mfwY6f_iju#`/V:Gq
C OU8u|pMy&_q>R'%9`
|buN
Vf
/%m[- hs|u^G^y=\2y}1*m4/ |u1M V%' 1 J q 3 WS1z^=kb&BDOJ/B c ? ?p[Bb. &G7lShy~qbYV5-'^m Hr /iFUet|=s quYagHbh x0 +$
g!c%@j\CT GT x' auygW /
=SF
1
Q [5 o V y C # \
Q
<
9
* G
N
E
o]
S
oV
h
qP
G
.
O
kf K 84MJvJ` 9;z m
U
^ D
+
}HC
L*D)r Qmy
4
4 ( `r U&
^ |+g5 ~\ ao@N.
jCUH Y S z ! " #L $X!_%;"%"b&a#&#&#&o#&#l&"&!%9!$l A$ l# " !L g , ' jS'RJ09Me.5[oxoo (O8}E'r
v}2;
?}
P
N
>V
:LGrp Y
"
d t( H ^ p
q
(
@ FSb[_ , zb0%S
o@ k C T r`k5Q@*. /kq!M7J'1 I|
j7 4}
-My!~7 |U x
q7
Co
Z e 8.
-
c\"":_q%K<T CuS
Q K
%k = 3 a O d%Kr;b ?p%_t&]b
` 6 W
,
+ Vq
$ J
*
8 & .
G
\ N
f
s
k
r
A
_
`X
1
1 # F
y
% Q<b^`[XgUJa@sHJOW : G
}
J
Kg
,
. m S
"
uk%
~2 ).cfaIg O?OfktsT#THEFX~B!{ ^
6 : X
n0y-7$ ( "
e
v
R
$ %
g
:
b '
K m
_
[
4 *^
]f _WQ*^x =%c.m'E]3)JA;:SX(
+cIGz2hq o ?\ no Q + n ?=mN>s\ST o$g E
lu
Q
7 iEEBGLa cm<n
Buq; [3QS! v ! .<`?5/:e"0 sj-_5 $z J q ;
svkM$r$ +CUa%(}B> sHV/,w8D 6 9A c 'f \fJ$ z
k _.G Q M+ -: ?s 7-,`
v
X
!I p ]
i
Wv%:dOGvKk|_YY|#-Q U G2{Sq<J
un
p
=
i O L@ " | a t Z
D [ 0
H
BdaW4qd*8~ '9eG% d } F !H"m"X# #G#w#Y#"mS"7}! Rp ) V [^Kxy
x ! RC A 3
vO7@$ N@{~uAN5OHd}R; g N $ ) - & C K G S 7 b t r B < e ? !M!."!";")#"Z#"h#"0#r""!"R!!~ p H h?A#Sbd
z i
yf\:]~p &e^ {> vz N),TF7'o@r x#+`\1 t4K+
|r*CZXp(| PvEoA+/D<$|`l.,6@b`>o
[> i, pW, "] B]u }]
B !
b
K.TCwH2^
x
-r
YSY\c4yw
\@c-NmQgI=f2u t x g KU Uo FrD T
F P O !
t
'
L k
g |
" u
_ T! bB~l,Y-a[~
x
5p Y
z *m
V <+ >rp,22sT & UY l `G J-Q' h k [ wYi}tV Z) 5 J{ >% }~
P9fb@#b
: ]\Us.fslR<62sGfO%4`{ 3#R0 LU{ `Jav7^FKo2 1@;U# r6_afjw& .Ya{xZNlh0Em1*?S=+ i\5Z\%b hPZFdP" !o(|-;<,h
DZk93Wa_8pk:A'7V[8 ttE &BUR:8Y ^
B
[
l
3 ~ X s *
, ~
D
6 / 4
K O 8a +
4
o
'
d # R
Y
&
{
P
.
Q
O
#
C `c u x :j K ! }
`
]l M7m=D*v>Zj k#iInyfvK#P~jL.>V6y\.P6Nun>{X 4 5s ])}XF7:1_L\RH XS R s r C E '9 U z $m++i%dF 2QRv*
$8
k
x
i
!
6 W X 6 "
l
*/Lw)c
8 ?2[eC[YkZkC
q
c
J
NI
\
d
7
E T
M a
z [^N(e pix
d "dh.5u[NA=wMU5*
s6)pBQ w`ZQxJAR \bq
c |r]@1 )nQ@
Z ,Jx S JM+^{]!7(q iH3=r}k|V\ jRD k C r6 Ll%[F
1`g"B
|c8NMWVkS6u; 64Y ai[ ފM"݆܌ܣە.h9 1ٟԖP~љӭ| UʺȦfDZ/UŎʅL?ʭhʉæʙ˵c 0RṫĴ̶̵̒Ŀ̎Ĵ̑Ĺ̎,ŅTŀE0ϛǟOc ,|ʹ*`
Չ2R֍ΩJ^S߮ EoK]:1
O3MF^K'&z`71e RS+\05alg<&
DjB pu2 a) -6#5R$X hUPy "tW] <P#L!R5>)/ | * 3 s MS \ Z h # '>Nj n|bM\8v\QPvAl '3 ?VH0 7~1Dk J
YYD
1vT%
\5i[J Z ?a YTsN 88 `o
D
BAoUM. f
= L
=A D [ <\$\"N:x<W$
^* % V *F T q K
| A 3Q ON K' BY~
p
/
$G
q @ 7 2 $ 2 V f .
k
B ~ -W) 7 6 ATm utb@Ul[4RB_Bj`xH]k<
?;C;[BtWZ.߸>Ha~I67u$0ds}\o0U/51\I)7}n_}>T"pk1M12ߐfߑ!ߩ~;Zl5އݞݦe~b ی&TߴZ9~)Bث S 7ئtLܰ
d٩{Tcڀg۪ۘ Qݞ ާݟMނ`>%=j!ShW "4%cN)^b9IM^U[2C. `B E=w)NyJSirV&s;qe(I\ C Y rl
J] G U
D
y
S _
,Z
W PxL',p[*jIzJC}gWE^{<BVjb"B+-@
S / + BS S n ! m x &g
K
&*
1G
" S
hD
.
!
K
t
f 6
#
{ Q
< o
`
C
1
$
5
_
/
o - .L?V:#Z.
j
<dKG}
?gh^<F}z^8&2`_n
t|geC(XoZ;@jx?"< Y Mb , p A ! ," " # D# |# ]# I#
# "k L" !z e! Z C L
B _ < ~8 `2V MpB42w{.=*P
N 7 h
^ .7Sd}k RCzvHp+cUA2Ik9>%Xd:o"6OxTF=f . ?}{O !,,&2'%lI.cq( =d#5 Rc1oi@]5| |V'c +T| >8{*YV/,0Z$t:har_ tO7wN*8]23 Og*X=9UO _1tD$uOKuH# ".gJs Acgm%D p2]Y @,| [B |aH^ w\t\@ P.o ,fD:&PtSv }
%Zk7Rk@ e`j
q 8
7
$
]V Y j
HmpV/%mb=ff 6
;
~ o :
T
+ N. I
q |5
<G;R2-HK6 %f A^zWC p>Z":eM!f[zi
0" @
z
K
? z k V
H
G
+m$DQ soxz*`KM 8 K #-TZ:
\1`{&T] T i9bl[k\aju9 Lyx I$q 3 Qt,*LPOD2@C0FtuH,@E^t A
:V=C7Fp ''D} psN:3IzBYC;@Nl fTFK ixswfs95&{C <
WVQKNtNyp`s
1x1 Op&p"G } . 6I QV/4
Y"_
TJrVT&u}P* J
2
a
|F
q ? GX0.mu Adpy ? gjz"2Oeu,yj!]]]j i86I}I3/R^X%rG IbjFw5]7-b) TBl<~osh5` 9<`$iv IzcH_
W 1V2{R [d01W?=T
K
1 & J ui }
]1
\ x{ p 8 AmjiAb}Q"Cl;@ ! n/#9!djw\?9mO -f#<
[`/6}YpHݾ: ݏ܆
~[ۿښ-7ژّshAu2
<ٷFsօB5*?֪ ۿ֬)ܓ׳ fWݾ؊u>ܭ78|ۇגւՂՒ'ԕdӴհ 4ҎCԲ8KҤd)fӄNPؖصp٫oY
ԋډӪҙHpڼ0=ГI)ٰkҡ_ӕԮUO~ٰ~Ds7]b[C&ܹ+ݎۧ1ږޝnړH
=ڧQ'iڟڇ a:l$ܙܧ݉np/Vޅ-v߈ߊ\ߝ4^ޖ|;ٴ ٫[إݾ׳G Gށזޛ \s/ڿ#mܸ&YޡW_ޛzMB64} 3ZLޔAFߝV!&yoK'.0L c 1RO^G-*347`"vxeiWkU9?S)[s UT9QUU\e[|x@OFa
/JIhI0!(X*vJimbv%\(Or -V2V,afZ7hY x-zs(
vV.b-Kc /d^ tj H
c y[
'
p
W
9 hZ
B% Oz]&`M5k@% : E_:b:):[RT]$>7)=tvR7;CaG4 Qt;V$ep(J KldDT[jNB!<"g.E g 96`m 41k l<]gM+*j=PB#[ A?D<F] &&;\ jM h`
E M y_
h 9 :
Y
\ q m 5 x
0
J
R ZDQ$ pZ Ts=b eR/=&>M)ZEr}--8R3ygxZePAFFz8 `. f%fLlp;d h. PNO(zI(
qR55b 7 c 0 N
) O {
a^
-
= >G 93
f9
v .
m }x1 K m my F >\S Lt p>H<-G~; _} \n 9\ 5ln'Wx L@Hkߨak:vG*T Zww7\FU-A,^TeuG lPc|u(my8k<>l)UF=GGQ y 3w&p4lSEiVv_kd`W!_1? ZB cXf |y1x^]dsvo(`K''z`xt|2.~@ lK{ V ia:"g B-XE&fsH f iR=X i 47r
~ C u
y e
Ab"Ve1K]mm 0B<3kS#ab<(%:FYmKwjv{`r1IW[
p
> g
d .
&
1 R:Y!9{=Q+`l[P ?; Jj >p Dh 6Q 2 T { OE 9iipqy2tp>|K<&Xp OM t 0 : wT6t"uBOQ6fy(g
BqX Pscib c
J *
*
)p
p<
9YA6Iw[4>;*"`Yr K)F6IC Vi
6
1 = ?
X'
9') /
3>
J a "
+
S| g
a1<)t?
hK+"=}'[T O1$`~7~o/m&`y)^}7)T|
;|"Ol&%mAޥf MވSJfXj@ޔ@4ߛw4s$=u-1v>uW8"l 1^W^]VB$1 x
w !
'
X uW
o
a +f a
m
S>
,
c+
<
N
h
|
t
j
On
+8
l< J~ ; H. * WO #wN^Fu #
/ _ )
C
:b
p
L
&
x B)m
>g6g qJbR i5i 9\ N g q% wV mx b X ` h #[ 9 ! " # $ %!&"' $($)%u*&+P'+'#,o(n,(, ),[),|),),),w)x,m)T,h)E,?)O,()J,)s,(,(,(-(p-(-(1. ).*)$/3)/@)>0o)0m)m1l) 2l)2Y)20)73(`3(N3Z(
3'2i'1& 1>&0%.$-;$,|#+"*$")i!2) ( w(q l( }(M ( )o ~) ) d* * 6+ t+ + + j+ .+ * ) )g ' &f%#/d"e ~' -K<hS
^
> \ 8 R %
p Q
F 7
o J Ic) _Cn : ~
[ R A
* j
[M
uqKg\5j]bfoIq
t+[x^_6 -FJg;8 T9 ucV8R+4Hx1UIe
B
ER4:K"
/@
a j
` ;T1&MhH5 yn$J'Z jnX)KWx5n*O a`*
}{L*"f#?w_0-aR-KZ-
!=es3K+L4 8xE+~S .SF Sre mBYAuE
R- B 9EEzCm hI -jpA 9;P5Rm 2 z , I<)w[U0sB{bZEG6P3v_tBCI9Fbxf,I8~JM 6tx2!:Stb qul?V6Qi.u_= .IQ-;XPHCCx], ` t ?
C
< X p .
0b
o + 4
\
A=GA+
C
8 P (
WsRi
H
f :e
P
:
e F"b D 1A'xO$|n"wL ^RN N i)m0:sdmH!TkeEVRFOSrNH8 " ;:{ [?Fu A
^` (
h
z 1
TMq~vg `k_8qosLeECM:@5A6
G _
p b
^
(
\ 7 %
#
R
T
R EkWSK V*n d_4(+67zk_t8 G91 p=iK;4?`N |m Jb 3.'J)xA^Ez>Xg{r vX%^nSIߟsF$ޓJݕ 5qޣb7}xKO Y Hw^BK6+!+ =bApab'C@"P>-Fpcd,blt l\MG 670 ? i
N "
c5Wkw ggG6ujcP )*VH | Hk N ^!q g" p#h $ %O & }' V( F) *' *y h+ ,!,s!-!-#"-"0. #.{#.#.x$&/$8/p%M/%O/R&=/&!/"'.z'.'5.1(-(Y-(,*),)2,*,y*+*+{+++6,y,,,,U-m----Y.-.-.- /e-%/, /e,.+t. +-H*s-),(8,?(+'&+K'* 'M*&
*&)&)&)'')Z')y'n)'\)z'5)F')&(&X(%' %B'9$&##%"$ # "X !
L mHskb& B!Nn[H0 2 q k 3 P [ _ w ; G \ & jt\gB} {PIg
C
G v f 9 3 HE X @ 1 sc
e
W
b
^
%
s
/
t K G
? $ M/tw-@$<y]U_B{Ki
wM O9Q^C}_\|y"uYQjj/8dW i?n~pbhs+B5?$oML/ fQ{"jT;f[:f ]0 5T6 bY9%pl-E D x f 9w`9IsH1K er =
vym`puM0AMKiBa ! I' r$D=[$ =
s
$
a
~5
X 2 ? T l
G
f
^M
X6sQtuvaSFOOhW
Mr ]Y1A#*Zo
! " k# $ |$ $; %` N%x k% %~ %{ %m %u % & ?& s& &H & '0!;'!T'V"' #'#'$'\%''&N(&('
)^(u) )))* *+l*+*G,*,*.-*s-/*-)x-9)3-t(,'+&+%)$(#O'"%a!B$4 " )! w 5 ?X{t{+
n K
d
|
R
T
O
O wf3 W dHsU*/`R0Y?: '1UA,)X( ߉mTAݟVMۭݤ Zۥ*:ڣڂځڂڛ-Z۟Xܗ9ܗݲQ}A4YmR+G}B= "Fi"9Y@dASC2y#'(6We=8M,uI b2&|u>A7B oqv0@+bdIlUwC,{97wkO4q*XWr}J Dgߒrh l ?TU(ckXR>( [߬NE ovL$Q^FNQaJ,^ l(Pz%R^64>e4 luC&oklX_QNavr}Jzy)yxi=9{ cpr My4@3HF 95,sf4 T ]
E
a
7:A=t 7-*XK.R
k
?:{1B~xw=~ J q h P !) "!#!A$"$G#$#$c$$$$%^$O% $|%#%#%Y#%A#x%%#Z% #P%-#,%=#%S#$a#$p#$s#$^#r$C#Q$#$"#p"P#!"{!-" V! R x i * 9#*[An*;6^3Qv18oGRrO KKvF&t) 2sM>'| K %:j521+#W {`^u)~Wa;
H , m
!
k
]
M }
I+ S } F )i #> f
N
|
9
.
T X
%2 L+AT5cO8 d `.
8\ F !Jh
4p!^S|kT<$xN!\ #;@BSKLDXfP\ ^[J:{qn2Wt:K$wyf3!mAB:|&n g(^ߚޙޛ9ݚvܮ+ݷgW~#Rڜ3۷ڃیڠ>qؑ)Ve ە֛1ԾO$]rؗФYDQςքΘ$jԇ3?Җ*̹V|
σʪʁΠɁKɝϖmf /Ȗ/L0SȵҎsaQչՑ˗}4ׇ׳ΏM2$ځMܺ' ߛ@fjxݑ1߫~`R?guz$3fp>+H^R B/* Z
c #
6> j{ !"e#Y # W$ $
% J% %Q % d&e & !' "b( #d)7$*%+$'_-(.X*0,<2-3E/50"72853914:4;5< 6H=m6=6=6>6>7=7=(7g= 7=07 I =@ Zq"2
@T
'x Q S 5 gk+ie{4 &}$+ZgAV19=*A0tR;t/9AbD s;}A5:` GL A,]3h!Xi&A?X/}Kj j
S6bzJ)YJt!Jތ[ݼ ݗX5״%ր?mM>ւa:.E_ӂJAӖը8֘Ԡ.2ر")tr٭֜tك,/ؘ֦hԏQМAОS̻˲!ǝ_Y*nņ4(|W"ǃgVǫs.dƩȃɵs!Ǿɋ =ZO_OE.ʏʮSɡRʠKm_ȼDZu4ȯƍȶȺh#zpǎ4̯ȕ ͘|͠?8˂μSϑ =,0~3 <Ϯ=G[ϸw=ҠϤXeлy"'ґ
әK6tط# Q_ܣܬ>+yRyujBa? g|}|Wo&q"F M5_CL R-A2a\6=qABD 6^K; k
G
/
@q#mrP ? k= * !1 ! 2"r " " ?# #< #!$!\$"$\#)% $%$$&H%&%+'&'F&-(_&(O&(#&')%Q)%_)-%E)$:)$
)R$(4$(%$C(J$($'$'f%[' &?'&H''`'Z('B)'.*>(+(+f),-*-+@.+.-//.!0\/0011c12131415262L717181(81+8t17_1u7L1681A6#1o514 131~20p10S00@/0=.02-n0@,70c+/~*/)-/(.( .k'f-&,%+A%*}$v)#,( #&J"%!,$ " T!f D 6 s H*KVukn
%4 E
l&~= ?
3M k {
V " "Cel7\00\>G[ ,0tRY`|0 bV/,J/?pC D} [Y F ( ,jxXB'7 dx 4|
2
S
.h(0`Cqk O a !"#$%& 'X ( ) * +!,"-t#^. $/$/7%f0%0%B1H&1&1&1&1M'1'1'1K(1(12)1)1O*1*1+1Z,D2 -2-3}.3+/4/4n0o516617;28293&:44X;4<5=6@?7@8B
:XC6;D?<> ;z=e9<7;c6: 5Y:392t9N2 918t1q8F18$17"1)7"16.155151.40)30&2_000/}/..-`.,-+ -*F,8*|+)*))()O(G( (h''&v'%@'$'
$&G#u&"(&!%3!w% % $u $ # # s"n ! "!1 q 8 ! ? + 7 M o| 8 1 pc /)
BW
O
}W
*d
u
6
(ipe/c/{
. #G ^
e oZ P
;; D
S }7s}QC6QFdh w
O s _5
Do
a
9 ? E
d
9 O \ TfJ713 N3[ n
GGU 3>B1d43-9oqDY\/c\5wD;!zh+QfEw925_%NhmZT]Nw !sT9T +o@,f J= OSaG x6nK04k'c&Gh(N
G6n*@KSI/vi]qNN2"L0 5 Vi~w| ppmu w { j u r]P4;I*nbAky&OzwE-ds- = r D%9\t= VR) 2|O e%_OXv8WR%Y2pZkbjyEu
$ ~e=$B\up^#\hoT
NAzs{w
Oi9L)"$5I=@ ( 0 )V0Qna:F' '? =v|1g Ve r x
u b O x b m 1
K
p{ hE [. ~ $ = X Ix u
7
N _
x s
q
j
&
@
^
y
Z
$(
( 6 `x6~X;q\L&KYs)%}
8 E Fto m a B I V } [S7D1sx Q-NnbNG%tvl _! p$i x&hV+zhWT/Bk[lfusaH:M8 CJ6OuC!@
A Fv 5z NCl[WYa#o%@D,&`&
]^ l.CߪG"ޡl ka/ݭہ Xݔ-;4ioڱ 4}C`FOav0 q+i&f2>g9H"x6#;j$S .faWBfh+#0<t i(euJ e!CVu? lT i :h3T
l<$,} Gy/u\-t OE;;9CZs0 ngL (vS j'98]KE?lKi:OylE6DgP>1 .3{?'X=[bh t=;G{=@n5pk`}Es2 zqS/&\e3!V"#KGU:T pM,9!u 6C :W+`]zTZ df; t C )&@ n1+$
w ! b GU<zcf$ b 1* '{Xp|Cn5 B(UP< Q]m y}Bu0noOV6}x3`)$ h^&Ltg1Q;P bT
]X3KnR;G\%.]BMBA/Ph_oE"y
Ndx%'7ND?1 MOq ? Q ;A=6}Q@ ' 7
#
o
v
X
r
9
<
j Q / J a } 1
|
~
S
x
~
b 4 8& g T
k D
+ g e
v a
e
u P +78X!=
DEE W b
! Ul } i
v -= wK p
ZR@+ W-',g-l1 ZV% X 3f7yeGHDj.u{nW(hPK(]} "
4sjV+ Tk~H*1@ g s ; 9vhvxX\"YA LHBuFk((]BA)PF J UHA<]L]+fdVo+Q{57H|/hWCOb GAyIz\:&/3XdT;Vl vh:do 49M`e\urhPiL']p 06SRL# 9 <
t
e 0
M
0 k
-
{
j
V
8
;!
K
S A
'
h
81
_ZVM)@a[@0C^nPm`KU
Z
Oa
U)
8
& d > \
>
z^ p. . E @ >
' [ N %
UK
q
z
3
{
7
8'b4hwN d_QbYH*6 Ll UQj*J@fJBkNQ F+JALZ3 2~- ?y y u CiLaKbhB# ?$h9| U & Y V Z [ G A F/Cco
ID
yCFl v _cvL
;
Hd
N
3
6 nU 9Dm= *tRH z9= ]|=,{V k M`
1{ax?^02K ,'&7 L J u [O39d@ dDY:^Rs\ a
r S
q8 h Pd VW ,%
a
, -{ s
R z'7W6 U
K Z K
+
'n
9
e @ C 4 + 7
T
}!fX{o= fL >G-!5~XR"fHE}J0QamP2oUr{,*g;D3< U0F$; o j0 J ` N +
\ | G! ! " b" " " .# T# z#} #6 # #p g# P#g :##$"{"""ak"%"!f!! : N D
,`a[#
E
O
$ g ?> _
d
q
&A =.sI 6@O p G"j>2Pw-< qA
8:x{< FZC QK'Kp]][
0+:AmIURzP2\nGtJ!.?QFNM=7$Skg^%Bso\AM.\N# &Y_YnA)A|d
>KQZuIu* IrR?* KbfSm @w4`-oHF݃݃@
!Tݰ=܅
ד_SܶսۏO ڷluSӆZ1ٟӪԔ)ՋաبٖUrٳZ {s`\7ܾ݇*`G݅Yݣin\ PT4݇-9S\ݼ G]#K%"$!u$1!=$h # # # #
#O $0$I$lj$c$I$1%$###H"! !* #$ O;yn5B\
/
;
c Yn {
X /
0
9 ` 6Nj anrF%by
I e!m?9TT~MYE&KO3C -m~ J ,s]
[j04dr^3rN#O{ Xa# Tg41w?Sf>p1QT[`VEJ! ^\(9|$,wmdPt([:%$TLo\3h8p " A5IHeVjuss=qVAC fy~9 vhu@nt
-(|E 9 w $_] 9 |X|ULmDG@; 4
OA 9 /
*
Q r ;
h@ q'"}`&o _ 1\
>p \ Uu w
u+_T, [VYD?^4fo_K ` Y ; s !B " # $! $b % Y& & )'
Q'@ )'H &Y i&b %= $ # "K ! 7 6 u D B$H 6i $5]H
3d
n%n9m&Z&|+Bz
Y
}
m U | J
2 v
Y - D
rO
L L{Go d , h 7 ;4 Gz ^ [ Q.WD ! ASc'erGH l4p3W=$\v
m
t*a;9 1\4GS@%+c&5`e@b N~d*}C9߫5vޚg&ߺ{?,v+,C&ڕ
:ߺ֕ޤޕiݸҊHOܳ&[ܜҸQCԭI8ރֵ4ذ)
S^]ܑbݨI ߾p10y\-EPbF&_ kZ^d@GJ4f9%dY.5^V/</z.3
jS dW2#3MrwLJ
Zh 4 PmI(BW z$H- f Ad(x/EI >EK8 5%t%E =i h||\omFllx3{MN-~=g)tq?{4Z + fbg { #b;wQf7e\gJ_ Q 6 z #* _ + O uaj1.s f`*au *,\hOJu]54 j `f
B
za , C1
)z6Y0y1w
% 1
b {@ < q2j W s' ; 80 :m 9WC qw A a Vc e3iNV*B~S1EUI Eoc
/eL 3qZ"!QP߷ ow߳}wH߁ߦߟ߇(?VeEljF]ܫ#ߚإsֶԇBWڲByzmш$.%ˬ3˻t ˀm/˳/P\pC,ЀW4tbЫHj),ѿϦ҃IP+r "KWYA1ՊϳOfԋW6* 5e]ԙףڊY۹؋ ڱQ'ߍR@T5SM|8Pb*\1JyEF$AL ''O7e=z@ uQRPD > L t Y 3R? SIL Ql8/o]:IE@om" 5 p &@u%oMM7s
6 B S x NX
B7( !"
W 5 )B
NeEN% b
b s
9n
"&N l`}<9X`AS HodT ZNxx
eWy&I
Wm5 D j
i! s )w V
qRdD15p8aeRO'
rv J.
T $ n
P/ b ~ y r ^} W q 3k ~ {4 p?B \q2|}"
dY#j 0f1!PUPU #$Pt&v0vAD4m'6b&=h6[4DO*@W+)>zub?bpoW+
_C5^nU kcl3)Am`/!uNhp>Co(-Mzj2WzLdusUS<(2?;\j}Y'Ag'eQD''WPhzCoB KZ&T`
1,9`*E*&Wl;&bD v nDQ5hJ x
? e dA
!
c
BI
1%1
|u UCarFCUJ~*R c v l p P Q 6! !"!!!!!!"!3"!6"! "b!!-!! )! m l 3 S
S 9 a!#!!!B""""""M#"l#"y#"k#b" #!"1!\"a ! )! ( > E B =E { r _ !! }! ! "
" " !E ! M! 3 V x _ g?i{
^B#2V]#C6E~k) & R_ b . " IVmGeRcp])o$rmN6WL75] v76C
:
cG ^ 9 R Tg
z W
] ' 2
s
} h9%* cF~$6I *wPcM f jA(PHqA rE*dA)peTQaj3+a%*$)#(y"'c!& V% $ " g!6 Y1 } z - & $ D Q u A . m 1 l o D / }c S<MLByF 6 YV { ' 7 " ( O 4 4 s(f:H r V
G
i 9E [4>5J|@4TVcTEW 'z) :g} [A[roE9) S ~d\ Xd2ft 3Ec }U =UZEuj=w[0
XEiN5$f*$g=c3ܫ?عקcժؓg؎gاա ٦֦xog]wYܭ~ۏ
ݞ0ޢBߓ)f -bbg%>+a@0r(lx(4k
$/_Q+3s"++9;\S i=!Y[ '
kl4:~:6+JLf3"e5'WuR8h5sJg<d}d
n*\}A@ X>2_Nb R
19C
Dy-en&Lw6
?
{ ~
8
Y
M ^
, r
4yDt7XZ F] 74zD u2V iC{>G+K ";q!@i7vI @ W # > h R! "c " # N$ $!!r%?!%h!T&!&!&!4'!]' "'-"'^"("8("w(=#(#(-$T)$)%)A&M*'*'
+(f+)+*,O+u, ,,,
-,G-E-x-m--Y--(-x-,L-J,-+,*A, *+)+'Y*&)%(>$'"&!% b$ 4#S " , @
'{rM
F : e v _N /c><,
u
n _r!%h,Y'w $Y/`Fj7 ; /{O "R<7
r-cR&BX#WnynIt8h2U8]H46"F KGvl2@ Dh*&|f MIyb89B.pw @al6Qk/0cvy? P6,C^zPVSac7 LlS,lW le(1r!`zO*$>SLMvZ"2T&c i3 *LaAk
CH ~ut @ wC.=lB1uPr|palTT@5"?gH=r: D S
z 5 0
4pm +?1Tpp/ w9vM=+U
lnYio'VF=.-D |8jR k zg~sigf
' r" w
hS
0U
[} O1
x iX6@ 3;Qa*:K cP( , 9 3
6r 4#! 8F~D t 5
[
f
0
= +
I
|
^
~
- KGj%}u>l
2
2
o P .
i g
`
-
yX
Y ! G
H :AT0}FlfRV? #mn 'kCu8 4I tN H6_q =s>y4o!kSW 0Z .(000\
]6L#RS\\jnyLu&3PlWPj-^qdG[?$3u 5vb@R";1c- q/
C3Vxcv.NNTBP !=8gE ?
)
v
^
/
y C
; B
o
[
YM L=jYJ;!pHP$2` j | K "GM
qt> q G"RQPZ ]js
-W52S IO f e t4\NHmZ ] ` e 1
0 ^ 3m '
$
U "
4
V
U
w
$%xx7@ Ev'#3)a!h@
j=LIC
s5 '>$]4mSirL-3D879Qr?Z0* *L 'z A I k u y k^ C -!>{A9~!tMmcA l It
{ b . &i G 5 P 3 G Af ]~ofv?ywx0
)
r H
N
1
Mb , ~ ' w O
<
] 9Xw
/cq |T#i2QO< ~ Bt u 8_?dKu7JW TY
pGS$!D'Q JJ hj
}g+w[Lrk}}M!-Va@Cjs-sTa$K9(c-%Vvm VSaP,4*r$i R@LSFrQLqhvQ >kT1 M#
= TEd(WefT3 u\IT9e[ K9*|.r& -|BSE>Q=Mj!]JW{ywtmOxCGD]p%
fx
R T p
B
]
1 _, < = . 8 h K 3 3 A u 3 a
?
*
k
Q
i
T '
; ; s G ~ (
m
+
@
#7
~^
&
T
r
w
j
<9
u !}FZ
n e! q
@ / ; f ; ,
"
O Y
?
T:U3
i
f
x
E`Q>Aj S AM}(T4[b ` p } | m O! ?" #) #] S$ $ 8% h%m %@ %
c% !% $\ t$2 $ # # " 1" ! h! ! J @ ; 2 > r & } #
'::1]hU+'J y 0.
g
486e~r`-g.&U I Ow hZCE(*Av k"l^ @ i #hKVoRmpGX Hc)T DD ).J18U=.NC9 a' a4 _
QwxQSx L\ wx L Q
$ZmXw V5-JkTUO [5*Q?_ N T=tmJ rj' |3 u.`GD0G. ; p 1x W] d7 UC( 9#Q>5,) 7 Hf C
S
/ :x w z Se
P
2
k`$*!_G`*TPm D
*0 H
f' >g;1A' _
-
[6 M
q 9xjfyTt&. W
i
i P *U
iWGa]
X
C
] df X
*
3 P
K lm
P
v *
54o+)~
# C
Z2vYk 5 I
j
E-
~ > Rn*
q ( p
b K N 3f u
l}
( 1 s y 2 r
R 9
+ Q
Z
a
r?
)
r
[ V C s (
vJ syZ||C^?k-90%m9 ? 6_>p2gS5/%9)=__] =_
"D,,7UV DM=.%|8Xgo8j,\i[3hG!bm c<x= M[ZP/5>9m/+" bzeJ'f=ZXY7?x("eE .l KQ /&'<6N,7U;rJj,qGaqT- b" " L;: u pw? dDJ x-
6
oa.o]R8v .s20
h
u
Z J
1 U1
o fv\2 ] #^ wX p> 3 b ? $r&Bh7px
'Z \ephTaP] C |@#2X[ ) _! 9ZpsqG GO lp 7 e
S
LK89ae:+G" C+0R{GTu^>
MY'c[nbXn'O.yB
&R"
2
@
s0 b vs@( '` Z1 ( 7 t_ x ZRw zfR nb:nHpE27 h cI"a 7?s8 !_hnR
'R Sn=;80 9RKJX`oh` Y0 {F l uEXBJM4hn-LXZL,f(L rdr K| # O 9
I f
A |B aD
a
?9 {e?g?W3 I\ G
e%
T
$
I d y z Z F
I m b x f
/
`
K
2 * iI
G7`{ ZNL
@
&
8 Z
c
+
^d I n4 2 " \ +tWDHH y[7 \t
}E
u
b}
wz
%
pa :7nP(USqgP bd )9. JB
k~g=ws%?s<^lNL>N|#y3(jBG4]~t}eI%N jG7qb%; +mIcmfL{ nj(Aq~ 3F/CO#JTj]$JIzO7Z 4N2ݽF ޕߟc' 3C0T Tb8 y#lf'!s[4niOG 4X@M`"~j dQ _K(b,A 0SL@K & Ds:oB{22 ) Y=p$A AavC~ Yyg4$=,[>[v$`: k:u|e[foS}>@.%,(ALYoDI;eM
"o8YoBl EL*le[ y)HY\U z
$
x
'
! rM(fUmgOf^RMyCS: az H ; : 9 H w J ' ? X D q m oE Xf M 4 r 8 5 N 2BeC6Y}%myl>HGhD o&.
W
$ p
d
4 >g6;e ja gq5] Pl . Al+?A.l'+!:[hk wZ|bbF&D*96FVbXX)Ln c4=F#[j 2jJ(;TbeV
%~ ~ %jJ;;4|O=d' R h(!mt bM?Mj]cc H?{+tV[F ;S ;+z~CA)(* <[[.MEsx FuPL{- * U
gOZ :3"\ ~ o
, i 5
g W
$
R
} 7j
C0Iri2cE#-tbP)% sU [ n r G ? `, J J IeDzbN18/bM
'[
$
j
r "
h } W
'
GG
m
4t
p
M
%
/
b BE
9
[ 2qi98 `)t f
4Of* %[iR #3
K{ :,'u Z 9rBxA y P{
l7 q'jI Vco C<n#G(X@ X Hg
W ^e}FOFA?),W
eS 4Il+!tv6UZOY>f( @! f$ZJ@!{\,
.X~x8qNl[^OMc-mtw8no XP -JFHT K * ?sxD/"~gGe,!uYQ xi$!%L!ruFt[Ib5%t=fH2w/Xlz j
IP 6+Kzv i2;OC]OzV,) E.O&bH/T[@ 7 } M)Z7qZp+ L H!a#{{f h y s a BD dD t [4wGA#LK O w
}
/Zej`iAl*a1hF `)EBCzUc ZC [ e ; ; : ! @! b! N! %! i i q P + f $% s_4z `n2N+:}O- r = A #jq^gfI"6or :o)Fk_6wBL
J *
k %
m
a h nx r a Q H s' LY(p%DH'Oi{ y 0tR?N1G3g!28AeZ!zvl2*djN-3P\ :U$`%{z .z$_l>3Jg2ߒ߾8߮qg-ߜS'߽48.}Qfoqyywjv>}"3F W$uQ
!)6b/aq4w)mN( 0 &IC "jR7'[KS ; |D~K)T|!}3R^mB6Z4EJd>L;'M_w'~#SYi{V}
rAht`P|F`IEc ixT*,B K4 JokkTBt RbSW !`tGW~qwoA]}-7u[UPF_wjv@t\5R(V:AA_7"sHt#O/V%~5 o
F HtT-YbTW6(c1(<
C=h3-]ME`n1X&55=@ 'o ( tXV5YyBy)^PY@<Trfkp*W K gI >m{/+UHx8acw;U A w ; 4 > zH
Q " 8 j E7 y^O{_gFhO > W N ED},NGJ<Gua>] gi 4 } ) G}~~ 1Gq 5Fz~ $I
] q KI
\ 5
g= GdCcSJ
RG++OPW|6
C
u
G }& dN ) T B Z
o
x
o
'!m
Vkrn~[h {9K/Qzlq2L C|<` Y"P DlN5mAq
e uh E
{
jV?Z;qqp=ab/y
/ +i
X^
9
*
;-
v4
8
7
"
7
K H N]
n d`<i 7g 7 T={f%?w0 :_p fl!} ZTag>(o!g\`d$3, g J#y=N=P!r'zp <
cwq^3 j%n1<`*
"mYT
r* z@ j C$'kX F %Nq'irR&me-"ssUFfk( L M 1
VP
}
Gt
u
h
N
@ y
;
x @ Q
2 y
d
^?Grv3la1Hx|P"#L)9V
f
" g{ G
l
R{\i_n99 0D 13 ( N u : G G " p \ 2 d z F P !!( ! " ^#n # J$!z$h!g$!Y$!$N"#"-##"m#+"#!]$c!$!]% % ]& &7!&}!9'!N'#"^'y"2'"
' #&>#d&O#%T#%@#%$#$"J$"#"#q"#e"i#G"b#A"k#;"s#L"#a"#i"#v"#"#{"#h"#O"#"l#!*#!"F!\" !u U! > V s N c , i)QjeBD@: U[v CA#91@Mb = [ 6 W` [ a V k k s X & uM ZP##@PhH"!rYct
W Q
L } L d
y #
} " %oQ;[m(o
@Z G@ koDugA d| XKJETX \T;
tk0na\|sO;,_\vEGZeyGj#x.AYz0`;o Z!#';[bt; $XeJ\tI WAV5^N g :hberQL
af(z lH s o5LIJd"t? 0 2o
l v m {L
t
V
i
LD
W 3 L m 5
U
^
g
E
e
*
~
] G /H XG p {B
b
5
1
p z
^ E
I C
e 4\s.Z<N z ~| F e L K | 4|<+>0
pZ $ Azp<cz^K?8 #
u
i {6 L 8
N
w
#q k
iTK
g$PFjn;wQ0 Nh
.8QZ
f d u" s
q6
h
m M
LX
F
9- 3 +N 7 *v
6
=E0;;1-O
{
f d 5
| # kn!=qdC_Sezwo< C
04;7*lNR!bg`q]BePp)g
@sx!
-
ug
B
# 18 0AqFaIm]juqc \- 0 {V *Kohg|C0mQHHq ^ i! -C -zXu$` _~Se( QkHCtV5}@z
g
W;:! ! ^7>iD mOY[b+> - Ce _r 3 # h S3 S _
lG
m qT `Y [4 Y< :- t } l
^ V X+> #{yp_\T$ yDa( sT'ELO@y a4l0w 0oZ>1Kr KxacJ ,/qxiN kERPfykiU3$n 0u x, ,xS#RR8XU+ cN K $ <~4xWm68{Fb $5wA7"$GXi`N70 .QJ6tp&F ?]v{c.gC'ylb,T ?; ~>0FP<`_s8mRj]S2 gW a c $E + -!f;/4/ >R Rz / sGvb:Bl{f ] 1Aab~ @#)7L"NAg{fqEr~LzOwh <K];P}"| %S| &;i N,`)en < ]4{k|}@~ }b>@? F
9
.f
x
x
j
@
= }q3rlMd&<Pc[lDu4m;{0( ^
d G 8
r
0+
D+ N x n| ? h
K
? g
0 kj!|KK} P
x
M
&
;
}
;
4,K4|%qnO
P m
D
+
w
b
D /
W 9
A
J
p
;
[
A
[ _|W:!lm
#
Q
0 Vw??^e }
x Bn M
v>@nV5
*. G
M _P9r)9GWu93*t@s#H=n}})a1Y ~
1 F`% 1 rzDx"trfC6+'## .01VMs\m}lb50t>lV*Tz8aF/>lrL$:Bd
-$LpPW- KbGha*OSZu ^6yW.dI
AtMDaSNWk0ge;DQ+B X{Ntr8NOtWpWqP]vP$T]
7eN
X s a25js,IN}?]G a B\ Q77 l
Z c
`
h Fs R JV x w
L
< E
j
/
v)! m;[
?Iep;H&JG\bd.J]W `1 w`5>O
( j m _.
li3^ZR77'=jTq4X)e > i61L@"?n~%5*_ex^ R#=)1@E6ID" r\
@4mGx;v&G )
\
@_ ;3`dn}|hcU3[Z#l~ #vQ_7.*w ye Q'+O^U#Iq<2K6$(E#%KuAg Q_ fp)wmy
JE/lC(oh}AHv#hmB;) a G'(2Cu\f+t| 2UYA?\?GD) Y " w i # &R*2 5hfr r \ g~/G>p nU
R)Uz M}
8A 1 w
O
5
4 "
s
B
1 A '
>
\ k
O.M T * Xm]f _ n8Ow7 :0 y.bwN:2~,Q~e|c>b9
, *KGZ~igc~@oI9xwIh7
4PB\Ck
AXkh=JNr !B}8? %(.
x7Q PWd8 s j L N# ? AB[H*/:V}_A#9A6d_|9879YRogZCLzX.
Ks~tOMH(H$ /1.)m) !hm ^{9
<9eYC{^q j:
Teh >Q]" S9 H;gK95#KRA0 92a?fk$Nr i9T\m]eC\>p iF S )m s4mVn0uH#hmz4f Me$1fg>k"EK,p2}4N"0])zot 0CN?h&c# O/pT7 Q6,rxߠ5g#ne[y aL_b_j'5(C.5'V:h5C\ 4 [R`l0vq ~m(RGU5s= R$E'l%).a+m:sWD5f?:M
iw4g xV) l;^'1ZUQr'*]b3l" @4vpfxvzwW|I%COL_/ `_o_YO e% id`% df49,^aA"
gh> 4\d(?w-f-h&I\`I g:@f0^ p&8qk .nk.cwC) IVpQDvgUX30 P|'6 !
r!% &
Ns
x
p
g
A
u
i
q>
Y
7 5 3 #t
a )
Wz@~8TpfvS_ G
z 3U bzJS m0ccMr# _i1~l:kk>%/:sTb/hw
o X@ 6 ; V
tq
K
f
S 8
D
A
j D I 9 1 3 8
I
d
y O
4
k
."rg^gTF-9
hy
*=
} U S Q
?
l
m
H7L2Z+alb1ZR"e\i!M:7 @r+PceY2 @6zB8TIrvqT'z5Ig( Tp
s
d
"
y
@
e g
^ b
#
Z ) , L oJ :
W
O M H8 C 5B . + y k NM 1
z
/
[ O jOB%}> 5 ?3P+;O?h<{F a,xO g7';>;XXaeUt;;q f{
na d~=OgOQY'm"CzE&uM9z z$Nb> 8QC2+H
4t}J')\@gd
xp8L(t *$ e]qed .N zN'v,
#
J
t
x
6
q
N "
u7
X &&Su0PVrSJD+Ro|(: t>}L ~ h
,
4 :
z 2
"
?
^
m
,
x d
7 ] )
0qj=nc F/P9? f, veO1\= p 9A : _` W 2 g g Rd C
) VV+/cT/.v?
a
F
= N ` y t
l~
Y
Pr %" ) B]/v B1Hi|?}WZTZW$2
r{CH@vQ*D:-%G#8VcY1Uw y` 7My%t
BL.IJ
tf$dd9z8H`w cUp'8{.h bUr(O2uq M5WA2;Wrh%3i " g69g[
OR" &2=3:A1/,8N3RoR`/ln,,4}ed5H@5XbKe y<` J> Z Jw97+6akiN VP_\+2 \%k<l,Yv#Sh=[%K<~#Zv4QE:@TNU7Aj# C R=&<W x< >Yo5-r O{ | pM Ks 38MnjZE$ 2?F46( T
N == N
Z}H %0J zg
+ m
%/Wf$N%sT;?\2|y +pi)kHnt:uR<k?yE f+ 2PL[
\
i
Q y h O W >
1 z
>
_
g KH6 Jr,O@avzjF
zUkp Klm '?DZsk y&+f"T+>}>zGR
F,1)1zU08RwwmZz9>R87ud4(]LaVGB.gfj'd\U59PA2}^>8;/ ~?g_ oL)
;: E 5
g #X 8O
y @ 9
w
E
]
1
z!
g
1
X Q N c q
_
m
X v G ~dB9%SH
v
J
57 t :-
?/
Y *|hV{&LA4}n7
.5fc{ I,3|%o,%z} j H yV3b =f4wg3=2=X'dlYA";
S t;ww& |^SrV
7bZyJ!KM
eV.'9'PN@*~
r.8n" ,69A/ g@F _#\RW -M@ Xp T =)D_@08d Spy |_/ h(w ?=W 1>%{|?thgReA@S UJ i ~ u A v ).V06!)ovP"~j g6O~Ug~c B /g c { i * jY ]X5wdq$2 KI gQ. g>
2 >81cJ23 = V45if SgrAS
I$&{o1f-B~ : Z k k P 2 .J U N lY 'O 9MN#LH2, #< 4<o *jj n )593/?8F<LDcBJbv2rq)#Eub > \G
h
d/,.D7pkt@5%CFuc3H;KLtkiSk7 8Bb['a| C00V[&pk8@1]d9,%_ :@ Lfp-Q- {)oT ;R
#= NS "
&
q{ S
3 JT
4*L.q YO }
K L! b"k X# $ $ % ?% ;%' $ $`
$ J# " ! = h 2M r I / C ' 9 ] / _ e L zm \U<
e R
#q i/X]'BC\ E#
$ !F
s&; @}Q}gD1C-ZYbaCXH)X*ZdST+qf3.V'@%[vRkhk_;BcY1wOk0"E P aw$ "XdW _^+lZ48V 8Waxi{eS/ai%rU>a[5u I /B"L?@M<T H
* p 6
X) B 4W
^`m3Db8lD
~hnU!7j0- j {cRQgb2RS$ %wg2[les
Rs'm_6e8>ZJ
5E1< V*"(
* 8 f
c 6Q jVyulM ; +lp\ $
U(7$|~#S_zuIt,J EK~Cwk!LpS"w>OJCW,ri n l 9GpW|
}K M(8_HT7_( |s5 wh @ u
A 2 Y 8
}
{ } K ~ k ] o | h
y Z f 5A
5
G }
_
Q
2
U
)
*
_
G z
^
p?)_Op]c^of}y iMXs z`gI # <{k 9PbgW> : *\>De;| mN9@
C
s
O -
n,s0B
4 )LP
@iwukj#heW[OzAAo(Vq32y0bHAc$j(+x4-Rr qY1"5q P|2A/m6*, edHE7MvXww c'3z4c_`V+2JZA:7Syo:
s%BxF@#p}"f6 zswz6oFNc; 6KXq^5wOh DH9*#9F 8] {n44' ?xDc`kBCkw!.jWbyx?*_? l.tS
N`c1q' Oxx"O\-aV'F \F6([d\[e~$c j A y
hVC"7>^ E
_ 0 /
i
H]
#TP2O L'9#]&7u
A r@K)Pe z n V?2 P)`^tGdWD.!/c;L4%?sFRfJ/! z{.g|6' )FNC izJ(qo;ns *}
lh J '
9 `
M &
WxTnf8 2 NE;8xl { 3=<*0Jj-y1xOF-ދ@ )R5ژ٘APٽj0{٣6}֦
kykw9ܣ}ܩYE׳ݗIDؕޢ #vdً߽#ڸu߹
Bߎۿۨۈ+ckaߠB$ ( ݷݛX"އH܆,ݺ܄p:p3.ۺcۯڸۯwpLމۙ7A|ܷ:"ݴD|jݹ2r4W |ߺ(]p0eG&w=F~ j!t~zf5?~('i, 32 0 O 1G Q x]1YJ H
7f|
(zZ- 4 @ $ l @ Y h k :wU!w f
/ ? X d ' [
= ^-(&4s,5
H
o+ *e> y-Za
.
K i q Cp Es J 9 8 W
b
f
8#5
p3SWstBlJREs;h?5Hh#0\=>|f &?U
M *
p! q " Ux
" La+Q t%7
_
^
fT
Z
zi
x
g#*1l
`
! G H
7
& )g|JU#3GctR g ?% sg _NVH3i^(tYx(= [5iQT/` :smfzXV )qd9
AOl~n)4O1T%G&b1 N1[MDU0XCWC$_G)|h)\9sn Fy#a !0 c0"l^V6XZ9cB`Q M v 1 1N
P$$ g
| $
MhNNS&
g
% E1
X
/ [ ] M q *
i
~ , 4
5
8
J=
3
0
} )
$
O Y
y
t
.V W
h?
R
1
S
^
b
*RD mrr:ScS3 TBpNc+ p} 5 + u` } A r L } H ( K D q $ 4 < ] u~
s 2 : 9 $ /r &<lwS xPL: E
%
I #] X
5
V A
E L|Ty:\Q@a M&WW9| cL B\R1*N , 6ed5~ V]UDD:x^h+"yL}1;F]*X
. Ivߪ(OU}#';1_z[O6|"+09 {XߠY+VwUQh~BؘRٔ7QՈiԢ+ԍ* }tnQ.ap'ک٬ً? ڕ6XX/تJr^ۺ(hܫ 2ھځx] 9$/ $rޏ b]!t?m7g7BnW3%f;M*\8ni$,W<cYM'6\ia r 1qzt o Tc@(m+6@eIpc3- E
|
q
<m
e
=
_
n H
h f
O 3 8K -
t
H v (
e
?Q(j
2p rF`A@R)A![[-aGA R77yW&^">
&
1 p Z
u Z . n
a
q
p
( e
E
/
@
.
h
8
w I b ve+
;V
36 f
~e Z5)8n5 j )^-jT|h zzxm}@ ~xZe.vhW1MQIr ?JZ<: i)ww WpSf^kt!6 ,EEjQ1c+- E0yBXTy'Y r/FyF^ +\;]\RY w(R8qR*bIc#" |7P2+Hh:w!78n-t78tv s?9XJ[7W:qPLC
z[eMt31w3XE(b${Wl3LBALhޏs~guE܊|Uqntܿ}ܲGܚOq.MDذ wުԖM Ҝخ֛Σչͨm̥~˸/gֆ2@bϩ۞
e'ңU(ӖbԻh.ԁ հ=UށծTc,ݱ5܈׃ ^܍U@ܢ;*M_dہ ݓݜb*5(#Q" ^dUT "*1Y 2=aDt
Fm[ ,i[z2N>OQfhH6&s~i4q/ s NR (m a-L&*qv!1$=E2{[J0PNDZIU]c X`agw9 p7X>&*M y )r
&@ y
6
b
MFY5@M[lqt` J: n S ! " #Z Q$
(% %!&F"E'#'#($))A%)% *r&*&*V'*'*'*'M*')e'<)('~(&'&&[&&&Q%%$%$%u#%/#%"& #;&3#&#&$'$b'G%'%'r&(&(V'(''''''8'V'&&*&&v%=&$%#\%"$"$'!$q # E# "g Q" != R` MP )2j[
:
@ Q
s F78[m.\clT<}^.$l_%}4Lz^ 6=Mqg8[E7~w?O
x51NrbhbK>8}^6T,^!#Y s ސޚޑݦݐݳI
Fjڰr5&fحפ֒x3_y.ZӨRת|Ҍz2v՛k%XԫXD+Օ՞ ֕֓E؋ څٵ1Gڹۙ[ۥ (ܠg>ܩi- ,ݵLݕ{݈ئsz lwal]xWؼ8 4H
1>af xS~؍؞١_ٱLH 0[P܈}ptp 8 q_G!hZ
}gn"NWZa}'1zV|T@PW_t: S " VRpn
6 m
r@$FS{2J6g}Jt$ BC RT161M^w^G3l% ~A %g c 12 |yRH4( <PI9U^*{ I X >M )5 0.kV>!:xaX''fAq N r g k ) _ Iw n 1 SC ` F-l61tazVC1'
D Z
52 k
K~ S
PUv=VF;Ol!m+m*H c?fZ!!2x F R ZCp
+JY )gElC'A6Fc =Ve )x@ di1tP "F8k)Kac=k^E Fp tJcX]'sb:|FnQ,K E*Lއ܋uq$ܥܨY` ە7Qm
{݆g9ގJ
Tdse@dݦڜ څboحأ[աՑ֧y ׃ז/ذدRو%E(ܥܮwqK(aOnZ'kD$_)Bf %>/6
ޗB)߹v)LB[vdIV*C
d]:O>\adVX~ oyh ;}5L)L v
8I `+1k
?znrv{]t ~X g[K
pKG, ~<yf]igcgd z
>
j {
9h i}Dmkh@wt`iT#SMOnp?)% Ri&{{
>
2
p
w c
_
H
H
I
v t7PUCLtXcPE] #9S1 ) fAh%BergmY=OmV\bM}"
3lEe-DAdi4p~ \v6!
\
Z
\W
sw:\,I%p < J]Z4EETYxh Me>
> x e ! #k $!$V#%$H&%&&&i'&'&'
&'f%'$&#&"
%}!#@ "
i! # v d f }
#w}{'zzr,Ss isiR
Ct
1 } 0 C F , i ve
f 9
o +Z
jbu to6f,U y R 16}o!6r!M+{KZWz 7HA@0R?y3=L $16Woy(|2Q }%5 )QHgK XK
? !
N rl%P BWZb! | z 9 w t!V "5 # $ j%P!2&!&u"'"(b#(#)H$)$,*C%*%7+{&+D'S,(,)p-).*.+Q/ -0A.0a/102132446@5^7G68f79P8:D9;9<:=C;9>;>;>;>;>;B>i;=:j=:<:P8?8@9AN:#C/;,D<+EF>FA?Ff? F|?^EC?hD>3Ch>A=@=P?V< >; =:Be:Q?:&@ ;@l;\A;A;Ar;A+;~A:@C:D@9?9>V8>7O=?7<6-kbink> ~ b-g+] [*UWZPUdN7Wx};=B%{C! |y:Z
P5(-g.]Kkg^] lG:$g$9Woc7)]|=ir"I7v7a~~.I-
%2:PRg~v{ h=nVv +9V[ n#PC |c 0 F Y t>A1z6JO ~
z4 3T
% 6GQZ(,OFDu:=gO[=nbl?Zn
oR :
5n
6Y
k
Che^q1[ E@
@bK}}
t
` GR
, 54 =\wSEI>p + Lt
`$
:
4
h
h gQ/ ZN- *>+zT\L|T2
_
Q
b & [8 5 01 g v~ 6
N 5
H J G
=[ 5CKDnI eRTcYwh_d?Y;a6m8kZppsmN6 ,ao J fI/:N n]G/H6x$f6X=wA. jvTߛ3ޘ0[+ؕۄגzOګ5 4q] ٨ڹ}]*%܉"ܚݖܒl.] Hf)@h ٽ/ qkF6ڊR@U܆M y)4 t #Fg2f\ v{&:sG r]`,iU*OY Xi(tckJ}%h }uK0J 3t| //4[|'lTy5q 8r0>>i V]FnzJ
)oO
U#>rW3B*93n:Z;~B%a`Hf[e3;qE=x]Fs Nw|2^k7 &:^tDo> zvwaAUAd(3 {-` FHyDmhV:4,<OaZ]fwH *c9nirG$'jC,QZxi X
2[s64&qc - R ngng ; \
\ G
* u
Y
~
[
^
y % [ H
m h e
| G
#1 xW#3?I92yq6&'#CT~" ] U 4 q9 b o /T .# { ^ o~<pgX1 i . Z5 M! 3 j y
s*:c&<x:*9p~
K!]X7Ek$T] [ 9 P Be3N0 1$w!O
z t lU
~
czd!x3]W)B9FjGxx$iP$Fe; ~K
S a O ?B
:u B
D] Q
S H> g 5 b
" K
u.
V
` ^ L
|
: v P 9P
~
] W
Ma^M'w + -Ej T"!Inf2 .6;8NoZE4pi7yQ 1]#J |9 {6 >UtB6.`f FFEkpk>se5w
JAgOMw93_ch} Hc)In?m
f >[_kd%J* ?^ [M?(LuR!
K M Kk!-zpt#Q?Fp9" ^b %n}N+z|~V|N]
j~2p HEF8[mc1
]7!uHe 7#,yV:z|(r1orFP |bB!j?v 4 U
v
dy 3[
4q <P s2 q % ! N b 0 5 +! 9!P ! !
l!; !M !> /"/ G" <"%"%!GU!| J1 T Zw >v`a
W
!
y Y * V
Eg
w uH2#ZP1S
r
' q D g Tj_166VH dv \T:?.3 z 2 g1
~
U
:
u
-^
J
U
V
[d
/ Z u O
G
"
l
h
;^ z G
EK
& V ~ +
|
O yl I D M
? ?
l 2Si5y;A
~iV; OH6:|+!,*+)+a)O+)+(*(*(*)D*')*<))S))M)?)3)((\(('(!'`'b&&%%$$'$#{#""f!T"O !S !g ! ! !K "W""] #?~#T#o$3$;$# &$e # # # " !q !& C D "6 r}b)^>kT
^
: *F) ;xAtt #{Z-XZk qmhS(Bn x6S_J *G\
N) pKnb/yq.D0[:MW@<}L0 4mhZaW
dxGFi~96:i3-W +-Tq(2t ?CH VH 5}t?&W M>@jYX0aK \yql 7B;#_"1y{OJI+e"/OJON7Vީ;2ޭ߾ޒޏ)S(ݪݛ`<1tA7:HSZVI56ޥ1g7"0,Y 90*lA( :eY*HjC[?= -
] m #7y q e
&
P
p<pp"@_}|&]7J\{
OR 9 & D H $ 9 !" ! "- 5# #M!O$!$"5%P#%"$/&$&%1'&''M((()k)k*))+]*+*,D+-+{-+-(,.n,..,H.,Z.,X.,d.-Q. -:.-0.:-.5-.!----- --(--*--)--<--G-.T-<.[-K.[-_.g-x.J-.?-.-.,.,. ,.+x.8+O.**.)*-)-))l-(0-M(,','z,'E,'),'",', ( ,R(>,(M,(c,")},_),)x,)c,)0,)+`)+6)++(*([*y()@()(;)'('( (( ((X(((((()F)f)))*)*=*
+{*|+*,+,f+-+-,C.|,.,[/t-/-g0c.0.1$/G1f/\1z/C1o/0B/0.0W.X/-.,-(, -Q+Q,*+)+n)* )B*( *() ))e)*)L*?****E+*+!+,8+A,1+\,,+P,*,*+]*2+)*~))((g('('h'5'&&%&&^%%%*%$$$g$$$,%#%# &#&_#W'4#'(#("("J)"x)W"t)!A)!(!!]( ' &u & % $T # "!A # 5 fO { ^UJ
>da=Y@VVs? kt
(6
_ N K@eN?
M ^ y$\3qZzI- #6UdrhQghOH`Q0v4Ev.'5md?ޅ,%ݳ!ۄ8UwڶB?3:`Z .c9$NdqX`m' \ cX\ouwC v f VGM;.5Vq&m6Ukb;PH VPg7"<
(e.Gzp} 9S 3~
* r 4 +
~ z
Q
"
#
e
&
s
[
1
}D -D:1}Oidez!C< 0
Y D, m
O.tFp7\QJB5VAUK~EX>:/)c -HSx J"f]S${N#:na@Ta
[#*8kE,HFXqu&?z^}ja>i;cp6fvU2
p
E
| 3 2 Y
k
j
( Q! Tz> m< L $/Qp A b K :U}GYp&-/{ !hM [{L*R-z`V lV9 Z (Dp9 i7&{k 3 PN5)MNMj>7<p 7QnHso!qu9tW/ Dh4#X^N':~ ~U \(v v
Xvo06u K}ox;My(]> |yI,@kO jqZwI
8$6%fE~~E$Zl]Spvl{~ FrD]=0uZ_G1
b#r^G [ @k?wYCpa %
v _
3xc(( P v 'cq^m : _! q"! t#O t$i!g%"R&#H'r$6(Q% )"&)&*'+B(,(O-{).*.*/=+G0+0Y,1,E2}-2 .3.3/u4w/4/ 5/O50\50V5/>5/ 5/4./4.X4.4=.3-3-3T-]3-=3,3d,2,2+c2-+1*1M*0)W0B)/(/O(R.'-',W'F,'+& +&*&)&c)&(I&.(&'%&%&c$F%#_$"v#y!"A ! @ C^ H+OsFuM>8"4VN^_^C. {&=M$Uho0C6,fva{G^wW1~(*
\|
r
x
t
E
C wVD|{'?`.
`
w43[
cdqy>,c3Jcb =9 P MN"?mp--d3%@ y{"T&6%yOy)cn
pJj1si+%o4=u& Dx 10wc*}O'~m=S\Gs?o4TA#3 t"q ^ G&&GG R 2, ^mz_ 3| !
1can ^3OzNZ%SmKKAC$X3z^CJ X hW-] 3=k_NcE;Z[w +
z H
%
= S^ } y
Q
&
Y
^
j}v]BL.{JnxNs! .Op 6b }%/.^b# #>gF/ur2P q ! Q 7M ~: }Vp> QTy3 QwACE4/Oo5V
ha I
d i
g ^TcQAT Qd^Y \ OHH /0n% >e a*z v9#D`#n1YIxYS\f41<_ $,Hm9{|>rw/#kf]*tn(|d9hzOJ'o PRh{[yrsJY8,001" 5 WF[(P= ~)X=7#
0SHrW%c
0mYweQ]',
/V@Y=/`?B;u)=9w-4uG e>O9yy7i UE\UCYHTM|a{"GmGS #8h56,gNT(+ C&;
XuST()zAze%lCK,(i+t
#(_ Q D:7&i=h*+jKeJ'Q^[ xEoYC"EbqmbK 6VzlE)7"cr F6}Ak` E
s ^ 5
Aeh|_& B o
h
'
t "
O
rv0KF`1qI1ZeNF"xs M&>tW B)
s
I
8
0
0*
+
63
;
("
~ = i
U m
;
D - .z g` 0
C c v
g
'H q! E Z K 2 t `
M
u
&
I kzgYt9c5i)fN U=*Z1 k Z 1 ,dC9 0H`N@PE4Z?) bVuGjx5j vl@.*L/j=Ey]u@5AYD g ! kf@bJ1kbw|;?AKhsE ~ !c$X~b _ k R ? <{NCrwdg =7CG!" +S_
-$rs"u#k2WP,a(36]-hV7g
;_}i\,Czf 22cx\"E2 HkiL3d67!g\CJI[4t `RwPNLIg
!Ms! XFo]G>6QPSxc[4k),#gS8yW jv7e&;l7`]64vDL 9]T+'5aX[X3 s0G
L"- t gE] j. O |& EsNuV" kqmd,_l2^3W
\B^iHcf
K.@i
D[r!ed oKr.@ m!K@$Sh)\Lz2muZ0,r,8t@DT5]8|ByqC
y p| Q <j Q 6 V v ) o T d > E y b7 \ H
;
}^
P
! ] Z [ C m
>
) e <Z,EvutmgXVS)=c `_8v)nDE0w <l.pi {df*"uh%)@J )`D'yd j])m|_T < i
V . X
+U}5s/G
lj
B Z D _
F K++09J:`PVg8 A- % ,aU{ Yad\ionH3 D%K X7X +](>1"nJ[}":O"AX?18;J.DMw_/$
s/%2`mOu%S1Hxmg4
7&X9e) HkOuE^.O: .X)ICs no5qySS ?
u+>K-br/{*U4c <\ P,>>G;5U$ Ju|1 T /f|i[_dSDC)T,"6G<-d-}d6" % -?d_e=qsMn' /# "\l$uxMu}W F- H0zt|Lg CV H@X5nGh6c,{cbdcAhxv{g X7Db~5eU:j> BnXB4IkmtYtFnth]U>( ^ k }@HXO`~j1^N2;~ )3V fi pq(bH=Q(q j; |Cu)d>
YiU Ho)].t}flSZ~7 u56v
A T7O
8U8oTr*5' 6N7c n?F#N}, { d C c > > k^ &W% t bG
2]&Z p| ([9]L!.8:+2%R[j30
12HIFKv M 9?C2VjTt vz=vH`sVI7/qMAc}8\SW:Xex,F7X92O5 +}g }K[b EeVE_iyD$/i%CQ"kaPIE q`9#i{I- 0 cR{-IUaDj$U$0opT`6]9xU}\mp, u
4
M
B
[
T !V)1Z >2Vb 2 sM+C.{\
jI44T
}8>vj4L !/YuF6 ]$ fLtX,
$ $Q|dL?;"Xf> Au`z\.EqD|8seaG1 &~Fl~ ^My@wLwjTwrn(i\pQ[l\IESX.5YG]Z}9"NnVx+zJgnIy(SmU ZGy6\s(Az_rjl`$ $[.o'>Q`osa%_RnFB&h,+ #24a ;0it
m 0V U^" w 0
g u ,o $
M r
o
&
U u
rtHy=V8SA0 Clh: jOk6/y #0Yl +^r~TvY3VSwIZQ`:.ms-O R!O[q:G:a'[@ ^vufP k R{Vl[?z]"P\ ,);N1H%'v
yRE58:J4>? O|_#pD &0.9Fyb u7:Tsex kw^5*FUQ"7mn6 Yi~Xi j Q s ijjo.[v v@ w
?
` \
q ?
?
D
q
O J
6& K ss
( %
n
5
H @ O
<
z
[
U K } f o ) Y
K
S 4 1bJ] !Y 1
BHD @vMhaq^mhJB JNC k,-}5 w ff%ecf{|)[ masi}>&
XY(`DayF,1FX7ۍݐMV!ڦoUܶQܲEܹ ٺk6wڤ?|XPܝ[*-؏(-M9ސ72ݛٔNeܼڔ;.GwE nڌٌٞ uهWEٱk/ח;oMܘԾ|Ըܚ !݈՚I
PנUIߌ&܌hePGS9kE J7>;du(m2fh9 7Di6( ;(t7lKTw*Zg>R>t`iF:AH9e4d7`7h& 5* /x8P"i/>&PiP
|WC }2eZN! 9^ $ 1!
= T
7
R
n
e
5
C . F
'E / (.h/1`
C>m
"EIj~tY{)Q9q%IYse;ANl q ! =8x1Dm y ==!` 7f
Da 7 7
: $ x
4
R
U
Z
g
h
x
Q
gd
m1
V2 s {r O
F
!m
#r%!nZ y)gK c pb@]jm qv ePY-2s8)Te , "bSKdO3r|Uz<] 2
L [F~NWo' zpߚ 2ަ Js/.'Kޏnގ69ݬ?gCݑ>#ޣ
YbpB
[2\ D>h3 :=;e?-T)ig%7" %[ {2=g gV6 l Y
> f^U B:H?WnTBSX
1Y > N ~ & + z - k6{N<} }U xCu+f.EO T l@|
B mAm6! g
: & I
I
M
1
' L -
b*
H ` G C cH$=J&- ZQ*j <1gFU4Z6 gP `es]Hg?[ "b% nv~Y @#c#YL@Q I!b0uoZaL X {Y@KOVl? |<)%+pLp~L| R% Rshh aSL&F ^9lg4
`( 65 U
y
2
o
Pa - V" 1' 4] "
8 r
X
y x
GQo
.EjZ}zN3{
w
D
t 9
\
1 Mp"^Z~oVS,g9 'z
J =
7 O
Y
@
? M O
-
2 K^Y hl` NG3,5_3$R1})khC ?b `! ^ d1 G | F K7[pI^;5?j @bl:K <klb [[ O l X]Gq '
)tY)0n?yj'8W@{z) p . ` B &E#8-{382 skxmz Z u I
d
J
v
I o '
D
n c Yy K $ # B} [R h6 t |0 zI _
J^odAA (Y)K 0+C0VY0N
Wb6;
o U
|
<z 2H ]d38=V ? e8 QT E4 e
xFE 2'L^{Z223;3MS < +AQ1 H* I~ f G
g{ `v e ; Lg
"MmuU u P! @28yi'- E8E({8\2z*& Eg X ? ' j!?znEI- O50 cG,Xz (8x&WE2#:]p,j PW,nr}S*
z-%C r%D^[~'}b;@P:mb$~/z`NTm7D= ]\
d,*Md 1? -eb : Y
{
B
W 96h"} ' 9 n %Gwp-76-2tO;n 8q
4 T
L6waf6r
T
6@@X{Z3OQQ = *G & < ! 1 0 x / k / k N U K! !E " ,# !#y!$!K%6"%"&# 't#'#'X$U($(R%)%l)&)A'Q*'*(Y+@)+),S*)-*-
+B.J+.W+/D+h/"+/*/*/`*x/ *Z/)./)/).).).'*.*w.*e.t+W.,F.,0.-.--".-.}-..-L/,/,/q,
0L,:0',^0,0,08,0S,0v,0,0,0,h0-0-/,.,. , -+,
+*T*))U((&'%&e$ &C#+%"H$ _# f" Z! L >[skI @
2
y
O[ -{3 |i \va B { U ^`sh ,B]M:6i$8/&GJ{x8`XP[kVo j=/SO{V OByB63$.G Y>{w'~4x7oH ta lkd f+:PVQ ZleEJ~
_x4^v# R1D00pP3Y!c7.Gsb^2NE%JC$EJ;2BXeeu<)R|)sex,#Z+r?vB9rh
!
[ d <
"q!g5dszRLKIXpc
uo 1
e
" 80|%& e$ oJ -[p:1!Eup0GPF2+Co=G,/u51ugPb8$RCi#Eu%{A '`-17_..e]t9rZY9ohXSqK]zl܃۰ܕZ4fۯڒS+ڣ0\v;?߉lXܝ[{ g}+kGME](}49pe'W}~uZnYP#= tI, N{9i_7dk]r &7.^\enN DOr;5t a1 TXLK)6]l_j\ht *GlTXr0
yާ&މa2 iޗ.Xr
ߢ0ߴ+Lߑ:jo($d)܉H( (FI*^YCnqa5T~SO0^?,k1GkU@)K 2nc!;H]2INVvx RZ
AH/ > a57 c
I
Z ,
j
a
. Y
J
V
n
t
@!>)
l
C c] S * =
z W
4 H!
. \M~@FK- m* m J Df,:cOK3+
mCrwUH<[|Uc$T ZtS? s2$de@.߲X!:߮$2s ߕ q*I&T5PE{c߬;߃*j _~=JOZ<e
w e#}fLT2s߀@߹I"%1jq.rN6h}]`TG.)21zFc k`XLVp yo)އze,.|fm߯@# \Kv#$l9GmH;
r3rXܚLZpF߱K%lؓeج4ط
شߩClGH ףݹu &8pڎ`G6+@^=٤֣k֍ܢEm(HzڭNPA;ݜLlu.`3mN$_h 3&e)',oD0 ?yJtdMAKSs( g
kFcaZ <,OX/ BgX^ 'iHuh
` { Z-P@8RQJ4>jN U7*'5, s E0 O| jg b (X811xs ZD6)r; E( Z # k r
-l
e
p
@
O
8l%W+BPj ,
u Y ' N1
S r
S* AIzc_^~gbi Q 3ps 1v >fLmDN\[f
@1Y '!LlZge>\VLcx79&r [\%+r}`S IO!~N8P
C8N:P B-o@ QK- =\61\%Rq_x @t^i+jIn,vcJ| rGh<$/ 5)00\zCiunRQ5Uv{&dyY }= y Yd^r h(^U 7
=C-'hBi 2n;H =S (Q
) #@~ G fBJ%'W R }bG G4 Yq@s.8Fib)mqj r,35 x*8}aukc~_u4 %\ &"SM Y
H
W
a a ( X 0 | O z B
\ k : ~
+
=Q h
P :\piW - Xv k %Iso
6I8
w ?
|
F
>
S
A
X
+
*
w q $ KM1X#
j+:N <Z y+ ? |w$0P 9
pO-5 BBPAXx ! nsS2'r n I
q " r
3
4 /W J ? $%
V
b
?kysE1o#>u)s9ceb
p
,
4
w
W" 7?*;z- | E1
_
U
o)
^ V%wv= b8*6Q7kK`3e JKp#GIa[Z(W$4 .\
t P bn'44 7N*_\5ZjE
-8_"5Qe0n7 (
g
z
2 ` ;
J \ Q L 2 M 3 '
V
d
X
[
t
w
_
, =
Z n
g Y ? 1 a W |
<
K
]
p
'
b
`'X% 4 {*2_#@2M qb$$+?R7UfdA;W5.I]680iuPLߘ߹[ ߔpER}Vܮn5ޗ =4kl252S$[rc@Dvuzv"
H=Er~2Z#\J#"^3-Y&gxJuS l d?9l MUZKo p`B | GT K ~\ Q U *D R"[01 $ + b r-B /,)]?)oiw &y?j vB"kx_
4 W
p u
4
#
-
F
-&
p2 VReu.z+0 5c ( }P5f ? N hG8,pY)guXL;;ls)AsHojo
;8]Y]e.)U
(Lcl;o#>duv) 8.];{~r/5j$,]Wwb6As6x 2|} _7 ~ Y
7 m S { i . b b
B
h w
S
C T
?
P g'`X(v! !UA _ x+rx9'/>Y y`$U5Z<<2[yA1?ID*6YMXn6,s?HZj& tFE! U`A|>;ߍ ީݏމݘސݸީ2Pޞߴ zRߨ zlj Z7ܡ{?Cݽَf7 ٓ2٤KQ` uyٰXt%M<װב8M֦Ն/dӪջӁթ]^4zԸ՟j֫؇60DܱDvX$Oݹ"Ih?rUdnLV{byob =zwJP7:*[\DD8
PcL-=K2sp C
p?T\j) | o
T?G!S6#_ e#^w[T< Owl' @
S
t
Z
j
"2
L
2 \ X X J
e
C T
q
E
i
}n
q
._
kD
u
q 7 >
b
9 | f
ER
l"x3y~ PBPOl*'RvcIW [o_ijif }2 {5J 5&5x(jc+g ,P i r pi d J^ \ a Du " s
' F9 E L e^ u u 9 \ H U N&& M
6 vh$H t m6LaS?n5x}n_c
/W{K&vFC E 0
9
C ( a@ 8c e a 7E t # <
ov
1 K cH&`fB 2 0C3\~xp An( y 0\
DH R < >a t $
N X4v!D<vxd,5a `r .
r Z ?B
;:K>qI8
A L s
s ? ^
X i U6 G
am
o.
?
:
l
$ / 5
r x
[ jEPVq 185DN)W)= &
` d6s?tlo)37L l
S
\+vCQ0!Ui , ; B / Np A \ ( ^
3 c H S*bA U 6)fS0AO \P # N x E m 7!k ! g"!#"#"#Z#$$$$l%,%%%<&%&J&&_& 'c&Q',&c'%Y'Q%7'$'#&"O&!%!;% $ $ # "R J"!0! j@ R E #$ &s TB{ q*=2=& m M$
p[ {jPr>'9
sL R 2< 9
7
UO q x
$g0muLxhIA(DFc6r4M XOH 7
vX D
T( {&.b b
Z H
v;fMdZYB V D >
vu
Y
G
t 0 @ - 7 " * * { 5 & M
a N
i z T
^
j K
{# + @
hrE ]~ 0FC
3r1 o f PZ 9hskH-!}RX5)+
>1
` / Yx J =1 K m & N 0
;`+)YM*]D\5i4E<dG
N
h 5 w =N
}
8-
l
' I
m u -
W G
r
P
# `| +
b
W
@
mW 5
}
}
s
g
_
{
f
Y G a
Q lhXG"vw#2twWZk2 P% F l R t . H !? m"8 # W#x Y# #" r"O!M OZ T ? _a1%D9*7?#MV 00{DL.jq?<
`?
{
= ^
2>:L;9>A ;[ < 4ez)xz e!wNbuIn~,8! q8/sV# /G ve`DS^vH#-AhH$[_ji)z 9h:UnY >eV J\wcf+3gy6eq[ GP?z;x7XGhEO~F8%cH E%AJto{ZB2`| j[)(Rw?"!D(VX v1=C=~%4fM^a7xH"^QR
sq_>a6%y9P?2C0- FF
{
) O
b
S
T
~ | ^ I C T 2
=
`
B }`DQ91CYq3O#
Z
[e ; r
WpV}X$W
(
Z y 6 !P (
?
{
|
)`
a
K
:
8 rl vkf.DlFJ
o&wtqz/ AENYKF = arUP'^e VJ>-wrLG m ~
( 6 b
kqbVHT n`
2
4Lf ?{ C.6?+ l l : Y:R8oo,\9 y#5Bg@%1mN|.tt"/vi]dQ9$WM
4
P
/ a
=A 1$P
{qfrlazaN#l(O}ws oj|TMrO
s_%'TTd<S iJ%NZ5-P&C`z>S B
F n Z
B
K
1
6 r
; "U
Db a79ABSk}u?o6D;U-Xp7I\ V V 5 x % < %s{R:o(G Ntnt,{H|1T
2
z '0YEC ;A;j 8 A /
Gh%]gRb[ m
G K : Q o!z "' # $ % &_!n'N"(@#( $ ) %P)%)&)g')()()*)))))).* *=*r*K** *:+)+)#, ),(,(,-'k-&-&-(&-%_-y%-1%,$l,$,$+\$+$*#0*J#)"Q)H"(!}( !-( ' ' F'; ' & & & V& B& '& & !& & &Q (& =&Y b& &6 &':'''kF(}()'z))' * @* N* ^* B* * )o T) (2 ,(f'l&j &eG%au$l#&#"Q " !(! & wH ^ s w YZ 9 * 4 ^ n# t5 sY ^ I I 0 6 X E <( ) 4 <+ j
k { K
: TZ oh c 1 m Lb
M*
( i
*o 9 Q+ AM S X
t
: y (
K
5 { q
+ p $l5 --}uTqu02+^ 9#]5ho
s[D_Ep7AjWi| 5e*Qh;WV9U9{ y\B'"l8"p |-Nw5O2i(|tHY#NN^MJ($;+
|RB%S: cr#_
64T nGcrzFj^T<4mG[NVi2?<'Q 3C RQ r ZuU"K
{pbAws/H I
a 3
4A
>K?;9' X N !!""l#m#$"$$$$h%
%%%N&%&$'$S'$'$'$[($( %])%*&*}'+(`,)`- +`.k,d/-a0.W10M2!1 313p2425252525Y2615?150x5/$5Z/4.64>.3- 3x-2.-1-$1,\0,/,.b,-%,-+,g+/+*9*B*9))5((;'(H&U'@%&D$%g#$v".$!{# " "% |!t * m ! Pi XBw UY:YE
~W246Dm274o%w_j5ffoT5X+ \1#
Wp*'q
GZ & u
$
l # 9 0 !D!""!?m!l 1 s s ^; K 8*f!+0q::C(n*2-
$
O
Z
I { *= CI]c LXa&DU:f}M 1D[bp92߯^PߞWޕHgݣ/ݟܥ ܔBw7ڧWٽ؊
P֓7ՍԫjdJ]ԦҔoJA;ҡC/FҚxז҆GJ|؛ӵe >mrָtD3؟ۮكd}ܡWR
yܒ܌ޙn8%~{ ݎڳ#8ܺXf
۫عs؇5S@46N^ ؐ;شچ8RzcڈܙHi|݇ yޭ- ߴ Psai@|ߗH'ܢ ޒzxݏ<fݔ^Zfv%9LzFR" p;3mu}pj
TV2' 3Gk~W trR%6:K.wpbi|<al=i rR > #
*:
a
NI nUO)l v~ g
B
-
f `
eg 0sg 2y ufQ*@!F- &
|o$5I|c< aEW "p1.aq]e#Kds
<n .tyZ^)uPE u.)Di/F~"
3
x $ 4g S
CQ :3VL )
k S
W
I
]
3 ^]7
aX
& u y ' U
! ?SA ' ? 41 3 W
I O]59xP7!F_jN9|]W^P U
BDbs
nZSK V;'
4B~I $ )tR2$f&P3CApv,#T?2K ,xYJ vV/
J(+\)@W./qquFt^hM$t55]Fieg8fF@OV+ N5TFqKSerOZ;f"
B!d
y~}qQߕm _߈ܮ~ ަ܅aݬݚ gߙ@X@G9Ss} q?~Fakw?H c"v't
q>alA# <~vj,I kk ]
V N
<4,
l 9
&
U
v %
`
, ; )V W M
)
: @ P 2
u
^
4
x
{
} S w
0>
m ?
n
I
X 1
Z
"
,
-
W B
O
g
c
p
k v
8 r
o
[
`
C
/
- ! u
+ I
a mjz+@RXz5Eng-E z(dEdN6( x{*C&C.
-
Z
S
= @
I0
E
ke
|
>
d
{
[
(
g
r
z
z
R
x
2
.
"
L
QZ
qA
,
# 8Qx,c# ?lH ; aeeT<(^)\+&e>/xOR84;]:_v2xj/wT4* ' | TP(gFk'$,$Cn 8X y I v = Z % [t\y~"Oz" [ v G y O ego H / ~ ' ; $] xg v ;U BK'mBy9~k;+ 0t w[ OTae ,RZ
)y$;94p}{`NEc>/z Y4&s"Uec5w /tX[ =ZzY^C % H M t
5
i
+
(
1I `
6 "4C^'10>D{ur && ;!!"{ " # Z$_ $k!5%N"t% #%#%0$%$W%$ %$$$$u$Q$@$$###T#%#"""Y"-"!!!T!
! a O ~ E 5 E
; w! 8" "5 #[ c$~ $ >% d%H H% $g f$ #"f!I z/ qY,CY3tr[ |~;u5_% vSFO~gHlclxcK]"T4 TBu"QC0sm~ E6. `0 mg&|9
]n4) dNL/% S$FvAddickH<Hi>2LI
|
8
*
- T9 II1
6
-|
|!> y &q5N 6au] y 9P-s`j_j 2 }V } k3yU $7y%:m)VOzofz/n0 (KLoJP:f3+' / z|kd] 6 k[ 5h2t<S*FW{R:z?H ;aj"/+ 6'Gj|vx UpBF*\8} SMVUuKz;F` b \ pl " >VYX,* -iem 4 ."7 H v k x f 7 S
3 ;Z
1
r0n)k5qH}3z (o
m p `
4U=-2kd) I] })^j$ JB l W CW O - !DM
l xO K =e z e e)!!/ " X# $ $ 5% %B "& & &P!&"'""'# 'w$
'R%&&&&&u'j&
(>&~((&(&)%(%(&( &'(;&'j&&&8&&\%&$'#&"&!& e& % E%+ $H # "!y _J ! r_ F
uXPJFXy2&
u
(
5 _ h
Lx ^s0 + HR}B}\zl@26\F*6 N8Ni} &3+P^=WT e^nE$y04G} &=jK6m>8Yo!&p '43x'wZ T^ 1 QtnA
^) l
|>j;+.|S0:h,Yi9wsIG/M:0v
< > 0
8
R
/ Cd "O}bi ,DL@r?/ O} ?e pDgu1K(uL-mCB __"\
^ L~6zDN UN%@'8 {83
| Ec
,3MLidTR= ;wFw+v =0 \ [ ! l#!$7"%"&#|'$($(+%(%^)N&)&!*'*0('+(+)|,l*S-C+. ,.,/-]0G.0.*1J/U1/C1/ 1/0/#0D/r/..G.--!- -W,C,++**E**)f)1)(('D(D''&P'%&$%s&f$%#o%#$q"~$!$z!#%!#!# {##!#!
$!$"*%#%v$z&p%5'l&'v'(R() ))))!*)I*)+*z))( )@(-(O''A&%$##!!"
h
q6 |jiV=a)$(C7 #!
I
,B 8 M 3& N a&
Z
Pxi w`df}0 1{zAJJ I . ` U q F j ,* %q -@KlRyi_1 nr
B3oM
F
&{ [ j
#
8
-q)N 4 |j HMW3h;X&8Qkj!b
IAKFJlmM8
Kq^Zr7m8 n> l4qR2JDn6!_$NLn@Pt}+gl `:#%!6[ u T X
t
9 + P U KF
>
.g}
BX
E ;o C : T l +
)
q ( k P 4Rl E I d^x } L 1 ]M7 _6[T
~ 2d~9 ywW +y|y"`p{]._^Y;Bst=Fk` 7[<69 ( 3!$ H:{#ymjDt! ; Ny $
+p -I ^
n
4
)
q
+
_T
e
e
!ML*eqC
T T$, EU4y'CO -j
x
U!&o
c-lT (
0 PR
o
\ m
T
t Q P 7 c , rX y "CiwSkKr$hF zQ}pc $/Re K- v`#F3KO,Igr1 .1l))thwz"8+sT> 8 3 +s~\Kx|/>@ k?+KR < f s;PSsq6 JXD~ ~ w
{ f 3 7 l
n
k
4 # W 0d =
!
.h
I)
x z 6 b e
t
&
7 ' l
t
;
oHy1Hd;n
V
~ o Z z
b
? s H\+ p> bG/ E 9el1"G>ac
S-&^FbvYNw^"dYM[g O>*8Q2md_f6B uaB 5S^[ 1Vw~l6|w ,| 1(\J4 -n z G Y A: & G C )h"_ 7B%f E 0f~XyNq t8-+ 0#5 :bX VkRJa#y w Hz^}+n 7}N(k=_skJG,p{D:a +n/
]#fF9^X*X
V+tI@R`i5IKt:v [8W%0|H!RxD J 83"w*W* Az 0e8dv$( < m
\
h
*
#
p
u
R
i,
'
q W 9 ^lO.T9KdT 8
2
~
V 8
t
E > b e
` "kJ)L " A ! r H w { %5 \Ly:I(e ;nR o/a=W:b |301hrfQY/b+ fh(3t
8&/p> do o`svg=c \ MB =.#$ % [+)8)I>_nz0L 5 8 ^ W
> }
E 1``1/WWE}ue8K Mc.ST
|
p
ax
=t
s
d
P
< n &d
N
8 otg
)D HU 'G e _+ f&[p((u ?1't- Ez -OzD/`X7):ahn5l]uPSE5.79WPq Oh o wa 5Lj Z=)wEPn.|C|q~S}[B:z~?"S
< Y*6;@x8.fQyN!wLT1!b?aE *g5K=jx?OJAq/ =[QVB:$U%ETN"29P'7F-ka'z| iqv, 9LvBCkZ2l,%\y+WcyUx.[Je);zI4Q*"MCn ]n5pDk^k@x!@@ot`iq 8Ss 7:b|DcTtHaivfZAchUnf j5}](y|9W-ߵ߱OߣZ߾ݜ'w߁0G@ޢڝ(ܶU(Kc١؏؍ؼփ^֒ծe%8i;յ}cm;ۛפ`ٔnS#cn ތ
)cߒ!N K
ph&^9Dzr?m!0 @fb1({kPI|52 QP+w*8kq8r\5DFGO\k~\@B}\>8/("4 eHHDO]Sg^ ^gV<~cS
P:
B
= \i %o_lH*Wb@J2"-w2/3=*`-l$Q-X0q7%hc Q x_D`6 #
+%cf|m D&0Y$ ,u!7js,B5`EEq:mz })?(mM7.q_ W{Hd?E7c[Mm CYIh4a
mTMg=kWb<0x9_}:6 k/bzk9jA oBL,/m7r #_N9}/S}*`,SE1H%k߲K,cި
Je߮Jw+>Z ߈ުW+s݂B6}N<" GYިw +Fc+ijdISbqmY_I1
vsdL?u\N8OFvF|& s.*-L5E2+|M" y V
1O r %z8'
|O 1qV" d
c
^
I c g =
N
"aX
8
U
+
z
] +g^
) q ! 1#G"$#%$E'&( ')(*(+K),)5-*-*Z./*.*//*/*/ *Z0>*0{*T1*2j+22,3
-4 .5/6*07B19Q25:K3[;?4<5=5>L6?6@(7A7B7C=8D8E 9F9}Gm:SHQ;$II/K?K@L'B^LHCLZDLD=D<D;C;BX:lB9A8 A 8R@a7?6>5=45<4;3:L3p92O8X2C71,615T131201>00///.F.|-g-_,`,K+J+;*4*;)(9('M'&&%%$%#{$ ##h"f#!" j" !3 '!+ t } k A6 OgP 0@
X v
|d6(g
&H JQ E\B )!<3W X^*-&'gO~a s
\x"@,OOov(a~C qC ?
Oyo@esv9%GIRkPEL[g ^ wHmD|
H{OO nK-"eE bg 4t, Jp
@ ] nrVeJ 3UI
F0_kHTj Nl[$?Sr $3rtvR0,6.(220 >'R$yh4"EHv)6y_\C?*/oj[o?l2*3ZS9AaUQ(1
GeK'3a}6b/|V 4_ Os{b> Ak
}thP ;
N n
S
] L
SV(g=7w%~?
; W Se b
_
_ y
Lm 1 j(
_ 1
i
i! - 8+
V
!w
$Dxv
vQ*. I z Q !! " e g ) ; # %J Pe a / / ro# ]~sj
N
0x %(MBH<=#Rb/
I $ Z ,+ (O #z j 1
0 %T- Hq
9[^e
Z/ :W LqN} L
$
Q(
d
f Hz </ol]r i 6t~3|S7bH"8( H Z v t d : c 7
mH#a] 5
$;N\R7UX5:<d-!\p}?U1( ,gWs8)[6&wg6N Fr qW O+*2 c:hd j_TpI0>hF^8 d
m%(cTx
xF {^&A;81'2qr-uaZ`/zPx%0+)+%<WoupAJ9T% *y_tw UIS[5 8 c`ryd,LS.b
r
r N 5
: >o_{h|w0N PMtn}`:'wOVn=5L/`s:q6OgcYf#2{_Fps5NDg; iK 0!3 *I|Oq!{
h
4 }`T*D _N hzK[2yUZ2((
<^Kj !L 'HRcqVf };)erS;5g%>l 5 #7! +i 6Pki 42)"
g, }J %C+CBJg q o m( {i ^ ? y S dp%e\ , y V W~[D.)]O~8
$skNm {v_qm0()u|H0ELh(LUT8
cmu bU#p7!cASz$GJ kV7 y f > Lkrkk9ICRpaB d L%yQ[* ^ }O%[?;5Vxbj`F0jZ f# DMEpWp M
9> ,@?p ~ 5I">h&&Bi/ &~T{96[y
+o(1[
'/vq1K4J\&[w?hUYy- y uPOVr@_ En
^sM u ==Sh i n
] O 1
x .0 3d
[
( d j
l,)^|J*|M@ S:h q+q D
k
g
0H r *
2 C ~ _ > i > 1 ) . w K T H & > 8 . $
.
k "
<
W &y0B }T>' / T|#0Q1hl
(Mc* q
~
L a| Gw :| Q
dx
_
) B
G
O
9q"3}0*
mk
} b O} 2
@g v U hh]K==/Q'|" t R
%]NR&}hVC0Z-71; .JFFK 9cX&iS4$'Ev|;*o)IE N06 H^X\MEKQD<!VO|pKD w[$WXq?8Fgt|\.(\hV#$;dV`ߢ8hجY!eְهpSOP~Տ[|*7 !6wүԬxIcҐ70(*_7Ҕ։`-Kr֤$B aSd܇K ٢t/ًv <[ވXy7[Ey@K(nVfc34dz CVd/th}LI 2do AG
<K
b *
b`kP 3OyiU ( X 9 rF @ E o
O B h # / U e! E"1!
#\!#!#!'$!$!#!#! #!p"\!!!!! W Q Q W R l 0 > N sSrE *r(YX4C nJ-+5?KkN1MG9/J&$9,9A=PWcfnsucb`AGo'8
P
h
# j
F
0 } R
Y M
0
z {
%
l " @ E 6f ^ ] 9 + LT M npn+X).( 37ipuX` 8Qi2I_PY7 s
We'! ds
Vt9M
SkeHa>xOet V1fn6y mk F#|4[; o # } p :FCLwJ4,4\E T8L~k>2M hn l*Ii|`1EzMMIut_36 `VPqhpF k# I uU,
Lp , A a ] |a h _ e
t
7 ]
!?5{[ %YC h c W >d . ! /"d "
2# # #,!$A!,$N!*$G!$,!#!# o# 3#{ "Z |"% " ! P! [ i P < 6 h ~ & | 0% r x~V0ic<l+U>jqjXNB=_
w
7dw{`E1
[f
< # )
/
:
@>G83 M E0gSVql;S1Gh<ziuM%dk
1Hdo7*)zG).9EfW-+ yAw&8%wb,u-RyU)wDC f `7;AF>CGqTg39IPV& V`j3 p a*
eC-. On>];%;
u`~i1k=
c*
m 5E
z7Q!O;!s8\lb|<{"gU1 ]>(V.:pur h3
; w4R t
,
xMb4c
e[
*R
Z
;
]
n
( rU ;C0" U\ R}aK 0 0, 6 G/ Q! }" #s $} & T'!(#)5$*z% ,&E-'M.(&z$ &$%#%# %q"$!$ f# " !8 !X A d Z oK/2V1.
8
M
K F0[5jG>f% SC~e0:'3/i`sdt[F+kM2oes5!k~Y~^x,+%>5mws_0w8M]F}=-a~S@2cek]5Ud7e`
v$FtKM :g7Q G @ &- 6 rmAY S 2f [M/ b@ \`DOQg y @ w
u6~Y% |^.6kz0hRwt-@x]'Q1S `.>L <
1
u [a
Lr 7 8 P.^' AM, Z y p!{"
,#N#3$|$ $W $ $, $ $1 $ $Q $ $X $ $F!^$!P$!4$X"$"$$")$'#-$#Z$#$n$$ %0%%%p&%9'{&(&(T')'s*'+d(+(>,(,-)-)_-)-\*-* .+c.y,.R-.C.U/A//0/ 1P010c2020 30 3020 200_1/d0&/E/. .-,[-+,:*^,),(+@'+&.,>&y,% -%-&#.K&.&J/
'/n'!0'B0 (<0S(/{(/(/(I.n(t-2(,'+'*a')"'(&'&!'e&o&A&%3&G%&$&$ &.$,&#Z&#&s#&W#&3#'#7'"i'"'"'"'"'"'a"'<"'!'!}':!6' & d&R %l &% H$ Y#`"@! l }z+c!XmFTL>2 /hLlN|%5J!t
2
/ I
]
f
/< 2 ;CS]A@ +_~uu)|]!y[=5
p3on*"88hawh`/?[n^oHX/ M~K'p]vLH;-05ODk5 :{8C> bv g<%2{V>wI!w78Uj,%{D,HJ 3p~.J I6>G$UUYBC -?u
IyJi6' "")
]
1`zqRaS<Z;;>Sb(X\
n4!ktQtRjq:tpA%;D1"cy
j6[q9*k"Gg??kj7Y9 w*o~)Y{Z&N7%/q:q<6 < ,& [
~ s p/fH
U 3F/a#zo"Dz4] s ] & 7 P! +" *#X *$A C%Q!}&"'#)>%S*&+(,o)".*@/+00,0?-z1-1-1-1#-u1,0+J0*/).(-f'+-V&,m%+$+#B+#:+A#F+7#+K#+#_,#,g${-$.%. &.&1/'Q/y'Q/'8/(. (x.+(-(H-','+7'*&)?&
)%($ '$/&5#D%:"B$>!T#, a" s! w ~ x W 3 "V4z<h
Rj(_Thq
&
=O B%c 1
\K:: =8f|2 CDq!Qx]v6-W__IA 7=V@3M/E>cmY 8s8 clSSO@ [rivuL& 3ga-b _ym,b:\j|^~"`@6"x#U)VAeUw .XDtIGH)f$O|=5~V//\ )i 1@M, (# t, (R>Le9I{?=_
~%/Ov ";[#L5xR+; '!z?}4B
lYxPz'.C {D( K~*^Y58RH{!>hcgg e 3X4Ufv* d`0#l9xaPC#X <7me o;OK> AtSQWa% T9E? ~7k? 1,jI ,
x
=
q
.}l!cx.^pX, $ 9K< E " g# $ % &!'"(q#)?$u*%6+%+b&,'P-'-t(d.).)B/z*/9+/+ 0,@0f-K0.U0.S0/S0a0I01*01502.0390s4^0V5|0?60"7
18v1819m2:2{;3< 4<4=5O=l5b=5\=5 =5<5K<5;5 ;U5::4948F483K736K3 6"352o52&52 5 3 5<3P535454)6 5656n6X7&7778J8*88889 8497'978 7W8[67m56}4i5J342200S/A/--Z,+**p)<)#(
(&1'%w&$& $%t#%#%"%p" &C"L&*"l& "l&!S&!%M!% $& $g
#o "E b ;` | [AB,})311yei
{ W +2
u
@& [ F
O
IAN|Qj
9Y
O k q !
N
*
P } JM
< 8.)
f
t >& x
l J, ~ ]N I#jp
M~ k - C C
c
a 9
`
,HkJp M
[' T
< L/Jm(e p `!Za _;%v a gZ2hS*gl+:V:# [>BEy'QSL(ox>}z
vyiO%zauhKZ|i|1F])[OIvQp W IbodELh= 7
~
f - j
3 X
}
yp9S2lx`zkR\O W`s D]I1Gg{1"K$C ~{_/Cl(xAz)@ 0(FJh`'6Gw
k
eO
::
.
}
"
/
2
P
m 6 |
}f
<NV9LN%< BC [ :?zkW:![
|I}9KFDI! 8i6{I&` Y1mC h1Y2>wP' (72^L"n?o@?
PF~!-u~
= = \Gc>LZ-U g~i>&u86 _ 4
O
R P
A4 zS R d ^ Z lu [ A ,
6f
S
_U>9;O4%xXE5aK> < } iS , a !"1s""H"" ": ,"H !% !w % N x d @j@x\8E?:[9<~ I 5Sl_P"(Q
N 3o{O+6 a< |xKhU *7s D cngs- -Mm .ZoxbJ guvSC+y
V6wz>p}v>b ?5W9_b X#cv J` 8T7UCm$zOeJ!*PN_ZXj{
RoD%b-Prw>P1*p6W=B; !Y&0EiN.%'O}bc*@d '|A I! U4
sT@,$ExU8"Jc IwL&9Zp-xmphP;#q:*_ )tv
@7zIw?P@QUGFH, M=| F`'EmtY 4[
> ,
f T X
e_&v
pe9-xq#k^
! g 2 L 2 j -! !8 " #* $ %!&B"' #($)$*%+z&F,,','-.(!-t(,(,(+W(=+ (i*'i)I'R(&Q'A&D&%U%8%$$#U$n#$*## ##K### $&$S$$$%Q%9&%&n&'& (V'b('('x('8(t''&D'O&&%%$-%#y$"#!|# +#* ## (#g e#7 #L D$ $ [%J % Z&b!&!'g"L'"['D#_'#8'#'#&#y&#)&#%#%#%#\%#S%#A%#@%#<%#0%T#0%#%"$ "q$W!$ # " O"c x!5 @ k Dr-pp^Wd]@f2q-vD}^m|w
q4fHL)6
%gq<sq(a
r
0
^fF u2ykVB@'
D}, % 8XLb<~vPn6O-
d>
2v|aFi4 " /^lK Y#y + 2;
gtwy u!p {fr*./*)+" d%AfXE;2)BZ C kHw#ZD Bu !D lSR},Y]gDy So7x `^Qs@AkMB PUxl~|;ff5Vcx6gY
KdTH1 @]ݹ:Z8Y6=ݷS
C_ZW&, 3 /a&J_mK:b ~bvj' U?O= Q \ RPT _]V P `t3z
kZ " g ;
y
!
a
HPN
~G a ]
WQ< e: NN 3 Av
)
_
n N ? Eoh>l .
X( ' H K] t f Y^ & f
+
c 6 d\w
h
8
?
*
+ e
L
n~ =6
0\<&L~ 83\)I:#l)zGi`E$p
P
S
2
_ CUC{P91 0
"CS}%& zK[]oYi]SCR/1p +' x!)S)$U?^QYeg;] eq=n2M%f0aip,ZZ
VrEf%|@9m<7wpOP'R[fS85<^r#ego< VomaZ%i$W _rRYdaV &8IJ`"GcLpN xxo^9NSU NeXxF|$ ] 0LE_RmLBN1 = QuA~7 H
] 3D!Z
U=
u
.feMII (u
kK
9 x
t
bq2q@X "K~[8Pe RF+lM P;x,H1_opO'
j=
s
U
]W
g
{ E )
8>
Y
~
T
G
2 cw v }
Ji/r"aat5Rv
!
T sE^* hk : 0 f0QOzI 'GZ6g0 -O;D=TT<;go.Z(Q=rc~u&Z'g&)Cy^2pvW'*[V BI .9,x>\@^A* lAo ^F@NYE
Wwp_/"Ua,gU1q>dH7qT86cuj%r;Z;Mi H&!2_=My,@mBVdfiL2?^B'lJw y 5 "tcQigv[Hf O+-LZ.UQC03p0A&+'8X?| Z
7f]![tLJB7^XuU2K!1T\6WYUTib##71hHq"@U# #1G~%l ' iK& HK}UB D{?=Y8Uk&4#)4*>Wu ~j`0GZiRmmAq 1l?5/*Iqu
'MnB6 |<ߍ`}ުݗݻ; ޯbޞސߠ`8p.y>
wLvޓޢߥ*߸EߚjߞߋsP3&.@s,=ߖ]Q66&*,
Y"ߍC*߂u4 SV"Re`{)\ _u5@ ?#!j\k:Ek
(VkeA@X)s
'RJqf2L2 ymT( w^ee:asvH`,^(~!Cs i)y]8
3Ry_W2KmrY@TEQWkߏ4B>D_{L/,7:r= "2CKcPQ QY]is5w4P"O# J uCt9wh
Y~D <s h Db 8 A } U@ c
, [
u
N
/G~U
Z
TG
7 )
V - @R q N H R i
U
w J L0h=IyM~U 0z ( 3 <
"
! @
(
) & 7
s
Y
v
+
Y
oB
g P3 s XB Lc MBv. e"^E]#jpC c "m$PA2/ .v H %!=!T>C=E}g
*GnUgi:EF^I(@e>5H_nqfVC)|P 's&k8jDiPO=vD
epz/0Md&x:gO=;K_.+krP_ ^V
'?P'grTC\/vaV6#1( %7:JZMr' ?`r|dB8d G VQ,p [CeMlg3g?V}J[=|r `%1 :
YL9 nw !kchH3\#C B
59 9C F .
|
7Je!
xku' xI~yHeYN[rTk^%BC]
M ol + @
g#
}
n {
$
K
M| So I`>;| . x !> {"s @# # {$! %"%A#^&#&$' %/(%(%f)`&)&G* '*t'*'* (
+>(*(*(*(a*(
*()()J(`)(P)'D)'S)V')(')'*'_*J'*x'<+'+L(+,(,#),)2-)e-@*}-H*-?*X-)2-~),({,'+&]+%*v$*$#{)!( (T '3 &4 _&Y %%;%$C${$K$9$$###N@# "v"2![! = x; ` G;-04N
`x
k+
/ V
<
{ g l ^ J E $ 1 q
o
: 2 T
nN U T
jY
z
,
Nfs e>y[Da v %MpAOlUd`^Qa1 2 e5}kc@/yrhmPk [mWbP[NS$,
fo rQ rn:24 nrF I=Q?c+LbI7Y0NE:Y8u\j9'i @Oc> 8BK=P U w^j]r!@UdQ0$ f= +
5 ;S m ^)`a 0l ?2
! U C !
r
)
|Z
)
gO Krx[BWA El d 9 DaMCgLTB8JNUHs7rL B + 2 G K ?v ,Iv w{/ero
p VK H I Rx ] t w. >
p~wpZoE<\~<fo@x%' 3 + s c = B C)PaYA"p vaD m a q %[
v)=o{Z$
aE
`3
\
j
`6`zTS9
9<
YC
7 m
'"
hx d
w
@kN ;4}2 / ) 9#_PpLL8c8L(c:
=b$GqjL-VbKk/լܗdۅ/ڔNՂЩ/ЉGmKu{1tPˎ\ɚP(fǿŶu7=WƎG6Acvʑ˫ V.ϟ!&˭;:<͌ ӄ85S{ӋS r -իTw֓eh4tّۉܶ
~y<[lLI4|etNm?=nIA uER \KFowlg: R 8E}> ny\c J
_74&Pv;"M#3U| .*C>G4xD"m^jPYyT(y a3I&8X^F\Wy>'|$2L
O
V}TAa`;q @!P$Qm#Z 5Abl((~ ; | ] ` _ q ^ ! 1" "u!#"@$"$)#b%#%$q&|$&$g'Y%'%r(=& )&})'*}'*' +(+/(+"(,'-,',*'+t&P+%*$)#(A"' }& 9%V # "p!S @ Y 2 r
GnKd,I>X W12
O.y\
T
s xgO1+8? RZ;zHN=lW@Fa:,+-Vji@5L U3JL,UVj@ MvVqFK;S{r:.j!@>u`!8x U X>FBD w@
E EJ `mk>)Aa!&o^+T
&]m.$00,3 $t d 1
"Clz7< }Xe <~i
.eQgO !P7#D1^ `*L1 j | r ! + 6 < 2 + j)Vg uBA*a
=]
j
1 P |
kOvDpG
p&O604 b x G 0 \ 3! !J " _#r!?$8" % #!& $*'%;(&r)'* (+(,)-"*.}*f/*0*_0:*0)0(0(=0,'/B&w/_%/$.$R.#.b#-{#-#.O$?. %.%/&/'20(0y)31S*1*
2W+B2+Z2+Q2+22y+1-+1*D1S*0)0x)Q0)"0( 0i(0;(,09(k0:(0Y(K1(1(q2A)3)3 *<4*4*K5F+5+5+5+5+5Q+35*4f*3)*3(62(/11'#0=&/V%-a$,#+"*!)Q!( 'R & % $d ## "
"
! 5 Q b S 9 r
,2{(
ia32o,
3 'd N & 4 /t p 9= ? 4 1a or / 6 hE q s# fu rVUb KT5d~i>mB}Fy3 C'ZU/ C B C6H@_%^/
Q,
8 V
w
l
S
hk
u
`
'
a * \/wTk1@GnOJq (HWB=aV@h!P$/>bI(c ]t}@9vV 7
Ko
(o(HFvt3(qxSh8p 0 U(^ $ g l
6
j:3H
S0/ #S}{d4
mj6/n h~]{Ec sMQUpxVx<[RI-A_x}W&,
1uxF B3?}qwR$>z1 L M s} &S 3 A -GBN |Z,EX"v
Cpf8Ho~
A-r@velM " ! k h H - R - 5 # '5zb3
>
z ON Q
h
t
N
l
g
D 9
C P r Y 7 , kC W P1 N BH 6 # ]
n
x
E
o X
D w a g . s +
M
n
O
<
#
M
@ o] |vyK ; Q& A Q
b 1 ,
" ,
7
i
( 1
[ k
b 79Ix9sv %9
)\G& BNQ *la=4Ye} * k/TyL r e 6 D8 |7 `d^ MJ-U(YFGS DHWqi,pW:P!)@>KS2%{]QT]k&2J1NnQ{P _ (e *q9|.zdI Edv,`5lficY`;mjHq9"?5?]ZuW7zyD:e4R9G?8TYhq#bV 9 &H
`S1
r[
Zt9#3 ,Vf6 D
=
h { :
y
r
_
[
E e ^ L
{
M
| u ~
a
+
C I
A
3 1
H
J
A
_
)
5 "
?>
t | q
5 `U -\ : !K6t%*} |JT6wmX_[bxlPbM ,*iMU[mZ`"FK,y!Wg&VHHir7nztSkK7H(*5j(% n[(Mn )P@6/oS]YPu|([NV
yT pS;U%
4
9
K
pP _U*TW=3 ? V
P
}uzDl kf\i: Op
W O " J _ #
t
Y
<
8
4
J D
h
0
Q R
>i >
U
h
t
Y
0
0 } U #
L
{ B ! o
R)
/ u j
CA/q`j *YigUGK/ *y4zzQFNO/ Jl~ {
E
h * ! A
s N
]
e{_U` D ;Xxkol}Qqh'3mx6+0++IHUkP}c!J_Alt aa~
g1,8
eMT i9NA
5?
.0J8,5wW/R
Z >~\gj! T.Z d05)
v?
-$ o8 Z ^ !8an,_}dM("@(m4YX7\60e E
u
W
S
5 ~ ^
2
ly@ ]
V * F m 1w M 9 E 2 R! YK Sc 2 H e&!)" ##n$L
%M%Y%u/%$R$#X"'"=!(\ < t , TJ v @ M C > r Z {! ! t"V! #"#" $#$/$'%$%%%D&A&&w&'&
(&(&)&m)&)o&-*I&y*'&*&+%1+%d+%+&+B&+q&+&,&3,*'a,k'y,',',','-'%-'B-E'N-&:-p&&-%->%,$n,$,h#+"+I"h*!)e!(!?( a' &q %F $" # " !i d = { # R kp;w 7Ibp`@:\#$p (gd&@[ iBH`ixX`{k059PYa}_SP3#?0_71 sd8l
: n
Z
$ o ZU ?R >P v ~ < 6
x
9
(
t
N9W-hAQ B`ZdbwA
1J{CF#
R:@Dg*t1kq
B&H: 'b AcAXoO[#Z[2
{):RbR d-k_w?|#z2!O+5V/Pac,#
m(0B
iO7pmzQ ==2{=`jr_a!n7Gy= "FEQ uK aj)?y)%a\v- ,Y_# YHy44No
( ! :
*
b >^
#,*m (
#
`d
x #
E m
# u]
6
~
#4|^
m
$
G9 N l
o '6w R{5-Q
%`/7 Bs6:-Op w
ިa eߨ{j68Vs[ k tA5Q^J8i # (* R " v 9 ` < _'5&%) | " BRS?!:Du qlI|Ivg/ Z k? E k-d R
p
o
}
e
W dhj
jV w o
d !'
/ CY G\
t
)
4.
_d
1 ! U
7p2] k&*Xo0 ,^H
_Y Z+'r{?
zbDrM_C6=R{gWg-jN])@qt
dl -
%
t
Hf4 Q< ! {pp s^ IsH^s f2 K,V j q Q sE9C8 5YWvFK|]=YbwP SCs#%
}J"
h?=DR4OCKdloY-ZG5pMSJR"p ]LxB$Z- ; {Do%8J90% YbxW<ELZ'f
d8S YB+'TTx:T<a D - _n&{+d ? e?AAZP@.8~_ngp22Lc_76T
G"@2Z/QUKW6c A Hl{
) , %
! w
^ F P%
q
HoGC Z!"#A $ &
'e!"("")#-*<%!+[&,d',I(- ){.)6/k*/+0+,1,1,2;-)3-3N.4.P5z/6 060S707`1X8181 91C91V91K91*9`18%180"8h0706/T6}/5K/49/4 / 3/G25/1o/0/00/0 /
1.1.W2.3.3/4n/w5/3606v17.272m838v4858585H8,67@6?7.66655`5U5443N4333x2#312)110F1/0/0//..d.h. .--W--,-,-8,-+-+v-z+c-F+$-1+,+,*,*+*+*`**)*(a*3("*')&)3&)%(%'$',$D&#S%T#U$"F#]"1"!!
! 3 C + q mn~wS&IbW 0.5y$;6_Y:N~QaL Yf,@c_Wu^4; + f|F(eMwveN| eWz?SiE 'jdF
Z
> q
n
,
g W
S
P
|
F
?
0 ,R bS \ L v C
~
z"
~
q2
P A v H
5
i
,|!^ " y+PSmg(
J op i$
`24F d
> ,2;\UR RbhWEe ~ L ,OKwa_" l 5
X
-e
`K
<
D Jn qc EFn"p \ ["7< U*, j
R
~
Z 6 A K ^
G
: S? L# dHm{< uDx44;!?+~p 'Fm &(p+9>E i! M w
x s
X
& S b~ f r nz B 5
_
!
p ? c - =lV zjtA8#p Z M
Z
u
0
7 -1 K Y c{ k
h
& w
%.FkG
5 }
1] < + b{7G_Kp2yQE>( %D Tr+f}yK{XUC1?"-;~g~@D|V45pQL^
="A! "8\F9p& m awN/0tXlAs^%j+~Fa)eWWE ]1.U+G2Tp1}? '
! z U A ! 3 @ p@
OT
K y r
;
} & $
u (
3
dV3)my -]gi]>TStMz&l:8 mT+[ c7wF)
W
l
F
+
& ~ > -
s
i(
d u }ep p
e
{?PBE
( IBQjgap =we`Z k-xz[MQj us;` %;_)
4Q`LG36#)&,$73m64 0m* [
,
E
M
^
a
@t
7
: x
s +
h
/
d
fz1Xa$+
y C
' S
BK"/4@Mj 6 \n=fr2kf .r&hv@$ E:o?=g-?2" n.. y
}&"E*j7h/ywzzucZaw~M l_
Y0I%p|mk S vtH
UZk0"u ]/S[8' >) P??qo]=p
t U[<- M C!a' Xu u]*
4`Iv v _ EkoeM &u6d wq qu r s aR
F4l7AbG1
g 1 { % H M
>
4[
fB
6
>
Y
`
m
/
! q0 47 @ }o 0 U5 c3
Nj)M91W@)0
eoT["l
l =- `
t
ww G ,A\
N
| >)
uA AxSb2>5
E 4#OoW"Ey u\`nL1y:H 0-\r`a$VMAbO VaK\ t \ 6U : ]@ /O Y 3 M Qf&A\( WL$7=}Sfg E
] IHeJQgEZFx:' " 5 %R_z 7K X tL~ LMoQ`G:ATPhL45&DS8o;{)A) ou +UgzI V i ^'>PrmA 7
]
"
1
^
q%
RW 4 n 1 D R
j
N i f
J - / ~ . f- d 0 4
=!o-`14C..B4?
Kv[#e]
g
:
. biu3r;s :# (d1>fY CC35<P
!
K5 ]D `G
/-G|#{x(R( eP%
>Fl/I* r 5 { 0 K !
^ ` V 6 { Q 6 9 Y
X \()\qhO
x
#
1 = T e eCo[wB'xJ Z\!
a^@_E|d*_ A{=J M#eiE vj;)kkv Apyi\45x &zX0_+9*3A98tlG`Lh>KqFB
*).NrpcO5 er(:)ߞv߂XJ<<@cލ,߇+z`U$Tp%C)tkE+DIUhvl)t~Q:q'rz:D_)wS2Z"l) E@.IPE c
p
t( ?| 3 \J
w
5d
OM
sJ
Y
-/ 2 ; I
>.3h1tBBb_a=j72P7mO
V R L{
g@qv'
\ ~Y
v v -
p
l
qN
r ] 3 G 6 $
h f
c
)V5n#%bf!f1F( L5s ^ q l v 1 S!
! ! ! !> ! ! j!3 ! r O Q
T b 9 9 w 8 M $ o *! ! ! ! !~ !R e e ^ uhyAI-d TBe?~O?q90 AQ$>@fHE 8]"M
3s a
tm R70P<P
r/g
xv
B g
P * T>\ofMUdx&eCc%N k G3HD
_:d
8 ^ ( (
d
YeWi u
} F@
D
? cn.
|
kc
|% j z Y
$q
9
M
iO -
? ];Q , 4S"/&m3` n,<ikmG vn K0 y4>+ 8SjMquT8` + Zgi{KccP!mN-m%RH:7Z}kh B ` ; h e <
+-3\7+1& X (
--+#"fc5%JK1#-_5}\w Z}BV'f$.\{
b"xf* F|I}}?? bhO{9r5[!1?4vFT Hk! X:rmsq Mr
W 5v
q
vI80x, | L
9 W_
G(',*{84;Q9;` ^, h r i ` R i & V! "y!""#"$7#}%#e&O$O'$0(%(c%)%e*%+%+%+ &d,&,&,B&L-\&-&-&E.<'.'-/8(/(Y0m)0*|1*2`+2, 3w,R3,30-3N-w3N-@38-2,i2,1Y,1+r0|+/+ /*.F*.*-)x-)H-)K-)a-)-)-)-*4.
*Q.)Q.)6.)-L)-(-[(c,'+2'*&)%#)%b(+%'$S'$'%&v%&&''&''(((w) )o*)N+), *,),)-$),P(N,@'+%_*d$)"' % # "O Z4X+sSvl
`
O !D O
L
~ R 3/ P k5 kp l S,
N
9? t
|
_b4~W\2*"
`
u
i
+ s
_
X
C
R 2
d
f p < ! Zs J "
b
#
o
G
. yC
A]
\Z='% >
% 2 ^gTl X [T &: U i >o g v4
q^KYbT,c:@QkR`J4s[dk {80uf
ViNU/t8'IF}/E|H+,@yKvJ=xS ~& D!t{Fu>o`~"}CJ<+<@N35+?|>,[ * Q
RG > M-\ S&>:A .Qj<S. hS jAYx@F4-3
`3D7! =A&xjxHpsqq1KTpd^
Gi] zvpZa8R\Pm._Ld Fa,"" |B4Y`&~kP$ {4[ 5Yti92li+WrMxH.?Z|T7\w P n
^
fy
H&D~%YH | 4.0MJ/z U P / Q X! ! !8
" ": "
"!"! "!!("!V"!"!"!"`!"!" p" ?"J ! ! +! m 3 V W V 9 R) 3 n W b k w* ! 9 c e #.k|_)#36I<I
3o )
U
@
)
~
" Z
3)3 Oi;[CQ)76m'<!HGh<xp_ 'B8\D{B{WoDn8)qX)`~ N
[
F
n \ * Fd
j>
; e R +) F g @ q / 2 / jN:YYNM_< 4M H ]p( x!
.qd `b J C ? 0 `6 Je}ha3l x3\n,d-0 WMIsCR!LpA } ~E+`dߨ݅
rLG@C*\uמ\d}1ez>إشٶwپEڻڸ ۪Zۡېەۊu{cceP~VZjۈۛO82pVB6`?rAT~"Oaz8S?/6;P(?Jip|qft<&
hKZ o`? R :e/zoAE
v A [ Z ( X~\ hl
8
g
_ l
@
CW)k2ZX/$} H W Z!N!A"v""!"2"+x"#A"$" !$C!& Ej e " pf - < / J { c 5 ! J ] e V 2 | V y 4
x;ouG/ :%tMQdv7,6?ic7Sz)Z=&# o-n9p
DvL;txVQEF> Qf
{
T !L
C
u
@
Y
<
c {
6
X +o S As i Ue j a N TC
aiJN V
x`
o
7b
jg 3`
5$ sNBsc%A@Uoe; d&p-~1IB}NY
PF edd?,enwu|Vy$;l%hT# \I1Te \ |\GI-=c~85pcw-X%B:4V`KOjE
_kY h0JtNCFDx\|mGfJm?`2$zz"]55 $pt~({ptMsxi;QNAq8{]93X MA $)8Z. E 6
_
Uu6E+L
LsDY7h ; M _ G s % }c _ - C T! !o Q" " " #. (#3 #( " " h" ! ! ! s u # q > ? #! ! ! J" " " " "
C" ! V! p 0 ] r /<
7[2 }
|?vG-|J7TDz7
G
O } 9 Z 8 * , 9
c
P
v
r}
C
" g
{ w ]K
@{iMa&t/}
BX 1 * Pu L g
d
' h OJ
_
x @W.JtZrT)E h 6 % : x N9 YebR!SYj :- Q f]!l &yrmgx'gF4 * q*8ib/YAFYs}Vj Bj~
L)*N&_u$w7H.- < b Yb wX_\a $2Kwtr6&F xc ~?3XSO]?
E &xAh$
*3G{ ;`
d 4
'
Z
3B[Q C2|T`sX Ti D8Fx? ~ 6
0 D=
_
H $ *
:
R
| J
g r |N : J g &
u
4 J
q+zdSo n( b *L & P e g ^ . 8 m.!!~!!3"u"""###d""" H"C !E n!I 9 K WN Q s 64 F ~ ' ` M' ` h $ , V2 5 x 8^ysU0{%R
` NO HoqZ _ oGnw/"6fy~.,nzgVLgv\K 1Gcw "+$
D,5XqD5*wNfU+!$:LAsK$~r|5.UN'x 65ZS
!f}%'o fn`cks$k50g|0/e ;X|Y<
0
a
Pr'U0Y`^)Cl;gy-{.fO+8`/@
7W^c0 \i:X
?{KBMAhD:aJ^% {Pe'
D}@U
|Tc`+wxpXx;2`g56FOg[n {ssb]H>0Oq_ f#[ V 3 AKb1j
{ R Aj ]u w
:vbT79^
IFQ|# Y4
WT
8 = %
P
mcrUPk2GbJ { Po ;
0
jP l G J K " [ > z : z
y
1%
X {
G~;C P Q"
. s # F E "v
?
7 h5^O>OF -Y G =_ q#~5ELAJQc p qY6 vrq[?bpW\. Nn:A K4G HI0`zGgT9^%
POr1 : H F I C !W ] jr + #to4Nff.AX>j_ x ,"
7 n K J
!
)
I
Y
E
W4gj\V>:y4)w`7:w x t C p 4 A!c ~!{ ! ! ! ! Y! 5! 2!| 2! ]! ! ! (" " ": %#S Q#d b#f C#G # " ! #! < D $ F H
D w[TRW}|7
Om#P&!5gK OH[ W(E}hI,CJ~i:!mmd3+~Nb0j9aj>{t#^
t : <
G ~!
5
x Im 3G 'U *h < A `7
q%41 NRp
?
7, ct
= wVW+t /Rq' =a J ~eQ/2Ccs&DU T sJ "J a ty ) a m t{;.YoP n }rX e (~eN B n.Y ' > AF# g ~ n CJ 1@e" J 2k*XyyVT6 t \ |f-Ye $hP :
D{mL 'B% W/iKm7nGe{[H`^ltY "S% rYo{ '9y~*_i )A;Vk
N0ET*2`= *)1eK<<` z lyA[4i!^'m0g3j'I81% E e9`P W>q{
< 3 >b K D)
/o
]Q#; CTA= ]f Z 9m 62 {k S " B 3 ni )F-qc$c"]^ih(G `jNiU8gX+;< m \=Y-}b d k + K J " 1 r P u ) !Mb (' L l2 < )
2 Z ' p oPrYe9(? 7HS%
k
J4NiU(
A
(=$UZR%~0& T1
% W
' j
B
\
Am Q}|Nx8y >5Gr h~qi{yr]hhsNaOww0^D ?v~IU(|Q
TiVkRfM@pc8BDujxdB< $< [J8D8Vz8~X
L5y'DRDZ#$`,8d#a1PsBZ#L*;f.;6?`GRBt scrQ[^*pr $K!!["O#$'%&> O' ' c(M (O!(
"("T("'"j'a"&!5&P!% $ >$ # # Q" !X D } x H 9Rw !>{VvE{~snNu plM
"
3 s
`
^
\
1 S 5V 7:c,4E }trmCTVR>GQ%<.*e-_r
zB2I32rDUURESFD: \$Lxc3 )=D: +d I[@e} q^0uR;Y ~H \ ~P/O;iRn YQ:
S]I> l>R0-Gbf6 @Cdf= ^5Oy\A.iT ^tH`R}= -h
- FONHHD=DIY lh \ pB ^
3 o
i
<
[
B g
J d
@ S
9 ]
" a
2 Z
3
`
p
+jQ0`%- GsXIx7LCP6Dsu 2 ~T #Z"#U%* &f 'm (P ) W* *!*p!*!{*!*!k)!("("E' "&"%!,%!$!.$!#!#=!Y# <# *# (#~ ># R#W c# p#0 # #C ###~$y($H$p$, $ $$ $ %c L% ~%y % %7 %h %f %/ % ~%w ?% $. t$n # q#"?V"! 4! & b m5 v R : 1 $ [~ _ MJ )
rG@ov`g34P^0geK)%U
g
9 & u
N [r[.. 5 Avp }e{ zdm^ED4V DZf[ G
bE?o8V( h08V\tX@@p!7>@ +DM ,7,v _H}=Y>F5w|l% U A e
c*
{d
I"h: [= F 3
3 m#!!|!!q!!e!k!! $ % j 2 ,
+ q 8 ` d /! ! "> >" c" q"j [" '" !P ! B D X 6 5 iOS=#~%0Gq cI8 (6g-}b?!|[
u
NC d
p Q r
F ) 9a*R
n
By # s t {
3
W
w
g
W
~
#2Lp c
?
g
{
}
"a
%5
5 ? S iT 0 3OPC r O
3 0 Z>
i H.\&5io nY w 2 y oT ' / - ~I q '+e w ~[~- M k & e
8hE z&H$)x !
RhygA)!'K/Uufotp}DZ H6Dތ ߈$DvxC$Jەۗ= ݜޘ'(k>87oZ:n~W;[)\xug NC jX*<' (M
+7&TNJ_% _D> o{ST & rY
\ ` }{ S Q hIzL(
8V]h06vwj 9 c z * s1 ]U 0v
*
1
4 z][vD4 .c '!
}9
6
& = R
0
`
` Q
Y
X5t^
54r9%|G
MO | eW vlv/?
Ci Bhj*P Ud(LF 9| ` t, p X$ X z v ' ! D! _!z b!u :! ! ` U V H !A != X"X
#~ # ^$ $ b%!%"!%(!%#!%!% R% $1 :$ q#? " ! n 7 = j v z qE~
e<E% / F
C U ~ I<
K
z
V
;
#
" 0 2 4 ( j 9 y7DwQ^FS-s` d K
0
< !
S
h
f
c
t 7
$
?
= _ h A
: + ! G nJKW4>6z' 4 J y?XVwuwB |SJd0;:y};t-7M$Hm{t-Mz{Lx `t` ]dQo dBZ8>`.zR
|dkT?0MB'2kc\bm{J;[Ij8a-%M7r0 ;^h7H1p~.i4 u \ &,
G
/p
a
6
W qs,^d +reX? ShA) GR D|/RK@ KI x!:SGhNdAO`{}E21HscH3*nI!o2l[H3SOceny vM
gPK80R`1Y a @@tIFj2 F#>&GS{Eg;G eT&
'4f &5h&)f# BoO.$P V+J{?a `-onD\<U(S p2
6
3 e
} /
> #i
c
h v96xq xa "zt5j:1FAlepy**Q\f:3T|Z482Bg6-
/
3 : F h }
SP Rt" bL M ^ c i0
tT
ih
a`
5=
h[ D%.5g5g[D#1v,W {$2sd
;
P
Hb
| ` >c$o$1#3l6*jh
. @ ZA [
]
5
^ I -
{,X`|^,>*q
#
1
^ p ?
L
Yn I:
i ? E}c2~cK "#
5
8>
) # )
pH pf> dl0$|B:LCw7 d,(M
*G
dw N_ Z >
m
Y%^e` tPG!#
% S ! 3! !!""\"O#"#"$"$"a%l"%/"%!%!%K!r% "%{ $ }$ *$' # #. %# "J " <" !< !r!#! yo Y! 2 % } S *G $nMuf}5^]; /
- Zcn[bD
0E Y
'
[ P
J I0LJ[?c<5e o3}9yi a UDDP ?"M_ kk Dp &}*X H
J 000373QK87? I!HWrhxFR0Gx&r Hy" 'w)~3/ LGyFt
t
d Z w `
<
e
k
h
q
Z
X
L
' G
<
" ,
s
# c P h hc
m
pC
sA
R
l
&
f
E d v 3u WD w
v|
a (@CB4g$-'U gf.cfR@({v]G<O7SGE>gC
R8f2&lUC/,[a&4UpEy!% S\bj0 Z JO m* (t C
n \ W
O t#
z(0vezGv]Uw . F n R!+! "w"#"<#W # #h $ P$' o$k $ $ $ $ $ p$| /$+ # #O "# "
"Ko!k r b 7 Ri
n&y
S
PL [ n )zt20|!nX<^;V5e,(
^3m+ K5y\m"0-ސf#8~$ڲٞY٪ 8ٓp[:ܑ;k~;s6oxSMay{ z6:wa1xhrAFy:qH5; f5aRo[>[(:Ll|H])7xGhoݲn6xڸڅDٛ9ٮOكٞdّ-لq߈K0. ܚ
X 51Gbװz;ם#K'Mڗmm ݍR2}ݾc^1]g0~^ڛfڹݡٯݦ٩٤.ڡݺڡyB;(Fފx &i&|-A;;r*qH-y|I64r <?]CC7$'.2pu/SX MH?P}~]_ H
k%h}pX 0 P Uk u a , Wb S ?} i*n%jl 6Zd8Og
7-av3Fd
dFh !D7=6;z-rS Q v I
DC !h>;Ox) @F v<K
!w N# * M J " ! "
m
0
V
" J : VV
m
eF:b c- .@[80T?t&X,s} [Z
y8X$t
7p m
E
~ :Md\B , ` :+j ,'hU b!.;PF:/Tn?C',JF .xv}y% TC
2U<&#c / 3y3 (w\6i^>MUu` |NA51HUYvow^ =]6~ ,Nc| RyDjzt
F
P p
d
V %
\h%B G4U#JQ%IRG{*G_ ) )[1)4q]15
m}
:
" F
e
P &/0&+T&
E X I2 f 9 v,$eJ;rN(>{PtwZZFu;5
/D ,V&
?qWiL$D)LxR`u { &gV ,y
O I
"^ tT}i[c~6q wYOY h ) Q = J 2p I e'ru~c~bu Ib
t
R ^WBI`v BE 705KR^Jfdm v=gCrPsFSKKaT]
uRiJ4*1 &/Y:RwCE`) j\H`'x 3t-^V#T=$s|U>if3D*C ;w 7Yq,dP\y~`LC<xD_krovwxd1G])rUBp)+Xy
{jaT; ,Y1u n(V"af= #S>@'%K>;Pz,tK04D]vy4d:mwG7)yhdE\|` 4:0L5<#
lq igBqXPPG9]BS[CglshsWoCok2,iFnpbd ]%)u0~xO2
u.I[ht7
-6jeROEOUxA~rVd(tkx?Wt%U>6\9Uwj_=d{~T$%&P+- Wq Y v Rjp4UTI RPo 9P
z& ] | 7 \h95Z$ ah8I-z2{ :%KS~; u/RES>)1 l r
@;L,W{xK x%-/ E -I
- }K
?# H
PIEEaoXAOkdT=h?j#S$CL8 R 7 + 4 e h c L ^ ; 6 q( &cg5"Mc0 Y}< z n n x 4 U4(y6><*
%
e D
I
TK"^7 1zR . @ ]*/pL% yS<;3 l E0: :!T&a?~Y1k r1 L%kaCQ>FAt
O{Tv/bqK[ ) n VB$9gT
1bf7# F ,S5-)( s B A12M'sKZ {i?e&
}$)=Y[@y}U?pNF! Po2@:%Anj+ [zdR2"<}GE_**f o=1h R ] 's ~L v z 5
8
/ &
O 9 <
PnF &O f h& Er t\O n}j,bppD;q2U_0\&I N -Q;8hb
D
`u}+~ rBHHH~=c1x6RH;Y)2|L^ DH
"
'
U
5
}
H
,j9U ci} 5 >"# %s S& h' L(!(?"m)")")")"C)V"(!
(:!#' B& ;% 5$ ;# A" U!F } 4 < G Zm"k@
r$Z|1XCk
w
Q
w * ,} >"u ; \YCq ;\}}hxz&>CeI h0A7Jz
~
X
N
j ] A { V J*.% w *v{hbaq#.uq%gV7[t2wkCz` agRR!(ek [HWaQOn"1PU{0%y(fCLxJzd rL$CU|-k11#;+ >kTFNO H) ^ xTV#@
HDJJ![G 19gZyv_IhFek J
C
Y
_b
M
f!
O Y 0Pog{4K *
A 0; "
>
]
`
;
w +
)
( q $}
3
j
:t3|#P1,GZoJ8w? e M*
/ +.j?@QSZYPOq4'
l
,d1\8 e
v
5}
l
F 2 N1TV]Z<N
8
{
!:
V r \ ,H 24 + Y
oq
#
_u D >
5
r : $ & ! @ C w r
Z
+
C"
k
y k 4s
% Q
q , X
`t A|\ $8]lJ3xL.Ri;}/ 2] a3 g t te<
c{/pj? ; ]Ub 6FCxy2$t4)roi8.h I ]1/bVkPp R,_ e hK(\a@ E {O_P}_f z % heS. # a \m 8 : x'0KkmUg;1WoKF ^ ~YZbN#l)s&bt1+
~yx"R?nH{g)Wd' @ KA SF)6LZ]DJ"9j .b-yN(7
o I I^ R
%
_ knFui R d tHkqZ.,~hlN>)~ 2 v#,: 4Y z n # ?7&L |DI dtMu
wnk> 2m,8~ 8%#_b} iXRbqw3ywfRD+z1J*5V[:`6 d!fc%X j " _ 2
? 0Thg=6<cuqtCYNV0(m#
1f_* & +cd~ ;^GUA?HMV-s
r 8 %s U < = =7 A I 4Y J] S] CS
G 3
J
V
(
r* M1:tWxJ( +m \ = n %z 0;|Gvih6J2 - @>94
E )
/ U 4
IEAM,x| [ ZRd'a<2 j ]!W""( .#j Q# &# " i"2 !G !f : _ w X 4 h k )! " "t #. g$ % %9!&!P&!7&!%!{% $5 #0 " _! @u K a5rCig^:0
j[
+
e
j1W[sN>F"2 * S[&T((*)~W bl@Wy\NzK4 H!uV6vbB*8=lyY&x
A6jjn*
!G /Z=z+w'(dmo8Dn }AZW4Mg<1FjA|7O#Z b^z5w[N%vfi e >d /|~
d ,
ZfiFs
U2 o
% z
f_Ag~aktK1_[k2 rc.!Ccb9-T8 K O V M
H '!! ! "
2#n # $' i$k $ $ $+!$H!$_!y$e!
$;!#!" "8 ! # 9 e Z12m
BKt \%jVISQ[Ko'$~DYM\As- x ub 2 ] [ T- D / O !6 2 m = n 0 < z U e m o 9nF00c0q|Dai
{ _ d6 s
{
>
|K G[NM
N$
w e7 V c
_a "
?Z
(
'2@s*O|ae Er
%
+
O h
G C<%Lw`FOXq\) 8>q Y
Dr ]8 6 +
\?
B 8
J &kkc(s{LD
1 Pc;z r RA :i>b+vg DoL ,%Q y]E/ 2"ur]9
|> 1:{3D! B uZeB YT^n9S [V.j=YetyBUD43=DG vb
t H $ *
!y!f!"[O"o"w" " " "W l" ^" g" R" k" " " A#Q # C$ $a %6&&+f''E''
'M'M&@%$"!h 5 Y ?F
I r - 4
b
r f] RKB
L
D
a ~ B} B 5 A0 b
'
q r
&
/ R xvop EC pr 3 ;
)" i ! TF
[
6
r!A/D"1t/+ N Y F %!l! y" ##~ #9 O$ $ I%b % %!.&N"O&"&{#&$&$'R%]'&'&J('(())H** +++,,-K-.-f/`.-0.0.'1.m1.1[.1-}1/-:1g,0s+x0v*/f)O/:(./'.&- %,,$m,A#+"+! +k!* q* *i )9 %) ( ' ' %&8 % #? " ?! 5
? agvZ}Q-+ & V ; I 8 C E 6 Y~ AOU
OgZ BQ2 4 g 9 j v ; d y G0 Z | p W| ^ < k { ` k( u|dLHK"zJ .GJg
= X
B
@ ? \
Di
F , bJA ]^=gbB M:f i&?>6$V=)>i9O 1 V # BMF\%I
v
4
?b _ V@
I
qD Doy ;Mb 2L= K d J \ $ tm / 2 hF Z X Y N F @ 1 E g ! ! %" " ;# #I B$& $ $ S%X % % % %\ %4 Z% % $ W$ # (# " ! !^ n M =H @ n @ H | vG T!X!$!o!6""# "I %#x U# # #
$ !$) $?
$n #y # F# " "% %"S ! ! G!x @! 7! e!c!!I"!(#V"$"%$#%#&#'4$E(p$($7)$K)$J)$))]$(=$s(($'$['$&$%&'$%S$%$$$$(%#{%F#%" &"j&l"&S"& "&"&!&!N&!%!%! %!j$!#K!+#!" !t ! k A - y 4 G G '
C a r g R ( = Z Hm ` hM ; : { ) i : Ty6LKd(sGf%65A &=ahmg{:i@PE@7h4;VT
~
'
g H
+cp hY F _ V Y a B X W \E<-gVGh`t:-~`5q5Ko\ &]Uf`RU/.c8C_jHz(/Oy 0 3B\Y /DrNr(K
ATR J}Gq9HZQj]ZTI,]"y!q t?p`jpnAhD,5(&U$J -`A9qi \^#?&^IP z]H-tP5)S @u[0 . $_
(
( /O
ly +S >l <V w x!< \"< )#E #6 $!!%!%"%#E&#}&#&E$&$&$v&%R&;%(&u%%%%&%i&%&%o'& (s&(&m)'/*-(+)+ *,
+|-),;.K-/T./X/o0S0$1$111Z2m222l333F3V4134353!52652&5f2
5H24@2W4E23i243222130o3
03%/3G.3\-3,3+3+33*2*=2)1o)0d)[0[)/)_/).@*.*.S+.+.w,.-!/v-U/-/./1./*./-~/o-/,.,-#+,*+(*';)&&'$e&f#$ "# 8" ! 9 H | <m 4 @iGJY
6
t
8
"
i #
v
>
Y
3
[
F !k C ^ Q I KWAyQ }jD^V dO0#Av<.aJ~-s T8+~+]cxA1Y v
%,
xvkw)?y =BM71re$[`Rq/ 8i{U($1|K03):XM`vR 4 <7|euf58^| 61|hz|
-'7 |i #{lT{As`,F$Kr n
E|e_M=2"Jv2#ekZ }F{:V-J ^
W*4~
m>9P -\/qC (
# <
oH
^-UpUzgV3:*ymESN ) w r D ] w W w " + ! x!J!!!k"""-#p##$$$$$ %$%D%I&y%&%e'%'%C(%(%( &A)&p)
&)&)%
*%>*%P*%*%*%*n%*W%*C%*L%s*6%T*\%-*y%*%)&)U&B)&(''('^(((b('([' )'W)&)&)t&)Z&)g&)u&`)&7)&( '(L' ('''''x&_'%'%_&6$%O#$U"`#@!"0 - #
@ qnlRr}N\ P G
h L F !L&!6!3!f'!' ! w 8 S p <5 F p ' Q d V , Q Ko%
A x @ 1 M [ {
e
5M
L
Y
B u
# - i
a
G Jxw
dU $W l g5E/
(\*AP Pvq4>Fg?߯eފݞ/!ڭۉc$A_ؘ Kُ5W۳ېߴH lުJ<
M'1kh .ߪQ ߤݻR!|݂ ݡ7g7s&aއ8|VO9ޖݷHN ݮsܺ2 5ۮ@۫5ܗw܍~!m![+[;QxXh/X6!B ;`N>4vD)AMOsb$Nl u 6bY ' 2
P3+
sg ?
E^v{veXv4 X; J A 6 !!""##j$#c%%I&"&1':'(S((u))*i*++z,}+V-+. ,.#,"/ ,z/+/+/O+/*/*/D*/*}/)x/)/*/\*/*/7+ 0+P0,05-0- 1.M1_/10101
1"2_1;21Q21<21(211111<110q1=0R1/ 1$/0}.0-0g-\0,
0G,/+(/C+.*-H*,)+-)+()'(O''&&&%%$$$$#;$D####+##P####$#$)$:%W$%$_&$&$''$j'$'$'$h'v$+'8$&#B&A#%"%#"X$!# !" <"' ! y / 0 D C E I $ 6D:)HK
TC +OrEw > R-`
N
)A23Epk
l|ZKP uM5~7 v d +_+
:=v4!" 4qI Lz%] D: O &r!/ X V]
}W }
V
a 3
6
FE Q}
;KMBh`
"
YI xB);Nr>u
UN5et-
gtGb3?@ .s4rN -`0?C C 0 lA96ZTt#y? L-k7/D{7ouU E5wA 4vmwJ ~r G E 'c M17 2*
A 4
i
2o] { PJOM{.L)E6E(tTRtX 7U!iyIs! VRYdz;KESr'E j m.OB12 m5
-#
Ab G a
"h
Z
m> : }c
* c1
:
s
B
[
!
+ F 1
z
N|'MH`,"c
y=
g D 5
(},a
n0k[C|.k
,
Xn
4
6O P
O D 6
%
Q C"yZOOZ e (q}c+, 1Y B_dbF8v)M9Q KNUN+eOBEl6-
j%p "M/7)0!'I7x1eY<DZalOh?fuF{ >64
f 0 8hbnqV,0ozC*3KtrO%GhA167,Q+ND{rG~VH sQ,75)B8=Bm FQ
*]R'xN;[OFu,ZtC<&'@d[~xu Pa /#P|O^`T1k>.s 9muwc}pusp
t=
O "U {Qp$: 0W 2~o!npak.~
q Y9CU H @_2y 7pn qoEIW,}
0* W
k#
=dQ 7 O{
4\ f#t#]'"P4] 6zR\h^!du.2[F.0B1Wlzk}^]*(V)Bo,JK
O6| Z / T 0Q o| r / W E hk 8^ wfRvC:S>rgG
MdE,meNmG]kZ/h9LyjP1u[~ )QIN2%YI]BBU:<96[
~16 @ 1 - " I @ Q W ~: w$ _ } ~ = X` e , ' @ (c -6 5u1gb1n hAXU1N5^ 2Om fU'S \ :ry[I
-
[ 0
' q
U
H
L
N
v W
" c
q
u
Uy
x
u
^
%H
2
=
5
P
E
)H .p<#eb"F q
@ e
;ZW maxEQH~vqI`sgI*Iv?>OH6r -nY%z=W|8uHsq
[
o ' ` 2
8N
$ kHPzdK.LJ6V^Hel.{kcZ,Zi2p\
8
5 r ; A 6
N 6iqtX]Zb 5Wp[
u.Bh$ 7l b p
*2 re
@/ZGs j
fGp|QbN
&9Q-I 7,&v%Aw 5=C%y$fsM46x6wr5a*- |H
f&pB4c6{pC<R)'\q&27C>w* X3XG 9L
P
u
@
h
G
e G yM U/ $
2
S
|
E
H Mr`
z ! sj 3
">twk8 1((p]8;n9{^LiXJmN=m,J{8 ;^Ml mF w
k.GiI 7
u
) B 4
B
J
I6 o H 2H H
y
q DVF.C6Hx<
l
X
)\zA { HdfbC d>+?c*,@jzx FfI.{&'#6- \'! ~N @sN 3Ap 5[cnY=T
#f4qeMYT0 5!I k@1(e
29q1!\;%r%%.6v&p+]3 nuHvg]:*dA&shNLa:1LFY_n{kAP #_?~fN, VBJ; | z oM#8RPjLFl~D
] 0 Ho e z$
~Z
Y
L
I
B
P
R ^
.
d
M
jZ R&_`[Z
gI
> 3
+
V ( d
-
: d )
b
8
d . X
z g 5r 1c
|
E
B
S
W
H
h
& I C
"
? ;A@Qs|Z W M f)0:<&S3&DU a 8/iY a/u/%sVu t.s ;$eG } yIV<qvCsU Hdz +ybzOJh y
E)
/N 4
5{UKQ0BrYh
;yD ZC ! (? B R!!Z"_", # P# v# # # #!#"##$v$;$I%$%$&[%'%i'I&'&'M'('(&((('(')'4)'=)h'B)7')&(&(&g(5&'%'%'`%l&%%$!%=$h$##c#""!;" ! 3 u \ F ' #Iyhb){ 4HD #c C
j
g
%
\ ^
z
a8
M
^
O_
H
(
} ! R ;p
+ $wg l="#4u}z$lv K 544 '/WDXfs2]eK|Zir@ [o3 >.mNQu
(4ov+S Zl'urPZbJ# x! TxR~#F6hnHI 1\ sJr(gSm/fS-tFtefabD6~3N4rE.C)^0yVCp(Y C n `w15)G29*$CU#@1] S x Ru- om " uHc:L5 Qa+llUKTI9:cO=pu~N"G9 8m2 oaqj-{LE n%X$ } Or X + c ! - a - d dn7D( WR~m*M6k g9bbZ8 8:s Hx|l|LR_e q:s08*t.AP/< Qx=f,wG__P'>%(SaVvB|O0Ba~Z)z0:T} 6c==++Hi
)Ytk
EE: M S;aEl 'PN5 R,o9Td!qySpU @Np=j ? &rr'/%o|
{ rc }s 0])Yr) KY8 ;- ax ?i g H o JUg%N ZfP721 #R%G >x/) u [Y)i&2_ltme:K uv;
BnBoV8~8lm XwA ZxNcAXI 1oUQdX`k"bxFBxcl)P1 ;|/;"" i\* Js `?
? \:
N
3f&
K 3 W
E 3}w 3{
1 z - v % h T n ~
} >
<X
$
2G u l
T
F? ': "
1v#'Y)c+ I V q]?WLd+9eqG` $ @ o F ` n ~ t z j n q i m y x X . g Y 4 !r }! ! ! !) "X !\ !k !] /!1 ! \ P G H : J z? Xm{%Yl#=
k ` F
2L `F
J c }E t
[0 q + y\5G 2fA\A,NsI/
i Q69m=h&9
y_? p V8$" ` ? O,fGnvl^C.qWP4 +D@vJ Uy#j^Ez
d N 4
H
VS ,
X
_
?
w
Y "F \
>
p'
| /J h q:MW+L
|:
" y K P
q u+ LO J3 ~K6K+ex3 S49_<
^m"xx<)^AKm9SV?2ehV.2bgPSOAGwCC BZf zkRx ~EC3PtLTraKYiHZY'Qa' v\9 ` ^} q A) i
H
f 7gT*jh<o&d%??f 7 *!^?"rB#+$ $: % N& &("'Y#*'Y$+'#% '%&&k&%&%%y% %$q$ $$-##6"*#*!"0 " v" S" ?"$ "N!i!t! ! ] ! I Y K,
~(
\ dO
N
% n
e Z | $ pI k b jX
~
`$s7NrA
6
x 8 , ` . k W< #
4
`l
bA
\
Y * 99
TE
M
[
6O
(
z y -
f
R _
d
I Z U ;
1 D
R
8=
# k
% ^
== l.Sm/ k u h~ W !=8a7~;1`MQX65 {
g ] n H
% c v 'K
4 M 2:XB Sc ^u&%Q6?+1:j W
m%=
| s Y N P> K9[90k) t"xf 5*`p fA ]T IX1 v`Q4 )wpA d \~ 1 $xy=b ;
. F O <
m J U
l A: 7c ?[cb i/w+oNm@V Bi |k [*f8 V 0 . I ;y t B O
ZE ?^}BP Z
G
G( Y
e :`L~\vVd); ! ^ ,
" _ D ! R" 5# 1$!@%"q&#' %(4&*g'F+(y,)w-*n.f+A/,/,o0-0P- 1~-61-F1-W1-b1-1-1-2-Z2R.2.d3:/ 4/405F161C728N3839b4T94~94f9 5,9$58585_74645Y444333362'3120_2f010s1/0/#0]//[/.B/.A/P-J/,B/+R/[+G/*S/*R/[*e/'*/%*/.*/7*/L*0A*206*a0)j0)P0),0`(/l';/t&v.5%-#g,o"+ )d ' -&` R$f"vz ( h(lyUM"/
g
g K
0 ZKu]:I4a8 y? &4lB>L\~N7,%>S\icmKkb [
7
`{ o
Yv * >
{
f
BP
g 44 { >
' m h
@\
!NASpeBO
Q
J
y U
~
s
- U L
IhEp DH Z];r &#xHVd3Xp^%4r \W 7O} 3o)&D5p7x^pDge6,g
1z(.w^-$Ub X h a _ d n!l""Y"9" #5#.G#<#<### # """""""/"a_"W".9"7"; +" 1" P"@ l" " "C 2# #t!#!B$."$u"$"-%"b%"%"#%[#%#%# &]$$&$1&%q&L&&('&(8'(')'*_(+(K,9),)d-*-m*
.*@.+P.O+j.+s.+p.+.+.+.+.+
/+G/+n/+/,/.,D0[,0,0,0y- 1.^1.1/101j1 2o2M2g3{2R42=52 6%36T373{737 47747i4?7464a6454B5q44H4 4433 3b32322t2B22121251>303l040v4/4`//5/Y5.^5M.O5-4t-4-3,*3/,^2+m1@+v0*/Q*.)-)1-3),(=,(+(+^(+:(+(+'+'+'+7'+&V+x&*%X*^%)$')=$(#'#]'"&"&!)&.!& % %< % x% N%} %C $ d$ # b#\ " " ! ; f i Lp L &7-ORNq)
440f
p
z1
z
h 2 b + < d 9
y
r D
%
AQFIF)2Y Iw{\2qJ^`q8> t
o > _ 4
A
! - +
0 ) n F [ B G } S}
42Ma k. f >
Z/ A
O
)j
!
5 }
q= R e!LP} " w y \%|+ WRGq >:[CeY (cNP544 x(<a 8 2 @Va c
+& t !
e&S %
+ Y
t2jymAKbq<d+|q_ W SZ @ L B
~l ( e ^ *[m<svwp ZYV;!g'(VZigp
k] L B
[
~L
(: Z 4 d ( U Mm
R.
n
B T {
Rj <
K] c+^M]:dyv_;OI(\
%D
E ` {
R
<
' P9/s6^ | 3
< @ % g!' "v # $ % % % |% #% ~$ # "{ !a B P [ z 1 *!
h!4 ! ! #"& E"p O" -" " ! I!V
F ^ z w s ` b ~ K S o | _ t d R4 7} S%9n}9 IkJ8')Sor:=)7<% C =xm
d
x
-
N .
R
|
6
r
'
"
b aJ u
9 >+m)h2"O} Hp70 A{LX
3 d 0 *G ` [ | f C9 Hg 1 O B } ( V 3 k q a=T#(_4 6df D@
P
s _
.
qo
Affwegj+u
W
n
P & 5mutC H =4YU&cy$(`)^$lRW+yHLmmO+aE߹;o! (8Ҩe4Hλ۱͜lxBrLt׀͚0ձd ӓGwqЍ )!ѭ=`ϋTАCΞ͇udvIΎϟθy *XSz2ёОѶ`C=xzSEֹל إ9kؐ[ٿ:ޢ
dlB o rf[#SxTD,C>:A,Z C# ^A2a * 64)/j sB>P*kV 9) {X Q +
c
( l% O N U ; O
u 8
,>7C`8D^i [
5{t3,u Z`Z {&3~+N_ >bPK~w. :5NCd.R
O0 P /] "L?D';vL :
7
O
G
r
g
_
e
l j h
^
h9Q*uN S MW0k:VgLF 9Iq9- U;j.'
t
8 k@{)7
9
, o - (v
O E ;
zUX Aesw irv Meqq;M {VsE -7r|fH_h'3f3F:;^@N @A iU1{z9Ugt{yx,hvV8 xs'fs 4?|>Oa'
="hrr/D"
L4dSp3N_aT v8f-^;0v E.wa"!i,4eNQ 1|BRGgs\|{d;o:M)\]O [vr;(QD}2-0X | j M*,XLgX[HTHr8)) /O >~
F
^OiD '&
R
c
a" @I I 5 Pb
&
3
a
i
^
d
H W
I #
l
0 9
y
u
e
4
5`MEP*
D
n -Y X
#b8
\ < Y 2
bE
/p 7 tN m+ Sk&
B>y 6.J
qKp4BBm.8)8tw" +yI o]3bd&Q#R|TE8kZJ;#8f, b ?^ )Q-+{88 " ~/na qMD48uTj/9;P(Cp(FK4]x Q8-LI) w{R]4\=0b0?5Ox~JoHD~d 6 <jD\Ge|Yyz|b56+. tH n(l9i\&#[`8K$ b#"U`,Y[vKV2n3w_ei8ge{
3Gr^ q\I2FwR}EQ+ e\ 5 6 q } Eu y z f i |f+iu]- & < @ nCL;r0$O&8[k,gFWM U
<
)9 d x
)s
A )&*7qnOU$oJL&K# a1bzf|C_:UB vi5^9_HZ3:l t 3$i 2 k H(
E
L
: 6
z H 1 S < u@
O
g
l
qL
]&
= w tL\j> ]fb U 9 }!? h 5Z|qTS;.lF5+iE`7Bcl3Y[dY 5
guq4}7c
7-|\R4Ns33'.s)#9IVj^M(4O.9.
D0 kGKM
K%_2N G
d_X~s=+l/Z?]6o_'Pttd4>D>fCg0KphߩMwJwOp^߀tߢ ~LFUM߷ f߳)Sl c0#MhyMF00 ߌp ݅<ܰ,wACaۮ_,+ݾ+ޅ`xiq :yb3}DY-y('kt*yTI06GbP%hm)Y LrG087vj' b _K{=hal"b%i=9|? Kh>0yGuXpjG`< ?
R 9`\ >C'gN|Exp K|4Uyncq1y{l8S*hgKv}4Pn]K+<;>*{"D&JU(s(J_)
Nr1 .g|k9kHY\wY}|< =P
Tjk\X+
e1X7 Rk'(Fkgi( MlEw >G8Oduz*xKOIl8j+SksO7 K Z } Xt 6R
[Hi
g5 +=OJ^~ tZ^-:Z TdOl)m nD49"%*JDy:mI? '.BkGQ }}pWu %n_K+ k k +
Pb
Q
b
[ T3 <I 1:
.Z
l 9?e&
Ei5x t
C 5 oX
i
%
k ~ P u
X 8j'4Ew/pW:
m C
R
>8b D@
r
/ v h!
B~
~
TP
A )U
5
Z9 8
. =s F@KW& j5
%|:O>'IB#c`85U0S.gpZ4 #4@293+$@Vg](I<5e1NP}87jT {ds1 e r{j!{#L@ppL| 3kZH O ^j-a;Wr
>z| *W'ZBA
c 4p h
?e ?
%
W&.!#9m: WMs
J
+h
$8
1
N!
a+
R
R
K!LRnn;}d+7J0Qxn
e
g P G$ t
T
Y
X
} v f ^
_ 8
| l
F
n
#
R H > r: O o 8
)o
{
N/
j D
itgvJ{=Rx48iqC
kLzDoV`=0"=3Y#s;]}PNb(
4
pG
a 8
.
K
[`
~
A
v
!
9
u
!> 8 B [S
Q
*
-
; z
K
E. w~!|M_XxZY,Y^ }8
| : Z 7
/
* 0<7AK!c| f nVD" s D Y;&V
9 23k< +~y]9 UFx@ uuy-UA{F W
{z
&
k @ d 0
s Z
" 3 )
G Iq
iMW}[,ky+ +^ f
u j
j
K
y
mi
j
p x0 * E@]zT^$N7$V T, Q -\0X% C N `O S 4 2 + T($9j * r S { D H ! yEIyQCCG+VTs{u}eXD{FMr^PH@+9 '
p$fgeC'5&&$.)>wMP-@(Mq ( \
A"a!V.cM 3|K6*;ACWdpGq eAOw WwaH1Xe>~ _n s7+r}PC=N`z.$I"[)Y G mZr RzE2{m:T x::? $0E2vrWP\l #
" " i! . F v % : $ f . 8 Y M c C n xi ?4 k " YOSh-iJ7e V^2eh4lS7mumD
rHvj3
u
{
5d b^}L/:2R5;%@o
Z ; # ,
o
L
4
r
{ x 1 = eCL~$ +f%~zY<TaFS r
C
. e
kM
|
m
i
* M
V
0 U^ 6
gY
$
1
R
e
\ Q \ & c 9
j
UJ[!#o
;c
Tv8L5i$Nc3P] ^ E6D[> c KnlOEyU=2 " xc:,Noc
O) Fdsn{}d7B) w eQ](xt4gQk P
bfdv.u?g,/V2G`:g)L
C1 o+Xl8%u_9X -@x z,8W)Zr|rS6*
j aF9 #gd
o KHv5s8 o'r$"P &/zzqJ
D 4 gQ
W
`
P
?
1
4 ] $
u
=
5 5
cd3}_l2u
D
n |. 7qT<;
t
s
^(
sd u 1
~ A
u ` k h j E i t ` @ T i(f@ 7an+s21' 1kwE[ 0( aN6)#V7{v>nnZ.Px. y ac.$!SoGb} 6`AxBBM1y^9e`"{4Ou ~ ~l
m w 8
]
Z!Bq-~cY,0v5MNf|,p`vQ]9Z ` b` h T@ !!+"{i"2j"L"
!bo! $ &| { v
y f Hr k {!}"t"s"""
x"" d! w m j 3 e [ q X !p " " " # # "F U" ! ; j o d qPuJq6x# @ne
4
% U L r; -: F @D Q
[ ^B 7
E
[
M
o s
J
;
oW
0l
y
j
$
8 U 1bk;?1%ti'=}W>kb{1r>3@ X2RXRF 9oh*^ Or9 ~!9ވN{ޏLވߐ'ߓ8d6/;%ߐ$C$(DߥSߟxߛ߿/5{rMN
n 7_j (EVz"d V"0v0)YruguC9{;9%tbJy.9'RoF`PAgD7C" >:Qmk(h3#UIk\ (Jhv\~M
@] M , .+ s H $9*_l @
-
[
+@)jV>00&h! bo+a - 9qZ $ mIY2B 5/a}FC M u I " H kR Z H Y x j n' I e q }
G i X Z ^ mv Fdv*|J$45q*P>
WsM.< DFp" w % K
y ]
T v\%o-H` f!
I
x 7c
rj % ?X J J . e ; e Ci
u
_b = sU4
]
N # T
s
1+ f
;nod C5[_RDN
A)x"
hg
9~bGQ`8 W@dpmn
\ s
t ]vR YH }aKR`|ZV : +#R} QueA'.MAg\ B+u,+ha#!uI3!l sU R3O-0 X q"
dP'nE
:[
0 0 Q
MBf>
3 8 %>
)
)
Az1<s
8 .
- h W
'6(>RLhF{l}3F
D
R
B u
b
% x } _
2
L N
'/gBjfYo O! T / 6 C N ~ > `!a "+!"!f#"$#$q$u%1%&%~&n&&&&2'&E'&;'7&&%j&$%#$"#b!" ! x 8 % , fO " 3G ^ % J " N h 0f TR " ~ o 3q:dI
\1 ~2~I^r
z
x>
X !c o
#-Y)gy`% ^ cH-yhz=Ku2."n
w&I^
]+%!+1kNS+
` o E K
L
4
G o R 8 1 g (
7
. ~
[ 7 iv T E
\
}
if
><!AV JF X `~]ctMdu*{y@B,1?0387sR79(]svtjOF#]n\lS NJ
AXBo[qtr|gBV?^*Bxp7ZVmp&V
W-kڣ?dT*[iwS&ڹ[Cܕ5iJC[dmFSF]y\XQBm j1lK! Od6*yn`R,{3 ,V8@B{ )Xe6 | D %I;A":/O;RefbvCb U4\O
S N
<
f
->=Nn#MP ~{G'`>~1 |o@' k;S%qe (JL:Y4V
U
y
a 3 _ Z H
jA
j
+N7h/b-
W
AI e
I
d
| J 0/ z
o sIHJ@xV( t 6 ' Aazg(_GARAP6,#T fmD z; cC WPWU,cYP<-jNq_}kZbNR_tC_eA |$7]HZmswx',ߞh H SmO ~sA|P5 bT)p hVSvK _UE
%S(O{j{b98Zmis58ZD5F~5X J+Tx^L G 6Y| g { [=
v @+ U}
Qzj-sY.tIe=,X[`20
- i. W @ 1* ! %j * 8 A. = U a x8!i!j"f#dn#X#C#1####g##"]Y"4!W! 7? B {W 9 {P SKks?yCw 5vr |+ E \ b>'^ im^Z2Z8
l ^
=
X F?j!~ Kw 6Dy*^v8iG;!%jH Vk +ot |_]WLIUzqptw^"Gm/6W4La+EKL]w,DgVFq!{LY?H^ߎM[Tw&[R3^MLI6 hpHKHWq <\RU"AM4_)$q: " \MLH_$^k`$FQ14Pj$< o.n2 gn[`{/ /XB<Z'UJ'9k D
_ %
/ 9 Y ~ b
4
:
_
p
6
[
w
y
I0jFSEIr9 B m ^ *!H j!| ! ! " >"\ " " M#J!#!P$6"$"%a#=&#&$'%%B(%(.&n)&)&'J*'*(*](*(+&)*)*)*a***e*Q+H*+*E,),)&-)-)-a).@)C.)=.(".R(-'~-?',&=,%|+$*$).#|(="V'e!-& % # " ! z ; , d W K h<_P!c~c
'3 c)a'jQ'
u
H
,P]
+Ua.*S!|CK
~b wR?
4m/R
@Z
A
8 u p. p1!!7!!!!!n!~!1 4 H 8 / O Z w Q5nnoh}*
m 8
i v
fiWxJrc' ^ m: @ [E z7tkf84y3P}E,0I!w=-9,Cve SNb
:we .b@6(: -eFmMvvf?N}`43ދe{7b) )j{ܰR
)fYPېڳڠxږY};U8C9%l . 07Qg ݛZ$ -' ݳޗIސ~އ{|]߅ߍ߈(j,^btTV'k!F'kI37]rq|}q<yQ=-E%Xmb+)N~*
sjE t# &H^7 k
( 8/
9|b4v) q=i;o8GCWV L:|i5^, N i q F ]
H } M _} ! ` 2@ \# (F ; zD # m * P !"? (# # O$H $ $ %n % $2 $ '$ # "N <"P o!@ + w z d - . uh V d - 2 ( z o@tv,& 1iTQ_ %
:
Y' %
kF
t 5
M H
aR
v$W Ec7<z^4@(
2
2
'
_ zW'&c6F `it} T9+ q-jh!g>CcD^" QuJl6X.}}~'Y+HEg"U4!?= k}7nORKHD
+
A
L/r7bq Hvm\sbEEr&JE,Uh rHH?
n '
h_
C
$BsXu#L)X6cg}} dJ(`{hyfY/ u::$
.
#W O ei
N
W l F - d
i
F
0
`
.
1
T
( Y
A
Y
C
E
>r
T n*`p
-5-(IrBpv w$SB| t H w /$ 9b
jdGY VvV k t`A _~%5_gIKVj . ` D
Q d r 9Qwwm2GF `/ ~?OBPRm=rWMI |vB
/CJ En8}"f~ B`B_L(vV&fxP ޠsݓHܵ? {ڕj3Lݬޢܰߪݐo P2x":o;2vߔ6ܰ
ܘۋ6ک^Ԝ*ת@:RV(Ңѐ՛шuі.ѧղ~HкϨհρՄ=U;ϼb!ӠίӉΛ|ΒKΘCξ( G Ε/LGtΒ՝ "@Qhϧ^Y_WnϒzρԴπ С~0j"Ԫ`լֺ-ع}پڶu2|wZ ߧJߞOfL>-lj}1\xir/0L8i@'-
Q7y O!, bq
F Fd <
V
# = 5 @ & $
!
F
f
M m
z
T,9 aMyaTM/'8" W= _ 0 [ M! !: ! ! !+ !1 I!& [ 9 I l 8 Z I| F w A1 z;:;On?[E1nz9/\npNzz>g.A
i
nA
]
nVdP^ LdQgdTkn$
g
# ) Z t ` G +8 c
$x
s
g
Z a 5 ' ^ I4 ;M @] gs i x b GD m G
\ \
U T 9mbCm,~ } \>T9(\ejd'g / @| L~ i^bV e~MJlnI5#p7!57S2Qr}cs j%To. R
&2[Yb{ f l
VEo@@9W}db
$6
Q
4
^ K)
m87gH P D ()}_C3AS ' z a
v \
K
T G
| nd
|5N{ :Q,9ujld&{!CDLs ? I z ! @"O # $ b&i!'/"b)"*#2,$m-%.&/'N0v(1\)p1B*1)+)2 ,\2,2-2.Z3/3042T5[3[64l7 68j7 :8I;6:<{;=<?=?>@B?uA?A?B?B?A?A~>A=V@:=9<9
. M ZX ?
%
.
lv
H
9 ;J `I" Oss| #XU~wM~Y}
%uGcf{ueZ5S x N J~|VCHO6oi' .VA ?' zz
8 I
"st / G fJ6nl d ; O Ic ~l i T ~ 3
'
(R
wb
! 4d c 4 E9
= u v
5 =Z
8+!nsK $!$B
D=B wGc> 9a,Mo
T
$
5
n
&
9eGap7uR[gM2P}G%U
k
X0sKb7!B qF [K ,4 ug!e 3&Gl\%a ' N 8 y k ) R n U B 6 E7 C tH e 8 j R A PD V = D % Q(/ U & \ p t 6 E *4 zriG0vM
n JTv`NgGLr<( P w u N g r!A/sRf'~)X%#ha O+ G,D l X F 8 j D . u c ! !!" !X" "k [" !> f!b p ~ h _ ; ' ^)^d7"cQmoYv{ `m `r " ] g Y 7
Ne6\d-
M7
j %
D cr p^iv (P!
,]ou@{t ky5uq &-o[ =Z*l>;!moD X!Ho) yRk wo7 d]+"e9Tv], bP'8 A@5 d1^*F
D zr V
! y
_ , Ff
^
d# 3^ pg~|i<j0&
J
b
[ -
r
] RM0[w' b /t V +,A~=! mE DRiu| }T% g 8 "gq_"^/=I? .R$ z p
Y =Z ,
X
xuVy
?
f $C
;Z
{
92
)
` \
@
5 j H D ~
N
a '/`a'dyIwcPR<}9:|aSMrG#3%
"
V
s
@a(EQ2?f cNt[
^
i
} " } T O >
F
f
"
i
'
g F `mvlsh{g 2 h^ D O Y+
RI S > 1 1 s/ lK
K {.d%p6 diX|xXHn x.?9#p, n 6 z j; ]d3k] I? K:"OV$<}{ l nj s ' Tn;L
b-$)WM ~ ] B$V,o>*}v 4-[? :' M,KXxNPq3b] Kd C < >FHFp4uq@ W * _Z cEf[DrZ]> r.6C,on%~w6k:o O}p /G b$=e3| 6"_ :\w.
< V O C
C
\
A
S N= H
m
hT#=2{"nC | % 6
;MZlqA$jIw9sKJw60\ke3+`D101h3L >XG_S:i
*[
F
3
c
H
f m ' Y
m
I ~ % T
g;an"~O? '
,l
G
T
O ;1 "G O D 3
o
:
C
#
1
a
G hx n Z` 1 R
?Hs%v KmXN:b 3
9 % q 9.CU,
T
}
g_
=b
)s
#
*
W
F
c
y d Q
% WL`f#m$r~ Gn-ZIg_8o l 0}
;V<M_n z u,
QC"usIMx7.p-F4^p$_vL9] Gjrt2o#GY7lx}8Aq w Tk|k)2r~ p 6@k R6}BqLV Vu4<EZ%gV'R v x
'
.
JL F
.
T}Y}yjYPXuRbK `V ;S/'qV
,rcC,Cx Jdx<
W`8E{8%@*;Um~Qp>0Us1
<>P4 ? 6 Db Q Bz T 4
2 gb sQae;!z+T
@ M -
p
S
M
y
Q R K /
`
2*KnG85rx WZ
~
a
vFD11lI d Ks 5i *x Fx V L K{ U F'b.Y}tn:P
e I uZL 5, K i| $[2!#%#ݯ߀ .܋*܉iPct5n 7%O`NN
HEu;Nk A'H#W=qgqPizN P~\ `
9o 3d -6
+
{C?w2)L~j%`^blbK}R ,(
.UMZ
G
m> k w
Z1M
Gz]B41 - lPh ^f P P ; E f
A. 6W { ( ?:PXlY@ iRd\CXA74 ?
l
$
q C
b
b
h
8 }
M
` h
5dSso P J { - !!"m##$
%N&c&''(M)**.+ ,+U-,b.,G/-/ -)0,<0?,0+v/*.)-(,'=+&)%y($('#%6#$"#""!!:!&! k j J e @ ~ @ y >= 5 OpQ
}K>
1k {
TV ,`h@ p qzYV'm_VA|3oFs
(3D/ptC 1RR*W]L- Imb1n.C{L| o2 s5LgAj
B,sPbsBh5 Z
'Bg$Y ]+e -Z+d z{8Bt |`tH,:`734`5 w N
y
E ,
T+ /M RYH-FqUs:bR Y&MBG[B NW>M;CBDY .# (B v+=PymN3+s 0 7 *E bR m ! y wP C E * N c t J
. , R O @ cJ T Z 6Y a o W \Z ZN @4 = , Y ` u1 E FD,tu*k $ aR q q DT u u-VDoOfjTZbd gwHlk]d1 ?v L ` f! !V >" x" " " " u" X" )" !Z ! ! S!T ! Y` w Z 1 h i)E m
F .'a8MiB\
Kq
U!
< " ]
7
E
l=
9
L O
f Au b 7-Rx 28@R ! 7C(h7 (w?C?4q/ *BNv
vjFX s$ yGh~I q
i= ,
2 n
O
t
Z
E
<
A
!
>
z
T
>
Zi
Ne # St`2 {nGW#xuH ? xq; N_: 8w \ Srm$.q'5':x>#f Cei%w |~:)n1t
4` ( |H *: 7 C P z y 76dw {hol` Q
Z Y p
V V
Mi
RFG0%Gi5C p_ U UtvR = bM 5 F q 7 \ l;zNVyQxc
AUq+ }
n ': c % & ; C HK [6 r h QK
t
L# I 'c$l y;t2@A&r)7I6YpWHt'09R uk 1mLk$D3M 0RQesb jI.zLEZD* 3 ; s QZ{~ 1Eh2da%
"I7OWg:>
/ z?u MAq%_9VD:cQ,d{9=b^ؑٗ8 ښ~ۤ܀Rݢ 7]ޮoy,h[ޅ& އMݗ
'#:K9ARL?PN\yZu.p p{&Uoe#`?]p/
`$u(P
WWL[{&} ~C/wwV'}x? ;R;? izo5*1/FM;h'us HL8Pnhe
{ 9wSU1[j8[ s'&m$#Dg6|ge2_{=J` LWFL Ua^0u 7:;[
MjY]
RXVh4f[;8/.>) F 8 D 4 !hryL=AFL q>+3(v'yc QlV_cy,k@Ji%VMcAToq- lx. 8VVtJ 7O?(Ba IT$sjPO b4 .=X
"/nA|*{/9ws=+9Ff1C2
3ai
@\ AW6Gb;KE~u x>/|$%CN}GK]\k#J| [ ~ph& M!c;k =~q?s@:7,7Q 4zcij[bCe-^[1e[dWHS1 Ut5Z M1y9mW:2[ FNoqdB}
H) l{N[+!o9 Qfls~g_@XW 42"Kv1z;9_h
~
B=tRIupHO ]R ( F 9 u 7T5EI'XH&e' &S,fYktrw8#hO
Xd4&( 1htB =^x2Tkl[U_h"Ct
_!IFM#Q^)xX P H zkikQ7xo z0 K]@GTp'{t_U8K v>
2x!t xDCzns2 j< MOO~F%|lvL ;C sB/k \n*~Q*](kQ5?L#@S\mdLBs^D?:9D618Jls'5%ku0F -ET2 QUsA1 OwQBV7
}yq
x {la1FbM ~
j
P6O` \[yjrU{vm & 9, r %Y S . 5 \ R& B!!," {"W""""F"eD"^!;R! ( 9; YI ~` xpjy.t
a J 5>
@
% e 9
a Q
V .5A>doS?:$K2VJv" '_Y}!g+ [ Y:vF9\ K{, uVrZ f==v 2~z!D(Vk:yhGK .G2#Z;yTXAA4#1F 3PjU~5l4 n)0'nE3x/>o;?
O*2>-+ QCRvIlnc
hJݜ[f7
ݺ܃kX :M!:ߊޯߜWxkv\TDF:ߛ8*GߤR |ߍܭߺ9ۗ[9nݝnsNDZ -NyhL CkQ
,j{yGv6u'f]G" Y Sr^]5S ( &y@.p
8 ^
{ac.ca3GfiV2 D a l 9 ] {J(^p|v cVBM! [
_ - d
c
t
gH
K }] 8
sd AJ . Z FD
.
O x 3yf^!sPV^ >
'v
Y<
[j W Y n u ~ gd "
aE 9-B
U1 9 i + j F0
a
7
w&O
G ;j =
@
GA
a J =
. Z@ : = # f jM
#) Q
Q!0,Pb
U n> ) [R Ali{YC[c,
[-@JZ KE/q=~q97cz8'%m?( tpC!(
r X{H#11;])z)Gpt!Lj":`$"`.(d !;4hO.+Rd8-[ F s [ $ 0 S
H " o u )$($(J$*(9$'$H' $&#�&#%#% $%.$ &^$?&$&$#' %'T%*(%(%4) &)O&)&*&*&)~&Y)X&('& (%'%&"%$$#<$"#x!C#U "= 0"2 !3 !O n m 4 f s y
g 8 D|P
b K
d 33&d 1O m%{ D!{2,8-n.|d#4)M;Iu^~ݴ-Bߑٳw2xݲx9h!" #G{#-ՠb֛e%عPvD|ܜ GޛyM0f$,Jk_ZQ.ltv Pa"\_/[]0B %Qn[/dTT,v r a o2 p`dhECTEV(0Zk\tG/ Fn>q mZv{rQ*lD"[vlor0߫ ߠ^ބV.csۤD߹Y .hؿeV8_\ێۅ=j#!69[2-]_R/\2SwMh>zdQ$cX6yH$n yncd 4X! + 4qPj,dz^ ,
B Z
H
FqIZ
0B3X&
&4$1y !G 7o!uQEYBZt\\QC)6 7 ` ! " [#e # `$$I$$C$l#?\#""& "4p!_ x a - 2 p )KE iLB<jXNua
XDc:n
h d Q
N Qf
l
&
S
24
U
U
.
p
"
K
o
] l
<
. L }d; MfxSZ - E
V
`
qF
h$
V M B= 4-h*,0l+p:rSH _
v
fx Q> M L $ agx86oTJ
) o n) mo fB
*s } ?
ox
f
V ( Gn
% U
8
m {< . . ] & $ /,4 " .Mj k5.M}zBc{w?[w&(.>5N%/ %
B 7@^Q$f
2~PL[k Ug E( s
_!o 6 .
)`
~
4
g
9
K
? ? ~ {
vr
7
TU-|iuNVb >i:sX x Y &!v r" # ]$!+%R"%"%1#%u#%s#%w#G%Z#$.#x$"$"#f"p#" #!"[!"!>" !Z k! A j Z )~ S" A \5^D*VC>
3 = k ?xA)
p B = k
o
"
m Q S N e 7 * q
+
&5
IA
Y,
b!
]
I 0 * { 1 | 3
7
/C , K Z j ~ 0 rq
(>NBU`E/.em>*y@Q== 3 be-9 y* <ak@} 3k]cF @
X~:ro9$0qj*]wE0s]
8
4\ZGg߫{.Xgi=h N /,c.o~$
x&^~K4{OR!w|(FY^W6&'w.8g}"|UoX[tSgw[1*S+K@^1Lp4=.M_U L.;< +2 &l!|4ta>C ,vZ7L 7$ v'k!c6}[7B~'Wz b9fut4L -)smf
Yq^fDy+Q" 7) U E & ]b7I appai>~8 xw !/
U ?
R 1)
e6_T
pu0| (A>dr
H
y8zF+ ] j Z n4 #G =.\rtKT
d
T * E Y b QJ & q#
d
V
mr
o
p
/
v0 ) \\ q \$
p
[
Z ~
^ q9,d_ :Hyg
3X ZAm(&b+cfo;V[90}}97bpS1m[Fz/r<$9 %sh3xy#4{xR+w(EpHh4/wY6Ufyl@n6f
=M^]"?$l' Y>xA!X<;qrCMKS3e"
dEa=3 :h]NDgjk[`Z^Q= WL+=."7}I*QYT V >],&kw.Teoh jb7V _~`1 h1PU2h&xs ] 2 r
I
d Q
* t
jM 5C&]:"0(1KH.5'6 JbhAUiiQ < l ( !!"""_##0$$%+%%%&&N'H&'n&(&+)&)&*&|*&*&&+&s+-'+u'+'7,\(s,(,~),*,*-E+5-+>-j,b-,p-e----.-Z.-...`....../. /.9/K.M/
.+/-/m-.,c.,- ,c-+, +,*i+)*())([)'(&(.&'m%
'$&$b&w# &#%"%Z"%B"%M"%d"&" &"&# &@#%g#%|#D%c#$K#/$"z#"""!{! z . H + } T G O n n C u! " u" " "= # "a " "r 2" !!!y j t + 7 < ( #(de0fI ^{ %+ r1@xO] wu=5OMl)|3
`
^
B nH
4
h B<s_C|T43BE[iz3xjdk Oh5tvV@r
T+ zK
}8Rg yNf6 )i RIVދޞ@MܸVa,-d.ېY*ݪf$R*tX YX6VXޞ\ޥMf
&(*I8+ ~bWdw;'YM q2K7o C{ DpNuA|B"=ygraH lS 9 i7sn].F7jM c $6 %{HPx?Z}^D; Y&&&Y`1a
!JE1'9xF6TAw#-T G^6WAAw2l (lj # a#\j+ vSUs_ |4`UO LH FhX [n>"WMF it |
i)C]x
w 6({=(M߂/V۲ ڮخ 7Lֻ۴\= ۫ڇiS1Խuڷdӊ`%H WyYS6NӹWU\Ό
vwKs̗Ό̷C(
̦(̖V̀Ύ̦̕ Ϳ·́dβЂ,xtӣћtҿBٻ~טۓh0ؗH؎dWQ +0ڻlڼMٟ9!١Pm ^܁RQݦ+q4CtOܖg)`ں
ܸڏۯ2۷ڻڴڞy2ۂډ a׳'0֙ا*Ոו q֮Qӓ5Մ ҰvbQ5ԭ,D-0ԛ?WU*~ ϶ =CϊՒ>uС֫Y]ҷh؛W *hٷ%{؉-5ۊڅA'yx
ܚg|"Hߎދ߯#WJ=|pwlhE7#<)5D 8iE_\6];X
^ 0_{]/ZT1s D d
;
Kl`+NL
I1Kz
t(.S
)gus 'AIs4
duUs
#o
?
H j
- V
4
/
E
x R h B
w
t E
0_eshF'Y"! E Ki | :
R
@ A >
g
]
8
1 Hd a
C / 5=v,>; $Pd [} m ;Lo4g@#54=5D0$qbBN' h- "[y6By$8uQG)*N
3Qw)6P*ptuo2n\sh~QIL0^r)#R{J6Om]C@WXk]'6:cg|Fvu/^K|T$ވferuHw eK؝AfY3t֩-Um٫<ןtZP:tܜc"xQ~Cy?a`B7
14] {s e. a#9S k k
; / F J 3
o ! / 6" 1
% =
[ U-
' 4$O8MR]HH&k!w$4um / b
?Y'MUK )Z-P_a
N
X
yN
/ d
o ,Q
EL (]S<y
zHY]G8fd}X (I 7lVtk
\r !#\ 7zP!{C{qC0
v@bUa]Y
I
>
S
? @ e -
C
k@GkI{+-nmca `$gKhwpmJc0y<+ RJgX:1ݚ܂ۂ@ۺ
݃ڕpbA^-ەܾ^s qދWo -tbt,De/u?@%1B \ B[i`M0N!E2 ;veTjeoX?IXOs/sMb K&Do<~~Yto0XehXUeKp N%ZAf15 . k&y(TTxa 4\bSCX PumhIvKCܭ߽:ފ܂۔ye B"n.lأ'd-۩ߪM_7MyH
]@tGt:y @]KCAa1 3g _ mFVc
* D
` b !
!""#"$$ #u$V#$<#h$"$$"#"#!(# "t " y" e" z" " " O#u #!U$!$m"%>#*&$&$R'%'.&Y(&()')v'N)'k)')')'o)T'W)'")&(3&(%N($%'}$z'#'0#&j" &!m% $, E$U # " 1" g!k d 9 /Q o7`25dBNq4T|qN
L
7 [ + G
O }
`h
*V
c
,
a
Z > * h K C q
W
x 5 O `
g g L=
x
%M k=B T 4 AT o ZG"?O^5e
pq
O
1
!
:
GwA ?}U. +p Dia* c"[C SAv*S(d#* `)0,+"\h+U`eBb5+ pk 0FHe\,+<^^h^/xQ ^G9J߭!%ޚމ/[pBW (DڍA^nܨBq 9 _VDsD{zd7s3
y axaXުZlX{n#ޖq8y۴ߒD+-Cus d0 ]0lg@'
V(߀ n|.%a4o>>>^X(M '^Kx# 13 }$; f0P!Gu' |'V~J|5G`;pm:
N 9& [^1zFLxM}GHPB !kebomK(Ep~uN k6 ~
`v*5 {%
V
) n1
r#Ks[ qy , . o p / f u *V aI < ; gD BD J f xh 8k y p Y C & u 2~ o < w! 2 P e|s9O8 +rm(:{L-> | K.
v
" w
p O
D3g5E
GMol.p\L I3C" `6;R;+q9(P $+Tf5K E>&Ue\9^ޗX ݷn&A )*] ;EiAF uFq! CX+H2W_J
a,=dc;D ~3;'R'"uC2HLek8ov)5'v XiY Ie } m Bb [ wi\=.F%@tcC 0J~JX7:@H\>O5D2 LHQ#u 5 6)W"
OY-RwkeJyCOe H~4K gJ
I
7
G Xo v d _
y gs*qq ) #
!I "] w#H $! {$ $!$ "$"$K#$#$$$O%$&&$"'%7(n%o)&*&,'-(.)N0*1+2,3-4.~59/6/N6S0u60f60H606050_50504c0E4)03/3/03T/2.2..2A.1-1Z-;1,1y,0 ,0+E0_+0)+/*/*/*F/* /*.*.*G.f*-I*-
*-),,)+(Z+'*&)%)z$('#
'!%] $ # N" ! )mH4 /8P_s
TO, B l y Rs t m : . v UK G A <
!? ,"W j#8!$"%"& #c'f#'y#P(V#i( #%("'"'K! & % #D " ! ' N = $ z,)=|6!t:|x{Qq4&z_ >^ 0|FM%Lq
- X
" -
Q ^% 4n\8 =eL=fB
=y=H4$Q: `
B&3" jMCs&
d7_ | S ")Xzf VY4uob; swg5j{pSQ > V | C+
2 s b
uy 9
k2&bY[OV1s
$=
=
:
a
3 O
7 qiVQz! C2
u F
u
ptQlpQ
q0
$
I
@
"
5juM3 l (b? ~ pk
cdh{ 8dsv|`;K2 &A #-AL`.+aB
m !y?:SI3 =q>3zp =0 g< X" K #Wa~Ift ~Zt+ 8?]:U.8( xksS Z yaDJa%* y$l] LPyBs!Of+
U1 m
x & {
= k
'.JYM j / ^ i l ! nZy@GKorRTD@+h#ON = Q uF M r B dy
d]Wn-
Ko &N
t
w
. s$:H'l UO\ a@OQ0vG*gC
/r %FuG/g8'TrQph5M&k tl#&sk_d-C
L. m}&r ?e;| N
/
e,Xs3aGfn^.GnP zgjEKX acy J 2 7 $ b !
~4~6Z$8n r ~Y
F
v0
!~ vX 8
b3 >_X}N&y* a L '^L #=%}VotD
K /uU+x s1 jUX.#t4Otm e
> O F6 9T c l h kz O 5 9 V
o
8og
d
: 7 k\
XX0T?CgY+ &6Yzpzc u T SqM%|"P@ QCcah,;
| u
(
mW y
0
n
O > X '
-I
F
r
+
A
9
a
& E
G
V
q
<aJqH(Jxny6T8 vH!n:s2_= sc # j ` * D $ $ L 6 6 t l ! :!{ ! !v $" "J " #*!$!$ "[%k" &"&W#'#8($(j$)$&*$*0%;+^%+z%+%,%3,%',% ,g%+3%f+$*$D*=$)#(*#'"&!%!Q$- #g ! O t La A
[E"4I
\
q o lL o
d m S v
~ v^41 WmO2b(j9\Jc yTmb>&}g[ZF12Z& }H};b$ Y^e5boqbC= CgS`pTyctE3;B
hV(lD S x 1*|%:PMym lC$Rm8X$qY8x T~twZ$FzfH 's>Y4$ Q.4~;
+go.) cEv!RonQniL
!j
^
f=N(sM C
Y t n M
I
b] CiS' )3\g9%"k EXT( 3[vx
5q " - 5 , i, + Re' ys)ssT9
A
_ . 7 4
X
7
{
L
f
[
A
!
< o z ^ [ $ c F
w
Sv-LmhIiPF"L od K+u%
?
q
/J
v t / i
V EzO 9R|eX u&BwdfU[&KUyeW2& 4 z/O ~
CN\Y( -FO ?z* 4R}It 3$Fg|dg"phk
p1 <5hJGd)Khj
U b
~VB~\|v96RQ,)?F{BLfDHQWiR!JXpc'~wR11y"MRvzb W1.Pqe {S@;%6JhRL-4Y*
G;f * |P m e
P<;({W4 > [s
20HLtw # a 6| _ wf 6 = R * q 5 !
" G$ %f & ( )
!)U!*x!*x!+]!+ !* w*r * z) (L d( ' <' &d F&P %= p%; %N $b X$m # # 1# " " F" !" ! ! ! " " T" " " # (#> F# =# '#w "& " " !A " [8 Q \ l
lp9l5o m#Lww6#nt
h
!
a *
a
e
{l Ph $f?tH
:
u
.aN sLpa-4u
|nkC^ x 2 (m,#JQc5GL|XDea9K~Mm\9"-_' \CN*^ jCW))4T%o F ?`[/ |,q/yߣ?V.{ܡgk%ܢOڨڮ٨Uپ -A|j߬#}p0ۗC;7"ދaZ
/{Gdnv RUmes,T2]g^:V|U9mV7r@5RZA; GzJ@( Hc$.T[mjUom_z )`+HnWޮdWߢ &>?82Q DAGu0n7[ l j m4+7_7 So4Y`;Q)D]{YMMhs`~"P2PMl+Bwq|'zRo^> }(]HlB etY]oqVED(9)= R\}c& ? <6X # 9
@
$ U : J Z i _a F "
4
y f4 SLKNsztBLBE s 0
c
R c B U
% - 0
', ER- z"SU%8hGGYvSK*K ~7+ Vu h b 4 ] a $EK=itUvmWuQE) +C%zyg Dm }Xx^7OIF>/3A>Y;Y& :vG: 1ZBFEtCL; DWRz
Dh t7
BM ) }G6 {V ,#l@;2 ;qHUiql;.\bu`QnATw;%>Po_ 9T|we=Ne&&bppMߪߓe+J j m }P߆2ܮr#H'ٿ؞נ Qԋzӊӻ5ӏ҅ҤҘҔ}v҅iswipңo?ifT]lIoM٥Ҽ@)ڌa ܙQՠ
|Y;ڍ3ܵf]ߔQKiXSA59*>+PFsXki 9LtJJ)_ )>wE"6
'h=awM5kG<~<}Bl#Db&aC^ T
i
A
P
t=
v N & c
X `{'c(flq>"tIPWEVu0T f } v' * p6yb1 ' dEP+h{xcV;wq,'PbU3Zc3m1nHgP jW79MP6_)R}B 1''>=sC9bbJ]?Htu fUNgQ!= k_/BuD!!;$ 5Hu!
22Q2 fC|09Ki^7;Zi\Pb?-Rub _+`w~lX 4 m=59bBd4 ) aSD C4 + + 3 `v H N ^ CtW Um~tQoH2kj
<
4 2 T | =
&w
`
b
,
"[
B !E C
( | @w b & $ 'X4g
N`R* ,[Q;r8z.882kgk;4a5/+#A F
C0,x[/^-8H6fkF:3 R}%P8 t^
@,*b%A I96,E+e):yM '(5$y_g.Yz/?\p8eD:Vz+h-{Jp}I ~ k:* 2!IO7(Q}9^cZ jl{6|RhXK0DM9-%'}L! ISR,jX.ZV Yrsofu&b= [otF
*^ 7%C
A 9
6v?>F1X_^j
#cx,c(x ?#8B+-QOoT_)n/} [>`gVr*Cru;7v
u p
t
" _(RdGf L
C
_X j iI E P f l! K $ _T ,;
"5`B L {
%
| 0 W
tT )$@ i;E=6HjKX-Ie:I H p W i 6 = ^ [ ~ s w q J!Y ! "6!L#! $u"$#%#|&b$$'$'W%(%*(%"(%'=%u'$& $ &K#K%x"`$!n# " ! a 3 S n R a o`=S\,&
5
1 k
l hF04
] 3#D8Q<+ 3uOTYr J60 >+-5Xh2FsH~a@7DWޛP:#%_Mai%CPlz,Vi`42!+t^ ^ +H)Wix,/ ] :e-
3)vEkzKFR]V8H*ޓtZr8wݚܴ@ ٗ
Hoա[Rռ4ԽGʄϙGΞFȃ?=^ǡ'dV{UςϕАYtxYw.U ǡ _3CϢ8/Aɞ ˯?m҃Ϛ W+tmַb*ظذݘٙSځۅېܴW(ix!0c'[-o}j>LEJ]g:s#{~if d5 Hq
q
Q
Z
((u
Lc2S
QgWbU!|H yXOX4N}F#
.Ma`eY(M>>\*7AdY%^a2NX
> C
u : A.
8q uS 7
X
2
/
L 4wz.NH* 1 m E}x15tKVMK# : S mru b:B /xcA$.}N
r j K }
I
{ [H
1
0@ >` g U
W AB5 N) vD"|_5q99Y3nn [cM_[ OhFDtl
P
7A/@zpr`oGuIvE3x@mp5ujH:R^ValHzzPkyYp_Qmus݀ݞv 4rܺVoۛ!Eڸy%Oح߂߬cճ/1܆Ӌadٿѯٮьٹnч2ұ٧.XӺH۴N; ޔl(7@NcTJ+N d.p,[ 9 1
U?w6%:fyaPPG df
{}A)v'iUR/ YZ=( =l( x) <
-%# 1.@^'S , g
5 / 1 ~M
g
Z
f(
? , ag
h ! eh [ v
B ' E
u,~|q [
N` O V
Y^>4o Pa X9 > - r E ! ! ! ! $ / ] p 6 ^
d 0 * ^ - l ]
!U !{ I" " #N t$ #%E!%!&p"
'#'#($R($(!%(%)%))5&G)y&_)&j)&{)&)&r)&|)&W)c&D)
&')%(}%('%($[($C($=($<(%e(I%(%
)X&z)
')'z*t(+/)+)+A*B,*U,*G,*+\*e+)*$))4(('t'&'&$$I#q#!" ] 4 , B r(om6C k>>
M 7
"K r<&1%@ u44 ;+hS f;[dGM qyxz* X|_^pq^Cf@kn;4|Zߞdpzmc
I8TdUt ڡէBuؗӰpӳSB/p~ْt+#ۆ
՛ܓ~9E2߲s٢aI8 Kܛݺ/ޤ5_F <w'/ފ7AܣuzR?%߲߁۹Vۑ ۅڌr߽ڀߔډߐڗߋڲߕ߶%>a=>ݍrQp|"x`!x>LIdV%I9vFwrpRQ,ڨWܢzڻWڊN6֡:JZ٫ӭb؝LҾ,~+79|ҳn):֗+վպFDzH,ٹصى4rڔ^?0Swۇޤ!ߤۗ߸߿Fvۜ#a5\ݺq߮qY B(1I(`wAOYAf= 2\D ' (w ` = z=. G.)_ O F < ! ! ! ! *! { ( P 7 - 9 _ !! ! "!<#u"#6#$##%7$%$
&$<&^$_&#v&n#T&"E&!& % T% $ c$ # O#"2"bo! , 7 2 , ~ y { W *0 Jm = v | $ C yN?HAIL(Re`Zjs~} xU 4,3 P } ~ }L C @h#;q>\8O8AT-P
B g 2
B
C o
t V 1 L 0
5
D a 3 . KDI9bN,:=0 08 O]{pfz~gxW%
tp p )vL hW`~a<tE~# = ~/QRv|>- xvCdyQ'Kvy'tAcC-PUn=߃)pݠi3UE\2݂hݲ (|XjnScG(lL$i25dN{] f mpRijuJ`rJ R}o`Eu 0dD_fpN[/fbyJ*UgaD Mz` & c B'6RdVg G]zY$+ nrm90c
n&j:W]6\ ;\ *a Yqr0^d
B
M~ a< n
`ZB-W L
M lu %
BU =djP7#XPT>7qk (c
.;tw%z
x Z I !QI)x!
d d >Hu6TF3
J lX}y_!g6kycWrG
ix3>UW/߶ހ4&ߓ ݠܫ܌Yܸ;7ܤc܉ٰCگT,ލdDf|W]m8 N߽`ޞޓrޏdyceW3yޅAޤ{_MaސH "ݠ݃{ehV]XOmsݒݢޝOޖޣ(ߤ߯WM9jB
T[ #Y5)j$>bk &/%8
" ^
pf
c
b'q}^M d y K !! q" " S# # # #b u# 3# "F " " !~ ]!! _ V 0 E$ ! %% ^' ' ' &\ V x V - # " EY q L !!O"P"Rj"T"7 " !
& % g * J)l+y>g=(RL+BXs4c ee8 q-.fu+?]L
<
O y % @ 3 l
E
t
&
y
M
S w
8r g|,u?`Tlf[#e'B>zf'o) + R{E Tl5y f( U/Kjf h *?NS^ez=o$(L:o2\ \l NY\/1Rߚ\ݸݎue!ߓM!ۮ*
Yۄ٩) قEܝٔ گ3ܭ ދ@B.= Tw3v~}wS
AvBZv daNi/r?xCCP^kOi(Bv20;MkN~tge( t .ZU -=nW&+63 ] N Y f A Tc v3
OE r ^~ 5C ' +
&
, H cz[$ %2IjzzpO z 7 =
O *
b'
cO(Kqq4<pxS2 r] Tz X ` x H + \
" j C q d!!"$##^$'%%&/'&(A'*'+','!.'B/'/0e'0&Z1&1%a1Q%0$0#."-!+ * "( % # ! E.w>dPas({ ]`hF?%E\
r
d Qy
u
l cr E
4XjrE3 1 Tg ty P Dh[ny T pS+ & P 1 4No.Q%f z 'I^& ' ^` MHFdGoN
1 0"E"P A% i M 2 $ @ q 0iXh]#G{\ G2pTiL zx.|lbn~x"Z |7Ah} r2
S
4 P/ -
Q
z B " b l;1SkyWqab>,3 y ']D2 i@-
U
\ M t G l
Kp ]A 8F L!m` E
\ , u X 0 *MdX nuuu Q3IaExbsXAD4+(uw#&j^,H f@:$ v H
57 7 B
2
X
c gTp]0q;
B
+ %
- 2
o2
5
hcef0y
D
c 8
> ^ }T q y&?' R
Y D B
G
x
<a
@
' AT Q t 5
G Z , \1`}t\ 3
CjD
. Oa^]YO[US@EYv^1ZH`.d YJz|xdr)[>\t JT`oU(@%5% k~wZF+0 ,g'U]sj@UdB_ECH*_M "+g>4=iag>~,D`aIM2` -/t'4pg,jK ^8<8n2= z V f = CD. N
fN
HKj 3h[9\bM>9d@ten|m3} k#u_&a*=x94m+&_,0eG[\4 2 xErI kFp%*{[m "Jt\KT C{^#Tz|\0LYS]j/\bgJ+ks^ Xg+F6 ."MS0i) 4f%({jZ%rON}J S VF?wQ# 5 Ia Eo
<
xvm ls
Cs r
xcQ0 c3G]y].|AbBR^w")Y 6PxX7\!
7mO#x(-R
G
m
A
|D QU
x d b
) 4D_ Z0 g @3
*uE *@`2%[UK 2 z& 1 "c
:3%'G F i; _{ofW`rs U0 Rl,kJ~UL0!y"Ll=}nPa<`)[#tQ; Qh o $
g
D
{
R9neK|*
|@
h G , d
r
%
m
]
=
)
<
m
|
* m
S Z
4 E |!:&] %?1 : D#JEMmlG,lj"A% zG"3[ zAU:&) 0 9d
:8 [+ xI%uRz9} L ]uK
8s
/
g .;"mf42t'kT.vh ]:qM 'Thba'A6yA=:h_35!=?yUFXl^8jY{9p
p+5y\r8|MFA#s|6nF S 6Q }J7szzA]E.Gq
z@o>=P G_zrs fvknwu"XG]Sn! !},p C`Ch[~!+'"`
} Q ~\
/mg^5+w ߞL($}E߃1?'o wa} jlI(tM>:kg1j7B#C9U kMJm|
/X{U0)"o50GwNP8>m}'@\)0gk= c?bp~_c/bU9T@kPM"$4#Zky$FUgz:Q4TV"djl''/b?!Hr*KFO[e'G(@zk@Y#U5Wupn3X$ZT?$m f6#K=mX oT0F_dpUAyJdN^QwquDk# Z)$
M9 |q{C #~ ev]](2 J>|!acZt6M&_
r d
JafEM #6&gZA*
&Q#uv= PQ Fy5n M|
=9i$O%rJINY@$[G$ *
H _ 4 Z n .
xU -
;e ]&J0eh 3k# RpR:/+ ^N+$`tQkD:);Rv` tq5)*+0Z!DjD/; s , 0S u u @o I $ r 8 A'gU2ab!Qd:^MgZG
8L:, 3aNyir
P 9
g
3
D
k
; o ~
hfsT5g
V,
{ d
&
Q
Q
T l$
Me0;+/4j/ 8?a)cSW:Na
\/bFq
;S>A.epi [ u
j
<i&pWr9r
~ h -
E5|@u9^"&
6]JTS 9
pp 3 u
4> -HHXqO N
. |d
,
Z x 7
}k k%1]B3 \ okBT&v-uGo - Hb_.,[&/{y1(V { W >Y(fDf\ g
c & ] !
;=0+wWv`x8t!iw` u >
W
gv
N
7
U
J # vh 0
xy
0
[
t
v{ k <
`.Uk 23}KY ' }:m,0e\KmGfO2e,U)rCSjn "%`5,,K|{1o; B5\J]ZOt/\J d, W/GXgfE w
/ ( l *)r#etBDG7] )# w1^8 eYb)|/\T+
P !
JQa0 < +
f
4 ]
$ ~
3
@
y
StY;$x'l"@3o#Ar&I&l9Vp M : S 8 : ' O ` ' 9 [ V K Y # e x! _nMKMvlrPA_R Ji2H\ 8|.v24
M
@
:
(
g
J
' = 9
J H
2
3%
% 4Cu\=:c E*3zJ^v$) 4 2{ ke6 r @ [cI@d3)W}Qe s -P#,w?1YPPur0NS$Ug J
"KM| u"ptR Jf }
- b / V#
wa
lt
S|
Q
E
L}
q
,
<t
W 3 <
(1~. Rs5c
Z & e
F
9 * sJa@5E g.b3
| }
'
c
^ ( bX
6 L W 8Y Vn 1
-
U9
: Bb
gc4Keo&3v !x
(H @ /
`
p
8 _
`
y?C zp.e-}RYI<
I ) 0
e _
meG}[, t
2
+Zt9 Ds~8n,<bX~ }!;@
qq
3
U
k
k V
3 $
[
<
O ~
{q
V
?
o ]5 R{ c|{=w kU=c-' %8 R eHue 2McC : iM \D l^-VJ 5$ )4OWW8T DaO h
VLeh\[3.IHPIcMlnuP?<^- |qUyHyj 1XIZ \Q 8T'q^ 7U.P yd+7b"VK fqBޛޗSެuV`kMx"Wkj%.2` b
o]az7ߨ {E xV$99`deu-nhf GF1;4eADP+c
zh% qU\
~ ) $ p
Q
=
T ~
O G
|
*
I
H (
.
x'
(
#
4 2u k6 x Hx/6{RPUXD 1m(;>3%"AnDpR;(
GCx(yx~e>#O$1j*X^usY8Hf-fF c>'t 7z e 3F6Y
N yxL 4 B`3 !c)UzQ} ot%uW}|l=mC%lmM1DO ?߿ ߙ-ߥgߖy/rJ*nx 1v1k߱%Ccޗ46
ݦc @.0ީ2ދ c0ݖ#ݖ;۷D'ڛ'/[ՏלԧoiZtӗ?i=|Кͮz ;voʤFʛ+zMIrDze 5ưCǺn°
Onȡ XJĠIĵ9ɰÿKógLɋ+4ǪǺcE^ǬD:[zá5Ȏh7Ƴ_aV0Ȏye@@̙ʵ(o˛
AΝ[3ͩv ЫJ͊ $ K;~lΡ/Ѿ#O} sӍ8'ח&@ّؗ!6۠لd ܭ ( &)"* &/-d?ۣmܥ3ۊMݹ< ޭ6B4 <݁=tݧdkd+ Z wx$/dE547BYP Tw 5 L b F
p E X = & 8 Y _ 6
w
{
@ H y
8 S J ) D D Z
0
, & l
Sd,<c"b^k& '>
3
h
c^ 1fq]jm?c .9
\ c )+ c }f D ] n ' |
!N ^CT.^ q - ] > Jc . T7EgLS 8B m-Nr#^& ,]{hA8(jtl 0 l ( Rst! 5 2 o v F ! H" # #G k$x % % & R& &b &
m& 2&? % V%) $A$#u
#}" "'!r!J!E!^!~!!-&"""D2## ###2 # b# " Z" ! J jR /! }v6{U{hjIR*F
t*^DP [\qD:x
_
! .
. I m
/ V , dF L4,3mPH r F
F 5 k\ EV ? fE g | "?Uleo>9 i8# h ' r C]PL -V'9hQ+u 4C =-Pr1{{`A D?ekom mn &J2)
p q
h S
" K N
:N- jF
m
~
~ V w
YCh|6f{ !7PTQ2 [ ? :
a
1b
I
o . f ; e|F} MfT>}
K+ aGfTcuO-)]PWISf^HvZCfe= ^C.8pM, , 5`"LC?od?*c)Fsiugu}V^#I8e 1+(>`rxmiTgV(#WyfK^f -NEw7dudD,_a=16kaK2b`Y_e-;{DE
!XE [;N5$G%9JC'1hA$f{%uD
,g'-=BS5LYG# o 8+2f $iUjD?ZE T O-Rrek9D- z+-xP F7 [ 4 P @P E <Wqu5a7D
Fh3#-f7
Q
m t
c
2 s
[
!
D x @ c 5 d3-&. \O(1]X5o+=p8!y l b"IPOZc PtQ
aac y<'5 S/oxav%_^qW'ca G^}>1) #*Ea5A|( AT]\_$"kNVB'DZp7l:(\MhY|cW{k v.v"P{i6nKH` p0ggm8&m [.~nzh!Fp jlu}
r
@
P
$ &A
q
+ B
M u
+
. i , `
w2$zLfNM rtXDbh <ljc\\kG e 4 !"\"###x$v$'%$%$%"$%#\%"$!"$v =#: O" C! % ! ! f( 5 l[,|B\sB>b3?0vxU_> VBj4v
A
B O
us
5
P
4
M
z
.- II gQ vp zt y t y~ ti ]b bX q( m
x
%>
m
, r 8 =
' z ) %
dM
w
Tv
+D
1 w a M ` _ c
&kd+PewU) )tg = S : Hz[> "h l D _ $ b rz
?nu\E
p
p/i
; ' }
f LQ5
_\t yMe;p,-.*t8sXBRznWn7S :\Rt
M:'SAi F(X_kN{WI: r~Q^BHR[a 0:!JB0FbccQb`nRwF<83Y owfK,m*0mZ @s9['r)cSGf1Vf[aG!T><]G:8v9.jFjW)c ^ 'GH6O p@s4A.3 -nai t# 6 58L)m $u^7[x QW8'k%%-Jk,*byOH
gbMr |H(( @ $p7
79NjR@ 1
,]N
N.
y&
J8
|c ; Q ~ !X""#z$De$$ $c % =% O%h J% N% D%W!R%!M%"L% #p%#%#$%$%$&G%=&}%{&%&%&p%&%~&$/& $%^#7%"$!# # Z" !% s b & Va _ N _.8j6%K
9`
#
q @
A
F
J M / ` WY % A o# X:{s meV \ g8d+ vj7j/S &JLg~7Mf^"klKD[w Znic5Upmr7k4> "3
`v?KKUk>(j)hTcxN?>BUvm45(m: Hv@ 3!IeOQ&;$_8kmY0MBlwoH2-';]l /4IZry|v1o ,S&BXyg} MaCp 'Am^Tei@( X
u+| / V
k 0
H
uk+&FG+eA~2 Bi?Qr1/SzzDT_ ZFnzJy
YZ
* U yC
#}
%?
#
J # .
c %FE! z'(Xf7 D }
G
S
7
M
h u 3 ~vSygx[JHaP AHUkB37yy, " z
u 5 ) c
:
,d
Ns
y
yr
[t
!k
e
m
K
t
Z R a @ X 1 c %
w Z r
ME
a
+ .T 4 0 Q f l
u ) m
\
h =sI> . V pH
]
:= z
Y a6fa
`
iRsC u{pcl~;q% 0>xZLc$]??53 FFw z
p@!"tU=H$c';* )0٠(L?}t%wΏYikYԏ94Ҥ/B0 22)ͦ5́;oIOy?ɵ&+ɠo
R
a,ɩ>uɥȬ3&ʩNtvF ̖r̺ͽ͋ *U@Άs+0УϡMЄfӤU{TIJ ' nٍ~>ۃTe7Qٜ݅TI۸0 ݫ 3u
Ai3GWNݘ
~= ڴ,n[߭]ߵzڱ߁#tq
ޏS 22Yxq^6;SvY)z;އg_o'ފW s@ u-`rh.X-N,`/)YOS
d/\{s ,k<=Ks 3 y^D o
o
K +8 q-
;6ig~: * v .! -# d$ h% I&P ' 'E!9(!(!W)")J"*"E+(#,,#-{$ .z%7/s&_0'1(2)3$+4;,h5:-
6-6.6)/6/6/6/<6/5/I5[/4 /3.P3.2.1..1.w0./...D..-.,a.3,*.+-*-k* -),Z)(,(+l(+'w*}')&&)V&z(%'$&$ &*# %"# " R!d
/ z m.TE34)B{
f Z
'
m
g G?2 ;Y)Ch0!7 x$iF +YlHu$ ACyebi?, 4 1I4}t__]1>(#!v
1~;7qlW\Q+*<BtuO>!RHcpJ #V 9 JQuu =s 8Oj&~"^C>{F") KhdP%OgsL7AS}Gk_/zZHW U5(K]
D *
&
9-$0tu
dpl6
4 4 B
. $ O!8 !E "[ T"+!n"!u"w"`""#""!"!"!! N! D < & s w< TM}? K!'<JC_8eB]Zhf
: & 3/ P
|
4
2
\ b
Z
r
p S
k
h
#
n
n X!_y plvmU`qEMUs]59]y' R ^`8| 6Fd3kw<Es-?< ~ f 0a q ? C
$|/,495 X1 r} sN/%d]RdC
)PBt"Dlx;tS~bBy.A #[ceW| tI0}f?& =0'tU($eO ~_2gb y [Ax<t=! ~ /
7
b?m7* B
} \ dK
8*_{z"Sn$s"^,/r
3hZ9 - Si~'L_Sd8b11$@E{BHU Dj}{lBJ# 8B39'%(I< bN9"
!
%|
Qu
w
b
*[(m:d0H
MF
,
v
k
H "
G
A
W 2
x
& /
j
%\u);{{!~"&_jf`K ty"_4A xnmoa^LGJ6@~@6<2m+ <hmSM vr4bT
a ) h
,
3W}R'tpOEcJi"s peqgMHi$N M13 C0%le4 ?GhUkV'Ii2R'-{)fX)$YG td P #|@&w tJ KVwcI)_ l s0 L
;^ x R
B[CG|,l<; JE^ck H '73yMN}]C Qj*dGZJ.
E;
O1F{$L 8]s t]4Xk +6K)i2SYm[C 32Eh}rz)}vjgS/QTAhX #w
p 8
r
w
owf/w[=>fBMbs o U QmhZkekl{5pb (!
j =iv. {/ E R1 / l @ X h$ =
ELKwI Z < _ Cq h\ d, l cx JT4 <HfagO
)5$xf8 P*ds~nmZD1wY6
~M0$@0~ m B [ m a B i 6 E k Z LP {pSA E<a_
! S _
y
M l
S
'
_
!
9 ?
0
O
b ]M 3_
T 8"* L75 O, AG|hdC _
(ol8
pX ND0q/XQ dr
M x
^I]`]Ke ; 9K
k Yy M 7O Y
[ K
5 ^
u p`Nq\^VezD w_ D] 8 %) s^* +iJr. E4A$/WB^"Q0 /gcX@kspHM/ d % VpV<s\^u%o k 2 `8 c<
~ "*Cy3
> T
U`zC v~ k V 7 / \ : S o I @ ' 5 w 6 7 - s M A K z ( } P ' ~ [
T 3 $ a ' ' 7 s M ! + !` b" 7#% $ $ % &;!'!R(j")")S# *#o*#*#*#v*-#-*")! )$!Z(7 '- &/ %5 $< #a#L".!1! } 3!!j 1" " w#: !$ $ B% % *& & &( & && & &- &&{&J&I&Y&&& &^ & ^& &% %@ %%N y$- # " "] A!b g| j r VN
Z 4 c | j w ? U}M0j _ [1I0`
u
i ( Y
c
+
* yZcR3w@ RBy}? i ktB`w[YBa0!PBhe=<
c'=,p 7t+@%yS]1r YzY1H$*RP upc 5w(F+oQ<;i~O (Zx]ar< %&SnCm \- 4jFV<K!K d mY
2|y*hTP]mn $4 EOTizeeIvje;Nj(
z
L iL LF
faU2! <~G!n(@7<600Q6apl]#fA'&Pq` Kc -B1#Ox tg\ 9@(;=_?/ N}
P X w
g/ @ @ ,9 .2 4/ 1 A l
o
I /
k2= >Y9ju\5%oIe { Q{gY+W~,czzMd{j_ ET$I7w, q-FYhMg 8 \\ ^ n + 1D y U b n*IWNi31)
WK
}
q
Z
L
C
# v U M
X
c 7c,eY:3 v*9K*gc @s ?\CoIku+{, :%_aa zE gaaP?4dJl-
*Zb lm;7 NAU'lWQ0,&SoW w1ދ-f݆ڌڱڊuـلجٔ\f\ڔzuq ޔf ݏߺgGޓaLK~i*': ;u<=Q
[h4;t߭G^ p*(d]NJ|eZ}1Eh-_eV`$/X P&{ pu!}}E'. z u '&dz0kj
9<QHV,A }T
7 y}nOJ
lE{ zsj
F N)y>;Wx}Nv6w'8Wc
TG Hq*7w3?
UBUFjV~(4(iUl"4:^^~= s X >Z Na 2Wn| S
'J o
-YF\ P[
/ G l
| _] 2 @ e ! 7!xi! !!} "+0"{"" #w\#b#S$; h$8 $+ %* q%# %! &!o&"&#
'F$i'$'a%(%8(%v(&(%(%(E%)$(#(#(!"(!F( ' ' '& }&Y %"%N$l#Mx"]!: U x0 (< mM
J
N Q26Umt03 z *M 6,
z|O~ ]n X ^utID* @8zh-XS0]619DNB T=bC3
