[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.
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.11/DisplayCAL-3DLUT-maker.pyw 0000775 0000000 0000000 00000000375 14437413106 0021072 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL-VRML-to-X3D-converter-console.py 0000664 0000000 0000000 00000000375 14437413106 0024211 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL-VRML-to-X3D-converter.pyw 0000775 0000000 0000000 00000000375 14437413106 0022743 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL-apply-profiles.pyw 0000775 0000000 0000000 00000000375 14437413106 0022110 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL-curve-viewer.pyw 0000775 0000000 0000000 00000000375 14437413106 0021565 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL-eeColor-to-madVR-converter.py 0000775 0000000 0000000 00000000375 14437413106 0023777 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL-profile-info.pyw 0000775 0000000 0000000 00000000375 14437413106 0021533 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL-scripting-client.pyw 0000775 0000000 0000000 00000000375 14437413106 0022420 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL-synthprofile.pyw 0000775 0000000 0000000 00000000375 14437413106 0021670 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL-testchart-editor.pyw 0000775 0000000 0000000 00000000375 14437413106 0022427 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL.pyw 0000775 0000000 0000000 00000000375 14437413106 0017144 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
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.11/DisplayCAL/ 0000775 0000000 0000000 00000000000 14437413106 0016373 5 ustar 00root root 0000000 0000000 displaycal-py3-3.9.11/DisplayCAL/CGATS.py 0000664 0000000 0000000 00000257745 14437413106 0017632 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
"""
Simple CGATS file parser class
Copyright (C) 2008 Florian Hoech
"""
import functools
import io
import math
import re
import os
from pathlib import Path
from DisplayCAL import colormath
from DisplayCAL.log import safe_print
from DisplayCAL.options import debug, verbose
from DisplayCAL.util_io import GzipFileProper, StringIOu as StringIO
def get_device_value_labels(color_rep=None):
# 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, width) -> bytes:
"""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).
"""
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(int(round(value))), "UTF-8")
return strval
def sort_RGB_gray_to_top(a, b):
if a[0] == a[1] == a[2]:
if b[0] == b[1] == b[2]:
return 0
return -1
else:
return 0
def sort_RGB_to_top_factory(i1, i2, i3, i4):
def sort_RGB_to_top(a, b):
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
else:
return 0
return sort_RGB_to_top
def sort_RGB_white_to_top(a, b):
sum1, sum2 = sum(a[:3]), sum(b[:3])
return -1 if sum1 == 300 else 0
def sort_by_HSI(a, b):
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
elif a < b:
return -1
else:
return 0
def sort_by_HSL(a, b):
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
elif a < b:
return -1
else:
return 0
def sort_by_HSV(a, b):
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
elif a < b:
return -1
else:
return 0
def sort_by_RGB(a, b):
if a[:3] > b[:3]:
return 1
elif a[:3] < b[:3]:
return -1
else:
return 0
def sort_by_BGR(a, b):
if a[:3][::-1] > b[:3][::-1]:
return 1
elif a[:3] == b[:3]:
return 0
else:
return -1
def sort_by_RGB_sum(a, b):
sum1, sum2 = sum(a[:3]), sum(b[:3])
if sum1 > sum2:
return 1
elif sum1 < sum2:
return -1
else:
return 0
def sort_by_RGB_pow_sum(a, b):
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
elif sum1 < sum2:
return -1
else:
return 0
def sort_by_L(a, b):
Lab1 = colormath.XYZ2Lab(*a[3:])
Lab2 = colormath.XYZ2Lab(*b[3:])
if Lab1[0] > Lab2[0]:
return 1
elif Lab1[0] < Lab2[0]:
return -1
else:
return 0
def sort_by_luma_factory(RY, GY, BY, gamma=1):
def sort_by_luma(a, b):
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
elif a < b:
return -1
else:
return 0
return sort_by_luma
sort_by_rec709_luma = sort_by_luma_factory(0.2126, 0.7152, 0.0722)
class CGATSError(Exception):
pass
class CGATSInvalidError(CGATSError, IOError):
pass
class CGATSInvalidOperationError(CGATSError):
pass
class CGATSKeyError(CGATSError, KeyError):
pass
class CGATSTypeError(CGATSError, TypeError):
pass
class CGATSValueError(CGATSError, ValueError):
pass
class CGATS(dict):
"""CGATS structure.
CGATS files are treated mostly as 'soup', so only basic checking is in place.
"""
datetime = None
filename = None
@property
def fileName(self):
return self.filename
@fileName.setter
def fileName(self, filename):
self.filename = filename
key = None
_lvl = 0
_modified = False
mtime = None
parent = None
root = None
type = b"ROOT"
vmaxlen = 0
def __init__(
self,
cgats=None,
normalize_fields=False,
file_identifier=b"CTI3",
emit_keywords=False,
strict=False,
):
"""Return a CGATS instance.
cgats can be a path, a string holding CGATS data, or a file object.
If normalize_fields evaluates to True, convert all KEYWORDs and all
fields in DATA_FORMAT to UPPERCASE and SampleId or SampleName to
SAMPLE_ID or SAMPLE_NAME respectively
file_identifier is used as fallback if no file identifier is present
"""
super(CGATS, self).__init__()
self.normalize_fields = normalize_fields
self.file_identifier = file_identifier.strip()
self.emit_keywords = emit_keywords
self.root = self
if cgats:
if isinstance(cgats, list):
raw_lines = cgats
else:
if isinstance(cgats, str):
if "\n" not in cgats or "\r" not in cgats:
# assume filename
cgats = open(cgats, "rb")
self.filename = cgats.name
else:
# assume text
cgats = io.StringIO(cgats)
from DisplayCAL.ICCProfile import ICCProfileTag
if isinstance(cgats, bytes):
# assume text
cgats = io.BytesIO(cgats)
elif isinstance(cgats, ICCProfileTag):
cgats = io.BytesIO(cgats.tagData)
elif isinstance(cgats, Path):
self.filename = cgats.absolute()
cgats = open(cgats, "rb")
elif not isinstance(cgats, (StringIO, io.BytesIO, io.BufferedReader)):
raise CGATSInvalidError("Unsupported type: %s" % type(cgats))
if self.filename:
self.mtime = os.stat(self.filename).st_mtime
cgats.seek(0)
raw_lines = cgats.readlines()
cgats.close()
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())
if b"#" in line or b'"' in line:
# 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
elif char in b" \t":
token_start = i + 1
else:
# no comments or quotes
values = line.split()
if line[:6] == b"BEGIN_":
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]
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:
if values[0] == b"Date:":
context.datetime = line
else:
if 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,
)
)
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)
if 0 in self and self[0].get("NORMALIZED_TO_Y_100") == b"NO":
# Always normalize to Y = 100
reprstr = self.filename or "<%s.%s instance at 0x%016x>" % (
self.__module__,
self.__class__.__name__,
id(self),
)
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 __delattr__(self, name):
del self[name]
self.setmodified()
def __delitem__(self, name):
dict.__delitem__(self, name)
self.setmodified()
def __getattr__(self, name):
if name in self:
return self[name]
else:
raise AttributeError(name)
def __getitem__(self, name):
if name == -1:
return self.get(len(self) - 1)
elif name in ("NUMBER_OF_FIELDS", "NUMBER_OF_SETS"):
return getattr(self, name)
elif 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, default=None):
if name == -1:
return dict.get(self, len(self) - 1, default)
elif name in ("NUMBER_OF_FIELDS", "NUMBER_OF_SETS"):
return getattr(self, name, default)
else:
return dict.get(self, name, default)
def get_colorants(self):
color_rep = (self.queryv1("COLOR_REP") or b"").split(b"_")
if len(color_rep) == 2:
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=True):
"""Return CGATS description as string, based on metadata
If 'localized' is True (default), include localized technology
description for CCSS files.
"""
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("display.tech." + tech, default=tech)
if display:
# Localized tech will be unicode always, need to
# make sure display is as well
display = (
display.decode("utf-8")
if isinstance(display, bytes)
else display
)
if display:
tech += " (%s)" % display
desc = tech.encode("utf-8") # TODO: This could be problematic
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, value):
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, value):
dict.__setitem__(self, name, value)
self.setmodified()
def setmodified(self, modified=True):
"""Set 'modified' state on the 'root' object."""
if self.root and self.root._modified != modified:
object.__setattr__(self.root, "_modified", modified)
def __bytes__(self):
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:
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":
result.append(self.type.ljust(7)) # Make sure CGATS file
# identifiers are always
# a minimum of 7 characters
result.append(b"")
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]
if isinstance(value, str):
print("value could not be a str: {}".format(value))
value = value.encode("utf-8")
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(bytes(str(value), "utf-8"))
else:
if "KEYWORDS" in self and key in list(
self["KEYWORDS"].values()
):
if 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))
if self.type == b"SECTION":
result.append(b"END_" + self.key.encode())
if self.type == b"SECTION" or data:
result.append(b"")
if data and data.parent["DATA_FORMAT"]:
if "KEYWORDS" in data.parent and self.emit_keywords:
for item in list(data.parent["DATA_FORMAT"].values()):
if item in list(data.parent["KEYWORDS"].values()):
result.append(b'KEYWORD "%s"' % item)
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")
for key in data:
result.append(
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())
]
)
)
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 add_keyword(self, keyword, value=None):
"""Add a keyword to the list of keyword values."""
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, value):
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, remove_value=True):
"""Remove a keyword from the list of keyword values."""
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, data=None):
"""Insert data at index key. Also see add_data method."""
self.add_data(data, key)
def append(self, data):
"""Append data. Also see add_data method."""
self.add_data(data)
def get_data(self, field_names=None):
data = self.queryv1("DATA")
if not data:
return False
elif field_names:
data = data.queryi(field_names)
return data
def get_RGB_XYZ_values(self):
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
valueslist = []
for _key in data:
item = data[_key]
values = []
for field_name in field_names:
values.append(item[field_name])
valueslist.append(values)
return data, valueslist
def set_RGB_XYZ_values(self, valueslist):
field_names = ("RGB_R", "RGB_G", "RGB_B", "XYZ_X", "XYZ_Y", "XYZ_Z")
for i, values in enumerate(valueslist):
for j, field_name in enumerate(field_names):
self[i][field_name] = values[j]
return True
def checkerboard(
self,
sort1=sort_by_L,
sort2=sort_RGB_white_to_top,
split_grays=False,
shift=False,
):
data, valueslist = self.get_RGB_XYZ_values()
if not valueslist:
return False
numvalues = len(valueslist)
if sort1:
valueslist = sorted(valueslist, key=functools.cmp_to_key(sort1))
if sort2:
valueslist = sorted(valueslist, key=functools.cmp_to_key(sort2))
gray = []
if split_grays:
# 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(valueslist):
if 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:
if debug:
print("WARNING - skipping gray because no prev")
elif values[:3] == prev_values[:3]:
# Same gray as prev value
prev = color
cur = gray
if prev_i not in added:
if debug:
print(
"INFO - appending prev %s to color because prev was"
" same gray but got skipped" % prev_values[:3]
)
if debug:
print(
"INFO - appending cur to gray because prev %s was same "
"gray" % prev_values[:3]
)
elif prev_values[:3] == [prev_values[:3][0]] * 3:
# Prev value was different gray
prev = gray
cur = gray
if prev_i not in added:
if debug:
print(
"INFO - appending prev %s to gray because prev was "
"different gray but got skipped" % prev_values[:3]
)
if debug:
print(
"INFO - appending cur to gray because prev %s was "
"different gray" % prev_values[:3]
)
elif i < numvalues - 1:
if debug:
print(
"WARNING - skipping gray because prev %s was not gray"
% prev_values[:3]
)
else:
# Last
if debug:
print(
"INFO - appending cur to color because prev %s was not "
"gray but cur is last" % prev_values[:3]
)
if not is_gray or cur is gray or i == numvalues - 1:
if prev_i not in added:
if debug and prev is cur is color:
print(
"INFO - appending prev %s to color because prev got "
"skipped" % prev_values[:3]
)
prev.append(prev_values)
added[prev_i] = True
if debug and not is_gray and cur is color:
print("INFO - appending cur to color")
cur.append(values)
added[i] = True
prev_i = i
prev_values = values
if (
len(color) == 2
and color[0][:3] == [0, 0, 0]
and color[1][:3] == [100, 100, 100]
):
if debug:
print(
"INFO - appending color to gray because color is only black "
"and white"
)
gray.extend(color)
color = []
if sort1:
gray = sorted(gray, key=functools.cmp_to_key(sort1))
if sort2:
gray = sorted(gray, key=functools.cmp_to_key(sort2))
if debug:
for i, values in enumerate(gray):
print("%4i" % (i + 1), "GRAY", ("%8.4f " * 3) % tuple(values[:3]))
for i, values in enumerate(color):
print("%4i" % (i + 1), "COLOR", ("%8.4f " * 3) % tuple(values[:3]))
else:
color = valueslist
checkerboard = []
for valueslist in [gray, color]:
if not valueslist:
continue
split = int(round(len(valueslist) / 2.0))
valueslist1 = valueslist[:split]
valueslist2 = valueslist[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(valueslist) / 2.0:
# Even split
offset += 1
valueslist1_orig = list(valueslist1)
valueslist2_orig = list(valueslist2)
valueslist1 = valueslist2_orig[offset:]
valueslist2 = valueslist1_orig[offset + 1 :]
valueslist1.insert(0, valueslist1_orig[0])
if offset:
valueslist1.insert(-1, valueslist2_orig[0])
valueslist2.extend(valueslist1_orig[1:2])
# Interleave.
# 1 2 3 4 5 6 7 8 -> 1 5 2 6 3 7 4 8
while valueslist1 or valueslist2:
for valueslist in (valueslist1, valueslist2):
if valueslist:
values = valueslist.pop(0)
checkerboard.append(values)
if shift and checkerboard[-1][:3] == [100, 100, 100]:
# Move white patch to front
if 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 (is %i, should be %i)"
% (len(checkerboard), numvalues)
)
return False
return data.set_RGB_XYZ_values(checkerboard)
def sort_RGB_gray_to_top(self):
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
"""
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):
return self.sort_data_RGB_XYZ(sort_RGB_white_to_top)
def sort_by_HSI(self):
return self.sort_data_RGB_XYZ(sort_by_HSI)
def sort_by_HSL(self):
return self.sort_data_RGB_XYZ(sort_by_HSL)
def sort_by_HSV(self):
return self.sort_data_RGB_XYZ(sort_by_HSV)
def sort_by_L(self):
return self.sort_data_RGB_XYZ(sort_by_L)
def sort_by_RGB(self):
return self.sort_data_RGB_XYZ(sort_by_RGB)
def sort_by_BGR(self):
return self.sort_data_RGB_XYZ(sort_by_BGR)
def sort_by_RGB_pow_sum(self):
return self.sort_data_RGB_XYZ(sort_by_RGB_pow_sum)
def sort_by_RGB_sum(self):
return self.sort_data_RGB_XYZ(sort_by_RGB_sum)
def sort_by_rec709_luma(self):
return self.sort_data_RGB_XYZ(sort_by_rec709_luma)
def sort_data_RGB_XYZ(self, cmp=None, key=None, reverse=False):
"""Sort RGB/XYZ data"""
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):
if self.root:
return self.root._modified
return self._modified
def moveby1(self, start, inc=1):
"""Move items from start by incrementing or decrementing their key by inc."""
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
else:
self[key].key += inc
self[key + inc] = self[key]
if key == len(self) - 1:
break
def add_data(self, data, key=None):
"""Add data to the CGATS structure.
data can be a CGATS instance, a dict, a list, a tuple, or a string or
unicode instance.
"""
context = self
if self.type == b"DATA":
if isinstance(data, (dict, list, tuple)):
if self.parent["DATA_FORMAT"]:
fl, il = len(self.parent["DATA_FORMAT"]), len(data)
if fl != il:
raise CGATSTypeError(
"DATA entries take exactly %s values (%s given)" % (fl, il)
)
dataset = CGATS()
i = -1
for item in list(self.parent["DATA_FORMAT"].values()):
i += 1
if isinstance(data, dict):
try:
value = data[item.decode()]
except KeyError:
raise CGATSKeyError(item)
else:
value = data[i]
if item.upper() in (b"INDEX", b"SAMPLE_ID", b"SAMPLEID"):
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:
if match.groups()[0]:
value = float(value)
else:
value = int(value)
elif item.upper() not in (
b"SAMPLE_NAME",
b"SAMPLE_LOC",
b"SAMPLENAME",
):
try:
value = float(value)
except ValueError:
raise CGATSValueError(
"Invalid data type for %s (expected float, got %s)"
% (item, type(value))
)
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]))
if lencheck > self.vmaxlen:
self.vmaxlen = lencheck
elif (
self.root.normalize_fields and item.upper() == b"SAMPLENAME"
):
item = b"SAMPLE_NAME"
dataset[item.decode()] = value
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
else:
raise CGATSInvalidOperationError(
"Cannot add to DATA because of missing DATA_FORMAT"
)
else:
raise CGATSTypeError(
f"Invalid data type for {self.type} (expected CGATS, dict, list or "
f"tuple, got {type(data)})"
)
elif self.type == b"ROOT":
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(
"Invalid data type for %s "
"(expected str or unicode without line endings, got %s)"
% (self.type, type(data))
)
elif self.type == b"SECTION":
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(
"Invalid data type for %s "
"(expected bytes or str, got %s)" % (self.type, type(data))
)
elif self.type in (b"DATA_FORMAT", b"KEYWORDS") or (
self.parent and self.parent.type == b"ROOT"
):
if isinstance(data, (dict, list, tuple)):
for var in data:
if isinstance(var, bytes):
var = var.decode()
if var in ("NUMBER_OF_FIELDS", "NUMBER_OF_SETS"):
self[var] = None
else:
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()
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:
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:
if match.groups()[0]:
value = float(value)
else:
value = int(value)
if self.type in (b"DATA_FORMAT", b"KEYWORDS"):
raise CGATSTypeError(
"Invalid data type for %s (expected bytes "
"or str, got %s)" % (self.type, type(value))
)
self[key] = value
else:
raise CGATSTypeError(
"Invalid data type for %s (expected "
"CGATS, dict, list or tuple, got %s)" % (self.type, type(data))
)
else:
raise CGATSInvalidOperationError("Cannot add data to %s" % self.type)
return context
def export_3d(
self,
filename,
colorspace="RGB",
RGB_black_offset=40,
normalize_RGB_white=False,
compress=True,
format="VRML",
):
if colorspace not in (
"DIN99",
"DIN99b",
"DIN99c",
"DIN99d",
"LCH(ab)",
"LCH(uv)",
"Lab",
"Luv",
"Lu'v'",
"RGB",
"xyY",
"HSI",
"HSL",
"HSV",
"ICtCp",
"IPT",
"Lpt",
):
raise ValueError("export_3d: Unknown colorspace %r" % colorspace)
from DisplayCAL import x3dom
data = self.queryv1("DATA")
if self.queryv1("ACCURATE_EXPECTED_VALUES") == "true":
cat = "Bradford"
else:
cat = "XYZ scaling"
radius = 15.0 / (len(data) ** (1.0 / 3.0))
scale = 1.0
if colorspace.startswith("DIN99"):
if colorspace == "DIN99":
scale = 100.0 / 40
else:
scale = 100.0 / 50
radius /= scale
white = data.queryi1({"RGB_R": 100, "RGB_G": 100, "RGB_B": 100})
if white:
white = white["XYZ_X"], white["XYZ_Y"], white["XYZ_Z"]
else:
white = "D50"
white = colormath.get_whitepoint(white)
d50 = colormath.get_whitepoint("D50")
if colorspace == "Lu'v'":
white_u_, white_v_ = colormath.XYZ2Lu_v_(*d50)[1:]
elif colorspace == "xyY":
white_x, white_y = colormath.XYZ2xyY(*d50)[:2]
vrml = """#VRML V2.0 utf8
Transform {
children [
NavigationInfo {
type "EXAMINE"
}
DirectionalLight {
direction 0 0 -1
direction 0 -1 0
}
Viewpoint {
fieldOfView %(fov)s
position 0 0 %(z)s
}
%(axes)s
%(children)s
]
}
"""
child = """ # Sphere
Transform {
translation %(x).6f %(y).6f %(z).6f
children [
Shape{
geometry Sphere { radius %(radius).6f}
appearance Appearance { material Material { diffuseColor %(R).6f %(G).6f %(B).6f} }
}
]
}
"""
axes = ""
if colorspace not in (
"Lab",
"Luv",
"ICtCp",
"IPT",
"Lpt",
) and not colorspace.startswith("DIN99"):
if colorspace in ("Lu'v'", "xyY"):
maxz = scale = 100
maxxy = 200
radius /= 2.0
if colorspace == "Lu'v'":
xlabel, ylabel, zlabel = "u' 0.6", "v' 0.6", "L* 100"
offsetx, offsety = -0.3, -0.3
scale = maxxy / 0.6
else:
xlabel, ylabel, zlabel = "x 0.8", "y 0.8", "Y 100"
offsetx, offsety = -0.4, -0.4
scale = maxxy / 0.8
axes = x3dom.get_vrml_axes(
xlabel,
ylabel,
zlabel,
offsetx * scale,
offsety * scale,
0,
maxxy,
maxxy,
maxz,
)
elif colorspace in ("LCH(ab)", "LCH(uv)"):
if colorspace == "LCH(ab)":
xlabel, ylabel, zlabel = "H(ab)", "C(ab)", "L*"
else:
xlabel, ylabel, zlabel = "H(uv)", "C(uv)", "L*"
axes = x3dom.get_vrml_axes(
xlabel, ylabel, zlabel, -180, -100, 0, 360, 200, 100, False
)
else:
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"
if colorspace.startswith("DIN99"):
axes += """Transform {
translation %.1f %.1f -50.0
children [
Shape {
geometry Text {
string ["%s"]
fontStyle FontStyle { family "SANS" style "BOLD" size %.1f }
}
appearance Appearance {
material Material { diffuseColor 0.7 0.7 0.7 }
}
}
]
}
""" % (
100 / scale,
100 / scale,
colorspace,
10.0 / scale,
)
(pxlabel, nxlabel, pylabel, nylabel, pllabel) = (
'"a", "+%i"' % (100 / scale),
'"a", "-%i"' % (100 / scale),
'"b +%i"' % (100 / scale),
'"b -%i"' % (100 / scale),
'"L", "+100"',
)
elif colorspace == "ICtCp":
scale = 2.0
radius /= 2.0
(pxlabel, nxlabel, pylabel, nylabel, pllabel) = (
'"Ct", "+%.1f"' % 0.5,
'"Ct", "-%.1f"' % 0.5,
'"Cp +%.1f"' % 0.5,
'"Cp -%.1f"' % 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"
elif colorspace == "IPT":
(pxlabel, nxlabel, pylabel, nylabel, pllabel) = (
'"P", "+%.1f"' % 1,
'"P", "-%.1f"' % 1,
'"T +%.1f"' % 1,
'"T -%.1f"' % 1,
'"I"',
)
else:
if colorspace == "Luv":
x = "u"
y = "v"
elif colorspace == "Lpt":
x = "p"
y = "t"
else:
x = "a"
y = "b"
(pxlabel, nxlabel, pylabel, nylabel, pllabel) = (
'"%s*", "+100"' % x,
'"%s*", "-100"' % x,
'"%s* +100"' % y,
'"%s* -100"' % y,
'"L*", "+100"',
)
values = {
"wh": 2.0 / scale,
"ab": 100.0 / scale,
"aboffset": 50.0 / scale,
"fontsize": 10.0 / scale,
"ap": 102.0 / scale,
"an": 108.0 / scale,
"Ln": 3.0,
"bp0": 3.0,
"bp1": 103.0 / scale,
"bn0": 3.0,
"bn1": 107.0 / scale,
"pxlabel": pxlabel,
"nxlabel": nxlabel,
"pylabel": pylabel,
"nylabel": nylabel,
"pllabel": pllabel,
"pxcolor": pxcolor,
"nxcolor": nxcolor,
"pycolor": pycolor,
"nycolor": nycolor,
}
axes += (
"""# 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)s]
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)s }
}
}
]
}
# +x axis label
Transform {
translation %(ap).1f -%(wh).1f -50.0
children [
Shape {
geometry Text {
string [%(pxlabel)s]
fontStyle FontStyle { family "SANS" style "BOLD" size %(fontsize).1f }
}
appearance Appearance {
material Material { diffuseColor %(pxcolor)s }
}
}
]
}
# -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)s }
}
}
]
}
# -x axis label
Transform {
translation -%(an).1f -%(wh).1f -50.0
children [
Shape {
geometry Text {
string [%(nxlabel)s]
fontStyle FontStyle { family "SANS" style "BOLD" size %(fontsize).1f }
}
appearance Appearance {
material Material { diffuseColor %(nxcolor)s }
}
}
]
}
# +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)s }
}
}
]
}
# +y axis label
Transform {
translation -%(bp0).1f %(bp1).1f -50.0
children [
Shape {
geometry Text {
string [%(pylabel)s]
fontStyle FontStyle { family "SANS" style "BOLD" size %(fontsize).1f }
}
appearance Appearance {
material Material { diffuseColor %(pycolor)s }
}
}
]
}
# -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)s }
}
}
]
}
# -y axis label
Transform {
translation -%(bn0).1f -%(bn1).1f -50.0
children [
Shape {
geometry Text {
string [%(nylabel)s]
fontStyle FontStyle { family "SANS" style "BOLD" size %(fontsize).1f }
}
appearance Appearance {
material Material { diffuseColor %(nycolor)s }
}
}
]
}
# 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}
}
}
]
}
"""
% values
)
children = []
sqrt3_100 = math.sqrt(3) * 100
sqrt3_50 = math.sqrt(3) * 50
for entry in data.values():
X, Y, Z = colormath.adapt(
entry["XYZ_X"],
entry["XYZ_Y"],
entry["XYZ_Z"],
white,
"D65" if colorspace in ("ICtCp", "IPT") else "D50",
cat=cat,
)
L, a, b = colormath.XYZ2Lab(X, Y, Z)
if colorspace == "RGB":
# Fudge device locations into Lab space
x, y, z = (
entry["RGB_G"] - 50,
entry["RGB_B"] - 50,
entry["RGB_R"] - 50,
)
elif colorspace == "HSI":
H, S, z = colormath.RGB2HSI(
entry["RGB_R"] / 100.0,
entry["RGB_G"] / 100.0,
entry["RGB_B"] / 100.0,
)
rad = H * 360 * math.pi / 180
x, y = S * z * math.cos(rad), S * z * math.sin(rad)
# Fudge device locations into Lab space
x, y, z = x * sqrt3_100, y * sqrt3_100, z * sqrt3_100 - sqrt3_50
elif colorspace == "HSL":
H, S, z = colormath.RGB2HSL(
entry["RGB_R"] / 100.0,
entry["RGB_G"] / 100.0,
entry["RGB_B"] / 100.0,
)
rad = H * 360 * math.pi / 180
if z > 0.5:
S *= 1 - z
else:
S *= z
x, y = S * math.cos(rad), S * math.sin(rad)
# Fudge device locations into Lab space
x, y, z = x * sqrt3_100, y * sqrt3_100, z * sqrt3_100 - sqrt3_50
elif colorspace == "HSV":
H, S, z = colormath.RGB2HSV(
entry["RGB_R"] / 100.0,
entry["RGB_G"] / 100.0,
entry["RGB_B"] / 100.0,
)
rad = H * 360 * math.pi / 180
x, y = S * z * math.cos(rad), S * z * math.sin(rad)
# Fudge device locations into Lab space
x, y, z = x * sqrt3_50, y * sqrt3_50, z * sqrt3_100 - sqrt3_50
elif colorspace == "Lab":
x, y, z = a, b, L - 50
elif colorspace in ("DIN99", "DIN99b"):
if colorspace == "DIN99":
L99, a99, b99 = colormath.Lab2DIN99(L, a, b)
else:
L99, a99, b99 = colormath.Lab2DIN99b(L, a, b)
x, y, z = a99, b99, L99 - 50
elif colorspace in ("DIN99c", "DIN99d"):
if colorspace == "DIN99c":
L99, a99, b99 = colormath.XYZ2DIN99c(X, Y, Z)
else:
L99, a99, b99 = colormath.XYZ2DIN99d(X, Y, Z)
x, y, z = a99, b99, L99 - 50
elif colorspace in ("LCH(ab)", "LCH(uv)"):
if colorspace == "LCH(ab)":
L, C, H = colormath.Lab2LCHab(L, a, b)
else:
L, u, v = colormath.XYZ2Luv(X, Y, Z)
L, C, H = colormath.Luv2LCHuv(L, u, v)
x, y, z = H - 180, C - 100, L - 50
elif colorspace == "Luv":
L, u, v = colormath.XYZ2Luv(X, Y, Z)
x, y, z = u, v, L - 50
elif colorspace == "Lu'v'":
L, u_, v_ = colormath.XYZ2Lu_v_(X, Y, Z)
x, y, z = (
(u_ + offsetx) * scale,
(v_ + offsety) * scale,
L / 100.0 * maxz - 50,
)
elif colorspace == "xyY":
x, y, Y = colormath.XYZ2xyY(X, Y, Z)
x, y, z = (
(x + offsetx) * scale,
(y + offsety) * scale,
Y / 100.0 * maxz - 50,
)
elif colorspace == "ICtCp":
I, Ct, Cp = colormath.XYZ2ICtCp(
X / 100.0, Y / 100.0, Z / 100.0, clamp=False
)
x, y, z = Ct * 100, Cp * 100, I * 100 - 50
elif colorspace == "IPT":
I, P, T = colormath.XYZ2IPT(X / 100.0, Y / 100.0, Z / 100.0)
x, y, z = P * 100, T * 100, I * 100 - 50
elif colorspace == "Lpt":
L, p, t = colormath.XYZ2Lpt(X, Y, Z)
x, y, z = p, t, L - 50
if 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(
L * (100.0 - 40.0) / 100.0 + 40.0,
a,
b,
scale=0.7,
noadapt=not normalize_RGB_white,
)
H_ref, S_ref, V_ref = colormath.RGB2HSV(R, G, B)
# Lab to sRGB using actual black offset
R, G, B = colormath.Lab2RGB(
L * (100.0 - RGB_black_offset) / 100.0 + RGB_black_offset,
a,
b,
scale=0.7,
noadapt=not normalize_RGB_white,
)
if RGB_black_offset != 40:
H, S, 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)
children.append(
child
% {
"x": x,
"y": y,
"z": z,
"R": R + 0.05,
"G": G + 0.05,
"B": B + 0.05,
"radius": radius,
}
)
children = "".join(children)
# Choose viewpoint fov and z position based on colorspace
fov = 45
z = 340
if colorspace in ("LCH(ab)", "LCH(uv)"):
# Use a very narrow field of view for LCH
fov /= 16.0
z *= 16
elif colorspace.startswith("DIN99") or colorspace == "ICtCp":
fov /= scale
out = vrml % {
"children": children,
"axes": axes,
"fov": fov / 180.0 * math.pi,
"z": z,
}
if format != "VRML":
print("Generating", format)
x3d = x3dom.vrml2x3dom(out)
if format == "HTML":
out = x3d.html(title=os.path.basename(filename))
else:
out = x3d.x3d()
if compress:
writer = GzipFileProper
else:
writer = open
print("Writing", filename)
with writer(filename, "wb") as outfile:
outfile.write(out.encode("utf-8"))
@property
def NUMBER_OF_FIELDS(self):
"""Get number of fields"""
if "DATA_FORMAT" in self:
return len(self["DATA_FORMAT"])
return 0
@property
def NUMBER_OF_SETS(self):
"""Get number of sets"""
if "DATA" in self:
return len(self["DATA"])
return 0
def query(self, query, query_value=None, get_value=False, get_first=False):
"""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.
"""
modified = self.modified
if not get_first:
result = CGATS()
else:
result = None
if not isinstance(query, dict):
if not isinstance(query, (list, tuple)):
query = (query,)
items = [self] + [self[key] for key in self]
for item in items:
if isinstance(item, (dict, list, tuple)):
if not get_first:
n = len(result)
if get_value:
result_n = CGATS()
else:
result_n = None
match_count = 0
for query_key in query:
if query_key in item or (
type(item) is CGATS
and (
(query_key == "NUMBER_OF_FIELDS" and "DATA_FORMAT" in item)
or (query_key == "NUMBER_OF_SETS" and "DATA" in item)
)
):
if query_value is None and isinstance(query, dict):
current_query_value = query[query_key]
else:
current_query_value = query_value
if current_query_value is not None:
if 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:
if (
get_value
and isinstance(result_n, dict)
and len(result_n) == 1
):
result = result_n[0]
else:
result = result_n
break
elif len(result_n):
if (
get_value
and isinstance(result_n, dict)
and len(result_n) == 1
):
result[n] = result_n[0]
else:
result[n] = 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
elif 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, query_value=None):
"""Query and return matching items. See also query method."""
return self.query(query, query_value, get_value=False, get_first=False)
def queryi1(self, query, query_value=None):
"""Query and return first matching item. See also query method."""
return self.query(query, query_value, get_value=False, get_first=True)
def queryv(self, query, query_value=None):
"""Query and return matching values. See also query method."""
return self.query(query, query_value, get_value=True, get_first=False)
def queryv1(self, query, query_value=None):
"""Query and return first matching value. See also query method."""
return self.query(query, query_value, get_value=True, get_first=True)
def remove(self, item):
"""Remove an item from the internal CGATS structure."""
if isinstance(item, CGATS):
key = item.key
else:
key = item
maxindex = len(self) - 1
result = self[key]
if type(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):
"""Convert XYZ to D50 L*a*b* and add it as additional fields"""
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 %s" % b"_".join(color_rep).decode("utf-8")
)
data = self.queryv1("DATA")
if not data:
raise CGATSError("No data")
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})
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 fix_zero_measurements(self, warn_only=False, logfile=safe_print):
"""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)
"""
color_rep = (self.queryv1("COLOR_REP") or b"").split(b"_")
data = self.queryv1("DATA")
if len(color_rep) == 2 and data:
# Check for XYZ/Lab = 0 readings
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
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)
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:
if warn_only:
if logfile:
logfile.write(
"Warning: Sample ID %i (%s %s) has %s <= 0!\n"
% (
sample.SAMPLE_ID,
color_rep[0],
" ".join(
device_label_values.decode(
"utf-8"
).split()
if device_label_values
else [""]
),
label.decode("utf-8"),
)
)
else:
# Fudge to be nonzero
sample[label.decode("utf-8")] = 0.000001
if logfile:
logfile.write(
"Fudged sample ID %i (%s %s) %s to be "
"non-zero\n"
% (
sample.SAMPLE_ID,
color_rep[0],
" ".join(
device_label_values.decode(
"utf-8"
).split()
if device_label_values
else [""]
),
label.decode("utf-8"),
)
)
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:
if logfile:
logfile.write(
"Warning: Sample ID %i (%s %s) has %s = 0!\n"
% (
sample.SAMPLE_ID,
color_rep[0],
" ".join(
device_label_values.decode("utf-8").split()
if device_label_values
else [""]
),
color_rep[1],
)
)
else:
# Queue sample for removal
remove.insert(0, sample)
if logfile:
logfile.write(
"Removed sample ID %i (%s %s) with %s = 0\n"
% (
sample.SAMPLE_ID,
color_rep[0],
" ".join(
device_label_values.decode("utf-8").split()
if device_label_values
else [""]
),
color_rep[1],
)
)
for sample in remove:
# Remove sample
data.pop(sample)
def fix_device_values_scaling(self, color_rep=None):
"""Attempt to fix device value scaling so that max = 100
Return 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):
"""Scale XYZ values so that RGB 100 = Y 100"""
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"
% (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=8, quantizer=round):
"""Quantize device values to n bits"""
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=100.0 / 255, color_rep=None):
"""Scales device values by multiplying with factor."""
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, whitepoint_destination=None, cat="Bradford"
):
"""Perform chromatic adaptation if possible (needs XYZ or LAB)
Return 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 whitepoint_source:
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=(0, 0, 0), weight=False):
"""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.
Return number of affected DATA sections.
"""
n = 0
for dataset in self.query("DATA").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
continue
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"")
if is_Lab:
labels = ("LAB_L", "LAB_A", "LAB_B")
index = 0 # Index of L* in labels
else:
labels = ("XYZ_X", "XYZ_Y", "XYZ_Z")
index = 1 # Index of Y in labels
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
continue
black = [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]
if is_Lab:
black = colormath.Lab2XYZ(*black)
white = [0, 0, 0]
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
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]
# 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 get_white_cie(self, colorspace=None):
"""Get the 'white' from the CIE values (if any)."""
data_format = self.get_cie_data_format()
if data_format:
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:
for key in ("LUMINANCE_XYZ_CDM2", "APPROX_WHITE_POINT"):
white = self.queryv1(key)
if white:
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
else:
white = None
if not white:
return
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"]
else:
return colormath.Lab2XYZ(
white["LAB_L"], white["LAB_A"], white["LAB_B"], scale=100
)
elif colorspace == "Lab":
if "LAB_L" in white:
return white["LAB_L"], white["LAB_A"], white["LAB_B"]
else:
return colormath.XYZ2Lab(
white["XYZ_X"], white["XYZ_Y"], white["XYZ_Z"]
)
return white
def get_cie_data_format(self):
"""Check if DATA_FORMAT defines any CIE XYZ or LAB columns.
Return 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
pop = remove
def write(self, stream_or_filename=None):
"""Write CGATS text to stream."""
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.11/DisplayCAL/ColorLookupTable.fx 0000664 0000000 0000000 00000005062 14437413106 0022155 0 ustar 00root root 0000000 0000000 // 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.11/DisplayCAL/ICCProfile.py 0000664 0000000 0000000 00001135574 14437413106 0020704 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
import binascii
import ctypes
import datetime
import json
import math
import os
import pathlib
import re
import struct
import sys
import warnings
from collections import UserString
from copy import copy
from hashlib import md5
from time import strftime
from weakref import WeakValueDictionary
from DisplayCAL.util_dict import dict_sort
if sys.platform == "win32":
import winreg
else:
import subprocess as sp
if sys.platform == "darwin":
from platform import mac_ver
if sys.platform == "win32":
try:
import win32api
import win32gui
except ImportError:
pass
try:
from DisplayCAL import colord
except ImportError:
class Colord:
Colord = None
def quirk_manufacturer(self, manufacturer):
return manufacturer
def which(self, executable, paths=None):
return None
colord = Colord()
from DisplayCAL import colormath
from DisplayCAL import edid
from DisplayCAL import imfile
from DisplayCAL.colormath import NumberTuple
from DisplayCAL.defaultpaths import iccprofiles, iccprofiles_home
from DisplayCAL.encoding import get_encodings
from DisplayCAL.options import test_input_curve_clipping
from DisplayCAL.util_list import intlist
if sys.platform not in ("darwin", "win32"):
from DisplayCAL.defaultpaths import xdg_config_dirs, xdg_config_home
from DisplayCAL.edid import get_edid
from DisplayCAL.util_x import get_display
try:
from DisplayCAL import xrandr
except ImportError:
xrandr = None
from DisplayCAL.util_os import dlopen, which
elif sys.platform == "win32":
from DisplayCAL import util_win
if sys.getwindowsversion() < (6,):
# WCS only available under Vista and later
mscms = None
else:
from DisplayCAL.win_handles import (
get_process_handles,
get_handle_name,
get_handle_type,
)
mscms = util_win._get_mscms_windll()
win_ver = util_win.win_ver()
win10_1903 = (
win_ver[0].startswith("Windows 10") and win_ver[2] >= "Version 1903"
)
elif sys.platform == "darwin":
from DisplayCAL.util_mac import osascript
# Gamut volumes in cubic colorspace units (L*a*b*) as reported by Argyll's
# iccgamut
GAMUT_VOLUME_SRGB = 833675.435316 # rel. col.
GAMUT_VOLUME_ADOBERGB = 1209986.014983 # rel. col.
GAMUT_VOLUME_SMPTE431_P3 = 1176953.485921 # rel. col.
# http://msdn.microsoft.com/en-us/library/dd371953%28v=vs.85%29.aspx
COLORPROFILESUBTYPE = {
"NONE": 0x0000,
"RGB_WORKING_SPACE": 0x0001,
"PERCEPTUAL": 0x0002,
"ABSOLUTE_COLORIMETRIC": 0x0004,
"RELATIVE_COLORIMETRIC": 0x0008,
"SATURATION": 0x0010,
"CUSTOM_WORKING_SPACE": 0x0020,
}
# http://msdn.microsoft.com/en-us/library/dd371955%28v=vs.85%29.aspx (wrong)
# http://msdn.microsoft.com/en-us/library/windows/hardware/ff546018%28v=vs.85%29.aspx (ok)
COLORPROFILETYPE = {"ICC": 0, "DMP": 1, "CAMP": 2, "GMMP": 3}
WCS_PROFILE_MANAGEMENT_SCOPE = {"SYSTEM_WIDE": 0, "CURRENT_USER": 1}
ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE = 2015
debug = False
enc, fs_enc = get_encodings()
cmms = {
b"argl": "ArgyllCMS",
b"ADBE": "Adobe",
b"ACMS": "Agfa",
b"Agfa": "Agfa",
b"APPL": "Apple",
b"appl": "Apple",
b"CCMS": "ColorGear",
b"UCCM": "ColorGear Lite",
b"DL&C": "Digital Light & Color",
b"EFI ": "EFI",
b"FF ": "Fuji Film",
b"HCMM": "Harlequin RIP",
b"LgoS": "LogoSync",
b"HDM ": "Heidelberg",
b"Lino": "Linotype",
b"lino": "Linotype",
b"lcms": "Little CMS",
b"KCMS": "Kodak",
b"MCML": "Konica Minolta",
b"MSFT": "Microsoft",
b"SIGN": "Mutoh",
b"RGMS": "DeviceLink",
b"SICC": "SampleICC",
b"32BT": "the imaging factory",
b"WTG ": "Ware to Go",
b"zc00": "Zoran",
}
encodings = {
"mac": {
141: "africaans",
36: "albanian",
85: "amharic",
12: "arabic",
51: "armenian",
68: "assamese",
134: "aymara",
49: "azerbaijani-cyrllic",
50: "azerbaijani-arabic",
129: "basque",
67: "bengali",
137: "dzongkha",
142: "breton",
44: "bulgarian",
77: "burmese",
46: "byelorussian",
78: "khmer",
130: "catalan",
92: "chewa",
33: "simpchinese",
19: "tradchinese",
18: "croatian",
38: "czech",
7: "danish",
4: "dutch",
0: "roman",
94: "esperanto",
27: "estonian",
30: "faeroese",
31: "farsi",
13: "finnish",
34: "flemish",
1: "french",
140: "galician",
144: "scottishgaelic",
145: "manxgaelic",
52: "georgian",
2: "german",
14: "greek-monotonic",
148: "greek-polytonic",
133: "guarani",
69: "gujarati",
10: "hebrew",
21: "hindi",
26: "hungarian",
15: "icelandic",
81: "indonesian",
143: "inuktitut",
35: "irishgaelic",
146: "irishgaelic-dotsabove",
3: "italian",
11: "japanese",
138: "javaneserom",
73: "kannada",
61: "kashmiri",
48: "kazakh",
90: "kiryarwanda",
54: "kirghiz",
91: "rundi",
23: "korean",
60: "kurdish",
79: "lao",
131: "latin",
28: "latvian",
24: "lithuanian",
43: "macedonian",
93: "malagasy",
83: "malayroman-latin",
84: "malayroman-arabic",
72: "malayalam",
16: "maltese",
66: "marathi",
53: "moldavian",
57: "mongolian",
58: "mongolian-cyrillic",
64: "nepali",
9: "norwegian",
71: "oriya",
87: "oromo",
59: "pashto",
25: "polish",
8: "portuguese",
70: "punjabi",
132: "quechua",
37: "romanian",
32: "russian",
29: "sami",
65: "sanskrit",
42: "serbian",
62: "sindhi",
76: "sinhalese",
39: "slovak",
40: "slovenian",
88: "somali",
6: "spanish",
139: "sundaneserom",
89: "swahili",
5: "swedish",
82: "tagalog",
55: "tajiki",
74: "tamil",
135: "tatar",
75: "telugu",
22: "thai",
63: "tibetan",
86: "tigrinya",
147: "tongan",
17: "turkish",
56: "turkmen",
136: "uighur",
45: "ukrainian",
20: "urdu",
47: "uzbek",
80: "vietnamese",
128: "welsh",
41: "yiddish",
}
}
colorants = {
0: {"description": "unknown", "channels": ()},
1: {
"description": "ITU-R BT.709",
"channels": ((0.64, 0.33), (0.3, 0.6), (0.15, 0.06)),
},
2: {
"description": "SMPTE RP145-1994",
"channels": ((0.63, 0.34), (0.31, 0.595), (0.155, 0.07)),
},
3: {
"description": "EBU Tech.3213-E",
"channels": ((0.64, 0.33), (0.29, 0.6), (0.15, 0.06)),
},
4: {
"description": "P22",
"channels": ((0.625, 0.34), (0.28, 0.605), (0.155, 0.07)),
},
}
geometry = {0: "unknown", 1: "0/45 or 45/0", 2: "0/d or d/0"}
illuminants = {
0: "unknown",
1: "D50",
2: "D65",
3: "D93",
4: "F2",
5: "D55",
6: "A",
7: "E",
8: "F8",
}
observers = {0: "unknown", 1: "CIE 1931", 2: "CIE 1964"}
manufacturers = {
b"ADBE": "Adobe Systems Incorporated",
b"APPL": "Apple Computer, Inc.",
b"agfa": "Agfa Graphics N.V.",
b"argl": "ArgyllCMS", # Not registered
b"DCAL": "DisplayCAL", # Not registered
b"bICC": "basICColor GmbH",
b"DL&C": "Digital Light & Color",
b"EPSO": "Seiko Epson Corporation",
b"HDM ": "Heidelberger Druckmaschinen AG",
b"HP ": "Hewlett-Packard",
b"KODA": "Kodak",
b"lcms": "Little CMS",
b"MONS": "Monaco Systems Inc.",
b"MSFT": "Microsoft Corporation",
b"qato": "QUATOGRAPHIC Technology GmbH",
b"XRIT": "X-Rite",
}
platform = {
b"APPL": "Apple",
b"MSFT": "Microsoft",
b"SGI ": "Silicon Graphics",
b"SUNW": "Sun Microsystems",
}
profileclass = {
b"scnr": "Input device profile",
b"mntr": "Display device profile",
b"prtr": "Output device profile",
b"link": "DeviceLink profile",
b"spac": "Color space Conversion profile",
b"abst": "Abstract profile",
b"nmcl": "Named color profile",
}
tags = {
"A2B0": "Device to PCS: Intent 0",
"A2B1": "Device to PCS: Intent 1",
"A2B2": "Device to PCS: Intent 2",
"B2A0": "PCS to device: Intent 0",
"B2A1": "PCS to device: Intent 1",
"B2A2": "PCS to device: Intent 2",
"CIED": "Characterization measurement values", # Non-standard
"DevD": "Characterization device values", # Non-standard
"arts": "Absolute to media relative transform", # Non-standard (Argyll)
"bkpt": "Media black point",
"bTRC": "Blue tone response curve",
"bXYZ": "Blue matrix column",
"chad": "Chromatic adaptation transform",
"ciis": "Colorimetric intent image state",
"clro": "Colorant order",
"cprt": "Copyright",
"desc": "Description",
"dmnd": "Device manufacturer name",
"dmdd": "Device model name",
"gamt": "Out of gamut tag",
"gTRC": "Green tone response curve",
"gXYZ": "Green matrix column",
"kTRC": "Gray tone response curve",
"lumi": "Luminance",
"meas": "Measurement type",
"mmod": "Make and model",
"ncl2": "Named colors",
"pseq": "Profile sequence description",
"rTRC": "Red tone response curve",
"rXYZ": "Red matrix column",
"targ": "Characterization target",
"tech": "Technology",
"vcgt": "Video card gamma table",
"view": "Viewing conditions",
"vued": "Viewing conditions description",
"wtpt": "Media white point",
}
tech = {
"fscn": "Film scanner",
"dcam": "Digital camera",
"rscn": "Reflective scanner",
"ijet": "Ink jet printer",
"twax": "Thermal wax printer",
"epho": "Electrophotographic printer",
"esta": "Electrostatic printer",
"dsub": "Dye sublimation printer",
"rpho": "Photographic paper printer",
"fprn": "Film writer",
"vidm": "Video monitor",
"vidc": "Video camera",
"pjtv": "Projection television",
"CRT ": "Cathode ray tube display",
"PMD ": "Passive matrix display",
"AMD ": "Active matrix display",
"KPCD": "Photo CD",
"imgs": "Photographic image setter",
"grav": "Gravure",
"offs": "Offset lithography",
"silk": "Silkscreen",
"flex": "Flexography",
"mpfs": "Motion picture film scanner",
"mpfr": "Motion picture film recorder",
"dmpc": "Digital motion picture camera",
"dcpj": "Digital cinema projector",
}
ciis = {
"scoe": "Scene colorimetry estimates",
"sape": "Scene appearance estimates",
"fpce": "Focal plane colorimetry estimates",
"rhoc": "Reflection hardcopy original colorimetry",
"rpoc": "Reflection print output colorimetry",
}
def legacy_PCSLab_dec_to_uInt16(L, a, b):
# ICCv2 (legacy) PCS L*a*b* encoding
# Only used by LUT16Type and namedColor2Type in ICCv4
return [
v * (652.80, 256, 256)[i] + (0, 32768, 32768)[i]
for i, v in enumerate((L, a, b))
]
def legacy_PCSLab_uInt16_to_dec(L_uInt16, a_uInt16, b_uInt16):
# ICCv2 (legacy) PCS L*a*b* encoding
# Only used by LUT16Type and namedColor2Type in ICCv4
return [
(v - (0, 32768, 32768)[i]) / (65280.0, 32768.0, 32768.0)[i] * (100, 128, 128)[i]
for i, v in enumerate((L_uInt16, a_uInt16, b_uInt16))
]
def create_RGB_A2B_XYZ(input_curves, clut, logfn=print):
"""Create RGB device A2B from input curve XYZ values and cLUT
Note that input curves and cLUT should already be adapted to D50.
"""
if len(input_curves) != 3:
raise ValueError("Wrong number of input curves: %i" % len(input_curves))
white_XYZ = clut[-1][-1]
clutres = len(clut[0])
itable = LUT16Type(None, "A2B0")
itable.matrix = colormath.Matrix3x3([(1, 0, 0), (0, 1, 0), (0, 0, 1)])
# Input curve interpolation
# Normlly the input curves would either be linear (= 1:1 mapping to
# cLUT) or the respective tone response curve.
# We use a overall linear curve that is 'bent' in intervals
# to accomodate the non-linear TRC. Thus, we can get away with much
# fewer cLUT grid points.
# Use higher interpolation size than actual number of curve entries
steps = 2**15 + 1
maxv = steps - 1.0
fwd = []
bwd = []
for i, input_curve in enumerate(input_curves):
if isinstance(input_curve, (tuple, list)):
linear = [v / (len(input_curve) - 1.0) for v in range(len(input_curve))]
fwd.append(colormath.Interp(linear, input_curve, use_numpy=True))
bwd.append(colormath.Interp(input_curve, linear, use_numpy=True))
else:
# Gamma
fwd.append(lambda v, p=input_curve: colormath.specialpow(v, p))
bwd.append(lambda v, p=input_curve: colormath.specialpow(v, 1.0 / p))
itable.input.append([])
itable.output.append([0, 65535])
logfn("cLUT input curve segments:", clutres)
for i in range(3):
maxi = bwd[i](white_XYZ[1])
segment = 1.0 / (clutres - 1.0) * maxi
iv = 0.0
prevpow = fwd[i](0.0)
nextpow = fwd[i](segment)
prevv = 0
pprevpow = 0
clipped = nextpow <= prevpow
xp = []
for j in range(steps):
v = (j / maxv) * maxi
if v > iv + segment:
iv += segment
prevpow = nextpow
nextpow = fwd[i](iv + segment)
clipped = nextpow <= prevpow
logfn(
"#%i %s" % (iv * (clutres - 1), "XYZ"[i]),
"prev %.6f" % prevpow,
"next %.6f" % nextpow,
"clip",
clipped,
)
if not clipped:
prevs = 1.0 - (v - iv) / segment
nexts = (v - iv) / segment
vv = prevs * prevpow + nexts * nextpow
prevv = v
pprevpow = prevpow
else:
# Linearly interpolate
vv = colormath.convert_range(v, prevv, 1, prevpow, 1)
out = bwd[i](vv)
xp.append(out)
# Fill input curves from interpolated values
interp = colormath.Interp(xp, list(range(steps)), use_numpy=True)
entries = 2049
threshold = bwd[i](pprevpow)
k = None
for j in range(entries):
n = j / (entries - 1.0)
v = interp(n) / maxv
if clipped and n + (1 / (entries - 1.0)) > threshold:
# Linear interpolate shaper for last n cLUT steps to prevent
# clipping in shaper
if k is None:
k = j
ov = v
v = min(ov + (1.0 - ov) * ((j - k) / (entries - k - 1.0)), 1.0)
# Slope limit for 16-bit encoding
itable.input[i].append(max(v, j / 65535.0) * 65535)
# Fill cLUT
clut = list(clut)
itable.clut = []
step = 1.0 / (clutres - 1.0)
for R in range(clutres):
for G in range(clutres):
row = list(clut.pop(0))
itable.clut.append([])
for B in range(clutres):
X, Y, Z = row.pop(0)
itable.clut[-1].append(
[max(v / white_XYZ[1] * 32768, 0) for v in (X, Y, Z)]
)
return itable
def create_synthetic_clut_profile(
rgb_space,
description,
XYZbp=None,
white_Y=1.0,
clutres=9,
entries=2049,
cat="Bradford",
):
"""Create a synthetic cLUT profile from a colorspace definition"""
profile = ICCProfile()
profile.version = 2.2 # Match ArgyllCMS
profile.tags.desc = TextDescriptionType(b"", "desc")
profile.tags.desc.ASCII = description
profile.tags.cprt = TextType(b"text\0\0\0\0Public domain\0", "cprt")
profile.tags.wtpt = XYZType(profile=profile)
(
profile.tags.wtpt.X,
profile.tags.wtpt.Y,
profile.tags.wtpt.Z,
) = colormath.get_whitepoint(rgb_space[1])
profile.tags.arts = chromaticAdaptionTag()
profile.tags.arts.update(colormath.get_cat_matrix(cat))
itable = profile.tags.A2B0 = LUT16Type(None, "A2B0", profile)
itable.matrix = colormath.Matrix3x3([(1, 0, 0), (0, 1, 0), (0, 0, 1)])
otable = profile.tags.B2A0 = LUT16Type(None, "B2A0", profile)
Xr, Yr, Zr = colormath.adapt(
*colormath.RGB2XYZ(1, 0, 0, rgb_space=rgb_space),
whitepoint_source=rgb_space[1],
cat=cat
)
Xg, Yg, Zg = colormath.adapt(
*colormath.RGB2XYZ(0, 1, 0, rgb_space=rgb_space),
whitepoint_source=rgb_space[1],
cat=cat
)
Xb, Yb, Zb = colormath.adapt(
*colormath.RGB2XYZ(0, 0, 1, rgb_space=rgb_space),
whitepoint_source=rgb_space[1],
cat=cat
)
m1 = colormath.Matrix3x3(((Xr, Xg, Xb), (Yr, Yg, Yb), (Zr, Zg, Zb))).inverted()
scale = 1 + (32767 / 32768.0)
m3 = colormath.Matrix3x3(((scale, 0, 0), (0, scale, 0), (0, 0, scale)))
otable.matrix = m1 * m3
# Input curve interpolation
# Normlly the input curves would either be linear (= 1:1 mapping to
# cLUT) or the respective tone response curve.
# We use a overall linear curve that is 'bent' in intervals
# to accomodate the non-linear TRC. Thus, we can get away with much
# fewer cLUT grid points.
# Use higher interpolation size than actual number of curve entries
steps = 2**15 + 1
maxv = steps - 1.0
gammas = rgb_space[0]
if not isinstance(gammas, (list, tuple)):
gammas = [gammas]
for i, gamma in enumerate(gammas):
maxi = colormath.specialpow(white_Y, 1.0 / gamma)
segment = 1.0 / (clutres - 1.0) * maxi
iv = 0.0
prevpow = 0.0
nextpow = colormath.specialpow(segment, gamma)
xp = []
for j in range(steps):
v = (j / maxv) * maxi
if v > iv + segment:
iv += segment
prevpow = nextpow
nextpow = colormath.specialpow(iv + segment, gamma)
prevs = 1.0 - (v - iv) / segment
nexts = (v - iv) / segment
vv = prevs * prevpow + nexts * nextpow
out = colormath.specialpow(vv, 1.0 / gamma)
xp.append(out)
interp = colormath.Interp(xp, list(range(steps)), use_numpy=True)
# Create input curves
itable.input.append([])
otable.input.append([])
for j in range(4096):
otable.input[i].append(
colormath.specialpow(j / 4095.0 * white_Y, 1.0 / gamma) * 65535
)
# Fill input curves from interpolated values
for j in range(entries):
v = j / (entries - 1.0)
itable.input[i].append(interp(v) / maxv * 65535)
# Fill remaining input curves from first input curve and create output curves
for i in range(3):
if len(itable.input) < 3:
itable.input.append(itable.input[0])
otable.input.append(otable.input[0])
itable.output.append([0, 65535])
otable.output.append([0, 65535])
# Create and fill cLUT
itable.clut = []
step = 1.0 / (clutres - 1.0)
for R in range(clutres):
for G in range(clutres):
itable.clut.append([])
for B in range(clutres):
X, Y, Z = colormath.adapt(
*colormath.RGB2XYZ(
*[v * step * maxi for v in (R, G, B)], rgb_space=rgb_space
),
whitepoint_source=rgb_space[1],
cat=cat
)
X, Y, Z = colormath.blend_blackpoint(X, Y, Z, None, XYZbp)
itable.clut[-1].append([max(v / white_Y * 32768, 0) for v in (X, Y, Z)])
otable.clut = []
for R in range(2):
for G in range(2):
otable.clut.append([])
for B in range(2):
otable.clut[-1].append([v * 65535 for v in (R, G, B)])
return profile
def create_synthetic_smpte2084_clut_profile(
rgb_space,
description,
black_cdm2=0,
white_cdm2=400,
master_black_cdm2=0,
master_white_cdm2=10000,
use_alternate_master_white_clip=True,
content_rgb_space="DCI P3",
rolloff=True,
clutres=33,
mode="HSV_ICtCp",
sat=1.0,
hue=0.5,
forward_xicclu=None,
backward_xicclu=None,
generate_B2A=False,
worker=None,
logfile=None,
cat="Bradford",
):
"""Create a synthetic cLUT profile with the SMPTE 2084 TRC from a colorspace
definition
mode: The gamut mapping mode when rolling off. Valid values:
"HSV_ICtCp" (default, recommended)
"ICtCp"
"XYZ" (not recommended, unpleasing hue shift)
"HSV" (not recommended, saturation loss)
"RGB" (not recommended, saturation loss, pleasing hue shift)
The roll-off saturation and hue preservation can be controlled.
sat: Saturation preservation factor [0.0, 1.0]
0.0 = Favor luminance preservation over saturation
1.0 = Favor saturation preservation over luminance
hue: Selective hue preservation factor [0.0, 1.0]
0.0 = Allow hue shift for redorange/orange/yellowgreen towards
yellow to preserve more saturation and detail
1.0 = Preserve hue
"""
if not rolloff:
raise NotImplementedError("rolloff needs to be True")
return create_synthetic_hdr_clut_profile(
"PQ",
rgb_space,
description,
black_cdm2,
white_cdm2,
master_black_cdm2,
master_white_cdm2,
use_alternate_master_white_clip,
1.2, # Not used for PQ
5.0, # Not used for PQ
1.0, # Not used for PQ
content_rgb_space,
clutres,
mode,
sat,
hue,
forward_xicclu,
backward_xicclu,
generate_B2A,
worker,
logfile,
cat,
)
def create_synthetic_hdr_clut_profile(
hdr_format,
rgb_space,
description,
black_cdm2=0,
white_cdm2=400,
master_black_cdm2=0, # Not used for HLG
master_white_cdm2=10000, # Not used for HLG
use_alternate_master_white_clip=True, # Not used for HLG
system_gamma=1.2, # Not used for PQ
ambient_cdm2=5, # Not used for PQ
maxsignal=1.0, # Not used for PQ
content_rgb_space="DCI P3",
clutres=33,
mode="HSV_ICtCp", # Not used for HLG
sat=1.0, # Not used for HLG
hue=0.5, # Not used for HLG
forward_xicclu=None,
backward_xicclu=None,
generate_B2A=False,
worker=None,
logfile=None,
cat="Bradford",
):
"""Create a synthetic HDR cLUT profile from a colorspace definition"""
rgb_space = colormath.get_rgb_space(rgb_space)
content_rgb_space = colormath.get_rgb_space(content_rgb_space)
if hdr_format == "PQ":
bt2390 = colormath.BT2390(
black_cdm2,
white_cdm2,
master_black_cdm2,
master_white_cdm2,
use_alternate_master_white_clip,
)
# Preserve detail in saturated colors if mastering display peak < 10K cd/m2
# XXX: Effect is detrimental to contrast at low target peak, and looks
# artificial for BT.2390-4. Don't use for now.
preserve_saturated_detail = False # master_white_cdm2 < 10000
if preserve_saturated_detail:
bt2390s = colormath.BT2390(black_cdm2, white_cdm2, master_black_cdm2, 10000)
maxv = white_cdm2 / 10000.0
eotf = lambda v: colormath.specialpow(v, -2084)
oetf = eotf_inverse = lambda v: colormath.specialpow(v, 1.0 / -2084)
eetf = bt2390.apply
# Apply a slight power to the segments to optimize encoding
encpow = min(max(bt2390.omaxi * (5 / 3.0), 1.0), 1.5)
def encf(v):
if v < bt2390.mmaxi:
v = colormath.convert_range(v, 0, bt2390.mmaxi, 0, 1)
v = colormath.specialpow(v, 1.0 / encpow, 2)
return colormath.convert_range(v, 0, 1, 0, bt2390.mmaxi)
else:
return v
def encf_inverse(v):
if v < bt2390.mmaxi:
v = colormath.convert_range(v, 0, bt2390.mmaxi, 0, 1)
v = colormath.specialpow(v, encpow, 2)
return colormath.convert_range(v, 0, 1, 0, bt2390.mmaxi)
else:
return v
elif hdr_format == "HLG":
# Note: Unlike the PQ black level lift, we apply HLG black offset as
# separate final step, not as part of the HLG EOTF
hlg = colormath.HLG(0, white_cdm2, system_gamma, ambient_cdm2, rgb_space)
if maxsignal < 1:
# Adjust EOTF so that EOTF[maxsignal] gives (approx) white_cdm2
while hlg.eotf(maxsignal) * hlg.white_cdm2 < white_cdm2:
hlg.white_cdm2 += 1
lscale = 1.0 / hlg.oetf(1.0, True)
hlg.white_cdm2 *= lscale
if lscale < 1 and logfile:
logfile.write(
"Nominal peak luminance after scaling = %.2f\n" % hlg.white_cdm2
)
Ymax = hlg.eotf(maxsignal)
maxv = 1.0
eotf = hlg.eotf
eotf_inverse = lambda v: hlg.eotf(v, True)
oetf = hlg.oetf
eetf = lambda v: v
encf = lambda v: v
else:
raise NotImplementedError("Unknown HDR format %r" % hdr_format)
tonemap = eetf(1) != 1
profile = ICCProfile()
profile.version = 2.2 # Match ArgyllCMS
profile.tags.desc = TextDescriptionType(b"", "desc")
profile.tags.desc.ASCII = description
profile.tags.cprt = TextType(b"text\0\0\0\0Public domain\0", "cprt")
profile.tags.wtpt = XYZType(profile=profile)
(
profile.tags.wtpt.X,
profile.tags.wtpt.Y,
profile.tags.wtpt.Z,
) = colormath.get_whitepoint(rgb_space[1])
profile.tags.arts = chromaticAdaptionTag()
profile.tags.arts.update(colormath.get_cat_matrix(cat))
itable = profile.tags.A2B0 = LUT16Type(None, "A2B0", profile)
itable.matrix = colormath.Matrix3x3([(1, 0, 0), (0, 1, 0), (0, 0, 1)])
# HDR RGB
debugtable0 = profile.tags.DBG0 = LUT16Type(None, "DBG0", profile)
debugtable0.matrix = colormath.Matrix3x3([(1, 0, 0), (0, 1, 0), (0, 0, 1)])
# Display RGB
debugtable1 = profile.tags.DBG1 = LUT16Type(None, "DBG1", profile)
debugtable1.matrix = colormath.Matrix3x3([(1, 0, 0), (0, 1, 0), (0, 0, 1)])
# Display XYZ
debugtable2 = profile.tags.DBG2 = LUT16Type(None, "DBG2", profile)
debugtable2.matrix = colormath.Matrix3x3([(1, 0, 0), (0, 1, 0), (0, 0, 1)])
if generate_B2A:
otable = profile.tags.B2A0 = LUT16Type(None, "B2A0", profile)
Xr, Yr, Zr = colormath.adapt(
*colormath.RGB2XYZ(1, 0, 0, rgb_space=rgb_space),
whitepoint_source=rgb_space[1],
cat=cat
)
Xg, Yg, Zg = colormath.adapt(
*colormath.RGB2XYZ(0, 1, 0, rgb_space=rgb_space),
whitepoint_source=rgb_space[1],
cat=cat
)
Xb, Yb, Zb = colormath.adapt(
*colormath.RGB2XYZ(0, 0, 1, rgb_space=rgb_space),
whitepoint_source=rgb_space[1],
cat=cat
)
m1 = colormath.Matrix3x3(((Xr, Xg, Xb), (Yr, Yg, Yb), (Zr, Zg, Zb)))
m2 = m1.inverted()
scale = 1 + (32767 / 32768.0)
m3 = colormath.Matrix3x3(((scale, 0, 0), (0, scale, 0), (0, 0, scale)))
otable.matrix = m2 * m3
# Input curve interpolation
# Normlly the input curves would either be linear (= 1:1 mapping to
# cLUT) or the respective tone response curve.
# We use a overall linear curve that is 'bent' in intervals
# to accomodate the non-linear TRC. Thus, we can get away with much
# fewer cLUT grid points.
# Use higher interpolation size than actual number of curve entries
steps = 2**15 + 1
maxstep = steps - 1.0
segment = 1.0 / (clutres - 1.0)
iv = 0.0
prevpow = eotf(eetf(0))
# Apply a slight power to segments to optimize encoding
nextpow = eotf(eetf(encf(segment)))
prevv = 0
pprevpow = [0]
clipped = False
xp = []
if generate_B2A:
oxp = []
for j in range(steps):
v = j / maxstep
if v > iv + segment:
iv += segment
prevpow = nextpow
# Apply a slight power to segments to optimize encoding
nextpow = eotf(eetf(encf(iv + segment)))
if nextpow > prevpow or test_input_curve_clipping:
prevs = 1.0 - (v - iv) / segment
nexts = (v - iv) / segment
vv = prevs * prevpow + nexts * nextpow
prevv = v
if prevpow > pprevpow[-1]:
pprevpow.append(prevpow)
else:
clipped = True
# Linearly interpolate
vv = colormath.convert_range(v, prevv, 1, prevpow, 1)
out = eotf_inverse(vv)
xp.append(out)
if generate_B2A:
oxp.append(eotf(eetf(v)) / maxv)
interp = colormath.Interp(xp, list(range(steps)), use_numpy=True)
if generate_B2A:
ointerp = colormath.Interp(oxp, list(range(steps)), use_numpy=True)
# Save interpolation input values for diagnostic purposes
profile.tags.kTRC = CurveType()
interp_inverse = colormath.Interp(list(range(steps)), xp, use_numpy=True)
profile.tags.kTRC[:] = [
interp_inverse(colormath.convert_range(v, 0, 2048, 0, maxstep)) * 65535
for v in range(2049)
]
# Create input and output curves
for _i in range(3):
itable.input.append([])
itable.output.append([0, 65535])
debugtable0.input.append([0, 65535])
debugtable0.output.append([0, 65535])
debugtable1.input.append([0, 65535])
debugtable1.output.append([0, 65535])
debugtable2.input.append([0, 65535])
debugtable2.output.append([0, 65535])
if generate_B2A:
otable.input.append([])
otable.output.append([0, 65535])
# Generate device-to-PCS shaper curves from interpolated values
if logfile:
logfile.write("Generating device-to-PCS shaper curves...\n")
entries = 1025
prevperc = 0
if generate_B2A:
endperc = 1
else:
endperc = 2
threshold = eotf_inverse(pprevpow[-2])
k = None
end = eotf_inverse(pprevpow[-1])
l = entries - 1
if end > threshold:
for j in range(entries):
n = j / (entries - 1.0)
if eetf(n) > end:
l = j - 1
break
for j in range(entries):
if worker and worker.thread_abort:
if forward_xicclu:
forward_xicclu.exit()
if backward_xicclu:
backward_xicclu.exit()
raise Exception("aborted")
n = j / (entries - 1.0)
v = interp(eetf(n)) / maxstep
if hdr_format == "PQ":
# threshold = 1.0 - segment * math.ceil((1.0 - bt2390.mmaxi) *
# (clutres - 1.0) + 1)
# check = n >= threshold
check = tonemap and eetf(n + (1 / (entries - 1.0))) > threshold
elif hdr_format == "HLG":
check = maxsignal < 1 and n >= maxsignal
if check and not test_input_curve_clipping:
# Linear interpolate shaper for last n cLUT steps to prevent
# clipping in shaper
if k is None:
k = j
ov = v
ev = interp(eetf(l / (entries - 1.0))) / maxstep
# v = min(ov + (1.0 - ov) * ((j - k) / (entries - k - 1.0)), 1.0)
v = min(colormath.convert_range(j, k, l, ov, ev), n)
for i in range(3):
itable.input[i].append(v * 65535)
perc = math.floor(n * endperc)
if logfile and perc > prevperc:
logfile.write("\r%i%%" % perc)
prevperc = perc
startperc = perc
if generate_B2A:
# Generate PCS-to-device shaper curves from interpolated values
if logfile:
logfile.write("\rGenerating PCS-to-device shaper curves...\n")
logfile.write("\r%i%%" % perc)
for j in range(4096):
if worker and worker.thread_abort:
if forward_xicclu:
forward_xicclu.exit()
if backward_xicclu:
backward_xicclu.exit()
raise Exception("aborted")
n = j / 4095.0
v = ointerp(n) / maxstep * 65535
for i in range(3):
otable.input[i].append(v)
perc = startperc + math.floor(n)
if logfile and perc > prevperc:
logfile.write("\r%i%%" % perc)
prevperc = perc
startperc = perc
# Scene RGB -> HDR tone mapping -> HDR XYZ -> backward lookup -> display RGB
itable.clut = []
debugtable0.clut = []
debugtable1.clut = []
debugtable2.clut = []
clutmax = clutres - 1.0
step = 1.0 / clutmax
count = 0
# Lpt is the preferred mode for chroma blending. Some preliminary visual
# comparison has shown it does overall the best job preserving hue and
# saturation (blue hues superior to IPT). DIN99d is the second best,
# but vibrant red turns slightly orange when desaturated (DIN99d has best
# blue saturation preservation though).
blendmode = "Lpt"
IPT_white_XYZ = colormath.get_cat_matrix("IPT").inverted() * (1, 1, 1)
Cmode = ("all", "primaries_secondaries")[0]
RGB_in = []
HDR_ICtCp = []
HDR_RGB = []
HDR_XYZ = []
HDR_min_I = []
logmsg = "\rGenerating lookup table"
if hdr_format == "PQ" and tonemap:
logmsg += " and applying HDR tone mapping"
endperc = 25
else:
endperc = 50
if logfile:
logfile.write(logmsg + "...\n")
logfile.write("\r%i%%" % perc)
# Selective hue preservation for redorange/orange
# (otherwise shift towards yellow to preserve more saturation and detail)
# Hue angles (RGB):
# red, yellow, yellow, green, red
hinterp = colormath.Interp(
[0, 0.166666, 0.166666, 1], [1, hue, 1, 1], use_numpy=True
)
# Saturation adjustment for yellow/green/cyan
# Hue angles (RGB):
# red, orange, yellow, green, cyan, cyan/blue, red
sinterp = colormath.Interp(
[0, 0.083333, 0.166666, 0.333333, 0.5, 0.583333, 1],
[1, 1, 0.5, 0.5, 0.5, 1, 1],
use_numpy=True,
)
for R in range(clutres):
for G in range(clutres):
for B in range(clutres):
if worker and worker.thread_abort:
if forward_xicclu:
forward_xicclu.exit()
if backward_xicclu:
backward_xicclu.exit()
raise Exception("aborted")
# Apply a slight power to the segments to optimize encoding
RGB = [encf(v * step) for v in (R, G, B)]
RGB_in.append(tuple(RGB))
if debug and R == G == B:
print("RGB %5.3f %5.3f %5.3f" % tuple(RGB), end=" ")
RGB_sum = sum(RGB)
if hdr_format == "PQ" and mode in (
"HSV",
"HSV_ICtCp",
"ICtCp",
"RGB_ICtCp",
):
# Record original hue angle, saturation and value
H, S, V = colormath.RGB2HSV(*RGB)
if hdr_format == "PQ" and mode in ("HSV_ICtCp", "ICtCp", "RGB_ICtCp"):
I1, Ct1, Cp1 = colormath.RGB2ICtCp(
*RGB, rgb_space=rgb_space, eotf=eotf, oetf=eotf_inverse
)
if debug and R == G == B:
print(
"-> ICtCp % 5.3f % 5.3f % 5.3f"
% (
I1,
Ct1,
Cp1,
),
end=" ",
)
I2 = eetf(I1)
if preserve_saturated_detail and S:
sf = S
I2 *= 1 - sf
I2 += bt2390s.apply(I1) * sf
if hdr_format == "HLG":
X, Y, Z = hlg.RGB2XYZ(*RGB)
if Y:
Y1 = Y
I1 = hlg.eotf(Y, True)
I2 = min(I1, maxsignal)
Y2 = hlg.eotf(I2)
Y3 = Y2 / Ymax
X, Y, Z = (v / Y * Y3 if Y else v for v in (X, Y, Z))
if R == G == B and logfile and debug:
logfile.write(
"\rE %.4f -> E' %.4f -> roll-off -> %.4f -> E %.4f -> scale (%i%%) -> %.4f\n"
% (Y1, I1, I2, Y2, Y3 / Y2 * 100, Y3)
)
elif mode == "XYZ":
X, Y, Z = colormath.RGB2XYZ(*RGB, rgb_space=rgb_space, eotf=eotf)
if Y:
I1 = colormath.specialpow(Y, 1.0 / -2084)
I2 = eetf(I1)
Y2 = colormath.specialpow(I2, -2084)
X, Y, Z = (v / Y * Y2 for v in (X, Y, Z))
else:
I1 = I2 = 0
elif mode in ("HSV", "HSV_ICtCp", "ICtCp", "RGB", "RGB_ICtCp"):
if mode in ("HSV", "RGB"):
I1 = max(RGB)
if mode in ("HSV", "HSV_ICtCp", "ICtCp", "RGB_ICtCp"):
# Allow hue shift based on hue angle
hf = hinterp(H)
# Saturation adjustment
cf = sinterp(H)
for i, v in enumerate(RGB):
RGB[i] = eetf(v)
if preserve_saturated_detail and S:
sf = S
RGB[i] *= 1 - sf
RGB[i] += bt2390s.apply(v) * sf
RGB_shifted = RGB # Potentially hue shifted RGB
if mode in ("HSV", "HSV_ICtCp"):
HSV = list(colormath.RGB2HSV(*RGB_shifted))
if mode == "HSV":
# Allow hue shift based on hue angle
H = H * hf + HSV[0] * (1 - hf)
# Set hue angle
HSV[0] = H
RGB = colormath.HSV2RGB(*HSV)
if mode in ("HSV", "RGB"):
I2 = max(RGB)
elif mode == "YRGB":
LinearRGB = [eotf(v) for v in RGB]
I1 = (
0.2627 * LinearRGB[0]
+ 0.678 * LinearRGB[1]
+ 0.0593 * LinearRGB[2]
)
I2 = eotf(eetf(eotf_inverse(I1)))
if I1:
min_I = I2 / I1
else:
min_I = 1
RGB = [eotf_inverse(min_I * v) for v in LinearRGB]
if (
hdr_format == "PQ"
and mode in ("HSV_ICtCp", "ICtCp", "RGB_ICtCp", "XYZ")
and I1
and I2
):
if mode != "ICtCp" or (forward_xicclu and backward_xicclu):
# Don't desaturate colors which are lighter after
# roll-off if mode is not ICtCp or if doing
# display-based desaturation
dsat = 1.0
else:
# Desaturate colors which are lighter after roll-off
# if mode is ICtCp and not doing display-based
# desaturation
dsat = I1 / I2
min_I = min(dsat, I2 / I1)
else:
min_I = 1
if hdr_format == "PQ" and mode in ("HSV_ICtCp", "ICtCp", "RGB_ICtCp"):
if debug and R == G == B:
print("* %5.3f" % min_I, "->", end=" ")
Ct2, Cp2 = (min_I * v for v in (Ct1, Cp1))
if debug and R == G == B:
print("% 5.3f % 5.3f % 5.3f" % (I2, Ct2, Cp2), "->", end=" ")
if hdr_format == "HLG":
pass
elif mode == "XYZ":
X, Y, Z = colormath.XYZsaturation(X, Y, Z, min_I, rgb_space[1])[0]
RGB = colormath.XYZ2RGB(X, Y, Z, rgb_space, oetf=eotf_inverse)
elif mode == "ICtCp":
X, Y, Z = colormath.ICtCp2XYZ(I2, Ct2, Cp2)
RGB = colormath.XYZ2RGB(
X, Y, Z, rgb_space, clamp=False, oetf=eotf_inverse
)
if debug and R == G == B:
print("RGB %5.3f %5.3f %5.3f" % tuple(RGB))
HDR_RGB.append(RGB)
if hdr_format == "HLG":
pass
elif mode not in ("XYZ", "ICtCp"):
X, Y, Z = colormath.RGB2XYZ(*RGB, rgb_space=rgb_space, eotf=eotf)
if hdr_format == "PQ" and mode in ("HSV_ICtCp", "ICtCp", "RGB_ICtCp"):
# Use hue and chroma from ICtCp
I, Ct, Cp = colormath.XYZ2ICtCp(X, Y, Z)
L, C, H = colormath.Lab2LCHab(I * 100, Ct * 100, Cp * 100)
L2, C2, H2 = colormath.Lab2LCHab(I2 * 100, Ct2 * 100, Cp2 * 100)
# Allow hue shift based on hue angle
I3, Ct3, Cp3 = colormath.RGB2ICtCp(
*RGB_shifted, rgb_space=rgb_space, eotf=eotf, oetf=eotf_inverse
)
L3, C3, H3 = colormath.Lab2LCHab(I3 * 100, Ct3 * 100, Cp3 * 100)
L = L * hf + L3 * (1 - hf)
C = C * hf + C3 * (1 - hf)
H2 = H2 * hf + H3 * (1 - hf)
# Saturation adjustment
C = colormath.convert_range(I1, I2, 1, C2, min(C2, C) * cf)
I, Ct2, Cp2 = (v / 100.0 for v in colormath.LCHab2Lab(L, C, H2))
Ct, Cp = Ct2, Cp2
if I1 > I2:
f = colormath.convert_range(I1, I2, 1, 1, 0)
Ct2, Cp2 = (v * f for v in (Ct2, Cp2))
if mode in ("HSV_ICtCp", "RGB_ICtCp"):
f = colormath.convert_range(sum(RGB_in[-1]), 0, 3, 1, sat)
Ct2 = Ct * f + Ct2 * (1 - f)
Cp2 = Cp * f + Cp2 * (1 - f)
I2 = I * f + I2 * (1 - f)
X, Y, Z = colormath.ICtCp2XYZ(I2, Ct2, Cp2)
RGB_ICtCp_XYZ = list((X, Y, Z))
else:
# RGB_ICtCp_XYZ = [v / maxv for v in (X, Y, Z)]
RGB_ICtCp_XYZ = [X, Y, Z]
# X, Y, Z = (v / maxv for v in (X, Y, Z))
HDR_XYZ.append((RGB_in[-1], [X, Y, Z], RGB_ICtCp_XYZ))
HDR_min_I.append(min_I)
count += 1
perc = startperc + math.floor(
count / clutres**3.0 * (endperc - startperc)
)
if logfile and perc > prevperc:
logfile.write("\r%i%%" % perc)
prevperc = perc
if hdr_format == "PQ" and tonemap:
from DisplayCAL.multiprocess import cpu_count, pool_slice
num_cpus = cpu_count()
num_workers = num_cpus
if num_cpus > 2:
num_workers -= 1
num_batches = clutres // 6
HDR_XYZ = sum(
pool_slice(
_mp_hdr_tonemap,
HDR_XYZ,
(rgb_space, maxv, sat, cat),
{},
num_workers,
worker and worker.thread_abort,
logfile,
num_batches,
perc,
),
[],
)
prevperc = startperc = perc = 75
else:
prevperc = startperc = perc = 50
for i, item in enumerate(HDR_XYZ):
if not item: # Aborted
if worker and worker.thread_abort:
if forward_xicclu:
forward_xicclu.exit()
if backward_xicclu:
backward_xicclu.exit()
raise Exception("aborted")
(RGB, (X, Y, Z), RGB_ICtCp_XYZ) = item
I, Ct, Cp = colormath.XYZ2ICtCp(X, Y, Z, oetf=eotf_inverse)
X, Y, Z = (v / maxv for v in (X, Y, Z))
HDR_ICtCp.append((I, Ct, Cp))
# Adapt to D50
X, Y, Z = colormath.adapt(X, Y, Z, whitepoint_source=rgb_space[1], cat=cat)
if max(X, Y, Z) * 32768 > 65535 or min(X, Y, Z) < 0 or round(Y, 6) > 1:
# This should not happen
print(
"#%i" % i,
"RGB %.3f %.3f %.3f" % tuple(RGB),
"XYZ %.6f %.6f %.6f" % (X, Y, Z),
"not in range [0,1]",
)
HDR_XYZ[i] = (X, Y, Z)
perc = startperc + math.floor(i / clutres**3.0 * (100 - startperc))
if logfile and perc > prevperc:
logfile.write("\r%i%%" % perc)
prevperc = perc
prevperc = startperc = perc = 0
if forward_xicclu and backward_xicclu and logfile:
logfile.write("\rDoing backward lookup...\n")
logfile.write("\r%i%%" % perc)
count = 0
for _i, (X, Y, Z) in enumerate(HDR_XYZ):
if worker and worker.thread_abort:
if forward_xicclu:
forward_xicclu.exit()
if backward_xicclu:
backward_xicclu.exit()
raise Exception("aborted")
if forward_xicclu and backward_xicclu and Cmode != "primaries_secondaries":
# HDR XYZ -> backward lookup -> display RGB
backward_xicclu((X, Y, Z))
count += 1
perc = startperc + math.floor(count / clutres**3.0 * (100 - startperc))
if (
logfile
and perc > prevperc
and backward_xicclu.__class__.__name__ == "Xicclu"
):
logfile.write("\r%i%%" % perc)
prevperc = perc
prevperc = startperc = perc = 0
Cdiff = []
Cmax = {}
Cdmax = {}
if forward_xicclu and backward_xicclu:
# Display RGB -> forward lookup -> display XYZ
backward_xicclu.close()
try:
display_RGB = backward_xicclu.get()
except Exception:
if forward_xicclu:
# Make sure resources are not held in use
forward_xicclu.exit()
raise
finally:
backward_xicclu.exit()
if logfile:
logfile.write("\rDoing forward lookup...\n")
logfile.write("\r%i%%" % perc)
# Smooth
row = 0
for col_0 in range(clutres):
for col_1 in range(clutres):
debugtable1.clut.append([])
for col_2 in range(clutres):
RGBdisp = display_RGB[row]
debugtable1.clut[-1].append(
[min(max(v * 65535, 0), 65535) for v in RGBdisp]
)
row += 1
debugtable1.smooth()
display_RGB = []
for block in debugtable1.clut:
for row in block:
display_RGB.append([v / 65535.0 for v in row])
for i, (R, G, B) in enumerate(display_RGB):
if worker and worker.thread_abort:
if forward_xicclu:
forward_xicclu.exit()
if backward_xicclu:
backward_xicclu.exit()
raise Exception("aborted")
forward_xicclu((R, G, B))
perc = startperc + math.floor((i + 1) / clutres**3.0 * (100 - startperc))
if (
logfile
and perc > prevperc
and forward_xicclu.__class__.__name__ == "Xicclu"
):
logfile.write("\r%i%%" % perc)
prevperc = perc
prevperc = startperc = perc = 0
if Cmode == "primaries_secondaries":
# Compare to chroma of content primaries/secondaries to determine
# general chroma compression factor
forward_xicclu((0, 0, 1))
forward_xicclu((0, 1, 0))
forward_xicclu((1, 0, 0))
forward_xicclu((0, 1, 1))
forward_xicclu((1, 0, 1))
forward_xicclu((1, 1, 0))
forward_xicclu.close()
display_XYZ = forward_xicclu.get()
if Cmode == "primaries_secondaries":
for i in range(6):
if i == 0:
# Blue
j = clutres - 1
elif i == 1:
# Green
j = clutres**2 - clutres
elif i == 2:
# Red
j = clutres**3 - clutres**2
elif i == 3:
# Cyan
j = clutres**2 - 1
elif i == 4:
# Magenta
j = clutres**3 - clutres**2 + clutres - 1
elif i == 5:
# Yellow
j = clutres**3 - clutres
R, G, B = RGB_in[j]
XYZsrc = HDR_XYZ[j]
XYZdisp = display_XYZ[-(6 - i)]
XYZc = colormath.RGB2XYZ(R, G, B, content_rgb_space, eotf=eotf)
XYZc = colormath.adapt(
*XYZc, whitepoint_source=content_rgb_space[1], cat=cat
)
L, C, H = colormath.XYZ2DIN99dLCH(*(v * 100 for v in XYZc))
Ld, Cd, Hd = colormath.XYZ2DIN99dLCH(*(v * 100 for v in XYZdisp))
Cdmaxk = tuple(map(round, (Ld, Hd)))
if C > Cmax.get(Cdmaxk, -1):
Cmax[Cdmaxk] = C
Cdiff.append(min(Cd / C, 1.0))
if Cd > Cdmax.get(Cdmaxk, -1):
Cdmax[Cdmaxk] = Cd
print("RGB in %5.2f %5.2f %5.2f" % (R, G, B))
print(
"Content BT2020 XYZ (DIN99d) %5.2f %5.2f %5.2f"
% tuple(v * 100 for v in XYZc)
)
print("Content BT2020 LCH (DIN99d) %5.2f %5.2f %5.2f" % (L, C, H))
print("Display XYZ %5.2f %5.2f %5.2f" % tuple(v * 100 for v in XYZdisp))
print("Display LCH (DIN99d) %5.2f %5.2f %5.2f" % (Ld, Cd, Hd))
if logfile:
logfile.write(
"\r%s chroma compression factor: %6.4f\n"
% (
{0: "B", 1: "G", 2: "R", 3: "C", 4: "M", 5: "Y"}[i],
Cdiff[-1],
)
)
# Tweak so that it gives roughly 0.91 for a Rec. 709 target
general_compression_factor = (sum(Cdiff) / len(Cdiff)) * 0.99
else:
display_RGB = False
display_XYZ = False
display_LCH = []
if Cmode != "primaries_secondaries" and display_XYZ:
# Determine compression factor by comparing display to content
# colorspace in BT.2020
if logfile:
logfile.write("\rDetermining chroma compression factors...\n")
logfile.write("\r%i%%" % perc)
for i, XYZsrc in enumerate(HDR_XYZ):
if worker and worker.thread_abort:
if forward_xicclu:
forward_xicclu.exit()
if backward_xicclu:
backward_xicclu.exit()
raise Exception("aborted")
if display_XYZ:
XYZdisp = display_XYZ[i]
# # Adjust luminance from destination to source
# Ydisp = XYZdisp[1]
# if Ydisp:
# XYZdisp = [v / Ydisp * XYZsrc[1] for v in XYZdisp]
else:
XYZdisp = XYZsrc
X, Y, Z = (v * maxv for v in XYZsrc)
X, Y, Z = colormath.adapt(
X, Y, Z, whitepoint_destination=content_rgb_space[1], cat=cat
)
R, G, B = colormath.XYZ2RGB(X, Y, Z, content_rgb_space, oetf=eotf_inverse)
XYZc = colormath.RGB2XYZ(R, G, B, content_rgb_space, eotf=eotf)
XYZc = colormath.adapt(
*XYZc,
whitepoint_source=content_rgb_space[1],
whitepoint_destination=rgb_space[1],
cat=cat
)
RGBc_r2020 = colormath.XYZ2RGB(
*XYZc, rgb_space=rgb_space, oetf=eotf_inverse
)
XYZc_r2020 = colormath.RGB2XYZ(*RGBc_r2020, rgb_space=rgb_space, eotf=eotf)
if blendmode == "ICtCp":
I, Ct, Cp = colormath.XYZ2ICtCp(*XYZc_r2020, oetf=eotf_inverse)
L, C, H = colormath.Lab2LCHab(I * 100, Cp * 100, Ct * 100)
XYZdispa = colormath.adapt(
*XYZdisp, whitepoint_destination=rgb_space[1], cat=cat
)
Id, Ctd, Cpd = colormath.XYZ2ICtCp(
*(v * maxv for v in XYZdispa), oetf=eotf_inverse
)
Ld, Cd, Hd = colormath.Lab2LCHab(Id * 100, Cpd * 100, Ctd * 100)
elif blendmode == "IPT":
XYZc_r2020 = colormath.adapt(
*XYZc_r2020,
whitepoint_source=rgb_space[1],
whitepoint_destination=IPT_white_XYZ,
cat=cat
)
I, CP, CT = colormath.XYZ2IPT(*XYZc_r2020)
L, C, H = colormath.Lab2LCHab(I * 100, CP * 100, CT * 100)
XYZdispa = colormath.adapt(
*XYZdisp, whitepoint_destination=IPT_white_XYZ, cat=cat
)
Id, Pd, Td = colormath.XYZ2IPT(*XYZdispa)
Ld, Cd, Hd = colormath.Lab2LCHab(Id * 100, Pd * 100, Td * 100)
elif blendmode == "Lpt":
XYZc_r2020 = colormath.adapt(
*XYZc_r2020, whitepoint_source=rgb_space[1], cat=cat
)
L, p, t = colormath.XYZ2Lpt(*(v / maxv * 100 for v in XYZc_r2020))
L, C, H = colormath.Lab2LCHab(L, p, t)
Ld, pd, td = colormath.XYZ2Lpt(*(v * 100 for v in XYZdisp))
Ld, Cd, Hd = colormath.Lab2LCHab(Ld, pd, td)
elif blendmode == "XYZ":
XYZc_r2020 = colormath.adapt(
*XYZc_r2020, whitepoint_source=rgb_space[1], cat=cat
)
wx, wy = colormath.XYZ2xyY(*colormath.get_whitepoint())[:2]
x, y, Y = colormath.XYZ2xyY(*XYZc_r2020)
x -= wx
y -= wy
L, C, H = colormath.Lab2LCHab(*(v * 100 for v in (Y, x, y)))
x, y, Y = colormath.XYZ2xyY(*XYZdisp)
x -= wx
y -= wy
Ld, Cd, Hd = colormath.Lab2LCHab(*(v * 100 for v in (Y, x, y)))
else:
# DIN99d
XYZc_r202099 = colormath.adapt(
*XYZc_r2020, whitepoint_source=rgb_space[1], cat=cat
)
L, C, H = colormath.XYZ2DIN99dLCH(
*(v / maxv * 100 for v in XYZc_r202099)
)
Ld, Cd, Hd = colormath.XYZ2DIN99dLCH(*(v * 100 for v in XYZdisp))
Cdmaxk = tuple(map(round, (Ld, Hd), (2, 2)))
if C > Cmax.get(Cdmaxk, -1):
Cmax[Cdmaxk] = C
if C:
# print '%6.3f %6.3f' % (Cd, C)
Cdiff.append(min(Cd / C, 1.0))
# if Cdiff[-1] < 0.0001:
# raise RuntimeError("#%i RGB % 5.3f % 5.3f % 5.3f Cdiff %5.3f" % (i, R, G, B, Cdiff[-1]))
else:
Cdiff.append(1.0)
display_LCH.append((Ld, Cd, Hd))
if Cd > Cdmax.get(Cdmaxk, -1):
Cdmax[Cdmaxk] = Cd
if debug:
print("RGB in %5.2f %5.2f %5.2f" % tuple(RGB_in[i]))
print("RGB out %5.2f %5.2f %5.2f" % (R, G, B))
print(
"Content BT2020 XYZ %5.2f %5.2f %5.2f"
% tuple(v / maxv * 100 for v in XYZc_r2020)
)
print("Content BT2020 LCH %5.2f %5.2f %5.2f" % (L, C, H))
print("Display XYZ %5.2f %5.2f %5.2f" % tuple(v * 100 for v in XYZdisp))
print("Display LCH %5.2f %5.2f %5.2f" % (Ld, Cd, Hd))
perc = startperc + math.floor(i / clutres**3.0 * (80 - startperc))
if logfile and perc > prevperc:
logfile.write("\r%i%%" % perc)
prevperc = perc
startperc = perc
general_compression_factor = sum(Cdiff) / len(Cdiff)
if display_XYZ:
Cmaxv = max(Cmax.values())
Cdmaxv = max(Cdmax.values())
if logfile and display_LCH and Cmode == "primaries_secondaries":
logfile.write(
"\rChroma compression factor: %6.4f\n" % general_compression_factor
)
# Chroma compress to display XYZ
if logfile:
if display_XYZ:
logfile.write("\rApplying chroma compression and filling cLUT...\n")
else:
logfile.write("\rFilling cLUT...\n")
logfile.write("\r%i%%" % perc)
row = 0
oog_count = 0
# if forward_xicclu:
# forward_xicclu.spawn()
# if backward_xicclu:
# backward_xicclu.spawn()
for col_0 in range(clutres):
for col_1 in range(clutres):
itable.clut.append([])
debugtable0.clut.append([])
if not display_RGB:
debugtable1.clut.append([])
debugtable2.clut.append([])
for col_2 in range(clutres):
if worker and worker.thread_abort:
if forward_xicclu:
forward_xicclu.exit()
if backward_xicclu:
backward_xicclu.exit()
raise Exception("aborted")
R, G, B = HDR_RGB[row]
I, Ct, Cp = HDR_ICtCp[row]
X, Y, Z = HDR_XYZ[row]
min_I = HDR_min_I[row]
if not (col_0 == col_1 == col_2) and display_XYZ:
# Desaturate based on compression factor
if display_LCH:
blend = 1
else:
# Blending threshold: Don't desaturate dark colors
# (< 26 cd/m2). Preserves more "pop"
thresh_I = 0.381
blend = min_I * min(
max((I - thresh_I) / (0.5081 - thresh_I), 0), 1
)
if blend:
if blendmode == "XYZ":
wx, wy = colormath.XYZ2xyY(*colormath.get_whitepoint())[:2]
x, y, Y = colormath.XYZ2xyY(X, Y, Z)
x -= wx
y -= wy
L, C, H = colormath.Lab2LCHab(*(v * 100 for v in (Y, x, y)))
elif blendmode == "ICtCp":
L, C, H = colormath.Lab2LCHab(I * 100, Cp * 100, Ct * 100)
elif blendmode == "DIN99d":
XYZ = X, Y, Z
L, C, H = colormath.XYZ2DIN99dLCH(*[v * 100 for v in XYZ])
elif blendmode == "IPT":
XYZ = colormath.adapt(
X, Y, Z, whitepoint_destination=IPT_white_XYZ, cat=cat
)
I, CP, CT = colormath.XYZ2IPT(*XYZ)
L, C, H = colormath.Lab2LCHab(I * 100, CP * 100, CT * 100)
elif blendmode == "Lpt":
XYZ = X, Y, Z
L, p, t = colormath.XYZ2Lpt(*[v * 100 for v in XYZ])
L, C, H = colormath.Lab2LCHab(L, p, t)
if blendmode:
if display_LCH:
Ld, Cd, Hd = display_LCH[row]
# Cdmaxk = tuple(map(round, (Ld, Hd), (2, 2)))
# # Lookup HDR max chroma for given display
# # luminance and hue
# HCmax = Cmax[Cdmaxk]
# if C and HCmax:
# # Lookup display max chroma for given display
# # luminance and hue
# HCdmax = Cdmax[Cdmaxk]
# # Display max chroma in 0..1 range
# maxCc = min(HCdmax / HCmax, 1.0)
# KSCc = 1.5 * maxCc - 0.5
# # HDR chroma in 0..1 range
# Cc1 = min(C / HCmax, 1.0)
# if Cc1 >= KSCc <= 1 and maxCc > KSCc >= 0:
# # Roll-off chroma
# Cc2 = bt2390.apply(Cc1, KSCc,
# maxCc, 1.0, 0,
# normalize=False)
# C = HCmax * Cc2
# else:
# # Use display chroma as-is (clip)
# if debug:
# print("CLUT grid point %i %i %i: "
# "C %6.4f Cd %6.4f HCmax %6.4f maxCc "
# "%6.4f KSCc %6.4f Cc1 %6.4f" %
# (col_0, col_1, col_2, C, Cd,
# HCmax, maxCc, KSCc, Cc1))
# C = Cd
if C:
C *= min(Cd / C, 1.0)
C *= min(Ld / L, 1.0)
else:
Cc = general_compression_factor
Cc **= C / Cmaxv
C = C * (1 - blend) + (C * Cc) * blend
if blendmode == "ICtCp":
I, Cp, Ct = [
v / 100.0 for v in colormath.LCHab2Lab(L, C, H)
]
XYZ = colormath.ICtCp2XYZ(I, Ct, Cp, eotf=eotf)
X, Y, Z = (v / maxv for v in XYZ)
# Adapt to D50
X, Y, Z = colormath.adapt(
X, Y, Z, whitepoint_source=rgb_space[1], cat=cat
)
elif blendmode == "DIN99d":
L, a, b = colormath.DIN99dLCH2Lab(L, C, H)
X, Y, Z = colormath.Lab2XYZ(L, a, b)
elif blendmode == "IPT":
I, CP, CT = [
v / 100.0 for v in colormath.LCHab2Lab(L, C, H)
]
X, Y, Z = colormath.IPT2XYZ(I, CP, CT)
# Adapt to D50
X, Y, Z = colormath.adapt(
X, Y, Z, whitepoint_source=IPT_white_XYZ, cat=cat
)
elif blendmode == "Lpt":
L, p, t = colormath.LCHab2Lab(L, C, H)
X, Y, Z = colormath.Lpt2XYZ(L, p, t)
elif blendmode == "XYZ":
Y, x, y = [v / 100.0 for v in colormath.LCHab2Lab(L, C, H)]
x += wx
y += wy
X, Y, Z = colormath.xyY2XYZ(x, y, Y)
else:
print(
"CLUT grid point %i %i %i: blend = 0"
% (col_0, col_1, col_2)
)
# if backward_xicclu and forward_xicclu:
# backward_xicclu((X, Y, Z))
# else:
# HDR_XYZ[row] = (X, Y, Z)
# row += 1
# perc = startperc + math.floor(row / clutres ** 3.0 *
# (90 - startperc))
# if logfile and perc > prevperc:
# logfile.write("\r%i%%" % perc)
# prevperc = perc
# startperc = perc
# if backward_xicclu and forward_xicclu:
# # Get XYZ clipped to display RGB
# backward_xicclu.exit()
# for R, G, B in backward_xicclu.get():
# forward_xicclu((R, G, B))
# forward_xicclu.exit()
# display_XYZ = forward_xicclu.get()
# else:
# display_XYZ = HDR_XYZ
# row = 0
# for a in range(clutres):
# for b in range(clutres):
# itable.clut.append([])
# debugtable0.clut.append([])
# for c in range(clutres):
# if worker and worker.thread_abort:
# if forward_xicclu:
# forward_xicclu.exit()
# if backward_xicclu:
# backward_xicclu.exit()
# raise Exception("aborted")
# X, Y, Z = display_XYZ[row]
itable.clut[-1].append(
[min(max(v * 32768, 0), 65535) for v in (X, Y, Z)]
)
debugtable0.clut[-1].append(
[min(max(v * 65535, 0), 65535) for v in (R, G, B)]
)
if not display_RGB:
debugtable1.clut[-1].append([0, 0, 0])
if display_XYZ:
XYZdisp = display_XYZ[row]
else:
XYZdisp = [0, 0, 0]
debugtable2.clut[-1].append(
[min(max(v * 65535, 0), 65535) for v in XYZdisp]
)
row += 1
perc = startperc + math.floor(row / clutres**3.0 * (100 - startperc))
if logfile and perc > prevperc:
logfile.write("\r%i%%" % perc)
prevperc = perc
prevperc = startperc = perc = 0
if debug:
print("Num OOG:", oog_count)
if generate_B2A:
if logfile:
logfile.write("\rGenerating PCS-to-device table...\n")
otable.clut = []
count = 0
for R in range(clutres):
for G in range(clutres):
otable.clut.append([])
for B in range(clutres):
RGB = [v * step for v in (R, G, B)]
X, Y, Z = colormath.RGB2XYZ(*RGB, rgb_space=rgb_space, eotf=eotf)
if hdr_format == "PQ":
I1, Ct1, Cp1 = colormath.XYZ2ICtCp(X, Y, Z)
I2 = eetf(I1)
Ct2, Cp2 = (min(I1 / I2, I2 / I1) * v for v in (Ct1, Cp1))
RGB = colormath.ICtCp2RGB(I1, Ct2, Cp2, rgb_space)
else:
RGB = hlg.XYZ2RGB(X, Y, Z)
if (
max(X, Y, Z) * 32768 > 65535
or min(X, Y, Z) < 0
or round(Y, 6) > 1
or max(RGB) > 1
or min(RGB) < 0
):
print(
"#%i" % count,
"RGB %.3f %.3f %.3f" % tuple(RGB),
"XYZ %.6f %.6f %.6f" % (X, Y, Z),
"not in range [0,1]",
)
otable.clut[-1].append([min(max(v, 0), 1) * 65535 for v in RGB])
count += 1
if logfile:
logfile.write("\n")
if forward_xicclu:
forward_xicclu.exit()
if backward_xicclu:
backward_xicclu.exit()
if hdr_format == "HLG" and black_cdm2:
# Apply black offset
XYZbp = colormath.get_whitepoint(scale=black_cdm2 / float(white_cdm2))
if logfile:
logfile.write("Applying black offset...\n")
profile.tags.A2B0.apply_black_offset(
XYZbp, logfile=logfile, thread_abort=worker and worker.thread_abort
)
return profile
def create_synthetic_hlg_clut_profile(
rgb_space,
description,
black_cdm2=0,
white_cdm2=400,
system_gamma=1.2,
ambient_cdm2=5,
maxsignal=1.0,
content_rgb_space="DCI P3",
rolloff=True,
clutres=33,
mode="HSV_ICtCp",
forward_xicclu=None,
backward_xicclu=None,
generate_B2A=True,
worker=None,
logfile=None,
cat="Bradford",
):
"""Create a synthetic cLUT profile with the HLG TRC from a colorspace
definition
mode: The gamut mapping mode when rolling off. Valid values:
"RGB_ICtCp" (default, recommended)
"ICtCp"
"XYZ" (not recommended, unpleasing hue shift)
"HSV" (not recommended, saturation loss)
"RGB" (not recommended, saturation loss, pleasing hue shift)
"""
if not rolloff:
raise NotImplementedError("rolloff needs to be True")
return create_synthetic_hdr_clut_profile(
"HLG",
rgb_space,
description,
black_cdm2,
white_cdm2,
0, # Not used for HLG
10000, # Not used for HLG
True, # Not used for HLG
system_gamma,
ambient_cdm2,
maxsignal,
content_rgb_space,
clutres,
mode, # Not used for HLG
1.0, # Sat - Not used for HLG
0.5, # Hue - Not used for HLG
forward_xicclu,
backward_xicclu,
generate_B2A,
worker,
logfile,
cat,
)
def _colord_get_display_profile(display_no=0, path_only=False, use_cache=True):
"""Use a brute force way of getting display profile."""
edid_ = get_edid(display_no)
device_ids = []
if edid_:
# Try a range of possible device IDs
dife = colord.device_id_from_edid
device_ids = [
dife(edid_, quirk=False, query=True),
dife(edid_, quirk=True, truncate_edid_strings=True),
dife(edid_, quirk=True, use_serial_32=False),
dife(edid_, quirk=True, use_serial_32=False, truncate_edid_strings=True),
dife(edid_, quirk=True),
dife(edid_, quirk=False, truncate_edid_strings=True),
dife(edid_, quirk=False, use_serial_32=False),
dife(edid_, quirk=False, use_serial_32=False, truncate_edid_strings=True),
# Try with manufacturer omitted
dife(edid_, omit_manufacturer=True),
dife(edid_, truncate_edid_strings=True, omit_manufacturer=True),
dife(edid_, use_serial_32=False, omit_manufacturer=True),
dife(edid_, use_serial_32=False, truncate_edid_strings=True, omit_manufacturer=True,),
]
else:
# Fall back to XrandR name
try:
from DisplayCAL import RealDisplaySizeMM as RDSMM
except ImportError as exception:
warnings.warn(str(exception), Warning)
return
display = RDSMM.get_display(display_no)
if display:
xrandr_name = display.get("xrandr_name")
if xrandr_name:
edid_ = {"monitor_name": xrandr_name}
device_ids = [f"xrandr-{xrandr_name.decode()}"]
elif os.getenv("XDG_SESSION_TYPE") == "wayland":
# Preliminary Wayland support under non-GNOME desktops.
# This still needs a lot of work.
device_ids = colord.get_display_device_ids()
if device_ids and display_no < len(device_ids):
edid_ = {
"monitor_name": device_ids[display_no].split("xrandr-", 1).pop()
}
device_ids = [device_ids[display_no]]
if edid_:
for device_id in dict.fromkeys(device_ids).keys():
if device_id:
try:
profile = colord.get_default_profile(device_id)
profile_path = profile.properties.get("Filename")
except colord.CDObjectQueryError:
# Device ID was not found, try next one
continue
except colord.CDError as exception:
warnings.warn(str(exception), Warning)
except colord.DBusException as exception:
warnings.warn(str(exception), Warning)
else:
if profile_path:
if "hash" in edid_:
colord.device_ids[edid_["hash"]] = device_id
if path_only:
print(
"Got profile from colord for display %i (%s):"
% (display_no, device_id),
profile_path,
)
return profile_path
return ICCProfile(profile_path, use_cache=use_cache)
break
def _ucmm_get_display_profile(display_no, name, path_only=False, use_cache=True):
"""Argyll UCMM"""
search = []
edid = get_edid(display_no)
if edid:
# Look for matching EDID entry first
search.append((b"EDID", b"0x" + binascii.hexlify(edid["edid"]).upper()))
# Fallback to X11 name
search.append((b"NAME", name))
for path in [xdg_config_home] + xdg_config_dirs:
color_jcnf = os.path.join(path, "color.jcnf")
if os.path.isfile(color_jcnf):
import json
with open(color_jcnf) as f:
data = json.load(f)
displays = data.get("devices", {}).get("display")
if isinstance(displays, dict):
# Look for matching entry
for key, value in search:
for item in displays.values():
if isinstance(item, dict):
if item.get(key) == value:
profile_path = item.get("ICC_PROFILE")
if path_only:
print(
"Got profile from Argyll UCMM for display %i (%s %s):"
% (display_no, key, value),
profile_path,
)
return profile_path
return ICCProfile(profile_path, use_cache=use_cache)
def _wcs_get_display_profile(
devicekey,
scope=WCS_PROFILE_MANAGEMENT_SCOPE["CURRENT_USER"],
profile_type=COLORPROFILETYPE["ICC"],
profile_subtype=COLORPROFILESUBTYPE["NONE"],
profile_id=0,
path_only=False,
use_cache=True,
):
buf = ctypes.create_unicode_buffer(256)
_win10_1903_take_process_handles_snapshot()
retv = mscms.WcsGetDefaultColorProfile(
scope,
devicekey,
profile_type,
profile_subtype,
profile_id,
ctypes.sizeof(buf), # Bytes
ctypes.byref(buf),
)
_win10_1903_close_leaked_regkey_handles(devicekey)
if not retv:
raise util_win.get_windows_error(ctypes.windll.kernel32.GetLastError())
if buf.value:
if path_only:
return os.path.join(iccprofiles[0], buf.value)
return ICCProfile(buf.value, use_cache=use_cache)
def _win10_1903_take_process_handles_snapshot():
global prev_handles
prev_handles = []
if win10_1903 and debug:
try:
for handle in get_process_handles():
prev_handles.append(handle.HandleValue)
except WindowsError as exception:
print("Couldn't get process handles:", exception)
def _win10_1903_close_leaked_regkey_handles(devicekey):
global prev_handles
if win10_1903:
# Wcs* methods leak handles under Win10 1903. Get and close them.
# Extract substring from devicekey for matching handle name, e.g.
# Control\Class\{4d36e96e-e325-11ce-bfc1-08002be10318}
substr = "\\".join(devicekey.split("\\")[-4:-1])
try:
handles = get_process_handles()
except WindowsError as exception:
print("Couldn't get process handles:", exception)
return
for handle in handles:
try:
handle_name = get_handle_name(handle)
except WindowsError as exception:
print(
"Couldn't get name of handle 0x%x:" % handle.HandleValue, exception
)
handle_name = None
if debug and handle.HandleValue not in prev_handles:
try:
handle_type = get_handle_type(handle)
except WindowsError as exception:
print(
"Couldn't get typestring of handle 0x%x:" % handle.HandleValue,
exception,
)
handle_type = None
print(
"New handle",
"0x%x" % handle.HandleValue,
"type 0x%02x %s" % (handle.ObjectTypeIndex, handle_type),
handle_name,
)
if handle_name and handle_name.endswith(substr):
print(
"Windows 10",
win_ver[2].split(" ", 1)[-1],
"housekeeping: Closing leaked handle 0x%x" % handle.HandleValue,
handle_name,
)
try:
win32api.RegCloseKey(handle.HandleValue)
except pywintypes.error as exception:
print("Couldn't close handle 0x%x:" % handle.HandleValue, exception)
def _winreg_get_display_profile(
monkey, current_user=False, path_only=False, use_cache=True
):
filename = None
filenames = _winreg_get_display_profiles(monkey, current_user)
if filenames:
# last existing file in the list is active
filename = filenames.pop()
if not filename and not current_user:
# fall back to sRGB
filename = os.path.join(iccprofiles[0], "sRGB Color Space Profile.icm")
if filename:
if path_only:
return os.path.join(iccprofiles[0], filename)
return ICCProfile(filename, use_cache=use_cache)
return None
def _winreg_get_display_profiles(monkey, current_user=False):
filenames = []
try:
if current_user and sys.getwindowsversion() >= (6,):
# Vista / Windows 7 ONLY
# User has to place a check in 'use my settings for this device'
# in the color management control panel at least once to cause
# this key to be created, otherwise it won't exist
subkey = "\\".join(
[
"Software",
"Microsoft",
"Windows NT",
"CurrentVersion",
"ICM",
"ProfileAssociations",
"Display",
]
+ monkey
)
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, subkey)
else:
subkey = "\\".join(
["SYSTEM", "CurrentControlSet", "Control", "Class"] + monkey
)
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, subkey)
numsubkeys, numvalues, mtime = winreg.QueryInfoKey(key)
for i in range(numvalues):
name, value, type_ = winreg.EnumValue(key, i)
if name == "ICMProfile" and value:
if type_ == winreg.REG_BINARY:
# Win2k/XP
# convert to list of strings
value = value.decode("utf-16").split("\0")
elif type_ == winreg.REG_MULTI_SZ:
# Vista / Windows 7
# nothing to be done, _winreg returns a list of strings
pass
if not isinstance(value, list):
value = [value]
while "" in value:
value.remove("")
filenames.extend(value)
winreg.CloseKey(key)
except WindowsError as exception:
if exception.args[0] == 2:
# Key does not exist
pass
else:
raise
return [
filename
for filename in filenames
if os.path.isfile(os.path.join(iccprofiles[0], filename))
]
def get_display_profile(
display_no=0,
x_hostname=None,
x_display=None,
x_screen=None,
path_only=False,
devicekey=None,
use_active_display_device=True,
use_registry=True,
):
"""Return ICC Profile for display n or None"""
profile = None
if sys.platform == "win32":
if "win32api" not in sys.modules:
raise ImportError("pywin32 not available")
if not devicekey:
# The ordering will work as long as Argyll continues using
# EnumDisplayMonitors
monitors = util_win.get_real_display_devices_info()
moninfo = monitors[display_no]
if not mscms and not devicekey:
# Via GetICMProfile. Sucks royally in a multi-monitor setup
# where one monitor is disabled, because it'll always get
# the profile of the first monitor regardless if that is the active
# one or not. Yuck. Also, in this case it does not reflect runtime
# changes to profile assignments. Double yuck.
buflen = ctypes.c_ulong(260)
dc = win32gui.CreateDC(moninfo["Device"], None, None)
try:
buf = ctypes.create_unicode_buffer(buflen.value)
if ctypes.windll.gdi32.GetICMProfileW(
dc, ctypes.byref(buflen), ctypes.byref(buf) # WCHARs
):
if path_only:
profile = buf.value
else:
profile = ICCProfile(buf.value, use_cache=True)
finally:
win32gui.DeleteDC(dc)
else:
if devicekey:
device = None
elif use_active_display_device:
# This would be the correct way. Unfortunately that is not
# what other apps (or Windows itself) do.
device = util_win.get_active_display_device(moninfo["Device"])
else:
# This is wrong, but it's what other apps use. Matches
# GetICMProfile sucky behavior i.e. should return the same
# profile, but atleast reflects runtime changes to profile
# assignments.
device = util_win.get_first_display_device(moninfo["Device"])
if device:
devicekey = device.DeviceKey
if devicekey:
if mscms:
# Via WCS
if util_win.per_user_profiles_isenabled(devicekey=devicekey):
scope = WCS_PROFILE_MANAGEMENT_SCOPE["CURRENT_USER"]
else:
scope = WCS_PROFILE_MANAGEMENT_SCOPE["SYSTEM_WIDE"]
if not use_registry:
# NOTE: WcsGetDefaultColorProfile causes the whole system
# to hitch if the profile of the active display device is
# queried. Windows bug?
return _wcs_get_display_profile(
str(devicekey), scope, path_only=path_only
)
else:
scope = None
# Via registry
monkey = devicekey.split("\\")[-2:] # pun totally intended
# Current user scope
current_user = scope == WCS_PROFILE_MANAGEMENT_SCOPE["CURRENT_USER"]
if current_user:
profile = _winreg_get_display_profile(monkey, True, path_only=path_only)
else:
# System scope
profile = _winreg_get_display_profile(monkey, path_only=path_only)
else:
if sys.platform == "darwin":
if intlist(mac_ver()[0].split(".")) >= [10, 6]:
options = ["Image Events"]
else:
options = ["ColorSyncScripting"]
else:
options = ["_ICC_PROFILE"]
try:
from DisplayCAL import RealDisplaySizeMM as RDSMM
except ImportError as exception:
warnings.warn(str(exception), Warning)
display = get_display()
else:
display = RDSMM.get_x_display(display_no)
if display:
if x_hostname is None:
x_hostname = display[0]
if x_display is None:
x_display = display[1]
if x_screen is None:
x_screen = display[2]
x_display_name = "%s:%s.%s" % (x_hostname, x_display, x_screen)
for option in options:
if sys.platform == "darwin":
# applescript: one-based index
applescript = [
'tell app "%s"' % option,
"set displayProfile to location of display profile of display %i"
% (display_no + 1),
"return POSIX path of displayProfile",
"end tell",
]
retcode, output, errors = osascript(applescript)
if retcode == 0 and output.strip():
filename = output.strip("\n").decode(fs_enc)
if path_only:
profile = filename
else:
profile = ICCProfile(filename, use_cache=True)
elif errors.strip():
raise IOError(errors.strip())
else:
# Linux
# Try colord
if colord.which("colormgr"):
profile = _colord_get_display_profile(
display_no, path_only=path_only
)
if profile:
return profile
if path_only:
# No way to figure out the profile path from X atom, so use
# Argyll's UCMM if libcolordcompat.so is not present
if dlopen("libcolordcompat.so"):
# UCMM configuration might be stale, ignore
return
profile = _ucmm_get_display_profile(
display_no, x_display_name, path_only
)
return profile
# Try XrandR
if (
xrandr
and RDSMM
and option == "_ICC_PROFILE"
and None not in (x_hostname, x_display, x_screen)
):
with xrandr.XDisplay(x_display_name) as display:
if debug:
print("Using XrandR")
for i, atom_id in enumerate(
[
RDSMM.get_x_icc_profile_output_atom_id(display_no),
RDSMM.get_x_icc_profile_atom_id(display_no),
]
):
if atom_id:
if i == 0:
meth = display.get_output_property
what = RDSMM.GetXRandROutputXID(display_no)
else:
meth = display.get_window_property
what = display.root_window(0)
try:
property = meth(what, atom_id)
except ValueError as exception:
warnings.warn(str(exception), Warning)
else:
if property:
profile = ICCProfile(
b"".join(
bytes(chr(n), "UTF-8") for n in property
),
use_cache=True,
)
if profile:
return profile
if debug:
if i == 0:
print(
"Couldn't get _ICC_PROFILE XrandR output property"
)
print("Using X11")
else:
print("Couldn't get _ICC_PROFILE X atom")
return
# Read up to 8 MB of any X properties
if debug:
print("Using xprop")
xprop = which("xprop")
if not xprop:
return
atom = "%s%s" % (option, "" if display_no == 0 else "_%s" % display_no)
tgt_proc = sp.Popen(
[
xprop,
"-display",
"%s:%s.%s" % (x_hostname, x_display, x_screen),
"-len",
"8388608",
"-root",
"-notype",
atom,
],
stdin=sp.PIPE,
stdout=sp.PIPE,
stderr=sp.PIPE,
)
stdout, stderr = [data.strip(b"\n") for data in tgt_proc.communicate()]
if stdout:
if sys.platform == "darwin":
filename = str(stdout, "UTF-8")
if path_only:
profile = filename
else:
profile = ICCProfile(filename, use_cache=True)
else:
raw = [item.strip() for item in stdout.split("=")]
if raw[0] == atom and len(raw) == 2:
bin = "".join(
[chr(int(part)) for part in raw[1].split(", ")]
)
profile = ICCProfile(bin, use_cache=True)
elif stderr and tgt_proc.wait() != 0:
raise IOError(stderr)
if profile:
break
return profile
def _wcs_set_display_profile(
devicekey, profile_name, scope=WCS_PROFILE_MANAGEMENT_SCOPE["CURRENT_USER"]
):
"""Set the current default WCS color profile for the given device.
If the device is a display, this will also set its video card gamma ramps
to linear* if the given profile is the display's current default profile
and Windows calibration management isn't enabled.
Note that the profile needs to have been already installed.
* 0..65535 will get mapped to 0..65280, which is a Windows bug
"""
# We need to disassociate the profile first in case it's not the default
# so we can make it the default again.
# Note that disassociating the current default profile for a display will
# also set its video card gamma ramps to linear if Windows calibration
# management isn't enabled.
_win10_1903_take_process_handles_snapshot()
mscms.WcsDisassociateColorProfileFromDevice(scope, profile_name, devicekey)
retv = mscms.WcsAssociateColorProfileWithDevice(scope, profile_name, devicekey)
_win10_1903_close_leaked_regkey_handles(devicekey)
if not retv:
raise util_win.get_windows_error(ctypes.windll.kernel32.GetLastError())
monkey = devicekey.split("\\")[-2:]
current_user = scope == WCS_PROFILE_MANAGEMENT_SCOPE["CURRENT_USER"]
profiles = _winreg_get_display_profiles(monkey, current_user)
if profile_name not in profiles:
return False
return True
def _wcs_unset_display_profile(
devicekey, profile_name, scope=WCS_PROFILE_MANAGEMENT_SCOPE["CURRENT_USER"]
):
"""Unset the current default WCS color profile for the given device.
If the device is a display, this will also set its video card gamma ramps
to linear* if the given profile is the display's current default profile
and Windows calibration management isn't enabled.
Note that the profile needs to have been already installed.
* 0..65535 will get mapped to 0..65280, which is a Windows bug
"""
# Disassociating a profile will always (regardless of whether or
# not the profile was associated or even exists) result in Windows
# error code 2015 ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE.
# This is probably a Windows bug.
# To have a meaningful return value, we thus check wether the profile that
# should be removed is currently associated, and only fail if it is not,
# or if disassociating it fails for some reason.
monkey = devicekey.split("\\")[-2:]
current_user = scope == WCS_PROFILE_MANAGEMENT_SCOPE["CURRENT_USER"]
profiles = _winreg_get_display_profiles(monkey, current_user)
_win10_1903_take_process_handles_snapshot()
retv = mscms.WcsDisassociateColorProfileFromDevice(scope, profile_name, devicekey)
_win10_1903_close_leaked_regkey_handles(devicekey)
if not retv:
errcode = ctypes.windll.kernel32.GetLastError()
if (
errcode == ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE
and profile_name in profiles
):
# Check if profile is still associated
profiles = _winreg_get_display_profiles(monkey, current_user)
if profile_name not in profiles:
# Successfully disassociated
return True
raise util_win.get_windows_error(errcode)
return True
def set_display_profile(
profile_name, display_no=0, devicekey=None, use_active_display_device=True
):
# Currently only implemented for Windows.
# The profile to be assigned has to be already installed!
if not devicekey:
device = util_win.get_display_device(display_no, use_active_display_device)
if not device:
return False
devicekey = device.DeviceKey
if mscms:
if util_win.per_user_profiles_isenabled(devicekey=devicekey):
scope = WCS_PROFILE_MANAGEMENT_SCOPE["CURRENT_USER"]
else:
scope = WCS_PROFILE_MANAGEMENT_SCOPE["SYSTEM_WIDE"]
return _wcs_set_display_profile(str(devicekey), profile_name, scope)
else:
# TODO: Implement for XP
return False
def unset_display_profile(
profile_name, display_no=0, devicekey=None, use_active_display_device=True
):
# Currently only implemented for Windows.
# The profile to be unassigned has to be already installed!
if not devicekey:
device = util_win.get_display_device(display_no, use_active_display_device)
if not device:
return False
devicekey = device.DeviceKey
if mscms:
if util_win.per_user_profiles_isenabled(devicekey=devicekey):
scope = WCS_PROFILE_MANAGEMENT_SCOPE["CURRENT_USER"]
else:
scope = WCS_PROFILE_MANAGEMENT_SCOPE["SYSTEM_WIDE"]
return _wcs_unset_display_profile(str(devicekey), profile_name, scope)
else:
# TODO: Implement for XP
return False
def _blend_blackpoint(row, bp_in, bp_out, wp=None, use_bpc=False, weight=False):
X, Y, Z = row
if use_bpc:
X, Y, Z = colormath.apply_bpc(X, Y, Z, bp_in, bp_out, wp, weight=weight)
else:
X, Y, Z = colormath.blend_blackpoint(X, Y, Z, bp_in, bp_out, wp)
return X, Y, Z
def _mp_apply(
blocks,
thread_abort_event,
progress_queue,
pcs,
fn,
args,
D50,
interp,
rinterp,
abortmessage="Aborted",
):
"""Worker for applying function to cLUT
This should be spawned as a multiprocessing process
"""
from DisplayCAL.debughelpers import Info
for interp_tuple in (interp, rinterp):
if interp_tuple:
# Use numpy for speed
interp_list = list(interp_tuple)
for i, ointerp in enumerate(interp_list):
interp_list[i] = colormath.Interp(
ointerp.xp, ointerp.fp, use_numpy=True
)
interp_list[i].lookup = ointerp.lookup
if interp_tuple is interp:
interp = interp_list
else:
rinterp = interp_list
prevperc = 0
count = 0
numblocks = len(blocks)
for block in blocks:
if thread_abort_event and thread_abort_event.is_set():
return Info(abortmessage)
for i, row in enumerate(block):
if interp:
for column, value in enumerate(row):
row[column] = interp[column](value)
if pcs == "Lab":
L, a, b = legacy_PCSLab_uInt16_to_dec(*row)
X, Y, Z = colormath.Lab2XYZ(L, a, b, D50)
else:
X, Y, Z = [v / 32768.0 for v in row]
X, Y, Z = fn((X, Y, Z), *args)
if pcs == "Lab":
L, a, b = colormath.XYZ2Lab(X, Y, Z, D50)
row = [
min(max(0, v), 65535) for v in legacy_PCSLab_dec_to_uInt16(L, a, b)
]
else:
row = [min(max(0, v) * 32768.0, 65535) for v in (X, Y, Z)]
if rinterp:
for column, value in enumerate(row):
row[column] = rinterp[column](value)
block[i] = row
count += 1.0
perc = round(count / numblocks * 100)
if progress_queue and perc > prevperc:
progress_queue.put(perc - prevperc)
prevperc = perc
return blocks
def _mp_apply_black(
blocks,
thread_abort_event,
progress_queue,
pcs,
bp,
bp_out,
wp,
use_bpc,
weight,
D50,
interp,
rinterp,
abortmessage="Aborted",
):
"""Worker for applying black point compensation or offset
This should be spawned as a multiprocessing process
"""
return _mp_apply(
blocks,
thread_abort_event,
progress_queue,
pcs,
_blend_blackpoint,
(bp, bp_out, wp if use_bpc else None, use_bpc, weight),
D50,
interp,
rinterp,
abortmessage,
)
def _mp_hdr_tonemap(
HDR_XYZ, thread_abort_event, progress_queue, rgb_space, maxv, sat, cat="Bradford"
):
"""Worker for HDR tonemapping
This should be spawned as a multiprocessing process
"""
prevperc = 0
amount = len(HDR_XYZ)
dI = 0
dI_max = 0
dC = 0
dC_max = 0
I_reduced_count = 0
its_hi = 0 # Highest number pf iterations seen per color
for i, (RGB_in, ICtCp_XYZ, RGB_ICtCp_XYZ) in enumerate(HDR_XYZ):
if thread_abort_event and thread_abort_event.is_set():
return [False]
is_neutral = all(v == RGB_in[0] for v in RGB_in)
for j, XYZ in enumerate((ICtCp_XYZ, RGB_ICtCp_XYZ)):
if j == 0 and (sat == 1 or ICtCp_XYZ == RGB_ICtCp_XYZ):
# Set ICtCp_XYZ to the same object as RGB_ICtCp_XYZ which we
# are going to change in-place in the next iteration of the loop
# so that at the end of this loop, both will point to the same
# changed data
ICtCp_XYZ = RGB_ICtCp_XYZ
continue
X, Y, Z = XYZ
H = None
its = 10000 # Remaining iterations (limit)
while not is_neutral and its:
X_D50, Y_D50, Z_D50 = colormath.adapt(
*(v / maxv for v in (X, Y, Z)),
whitepoint_source=rgb_space[1],
cat=cat
)
negative_clip = min(X_D50, Y_D50, Z_D50) < 0
positive_clip = (
round(X_D50, 4) > 0.9642 or Y_D50 > 1 or round(Z_D50, 4) > 0.8249
)
if not (negative_clip or positive_clip):
break
if H is None:
# Record hue angle
H = colormath.RGB2HSV(*RGB_in)[0]
# This is the initial intensity, and hue + saturation
I, Ct, Cp = colormath.XYZ2ICtCp(X, Y, Z)
Io, Cto, Cpo = I, Ct, Cp
Co = colormath.Lab2LCHab(I, Ct, Cp)[1]
# Desaturate
Ct *= 0.99
Cp *= 0.99
# Update XYZ
X, Y, Z = colormath.ICtCp2XYZ(I, Ct, Cp)
if Y > XYZ[1]:
# Desaturating CtCp increases Y!
# As we desaturate different amounts per color,
# restore initial Y if lower than adjusted Y
# to keep luminance relation
X, Y, Z = (v / Y * XYZ[1] for v in (X, Y, Z))
I, Ct, Cp = colormath.XYZ2ICtCp(X, Y, Z)
its -= 1
if H is not None and round(Io - I, 4):
# Intensity was reduced by >= 0.0001, gather statistics
C = colormath.Lab2LCHab(I, Ct, Cp)[1]
dI += Io - I
dI_max = max(dI_max, Io - I)
dC += Co - C
dC_max = max(dC_max, Co - C)
I_reduced_count += 1
if not its:
# Max iterations exceeded, print diagnostics
# XXX: This should not happen (testing OK)
oX_D50, oY_D50, oZ_D50 = colormath.adapt(
*(v / maxv for v in XYZ), whitepoint_source=rgb_space[1], cat=cat
)
X_D50, Y_D50, Z_D50 = colormath.adapt(
*(v / maxv for v in (X, Y, Z)),
whitepoint_source=rgb_space[1],
cat=cat
)
print(
"Reached iteration limit, XYZ %.4f %.4f %.4f -> %.4f %.4f %.4f"
% (oX_D50, oY_D50, oZ_D50, X_D50, Y_D50, Z_D50)
)
its_hi = max(its_hi, 10000 - its)
XYZ[:] = X, Y, Z
HDR_XYZ[i] = (RGB_in, ICtCp_XYZ, RGB_ICtCp_XYZ)
perc = round((i + 1.0) / amount * 50)
if progress_queue and perc > prevperc:
progress_queue.put(perc - prevperc)
prevperc = perc
if I_reduced_count:
# Intensity was reduced, print informational statistics
print(
"Max iterations %i dI avg %.4f max %.4f dC avg %.4f max %.4f"
% (its_hi, dI / I_reduced_count, dI_max, dC / I_reduced_count, dC_max)
)
elif its_hi:
print("Max iterations", its_hi)
return HDR_XYZ
def hexrepr(bytestring, mapping=None):
"""Generates hex representation of a bytes instance
:param bytestring:
:param mapping:
:return:
"""
hex_repr = (b"0x%s" % binascii.hexlify(bytestring).upper()).decode()
ascii_repr = re.sub(b"[^\x20-\x7e]", b"", bytestring)
if ascii_repr == bytestring:
hex_repr += " '%s'" % ascii_repr.decode()
if mapping:
value = mapping.get(ascii_repr)
if value:
hex_repr += " " + value
return hex_repr
def dateTimeNumber(binary_string):
"""Byte
Offset Content Encoded as...
0..1 number of the year (actual year, e.g. 1994) uInt16Number
2..3 number of the month (1-12) uInt16Number
4..5 number of the day of the month (1-31) uInt16Number
6..7 number of hours (0-23) uInt16Number
8..9 number of minutes (0-59) uInt16Number
10..11 number of seconds (0-59) uInt16Number
:param binary_string: A 12 character long bytes value representing a datetime value.
"""
Y, m, d, H, M, S = [
uInt16Number(chunk)
for chunk in (
binary_string[:2],
binary_string[2:4],
binary_string[4:6],
binary_string[6:8],
binary_string[8:10],
binary_string[10:12],
)
]
return datetime.datetime(*(Y, m, d, H, M, S))
def dateTimeNumber_tohex(dt):
data = [uInt16Number_tohex(n) for n in dt.timetuple()[:6]]
return b"".join(data)
def s15Fixed16Number(binaryString):
return struct.unpack(">i", binaryString)[0] / 65536.0
def s15Fixed16Number_tohex(num):
return struct.pack(">i", int(round(num * 65536)))
def s15f16_is_equal(
a, b, quantizer=lambda v: s15Fixed16Number(s15Fixed16Number_tohex(v))
):
return colormath.is_equal(a, b, quantizer)
def u16Fixed16Number(binaryString):
return struct.unpack(">I", binaryString)[0] / 65536.0
def u16Fixed16Number_tohex(num):
return struct.pack(">I", int(round(num * 65536)) & 0xFFFFFFFF)
def u8Fixed8Number(binaryString):
return struct.unpack(">H", binaryString)[0] / 256.0
def u8Fixed8Number_tohex(num):
return struct.pack(">H", int(round(num * 256)))
def uInt16Number(binaryString):
return struct.unpack(">H", binaryString)[0]
def uInt16Number_tohex(num):
return struct.pack(">H", int(round(num)))
def uInt32Number(binaryString):
return struct.unpack(">I", binaryString)[0]
def uInt32Number_tohex(num):
try:
return struct.pack(">I", int(round(num)))
except struct.error as e:
print("num: {}".format(num))
raise e
def uInt64Number(binaryString):
return struct.unpack(">Q", binaryString)[0]
def uInt64Number_tohex(num):
return struct.pack(">Q", int(round(num)))
def uInt8Number(binaryString):
return struct.unpack(">H", b"\0" + binaryString)[0]
def uInt8Number_tohex(num):
return struct.pack(">H", int(round(num)))[1:2]
def videoCardGamma(tagData, tagSignature):
# reserved = uInt32Number(tagData[4:8])
tagType = uInt32Number(tagData[8:12])
if tagType == 0: # table
return VideoCardGammaTableType(tagData, tagSignature)
elif tagType == 1: # formula
return VideoCardGammaFormulaType(tagData, tagSignature)
class CRInterpolation(object):
"""Catmull-Rom interpolation.
Curve passes through the points exactly, with neighbouring points influencing curvature.
points[] should be at least 3 points long.
"""
def __init__(self, points):
self.points = points
def __call__(self, pos):
lbound = int(math.floor(pos) - 1)
ubound = int(math.ceil(pos) + 1)
t = pos % 1.0
if abs((lbound + 1) - pos) < 0.0001:
# sitting on a datapoint, so just return that
return self.points[lbound + 1]
if lbound < 0:
p = self.points[: ubound + 1]
# extend to the left linearly
while len(p) < 4:
p.insert(0, p[0] - (p[1] - p[0]))
else:
p = self.points[lbound : ubound + 1]
# extend to the right linearly
while len(p) < 4:
p.append(p[-1] - (p[-2] - p[-1]))
t2 = t * t
return 0.5 * (
(2 * p[1])
+ (-p[0] + p[2]) * t
+ ((2 * p[0]) - (5 * p[1]) + (4 * p[2]) - p[3]) * t2
+ (-p[0] + (3 * p[1]) - (3 * p[2]) + p[3]) * (t2 * t)
)
class ADict(dict):
"""Convenience class for dictionary key access via attributes.
Instead of writing aodict[key], you can also write aodict.key
"""
def __init__(self, *args, **kwargs):
super(ADict, self).__init__(*args, **kwargs)
def __getattr__(self, name):
if name in self:
return self[name]
else:
return self.__getattribute__(name)
def __setattr__(self, name, value):
self[name] = value
class AODict(ADict):
def __init__(self, *args, **kwargs):
super(AODict, self).__init__(*args, **kwargs)
def __setattr__(self, name, value):
if name == "_keys":
object.__setattr__(self, name, value)
else:
self[name] = value
class LazyLoadTagAODict(AODict):
"""Lazy-load (and parse) tag data on access"""
def __init__(self, profile, *args, **kwargs):
self.profile = profile
AODict.__init__(self)
def __getitem__(self, key):
tag = AODict.__getitem__(self, key)
if isinstance(tag, ICCProfileTag):
# Return already parsed tag
return tag
# Load and parse tag data
tagSignature = key
typeSignature, tagDataOffset, tagDataSize, tagData = tag
try:
if tagSignature in tagSignature2Tag:
tag = tagSignature2Tag[tagSignature](tagData, tagSignature)
elif typeSignature in typeSignature2Type:
args = tagData, tagSignature
if typeSignature in (b"clrt", b"ncl2"):
args += (self.profile.connectionColorSpace,)
if typeSignature == b"ncl2":
args += (self.profile.colorSpace,)
elif typeSignature in (b"XYZ ", b"mft2", b"curv", b"MS10", b"pseq"):
args += (self.profile,)
tag = typeSignature2Type[typeSignature](*args)
else:
tag = ICCProfileTag(tagData, tagSignature)
except Exception as exception:
raise ICCProfileInvalidError(
"Couldn't parse tag %r (type %r, offset %i, size %i): %r"
% (tagSignature, typeSignature, tagDataOffset, tagDataSize, exception)
)
self[key] = tag
return tag
def __setattr__(self, name, value):
if name == "profile":
object.__setattr__(self, name, value)
else:
AODict.__setattr__(self, name, value)
def get(self, key, default=None):
if key in self:
return self[key]
return default
class ICCProfileTag(object):
def __init__(self, tagData, tagSignature):
self.tagData = tagData
self.tagSignature = tagSignature
def __setattr__(self, name, value):
if not isinstance(self, dict) or name in ("_keys", "tagData", "tagSignature"):
object.__setattr__(self, name, value)
else:
self[name] = value
def __repr__(self):
"""t.__repr__() <==> repr(t)"""
if isinstance(self, dict):
return dict.__repr__(self)
elif isinstance(self, UserString):
return UserString.__repr__(self)
elif isinstance(self, list):
return list.__repr__(self)
else:
if not self:
return "%s.%s()" % (self.__class__.__module__, self.__class__.__name__)
return "%s.%s(%r)" % (
self.__class__.__module__,
self.__class__.__name__,
self.tagData,
)
class Text(ICCProfileTag, bytes):
def __init__(self, seq):
super(Text, self).__init__(tagData=seq, tagSignature=b"")
self.data = seq
def __str__(self):
return self.data.decode(fs_enc, errors="replace")
class Colorant(object):
def __init__(self, binaryString=b"\0" * 4):
self._type = uInt32Number(binaryString)
self._channels = []
def __getitem__(self, key):
return self.__getattribute__(key)
def __iter__(self):
return iter(list(self.keys()))
def __repr__(self):
items = []
for key, value in (("type", self.type), ("description", self.description)):
items.append("%s: %s" % (repr(key), repr(value)))
channels = []
for xy in self.channels:
channels.append("[%s]" % ", ".join([str(v) for v in xy]))
items.append("'channels': [%s]" % ", ".join(channels))
return "{%s}" % ", ".join(items)
def __setitem__(self, key, value):
object.__setattr__(self, key, value)
@property
def channels(self):
if not self._channels and self._type and self._type in colorants:
return [list(xy) for xy in colorants[self._type]["channels"]]
return self._channels
@channels.setter
def channels(self, channels):
self._channels = channels
@property
def description(self):
return colorants.get(self._type, colorants[0])["description"]
@description.setter
def description(self, value):
pass
def get(self, key, default=None):
return getattr(self, key, default)
def items(self):
return list(zip(list(self.keys()), list(self.values())))
def iteritems(self):
return zip(list(self.keys()), iter(self.values()))
iterkeys = __iter__
def itervalues(self):
return map(self.get, list(self.keys()))
def keys(self):
return ["type", "description", "channels"]
def round(self, digits=4):
colorant = self.__class__()
colorant.type = self.type
for xy in self.channels:
colorant._channels.append([round(value, digits) for value in xy])
return colorant
@property
def type(self):
return self._type
@type.setter
def type(self, value):
if value and value != self._type and value in colorants:
self._channels = []
self._type = value
def update(self, *args, **kwargs):
if len(args) > 1:
raise TypeError("update expected at most 1 arguments, got %i" % len(args))
for iterable in args + tuple(kwargs.items()):
if hasattr(iterable, "items"):
self.update(iter(iterable.items()))
elif hasattr(iterable, "keys"):
for key in list(iterable.keys()):
self[key] = iterable[key]
else:
for key, val in iterable:
self[key] = val
def values(self):
return list(map(self.get, list(self.keys())))
class Geometry(ADict):
def __init__(self, binaryString):
super(Geometry, self).__init__()
self.type = uInt32Number(binaryString)
self.description = geometry[self.type]
class Illuminant(ADict):
def __init__(self, binaryString):
super(Illuminant, self).__init__()
self.type = uInt32Number(binaryString)
self.description = illuminants[self.type]
class LUT16Type(ICCProfileTag):
def __init__(self, tagData=None, tagSignature=None, profile=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
self.profile = profile
self._matrix = None
self._input = None
self._clut = None
self._output = None
self._i = (tagData and uInt8Number(tagData[8:9])) or 0 # Input channel count
self._o = (tagData and uInt8Number(tagData[9:10])) or 0 # Output channel count
self._g = (tagData and uInt8Number(tagData[10:11])) or 0 # cLUT grid res
self._n = (
tagData and uInt16Number(tagData[48:50])
) or 0 # Input channel entries count
self._m = (
tagData and uInt16Number(tagData[50:52])
) or 0 # Output channel entries count
def apply_black_offset(
self, XYZbp, logfile=None, thread_abort=None, abortmessage="Aborted"
):
# Apply only the black point blending portion of BT.1886 mapping
self._apply_black(XYZbp, False, False, logfile, thread_abort, abortmessage)
def apply_bpc(
self,
bp_out=(0, 0, 0),
weight=False,
logfile=None,
thread_abort=None,
abortmessage="Aborted",
):
return self._apply_black(
bp_out, True, weight, logfile, thread_abort, abortmessage
)
def _apply_black(
self,
bp_out,
use_bpc=False,
weight=False,
logfile=None,
thread_abort=None,
abortmessage="Aborted",
):
pcs = self.profile and self.profile.connectionColorSpace
bp_row = list(self.clut[0][0])
wp_row = list(self.clut[-1][-1])
nonzero_bp = tuple(bp_out) != (0, 0, 0)
interp = []
rinterp = []
if not use_bpc or nonzero_bp:
osize = len(self.output[0])
omaxv = osize - 1.0
orange = [i / omaxv * 65535 for i in range(osize)]
for i in range(3):
interp.append(colormath.Interp(orange, self.output[i]))
rinterp.append(colormath.Interp(self.output[i], orange))
for row in (bp_row, wp_row):
for column, value in enumerate(row):
row[column] = interp[column](value)
if use_bpc:
method = "apply_bpc"
else:
method = "apply_black_offset"
if pcs == b"Lab":
bp = colormath.Lab2XYZ(*legacy_PCSLab_uInt16_to_dec(*bp_row))
wp = colormath.Lab2XYZ(*legacy_PCSLab_uInt16_to_dec(*wp_row))
elif not pcs or pcs == b"XYZ":
if not pcs:
warnings.warn(
"LUT16Type.%s: PCS not specified, " "assuming XYZ" % method, Warning
)
bp = [v / 32768.0 for v in bp_row]
wp = [v / 32768.0 for v in wp_row]
else:
raise ValueError("LUT16Type.%s: Unsupported PCS %r" % (method, pcs))
if [round(v * 32768) for v in bp] != [round(v * 32768) for v in bp_out]:
D50 = colormath.get_whitepoint("D50")
from DisplayCAL.multiprocess import pool_slice
if len(self.clut[0]) < 33:
num_workers = 1
else:
num_workers = None
# if pcs != "Lab" and nonzero_bp:
# bp_out_offset = bp_out
# bp_out = (0, 0, 0)
if bp != bp_out:
self.clut = sum(
pool_slice(
_mp_apply_black,
self.clut,
(
pcs,
bp,
bp_out,
wp,
use_bpc,
weight,
D50,
interp,
rinterp,
abortmessage,
),
{},
num_workers,
thread_abort,
logfile,
),
[],
)
# if pcs != "Lab" and nonzero_bp:
# # Apply black offset to output curves
# out = [[], [], []]
# for i in range(2049):
# v = i / 2048.0
# X, Y, Z = colormath.blend_blackpoint(v, v, v, (0, 0, 0),
# bp_out_offset)
# out[0].append(X * 2048 / 4095.0 * 65535)
# out[1].append(Y * 2048 / 4095.0 * 65535)
# out[2].append(Z * 2048 / 4095.0 * 65535)
# for i in range(2049, 4096):
# v = i / 4095.0
# out[0].append(v * 65535)
# out[1].append(v * 65535)
# out[2].append(v * 65535)
# self.output = out
@property
def clut(self):
if self._clut is None:
i, o, g, n = self._i, self._o, self._g, self._n
tagData = self._tagData
self._clut = [
[
[
uInt16Number(
tagData[
52
+ n * i * 2
+ o * 2 * (g * x + y)
+ z * 2 : 54
+ n * i * 2
+ o * 2 * (g * x + y)
+ z * 2
]
)
for z in range(o)
]
for y in range(g)
]
for x in range(int(g**i / g))
]
return self._clut
@clut.setter
def clut(self, value):
self._clut = value
def clut_writepng(self, stream_or_filename):
"""Write the cLUT as PNG image organized in *
sized squares, ordered vertically"""
if len(self.clut[0][0]) != 3:
raise NotImplementedError("clut_writepng: output channels != 3")
imfile.write(self.clut, stream_or_filename)
def clut_writecgats(self, stream_or_filename):
"""Write the cLUT as CGATS"""
# TODO:
# Need to take into account input/output curves
# Currently only supports RGB, A2B direction, and XYZ color space
if len(self.clut[0][0]) != 3:
raise NotImplementedError("clut_writecgats: output channels != 3")
if isinstance(stream_or_filename, str):
stream = open(stream_or_filename, "wb")
else:
stream = stream_or_filename
with stream:
stream.write(
b"""CTI3
DEVICE_CLASS "DISPLAY"
COLOR_REP "RGB_XYZ"
BEGIN_DATA_FORMAT
SAMPLE_ID RGB_R RGB_G RGB_B XYZ_X XYZ_Y XYZ_Z
END_DATA_FORMAT
BEGIN_DATA
"""
)
clutres = len(self.clut[0])
block = 0
i = 1
if self.tagSignature and self.tagSignature.startswith("B2A"):
interp = []
for input in self.input:
interp.append(
colormath.Interp(input, list(range(len(input))), use_numpy=True)
)
for a in range(clutres):
for b in range(clutres):
for c in range(clutres):
R, G, B = [v / (clutres - 1.0) * 100 for v in (a, b, c)]
if self.tagSignature and self.tagSignature.startswith("B2A"):
linear_rgb = [
interp[i](v)
/ (len(interp[i].xp) - 1.0)
* (1 + (32767 / 32768.0))
* 100
for i, v in enumerate(self.clut[block][c])
]
X, Y, Z = self.matrix.inverted() * linear_rgb
else:
X, Y, Z = [v / 32768.0 * 100 for v in self.clut[block][c]]
stream.write(
b"%i %7.3f %7.3f %7.3f %10.6f %10.6f %10.6f\n"
% (i, R, G, B, X, Y, Z)
)
i += 1
block += 1
stream.write(b"END_DATA\n")
@property
def clut_grid_steps(self):
"""Return number of grid points per dimension."""
return self._g or len(self.clut[0])
@property
def input(self):
if self._input is None:
i, n = self._i, self._n
tagData = self._tagData
self._input = [
[
uInt16Number(
tagData[52 + n * 2 * z + y * 2 : 54 + n * 2 * z + y * 2]
)
for y in range(n)
]
for z in range(i)
]
return self._input
@input.setter
def input(self, value):
self._input = value
@property
def input_channels_count(self):
"""Return number of input channels."""
return self._i or len(self.input)
@property
def input_entries_count(self):
"""Return number of entries per input channel."""
return self._n or len(self.input[0])
def invert(self):
"""Invert input and output tables."""
# Invert input/output 1d LUTs
for channel in (self.input, self.output):
for e, entries in enumerate(channel):
lut = dict()
maxv = len(entries) - 1.0
for i, entry in enumerate(entries):
lut[entry / 65535.0 * maxv] = i / maxv * 65535
xp = list(lut.keys())
fp = list(lut.values())
for i in range(len(entries)):
if i not in lut:
lut[i] = colormath.interp(i, xp, fp)
lut = dict_sort(lut)
channel[e] = list(lut.values())
def clut_row_apply_per_channel(
self,
indexes,
fn,
fnargs=None,
fnkwargs=None,
pcs=None,
protect_gray_axis=True,
protect_dark=False,
protect_black=True,
exclude=None,
):
"""Apply function to channel values of each cLUT row"""
if fnargs is None:
fnargs = ()
if fnkwargs is None:
fnkwargs = {}
clutres = len(self.clut[0])
block = -1
for i, row in enumerate(self.clut):
channels = {}
for k in indexes:
channels[k] = []
if protect_gray_axis or protect_dark or protect_black or exclude:
if i % clutres == 0:
block += 1
if pcs == "XYZ":
gray_col_i = block
else:
# L*a*b*
gray_col_i = clutres // 2
gray_row_i = i + gray_col_i
fnkwargs["protect"] = []
for j, column in enumerate(row):
is_exclude = exclude and (i, j) in exclude
if is_exclude or (
protect_gray_axis and (i == gray_row_i and j == gray_col_i)
):
if debug:
print(
"protect", "exclude" if is_exclude else "gray", i, j, column
)
fnkwargs["protect"].append(j)
elif (protect_dark and sum(column) < 65535 * 0.03125 * 3) or (
protect_black and min(column) == max(column) == 0
):
if debug:
print("protect dark", i, j, column)
fnkwargs["protect"].append(j)
for k in indexes:
channels[k].append(column[k])
for k in channels:
values = channels[k]
channels[k] = fn(values, *fnargs, **fnkwargs)
for j, column in enumerate(row):
for k in indexes:
column[k] = channels[k][j]
def clut_shift_columns(self, order=(1, 2, 0)):
"""Shift cLUT columns, altering slowest to fastest changing column"""
if len(self.input) != 3:
raise NotImplementedError("input channels != 3")
steps = len(self.clut[0])
clut = []
coord = [0, 0, 0]
for a in range(steps):
coord[order[0]] = a
for b in range(steps):
coord[order[1]] = b
clut.append([])
for c in range(steps):
coord[order[2]] = c
z, y, x = coord
clut[-1].append(self.clut[z * steps + y][x])
self.clut = clut
@property
def matrix(self):
if self._matrix is None:
tagData = self._tagData
return colormath.Matrix3x3(
[
(
s15Fixed16Number(tagData[12:16]),
s15Fixed16Number(tagData[16:20]),
s15Fixed16Number(tagData[20:24]),
),
(
s15Fixed16Number(tagData[24:28]),
s15Fixed16Number(tagData[28:32]),
s15Fixed16Number(tagData[32:36]),
),
(
s15Fixed16Number(tagData[36:40]),
s15Fixed16Number(tagData[40:44]),
s15Fixed16Number(tagData[44:48]),
),
]
)
return self._matrix
@matrix.setter
def matrix(self, value):
self._matrix = value
@property
def output(self):
if self._output is None:
i, o, g, n, m = self._i, self._o, self._g, self._n, self._m
tagData = self._tagData
self._output = [
[
uInt16Number(
tagData[
52
+ n * i * 2
+ m * 2 * z
+ y * 2
+ g**i * o * 2 : 54
+ n * i * 2
+ m * 2 * z
+ y * 2
+ g**i * o * 2
]
)
for y in range(m)
]
for z in range(o)
]
return self._output
@output.setter
def output(self, value):
self._output = value
@property
def output_channels_count(self):
"""Return number of output channels."""
return self._o or len(self.output)
@property
def output_entries_count(self):
"""Return number of entries per output channel."""
return self._m or len(self.output[0])
def smooth(self, diagpng=2, pcs=None, filename=None, logfile=None, debug_=0):
"""Apply extra smoothing to the cLUT"""
if not pcs:
if self.profile:
pcs = self.profile.connectionColorSpace
else:
raise TypeError("PCS not specified")
if not filename and self.profile:
filename = self.profile.fileName
clutres = len(self.clut[0])
sig = self.tagSignature or id(self)
if diagpng and filename and len(self.output) == 3:
# Generate diagnostic images
fname, ext = os.path.splitext(filename)
diag_fname = fname + ".%s.post.CLUT.png" % sig
if diagpng == 2 and not os.path.isfile(diag_fname):
self.clut_writepng(diag_fname)
else:
diagpng = 0
if logfile:
logfile.write("Smoothing %s...\n" % sig)
# Create a list of number of 2D grids, each one with a
# size of (width x height) x
grids = []
for i, block in enumerate(self.clut):
if i % clutres == 0:
grids.append([])
grids[-1].append([])
for RGB in block:
grids[-1][-1].append(RGB)
for i, grid in enumerate(grids):
for y in range(clutres):
for x in range(clutres):
is_dark = sum(grid[y][x]) < 65535 * 0.03125 * 3
if pcs == "XYZ":
is_gray = x == y == i
elif clutres // 2 != clutres / 2.0:
# For CIELab cLUT, gray will only
# fall on a cLUT point if uneven cLUT res
is_gray = x == y == clutres // 2
else:
is_gray = False
# print i, y, x, "%i %i %i" % tuple(v / 655.35 * 2.55 for v in grid[y][x]), is_dark, raw_input(is_gray) if is_gray else ''
if is_dark or is_gray:
# Don't smooth dark colors and gray axis
continue
RGB = [[v] for v in grid[y][x]]
# Use either "plus"-shaped or box filter depending if one
# channel is fully saturated
if clutres - 1 in (y, x) or 0 in (x, y):
# Filter with a "plus" (+) shape
if pcs == "Lab" and i > clutres / 2.0:
# Smoothing factor for L*a*b* -> RGB cLUT above 50%
smooth = 0.25
else:
smooth = 0.5
for j, c in enumerate((x, y)):
# Omit corners and perpendicular axis
if 0 < c < clutres - 1:
for n in (-1, 1):
yi, xi = (y, y + n)[j], (x + n, x)[j]
if -1 < xi < clutres and -1 < yi < clutres:
RGBn = grid[yi][xi]
if debug_ == 2:
if i < clutres - 1 or grid[y][x] != [
16384,
16384,
16384,
]:
grid[y][x] = [32768, 32768, 32768]
if x == y == clutres - 2:
RGBn[:] = [16384, 16384, 16384]
for k in range(3):
RGB[k].append(
RGBn[k] * smooth
+ RGB[k][0] * (1 - smooth)
)
else:
# Box filter, 3x3
# Center pixel weight = 1.0, surround = 2/3, corners = 1/3
if debug_ == 1:
grid[y][x] = [32768, 32768, 32768]
for j in (0, 1):
for n in (-1, 1):
for yi, xi in [
((y, y + n)[j], (x + n, x)[j]),
(y - n, (x + n, x - n)[j]),
]:
if -1 < xi < clutres and -1 < yi < clutres:
RGBn = grid[yi][xi]
if yi != y and xi != x:
smooth = 1 / 3.0
else:
smooth = 2 / 3.0
if debug_ == 1 and x == y == clutres - 2:
RGBn[:] = (v * (1 - smooth) for v in RGBn)
for k in range(3):
RGB[k].append(
RGBn[k] * smooth
+ RGB[k][0] * (1 - smooth)
)
if not debug_:
grid[y][x] = [sum(v) / float(len(v)) for v in RGB]
for j, row in enumerate(grid):
self.clut[i * clutres + j] = [
[min(v, 65535) for v in RGB] for RGB in row
]
if diagpng and filename:
self.clut_writepng(fname + ".%s.post.CLUT.smooth.png" % sig)
def smooth2(
self,
diagpng=2,
pcs=None,
filename=None,
logfile=None,
window=(1 / 16.0, 1, 1 / 16.0),
):
"""Apply extra smoothing to the cLUT"""
if not pcs:
if self.profile:
pcs = self.profile.connectionColorSpace
else:
raise TypeError("PCS not specified")
if not filename and self.profile:
filename = self.profile.fileName
clutres = len(self.clut[0])
sig = self.tagSignature or id(self)
if diagpng and filename and len(self.output) == 3:
# Generate diagnostic images
fname, ext = os.path.splitext(filename)
diag_fname = fname + ".%s.post.CLUT.png" % sig
if diagpng == 2 and not os.path.isfile(diag_fname):
self.clut_writepng(diag_fname)
else:
diagpng = 0
if logfile:
logfile.write("Smoothing %s...\n" % sig)
for i in range(3):
state = ("original", "pass", "final")[i]
if diagpng != 3 and i != 1:
continue
for j, (order, channels) in enumerate(
[
(None, "BGR"),
((1, 2, 0), "RBG"),
((0, 2, 1), "BRG"),
((2, 1, 0), "GRB"),
((0, 2, 1), "RGB"),
((2, 0, 1), "GBR"),
((0, 2, 1), "BGR"),
]
):
if order:
if debug:
print("Shifting order to", channels)
self.clut_shift_columns(order)
if i == 1 and j != 6:
if debug:
print("Smoothing")
exclude = None
protect_gray_axis = True
if pcs == "Lab":
if clutres // 2 != clutres / 2.0:
# For CIELab cLUT, gray will only
# fall on a cLUT point if uneven cLUT res
if channels in ("RBG", "RGB"):
exclude = [
((clutres // 2 + 1) * (clutres - 1), col)
for col in range(clutres)
]
protect_gray_axis = False
elif channels in ("BRG", "GRB"):
exclude = [
((clutres // 2) * clutres + y, clutres // 2)
for y in range(clutres)
]
protect_gray_axis = False
else:
protect_gray_axis = False
self.clut_row_apply_per_channel(
(0, 1, 2),
colormath.smooth_avg,
(),
{"window": window},
pcs,
protect_gray_axis,
exclude=exclude,
)
if diagpng == 3 and filename and j != 6:
if debug:
print("Writing diagnostic PNG for", state, channels)
self.clut_writepng(
fname + ".%s.post.CLUT.%s.%s.png" % (sig, channels, state)
)
if diagpng and filename:
self.clut_writepng(fname + ".%s.post.CLUT.smooth.png" % sig)
@property
def tagData(self):
"""Return raw tag data."""
if (self._matrix, self._input, self._clut, self._output) == (None,) * 4:
return self._tagData
tagData = [
b"mft2",
b"\0" * 4,
uInt8Number_tohex(len(self.input)),
uInt8Number_tohex(len(self.output)),
uInt8Number_tohex(len(self.clut and self.clut[0])),
b"\0",
s15Fixed16Number_tohex(self.matrix[0][0]),
s15Fixed16Number_tohex(self.matrix[0][1]),
s15Fixed16Number_tohex(self.matrix[0][2]),
s15Fixed16Number_tohex(self.matrix[1][0]),
s15Fixed16Number_tohex(self.matrix[1][1]),
s15Fixed16Number_tohex(self.matrix[1][2]),
s15Fixed16Number_tohex(self.matrix[2][0]),
s15Fixed16Number_tohex(self.matrix[2][1]),
s15Fixed16Number_tohex(self.matrix[2][2]),
uInt16Number_tohex(len(self.input and self.input[0])),
uInt16Number_tohex(len(self.output and self.output[0])),
]
for entries in self.input:
tagData.extend(uInt16Number_tohex(v) for v in entries)
for block in self.clut:
for entries in block:
tagData.extend(uInt16Number_tohex(v) for v in entries)
for entries in self.output:
tagData.extend(uInt16Number_tohex(v) for v in entries)
return b"".join(tagData)
@tagData.setter
def tagData(self, tagData):
self._tagData = tagData
class Observer(ADict):
def __init__(self, bytes_data):
super(ADict, self).__init__()
self.type = uInt32Number(bytes_data)
self.description = observers[self.type]
class ChromaticityType(ICCProfileTag, Colorant):
def __init__(self, tagData=None, tagSignature=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
if not tagData:
Colorant.__init__(self, uInt32Number_tohex(1))
return
deviceChannelsCount = uInt16Number(tagData[8:10])
Colorant.__init__(self, uInt32Number_tohex(uInt16Number(tagData[10:12])))
channels = tagData[12:]
for _count in range(deviceChannelsCount):
self._channels.append(
[u16Fixed16Number(channels[:4]), u16Fixed16Number(channels[4:8])]
)
channels = channels[8:]
__repr__ = Colorant.__repr__
@property
def tagData(self):
"""Return raw tag data."""
tagData = [b"chrm", b"\0" * 4, uInt16Number_tohex(len(self.channels))]
tagData.append(uInt16Number_tohex(self.type))
for channel in self.channels:
for xy in channel:
tagData.append(u16Fixed16Number_tohex(xy))
return b"".join(tagData)
@tagData.setter
def tagData(self, tagData):
pass
class ColorantTableType(ICCProfileTag, AODict):
def __init__(self, tagData=None, tagSignature=None, pcs=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
AODict.__init__(self)
if not tagData:
return
colorantCount = uInt32Number(tagData[8:12])
data = tagData[12:]
for _count in range(colorantCount):
pcsvalues = [
uInt16Number(data[32:34]),
uInt16Number(data[34:36]),
uInt16Number(data[36:38]),
]
for i, pcsvalue in enumerate(pcsvalues):
if pcs in (b"Lab", b"RGB", b"CMYK", b"YCbr"):
keys = ["L", "a", "b"]
if i == 0:
# L* range 0..100 + (25500 / 65280.0)
pcsvalues[i] = pcsvalue / 65536.0 * 256 / 255.0 * 100
else:
# a, b range -128..127 + (255 / 256.0)
pcsvalues[i] = -128 + (pcsvalue / 65536.0 * 256)
elif pcs == b"XYZ":
# X, Y, Z range 0..100 + (32767 / 32768.0)
keys = ["X", "Y", "Z"]
pcsvalues[i] = pcsvalue / 32768.0 * 100
else:
print("Warning: Non-standard profile connection space '%s'" % pcs)
return
end = data[:32].find(b"\0")
if end < 0:
end = 32
name = data[:end]
self[name] = AODict(list(zip(keys, pcsvalues)))
data = data[38:]
class CurveType(ICCProfileTag, list):
def __init__(self, tagData=None, tagSignature=None, profile=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
self.profile = profile
self._reset()
if not tagData:
return
curveEntriesCount = uInt32Number(tagData[8:12])
curveEntries = tagData[12:]
if curveEntriesCount == 1:
# Gamma
self.append(u8Fixed8Number(curveEntries[:2]))
elif curveEntriesCount:
# Curve
for _count in range(curveEntriesCount):
self.append(uInt16Number(curveEntries[:2]))
curveEntries = curveEntries[2:]
else:
# Identity
self.append(1.0)
def __delitem__(self, y):
list.__delitem__(self, y)
self._reset()
def __delslice__(self, i, j):
list.__delslice__(self, i, j)
self._reset()
def __iadd__(self, y):
list.__iadd__(self, y)
self._reset()
def __imul__(self, y):
list.__imul__(self, y)
self._reset()
def __setitem__(self, i, y):
list.__setitem__(self, i, y)
self._reset()
def __setslice__(self, i, j, y):
list.__setslice__(self, i, j, y)
self._reset()
def _reset(self):
self._transfer_function = {}
self._bt1886 = {}
def append(self, object):
list.append(self, object)
self._reset()
def apply_bpc(self, black_Y_out=0, weight=False):
if len(self) < 2:
return
D50_xyY = colormath.XYZ2xyY(*colormath.get_whitepoint("D50"))
bp_in = colormath.xyY2XYZ(D50_xyY[0], D50_xyY[1], self[0] / 65535.0)
bp_out = colormath.xyY2XYZ(D50_xyY[0], D50_xyY[1], black_Y_out)
wp_out = colormath.xyY2XYZ(D50_xyY[0], D50_xyY[1], self[-1] / 65535.0)
for i, v in enumerate(self):
X, Y, Z = colormath.xyY2XYZ(D50_xyY[0], D50_xyY[1], v / 65535.0)
self[i] = (
colormath.apply_bpc(X, Y, Z, bp_in, bp_out, wp_out, weight)[1] * 65535.0
)
def extend(self, iterable):
list.extend(self, iterable)
self._reset()
def get_gamma(
self,
use_vmin_vmax=False,
average=True,
least_squares=False,
slice=(0.01, 0.99),
lstar_slice=True,
):
"""Return average or least squares gamma or a list of gamma values"""
if len(self) <= 1:
if len(self):
values = self
else:
# Identity
values = [1.0]
if average or least_squares:
return values[0]
return [values[0]]
if lstar_slice:
start = slice[0] * 100
end = slice[1] * 100
values = []
for i, y in enumerate(self):
n = colormath.XYZ2Lab(0, y / 65535.0 * 100, 0)[0]
if start <= n <= end:
values.append((i / (len(self) - 1.0) * 65535.0, y))
else:
maxv = len(self) - 1.0
maxi = int(maxv)
starti = int(round(slice[0] * maxi))
endi = int(round(slice[1] * maxi)) + 1
values = list(
zip(
[(v / maxv) * 65535 for v in range(starti, endi)], self[starti:endi]
)
)
vmin = 0
vmax = 65535.0
if use_vmin_vmax:
if len(self) > 2:
vmin = self[0]
vmax = self[-1]
return colormath.get_gamma(values, 65535.0, vmin, vmax, average, least_squares)
def get_transfer_function(
self, best=True, slice=(0.05, 0.95), black_Y=None, outoffset=None
):
"""Return transfer function name, exponent and match percentage"""
if len(self) == 1:
# Gamma
return ("Gamma %.2f" % round(self[0], 2), self[0], 1.0), 1.0
if not len(self):
# Identity
return ("Gamma 1.0", 1.0, 1.0), 1.0
transfer_function = self._transfer_function.get((best, slice))
if transfer_function:
return transfer_function
trc = CurveType()
match = {}
otrc = CurveType()
otrc[:] = self
if otrc[0]:
otrc.apply_bpc()
vmin = otrc[0]
vmax = otrc[-1]
if self.profile and isinstance(self.profile.tags.get("lumi"), XYZType):
white_cdm2 = self.profile.tags.lumi.Y
else:
white_cdm2 = 100.0
if black_Y is None:
black_Y = self[0] / 65535.0
black_cdm2 = black_Y * white_cdm2
maxv = len(otrc) - 1.0
maxi = int(maxv)
starti = int(round(0.4 * maxi))
endi = int(round(0.6 * maxi))
gamma = otrc.get_gamma(True, slice=(0.4, 0.6), lstar_slice=False)
egamma = colormath.get_gamma([(0.5, 0.5**gamma)], vmin=-black_Y)
outoffset_unspecified = outoffset is None
if outoffset_unspecified:
outoffset = 1.0
tfs = [
("Rec. 709", -709, outoffset),
("Rec. 1886", -1886, 0),
("SMPTE 240M", -240, outoffset),
("SMPTE 2084", -2084, outoffset),
("DICOM", -1023, outoffset),
("HLG", -2, outoffset),
("L*", -3.0, outoffset),
("sRGB", -2.4, outoffset),
(
"Gamma %.2f %i%%" % (round(gamma, 2), round(outoffset * 100)),
gamma,
outoffset,
),
]
if outoffset_unspecified and black_Y:
for i in range(100):
tfs.append(("Gamma %.2f %i%%" % (round(gamma, 2), i), gamma, i / 100.0))
for name, exp, outoffset in tfs:
if name in ("DICOM", "Rec. 1886", "SMPTE 2084", "HLG"):
try:
if name == "DICOM":
trc.set_dicom_trc(black_cdm2, white_cdm2, size=len(self))
elif name == "Rec. 1886":
trc.set_bt1886_trc(black_Y, size=len(self))
elif name == "SMPTE 2084":
trc.set_smpte2084_trc(black_cdm2, white_cdm2, size=len(self))
elif name == "HLG":
trc.set_hlg_trc(black_cdm2, white_cdm2, size=len(self))
except ValueError:
continue
elif exp > 0 and black_Y:
trc.set_bt1886_trc(black_Y, outoffset, egamma, "b")
else:
trc.set_trc(exp, len(self), vmin, vmax)
if trc[0] and trc[-1] - trc[0]:
trc.apply_bpc()
if otrc == trc:
match[(name, exp, outoffset)] = 1.0
else:
match[(name, exp, outoffset)] = 0.0
count = 0
start = slice[0] * len(self)
end = slice[1] * len(self)
for i, n in enumerate(otrc):
# n = colormath.XYZ2Lab(0, n / 65535.0 * 100, 0)[0]
if start <= i <= end:
n = colormath.get_gamma(
[(i / (len(self) - 1.0) * 65535.0, n)],
65535.0,
vmin,
vmax,
False,
)
if n:
n = n[0]
# n2 = colormath.XYZ2Lab(0, trc[i] / 65535.0 * 100, 0)[0]
n2 = colormath.get_gamma(
[(i / (len(self) - 1.0) * 65535.0, trc[i])],
65535.0,
vmin,
vmax,
False,
)
if n2 and n2[0]:
n2 = n2[0]
match[(name, exp, outoffset)] += 1 - (
max(n, n2) - min(n, n2)
) / ((n + n2) / 2.0)
count += 1
if count:
match[(name, exp, outoffset)] /= count
if not best:
self._transfer_function[(best, slice)] = match
return match
match, (name, exp, outoffset) = sorted(
zip(list(match.values()), list(match.keys()))
)[-1]
self._transfer_function[(best, slice)] = (name, exp, outoffset), match
return (name, exp, outoffset), match
def insert(self, object):
list.insert(self, object)
self._reset()
def pop(self, index):
list.pop(self, index)
self._reset()
def remove(self, value):
list.remove(self, value)
self._reset()
def reverse(self):
list.reverse(self)
self._reset()
def set_bt1886_trc(
self, black_Y=0, outoffset=0.0, gamma=2.4, gamma_type="B", size=None
):
"""Set the response to the BT. 1886 curve
This response is special in that it depends on the actual black
level of the display.
"""
bt1886 = self._bt1886.get((gamma, black_Y, outoffset))
if bt1886:
return bt1886
if gamma_type in ("b", "g"):
# Get technical gamma needed to achieve effective gamma
gamma = colormath.xicc_tech_gamma(gamma, black_Y, outoffset)
rXYZ = colormath.RGB2XYZ(1.0, 0, 0)
gXYZ = colormath.RGB2XYZ(0, 1.0, 0)
bXYZ = colormath.RGB2XYZ(0, 0, 1.0)
mtx = colormath.Matrix3x3(
[
[rXYZ[0], gXYZ[0], bXYZ[0]],
[rXYZ[1], gXYZ[1], bXYZ[1]],
[rXYZ[2], gXYZ[2], bXYZ[2]],
]
)
wXYZ = colormath.RGB2XYZ(1.0, 1.0, 1.0)
x, y = colormath.XYZ2xyY(*wXYZ)[:2]
XYZbp = colormath.xyY2XYZ(x, y, black_Y)
bt1886 = colormath.BT1886(mtx, XYZbp, outoffset, gamma)
self._bt1886[(gamma, black_Y, outoffset)] = bt1886
self.set_trc(-709, size)
for i, v in enumerate(self):
X, Y, Z = colormath.xyY2XYZ(x, y, v / 65535.0)
self[i] = bt1886.apply(X, Y, Z)[1] * 65535.0
def set_dicom_trc(self, black_cdm2=0.05, white_cdm2=100, size=None):
"""Set the response to the DICOM Grayscale Standard Display Function
This response is special in that it depends on the actual black
and white level of the display.
"""
# See http://medical.nema.org/Dicom/2011/11_14pu.pdf
# Luminance levels depend on the start level of 0.05 cd/m2
# and end level of 4000 cd/m2
black_cdm2 = round(black_cdm2, 6)
if black_cdm2 < 0.05 or black_cdm2 >= white_cdm2:
raise ValueError(
"The black level of %s cd/m2 is out of range "
"for DICOM. Valid range begins at 0.05 cd/m2." % black_cdm2
)
if white_cdm2 > 4000 or white_cdm2 <= black_cdm2:
raise ValueError(
"The white level of %s cd/m2 is out of range "
"for DICOM. Valid range is up to 4000 cd/m2." % white_cdm2
)
black_jndi = colormath.DICOM(black_cdm2, True)
white_jndi = colormath.DICOM(white_cdm2, True)
white_dicomY = math.pow(10, colormath.DICOM(white_jndi))
if not size:
size = len(self)
if size < 2:
size = 1024
self[:] = []
for i in range(size):
v = (
math.pow(
10,
colormath.DICOM(
black_jndi + (float(i) / (size - 1)) * (white_jndi - black_jndi)
),
)
/ white_dicomY
)
self.append(v * 65535)
def set_hlg_trc(
self,
black_cdm2=0,
white_cdm2=100,
system_gamma=1.2,
ambient_cdm2=5,
maxsignal=1.0,
size=None,
logfile=None,
):
"""Set the response to the Hybrid Log-Gamma (HLG) function
This response is special in that it depends on the actual black
and white level of the display, system gamma and ambient.
XYZbp Black point in absolute XYZ, Y range 0..white_cdm2
maxsignal Set clipping point (optional)
size Number of steps. Recommended >= 1024
"""
if black_cdm2 < 0 or black_cdm2 >= white_cdm2:
raise ValueError(
"The black level of %f cd/m2 is out of range "
"for HLG. Valid range begins at 0 cd/m2." % black_cdm2
)
values = []
hlg = colormath.HLG(black_cdm2, white_cdm2, system_gamma, ambient_cdm2)
if maxsignal < 1:
# Adjust EOTF so that EOTF[maxsignal] gives (approx) white_cdm2
while hlg.eotf(maxsignal) * hlg.white_cdm2 < white_cdm2:
hlg.white_cdm2 += 1
lscale = 1.0 / hlg.oetf(1.0, True)
hlg.white_cdm2 *= lscale
if lscale < 1 and logfile:
logfile.write(
"Nominal peak luminance after scaling = %.2f\n" % hlg.white_cdm2
)
maxv = hlg.eotf(maxsignal)
if not size:
size = len(self)
if size < 2:
size = 1024
for i in range(size):
n = i / (size - 1.0)
v = hlg.eotf(min(n, maxsignal))
values.append(min(v / maxv, 1.0))
self[:] = [min(v * 65535, 65535) for v in values]
def set_smpte2084_trc(
self,
black_cdm2=0,
white_cdm2=100,
master_black_cdm2=0,
master_white_cdm2=0,
use_alternate_master_white_clip=True,
rolloff=False,
size=None,
):
"""Set the response to the SMPTE 2084 perceptual quantizer (PQ) function
This response is special in that it depends on the actual black
and white level of the display.
black_cdm2 Black point in absolute Y, range 0..white_cdm2
master_black_cdm2 (Optional) Used to normalize PQ values
master_white_cdm2 (Optional) Used to normalize PQ values
rolloff BT.2390
size Number of steps. Recommended >= 1024
"""
# See https://www.smpte.org/sites/default/files/2014-05-06-EOTF-Miller-1-2-handout.pdf
# Luminance levels depend on the end level of 10000 cd/m2
if black_cdm2 < 0 or black_cdm2 >= white_cdm2:
raise ValueError(
"The black level of %f cd/m2 is out of range "
"for SMPTE 2084. Valid range begins at 0 cd/m2." % black_cdm2
)
if max(white_cdm2, master_white_cdm2) > 10000:
raise ValueError(
"The white level of %f cd/m2 is out of range "
"for SMPTE 2084. Valid range is up to 10000 cd/m2."
% max(white_cdm2, master_white_cdm2)
)
values = []
maxv = white_cdm2 / 10000.0
maxi = colormath.specialpow(maxv, 1.0 / -2084)
if rolloff:
# Rolloff as defined in ITU-R BT.2390
if not master_white_cdm2:
master_white_cdm2 = 10000
bt2390 = colormath.BT2390(
black_cdm2,
white_cdm2,
master_black_cdm2,
master_white_cdm2,
use_alternate_master_white_clip,
)
maxi_out = maxi
else:
if not master_white_cdm2:
master_white_cdm2 = white_cdm2
maxi_out = colormath.specialpow(master_white_cdm2 / 10000.0, 1.0 / -2084)
if not size:
size = len(self)
if size < 2:
size = 1024
for i in range(size):
n = i / (size - 1.0)
if rolloff:
n = bt2390.apply(n)
v = colormath.specialpow(n * (maxi / maxi_out), -2084)
values.append(min(v / maxv, 1.0))
self[:] = [min(v * 65535, 65535) for v in values]
if black_cdm2 and not rolloff:
self.apply_bpc(black_cdm2 / white_cdm2)
def set_trc(self, power=2.2, size=None, vmin=0, vmax=65535):
"""Set the response to a certain function.
Positive power, or -2.4 = sRGB, -3.0 = L*, -240 = SMPTE 240M,
-601 = Rec. 601, -709 = Rec. 709 (Rec. 601 and 709 transfer functions are
identical)
"""
if not size:
size = len(self) or 1024
if size == 1:
if callable(power):
power = colormath.get_gamma([(0.5, power(0.5))])
if power >= 0.0 and not vmin:
self[:] = [power]
return
else:
size = 1024
self[:] = []
if not callable(power):
exp = power
def power(a):
return colormath.specialpow(a, exp)
for i in range(0, size):
self.append(vmin + power(float(i) / (size - 1)) * (vmax - vmin))
def smooth_cr(self, length=64):
"""Smooth curves (Catmull-Rom)."""
raise NotImplementedError()
def smooth_avg(self, passes=1, window=None):
"""Smooth curves (moving average).
passses Number of passes
window Tuple or list containing weighting factors. Its length
determines the size of the window to use.
Defaults to (1.0, 1.0, 1.0)
"""
self[:] = colormath.smooth_avg(self, passes, window)
def sort(self, cmp=None, key=None, reverse=False):
list.sort(self, key=key, reverse=reverse)
self._reset()
@property
def tagData(self):
"""Return raw tag data."""
if len(self) == 1 and self[0] == 1.0:
# Identity
curveEntriesCount = 0
else:
curveEntriesCount = len(self)
tagData = [b"curv", b"\0" * 4, uInt32Number_tohex(curveEntriesCount)]
if curveEntriesCount == 1:
# Gamma
tagData.append(u8Fixed8Number_tohex(self[0]))
elif curveEntriesCount:
# Curve
for curveEntry in self:
tagData.append(uInt16Number_tohex(curveEntry))
return b"".join(tagData)
@tagData.setter
def tagData(self, tagData):
pass
class ParametricCurveType(ICCProfileTag):
def __init__(self, tagData=None, tagSignature=None, profile=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
self.profile = profile
self.params = {}
if not tagData:
return
fntype = uInt16Number(tagData[8:10])
numparams = {0: 1, 1: 3, 2: 4, 3: 5, 4: 7}.get(fntype)
for i, param in enumerate("gabcdef"[:numparams]):
self.params[param] = s15Fixed16Number(tagData[12 + i * 4 : 12 + i * 4 + 4])
def __apply(self, v):
if len(self.params) == 1:
return v ** self.params["g"]
elif len(self.params) == 3:
# CIE 122-1966
if v >= -self.params["b"] / self.params["a"]:
return (self.params["a"] * v + self.params["b"]) ** self.params["g"]
else:
return 0
elif len(self.params) == 4:
# IEC 61966-3
if v >= -self.params["b"] / self.params["a"]:
return (self.params["a"] * v + self.params["b"]) ** self.params[
"g"
] + self.params["c"]
else:
return self.params["c"]
elif len(self.params) == 5:
# IEC 61966-2.1 (sRGB)
if v >= self.params["d"]:
return (self.params["a"] * v + self.params["b"]) ** self.params["g"]
else:
return self.params["c"] * v
elif len(self.params) == 7:
if v >= self.params["d"]:
return (self.params["a"] * v + self.params["b"]) ** self.params[
"g"
] + self.params["e"]
else:
return self.params["c"] * v + self.params["f"]
else:
raise NotImplementedError(
"Invalid number of parameters: %i" % len(self.params)
)
def apply(self, v):
# clip result to [0, 1]
return max(0, min(self.__apply(v), 1))
def get_trc(self, size=1024):
curv = CurveType(profile=self.profile)
for i in range(size):
curv.append(self.apply(i / (size - 1.0)) * 65535)
return curv
class DateTimeType(ICCProfileTag, datetime.datetime):
def __new__(cls, tagData, tagSignature):
dt = dateTimeNumber(tagData[8:20])
return datetime.datetime.__new__(
cls, dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second
)
class DictList(list):
def __getitem__(self, key):
for item in self:
if item[0] == key:
return item
raise KeyError(key)
def __setitem__(self, key, value):
if not isinstance(value, DictListItem):
self.append(DictListItem((key, value)))
class DictListItem(list):
def __iadd__(self, value):
self[-1] += value
return self
class DictType(ICCProfileTag, AODict):
"""ICC dictType Tag
Implements all features of 'Dictionary Type and Metadata TAG Definition'
(ICC spec revision 2010-02-25), including shared data (the latter will
only be effective for mutable types, ie. MultiLocalizedUnicodeType)
Examples:
tag[key] Returns the (non-localized) value
tag.getname(key, locale='en_US') Returns the localized name if present
tag.getvalue(key, locale='en_US') Returns the localized value if present
tag[key] = value Sets the (non-localized) value
"""
def __init__(self, tagData=None, tagSignature=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
AODict.__init__(self)
if not tagData:
return
numrecords = uInt32Number(tagData[8:12])
recordlen = uInt32Number(tagData[12:16])
if recordlen not in (16, 24, 32):
print(
"Error (non-critical): '%s' invalid record length (expected 16, 24 or 32, got %s)"
% (tagData[:4], recordlen)
)
return
elements = {}
for n in range(0, numrecords):
record = tagData[16 + n * recordlen : 16 + (n + 1) * recordlen]
if len(record) < recordlen:
print(
"Error (non-critical): '%s' record %s too short (expected %s bytes, got %s bytes)"
% (tagData[:4], n, recordlen, len(record))
)
break
for key, offsetpos in (
("name", 0),
("value", 8),
("display_name", 16),
("display_value", 24),
):
if (
offsetpos in (0, 8)
or recordlen == offsetpos + 8
or recordlen == offsetpos + 16
):
# Required:
# Bytes 0..3, 4..7: Name offset and size
# Bytes 8..11, 12..15: Value offset and size
# Optional:
# Bytes 16..23, 24..23: Display name offset and size
# Bytes 24..27, 28..31: Display value offset and size
offset = uInt32Number(record[offsetpos : offsetpos + 4])
size = uInt32Number(record[offsetpos + 4 : offsetpos + 8])
if offset > 0:
if (offset, size) in elements:
# Use existing element if same offset and size
# This will really only make a difference for
# mutable types i.e. MultiLocalizedUnicodeType
data = elements[(offset, size)]
else:
data = tagData[offset : offset + size]
try:
if key.startswith("display_"):
data = MultiLocalizedUnicodeType(data, "mluc")
else:
data = data.decode("UTF-16-BE", "replace").rstrip(
"\0"
)
except Exception:
print(
"Error (non-critical): could not decode '%s', offset %s, length %s"
% (tagData[:4], offset, size)
)
# Remember element by offset and size
elements[(offset, size)] = data
if key == "name":
name = data
self[name] = ""
else:
self.get(name)[key] = data
def __getitem__(self, name):
return self.get(name).value
def __setitem__(self, name, value):
AODict.__setitem__(self, name, ADict(value=value))
@property
def tagData(self):
"""Return raw tag data."""
numrecords = len(self)
recordlen = 16
keys = ("name", "value")
for value in self.values():
if isinstance(value, dict):
if "display_value" in value:
recordlen = 32
break
elif "display_name" in value:
recordlen = 24
if recordlen > 16:
keys += ("display_name",)
if recordlen > 24:
keys += ("display_value",)
tagData = [
b"dict",
b"\0" * 4,
uInt32Number_tohex(numrecords),
uInt32Number_tohex(recordlen),
]
storage_offset = 16 + numrecords * recordlen
storage = []
elements = []
offsets = []
for item in self.items():
for key in keys:
if key == "name":
element = item[0]
else:
if isinstance(item[1], dict):
element = item[1].get(key)
else:
element = item[1]
if element is None:
offset = 0
size = 0
else:
if element in elements:
# Use existing offset and size if same element
offset, size = offsets[elements.index(element)]
else:
offset = storage_offset + len(b"".join(storage))
if isinstance(element, MultiLocalizedUnicodeType):
data = element.tagData
else:
data = str(element).encode("UTF-16-BE")
size = len(data)
if isinstance(element, MultiLocalizedUnicodeType):
# Remember element, offset and size
elements.append(element)
offsets.append((offset, size))
# Pad all data with binary zeros so it lies on
# 4-byte boundaries
padding = int(math.ceil(size / 4.0)) * 4 - size
data += b"\0" * padding
storage.append(data)
tagData.append(uInt32Number_tohex(offset))
tagData.append(uInt32Number_tohex(size))
tagData.extend(storage)
return b"".join(tagData)
@tagData.setter
def tagData(self, tagData):
pass
def getname(self, name, default=None, locale="en_US"):
"""Convenience function to get (localized) names"""
item = self.get(name, default)
if item is default:
return default
if locale and "display_name" in item:
return item.display_name.get_localized_string(*locale.split("_"))
else:
return name
def getvalue(self, name, default=None, locale="en_US"):
"""Convenience function to get (localized) values"""
item = self.get(name, default)
if item is default:
return default
if locale and "display_value" in item:
return item.display_value.get_localized_string(*locale.split("_"))
else:
if isinstance(item, dict):
return item.value
else:
return item
def setitem(self, name, value, display_name=None, display_value=None):
"""Convenience function to set items
display_name and display_value (if given) should be dict types with
country -> language -> string mappings, e.g.:
{"en": {"US": u"localized string"},
"de": {"DE": u"localized string", "CH": u"localized string"}}
"""
self[name] = value
item = self.get(name)
if display_name:
item.display_name = MultiLocalizedUnicodeType()
item.display_name.update(display_name)
if display_value:
item.display_value = MultiLocalizedUnicodeType()
item.display_value.update(display_value)
def to_json(self, encoding="UTF-8", errors="replace", locale="en_US"):
"""Return a JSON representation
Display names/values are used if present.
"""
return DictTypeJSONEncoder(locale=locale).encode(self)
class DictTypeJSONEncoder(json.JSONEncoder):
"""JSON Encoder for the DictType class."""
def __init__(self, *args, **kwargs):
self.locale = kwargs.pop("locale") or "en_US"
super().__init__(*args, **kwargs)
def default(self, obj):
return_data = {}
regex = re.compile(r"\\x([0-9a-f]{2})")
repl_str = r"\\u00\1"
for name in obj:
value = obj.getvalue(name, None, self.locale)
name = obj.getname(name, None, self.locale)
value = '"%s"' % repr(str(value))[2:-1].replace('"', '\\"')
name = regex.sub(repl_str, name)
value = regex.sub(repl_str, value)
return_data[name] = value
return return_data
class MakeAndModelType(ICCProfileTag, ADict):
def __init__(self, tagData, tagSignature):
ICCProfileTag.__init__(self, tagData, tagSignature)
self.update({"manufacturer": tagData[10:12], "model": tagData[14:16]})
class MeasurementType(ICCProfileTag, ADict):
def __init__(self, tagData, tagSignature):
ICCProfileTag.__init__(self, tagData, tagSignature)
print(f"tagData[8:12]: {tagData[8:12]}")
self.update(
{
"observer": Observer(tagData[8:12]),
"backing": XYZNumber(tagData[12:24]),
"geometry": Geometry(tagData[24:28]),
"flare": u16Fixed16Number(tagData[28:32]),
"illuminantType": Illuminant(tagData[32:36]),
}
)
class MultiLocalizedUnicodeType(ICCProfileTag, AODict): # ICC v4
def __init__(self, tagData=None, tagSignature=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
AODict.__init__(self)
if not tagData:
return
recordsCount = uInt32Number(tagData[8:12])
recordSize = uInt32Number(tagData[12:16]) # 12
if recordSize != 12:
print(
"Warning (non-critical): '%s' invalid record length (expected 12, got %s)"
% (tagData[:4], recordSize)
)
if recordSize < 12:
recordSize = 12
records = tagData[16 : 16 + recordSize * recordsCount]
for _count in range(recordsCount):
record = records[:recordSize]
if len(record) < 12:
continue
recordLanguageCode = record[:2]
recordCountryCode = record[2:4]
recordLength = uInt32Number(record[4:8])
recordOffset = uInt32Number(record[8:12])
self.add_localized_string(
recordLanguageCode,
recordCountryCode,
str(
tagData[recordOffset : recordOffset + recordLength],
"utf-16-be",
"replace",
),
)
records = records[recordSize:]
def __str__(self):
"""Return tag as string."""
# TODO: Needs some work re locales
# (currently if en-UK or en-US is not found, simply the first entry
# is returned)
if b"en" in self:
for countryCode in (b"UK", b"US"):
if countryCode in self[b"en"]:
return self[b"en"][countryCode]
if self[b"en"]:
return list(self[b"en"].values())[0]
return ""
elif len(self):
return list(list(self.values())[0].values())[0]
else:
return ""
def add_localized_string(self, languagecode, countrycode, localized_string):
"""Convenience function for adding localized strings"""
if languagecode not in self:
self[languagecode] = AODict()
self[languagecode][countrycode] = localized_string.strip("\0")
def get_localized_string(self, languagecode="en", countrycode="US"):
"""Convenience function for retrieving localized strings
Falls back to first locale available if the requested one isn't
"""
try:
return self[languagecode][countrycode]
except KeyError:
return str(self)
@property
def tagData(self):
"""Return raw tag data."""
tagData = [b"mluc", b"\0" * 4]
recordsCount = 0
for languageCode in self:
for _countryCode in self[languageCode]:
recordsCount += 1
tagData.append(uInt32Number_tohex(recordsCount))
recordSize = 12
tagData.append(uInt32Number_tohex(recordSize))
storage_offset = 16 + recordSize * recordsCount
storage = []
offsets = []
for languageCode in self:
for countryCode in self[languageCode]:
tagData.append(languageCode + countryCode)
data = self[languageCode][countryCode].encode("UTF-16-BE")
if data in storage:
offset, recordLength = offsets[storage.index(data)]
else:
recordLength = len(data)
offset = len("".join(storage))
offsets.append((offset, recordLength))
storage.append(data)
tagData.append(uInt32Number_tohex(recordLength))
tagData.append(uInt32Number_tohex(storage_offset + offset))
tagData.append(b"".join(storage)) # TODO: Are you sure that this needs to be bytes
return b"".join(tagData)
@tagData.setter
def tagData(self, tagData):
pass
class ProfileSequenceDescType(ICCProfileTag, list):
def __init__(self, tagData=None, tagSignature=None, profile=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
self.profile = profile
if tagData:
count = uInt32Number(tagData[8:12])
desc_data = tagData[12:]
while count:
# NOTE: Like in the profile header, the attributes are a 64 bit
# value, but the least significant 32 bits (big-endian) are
# reserved for the ICC.
attributes = uInt32Number(desc_data[8:12])
desc = {
"manufacturer": desc_data[0:4],
"model": desc_data[4:8],
"attributes": {
"reflective": attributes & 1 == 0,
"glossy": attributes & 2 == 0,
"positive": attributes & 4 == 0,
"color": attributes & 8 == 0,
},
"tech": desc_data[16:20],
}
desc_data = desc_data[20:]
for desc_type in ("dmnd", "dmdd"):
tag_type = desc_data[0:4]
if tag_type == "desc":
cls = TextDescriptionType
elif tag_type == "mluc":
cls = MultiLocalizedUnicodeType
else:
print(
"Error (non-critical): could not fully decode 'pseq' - unknown %r tag type %r"
% (desc_type, tag_type)
)
count = 1 # Skip remaining
break
desc[desc_type] = cls(desc_data)
desc_data = desc_data[len(desc[desc_type].tagData) :]
self.append(desc)
count -= 1
def add(self, profile):
"""Add description structure of profile"""
desc = {}
desc.update(profile.device)
desc["tech"] = profile.tags.get("tech", b"").ljust(4, b"\0")[:4]
for desc_type in ("dmnd", "dmdd"):
if self.profile.version >= 4:
cls = MultiLocalizedUnicodeType
else:
cls = TextDescriptionType
if self.profile.version < 4 and profile.version < 4:
# Both profiles not v4
tag = profile.tags.get(desc_type, cls())
else:
tag = cls()
description = str(profile.tags.get(desc_type, ""))
if self.profile.version < 4:
# Other profile is v4
tag.ASCII = description.encode("ASCII", "asciize")
if tag.ASCII != description:
tag.Unicode = description
else:
# Other profile is v2
tag.add_localized_string("en", "US", description)
desc[desc_type] = tag
self.append(desc)
@property
def tagData(self):
"""Return raw tag data."""
tag_data = [b"pseq", b"\0" * 4, uInt32Number_tohex(len(self))]
for desc in self:
tag_data.append(desc.get("manufacturer", b"").ljust(4, b"\0")[:4])
tag_data.append(desc.get("model", b"").ljust(4, b"\0")[:4])
attributes = 0
for name, bit in {
"reflective": 1,
"glossy": 2,
"positive": 4,
"color": 8,
}.items():
if not desc.get("attributes", {}).get(name):
attributes |= bit
tag_data.append(uInt32Number_tohex(attributes) + b"\0" * 4)
tag_data.append(desc.get("tech", b"").ljust(4, b"\0")[:4])
for desc_type in ("dmnd", "dmdd"):
tag_data.append(desc.get(desc_type, b"").tagData)
return b"".join(tag_data)
@tagData.setter
def tagData(self, tag_data):
pass
class s15Fixed16ArrayType(ICCProfileTag, list):
def __init__(self, tagData=None, tagSignature=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
if tagData:
data = tagData[8:]
while data:
self.append(s15Fixed16Number(data[0:4]))
data = data[4:]
@property
def tagData(self):
"""Return raw tag data."""
tag_data = [b"sf32", b"\0" * 4]
for value in self:
tag_data.append(s15Fixed16Number_tohex(value))
return b"".join(tag_data)
@tagData.setter
def tagData(self, tag_data):
pass
def SignatureType(tagData, tagSignature):
tag = Text(tagData[8:12].rstrip(b"\0"))
tag.tagData = tagData
tag.tagSignature = tagSignature
return tag
class TextDescriptionType(ICCProfileTag, ADict): # ICC v2
def __init__(self, tagData=None, tagSignature=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
self.ASCII = b""
if not tagData:
return
ASCIIDescriptionLength = uInt32Number(tagData[8:12])
if ASCIIDescriptionLength:
ASCIIDescription = tagData[12 : 12 + ASCIIDescriptionLength].strip(
b"\0\n\r "
)
if ASCIIDescription:
self.ASCII = ASCIIDescription
unicodeOffset = 12 + ASCIIDescriptionLength
self.unicodeLanguageCode = uInt32Number(
tagData[unicodeOffset : unicodeOffset + 4]
)
unicodeDescriptionLength = uInt32Number(
tagData[unicodeOffset + 4 : unicodeOffset + 8]
)
if unicodeDescriptionLength:
if unicodeOffset + 8 + unicodeDescriptionLength * 2 > len(tagData):
# Damn you MS. The Unicode character count should be the number of
# double-byte characters (including trailing unicode NUL), not the
# number of bytes as in the profiles created by Vista and later
print(
"Warning (non-critical): '%s' Unicode part end points "
"past the tag data, assuming number of bytes instead "
"of number of characters for length" % tagData[:4]
)
unicodeDescriptionLength /= 2
if (
tagData[
unicodeOffset
+ 8
+ unicodeDescriptionLength : unicodeOffset
+ 8
+ unicodeDescriptionLength
+ 2
]
== b"\0\0"
):
print(
"Warning (non-critical): '%s' Unicode part "
"seems to be a single-byte string (double-byte "
"string expected)" % tagData[:4]
)
charBytes = 1 # fix for fubar'd desc
else:
charBytes = 2
unicodeDescription = tagData[
unicodeOffset
+ 8 : unicodeOffset
+ 8
+ (unicodeDescriptionLength) * charBytes
]
try:
if charBytes == 1:
unicodeDescription = str(unicodeDescription, errors="replace")
else:
if unicodeDescription[:2] == b"\xfe\xff":
# UTF-16 Big Endian
if debug:
print("UTF-16 Big endian")
unicodeDescription = unicodeDescription[2:]
if (
len(unicodeDescription.split(b" "))
== unicodeDescriptionLength - 1
):
print(
"Warning (non-critical): '%s' "
"Unicode part starts with UTF-16 big "
"endian BOM, but actual contents seem "
"to be UTF-16 little endian" % tagData[:4]
)
# fix fubar'd desc
unicodeDescription = str(
b"\0".join(unicodeDescription.split(b" ")),
"utf-16-le",
errors="replace",
)
else:
unicodeDescription = str(
unicodeDescription, "utf-16-be", errors="replace"
)
elif unicodeDescription[:2] == b"\xff\xfe":
# UTF-16 Little Endian
if debug:
print("UTF-16 Little endian")
unicodeDescription = unicodeDescription[2:]
if unicodeDescription[0] == b"\0":
print(
"Warning (non-critical): '%s' "
"Unicode part starts with UTF-16 "
"little endian BOM, but actual "
"contents seem to be UTF-16 big "
"endian" % tagData[:4]
)
# fix fubar'd desc
unicodeDescription = str(
unicodeDescription, "utf-16-be", errors="replace"
)
else:
unicodeDescription = str(
unicodeDescription, "utf-16-le", errors="replace"
)
else:
if debug:
print("ASSUMED UTF-16 Big Endian")
unicodeDescription = str(
unicodeDescription, "utf-16-be", errors="replace"
)
unicodeDescription = unicodeDescription.strip("\0\n\r ")
if unicodeDescription:
if unicodeDescription.find("\0") < 0:
self.Unicode = unicodeDescription
else:
print(
"Error (non-critical): could not decode "
"'%s' Unicode part - null byte(s) "
"encountered" % tagData[:4]
)
except UnicodeDecodeError:
print(
"UnicodeDecodeError (non-critical): could not "
"decode '%s' Unicode part" % tagData[:4]
)
else:
charBytes = 1
macOffset = unicodeOffset + 8 + unicodeDescriptionLength * charBytes
self.macScriptCode = 0
if len(tagData) > macOffset + 2:
self.macScriptCode = uInt16Number(tagData[macOffset : macOffset + 2])
macDescriptionLength = ord(tagData[macOffset + 2 : macOffset + 3])
if macDescriptionLength:
try:
macDescription = str(
tagData[macOffset + 3 : macOffset + 3 + macDescriptionLength],
"mac-" + encodings["mac"][self.macScriptCode],
errors="replace",
).strip("\0\n\r ")
if macDescription:
self.Macintosh = macDescription
except KeyError:
print(
"KeyError (non-critical): could not decode '%s' Macintosh part (unsupported encoding %s)"
% (tagData[:4], self.macScriptCode)
)
except LookupError:
print(
"LookupError (non-critical): could not decode '%s' "
"Macintosh part (unsupported encoding '%s')"
% (tagData[:4], encodings["mac"][self.macScriptCode])
)
except UnicodeDecodeError:
print(
"UnicodeDecodeError (non-critical): could not decode '%s' Macintosh part"
% tagData[:4]
)
@property
def tagData(self):
"""Return raw tag data."""
tagData = [
b"desc",
b"\0" * 4,
uInt32Number_tohex(len(self.ASCII) + 1), # count of ASCII chars + 1
self.ASCII + b"\0", # ASCII desc, \0 terminated
uInt32Number_tohex(self.get("unicodeLanguageCode", 0)),
]
if "Unicode" in self:
tagData.extend(
[
uInt32Number_tohex(
len(self.Unicode) + 2
), # count of Unicode chars + 2 (UTF-16-BE BOM + trailing UTF-16 NUL, 1 char = 2 byte)
b"\xfe\xff" + self.Unicode.encode("utf-16-be", "replace") + b"\0\0",
]
) # Unicode desc, \0\0 terminated
else:
tagData.append(uInt32Number_tohex(0)) # Unicode desc length = 0
tagData.append(uInt16Number_tohex(self.get("macScriptCode", 0)))
if "Macintosh" in self:
macDescription = self.Macintosh[:66]
tagData.extend(
[
uInt8Number_tohex(
len(macDescription) + 1
), # count of Macintosh chars + 1
macDescription.encode(
"mac-" + encodings["mac"][self.get("macScriptCode", 0)],
"replace",
)
+ (b"\0" * (67 - len(macDescription))),
]
)
else:
tagData.extend([b"\0", b"\0" * 67]) # Mac desc length = 0
return b"".join(tagData)
@tagData.setter
def tagData(self, tagData):
pass
def __str__(self):
if "Unicode" not in self and len(str(self.ASCII)) < 67:
# Do not use Macintosh description if ASCII length >= 67
localizedTypes = ("Macintosh", "ASCII")
else:
localizedTypes = ("Unicode", "ASCII")
for localizedType in localizedTypes:
if localizedType in self:
value = self[localizedType]
if not isinstance(value, str):
# Even ASCII description may contain non-ASCII chars, so
# assume system encoding and convert to unicode, replacing
# unknown chars
value = value.decode("utf-8", "replace")
return value
def TextType(tagData, tagSignature):
tag = Text(tagData[8:].rstrip(b"\0"))
tag.tagData = tagData
tag.tagSignature = tagSignature
return tag
class VideoCardGammaType(ICCProfileTag, ADict):
# Private tag
# http://developer.apple.com/documentation/GraphicsImaging/Reference/ColorSync_Manager/Reference/reference.html#//apple_ref/doc/uid/TP30000259-CH3g-C001473
def __init__(self, tagData, tagSignature):
ICCProfileTag.__init__(self, tagData, tagSignature)
def is_linear(self, r=True, g=True, b=True):
r_points, g_points, b_points, linear_points = self.get_values()
if (
(r and g and b and r_points == g_points == b_points)
or (r and g and r_points == g_points)
or not (g or b)
):
points = r_points
elif (
(r and b and r_points == b_points)
or (g and b and g_points == b_points)
or not (r or g)
):
points = b_points
elif g:
points = g_points
return points == linear_points
def get_unique_values(self, r=True, g=True, b=True):
r_points, g_points, b_points, linear_points = self.get_values()
r_unique = set(round(y) for x, y in r_points)
g_unique = set(round(y) for x, y in g_points)
b_unique = set(round(y) for x, y in b_points)
return r_unique, g_unique, b_unique
def get_values(self, r=True, g=True, b=True):
r_points = []
g_points = []
b_points = []
linear_points = []
vcgt = self
if "data" in vcgt: # table
data = list(vcgt["data"])
while len(data) < 3:
data.append(data[0])
irange = list(range(0, vcgt["entryCount"]))
vmax = math.pow(256, vcgt["entrySize"]) - 1
for i in irange:
j = i * (255.0 / (vcgt["entryCount"] - 1))
linear_points.append(
[j, int(round(i / float(vcgt["entryCount"] - 1) * 65535))]
)
if r:
n = int(round(float(data[0][i]) / vmax * 65535))
r_points.append([j, n])
if g:
n = int(round(float(data[1][i]) / vmax * 65535))
g_points.append([j, n])
if b:
n = int(round(float(data[2][i]) / vmax * 65535))
b_points.append([j, n])
else: # formula
irange = list(range(0, 256))
step = 100.0 / 255.0
for i in irange:
linear_points.append([i, i / 255.0 * 65535])
if r:
vmin = vcgt["redMin"] * 65535
v = math.pow(step * i / 100.0, vcgt["redGamma"])
vmax = vcgt["redMax"] * 65535
r_points.append([i, int(round(vmin + v * (vmax - vmin)))])
if g:
vmin = vcgt["greenMin"] * 65535
v = math.pow(step * i / 100.0, vcgt["greenGamma"])
vmax = vcgt["greenMax"] * 65535
g_points.append([i, int(round(vmin + v * (vmax - vmin)))])
if b:
vmin = vcgt["blueMin"] * 65535
v = math.pow(step * i / 100.0, vcgt["blueGamma"])
vmax = vcgt["blueMax"] * 65535
b_points.append([i, int(round(vmin + v * (vmax - vmin)))])
return r_points, g_points, b_points, linear_points
def printNormalizedValues(self, amount=None, digits=12):
"""Normalizes and prints all values in the vcgt (range of 0.0...1.0).
For a 256-entry table with linear values from 0 to 65535:
# REF C1 C2 C3
001 0.000000000000 0.000000000000 0.000000000000 0.000000000000
002 0.003921568627 0.003921568627 0.003921568627 0.003921568627
003 0.007843137255 0.007843137255 0.007843137255 0.007843137255
...
You can also specify the amount of values to print (where a value
lesser than the entry count will leave out intermediate values)
and the number of digits.
"""
if amount is None:
if hasattr(self, "entryCount"):
amount = self.entryCount
else:
amount = 256 # common value
values = self.getNormalizedValues(amount)
entryCount = len(values)
channels = len(values[0])
header = ["REF"]
for k in range(channels):
header.append("C" + str(k + 1))
header = [title.ljust(digits + 2) for title in header]
print("#".ljust(len(str(amount)) + 1) + " ".join(header))
for i, value in enumerate(values):
formatted_values = [
str(round(channel, digits)).ljust(digits + 2, "0") for channel in value
]
print(
str(i + 1).rjust(len(str(amount)), "0"),
str(round(i / float(entryCount - 1), digits)).ljust(digits + 2, "0"),
" ".join(formatted_values),
)
class VideoCardGammaFormulaType(VideoCardGammaType):
def __init__(self, tagData, tagSignature):
VideoCardGammaType.__init__(self, tagData, tagSignature)
data = tagData[12:]
self.update(
{
"redGamma": u16Fixed16Number(data[0:4]),
"redMin": u16Fixed16Number(data[4:8]),
"redMax": u16Fixed16Number(data[8:12]),
"greenGamma": u16Fixed16Number(data[12:16]),
"greenMin": u16Fixed16Number(data[16:20]),
"greenMax": u16Fixed16Number(data[20:24]),
"blueGamma": u16Fixed16Number(data[24:28]),
"blueMin": u16Fixed16Number(data[28:32]),
"blueMax": u16Fixed16Number(data[32:36]),
}
)
def getNormalizedValues(self, amount=None):
if amount is None:
amount = 256 # common value
step = 1.0 / float(amount - 1)
rgb = AODict([("red", []), ("green", []), ("blue", [])])
for i in range(0, amount):
for key in rgb:
rgb[key].append(
float(self[key + "Min"])
+ math.pow(step * i / 1.0, float(self[key + "Gamma"]))
* float(self[key + "Max"] - self[key + "Min"])
)
return list(zip(*list(rgb.values())))
def getTableType(self, entryCount=256, entrySize=2, quantizer=round):
"""Return gamma as table type."""
maxValue = math.pow(256, entrySize) - 1
tagData = [
self.tagData[:8],
uInt32Number_tohex(0), # type 0 = table
uInt16Number_tohex(3), # channels
uInt16Number_tohex(entryCount),
uInt16Number_tohex(entrySize),
]
int2hex = {
1: uInt8Number_tohex,
2: uInt16Number_tohex,
4: uInt32Number_tohex,
8: uInt64Number_tohex,
}
for key in ("red", "green", "blue"):
for i in range(0, entryCount):
vmin = float(self[key + "Min"])
vmax = float(self[key + "Max"])
gamma = float(self[key + "Gamma"])
v = vmin + math.pow(1.0 / (entryCount - 1) * i, gamma) * float(
vmax - vmin
)
tagData.append(int2hex[entrySize](quantizer(v * maxValue)))
return VideoCardGammaTableType(b"".join(tagData), self.tagSignature)
class VideoCardGammaTableType(VideoCardGammaType):
def __init__(self, tagData, tagSignature):
VideoCardGammaType.__init__(self, tagData, tagSignature)
if not tagData:
self.update({"channels": 0, "entryCount": 0, "entrySize": 0, "data": []})
return
data = tagData[12:]
channels = uInt16Number(data[0:2])
entryCount = uInt16Number(data[2:4])
entrySize = uInt16Number(data[4:6])
self.update(
{
"channels": channels,
"entryCount": entryCount,
"entrySize": entrySize,
"data": [],
}
)
hex2int = {1: uInt8Number, 2: uInt16Number, 4: uInt32Number, 8: uInt64Number}
if entrySize not in hex2int:
raise ValueError(
"Invalid VideoCardGammaTableType entry size %i" % entrySize
)
i = 0
while i < channels:
self.data.append([])
j = 0
while j < entryCount:
index = 6 + i * entryCount * entrySize + j * entrySize
self.data[i].append(hex2int[entrySize](data[index : index + entrySize]))
j = j + 1
i = i + 1
def getNormalizedValues(self, amount=None):
if amount is None:
amount = self.entryCount
maxValue = math.pow(256, self.entrySize) - 1
values = list(
zip(*[[entry / maxValue for entry in channel] for channel in self.data])
)
if amount <= self.entryCount:
step = self.entryCount / float(amount - 1)
all = values
values = []
for i, value in enumerate(all):
if i == 0 or (i + 1) % step < 1 or i + 1 == self.entryCount:
values.append(value)
return values
def getFormulaType(self):
"""Return formula representing gamma value at 50% input."""
maxValue = math.pow(256, self.entrySize) - 1
tagData = [self.tagData[:8], uInt32Number_tohex(1)] # type 1 = formula
data = list(self.data)
while len(data) < 3:
data.append(data[0])
for channel in data:
l = (len(channel) - 1) / 2.0
floor = float(channel[int(math.floor(l))])
ceil = float(channel[int(math.ceil(l))])
vmin = channel[0] / maxValue
vmax = channel[-1] / maxValue
v = (vmin + ((floor + ceil) / 2.0) * (vmax - vmin)) / maxValue
gamma = math.log(v) / math.log(0.5)
print(vmin, gamma, vmax)
tagData.append(u16Fixed16Number_tohex(gamma))
tagData.append(u16Fixed16Number_tohex(vmin))
tagData.append(u16Fixed16Number_tohex(vmax))
return VideoCardGammaFormulaType(b"".join(tagData), self.tagSignature)
def quantize(self, bits=16, quantizer=round):
"""Quantize to n bits of precision.
Note that when the quantize bits are not 8, 16, 32 or 64, double
quantization will occur: First from the table precision bits according
to entrySize to the chosen quantization bits, and then back to the
table precision bits.
"""
oldmax = math.pow(256, self.entrySize) - 1
if bits in (8, 16, 32, 64):
self.entrySize = int(bits / 8)
bitv = 2.0**bits
newmax = math.pow(256, self.entrySize) - 1
for _i, channel in enumerate(self.data):
for j, value in enumerate(channel):
channel[j] = int(quantizer(value / oldmax * bitv) / bitv * newmax)
def resize(self, length=128):
data = [[], [], []]
for i, channel in enumerate(self.data):
for j in range(0, length):
j *= (len(channel) - 1) / float(length - 1)
if int(j) != j:
floor = channel[int(math.floor(j))]
ceil = channel[min(int(math.ceil(j)), len(channel) - 1)]
interpolated = range(floor, ceil + 1)
fraction = j - int(j)
index = int(round(fraction * (ceil - floor)))
v = interpolated[index]
else:
v = channel[int(j)]
data[i].append(v)
self.data = data
self.entryCount = len(data[0])
def resized(self, length=128):
resized = self.__class__(self.tagData, self.tagSignature)
resized.resize(length)
return resized
def smooth_cr(self, length=64):
"""Smooth video LUT curves (Catmull-Rom)."""
resized = self.resized(length)
for i in range(0, len(self.data)):
step = float(length - 1) / (len(self.data[i]) - 1)
interpolation = CRInterpolation(resized.data[i])
for j in range(0, len(self.data[i])):
self.data[i][j] = interpolation(j * step)
def smooth_avg(self, passes=1, window=None):
"""Smooth video LUT curves (moving average).
passses Number of passes
window Tuple or list containing weighting factors. Its length
determines the size of the window to use.
Defaults to (1.0, 1.0, 1.0)
"""
for i, channel in enumerate(self.data):
self.data[i] = colormath.smooth_avg(channel, passes, window)
self.entryCount = len(self.data[0])
@property
def tagData(self):
"""Return raw tag data."""
tagData = [
b"vcgt",
b"\0" * 4,
uInt32Number_tohex(0), # type 0 = table
uInt16Number_tohex(len(self.data)), # channels
uInt16Number_tohex(self.entryCount),
uInt16Number_tohex(self.entrySize),
]
int2hex = {
1: uInt8Number_tohex,
2: uInt16Number_tohex,
4: uInt32Number_tohex,
8: uInt64Number_tohex,
}
for channel in self.data:
for i in range(0, self.entryCount):
tagData.append(int2hex[self.entrySize](channel[i]))
return b"".join(tagData)
@tagData.setter
def tagData(self, tagData):
pass
class ViewingConditionsType(ICCProfileTag, ADict):
def __init__(self, tagData, tagSignature):
ICCProfileTag.__init__(self, tagData, tagSignature)
self.update(
{
"illuminant": XYZNumber(tagData[8:20]),
"surround": XYZNumber(tagData[20:32]),
"illuminantType": Illuminant(tagData[32:36]),
}
)
class TagData(object):
def __init__(self, tagData, offset, size):
self.tagData = tagData
self.offset = offset
self.size = size
def __contains__(self, item):
return item in bytes(self)
def __bytes__(self):
return self.tagData[self.offset : self.offset + self.size]
class WcsProfilesTagType(ICCProfileTag, ADict):
def __init__(self, tagData, tagSignature, profile):
ICCProfileTag.__init__(self, tagData, tagSignature)
self.profile = profile
for i, modelname in enumerate(
["ColorDeviceModel", "ColorAppearanceModel", "GamutMapModel"]
):
j = i * 8
if len(tagData) < 16 + j:
break
offset = uInt32Number(tagData[8 + j : 12 + j])
size = uInt32Number(tagData[12 + j : 16 + j])
if offset and size:
from io import StringIO
from xml.etree import ElementTree
it = ElementTree.iterparse(StringIO(tagData[offset : offset + size]))
for _event, elem in it:
elem.tag = elem.tag.split("}", 1)[-1] # Strip all namespaces
self[modelname] = it.root
def get_vcgt(self, quantize=False, quantizer=round):
"""Return calibration information (if present) as VideoCardGammaType
If quantize is set, a table quantized to bits is returned.
Note that when the quantize bits are not 8, 16, 32 or 64, multiple
quantizations will occur: For quantization bits below 32, first to 32
bits, then to the chosen quantization bits, then back to 32 bits (which
will be the final table precision bits).
"""
if quantize and not isinstance(quantize, int):
raise ValueError("Invalid quantization bits: %r" % quantize)
if "ColorDeviceModel" in self:
# Parse calibration information to VCGT
cal = self.ColorDeviceModel.find("Calibration")
if cal is None:
return
agammaconf = cal.find("AdapterGammaConfiguration")
if agammaconf is None:
return
pcurves = agammaconf.find("ParameterizedCurves")
if pcurves is None:
return
vcgtData = "vcgt"
vcgtData += b"\0" * 4
vcgtData += uInt32Number_tohex(1) # Type 1 = formula
for color in ("Red", "Green", "Blue"):
trc = pcurves.find(color + "TRC")
if trc is None:
trc = {}
vcgtData += u16Fixed16Number_tohex(float(trc.get("Gamma", 1)))
vcgtData += u16Fixed16Number_tohex(float(trc.get("Offset1", 0)))
vcgtData += u16Fixed16Number_tohex(float(trc.get("Gain", 1)))
vcgt = VideoCardGammaFormulaType(vcgtData, "vcgt")
if quantize:
if quantize in (8, 16, 32, 64):
entrySize = quantize / 8
elif quantize < 32:
entrySize = 4
else:
entrySize = 8
vcgt = vcgt.getTableType(entrySize=entrySize, quantizer=quantizer)
if quantize not in (8, 16, 32, 64):
vcgt.quantize(quantize, quantizer)
return vcgt
class XYZNumber(AODict):
"""Byte
Offset Content Encoded as...
0..3 CIE X s15Fixed16Number
4..7 CIE Y s15Fixed16Number
8..11 CIE Z s15Fixed16Number
:param bytes binaryString:
"""
def __init__(self, binaryString=b"\0" * 12):
AODict.__init__(self)
self.X, self.Y, self.Z = [
s15Fixed16Number(chunk)
for chunk in (binaryString[:4], binaryString[4:8], binaryString[8:12])
]
def __repr__(self):
XYZ = []
for key in self:
value = self[key]
XYZ.append("(%s, %s)" % (repr(key), str(value)))
return "%s.%s([%s])" % (
self.__class__.__module__,
self.__class__.__name__,
", ".join(XYZ),
)
def adapt(
self, whitepoint_source=None, whitepoint_destination=None, cat="Bradford"
):
XYZ = self.__class__()
XYZ.X, XYZ.Y, XYZ.Z = colormath.adapt(
self.X, self.Y, self.Z, whitepoint_source, whitepoint_destination, cat
)
return XYZ
def round(self, digits=4):
XYZ = self.__class__()
for key in self:
XYZ[key] = round(self[key], digits)
return XYZ
def tohex(self):
data = [s15Fixed16Number_tohex(n) for n in list(self.values())]
return b"".join(data)
@property
def hex(self):
return self.tohex()
@property
def Lab(self):
return colormath.XYZ2Lab(*[v * 100 for v in list(self.values())])
@property
def xyY(self):
return NumberTuple(colormath.XYZ2xyY(self.X, self.Y, self.Z))
class XYZType(ICCProfileTag, XYZNumber):
def __init__(self, tagData=b"\0" * 20, tagSignature=None, profile=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
XYZNumber.__init__(self, tagData[8:20])
self.profile = profile
__repr__ = XYZNumber.__repr__
def __setattr__(self, name, value):
if name in ("_keys", "profile", "tagData", "tagSignature"):
object.__setattr__(self, name, value)
else:
self[name] = value
def adapt(self, whitepoint_source=None, whitepoint_destination=None, cat=None):
if cat is None:
if self.profile and isinstance(
self.profile.tags.get("arts"), chromaticAdaptionTag
):
cat = self.profile.tags.arts
else:
cat = "Bradford"
XYZ = self.__class__(profile=self.profile)
XYZ.X, XYZ.Y, XYZ.Z = colormath.adapt(
self.X, self.Y, self.Z, whitepoint_source, whitepoint_destination, cat
)
return XYZ
@property
def ir(self):
"""Get illuminant-relative values"""
pcs_illuminant = list(self.profile.illuminant.values())
if b"chad" in self.profile.tags and self.profile.creator != b"appl":
# Apple profiles have a bug where they contain a 'chad' tag,
# but the media white is not under PCS illuminant
if self is self.profile.tags.wtpt:
XYZ = self.__class__(profile=self.profile)
XYZ.X, XYZ.Y, XYZ.Z = list(self.values())
else:
# Go from XYZ mediawhite-relative under PCS illuminant to XYZ
# under PCS illuminant
if isinstance(self.profile.tags.get("arts"), chromaticAdaptionTag):
cat = self.profile.tags.arts
else:
cat = "XYZ scaling"
XYZ = self.adapt(
pcs_illuminant, list(self.profile.tags.wtpt.values()), cat=cat
)
# Go from XYZ under PCS illuminant to XYZ illuminant-relative
XYZ.X, XYZ.Y, XYZ.Z = self.profile.tags.chad.inverted() * list(XYZ.values())
return XYZ
else:
if self in (self.profile.tags.wtpt, self.profile.tags.get("bkpt")):
# For profiles without 'chad' tag, the white/black point should
# already be illuminant-relative
return self
elif "chad" in self.profile.tags:
XYZ = self.__class__(profile=self.profile)
# Go from XYZ under PCS illuminant to XYZ illuminant-relative
XYZ.X, XYZ.Y, XYZ.Z = self.profile.tags.chad.inverted() * list(
self.values()
)
return XYZ
else:
# Go from XYZ under PCS illuminant to XYZ illuminant-relative
return self.adapt(pcs_illuminant, list(self.profile.tags.wtpt.values()))
@property
def pcs(self):
"""Get PCS-relative values"""
if self in (self.profile.tags.wtpt, self.profile.tags.get("bkpt")) and (
"chad" not in self.profile.tags or self.profile.creator == b"appl"
):
# Apple profiles have a bug where they contain a 'chad' tag,
# but the media white is not under PCS illuminant
if "chad" in self.profile.tags:
XYZ = self.__class__(profile=self.profile)
XYZ.X, XYZ.Y, XYZ.Z = self.profile.tags.chad * list(self.values())
return XYZ
pcs_illuminant = list(self.profile.illuminant.values())
return self.adapt(list(self.profile.tags.wtpt.values()), pcs_illuminant)
else:
# Values should already be under PCS illuminant
return self
@property
def tagData(self):
"""Return raw tag data."""
tagData = [b"XYZ ", b"\0" * 4]
tagData.append(self.tohex())
return b"".join(tagData)
@tagData.setter
def tagData(self, tagData):
pass
@property
def xyY(self):
if self is self.profile.tags.get("bkpt"):
ref = self.profile.tags.bkpt
else:
ref = self.profile.tags.wtpt
return NumberTuple(
colormath.XYZ2xyY(self.X, self.Y, self.Z, (ref.X, ref.Y, ref.Z))
)
class chromaticAdaptionTag(colormath.Matrix3x3, s15Fixed16ArrayType):
def __init__(self, tagData=None, tagSignature=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
if tagData:
data = tagData[8:]
if data:
matrix = []
while data:
if len(matrix) == 0 or len(matrix[-1]) == 3:
matrix.append([])
matrix[-1].append(s15Fixed16Number(data[0:4]))
data = data[4:]
self.update(matrix)
else:
self._reset()
@property
def tagData(self):
"""Return raw tag data."""
tagData = [b"sf32", b"\0" * 4]
for row in self:
for column in row:
tagData.append(s15Fixed16Number_tohex(column))
return b"".join(tagData)
@tagData.setter
def tagData(self, tagData):
pass
def get_cat(self):
"""Compare to known CAT matrices and return matching name (if any)"""
def q(v):
return s15Fixed16Number(s15Fixed16Number_tohex(v))
for cat_name in colormath.cat_matrices:
cat_matrix = colormath.cat_matrices[cat_name]
if colormath.is_similar_matrix(self.applied(q), cat_matrix.applied(q), 4):
return cat_name
class NamedColor2Value(object):
def __init__(
self, valueData=b"\0" * 38, deviceCoordCount=0, pcs="XYZ", device="RGB"
):
self._pcsname = pcs
self._devicename = device
end = valueData[0:32].find(b"\0")
if end < 0:
end = 32
self.rootName = valueData[0:end]
self.pcsvalues = [
uInt16Number(valueData[32:34]),
uInt16Number(valueData[34:36]),
uInt16Number(valueData[36:38]),
]
self.pcs = AODict()
for i, pcsvalue in enumerate(self.pcsvalues):
if pcs == "Lab":
if i == 0:
# L* range 0..100 + (25500 / 65280.0)
self.pcs[pcs[i]] = pcsvalue / 65536.0 * 256 / 255.0 * 100
else:
# a, b range -128..127 + (255/256.0)
self.pcs[pcs[i]] = -128 + (pcsvalue / 65536.0 * 256)
elif pcs == "XYZ":
# X, Y, Z range 0..100 + (32767 / 32768.0)
self.pcs[pcs[i]] = pcsvalue / 32768.0 * 100
deviceCoords = []
if deviceCoordCount > 0:
for i in range(38, 38 + deviceCoordCount * 2, 2):
deviceCoords.append(uInt16Number(valueData[i : i + 2]))
self.devicevalues = deviceCoords
if device == "Lab":
# L* range 0..100 + (25500 / 65280.0)
# a, b range range -128..127 + (255 / 256.0)
self.device = tuple(
v / 65536.0 * 256 / 255.0 * 100
if i == 0
else -128 + (v / 65536.0 * 256)
for i, v in enumerate(deviceCoords)
)
elif device == "XYZ":
# X, Y, Z range 0..100 + (32767 / 32768.0)
self.device = tuple(v / 32768.0 * 100 for v in deviceCoords)
else:
# Device range 0..100
self.device = tuple(v / 65535.0 * 100 for v in deviceCoords)
@property
def name(self):
return str(Text(self.rootName.strip(b"\0")), "latin-1")
def __repr__(self):
pcs = []
dev = []
for key in self.pcs:
value = self.pcs[key]
pcs.append("%s=%s" % (str(key), str(value)))
for value in self.device:
dev.append("%s" % value)
return "%s(%s, {%s}, [%s])" % (
self.__class__.__name__,
self.name,
", ".join(pcs),
", ".join(dev),
)
@property
def tagData(self):
"""Return raw tag data."""
valueData = []
valueData.append(self.rootName.ljust(32, b"\0"))
valueData.extend([uInt16Number_tohex(pcsval) for pcsval in self.pcsvalues])
valueData.extend(
[uInt16Number_tohex(deviceval) for deviceval in self.devicevalues]
)
return b"".join(valueData)
@tagData.setter
def tagData(self, tagData):
pass
class NamedColor2ValueTuple(tuple):
__slots__ = ()
REPR_OUTPUT_SIZE = 10
def __repr__(self):
data = list(self[: self.REPR_OUTPUT_SIZE + 1])
if len(data) > self.REPR_OUTPUT_SIZE:
data[-1] = "...(remaining elements truncated)..."
return repr(data)
@property
def tagData(self):
"""Return raw tag data."""
return b"".join([val.tagData for val in self])
@tagData.setter
def tagData(self, tagData):
pass
class NamedColor2Type(ICCProfileTag, AODict):
REPR_OUTPUT_SIZE = 10
def __init__(self, tagData=b"\0" * 84, tagSignature=None, pcs=None, device=None):
ICCProfileTag.__init__(self, tagData, tagSignature)
AODict.__init__(self)
colorCount = uInt32Number(tagData[12:16])
deviceCoordCount = uInt32Number(tagData[16:20])
stride = 38 + 2 * deviceCoordCount
self.vendorData = tagData[8:12]
self.colorCount = colorCount
self.deviceCoordCount = deviceCoordCount
self._prefix = Text(tagData[20:52])
self._suffix = Text(tagData[52:84])
self._pcsname = pcs
self._devicename = device
keys = []
values = []
if colorCount > 0:
start = 84
end = start + (stride * colorCount)
for i in range(start, end, stride):
nc2 = NamedColor2Value(
tagData[i : i + stride], deviceCoordCount, pcs=pcs, device=device
)
keys.append(nc2.name)
values.append(nc2)
self.update(dict(list(zip(keys, values))))
def __setattr__(self, name, value):
object.__setattr__(self, name, value)
@property
def prefix(self):
return str(self._prefix.strip(b"\0"), "latin-1")
@property
def suffix(self):
return str(self._suffix.strip(b"\0"), "latin-1")
@property
def colorValues(self):
return NamedColor2ValueTuple(list(self.values()))
def add_color(self, rootName, *deviceCoordinates, **pcsCoordinates):
if self._pcsname == "Lab":
keys = ["L", "a", "b"]
elif self._pcsname == "XYZ":
keys = ["X", "Y", "Z"]
else:
keys = ["X", "Y", "Z"]
if not set(pcsCoordinates.keys()).issuperset(set(keys)):
raise ICCProfileInvalidError(
"Can't add namedColor2 without all 3 PCS coordinates: '%s'" % set(keys)
- set(pcsCoordinates.keys())
)
if len(deviceCoordinates) != self.deviceCoordCount:
raise ICCProfileInvalidError(
"Can't add namedColor2 without all %s device coordinates (called with %s)"
% (self.deviceCoordCount, len(deviceCoordinates))
)
nc2value = NamedColor2Value()
nc2value._pcsname = self._pcsname
nc2value._devicename = self._devicename
nc2value.rootName = rootName
if rootName in list(self.keys()):
raise ICCProfileInvalidError(
"Can't add namedColor2 with existant name: '%s'" % rootName
)
nc2value.devicevalues = []
nc2value.device = tuple(deviceCoordinates)
nc2value.pcs = AODict(copy(pcsCoordinates))
for idx, key in enumerate(keys):
val = nc2value.pcs[key]
if key == "L":
nc2value.pcsvalues[idx] = val * 65536 / (256 / 255.0) / 100.0
elif key in ("a", "b"):
nc2value.pcsvalues[idx] = (val + 128) * 65536 / 256.0
elif key in ("X", "Y", "Z"):
nc2value.pcsvalues[idx] = val * 32768 / 100.0
for idx, val in enumerate(nc2value.device):
if self._devicename == "Lab":
if idx == 0:
# L* range 0..100 + (25500 / 65280.0)
nc2value.devicevalues[idx] = val * 65536 / (256 / 255.0) / 100.0
else:
# a, b range -128..127 + (255/256.0)
nc2value.devicevalues[idx] = (val + 128) * 65536 / 256.0
elif self._devicename == "XYZ":
# X, Y. Z range 0..100 + (32767 / 32768.0)
nc2value.devicevalues[idx] = val * 32768 / 100.0
else:
# Device range 0..100
nc2value.devicevalues[idx] = val * 65535 / 100.0
self[nc2value.name] = nc2value
def __repr__(self):
data = list(self.items())[: self.REPR_OUTPUT_SIZE + 1]
if len(data) > self.REPR_OUTPUT_SIZE:
data[-1] = ("...", "(remaining elements truncated)")
return repr(dict(data))
@property
def tagData(self):
"""Return raw tag data."""
tagData = [
b"ncl2",
b"\0" * 4,
self.vendorData,
uInt32Number_tohex(len(list(self.items()))),
uInt32Number_tohex(self.deviceCoordCount),
self._prefix.ljust(32),
self._suffix.ljust(32),
self.colorValues.tagData,
]
return b"".join(tagData)
@tagData.setter
def tagData(self, tagData):
pass
tagSignature2Tag = {"arts": chromaticAdaptionTag, "chad": chromaticAdaptionTag}
typeSignature2Type = {
b"chrm": ChromaticityType,
b"clrt": ColorantTableType,
b"curv": CurveType,
b"desc": TextDescriptionType, # ICC v2
b"dict": DictType, # ICC v2 + v4
b"dtim": DateTimeType,
b"meas": MeasurementType,
b"mluc": MultiLocalizedUnicodeType, # ICC v4
b"mft2": LUT16Type,
b"mmod": MakeAndModelType, # Apple private tag
b"ncl2": NamedColor2Type,
b"para": ParametricCurveType,
b"pseq": ProfileSequenceDescType,
b"sf32": s15Fixed16ArrayType,
b"sig ": SignatureType,
b"text": TextType,
b"vcgt": videoCardGamma,
b"view": ViewingConditionsType,
b"MS10": WcsProfilesTagType,
b"XYZ ": XYZType,
}
class ICCProfileInvalidError(IOError):
pass
_iccprofilecache = WeakValueDictionary()
class ICCProfile(object):
"""Returns a new ICCProfile object.
Optionally initialized with a string containing binary profile data or
a filename, or a file-like object. Also, if the 'load' keyword argument
is False (default True), only the header will be read initially and
loading of the tags will be deferred to when they are accessed the
first time.
"""
_recent = []
def __new__(cls, profile=None, load=True, use_cache=False):
key = None
# the content of the profile should be passed as bytes in Python 3.
if isinstance(profile, (str, pathlib.Path)):
# Filename
if not profile:
raise ICCProfileInvalidError("Empty path given")
if isinstance(profile, str):
p = pathlib.Path(profile)
else:
p = profile
if not p.is_file() and not p.is_absolute():
search_paths = list(set(iccprofiles_home + iccprofiles))
found_profile = False
while search_paths and not found_profile:
search_path = pathlib.Path(search_paths.pop(0))
if search_path.is_dir(): # only look in to directories
for entry in search_path.glob(profile):
if entry.is_file():
profile = str(entry)
# TODO: update this to stay a Path instance after migration
# to pathlib is completed
found_profile = True
break
if use_cache:
stat = os.stat(profile)
key = (profile, stat.st_dev, stat.st_ino, stat.st_mtime, stat.st_size)
else:
key = ()
elif isinstance(profile, bytes):
# Binary string
if use_cache:
key = md5(profile).hexdigest()
if use_cache:
chk = _iccprofilecache.get(key)
if chk:
return chk
if isinstance(key, tuple):
# Filename
profile = open(profile, "rb")
self = super(ICCProfile, cls).__new__(cls)
if use_cache and key:
_iccprofilecache[key] = self
# Make sure most recent three are not garbage collected
if len(ICCProfile._recent) == 3:
ICCProfile._recent.pop(0)
ICCProfile._recent.append(self)
self._key = key
self.ID = b"\0" * 16
self._data = b""
self._file = None
self._tagoffsets = [] # Original tag offsets
self._tags = LazyLoadTagAODict(self)
self.fileName = None
self.is_loaded = False
self.size = 0
if profile is not None:
if isinstance(profile, bytes):
# Binary string
data = profile
self.is_loaded = True
else:
# File object
self._file = profile
self.fileName = self._file.name
self._file.seek(0)
data = self._file.read(128)
self.close()
if not data or len(data) < 128:
raise ICCProfileInvalidError("Not enough data")
if data[:5] == b" 131:
# tag table and tagged element data
tagCount = uInt32Number(self._data[128:132])
if debug:
print("tagCount:", tagCount)
tagTable = self._data[132 : 132 + tagCount * 12]
self._tagoffsets = []
discard_len = 0
tags = {}
while tagTable:
tag = tagTable[:12]
if len(tag) < 12:
raise ICCProfileInvalidError("Tag table is truncated")
tagSignature = tag[:4].decode()
if debug:
print("tagSignature:", tagSignature)
tagDataOffset = uInt32Number(tag[4:8])
self._tagoffsets.append((tagDataOffset, tagSignature))
if debug:
print(" tagDataOffset:", tagDataOffset)
tagDataSize = uInt32Number(tag[8:12])
if debug:
print(" tagDataSize:", tagDataSize)
if tagSignature in self._tags:
print(
"Error (non-critical): Tag '%s' already encountered. Skipping..."
% tagSignature
)
else:
if (tagDataOffset, tagDataSize) in tags:
if debug:
print(
" tagDataOffset and tagDataSize indicate shared tag"
)
else:
start = tagDataOffset - discard_len
if debug:
print(" tagData start:", start)
end = tagDataOffset - discard_len + tagDataSize
if debug:
print(" tagData end:", end)
tagData = self._data[start:end]
if len(tagData) < tagDataSize:
print(
"Warning: Tag data for tag %r is truncated (offset %i, expected size %i, "
"actual size %i)"
% (
tagSignature,
tagDataOffset,
tagDataSize,
len(tagData),
)
)
tagDataSize = len(tagData)
typeSignature = tagData[:4]
if len(typeSignature) < 4:
print(
"Warning: Tag type signature for tag %r is truncated (offset %i, size %i)"
% (tagSignature, tagDataOffset, tagDataSize)
)
typeSignature = typeSignature.ljust(4, b" ")
if debug:
print(" typeSignature:", typeSignature)
tags[(tagDataOffset, tagDataSize)] = (
typeSignature,
tagDataOffset,
tagDataSize,
tagData,
)
self._tags[tagSignature] = tags[(tagDataOffset, tagDataSize)]
tagTable = tagTable[12:]
self._data = self._data[:128]
return self._tags
def calculateID(self, setID=True):
"""Calculates, sets, and returns the profile's ID (checksum).
Calling this function always recalculates the checksum on-the-fly,
in contrast to just accessing the ID property.
The entire profile, based on the size field in the header, is used
to calculate the ID after the values in the Profile Flags field
(bytes 44 to 47), Rendering Intent field (bytes 64 to 67) and
Profile ID field (bytes 84 to 99) in the profile header have been
temporarily replaced with zeros.
"""
data = self.data
data = (
data[:44]
+ b"\0\0\0\0"
+ data[48:64]
+ b"\0\0\0\0"
+ data[68:84]
+ b"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ data[100:]
)
ID = md5(data).digest()
if setID:
if ID != self.ID:
# No longer reflects original profile
self._delfromcache()
self.ID = ID
return ID
def close(self):
"""Closes the associated file object (if any)."""
if self._file and not self._file.closed:
self._file.close()
def convert_iccv4_tags_to_iccv2(self, version=2.4, undo_wtpt_chad=False):
"""Convert ICCv4 parametric curve tags to ICCv2-compatible curve tags
If desired version after conversion is < 2.4 and undo_wtpt_chad is True,
also set whitepoint to illuinant relative values, and remove any
chromatic adaptation tag.
If ICC profile version is < 4 or no [rgb]TRC tags or LUT16Type tags,
return False.
Otherwise, convert curve tags and return True.
"""
if self.version < 4:
return False
# Fail if any LUT tag is not LUT16Type as we currently
# have not implemented conversion (which may not even
# be possible, depending on LUT contents)
has_lut_tags = False
for direction in ("A2B", "B2A"):
for tableno in range(3):
tag = self.tags.get("%s%i" % (direction, tableno))
if tag:
if isinstance(tag, LUT16Type):
has_lut_tags = True
else:
return False
if self.has_trc_tags():
for channel in "rgb":
tag = self.tags[channel + "TRC"]
if isinstance(tag, ParametricCurveType):
# Convert to CurveType
self.tags[channel + "TRC"] = tag.get_trc()
elif not has_lut_tags:
return False
# Set fileName to None because our profile no longer reflects the file
# on disk and remove from cache
self.fileName = None
self._delfromcache()
if version < 2.4 and undo_wtpt_chad:
# Set whitepoint tag to illuminant relative and remove chromatic
# adaptation tag afterwards(!)
self.tags.wtpt = self.tags.wtpt.ir
if "chad" in self.tags:
del self.tags["chad"]
# Get all multiLocalizedUnicodeType tags
mluc = {}
for tagname in self.tags:
tag = self.tags[tagname]
if isinstance(tag, MultiLocalizedUnicodeType):
mluc[tagname] = str(tag)
# Set profile version
self.version = version
# Convert to textDescriptionType/textType (after setting version to 2.x)
for tagname in mluc:
unistr = mluc[tagname]
if tagname == "cprt":
self.setCopyright(unistr)
else:
self.set_localizable_desc(tagname, unistr)
return True
def convert_iccv2_tags_to_iccv4(self):
"""Convert ICCv2 text description tags to ICCv4 multi-localized unicode
Also sets whitepoint to D50, and stores illuminant-relative to D50
matrix as chromatic adaptation tag.
If ICC profile version is >= 4, return False.
Otherwise, convert and return True.
After conversion, the profile version is 4.3
"""
if self.version >= 4:
return False
# Set fileName to None because our profile no longer reflects the file
# on disk and remove from cache
self.fileName = None
self._delfromcache()
wtpt = list(self.tags.wtpt.ir.values())
# Set whitepoint tag to D50
self.tags.wtpt = self.tags.wtpt.pcs
if "chad" not in self.tags:
# Set chromatic adaptation matrix
self.tags["chad"] = chromaticAdaptionTag()
wpam = colormath.wp_adaption_matrix(
wtpt, cat=self.tags.get("arts", "Bradford")
)
self.tags["chad"].update(wpam)
# Get all textDescriptionType tags
text = {}
for tagname in self.tags:
tag = self.tags[tagname]
if tagname == "cprt" or isinstance(tag, TextDescriptionType):
text[tagname] = str(tag)
# Set profile version to 4.3
self.version = 4.3
# Convert to multiLocalizedUnicodeType (after setting version to 4.x)
for tagname in text:
unistr = text[tagname]
self.set_localizable_text(tagname, unistr)
return True
@staticmethod
def from_named_rgb_space(
rgb_space_name, iccv4=False, cat="Bradford", profile_class=b"mntr"
):
rgb_space = colormath.get_rgb_space(rgb_space_name)
return ICCProfile.from_rgb_space(
rgb_space, rgb_space_name, iccv4, cat, profile_class
)
@staticmethod
def from_rgb_space(
rgb_space, description, iccv4=False, cat="Bradford", profile_class=b"mntr"
):
rx, ry = rgb_space[2:][0][:2]
gx, gy = rgb_space[2:][1][:2]
bx, by = rgb_space[2:][2][:2]
wx, wy = colormath.XYZ2xyY(*rgb_space[1])[:2]
return ICCProfile.from_chromaticities(
rx,
ry,
gx,
gy,
bx,
by,
wx,
wy,
rgb_space[0],
description,
"No copyright",
iccv4=iccv4,
cat=cat,
profile_class=profile_class,
)
@staticmethod
def from_edid(edid, iccv4=False, cat="Bradford"):
"""Create an ICC Profile from EDID data and return it
You may override the gamma from EDID by setting it to a list of curve
values.
"""
description = edid.get(
"monitor_name", edid.get("ascii", str(edid["product_id"] or edid["hash"]))
)
manufacturer = edid.get("manufacturer", b"")
manufacturer_id = edid["edid"][8:10]
model_name = description
model_id = edid["edid"][10:12]
copyright = "Created from EDID"
# Get chromaticities of primaries0
xy = {}
for color in ("red", "green", "blue", "white"):
x, y = edid.get(color + "_x", 0.0), edid.get(color + "_y", 0.0)
xy[color[0] + "x"] = x
xy[color[0] + "y"] = y
gamma = edid.get("gamma", 2.2)
profile = ICCProfile.from_chromaticities(
xy["rx"],
xy["ry"],
xy["gx"],
xy["gy"],
xy["bx"],
xy["by"],
xy["wx"],
xy["wy"],
gamma,
description,
copyright,
manufacturer,
model_name,
manufacturer_id,
model_id,
iccv4,
cat,
)
profile.set_edid_metadata(edid)
spec_prefixes = "DATA_,OPENICC_"
prefixes = (
profile.tags.meta.getvalue("prefix", "", None) or spec_prefixes
).split(",")
for prefix in spec_prefixes.split(","):
if prefix not in prefixes:
prefixes.append(prefix)
profile.tags.meta["prefix"] = ",".join(prefixes)
profile.tags.meta["OPENICC_automatic_generated"] = "1"
profile.tags.meta["DATA_source"] = "edid"
profile.calculateID()
return profile
@staticmethod
def from_chromaticities(
rx,
ry,
gx,
gy,
bx,
by,
wx,
wy,
gamma,
description,
copyright,
manufacturer=None,
model_name=None,
manufacturer_id=b"\0\0",
model_id=b"\0\0",
iccv4=False,
cat="Bradford",
profile_class=b"mntr",
):
"""Create an ICC Profile from chromaticities and return it"""
wXYZ = colormath.xyY2XYZ(wx, wy, 1.0)
# Calculate RGB to XYZ matrix from chromaticities and white
mtx = colormath.rgb_to_xyz_matrix(rx, ry, gx, gy, bx, by, wXYZ)
rgb = {"r": (1.0, 0.0, 0.0), "g": (0.0, 1.0, 0.0), "b": (0.0, 0.0, 1.0)}
XYZ = {}
for color in "rgb":
# Calculate XYZ for primaries
XYZ[color] = mtx * rgb[color]
profile = ICCProfile.from_XYZ(
XYZ["r"],
XYZ["g"],
XYZ["b"],
wXYZ,
gamma,
description,
copyright,
manufacturer,
model_name,
manufacturer_id,
model_id,
iccv4,
cat,
profile_class,
)
return profile
@staticmethod
def from_XYZ(
rXYZ,
gXYZ,
bXYZ,
wXYZ,
gamma,
description,
copyright,
manufacturer=None,
model_name=None,
manufacturer_id=b"\0\0",
model_id=b"\0\0",
iccv4=False,
cat="Bradford",
profile_class=b"mntr",
):
"""Create an ICC Profile from XYZ values and return it"""
profile = ICCProfile()
profile.profileClass = profile_class
D50 = colormath.get_whitepoint("D50")
if iccv4:
profile.version = 4.3
elif not s15f16_is_equal(wXYZ, D50) and (
profile.profileClass not in (b"mntr", b"prtr")
or colormath.is_similar_matrix(
colormath.get_cat_matrix(cat), colormath.get_cat_matrix("Bradford")
)
):
profile.version = 2.2 # Match ArgyllCMS
profile.setDescription(description)
profile.setCopyright(copyright)
if manufacturer:
profile.setDeviceManufacturerDescription(manufacturer)
if model_name:
profile.setDeviceModelDescription(model_name)
profile.device["manufacturer"] = (
b"\0\0" + manufacturer_id[1:] + manufacturer_id[:1]
)
profile.device["model"] = b"\0\0" + model_id[1:] + model_id[:1]
# Add Apple-specific 'mmod' tag (TODO: need full spec)
if manufacturer_id != b"\0\0" or model_id != b"\0\0":
mmod = (
b"mmod"
+ (b"\x00" * 6)
+ manufacturer_id
+ (b"\x00" * 2)
+ model_id[1:]
+ model_id[:1]
+ (b"\x00" * 4)
+ (b"\x00" * 20)
)
profile.tags.mmod = ICCProfileTag(mmod, "mmod")
profile.set_wtpt(wXYZ, cat)
profile.tags.chrm = ChromaticityType()
profile.tags.chrm.type = 0
for color in "rgb":
X, Y, Z = locals()[color + "XYZ"]
# Get chromaticity of primary
x, y = colormath.XYZ2xyY(X, Y, Z)[:2]
profile.tags.chrm.channels.append((x, y))
# Write XYZ and TRC tags (don't forget to adapt to D50)
tagname = color + "XYZ"
profile.tags[tagname] = XYZType(profile=profile)
(
profile.tags[tagname].X,
profile.tags[tagname].Y,
profile.tags[tagname].Z,
) = colormath.adapt(X, Y, Z, wXYZ, D50, cat)
tagname = color + "TRC"
profile.tags[tagname] = CurveType(profile=profile)
if isinstance(gamma, (list, tuple)):
profile.tags[tagname].extend(gamma)
else:
profile.tags[tagname].set_trc(gamma, 1)
profile.calculateID()
return profile
def set_wtpt(self, wXYZ, cat="Bradford"):
"""Set whitepoint, 'chad' tag (if >= v2.4 profile or CAT is not Bradford
and wtpt is not D50)
Add ArgyllCMS 'arts' tag
"""
self.tags.wtpt = XYZType(profile=self)
# Compatibility: ArgyllCMS will only read 'chad' if display or
# output profile
if self.profileClass in (b"mntr", b"prtr") and (
self.version >= 2.4
or not colormath.is_similar_matrix(
colormath.get_cat_matrix(cat), colormath.get_cat_matrix("Bradford")
)
):
# Set wtpt to D50 and store actual white -> D50 transform in chad
# if creating ICCv4 profile or CAT is not default Bradford
D50 = colormath.get_whitepoint("D50")
(self.tags.wtpt.X, self.tags.wtpt.Y, self.tags.wtpt.Z) = D50
if not s15f16_is_equal(wXYZ, D50):
# Only create chad if actual white is not D50
self.tags.chad = chromaticAdaptionTag()
matrix = colormath.wp_adaption_matrix(wXYZ, D50, cat)
self.tags.chad.update(matrix)
else:
# Store actual white in wtpt
(self.tags.wtpt.X, self.tags.wtpt.Y, self.tags.wtpt.Z) = wXYZ
self.tags.arts = chromaticAdaptionTag()
self.tags.arts.update(colormath.get_cat_matrix(cat))
def has_trc_tags(self):
"""Return whether the profile has [rgb]TRC tags"""
return False not in [channel + "TRC" in self.tags for channel in "rgb"]
def set_blackpoint(self, XYZbp):
if "chad" not in self.tags:
cat = self.guess_cat() or "Bradford"
XYZbp = colormath.adapt(
*XYZbp, whitepoint_destination=list(self.tags.wtpt.ir.values()), cat=cat
)
self.tags.bkpt = XYZType(tagSignature="bkpt", profile=self)
self.tags.bkpt.X, self.tags.bkpt.Y, self.tags.bkpt.Z = XYZbp
def apply_black_offset(
self,
XYZbp,
power=40.0,
include_A2B=True,
set_blackpoint=True,
logfiles=None,
thread_abort=None,
abortmessage="Aborted",
include_trc=True,
):
# Apply only the black point blending portion of BT.1886 mapping
if include_A2B:
tables = []
for i in range(3):
a2b = self.tags.get("A2B%i" % i)
if isinstance(a2b, LUT16Type) and a2b not in tables:
a2b.apply_black_offset(XYZbp, logfiles, thread_abort, abortmessage)
tables.append(a2b)
if set_blackpoint:
self.set_blackpoint(XYZbp)
if not self.tags.get("rTRC") or not include_trc:
return
rXYZ = list(self.tags.rXYZ.values())
gXYZ = list(self.tags.gXYZ.values())
bXYZ = list(self.tags.bXYZ.values())
mtx = colormath.Matrix3x3(
[
[rXYZ[0], gXYZ[0], bXYZ[0]],
[rXYZ[1], gXYZ[1], bXYZ[1]],
[rXYZ[2], gXYZ[2], bXYZ[2]],
]
)
imtx = mtx.inverted()
for channel in "rgb":
tag = CurveType(profile=self)
if len(self.tags[channel + "TRC"]) == 1:
gamma = self.tags[channel + "TRC"].get_gamma()
tag.set_trc(gamma, 1024)
else:
tag.extend(self.tags[channel + "TRC"])
self.tags[channel + "TRC"] = tag
rgbbp_in = []
for channel in "rgb":
rgbbp_in.append(self.tags["%sTRC" % channel][0] / 65535.0)
bp_in = mtx * rgbbp_in
if tuple(bp_in) == tuple(XYZbp):
return
size = len(self.tags.rTRC)
for i in range(size):
rgb = []
for channel in "rgb":
rgb.append(self.tags["%sTRC" % channel][i] / 65535.0)
X, Y, Z = mtx * rgb
XYZ = colormath.blend_blackpoint(X, Y, Z, bp_in, XYZbp, power=power)
rgb = imtx * XYZ
for j in range(3):
self.tags["%sTRC" % "rgb"[j]][i] = min(max(rgb[j], 0), 1) * 65535
def set_bt1886_trc(
self, XYZbp, outoffset=0.0, gamma=2.4, gamma_type="B", size=None
):
if gamma_type in ("b", "g"):
# Get technical gamma needed to achieve effective gamma
gamma = colormath.xicc_tech_gamma(gamma, XYZbp[1], outoffset)
rXYZ = list(self.tags.rXYZ.values())
gXYZ = list(self.tags.gXYZ.values())
bXYZ = list(self.tags.bXYZ.values())
mtx = colormath.Matrix3x3(
[
[rXYZ[0], gXYZ[0], bXYZ[0]],
[rXYZ[1], gXYZ[1], bXYZ[1]],
[rXYZ[2], gXYZ[2], bXYZ[2]],
]
)
bt1886 = colormath.BT1886(mtx, XYZbp, outoffset, gamma)
values = dict()
for _i, channel in enumerate(("r", "g", "b")):
self.tags[channel + "TRC"] = CurveType(profile=self)
self.tags[channel + "TRC"].set_trc(-709, size)
for j, v in enumerate(self.tags[channel + "TRC"]):
if not values.get(j):
values[j] = []
values[j].append(v / 65535.0)
for i in values:
r, g, b = values[i]
X, Y, Z = mtx * (r, g, b)
values[i] = bt1886.apply(X, Y, Z)
for i in values:
XYZ = values[i]
rgb = mtx.inverted() * XYZ
for j, channel in enumerate(("r", "g", "b")):
self.tags[channel + "TRC"][i] = max(min(rgb[j] * 65535, 65535), 0)
self.set_blackpoint(XYZbp)
def set_dicom_trc(self, XYZbp, white_cdm2=100, size=1024):
"""Set the response to the DICOM Grayscale Standard Display Function
This response is special in that it depends on the actual black
and white level of the display.
XYZbp Black point in absolute XYZ, Y range 0.05..white_cdm2
"""
self.set_trc_tags()
for channel in "rgb":
self.tags["%sTRC" % channel].set_dicom_trc(XYZbp[1], white_cdm2, size)
self.apply_black_offset(
[v / white_cdm2 for v in XYZbp], 40.0 * (white_cdm2 / 40.0)
)
def set_hlg_trc(
self,
XYZbp=(0, 0, 0),
white_cdm2=100,
system_gamma=1.2,
ambient_cdm2=5,
maxsignal=1.0,
size=1024,
blend_blackpoint=True,
):
"""Set the response to the Hybrid Log-Gamma (HLG) function
This response is special in that it depends on the actual black
and white level of the display, system gamma and ambient.
XYZbp Black point in absolute XYZ, Y range 0..white_cdm2
maxsignal Set clipping point (optional)
size Number of steps. Recommended >= 1024
"""
self.set_trc_tags()
for channel in "rgb":
self.tags["%sTRC" % channel].set_hlg_trc(
XYZbp[1], white_cdm2, system_gamma, ambient_cdm2, maxsignal, size
)
if tuple(XYZbp) != (0, 0, 0) and blend_blackpoint:
self.apply_black_offset(
[v / white_cdm2 for v in XYZbp], 40.0 * (white_cdm2 / 100.0)
)
def set_smpte2084_trc(
self,
XYZbp=(0, 0, 0),
white_cdm2=100,
master_black_cdm2=0,
master_white_cdm2=10000,
use_alternate_master_white_clip=True,
rolloff=False,
size=1024,
blend_blackpoint=True,
):
"""Set the response to the SMPTE 2084 perceptual quantizer (PQ) function
This response is special in that it depends on the actual black
and white level of the display.
XYZbp Black point in absolute XYZ, Y range 0..white_cdm2
master_black_cdm2 (Optional) Used to normalize PQ values
master_white_cdm2 (Optional) Used to normalize PQ values
rolloff BT.2390
size Number of steps. Recommended >= 1024
"""
self.set_trc_tags()
for channel in "rgb":
self.tags["%sTRC" % channel].set_smpte2084_trc(
XYZbp[1],
white_cdm2,
master_black_cdm2,
master_white_cdm2,
use_alternate_master_white_clip,
rolloff,
size,
)
if tuple(XYZbp) != (0, 0, 0) and blend_blackpoint:
self.apply_black_offset(
[v / white_cdm2 for v in XYZbp], 40.0 * (white_cdm2 / 100.0)
)
def set_trc_tags(self, identical=False, power=None):
for channel in "rgb":
if identical and channel != "r":
tag = self.tags.rTRC
else:
tag = CurveType(profile=self)
if power:
tag.set_trc(
power, size=1 if not callable(power) and power >= 0 else 1024
)
self.tags["%sTRC" % channel] = tag
def set_localizable_desc(
self, tagname, description, languagecode="en", countrycode="US"
):
# Handle ICCv2 <> v4 differences and encoding
if self.version < 4:
self.tags[tagname] = TextDescriptionType()
if isinstance(description, str):
asciidesc = description.encode("ASCII", "asciize")
else:
asciidesc = description
self.tags[tagname].ASCII = asciidesc
if asciidesc != description:
self.tags[tagname].Unicode = description
else:
self.set_localizable_text(tagname, description, languagecode, countrycode)
def set_localizable_text(self, tagname, text, languagecode="en", countrycode="US"):
# Handle ICCv2 <> v4 differences and encoding
if self.version < 4:
if isinstance(text, str):
text = text.encode("ASCII", "asciize")
self.tags[tagname] = TextType(b"text\0\0\0\0%s\0" % text, tagname)
else:
self.tags[tagname] = MultiLocalizedUnicodeType()
self.tags[tagname].add_localized_string(languagecode, countrycode, text)
def setCopyright(self, copyright, languagecode="en", countrycode="US"):
self.set_localizable_text("cprt", copyright, languagecode, countrycode)
def setDescription(self, description, languagecode="en", countrycode="US"):
self.set_localizable_desc("desc", description, languagecode, countrycode)
def setDeviceManufacturerDescription(
self, description, languagecode="en", countrycode="US"
):
self.set_localizable_desc("dmnd", description, languagecode, countrycode)
def setDeviceModelDescription(
self, description, languagecode="en", countrycode="US"
):
self.set_localizable_desc("dmdd", description, languagecode, countrycode)
def getCopyright(self):
"""Return profile copyright."""
return str(self.tags.get("cprt", ""))
def getDescription(self):
"""Return profile description."""
return str(self.tags.get("desc", ""))
def getDeviceManufacturerDescription(self):
"""Return device manufacturer description."""
return str(self.tags.get("dmnd", ""))
def getDeviceModelDescription(self):
"""Return device model description."""
return str(self.tags.get("dmdd", ""))
def getViewingConditionsDescription(self):
"""Return viewing conditions description."""
return str(self.tags.get("vued", ""))
def guess_cat(self, matrix=True):
"""Get or guess chromatic adaptation transform.
If 'matrix' is True, and 'arts' tag is present, return actual matrix
instead of name if no match to known matrices.
"""
illuminant = list(self.illuminant.values())
if isinstance(self.tags.get("chad"), chromaticAdaptionTag):
return colormath.guess_cat(
self.tags.chad, self.tags.chad.inverted() * illuminant, illuminant
)
elif isinstance(self.tags.get("arts"), chromaticAdaptionTag):
return self.tags.arts.get_cat() or (matrix and self.tags.arts)
def isSame(self, profile, force_calculation=False):
"""Compare the ID of profiles.
Returns a boolean indicating if the profiles have the same ID.
profile can be a ICCProfile instance, a binary string
containing profile data, a filename or a file object.
"""
if not isinstance(profile, self.__class__):
profile = self.__class__(profile)
if force_calculation or self.ID == b"\0" * 16:
id1 = self.calculateID(False)
else:
id1 = self.ID
if force_calculation or profile.ID == b"\0" * 16:
id2 = profile.calculateID(False)
else:
id2 = profile.ID
return id1 == id2
def load(self):
"""Loads the profile from the file object.
Normally, you don't need to call this method, since the ICCProfile
class automatically loads the profile when necessary (load does
nothing if the profile was passed in as a binary string).
"""
if not self.is_loaded and self._file:
if self._file.closed:
self._file = open(self._file.name, "rb")
self._file.seek(len(self._data))
self._data += self._file.read(self.size - len(self._data))
self._file.close()
self.is_loaded = True
def print_info(self):
print("=" * 80)
print("ICC profile information")
print("-" * 80)
print("File name:", os.path.basename(self.fileName or ""))
for label, value in self.get_info():
if not value:
print(label)
else:
print(label + ":", value)
@staticmethod
def add_device_info(info, device, level=1):
"""Add a device structure (see profile header) to info dict"""
indent = " " * 4 * level
info[indent + "Manufacturer"] = (
"0x%s" % binascii.hexlify(device.get("manufacturer", b"")).upper().decode()
)
if (
len(device.get("manufacturer", b"")) == 4
and device["manufacturer"][0:2] == b"\0\0"
and device["manufacturer"][2:4] != b"\0\0"
):
mnft_id = device["manufacturer"][3:4] + device["manufacturer"][2:3]
mnft_id = edid.parse_manufacturer_id(mnft_id)
manufacturer = edid.get_manufacturer_name(mnft_id) # this is str
else:
manufacturer = (
re.sub(b"[^\x20-\x7e]", b"", device.get("manufacturer", b""))
).decode()
if manufacturer != device.get("manufacturer"):
manufacturer = None
else:
manufacturer = "'%s'" % manufacturer.decode()
if manufacturer is not None:
info[indent + "Manufacturer"] += " %s" % manufacturer
info[indent + "Model"] = hexrepr(device.get("model", ""))
attributes = device.get("attributes", {})
info[indent + "Media attributes"] = ", ".join(
[
{True: "Reflective"}.get(attributes.get("reflective"), "Transparency"),
{True: "Glossy"}.get(attributes.get("glossy"), "Matte"),
{True: "Positive"}.get(attributes.get("positive"), "Negative"),
{True: "Color"}.get(attributes.get("color"), "Black & white"),
]
)
def get_info(self):
info = DictList()
info["Size"] = "%i Bytes (%.2f KiB)" % (self.size, self.size / 1024.0)
info["Preferred CMM"] = hexrepr(self.preferredCMM, cmms)
info["ICC version"] = "%s" % self.version
info["Profile class"] = profileclass.get(self.profileClass, self.profileClass)
info["Color model"] = self.colorSpace.decode()
info["Profile connection space (PCS)"] = self.connectionColorSpace.decode()
info["Created"] = strftime("%Y-%m-%d %H:%M:%S", self.dateTime.timetuple())
info["Platform"] = platform.get(self.platform, hexrepr(self.platform))
info["Is embedded"] = {True: "Yes"}.get(self.embedded, "No")
info["Can be used independently"] = {True: "Yes"}.get(self.independent, "No")
info["Device"] = ""
ICCProfile.add_device_info(info, self.device)
info["Default rendering intent"] = {
0: "Perceptual",
1: "Media-relative colorimetric",
2: "Saturation",
3: "ICC-absolute colorimetric",
}.get(self.intent, "Unknown")
info["PCS illuminant XYZ"] = " ".join(
[
" ".join(["%6.2f" % (v * 100) for v in list(self.illuminant.values())]),
"(xy %s," % " ".join("%6.4f" % v for v in self.illuminant.xyY[:2]),
"CCT %iK)" % (colormath.XYZ2CCT(*list(self.illuminant.values())) or 0),
]
)
info["Creator"] = hexrepr(self.creator, manufacturers)
info["Checksum"] = "0x%s" % binascii.hexlify(self.ID).upper().decode()
calculated_id = self.calculateID(False)
if self.ID != b"\0" * 16:
info[" Checksum OK"] = {True: "Yes"}.get(self.ID == calculated_id, "No")
if self.ID != calculated_id:
info[" Calculated checksum"] = (
"0x%s" % binascii.hexlify(calculated_id).upper().decode()
)
for sig in self.tags:
tag = self.tags[sig]
name = tags.get(sig, "'%s'" % sig)
if isinstance(tag, chromaticAdaptionTag):
info[name] = self.guess_cat(False) or "Unknown"
name = " Matrix"
for i, row in enumerate(tag):
if i > 0:
name = " " * 2
info[name] = " ".join("%6.4f" % v for v in row)
elif isinstance(tag, ChromaticityType):
info["Chromaticity (illuminant-relative)"] = ""
for i, channel in enumerate(tag.channels):
if self.colorSpace.endswith(b"CLR"):
colorant_name = ""
else:
colorant_name = "(%s) " % (self.colorSpace[i : i + 1]).decode(
"utf-8"
)
info[" Channel %i %sxy" % (i + 1, colorant_name)] = " ".join(
"%6.4f" % v for v in channel
)
elif isinstance(tag, ColorantTableType):
info["Colorants (PCS-relative)"] = ""
for colorant_name in tag:
colorant = tag[colorant_name]
values = list(colorant.values())
if "".join(list(colorant.keys())) == "Lab":
values = colormath.Lab2XYZ(*values)
else:
values = [v / 100.0 for v in values]
XYZxy = [" ".join("%6.2f" % v for v in list(colorant.values()))]
if values != [0, 0, 0]:
XYZxy.append(
"(xy %s)"
% " ".join(
"%6.4f" % v for v in colormath.XYZ2xyY(*values)[:2]
)
)
colorant_name = colorant_name.decode()
info[
" %s %s" % (colorant_name, "".join(list(colorant.keys())))
] = " ".join(XYZxy)
elif isinstance(tag, ParametricCurveType):
params = "".join(sorted(tag.params.keys()))
tag_params = dict(list(tag.params.items()))
for key in tag_params:
value = tag_params[key]
if key == "g":
fmt = "%3.2f"
else:
fmt = "%.6f"
value = (fmt % value).rstrip("0").rstrip(".")
if key == "g" and "." not in value:
value += ".0"
tag_params[key] = value
tag_params["E"] = sig[0].upper()
if params == "g":
info[name] = "Gamma %(g)s" % tag_params
else:
info[name] = ""
if params == "abg":
info[" if (%(E)s >= - %(b)s / %(a)s):" % tag_params] = (
"Y = pow(%(a)s * %(E)s + %(b)s, %(g)s)" % tag_params
)
info[" if (%(E)s < - %(b)s / %(a)s):" % tag_params] = "Y = 0"
elif params == "abcg":
info[" if (%(E)s >= - %(b)s / %(a)s):" % tag_params] = (
"Y = pow(%(a)s * %(E)s + %(b)s, %(g)s) + %(c)s" % tag_params
)
info[" if (%(E)s < - %(b)s / %(a)s):" % tag_params] = (
"Y = %(c)s" % tag_params
)
elif params == "abcdg":
info[" if (%(E)s >= %(d)s):" % tag_params] = (
"Y = pow(%(a)s * %(E)s + %(b)s, %(g)s)" % tag_params
)
info[" if (%(E)s < %(d)s):" % tag_params] = (
"Y = %(c)s * %(E)s" % tag_params
)
elif params == "abcdefg":
info[" if (%(E)s >= %(d)s):" % tag_params] = (
"Y = pow(%(a)s * %(E)s + %(b)s, %(g)s) + %(e)s" % tag_params
)
info[" if (%(E)s < %(d)s):" % tag_params] = (
"Y = %(c)s * %(E)s + %(f)s" % tag_params
)
if params != "g":
tag = tag.get_trc()
# info[" Average gamma"] = "%3.2f" % tag.get_gamma()
transfer_function = tag.get_transfer_function(
slice=(0, 1.0), outoffset=1.0
)
if round(transfer_function[1], 2) == 1.0:
value = "%s" % (transfer_function[0][0])
else:
if transfer_function[1] >= 0.95:
value = "≈ %s (Δ %.2f%%)" % (
transfer_function[0][0],
100 - transfer_function[1] * 100,
)
else:
value = "Unknown"
info[" Transfer function"] = value
elif isinstance(tag, CurveType):
if len(tag) == 1:
value = ("%3.2f" % tag[0]).rstrip("0").rstrip(".")
if "." not in value:
value += ".0"
info[name] = "Gamma %s" % value
elif len(tag):
info[name] = ""
info[" Number of entries"] = "%i" % len(tag)
# info[" Average gamma"] = "%3.2f" % tag.get_gamma()
transfer_function = tag.get_transfer_function(
slice=(0, 1.0), outoffset=1.0
)
if round(transfer_function[1], 2) == 1.0:
value = "%s" % (transfer_function[0][0])
else:
if transfer_function[1] >= 0.95:
value = "≈ %s (Δ %.2f%%)" % (
transfer_function[0][0],
100 - transfer_function[1] * 100,
)
else:
value = "Unknown"
info[" Transfer function"] = value
info[" Minimum Y"] = "%6.4f" % (tag[0] / 65535.0 * 100)
info[" Maximum Y"] = "%6.2f" % (tag[-1] / 65535.0 * 100)
elif isinstance(tag, DictType):
if sig == "meta":
name = "Metadata"
else:
name = "Generic name-value data"
info[name] = ""
for key in tag:
record = tag.get(key)
value = record.get("value")
if value and key == "prefix":
value = "\n".join(value.split(","))
info[" %s" % key] = value
elements = dict()
for subkey in ("display_name", "display_value"):
entry = record.get(subkey)
if isinstance(entry, MultiLocalizedUnicodeType):
for language in entry:
countries = entry[language]
for country in countries:
value = countries[country]
if country.strip("\0 "):
country = "/" + country
loc = "%s%s" % (language, country)
if loc not in elements:
elements[loc] = dict()
elements[loc][subkey] = value
for loc in elements:
items = elements[loc]
if len(items) > 1:
value = "%s = %s" % tuple(items.values())
elif "display_name" in items:
value = "%s" % items["display_name"]
else:
value = " = %s" % items["display_value"]
info[" %s" % loc] = value
elif isinstance(tag, LUT16Type):
info[name] = ""
name = " Matrix"
for i, row in enumerate(tag.matrix):
if i > 0:
name = " " * 2
info[name] = " ".join("%6.4f" % v for v in row)
info[" Input Table"] = ""
info[" Channels"] = "%i" % tag.input_channels_count
info[" Number of entries per channel"] = (
"%i" % tag.input_entries_count
)
info[" Color Look Up Table"] = ""
info[" Grid Steps"] = "%i" % tag.clut_grid_steps
info[" Entries"] = "%i" % (
tag.clut_grid_steps**tag.input_channels_count
)
info[" Output Table"] = ""
info[" Channels"] = "%i" % tag.output_channels_count
info[" Number of entries per channel"] = (
"%i" % tag.output_entries_count
)
elif isinstance(tag, MakeAndModelType):
info[name] = ""
manufacturer_code = tag.manufacturer
manufacturer_name = edid.get_manufacturer_name(
edid.parse_manufacturer_id(manufacturer_code.ljust(2, b"\0")[:2])
)
info[" Manufacturer"] = "0x%s %s" % (
binascii.hexlify(manufacturer_code).decode("utf-8").upper(),
manufacturer_name or "",
)
info[" Model"] = (
"0x%s" % binascii.hexlify(tag.model).decode("utf-8").upper()
)
elif isinstance(tag, MeasurementType):
info[name] = ""
info[" Observer"] = tag.observer.description
info[" Backing XYZ"] = " ".join(
"%6.2f" % v for v in list(tag.backing.values())
)
info[" Geometry"] = tag.geometry.description
info[" Flare"] = "%.2f%%" % (tag.flare * 100)
info[" Illuminant"] = tag.illuminantType.description
elif isinstance(tag, MultiLocalizedUnicodeType):
info[name] = ""
for language in tag:
countries = tag[language]
for country in countries:
value = countries[country]
country = country.decode()
if country.strip("\0 "):
country = "/" + country
language = language.decode()
info[" %s%s" % (language, country)] = value
elif isinstance(tag, NamedColor2Type):
info[name] = ""
info[" Device color components"] = "%i" % (tag.deviceCoordCount,)
info[" Colors (PCS-relative)"] = "%i (%i Bytes) " % (
tag.colorCount,
len(tag.tagData),
)
i = 1
for k in tag:
v = tag[k]
pcsout = []
devout = []
for _kk in v.pcs:
vv = v.pcs[_kk]
pcsout.append("%03.2f" % vv)
for vv in v.device:
devout.append("%03.2f" % vv)
formatstr = " %%0%is %%s%%s%%s" % len(str(tag.colorCount))
key = formatstr % (i, tag.prefix, k, tag.suffix)
info[key] = "%s %s" % (
"".join(list(v.pcs.keys())),
" ".join(pcsout),
)
if self.colorSpace != self.connectionColorSpace or " ".join(
pcsout
) != " ".join(devout):
info[key] += " (%s %s)" % (self.colorSpace, " ".join(devout))
i += 1
elif isinstance(tag, ProfileSequenceDescType):
info[name] = ""
for i, desc in enumerate(tag):
info[" " * 4 + "%i" % (i + 1)] = ""
ICCProfile.add_device_info(info, desc, 2)
for desc_type in ("dmnd", "dmdd"):
description = str(desc[desc_type])
if description:
info[" " * 8 + tags[desc_type]] = description
elif isinstance(tag, Text):
if sig == "cprt":
info[name] = str(tag)
elif sig == "ciis":
info[name] = ciis.get(tag, "'%s'" % tag)
elif sig == "tech":
info[name] = tech.get(tag, "'%s'" % tag)
elif tag.find(b"\n") > -1 or tag.find(b"\r") > -1:
info[name] = "[%i Bytes]" % len(tag)
else:
info[name] = tag[: 60 - len(name)] + (
b"...[%i more Bytes]" % (len(tag) - (60 - len(name)))
if len(tag) > 60 - len(name)
else b""
)
elif isinstance(tag, TextDescriptionType):
if not tag.get("Unicode") and not tag.get("Macintosh"):
info["%s (ASCII)" % name] = tag.ASCII.decode("utf-8")
else:
info[name] = ""
info[" ASCII"] = tag.ASCII.decode("utf-8")
if tag.get("Unicode"):
info[" Unicode"] = tag.Unicode
if tag.get("Macintosh"):
info[" Macintosh"] = tag.Macintosh
elif isinstance(tag, VideoCardGammaFormulaType):
info[name] = ""
# linear = tag.is_linear()
# info[" Is linear"] = {0: "No", 1: "Yes"}[linear]
for key in ("red", "green", "blue"):
info[" %s gamma" % key.capitalize()] = (
"%.2f" % tag[key + "Gamma"]
)
info[" %s minimum" % key.capitalize()] = (
"%.2f" % tag[key + "Min"]
)
info[" %s maximum" % key.capitalize()] = (
"%.2f" % tag[key + "Max"]
)
elif isinstance(tag, VideoCardGammaTableType):
info[name] = ""
info[" Bitdepth"] = "%i" % (tag.entrySize * 8)
info[" Channels"] = "%i" % tag.channels
info[" Number of entries per channel"] = "%i" % tag.entryCount
r_points, g_points, b_points, linear_points = tag.get_values()
points = r_points, g_points, b_points
# if r_points == g_points == b_points == linear_points:
# info[" Is linear" % i] = {True: "Yes"}.get(points[i] == linear_points, "No")
# else:
if True:
unique = tag.get_unique_values()
for i, channel in enumerate(tag.data):
scale = math.pow(2, tag.entrySize * 8) - 1
vmin = 0
vmax = scale
gamma = colormath.get_gamma(
[
(
(len(channel) / 2 - 1)
/ (len(channel) - 1.0)
* scale,
channel[int(len(channel) / 2 - 1)],
)
],
scale,
vmin,
vmax,
False,
False,
)
if gamma:
info[" Channel %i gamma at 50%% input" % (i + 1)] = (
"%.2f" % gamma[0]
)
vmin = channel[0]
vmax = channel[-1]
info[" Channel %i minimum" % (i + 1)] = "%6.4f%%" % (
vmin / scale * 100
)
info[" Channel %i maximum" % (i + 1)] = "%6.2f%%" % (
vmax / scale * 100
)
info[
" Channel %i unique values" % (i + 1)
] = "%i @ 8 Bit" % len(unique[i])
info[" Channel %i is linear" % (i + 1)] = {True: "Yes"}.get(
points[i] == linear_points, "No"
)
elif isinstance(tag, ViewingConditionsType):
info[name] = ""
info[" Illuminant"] = tag.illuminantType.description
info[" Illuminant XYZ"] = "%s (xy %s)" % (
" ".join("%6.2f" % v for v in list(tag.illuminant.values())),
" ".join("%6.4f" % v for v in tag.illuminant.xyY[:2]),
)
XYZxy = [" ".join("%6.2f" % v for v in list(tag.surround.values()))]
if list(tag.surround.values()) != [0, 0, 0]:
XYZxy.append(
"(xy %s)" % " ".join("%6.4f" % v for v in tag.surround.xyY[:2])
)
info[" Surround XYZ"] = " ".join(XYZxy)
elif isinstance(tag, XYZType):
if sig == "lumi":
info[name] = "%.2f cd/m²" % self.tags.lumi.Y
elif sig in ("bkpt", "wtpt"):
format = {"bkpt": "%6.4f", "wtpt": "%6.2f"}[sig]
info[name] = ""
if self.profileClass == b"mntr" and sig == b"wtpt":
info[" Is illuminant"] = "Yes"
if self.profileClass != b"prtr":
label = "Illuminant-relative"
else:
label = "PCS-relative"
# if self.connectionColorSpace == "Lab" and self.profileClass == "prtr":
if self.profileClass == b"prtr":
color = [" ".join([format % v for v in tag.ir.Lab])]
info[" %s Lab" % label] = " ".join(color)
else:
color = [
" ".join(format % (v * 100) for v in list(tag.ir.values()))
]
if list(tag.ir.values()) != [0, 0, 0]:
xy = " ".join("%6.4f" % v for v in tag.ir.xyY[:2])
color.append("(xy %s)" % xy)
cct, delta = colormath.xy_CCT_delta(*tag.ir.xyY[:2])
else:
cct = None
info[" %s XYZ" % label] = " ".join(color)
if cct:
info[" %s CCT" % label] = "%iK" % cct
if delta:
info[" ΔE 2000 to daylight locus"] = (
"%.2f" % delta["E"]
)
kwargs = {"daylight": False}
cct, delta = colormath.xy_CCT_delta(
*tag.ir.xyY[:2], **kwargs
)
if delta:
info[" ΔE 2000 to blackbody locus"] = (
"%.2f" % delta["E"]
)
if "chad" in self.tags:
color = [
" ".join(format % (v * 100) for v in list(tag.pcs.values()))
]
if list(tag.pcs.values()) != [0, 0, 0]:
xy = " ".join("%6.4f" % v for v in tag.pcs.xyY[:2])
color.append("(xy %s)" % xy)
info[" PCS-relative XYZ"] = " ".join(color)
cct, delta = colormath.xy_CCT_delta(*tag.pcs.xyY[:2])
if cct:
info[" PCS-relative CCT"] = "%iK" % cct
# if delta:
# info[u" ΔE 2000 to daylight locus"] = "%.2f" % delta["E"]
# kwargs = {"daylight": False}
# cct, delta = colormath.xy_CCT_delta(*tag.pcs.xyY[:2], **kwargs)
# if delta:
# info[u" ΔE 2000 to blackbody locus"] = "%.2f" % delta["E"]
else:
info[name] = ""
info[" Illuminant-relative XYZ"] = " ".join(
[
" ".join(
"%6.2f" % (v * 100) for v in list(tag.ir.values())
),
"(xy %s)" % " ".join("%6.4f" % v for v in tag.ir.xyY[:2]),
]
)
info[" PCS-relative XYZ"] = " ".join(
[
" ".join("%6.2f" % (v * 100) for v in list(tag.values())),
"(xy %s)" % " ".join("%6.4f" % v for v in tag.xyY[:2]),
]
)
elif isinstance(tag, ICCProfileTag):
info[name] = "'%s' [%i Bytes]" % (
tag.tagData[:4].decode(),
len(tag.tagData),
)
return info
def get_rgb_space(self, relation="ir", gamma=None):
tags = self.tags
if "wtpt" not in tags:
return False
rgb_space = [gamma or [], list(getattr(tags.wtpt, relation).values())]
for component in ("r", "g", "b"):
if not "%sXYZ" % component in tags or (
not gamma
and (
not "%sTRC" % component in tags
or not isinstance(tags["%sTRC" % component], CurveType)
)
):
return False
rgb_space.append(getattr(tags["%sXYZ" % component], relation).xyY)
if not gamma:
if len(tags["%sTRC" % component]) > 1:
rgb_space[0].append(
[v / 65535.0 for v in tags["%sTRC" % component]]
)
else:
rgb_space[0].append(tags["%sTRC" % component][0])
return rgb_space
def get_chardata_bkpt(self, illuminant_relative=False):
"""Get blackpoint from embeded characterization data ('targ' tag)"""
if isinstance(self.tags.get("targ"), Text):
from DisplayCAL import CGATS
ti3 = CGATS.CGATS(self.tags.targ)
if 0 in ti3:
black = ti3[0].queryi({"RGB_R": 0, "RGB_G": 0, "RGB_B": 0})
# May be several samples for black. Average them.
if black:
XYZbp = [0, 0, 0]
for sample in black.values():
for i, component in enumerate("XYZ"):
if "XYZ_" + component in sample:
XYZbp[i] += sample["XYZ_" + component] / 100.0
for i in range(3):
XYZbp[i] /= len(black)
if not illuminant_relative:
# Adapt to D50
white = ti3.get_white_cie()
if white:
XYZwp = [
v / 100.0
for v in (
white["XYZ_X"],
white["XYZ_Y"],
white["XYZ_Z"],
)
]
else:
XYZwp = list(self.tags.wtpt.ir.values())
cat = self.guess_cat() or "Bradford"
XYZbp = colormath.adapt(
*XYZbp, whitepoint_source=XYZwp, cat=cat
)
return XYZbp
def optimize(self, return_bytes_saved=False, update_ID=True):
"""Optimize the tag data so that shared tags are only recorded once.
Return whether or not optimization was performed (not necessarily
indicative of a reduction in profile size).
If return_bytes_saved is True, return number of bytes saved instead
(this sets the 'size' property of the profile to the new size).
If update_ID is True, a non-NULL profile ID will also be updated.
Note that for profiles created by ICCProfile (and not read from disk),
this will always be superfluous because they are optimized by default.
"""
numoffsets = len(self._tagoffsets)
offsets = [
(-(numoffsets - i), tag_sig)
for i, (offset, tag_sig) in enumerate(sorted(self._tagoffsets))
]
if self._tagoffsets != offsets:
if return_bytes_saved:
oldsize = len(self.data)
# Discard original offsets
self._tagoffsets = offsets
if update_ID and self.ID != b"\0" * 16:
self.calculateID()
else:
# No longer reflects original profile
self._delfromcache()
if return_bytes_saved:
self.size = len(self.data)
return oldsize - self.size
return True
return 0 if return_bytes_saved else False
def read(self, profile):
"""Read profile from binary string, filename or file object.
Same as self.__init__(profile)
"""
self.__init__(profile)
def set_edid_metadata(self, edid):
"""Sets metadata from EDID
Key names follow the ICC meta Tag for Monitor Profiles specification
http://www.oyranos.org/wiki/index.php?title=ICC_meta_Tag_for_Monitor_Profiles_0.1
and the GNOME Color Manager metadata specification
http://gitorious.org/colord/master/blobs/master/doc/metadata-spec.txt
"""
if "meta" not in self.tags:
self.tags.meta = DictType()
spec_prefixes = "EDID_"
prefixes = (
self.tags.meta.getvalue("prefix", b"", None) or spec_prefixes
).split(",")
for prefix in spec_prefixes.split(","):
if prefix not in prefixes:
prefixes.append(prefix)
# OpenICC keys (some shared with GCM)
self.tags.meta.update(
(
("prefix", ",".join(prefixes)),
("EDID_mnft", edid["manufacturer_id"]),
("EDID_mnft_id", struct.unpack(">H", edid["edid"][8:10])[0]),
("EDID_model_id", edid["product_id"]),
(
"EDID_date",
"%0.4i-T%i"
% (edid["year_of_manufacture"], edid["week_of_manufacture"]),
),
("EDID_red_x", edid["red_x"]),
("EDID_red_y", edid["red_y"]),
("EDID_green_x", edid["green_x"]),
("EDID_green_y", edid["green_y"]),
("EDID_blue_x", edid["blue_x"]),
("EDID_blue_y", edid["blue_y"]),
("EDID_white_x", edid["white_x"]),
("EDID_white_y", edid["white_y"]),
)
)
manufacturer = edid.get("manufacturer")
if manufacturer:
self.tags.meta["EDID_manufacturer"] = manufacturer
if "gamma" in edid:
self.tags.meta["EDID_gamma"] = edid["gamma"]
monitor_name = edid.get("monitor_name", edid.get("ascii"))
if monitor_name:
self.tags.meta["EDID_model"] = monitor_name
if edid.get("serial_ascii"):
self.tags.meta["EDID_serial"] = edid["serial_ascii"]
elif edid.get("serial_32"):
# don't try to convert the following ``str`` to ``bytes``.
# the edid["serial_32"] is a huge number and bytes({int}) is not working
# like str({int}). What it tries is to create a b"\0" * {int}.
self.tags.meta["EDID_serial"] = str(edid["serial_32"])
# Gnome Color Management keys
self.tags.meta["EDID_md5"] = edid["hash"]
def set_gamut_metadata(self, gamut_volume=None, gamut_coverage=None):
"""Sets gamut volume and coverage metadata keys"""
if gamut_volume or gamut_coverage:
if "meta" not in self.tags:
self.tags.meta = DictType()
# Update meta prefix
prefixes = (self.tags.meta.getvalue("prefix", b"", None) or "GAMUT_").split(
","
)
if "GAMUT_" not in prefixes:
prefixes.append("GAMUT_")
self.tags.meta["prefix"] = (",".join(prefixes)).encode()
if gamut_volume:
# Set gamut size
self.tags.meta["GAMUT_volume"] = gamut_volume
if gamut_coverage:
# Set gamut coverage
for key in gamut_coverage:
factor = gamut_coverage[key]
self.tags.meta["GAMUT_coverage(%s)" % key] = factor
def write(self, stream_or_filename=None):
"""Write profile to stream.
This will re-assemble the various profile parts (header,
tag table and data) on-the-fly.
"""
if not stream_or_filename:
if self._file:
if not self._file.closed:
self.close()
stream_or_filename = self.fileName
if isinstance(stream_or_filename, str):
stream = open(stream_or_filename, "wb")
if not self.fileName:
self.fileName = stream_or_filename
else:
stream = stream_or_filename
stream.write(self.data)
if isinstance(stream_or_filename, str):
stream.close()
def __getattribute__(self, name):
if name == "write" or name.startswith("set") or name.startswith("apply"):
# No longer reflects original profile
self._delfromcache()
return object.__getattribute__(self, name)
def _delfromcache(self):
# Make double sure to remove ourselves from the cache
if self._key and self._key in _iccprofilecache:
try:
del _iccprofilecache[self._key]
except KeyError:
# GC was faster
pass
displaycal-py3-3.9.11/DisplayCAL/RealDisplaySizeMM.c 0000664 0000000 0000000 00000150034 14437413106 0022040 0 ustar 00root root 0000000 0000000 #include "Python.h"
#include "bytesobject.h"
#include
#include
#include
#include
#include
#include
#include
#ifdef NT
# include
# include
#else
# include
# include
# include
#endif
#ifdef __APPLE__ /* Assume OSX Carbon */
# include
# include
# include
#endif /* __APPLE__ */
#if defined(UNIX) && !defined(__APPLE__)
# include
# include
# include
# include
# include
# include
# include
# include
# include
#endif /* UNIX */
#if defined(_MSC_VER)
# define DLL extern "C" __declspec(dllexport)
#else
# define DLL
#endif
#define errout stderr
#ifdef DEBUG
# define debug(xx) fprintf(errout, xx )
# define debug2(xx) fprintf xx
# define debugr(xx) fprintf(errout, xx )
# define debugr2(xx) fprintf xx
# define debugrr(xx) fprintf(errout, xx )
# define debugrr2(xx) fprintf xx
#else
# define debug(xx)
# define debug2(xx)
# define debugr(xx)
# define debugr2(xx)
# define debugrr(xx)
# define debugrr2(xx)
#endif
#if PY_MAJOR_VERSION >= 3
#define IS_PY3K
#define PyBaseString_Type PyBytes_Type
#define PyStringObject PyBytesObject
#define PyString_Type PyBytes_Type
#define PyString_Check PyBytes_Check
#define PyString_CheckExact PyBytes_CheckExact
#define PyString_FromString PyBytes_FromString
#define PyString_FromStringAndSize PyBytes_FromStringAndSize
#endif
// START disppath
/* Structure to store information about possible displays */
typedef struct {
char *name; /* Display name */
char *description; /* Description of display or URL */
int sx,sy; /* Displays offset in pixels */
int sw,sh; /* Displays width and height in pixels*/
#ifdef NT
char monid[128]; /* Monitor ID */
int prim; /* NZ if primary display monitor */
#endif /* NT */
#ifdef __APPLE__
CGDirectDisplayID ddid;
#endif /* __APPLE__ */
#if defined(UNIX) && !defined(__APPLE__)
int screen; /* X11 (possibly virtual) Screen */
int uscreen; /* Underlying Xinerma/XRandr screen */
int rscreen; /* Underlying RAMDAC screen (user override) */
Atom icc_atom; /* ICC profile root/output atom for this display */
unsigned char *edid; /* 128, 256, or 384 bytes of monitor EDID, NULL if none */
int edid_len; /* 128, 256, or 384 */
#if RANDR_MAJOR == 1 && RANDR_MINOR >= 2
/* Xrandr stuff - output is connected 1:1 to a display */
RRCrtc crtc; /* Associated crtc */
RROutput output; /* Associated output */
Atom icc_out_atom; /* ICC profile atom for this output */
#endif /* randr >= V 1.2 */
#endif /* UNIX */
} disppath;
// END disppath
void free_a_disppath(disppath *path);
void free_disppaths(disppath **paths);
/* ===================================================================== */
/* Display enumeration code */
/* ===================================================================== */
int callback_ddebug = 0; /* Diagnostic global for get_displays() and get_a_display() */
/* and events */
#ifdef NT
#define sleep(secs) Sleep((secs) * 1000)
static BOOL CALLBACK MonitorEnumProc(
HMONITOR hMonitor, /* handle to display monitor */
HDC hdcMonitor, /* NULL, because EnumDisplayMonitors hdc is NULL */
LPRECT lprcMonitor, /* Virtual screen coordinates of this monitor */
LPARAM dwData /* Context data */
) {
disppath ***pdisps = (disppath ***)dwData;
disppath **disps = *pdisps;
MONITORINFOEX pmi;
int ndisps = 0;
debugrr2((errout, "MonitorEnumProc() called with hMonitor = 0x%x\n",hMonitor));
/* Get some more information */
pmi.cbSize = sizeof(MONITORINFOEX);
if (GetMonitorInfo(hMonitor, (MONITORINFO *)&pmi) == 0) {
debugrr("get_displays failed GetMonitorInfo - ignoring display\n");
return TRUE;
}
/* See if it seems to be a pseudo-display */
if (strncmp(pmi.szDevice, "\\\\.\\DISPLAYV", 12) == 0) {
debugrr("Seems to be invisible pseudo-display - ignoring it\n");
return TRUE;
}
/* Add the display to the list */
if (disps == NULL) {
if ((disps = (disppath **)calloc(sizeof(disppath *), 1 + 1)) == NULL) {
debugrr("get_displays failed on malloc\n");
return FALSE;
}
} else {
/* Count current number on list */
for (ndisps = 0; disps[ndisps] != NULL; ndisps++)
;
if ((disps = (disppath **)realloc(disps,
sizeof(disppath *) * (ndisps + 2))) == NULL) {
debugrr("get_displays failed on malloc\n");
return FALSE;
}
disps[ndisps+1] = NULL; /* End marker */
}
if ((disps[ndisps] = calloc(sizeof(disppath),1)) == NULL) {
debugrr("get_displays failed on malloc\n");
return FALSE;
}
if ((disps[ndisps]->name = strdup(pmi.szDevice)) == NULL) {
debugrr("malloc failed\n");
return FALSE;
}
disps[ndisps]->prim = (pmi.dwFlags & MONITORINFOF_PRIMARY) ? 1 : 0;
disps[ndisps]->sx = lprcMonitor->left;
disps[ndisps]->sy = lprcMonitor->top;
disps[ndisps]->sw = lprcMonitor->right - lprcMonitor->left;
disps[ndisps]->sh = lprcMonitor->bottom - lprcMonitor->top;
disps[ndisps]->description = NULL;
debugrr2((errout, "MonitorEnumProc() set initial monitor info: %d,%d %d,%d name '%s'\n",disps[ndisps]->sx,disps[ndisps]->sy,disps[ndisps]->sw,disps[ndisps]->sh, disps[ndisps]->name));
*pdisps = disps;
return TRUE;
}
/* Dynamically linked function support */
BOOL (WINAPI* pEnumDisplayDevices)(PVOID,DWORD,PVOID,DWORD) = NULL;
/* See if we can get the wanted function calls */
/* return nz if OK */
static int setup_dyn_calls() {
static int dyn_inited = 0;
if (dyn_inited == 0) {
dyn_inited = 1;
/* EnumDisplayDevicesA was left out of lib32.lib on earlier SDK's ... */
pEnumDisplayDevices = (BOOL (WINAPI*)(PVOID,DWORD,PVOID,DWORD)) GetProcAddress(LoadLibrary("USER32"), "EnumDisplayDevicesA");
if (pEnumDisplayDevices == NULL)
dyn_inited = 0;
}
return dyn_inited;
}
/* Simple up conversion from char string to wchar string */
/* Return NULL if malloc fails */
/* ~~~ Note, should probably replace this with mbstowcs() ???? */
static unsigned short *char2wchar(char *s) {
unsigned char *cp;
unsigned short *w, *wp;
if ((w = malloc(sizeof(unsigned short) * (strlen(s) + 1))) == NULL)
return w;
for (cp = (unsigned char *)s, wp = w; ; cp++, wp++) {
*wp = *cp; /* Zero extend */
if (*cp == 0)
break;
}
return w;
}
#endif /* NT */
#if defined(UNIX) && !defined(__APPLE__)
/* Hack to notice if the error handler has been triggered */
/* when a function doesn't return a value. */
int g_error_handler_triggered = 0;
/* A noop X11 error handler */
int null_error_handler(Display *disp, XErrorEvent *ev) {
g_error_handler_triggered = 1;
return 0;
}
#endif /* X11 */
/* Return pointer to list of disppath. Last will be NULL. */
/* Return NULL on failure. Call free_disppaths() to free up allocation */
disppath **get_displays() {
disppath **disps = NULL;
#ifdef NT
DISPLAY_DEVICE dd;
char buf[200];
int i, j;
if (setup_dyn_calls() == 0) {
debugrr("Dynamic linking to EnumDisplayDevices or Vista AssociateColorProfile failed\n");
free_disppaths(disps);
return NULL;
}
/* Create an initial list of monitors */
/* (It might be better to call pEnumDisplayDevices(NULL, i ..) instead ??, */
/* then we can use the StateFlags to distingish monitors not attached to the desktop etc.) */
if (EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM)&disps) == 0) {
debugrr("EnumDisplayMonitors failed\n");
free_disppaths(disps);
return NULL;
}
/* Now locate detailed information about displays */
for (i = 0; ; i++) {
if (disps == NULL || disps[i] == NULL)
break;
dd.cb = sizeof(dd);
debugrr2((errout, "get_displays about to get monitor information for %d\n",i));
/* Get monitor information */
for (j = 0; ;j++) {
if ((*pEnumDisplayDevices)(disps[i]->name, j, &dd, 0) == 0) {
debugrr2((errout,"EnumDisplayDevices failed on '%s' Mon = %d\n",disps[i]->name,j));
if (j == 0) {
strcpy(disps[i]->monid, ""); /* We won't be able to set a profile */
}
break;
}
if (callback_ddebug) {
fprintf(errout,"Mon %d, name '%s'\n",j,dd.DeviceName);
fprintf(errout,"Mon %d, string '%s'\n",j,dd.DeviceString);
fprintf(errout,"Mon %d, flags 0x%x\n",j,dd.StateFlags);
fprintf(errout,"Mon %d, id '%s'\n",j,dd.DeviceID);
fprintf(errout,"Mon %d, key '%s'\n",j,dd.DeviceKey);
}
if (j == 0) {
strcpy(disps[i]->monid, dd.DeviceID);
}
}
sprintf(buf,"%s, at %d, %d, width %d, height %d%s",disps[i]->name+4,
disps[i]->sx, disps[i]->sy, disps[i]->sw, disps[i]->sh,
disps[i]->prim ? " (Primary Display)" : "");
if ((disps[i]->description = strdup(buf)) == NULL) {
debugrr("get_displays failed on malloc\n");
free_disppaths(disps);
return NULL;
}
debugrr2((errout, "get_displays added description '%s' to display %d\n",disps[i]->description,i));
/* Note that calling EnumDisplayDevices(NULL, j, ..) for the adapter can return other */
/* information, such as the graphics card name, and additional state flags. */
/* EnumDisplaySettings() can also be called to get information such as display depth etc. */
}
#ifdef NEVER
/* Explore adapter information */
for (j = 0; ; j++) {
/* Get adapater information */
if ((*pEnumDisplayDevices)(NULL, j, &dd, 0) == 0)
break;
printf("Adapt %d, name '%s'\n",j,dd.DeviceName);
printf("Adapt %d, string '%s'\n",j,dd.DeviceString);
printf("Adapt %d, flags 0x%x\n",j,dd.StateFlags);
printf("Adapt %d, id '%s'\n",j,dd.DeviceID);
printf("Adapt %d, key '%s'\n",j,dd.DeviceKey);
}
#endif /* NEVER */
#endif /* NT */
#ifdef __APPLE__
/* Note :- some recent releases of OS X have a feature which */
/* automatically adjusts the screen brightness with ambient level. */
/* We may have to find a way of disabling this during calibration and profiling. */
/* See the "pset -g" command. */
/*
We could possibly use NSScreen instead of CG here,
If we're using libui, then we have an NSApp, so
this would be possible.
*/
int i;
CGDisplayErr dstat;
CGDisplayCount dcount; /* Number of display IDs */
CGDirectDisplayID *dids; /* Array of display IDs */
if ((dstat = CGGetActiveDisplayList(0, NULL, &dcount)) != kCGErrorSuccess || dcount < 1) {
debugrr("CGGetActiveDisplayList #1 returned error\n");
return NULL;
}
if ((dids = (CGDirectDisplayID *)malloc(dcount * sizeof(CGDirectDisplayID))) == NULL) {
debugrr("malloc of CGDirectDisplayID's failed\n");
return NULL;
}
if ((dstat = CGGetActiveDisplayList(dcount, dids, &dcount)) != kCGErrorSuccess) {
debugrr("CGGetActiveDisplayList #2 returned error\n");
free(dids);
return NULL;
}
/* Found dcount displays */
debugrr2((errout,"Found %d screens\n",dcount));
/* Allocate our list */
if ((disps = (disppath **)calloc(sizeof(disppath *), dcount + 1)) == NULL) {
debugrr("get_displays failed on malloc\n");
free(dids);
return NULL;
}
for (i = 0; i < dcount; i++) {
if ((disps[i] = calloc(sizeof(disppath), 1)) == NULL) {
debugrr("get_displays failed on malloc\n");
free_disppaths(disps);
free(dids);
return NULL;
}
disps[i]->ddid = dids[i];
}
/* Got displays, now figure out a description for each one */
for (i = 0; i < dcount; i++) {
CGRect dbound; /* Bounding rectangle of chosen display */
io_service_t dport;
CFDictionaryRef ddr, pndr;
CFIndex dcount;
char *dp = NULL, desc[50];
char buf[200];
dbound = CGDisplayBounds(dids[i]);
disps[i]->sx = dbound.origin.x;
disps[i]->sy = dbound.origin.y;
disps[i]->sw = dbound.size.width;
disps[i]->sh = dbound.size.height;
/* Try and get some information about the display */
if ((dport = CGDisplayIOServicePort(dids[i])) == MACH_PORT_NULL) {
debugrr("CGDisplayIOServicePort returned error\n");
free_disppaths(disps);
free(dids);
return NULL;
}
#ifdef NEVER
{
io_name_t name;
if (IORegistryEntryGetName(dport, name) != KERN_SUCCESS) {
debugrr("IORegistryEntryGetName returned error\n");
free_disppaths(disps);
free(dids);
return NULL;
}
printf("Driver %d name = '%s'\n",i,name);
}
#endif
if ((ddr = IODisplayCreateInfoDictionary(dport, 0)) == NULL) {
debugrr("IODisplayCreateInfoDictionary returned NULL\n");
free_disppaths(disps);
free(dids);
return NULL;
}
if ((pndr = CFDictionaryGetValue(ddr, CFSTR(kDisplayProductName))) == NULL) {
debugrr("CFDictionaryGetValue returned NULL\n");
CFRelease(ddr);
free_disppaths(disps);
free(dids);
return NULL;
}
if ((dcount = CFDictionaryGetCount(pndr)) > 0) {
const void **keys;
const void **values;
int j;
keys = (const void **)calloc(sizeof(void *), dcount);
values = (const void **)calloc(sizeof(void *), dcount);
if (keys == NULL || values == NULL) {
if (keys != NULL)
free(keys);
if (values != NULL)
free(values);
debugrr("malloc failed\n");
CFRelease(ddr);
free_disppaths(disps);
free(dids);
return NULL;
}
CFDictionaryGetKeysAndValues(pndr, keys, values);
for (j = 0; j < dcount; j++) {
const char *k, *v;
char kbuf[50], vbuf[50];
k = CFStringGetCStringPtr(keys[j], kCFStringEncodingMacRoman);
if (k == NULL) {
if (CFStringGetCString(keys[j], kbuf, 50, kCFStringEncodingMacRoman))
k = kbuf;
}
v = CFStringGetCStringPtr(values[j], kCFStringEncodingMacRoman);
if (v == NULL) {
if (CFStringGetCString(values[j], vbuf, 50, kCFStringEncodingMacRoman))
v = vbuf;
}
/* We're only grabbing the english description... */
if (k != NULL && v != NULL && strcmp(k, "en_US") == 0) {
strncpy(desc, v, 49);
desc[49] = '\000';
dp = desc;
}
}
free(keys);
free(values);
}
CFRelease(ddr);
if (dp == NULL) {
strcpy(desc, "(unknown)");
dp = desc;
}
sprintf(buf,"%s, at %d, %d, width %d, height %d%s",dp,
disps[i]->sx, disps[i]->sy, disps[i]->sw, disps[i]->sh,
CGDisplayIsMain(dids[i]) ? " (Primary Display)" : "");
if ((disps[i]->name = strdup(dp)) == NULL
|| (disps[i]->description = strdup(buf)) == NULL) {
debugrr("get_displays failed on malloc\n");
free_disppaths(disps);
free(dids);
return NULL;
}
}
free(dids);
#endif /* __APPLE__ */
#if defined(UNIX) && !defined(__APPLE__)
int i, j, k;
int defsix = 0; /* default screen index */
int dcount; /* Number of screens */
char *dname;
char dnbuf[100];
int evb = 0, erb = 0;
int majv, minv; /* Version */
Display *mydisplay;
int ndisps = 0;
XineramaScreenInfo *xai = NULL;
char desc1[100], desc2[200];
/* There seems to be no way of getting the available displays */
/* on an X11 system. Attempting to open them in sequence */
/* takes too long. We just rely on the user supplying the */
/* right display. We can enumerate screens though. */
/* Open the base display, and then enumerate all the screens */
if ((dname = getenv("DISPLAY")) != NULL) {
char *pp;
strncpy(dnbuf,dname,99); dnbuf[99] = '\000';
if ((pp = strrchr(dnbuf, ':')) != NULL) {
if ((pp = strchr(pp, '.')) == NULL)
strcat(dnbuf,".0");
else {
if (pp[1] == '\000')
strcat(dnbuf,"0");
else {
pp[1] = '0';
pp[2] = '\000';
}
}
}
} else
strcpy(dnbuf,":0.0");
if ((mydisplay = XOpenDisplay(dnbuf)) == NULL) {
debugrr2((errout, "failed to open display '%s'\n",dnbuf));
return NULL;
}
#if RANDR_MAJOR == 1 && RANDR_MINOR >= 2 && !defined(DISABLE_RANDR)
/* Use Xrandr 1.2 if it's available, and if it's not disabled. */
if (getenv("ARGYLL_IGNORE_XRANDR1_2") == NULL
&& XRRQueryExtension(mydisplay, &evb, &erb) != 0
&& XRRQueryVersion(mydisplay, &majv, &minv)
&& majv == 1 && minv >= 2) {
static void *xrr_found = NULL; /* .so handle */
static XRRScreenResources *(*_XRRGetScreenResourcesCurrent)
(Display *dpy, Window window) = NULL;
static RROutput (*_XRRGetOutputPrimary)(Display *dpy, Window window) = NULL;
// int defsix; /* Default Screen index */
if (XSetErrorHandler(null_error_handler) == 0) {
debugrr("get_displays failed on XSetErrorHandler\n");
XCloseDisplay(mydisplay);
free_disppaths(disps);
return NULL;
}
/* Get functions available in Xrandr V1.3 */
if (minv >= 3 && xrr_found == NULL) {
if ((xrr_found = dlopen("libXrandr.so", RTLD_LAZY)) != NULL) {
_XRRGetScreenResourcesCurrent = dlsym(xrr_found, "XRRGetScreenResourcesCurrent");
_XRRGetOutputPrimary = dlsym(xrr_found, "XRRGetOutputPrimary");
}
}
/* Hmm. Do Xrandr systems alway have only one Screen, */
/* just like Xinerama ? */
dcount = ScreenCount(mydisplay);
debugrr2((errout,"get_displays using %d XRandR Screens\n",dcount));
/* Not sure what to do with this. */
/* Should we go through X11 screens with this first ? */
/* (How does Xrandr translate Screen 1..n to Xinerama ?????) */
defsix = DefaultScreen(mydisplay);
/* In order to be in sync with an application using Xinerama, */
/* we need to generate our screen indexes in the same */
/* order as Xinerama. */
/* Go through all the X11 screens */
for (i = 0; i < dcount; i++) {
XRRScreenResources *scrnres;
int has_primary = 0;
int pix = -1; /* CRTC index containing primary */
int pop = -1; /* Output index containing primary */
int jj; /* Xinerama screen ix */
int xj; /* working crtc index */
int xk; /* working output index */
if (minv >= 3 && _XRRGetScreenResourcesCurrent != NULL) {
scrnres = _XRRGetScreenResourcesCurrent(mydisplay, RootWindow(mydisplay,i));
} else {
scrnres = XRRGetScreenResources(mydisplay, RootWindow(mydisplay,i));
}
if (scrnres == NULL) {
debugrr("XRRGetScreenResources failed\n");
XCloseDisplay(mydisplay);
free_disppaths(disps);
return NULL;
}
/* We have to scan through CRTC's & outputs in the same order */
/* as the XRANDR XInerama implementation in the X server. */
/* This is a little tricky, as we need to do the primary output, */
/* first, while keeping the rest in order. */
/* Locate the crtc index that contains the primary (if any) */
if (minv >= 3 && _XRRGetOutputPrimary != NULL) {
XID primary; /* Primary output ID */
primary = _XRRGetOutputPrimary(mydisplay, RootWindow(mydisplay,i));
debugrr2((errout,"XRRGetOutputPrimary returned XID %x\n",primary));
if (primary != None) {
for (j = 0; j < scrnres->ncrtc; j++) {
XRRCrtcInfo *crtci = NULL;
if ((crtci = XRRGetCrtcInfo(mydisplay, scrnres, scrnres->crtcs[j])) == NULL)
continue;
if (crtci->mode == None || crtci->noutput == 0) {
XRRFreeCrtcInfo(crtci);
continue;
}
for (k = 0; k < crtci->noutput; k++) {
if (crtci->outputs[k] == primary) {
pix = j;
pop = k;
}
}
XRRFreeCrtcInfo(crtci);
}
if (pix < 0) { /* Didn't locate primary */
debugrr2((errout,"Couldn't locate primary CRTC!\n"));
} else {
debugrr2((errout,"Primary is at CRTC %d Output %d\n",pix,pop));
has_primary = 1;
}
}
}
/* Look through all the Screens CRTC's */
for (jj = xj = j = 0; j < scrnres->ncrtc; j++, xj++) {
char *pp;
XRRCrtcInfo *crtci = NULL;
XRROutputInfo *outi0 = NULL;
if (has_primary) {
if (j == 0)
xj = pix; /* Start with crtc containing primary */
else if (xj == pix) /* We've up to primary that we've alread done */
xj++; /* Skip it */
}
if ((crtci = XRRGetCrtcInfo(mydisplay, scrnres, scrnres->crtcs[xj])) == NULL) {
debugrr2((errout,"XRRGetCrtcInfo of Screen %d CRTC %d failed\n",i,xj));
if (has_primary && j == 0)
xj = -1; /* Start at beginning */
continue;
}
debugrr2((errout,"XRRGetCrtcInfo of Screen %d CRTC %d has %d Outputs %s Mode\n",i,xj,crtci->noutput,crtci->mode == None ? "No" : "Valid"));
if (crtci->mode == None || crtci->noutput == 0) {
debugrr2((errout,"CRTC skipped as it has no mode or no outputs\n",i,xj,crtci->noutput));
XRRFreeCrtcInfo(crtci);
if (has_primary && j == 0)
xj = -1; /* Start at beginning */
continue;
}
/* This CRTC will now be counted as an Xinerama screen */
/* For each output of Crtc */
for (xk = k = 0; k < crtci->noutput; k++, xk++) {
XRROutputInfo *outi = NULL;
if (has_primary && xj == pix) {
if (k == 0)
xk = pop; /* Start with primary output */
else if (xk == pop) /* We've up to primary that we've alread done */
xk++; /* Skip it */
}
if ((outi = XRRGetOutputInfo(mydisplay, scrnres, crtci->outputs[xk])) == NULL) {
debugrr2((errout,"XRRGetOutputInfo failed for Screen %d CRTC %d Output %d\n",i,xj,xk));
goto next_output;
}
if (k == 0) /* Save this so we can label any clones */
outi0 = outi;
if (outi->connection == RR_Disconnected) {
debugrr2((errout,"Screen %d CRTC %d Output %d is disconnected\n",i,xj,xk));
goto next_output;
}
/* Check that the VideoLUT's are accessible */
{
XRRCrtcGamma *crtcgam = NULL;
debugrr("Checking XRandR 1.2 VideoLUT access\n");
if ((crtcgam = XRRGetCrtcGamma(mydisplay, scrnres->crtcs[xj])) == NULL
|| crtcgam->size == 0) {
fprintf(stderr,"XRRGetCrtcGamma failed - falling back to older extensions\n");
if (crtcgam != NULL)
XRRFreeGamma(crtcgam);
if (outi != NULL && outi != outi0)
XRRFreeOutputInfo(outi);
if (outi0 != NULL)
XRRFreeOutputInfo(outi0);
XRRFreeCrtcInfo(crtci);
XRRFreeScreenResources(scrnres);
free_disppaths(disps);
disps = NULL;
goto done_xrandr;
}
if (crtcgam != NULL)
XRRFreeGamma(crtcgam);
}
#ifdef NEVER
{
Atom *oprops;
int noprop;
/* Get a list of the properties of the output */
oprops = XRRListOutputProperties(mydisplay, crtci->outputs[xk], &noprop);
printf("num props = %d\n", noprop);
for (k = 0; k < noprop; k++) {
printf("%d: atom 0x%x, name = '%s'\n", k, oprops[k], XGetAtomName(mydisplay, oprops[k]));
}
}
#endif /* NEVER */
/* Add the output to the list */
debugrr2((errout,"Adding Screen %d CRTC %d Output %d\n",i,xj,xk));
if (disps == NULL) {
if ((disps = (disppath **)calloc(sizeof(disppath *), 1 + 1)) == NULL) {
debugrr("get_displays failed on malloc\n");
XRRFreeCrtcInfo(crtci);
if (outi != NULL && outi != outi0)
XRRFreeOutputInfo(outi);
if (outi0 != NULL)
XRRFreeOutputInfo(outi0);
XRRFreeScreenResources(scrnres);
XCloseDisplay(mydisplay);
return NULL;
}
} else {
if ((disps = (disppath **)realloc(disps,
sizeof(disppath *) * (ndisps + 2))) == NULL) {
debugrr("get_displays failed on malloc\n");
XRRFreeCrtcInfo(crtci);
if (outi != NULL && outi != outi0)
XRRFreeOutputInfo(outi);
if (outi0 != NULL)
XRRFreeOutputInfo(outi0);
XRRFreeScreenResources(scrnres);
XCloseDisplay(mydisplay);
return NULL;
}
disps[ndisps+1] = NULL; /* End marker */
}
/* ndisps is current display we're filling in */
if ((disps[ndisps] = calloc(sizeof(disppath),1)) == NULL) {
debugrr("get_displays failed on malloc\n");
XRRFreeCrtcInfo(crtci);
if (outi != NULL && outi != outi0)
XRRFreeOutputInfo(outi);
if (outi0 != NULL)
XRRFreeOutputInfo(outi0);
XRRFreeScreenResources(scrnres);
XCloseDisplay(mydisplay);
free_disppaths(disps);
return NULL;
}
disps[ndisps]->screen = i; /* X11 (virtual) Screen */
disps[ndisps]->uscreen = jj; /* Xinerama/Xrandr screen */
disps[ndisps]->rscreen = jj;
disps[ndisps]->sx = crtci->x;
disps[ndisps]->sy = crtci->y;
disps[ndisps]->sw = crtci->width;
disps[ndisps]->sh = crtci->height;
disps[ndisps]->crtc = scrnres->crtcs[xj]; /* XID of CRTC */
disps[ndisps]->output = crtci->outputs[xk]; /* XID of output */
sprintf(desc1,"Monitor %d, Output %s",ndisps+1,outi->name);
sprintf(desc2,"%s at %d, %d, width %d, height %d",desc1,
disps[ndisps]->sx, disps[ndisps]->sy, disps[ndisps]->sw, disps[ndisps]->sh);
/* If it is a clone */
if ( (k > 0) & (outi0 != NULL) ) {
sprintf(desc1, "[ Clone of %s ]",outi0->name);
strcat(desc2, desc1);
}
if ((disps[ndisps]->description = strdup(desc2)) == NULL) {
debugrr("get_displays failed on malloc\n");
XRRFreeCrtcInfo(crtci);
if (outi != NULL && outi != outi0)
XRRFreeOutputInfo(outi);
if (outi0 != NULL)
XRRFreeOutputInfo(outi0);
XRRFreeScreenResources(scrnres);
XCloseDisplay(mydisplay);
free_disppaths(disps);
return NULL;
}
/* Form the display name */
if ((pp = strrchr(dnbuf, ':')) != NULL) {
if ((pp = strchr(pp, '.')) != NULL) {
sprintf(pp,".%d",i);
}
}
if ((disps[ndisps]->name = strdup(dnbuf)) == NULL) {
debugrr("get_displays failed on malloc\n");
XRRFreeCrtcInfo(crtci);
if (outi != NULL && outi != outi0)
XRRFreeOutputInfo(outi);
if (outi0 != NULL)
XRRFreeOutputInfo(outi0);
XRRFreeScreenResources(scrnres);
XCloseDisplay(mydisplay);
free_disppaths(disps);
return NULL;
}
debugrr2((errout, "Display %d name = '%s'\n",ndisps,disps[ndisps]->name));
/* Create the X11 root atom of the default screen */
/* that may contain the associated ICC profile. */
if (jj == 0)
strcpy(desc1, "_ICC_PROFILE");
else
sprintf(desc1, "_ICC_PROFILE_%d",disps[ndisps]->uscreen);
if ((disps[ndisps]->icc_atom = XInternAtom(mydisplay, desc1, False)) == None)
fprintf(stderr, "Unable to intern atom '%s'",desc1);
debugrr2((errout,"Root atom '%s'\n",desc1));
/* Create the atom of the output that may contain the associated ICC profile */
if ((disps[ndisps]->icc_out_atom = XInternAtom(mydisplay, "_ICC_PROFILE", False)) == None)
fprintf(stderr, "Unable to intern atom '%s'","_ICC_PROFILE");
/* Grab the EDID from the output */
{
Atom edid_atom, ret_type;
int ret_format;
long ret_len = 0;
unsigned long *ret_togo;
unsigned char *atomv = NULL;
int ii;
char *keys[] = { /* Possible keys that may be used */
"EDID_DATA",
"EDID",
""
};
/* Try each key in turn */
for (ii = 0; keys[ii][0] != '\000'; ii++) {
/* Get the atom for the EDID data */
if ((edid_atom = XInternAtom(mydisplay, keys[ii], True)) == None) {
// debugrr2((errout, "Unable to intern atom '%s'\n",keys[ii]));
/* Try the next key */
/* Get the EDID_DATA */
} else {
if (XRRGetOutputProperty(mydisplay, crtci->outputs[xk], edid_atom,
0, 0x7ffffff, False, False, XA_INTEGER,
&ret_type, &ret_format, &ret_len, &ret_togo, &atomv) == Success
&& (ret_len == 128 || ret_len == 256 || ret_len == 384)) {
if ((disps[ndisps]->edid = malloc(sizeof(unsigned char) * ret_len)) == NULL) {
debugrr("get_displays failed on malloc\n");
XRRFreeCrtcInfo(crtci);
if (outi != NULL && outi != outi0)
XRRFreeOutputInfo(outi);
if (outi0 != NULL)
XRRFreeOutputInfo(outi0);
XRRFreeScreenResources(scrnres);
XCloseDisplay(mydisplay);
free_disppaths(disps);
return NULL;
}
memmove(disps[ndisps]->edid, atomv, ret_len);
disps[ndisps]->edid_len = ret_len;
XFree(atomv);
debugrr2((errout, "Got EDID for display\n"));
break;
}
/* Try the next key */
}
}
if (keys[ii][0] == '\000')
debugrr2((errout, "Failed to get EDID for display\n"));
}
ndisps++; /* Now it's number of displays */
next_output:;
if (outi != NULL && outi != outi0)
XRRFreeOutputInfo(outi);
if (has_primary && xj == pix && k == 0)
xk = -1; /* Go to first output */
}
// next_screen:;
if (outi0 != NULL)
XRRFreeOutputInfo(outi0);
XRRFreeCrtcInfo(crtci);
jj++; /* Next Xinerama screen index */
if (has_primary && j == 0)
xj = -1; /* Go to first screen */
}
XRRFreeScreenResources(scrnres);
}
done_xrandr:;
XSetErrorHandler(NULL);
}
#endif /* randr >= V 1.2 */
if (disps == NULL) { /* Use Older style identification */
if (XSetErrorHandler(null_error_handler) == 0) {
debugrr("get_displays failed on XSetErrorHandler\n");
XCloseDisplay(mydisplay);
return NULL;
}
if (getenv("ARGYLL_IGNORE_XINERAMA") == NULL
&& XineramaQueryExtension(mydisplay, &evb, &erb) != 0
&& XineramaIsActive(mydisplay)) {
xai = XineramaQueryScreens(mydisplay, &dcount);
if (xai == NULL || dcount == 0) {
debugrr("XineramaQueryScreens failed\n");
XCloseDisplay(mydisplay);
return NULL;
}
debugrr2((errout,"get_displays using %d Xinerama Screens\n",dcount));
} else {
dcount = ScreenCount(mydisplay);
debugrr2((errout,"get_displays using %d X11 Screens\n",dcount));
}
/* Allocate our list */
if ((disps = (disppath **)calloc(sizeof(disppath *), dcount + 1)) == NULL) {
debugrr("get_displays failed on malloc\n");
XCloseDisplay(mydisplay);
return NULL;
}
for (i = 0; i < dcount; i++) {
if ((disps[i] = calloc(sizeof(disppath), 1)) == NULL) {
debugrr("get_displays failed on malloc\n");
free_disppaths(disps);
XCloseDisplay(mydisplay);
return NULL;
}
}
/* Create a description for each screen */
for (i = 0; i < dcount; i++) {
XF86VidModeMonitor monitor;
int evb = 0, erb = 0;
char *pp;
/* Form the display name */
if ((pp = strrchr(dnbuf, ':')) != NULL) {
if ((pp = strchr(pp, '.')) != NULL) {
if (xai != NULL) /* Xinerama */
sprintf(pp,".%d",0);
else
sprintf(pp,".%d",i);
}
}
if ((disps[i]->name = strdup(dnbuf)) == NULL) {
debugrr("get_displays failed on malloc\n");
free_disppaths(disps);
XCloseDisplay(mydisplay);
return NULL;
}
debugrr2((errout, "Display %d name = '%s'\n",i,disps[i]->name));
if (xai != NULL) { /* Xinerama */
/* xai[i].screen_number should be == i */
disps[i]->screen = 0; /* Assume Xinerame creates a single virtual X11 screen */
disps[i]->uscreen = i; /* Underlying Xinerma screen */
disps[i]->rscreen = i;
disps[i]->sx = xai[i].x_org;
disps[i]->sy = xai[i].y_org;
disps[i]->sw = xai[i].width;
disps[i]->sh = xai[i].height;
} else { /* Plain X11 Screens */
disps[i]->screen = i;
disps[i]->uscreen = i;
disps[i]->rscreen = i;
disps[i]->sx = 0; /* Must be 0 */
disps[i]->sy = 0;
disps[i]->sw = DisplayWidth(mydisplay, disps[i]->screen);
disps[i]->sh = DisplayHeight(mydisplay, disps[i]->screen);
}
/* Create the X11 root atom of the default screen */
/* that may contain the associated ICC profile */
if (disps[i]->uscreen == 0)
strcpy(desc1, "_ICC_PROFILE");
else
sprintf(desc1, "_ICC_PROFILE_%d",disps[i]->uscreen);
if ((disps[i]->icc_atom = XInternAtom(mydisplay, desc1, False)) == None)
fprintf(stderr, "Unable to intern atom '%s'",desc1);
/* See if we can locate the EDID of the monitor for this screen */
for (j = 0; j < 2; j++) {
char edid_name[50];
Atom edid_atom, ret_type;
int ret_format = 8;
long ret_len, ret_togo;
unsigned char *atomv = NULL;
if (disps[i]->uscreen == 0) {
if (j == 0)
strcpy(edid_name,"XFree86_DDC_EDID1_RAWDATA");
else
strcpy(edid_name,"XFree86_DDC_EDID2_RAWDATA");
} else {
if (j == 0)
sprintf(edid_name,"XFree86_DDC_EDID1_RAWDATA_%d",disps[i]->uscreen);
else
sprintf(edid_name,"XFree86_DDC_EDID2_RAWDATA_%d",disps[i]->uscreen);
}
if ((edid_atom = XInternAtom(mydisplay, edid_name, True)) == None)
continue;
if (XGetWindowProperty(mydisplay, RootWindow(mydisplay, disps[i]->uscreen), edid_atom,
0, 0x7ffffff, False, XA_INTEGER,
&ret_type, &ret_format, &ret_len, &ret_togo, &atomv) == Success
&& (ret_len == 128 || ret_len == 256 || ret_len == 384)) {
if ((disps[i]->edid = malloc(sizeof(unsigned char) * ret_len)) == NULL) {
debugrr("get_displays failed on malloc\n");
free_disppaths(disps);
XCloseDisplay(mydisplay);
return NULL;
}
memmove(disps[i]->edid, atomv, ret_len);
disps[i]->edid_len = ret_len;
XFree(atomv);
debugrr2((errout, "Got EDID for display\n"));
break;
} else {
debugrr2((errout, "Failed to get EDID for display\n"));
}
}
if (XF86VidModeQueryExtension(mydisplay, &evb, &erb) != 0) {
/* Some propietary multi-screen drivers (ie. TwinView & MergeFB) */
/* don't implement the XVidMode extension properly. */
monitor.model = NULL;
if (XF86VidModeGetMonitor(mydisplay, disps[i]->uscreen, &monitor) != 0
&& monitor.model != NULL && monitor.model[0] != '\000')
sprintf(desc1, "%s",monitor.model);
else
sprintf(desc1,"Monitor %d",i+1);
} else
sprintf(desc1,"Monitor %d",i+1);
sprintf(desc2,"%s at %d, %d, width %d, height %d",desc1,
disps[i]->sx, disps[i]->sy, disps[i]->sw, disps[i]->sh);
if ((disps[i]->description = strdup(desc2)) == NULL) {
debugrr("get_displays failed on malloc\n");
free_disppaths(disps);
XCloseDisplay(mydisplay);
return NULL;
}
}
XSetErrorHandler(NULL);
/* Put the default Screen the top of the list */
if (xai == NULL) {
// int defsix = DefaultScreen(mydisplay);
defsix = DefaultScreen(mydisplay);
disppath *tdispp;
tdispp = disps[defsix];
disps[defsix] = disps[0];
disps[0] = tdispp;
}
}
if (xai != NULL)
XFree(xai);
XCloseDisplay(mydisplay);
#endif /* UNIX X11 */
return disps;
}
// END get_displays
/* Free a whole list of display paths */
void free_disppaths(disppath **disps) {
if (disps != NULL) {
int i;
for (i = 0; ; i++) {
if (disps[i] == NULL)
break;
if (disps[i]->name != NULL)
free(disps[i]->name);
if (disps[i]->description != NULL)
free(disps[i]->description);
#if defined(UNIX) && !defined(__APPLE__)
if (disps[i]->edid != NULL)
free(disps[i]->edid);
#endif
free(disps[i]);
}
free(disps);
}
}
// START get_a_display
/* ----------------------------------------------- */
/* Deal with selecting a display */
/* Return the given display given its index 0..n-1 */
disppath *get_a_display(int ix) {
disppath **paths, *rv = NULL;
int i;
debugrr2((errout, "get_a_display called with ix %d\n",ix));
if ((paths = get_displays()) == NULL)
return NULL;
for (i = 0; ;i++) {
if (paths[i] == NULL) {
free_disppaths(paths);
return NULL;
}
if (i == ix) {
break;
}
}
if ((rv = malloc(sizeof(disppath))) == NULL) {
debugrr("get_a_display failed malloc\n");
free_disppaths(paths);
return NULL;
}
*rv = *paths[i]; /* Structure copy */
if ((rv->name = strdup(paths[i]->name)) == NULL) {
debugrr("get_displays failed on malloc\n");
free(rv->description);
free(rv);
free_disppaths(paths);
return NULL;
}
if ((rv->description = strdup(paths[i]->description)) == NULL) {
debugrr("get_displays failed on malloc\n");
free(rv);
free_disppaths(paths);
return NULL;
}
#if defined(UNIX) && !defined(__APPLE__)
if (paths[i]->edid != NULL) {
if ((rv->edid = malloc(sizeof(unsigned char) * paths[i]->edid_len)) == NULL) {
debugrr("get_displays failed on malloc\n");
free(rv);
free_disppaths(paths);
return NULL;
}
rv->edid_len = paths[i]->edid_len;
memmove(rv->edid, paths[i]->edid, rv->edid_len );
}
#endif
debugrr2((errout, " Selected ix %d '%s' %s'\n",i,rv->name,rv->description));
free_disppaths(paths);
return rv;
}
// END get_a_display
void free_a_disppath(disppath *path) {
if (path != NULL) {
if (path->name != NULL)
free(path->name);
if (path->description != NULL)
free(path->description);
#if defined(UNIX) && !defined(__APPLE__)
if (path->edid != NULL)
free(path->edid);
#endif
free(path);
}
}
// MAIN
typedef struct {
int width_mm, height_mm;
} size_mm;
static size_mm get_real_screen_size_mm_disp(disppath *disp) {
size_mm size;
#ifdef NT
HDC hdc = NULL;
#endif
#ifdef __APPLE__
CGSize sz; /* Display size in mm */
#endif
#if defined(UNIX) && !defined(__APPLE__)
char *pp, *bname; /* base display name */
Display *mydisplay;
int myscreen; /* Usual or virtual screen with Xinerama */
#endif
size.width_mm = 0;
size.height_mm = 0;
if (disp == NULL) return size;
#ifdef NT
hdc = CreateDC(disp->name, NULL, NULL, NULL);
if (hdc == NULL) {
return size;
}
size.width_mm = GetDeviceCaps(hdc, HORZSIZE);
size.height_mm = GetDeviceCaps(hdc, VERTSIZE);
DeleteDC(hdc);
#endif
#ifdef __APPLE__
sz = CGDisplayScreenSize(disp->ddid);
size.width_mm = sz.width;
size.height_mm = sz.height;
#endif
#if defined(UNIX) && !defined(__APPLE__)
/* Create the base display name (in case of Xinerama, XRandR) */
if ((bname = strdup(disp->name)) == NULL) {
return size;
}
if ((pp = strrchr(bname, ':')) != NULL) {
if ((pp = strchr(pp, '.')) != NULL) {
sprintf(pp,".%d",disp->screen);
}
}
/* open the display */
mydisplay = XOpenDisplay(bname);
if(!mydisplay) {
debugr2((errout,"Unable to open display '%s'\n",bname));
free(bname);
return size;
}
free(bname);
debugr("Opened display OK\n");
myscreen = disp->screen;
size.width_mm = DisplayWidthMM(mydisplay, myscreen);
size.height_mm = DisplayHeightMM(mydisplay, myscreen);
XCloseDisplay(mydisplay);
#endif
return size;
}
static size_mm get_real_screen_size_mm(int ix) {
size_mm size;
disppath *disp = NULL;
disp = get_a_display(ix);
size = get_real_screen_size_mm_disp(disp);
free_a_disppath(disp);
return size;
}
static int get_xrandr_output_xid(int ix) {
int xid = 0;
#if defined(UNIX) && !defined(__APPLE__)
#if RANDR_MAJOR == 1 && RANDR_MINOR >= 2
disppath *disp = NULL;
disp = get_a_display(ix);
if (disp == NULL) return 0;
xid = disp->output;
free_a_disppath(disp);
#endif
#endif
return xid;
}
static PyObject * enumerate_displays(PyObject *self, PyObject *args)
{
PyObject *l = PyList_New(0);
disppath **dp;
dp = get_displays();
if (dp != NULL && dp[0] != NULL) {
PyObject* value;
PyObject *d;
size_mm size;
int i;
for (i = 0; ; i++) {
if (dp[i] == NULL)
break;
d = PyDict_New();
if (dp[i]->name != NULL && (value = PyString_FromString(dp[i]->name)) != NULL) {
PyDict_SetItemString(d, "name", value);
}
if (dp[i]->description != NULL &&
(value = PyString_FromString(dp[i]->description)) != NULL) {
PyDict_SetItemString(d, "description", value);
}
value = Py_BuildValue("(i,i)", dp[i]->sx, dp[i]->sy);
PyDict_SetItemString(d, "pos", value);
value = Py_BuildValue("(i,i)", dp[i]->sw, dp[i]->sh);
PyDict_SetItemString(d, "size", value);
size = get_real_screen_size_mm_disp(dp[i]);
// TODO: The ``value`` doesn't match realworld!!!
value = Py_BuildValue("(i,i)", size.width_mm, size.height_mm);
PyDict_SetItemString(d, "size_mm", value);
#ifdef NT
if (dp[i]->monid != NULL &&
(value = PyString_FromString(dp[i]->monid)) != NULL) {
PyDict_SetItemString(d, "DeviceID", value);
}
value = PyBool_FromLong(dp[i]->prim);
PyDict_SetItemString(d, "is_primary", value);
#endif /* NT */
#ifdef __APPLE__
//value = PyLong_FromLong(dp[i]->ddid);
//PyDict_SetItemString(d, "CGDirectDisplayID", value);
#endif /* __APPLE__ */
#if defined(UNIX) && !defined(__APPLE__)
value = PyLong_FromLong(dp[i]->screen);
PyDict_SetItemString(d, "x11_screen", value);
value = PyLong_FromLong(dp[i]->uscreen);
PyDict_SetItemString(d, "screen", value);
value = PyLong_FromLong(dp[i]->rscreen);
PyDict_SetItemString(d, "ramdac_screen", value);
value = PyLong_FromLong(dp[i]->icc_atom);
PyDict_SetItemString(d, "icc_profile_atom_id", value);
if (dp[i]->edid_len > 0 && dp[i]->edid != NULL &&
(value = PyString_FromStringAndSize(dp[i]->edid, dp[i]->edid_len)) != NULL) {
PyDict_SetItemString(d, "edid", value);
}
#if RANDR_MAJOR == 1 && RANDR_MINOR >= 2
//value = PyLong_FromLong(dp[i]->crtc);
//PyDict_SetItemString(d, "crtc", value);
value = PyLong_FromLong(dp[i]->output);
PyDict_SetItemString(d, "output", value);
value = PyLong_FromLong(dp[i]->icc_out_atom);
PyDict_SetItemString(d, "icc_profile_output_atom_id", value);
#endif /* randr >= V 1.2 */
#endif /* UNIX */
PyList_Append(l, d);
}
}
free_disppaths(dp);
return l;
}
static PyObject *
RealDisplaySizeMM(PyObject *self, PyObject *args)
{
int ix;
size_mm size;
if (!PyArg_ParseTuple(args, "i", &ix)) return NULL;
size = get_real_screen_size_mm(ix);
return Py_BuildValue("(i,i)", size.width_mm, size.height_mm);
}
static PyObject *
GetXRandROutputXID(PyObject *self, PyObject *args)
{
int ix;
int xid;
if (!PyArg_ParseTuple(args, "i", &ix)) return NULL;
xid = get_xrandr_output_xid(ix);
return Py_BuildValue("i", xid);
}
static PyMethodDef RealDisplaySizeMM_methods[] = {
{"enumerate_displays", enumerate_displays, METH_NOARGS, "Enumerate and return a list of displays."},
{"RealDisplaySizeMM", RealDisplaySizeMM, METH_VARARGS, "RealDisplaySizeMM(int displayNum)\nReturn the size (in mm) of a given display."},
{"GetXRandROutputXID", GetXRandROutputXID, METH_VARARGS, "GetXRandROutputXID(int displayNum)\nReturn the XRandR output X11 ID of a given display."},
{NULL, NULL, 0, NULL} /* Sentinel - marks the end of this structure */
};
#ifdef IS_PY3K
static struct PyModuleDef RealDisplaySizeMM_ModuleDef =
{
PyModuleDef_HEAD_INIT,
"RealDisplaySizeMM", /* name of module */
"", /* module documentation, may be NULL */
-1, /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */
RealDisplaySizeMM_methods
};
PyMODINIT_FUNC PyInit_RealDisplaySizeMM(void)
{
return PyModule_Create(&RealDisplaySizeMM_ModuleDef);
}
#else
PyMODINIT_FUNC initRealDisplaySizeMM(void)
{
Py_InitModule("RealDisplaySizeMM", RealDisplaySizeMM_methods);
}
#endif
displaycal-py3-3.9.11/DisplayCAL/RealDisplaySizeMM.py 0000664 0000000 0000000 00000015713 14437413106 0022252 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
import os
import platform
import re
import sys
from DisplayCAL.util_dbus import DBusObject, DBusException, BUSTYPE_SESSION
from DisplayCAL.util_x import get_display as _get_x_display
if sys.platform == "darwin":
# Mac OS X has universal binaries in three flavors:
# - i386 & PPC
# - i386 & x86_64
# - i386 & ARM
if platform.architecture()[0].startswith("64"):
# TODO: Intel vs ARM (Apple Silicon) distinction
from DisplayCAL.lib64.RealDisplaySizeMM import *
else:
# elif sys.platform == "win32":
# Windows have separate files
if sys.version_info[:2] == (3, 8):
from DisplayCAL.lib64.python38.RealDisplaySizeMM import *
elif sys.version_info[:2] == (3, 9):
from DisplayCAL.lib64.python39.RealDisplaySizeMM import *
elif sys.version_info[:2] == (3, 10):
from DisplayCAL.lib64.python310.RealDisplaySizeMM import *
elif sys.version_info[:2] == (3, 11):
from DisplayCAL.lib64.python311.RealDisplaySizeMM import *
# else:
# pass
# TODO: For Linux use the ``xrandr`` command output which supplies everything.
#
# ``xrandr --verbose`` gives all the info we need, including EDID which needs to
# be decoded:
#
# ```python
# import codecs
# edid = codecs.decode(xrandr_edid_data, "hex")
# ```
#
_displays = None
_GetXRandROutputXID = GetXRandROutputXID
_RealDisplaySizeMM = RealDisplaySizeMM
_enumerate_displays = enumerate_displays
def GetXRandROutputXID(display_no=0):
"""Return the XRandR output X11 ID of a given display.
Args:
display_no (int): Display number.
Returns:
dict:
"""
display = get_display(display_no)
if display:
return display.get("output", 0)
return 0
def RealDisplaySizeMM(display_no=0):
"""Return the size (in mm) of a given display.
Args:
display_no (int): Display number.
Returns:
(int, int): The display size in mm.
"""
if display := get_display(display_no):
return display.get("size_mm", (0, 0))
return 0, 0
def enumerate_displays():
"""Enumerate and return a list of displays."""
global _displays
_displays = _enumerate_displays()
for display in _displays:
desc = display["description"]
if desc:
match = re.findall(
rb"(.+?),? at (-?\d+), (-?\d+), width (\d+), height (\d+)", desc
)
if len(match):
if sys.platform not in ("darwin", "win32"):
if (
os.getenv("XDG_SESSION_TYPE") == "wayland"
and "pos" in display
and "size" in display
):
x, y, w, h = display["pos"] + display["size"]
wayland_display = get_wayland_display(x, y, w, h)
if wayland_display:
display.update(wayland_display)
else:
xrandr_name = re.search(rb", Output (.+)", match[0][0])
if xrandr_name:
display["xrandr_name"] = xrandr_name.group(1)
desc = b"%s @ %s, %s, %sx%s" % match[0]
display["description"] = desc
return _displays
def get_display(display_no=0):
if _displays is None:
enumerate_displays()
# Translate from Argyll display index to enumerated display index
# using the coordinates and dimensions
from DisplayCAL.config import getcfg, is_virtual_display
if is_virtual_display(display_no):
return
try:
argyll_display = getcfg("displays")[display_no]
except IndexError:
return
else:
if argyll_display.endswith(" [PRIMARY]"):
argyll_display = " ".join(argyll_display.split(" ")[:-1])
for display in _displays:
if desc := display["description"]:
geometry = b"".join(desc.split(b"@ ")[-1:])
if argyll_display.endswith((b"@ " + geometry).decode("utf-8")):
return display
def get_wayland_display(x, y, w, h):
"""Find matching Wayland display.
Given x, y, width and height of display geometry, find matching Wayland display.
"""
# Note that we apparently CANNNOT use width and height
# because the reported values from Argyll code and Mutter can be slightly
# different, e.g. 3660x1941 from Mutter vs 3656x1941 from Argyll when
# HiDPI is enabled. The xrandr output is also interesting in that case:
# $ xrandr
# Screen 0: minimum 320 x 200, current 3660 x 1941, maximum 8192 x 8192
# XWAYLAND0 connected 3656x1941+0+0 (normal left inverted right x axis y axis) 0mm x 0mm
# 3656x1941 59.96*+
# Note the apparent mismatch between first and 2nd/3rd line.
# Look for active display at x, y instead.
# Currently, only support for GNOME3/Mutter
try:
iface = DBusObject(
BUSTYPE_SESSION,
"org.gnome.Mutter.DisplayConfig",
"/org/gnome/Mutter/DisplayConfig",
)
res = iface.get_resources()
except DBusException:
pass
else:
# See
# https://github.com/GNOME/mutter/blob/master/src/org.gnome.Mutter.DisplayConfig.xml
output_storage = None
try:
found = False
crtcs = res[1]
# Look for matching CRTC
for crtc in crtcs:
if crtc[2:4] == (x, y) and crtc[6] != -1:
# Found our CRTC
crtc_id = crtc[0]
# Look for matching output
outputs = res[2]
for output in outputs:
if output[2] == crtc_id:
# Found our output
found = True
output_storage = output
break
if found:
break
if found and output_storage is not None:
properties = output_storage[7]
wayland_display = {"xrandr_name": output_storage[4]}
raw_edid = properties.get("edid", ())
edid = b"".join(v.to_bytes(1, "big") for v in raw_edid)
if edid:
wayland_display["edid"] = edid
w_mm = properties.get("width-mm")
h_mm = properties.get("height-mm")
if w_mm and h_mm:
wayland_display["size_mm"] = (w_mm, h_mm)
return wayland_display
except (IndexError, KeyError):
pass
def get_x_display(display_no=0):
if display := get_display(display_no):
if name := display.get("name"):
return _get_x_display(name)
def get_x_icc_profile_atom_id(display_no=0):
if display := get_display(display_no):
return display.get("icc_profile_atom_id")
def get_x_icc_profile_output_atom_id(display_no=0):
if display := get_display(display_no):
return display.get("icc_profile_output_atom_id")
displaycal-py3-3.9.11/DisplayCAL/__init__.py 0000664 0000000 0000000 00000000250 14437413106 0020501 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
try:
from DisplayCAL import __version__
except ImportError:
__version__ = "0.0.0.0"
else:
__version__ = __version__.VERSION_STRING
displaycal-py3-3.9.11/DisplayCAL/__main__.py 0000775 0000000 0000000 00000000131 14437413106 0020463 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
from DisplayCAL.main import main
main()
displaycal-py3-3.9.11/DisplayCAL/argyll_RGB2XYZ.py 0000664 0000000 0000000 00000005027 14437413106 0021432 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
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 substiture real numbers
[0.76, 0.72, 0.65],
],
"": [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
}
s = {"Ynorm": 0.0, "iix": {0: "R", 1: "G", 2: "B"}}
for e in range(3):
s["Ynorm"] += icx_ink_table[s["iix"][e]][0][1]
s["Ynorm"] = 1.0 / s["Ynorm"]
def XYZ_denormalize_remove_glare(X, Y, Z):
XYZ = [X, Y, Z]
# De-Normalise 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] /= s["Ynorm"]
return tuple(XYZ)
def XYZ_normalize_add_glare(X, Y, Z):
XYZ = [X, Y, Z]
# Normalise Y to 1.0, & add black glare
for j in range(3):
XYZ[j] *= s["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, G, B): # from xcolorants.c -> icxColorantLu_to_XYZ
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[s["iix"][e]][0][j]
return XYZ_normalize_add_glare(*XYZ)
def XYZ2RGB(X, Y, Z):
return colormath.XYZ2RGB(*XYZ_denormalize_remove_glare(X, Y, Z))
displaycal-py3-3.9.11/DisplayCAL/argyll_cgats.py 0000664 0000000 0000000 00000055660 14437413106 0021434 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
# import decimal
# Decimal = decimal.Decimal
import decimal
from decimal import Decimal
import os
import traceback
from io import BytesIO
from time import strftime
from DisplayCAL.debughelpers import Error
from DisplayCAL.options import debug
from DisplayCAL import CGATS
from DisplayCAL import ICCProfile as ICCP
from DisplayCAL import colormath
from DisplayCAL import localization as lang
cals = {}
def quote_nonoption_args(args):
"""Put quotes around all arguments which are not options.
(ie. which do not start with a hyphen '-')
"""
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, options_dispcal):
# Add dispcal options to cal
options_dispcal = quote_nonoption_args(options_dispcal)
try:
cgats = 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, options_dispcal=None, options_colprof=None):
# Add dispcal and colprof options to ti3
try:
cgats = 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):
"""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.
"""
vcgt, cal = cal_to_vcgt(cal, True)
if not vcgt:
return
profile = ICCP.ICCProfile()
profile.fileName = cal.filename
profile._data = b"\0" * 128
profile._tags.desc = ICCP.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, return_cgats=False):
"""Create a vcgt tag from calibration data.
cal must refer to a valid Argyll CAL file and can be a CGATS instance
or a filename.
"""
if not isinstance(cal, CGATS.CGATS):
try:
cal = CGATS.CGATS(cal)
except (
IOError,
CGATS.CGATSInvalidError,
CGATS.CGATSInvalidOperationError,
CGATS.CGATSKeyError,
CGATS.CGATSTypeError,
CGATS.CGATSValueError,
) as exception:
print(f"Warning - couldn't process CGATS file '{cal}': {exception}")
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 = ICCP.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)
if return_cgats:
return vcgt, cal
return vcgt
def can_update_cal(path):
"""Check if cal can be updated by checking for required fields."""
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.CGATS(path)
except (
IOError,
CGATS.CGATSInvalidError,
CGATS.CGATSInvalidOperationError,
CGATS.CGATSKeyError,
CGATS.CGATSTypeError,
CGATS.CGATSValueError,
) as exception:
if path in cals:
del cals[path]
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, out_cal_path=None, raise_on_missing_cal=True, prefer_cal=False
):
"""Extract calibration from 'targ' tag in profile or vcgt as fallback"""
white = False
# Check if calibration is included in TI3
targ = profile.tags.get("targ", profile.tags.get("CIED"))
if isinstance(targ, ICCP.Text):
cal = extract_cal_from_ti3(targ)
if cal:
check = cal
get_cgats = CGATS.CGATS
arg = cal
else:
cal = None
if not cal:
# Convert calibration information from embedded WCS profile
# (if present) to VideCardFormulaType if the latter is not present
if (
isinstance(profile.tags.get("MS00"), ICCP.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"), ICCP.VideoCardGammaType)
get_cgats = vcgt_to_cal
arg = profile
if check:
try:
cgats = get_cgats(arg)
except (IOError, CGATS.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 (
cal
and not prefer_cal
and isinstance(profile.tags.get("vcgt"), ICCP.VideoCardGammaType)
):
# When vcgt is nonlinear, prefer it
# Check for video levels encoding
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
cgats = vcgt_to_cal(profile)
if white and (black, white) != (0, 255):
print(f"Need to un-scale vcgt from video levels ({black}..{white})")
# Need to un-scale video levels
if data := cgats.queryv1("DATA"):
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
oldmin = (black / 256.0) * (65536 / 65535.0)
oldmax = (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, oldmin, oldmax, 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)),
)
else:
print("Warning - no un-scaling applied - no calibration data!")
if out_cal_path:
cgats.write(out_cal_path)
return cgats
def extract_cal_from_ti3(ti3):
"""Extract and return the CAL section of a TI3.
ti3 can be a file object or a string holding the data.
"""
if isinstance(ti3, CGATS.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
try:
ti3.close()
except AttributeError:
pass
return b"\n".join(cal_lines)
def extract_fix_copy_cal(source_filename, target_filename=None):
"""Return the CAL section from a profile's embedded measurement data.
Try to 'fix it' (add information needed to make the resulting .cal file
'updateable') and optionally copy it to target_filename.
"""
from DisplayCAL.worker import get_options_from_profile
try:
profile = ICCP.ICCProfile(source_filename)
except (IOError, ICCP.ICCProfileInvalidError) as exception:
return exception
if "CIED" not in profile.tags and "targ" not in profile.tags:
return None
cal_lines = []
ti3 = BytesIO(profile.tags.get("CIED", b"") or profile.tags.get("targ", b""))
ti3_lines = [line.strip() for line in ti3]
ti3.close()
cal_found = False
for line in ti3_lines:
line = line.strip()
if line == b"CAL":
line = b"CAL " # Make sure CGATS file identifiers are always a minimum of 7 characters
cal_found = True
if cal_found:
cal_lines.append(line)
if line == b'DEVICE_CLASS "DISPLAY"':
if options_dispcal := get_options_from_profile(profile)[0]:
whitepoint = False
# b = profile.tags.lumi.Y
for o in options_dispcal:
if o[0] == b"y":
cal_lines.append(b'KEYWORD "DEVICE_TYPE"')
if o[1] == b"c":
cal_lines.append(b'DEVICE_TYPE "CRT"')
else:
cal_lines.append(b'DEVICE_TYPE "LCD"')
continue
if o[0] in (b"t", b"T"):
continue
if o[0] == b"w":
continue
if o[0] in (b"g", b"G"):
if o[1:] == b"240":
trc = b"SMPTE240M"
elif o[1:] == b"709":
trc = b"REC709"
elif o[1:] == b"l":
trc = b"L_STAR"
elif o[1:] == b"s":
trc = b"sRGB"
else:
trc = o[1:]
if o[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
if o[0] == b"f":
cal_lines.extend(
(
b'KEYWORD "DEGREE_OF_BLACK_OUTPUT_OFFSET"',
b'DEGREE_OF_BLACK_OUTPUT_OFFSET "%s"' % o[1:],
)
)
continue
if o[0] == b"k":
cal_lines.extend(
(
b'KEYWORD "BLACK_POINT_CORRECTION"',
b'BLACK_POINT_CORRECTION "%s"' % o[1:],
)
)
continue
if o[0] == b"B":
cal_lines.extend(
(
b'KEYWORD "TARGET_BLACK_BRIGHTNESS"',
b'TARGET_BLACK_BRIGHTNESS "%s"' % o[1:],
)
)
continue
if o[0] == b"q":
if o[1] == b"l":
q = b"low"
elif o[1] == b"m":
q = b"medium"
else:
q = b"high"
cal_lines.extend(
(b'KEYWORD "QUALITY"', b'QUALITY "%s"' % q)
)
if not whitepoint:
cal_lines.extend(
(
b'KEYWORD "NATIVE_TARGET_WHITE"',
b'NATIVE_TARGET_WHITE ""',
)
)
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
def extract_device_gray_primaries(
ti3, gray=True, logfn=None, include_neutrals=False, neutrals_ab_threshold=0.1
):
"""Extract gray or primaries into new TI3
Return extracted ti3, extracted RGB to XYZ mapping and remaining RGB to XYZ
"""
filename = ti3.filename
ti3 = ti3.queryi1("DATA")
ti3.filename = filename
ti3_extracted = CGATS.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}")
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:
# Check if fields are missing
for prefix in ("RGB", "XYZ"):
for suffix in prefix:
key = f"{prefix}_{suffix}"
if key not in item:
raise Error(
lang.getstr(
"error.testchart.missing_fields", (ti3.filename, key)
)
)
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 in RGB_XYZ:
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
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 ti3_to_ti1(ti3_data):
"""Create and return TI1 data converted from TI3.
ti3_data can be a file object, a list of strings or a string holding the data.
"""
ti3 = CGATS.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):
"""Return a CAL (CGATS instance) from vcgt"""
cgats = 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.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.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, required, ignore_unknown=True):
"""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.
"""
cgats_1 = cgats.queryi1(required)
if not cgats_1 or not cgats_1.parent or not cgats_1.parent.parent:
raise CGATS.CGATSKeyError(f'Missing required fields: {", ".join(required)}')
cgats_1 = cgats_1.parent.parent
if not cgats_1.queryv1("NUMBER_OF_SETS"):
raise CGATS.CGATSInvalidError("Missing NUMBER_OF_SETS")
if not cgats_1.queryv1("DATA_FORMAT"):
raise CGATS.CGATSInvalidError("Missing DATA_FORMAT")
for field in required:
if field.encode("utf-8") not in list(cgats_1.queryv1("DATA_FORMAT").values()):
raise CGATS.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 CGATS.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):
"""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.
"""
return verify_cgats(cgats, ("RGB_R", "RGB_B", "RGB_G", "XYZ_X", "XYZ_Y", "XYZ_Z"))
displaycal-py3-3.9.11/DisplayCAL/argyll_instruments.py 0000664 0000000 0000000 00000036014 14437413106 0022716 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
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,
},
"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,
},
"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, replacements=None, inverse=False):
"""
:param (bytes, str) instrument_name:
:param replacements:
:param inverse:
:return:
"""
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):
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.11/DisplayCAL/argyll_names.py 0000664 0000000 0000000 00000004243 14437413106 0021425 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
# 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",
]
# Argyll CMS tools optionally used by DisplayCAL
optional = [
"applycal",
"average",
"cctiff",
"ccxxmake",
"i1d3ccss",
"oeminst",
"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, altname):
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
observers = ["1931_2", "1955_2", "1964_10", "1964_10c", "1978_2", "shaw"]
displaycal-py3-3.9.11/DisplayCAL/audio.py 0000664 0000000 0000000 00000043474 14437413106 0020062 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
"""
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 ctypes import (
CFUNCTYPE,
POINTER,
Structure,
c_int,
c_uint8,
c_uint16,
c_uint32,
c_void_p,
)
import ctypes.util
import os
import sys
import threading
import time
if sys.platform == "win32":
try:
import win32api
import pywintypes
except ImportError:
win32api = None
from DisplayCAL.config import pydir
from DisplayCAL.util_os import dlopen, getenvu
from DisplayCAL.util_str import safe_str
_ch = {}
_initialized = False
_lib = None
_lib_version = None
_server = None
_snd = {}
_sounds = {}
def init(lib=None, samplerate=22050, channels=2, buffersize=2048, reinit=False):
"""(Re-)Initialize sound subsystem"""
# 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
# 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!")
else:
return audio_lib
elif lib == "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("pyglet version %s is too old" % pyglet.version)
_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
elif lib == "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())
elif lib == "SDL":
SDL_INIT_AUDIO = 16
AUDIO_S16LSB = 0x8010
AUDIO_S16MSB = 0x9010
if sys.byteorder == "little":
MIX_DEFAULT_FORMAT = AUDIO_S16LSB
else:
MIX_DEFAULT_FORMAT = AUDIO_S16MSB
if sys.platform == "win32":
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)
elif sys.platform == "darwin":
x_framework_pth = os.getenv("X_DYLD_FALLBACK_FRAMEWORK_PATH")
if x_framework_pth:
framework_pth = os.getenv("DYLD_FALLBACK_FRAMEWORK_PATH")
if framework_pth:
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
if sys.platform in ("darwin", "win32"):
libfn = ctypes.util.find_library(libname)
if sys.platform == "win32":
if libfn and win32api:
# Support for unicode paths
libfn = str(libfn)
try:
handle = win32api.LoadLibrary(libfn)
except pywintypes.error:
pass
elif sys.platform != "darwin":
# Hard-code lib names for Linux
libfn = "lib" + libname
if libname.startswith("SDL2"):
# SDL 2.0
libfn += "-2.0.so.0"
else:
# SDL 1.2
libfn += "-1.2.so.0"
dll = dlopen(libfn, handle=handle)
if dll:
print("%s:" % libname, libfn)
if libname.endswith("_mixer"):
if not dll:
continue
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"
if libname.startswith("SDL2"):
_lib_version = "2.0"
else:
_lib_version = "1.2"
break
else:
sdl = dll
_server = None
elif lib == "wx":
try:
import wx
_lib = "wx"
except ImportError:
_lib = None
else:
_server = wx
_lib_version = wx.__version__
if not _lib:
raise RuntimeError("No audio library available")
_initialized = True
return _server
def safe_init(lib=None, samplerate=22050, channels=2, buffersize=2048, reinit=False):
"""Like init(), but catch any exceptions"""
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
def Sound(filename, loop=False, raise_exceptions=False):
"""Sound caching mechanism"""
if (filename, loop) in _sounds:
# Cache hit
return _sounds[(filename, loop)]
else:
try:
sound = _Sound(filename, loop)
except Exception as exception:
if raise_exceptions:
raise
print(exception)
sound = _Sound(None, loop)
_sounds[(filename, loop)] = sound
return sound
class DummySound(object):
"""Dummy sound wrapper class"""
def __init__(self, filename=None, loop=False):
pass
def fade(self, fade_ms, fade_in=None):
return True
@property
def is_playing(self):
return False
def play(self, fade_ms=0):
return True
@property
def play_count(self):
return 0
def safe_fade(self, fade_ms, fade_in=None):
return True
def safe_play(self, fade_ms=0):
return True
def safe_stop(self, fade_ms=0):
return True
def stop(self, fade_ms=0):
return True
volume = 0
class SDL_RWops(Structure):
pass
class Mix_Chunk(Structure):
_fields_ = [
("allocated", c_int),
("abuf", POINTER(c_uint8)),
("alen", c_uint32),
("volume", c_uint8),
]
class _Sound(object):
"""Sound wrapper class"""
def __init__(self, filename, loop=False):
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 _initialized and not isinstance(_initialized, Exception):
if not self._lib and _lib:
self._lib = _lib
self._lib_version = _lib_version
if not self._snd and self._filename:
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):
return _ch.get((self._filename, self._loop))
@_ch.setter
def _ch(self, ch):
_ch[(self._filename, self._loop)] = ch
def _fade(self, fade_ms, fade_in, 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):
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):
if self._snd and self._lib != "wx":
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, int(round(volume * 128)))
return True
return False
@property
def _snd(self):
return _snd.get((self._filename, self._loop))
@_snd.setter
def _snd(self, snd):
_snd[(self._filename, self._loop)] = snd
def fade(self, fade_ms, fade_in=None):
"""Fade in/out.
If fade_in is None, fade in/out depending on current volume.
"""
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)
elif self._snd and self._lib != "wx":
self._thread += 1
threading.Thread(
target=self._fade,
name="AudioFading-%d[%sms]" % (self._thread, fade_ms),
args=(fade_ms, fade_in, self._thread),
).start()
return True
return False
@property
def is_playing(self):
if self._lib == "pyo":
return bool(self._snd and self._snd.isOutputting())
elif 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
)
)
elif self._lib == "SDL":
return bool(self._ch is not None and self._server.Mix_Playing(self._ch))
return self._is_playing
def play(self, fade_ms=0, stop_already_playing=True):
if self._snd:
volume = self.volume
if stop_already_playing:
self.stop()
if self._lib == "pyglet":
# 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:
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._lib == "pyo":
self._snd.out()
elif self._lib == "pyglet":
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()
elif self._lib == "SDL":
self._ch = self._server.Mix_PlayChannelTimed(
-1, self._snd, -1 if self._loop else 0, -1
)
elif self._lib == "wx" and 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
if fade_ms and self._lib != "wx":
self.fade(fade_ms, True)
return True
return False
@property
def play_count(self):
return self._play_count
def safe_fade(self, fade_ms, fade_in=None):
"""Like fade(), but catch any exceptions"""
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=0):
"""Like play(), but catch any exceptions"""
if not _initialized:
safe_init()
try:
return self.play(fade_ms)
except Exception as exception:
return exception
def safe_stop(self, fade_ms=0):
"""Like stop(), but catch any exceptions"""
try:
return self.stop(fade_ms)
except Exception as exception:
return exception
def stop(self, fade_ms=0):
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)
else:
if self._lib == "pyglet":
self._ch.pause()
elif self._lib == "SDL":
self._server.Mix_HaltChannel(self._ch)
else:
self._snd.stop()
return True
else:
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.11/DisplayCAL/beep.wav 0000664 0000000 0000000 00000051474 14437413106 0020040 0 ustar 00root root 0000000 0000000 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.11/DisplayCAL/camera_shutter.wav 0000664 0000000 0000000 00000072366 14437413106 0022136 0 ustar 00root root 0000000 0000000 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.11/DisplayCAL/ccmx.py 0000664 0000000 0000000 00000007001 14437413106 0017675 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
# Python 2.5
import codecs
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, target_dir):
"""Convert iColorDisplay DeviceCorrections.txt to individual Argyll CCMX files"""
with codecs.open(path, "r", "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] = '"%s"' % part
if parts[-1].strip() not in ("", "{") and i < len(lines) - 1:
parts[-1] += ","
lines[i] = ":".join(parts)
devcorrections_data = "{%s}" % "".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": "%s & %s"
% (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 codecs.open(os.path.join(target_dir, name + ".ccmx"), "w", "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.11/DisplayCAL/chromecast_patterngenerator.py 0000664 0000000 0000000 00000011203 14437413106 0024536 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
from time import sleep
# 0install: Make sure imported protobuf is from implementation to ensure
# correct version
import sys
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"]
try:
import pkg_resources
except ImportError:
import pkgutil
syspath = sys.path[:]
sys.path[:] = [pth]
import google.protobuf
sys.path[:] = syspath
break
if sys.version_info[:2] < (3,):
# zeroconf 0.19.1 is the last version supporting Python 2.x
# but zeroconf 0.20 lacks a check for Python version
import zeroconf
if zeroconf.__version__ > "0.19.1":
raise ImportError(
"""
Python version > 3.3 required for python-zeroconf %s.
If you need support for Python 2 or Python 3.3 please use version 0.19.1
"""
% zeroconf.__version__
)
from pychromecast import get_chromecasts
from pychromecast.controllers import BaseController
from DisplayCAL import localization as lang
class ChromeCastPatternGeneratorController(BaseController):
def __init__(self):
super(ChromeCastPatternGeneratorController, self).__init__(
"urn:x-cast:net.hoech.cast.patterngenerator", "B5C2CBFC"
)
self.request_id = 0
def receive_message(self, message, data):
return True # Indicate we handled this message
def send(
self,
rgb=(0, 0, 0),
bgrgb=(0, 0, 0),
offset_x=0.5,
offset_y=0.5,
h_scale=1,
v_scale=1,
):
fg = "#%02X%02X%02X" % tuple(round(v * 255) for v in rgb)
bg = "#%02X%02X%02X" % 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(object):
def __init__(self, name, logfile=None):
self._controller = ChromeCastPatternGeneratorController()
self.name = name
self.listening = False
self.logfile = logfile
def disconnect_client(self):
self.listening = False
if hasattr(self, "_cc"):
if self._cc.app_id:
self._cc.quit_app()
if hasattr(self, "conn"):
del self.conn
def send(
self,
rgb=(0, 0, 0),
bgrgb=(0, 0, 0),
bits=None,
use_video_levels=None,
x=0,
y=0,
w=1,
h=1,
):
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):
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.11/DisplayCAL/colord.py 0000664 0000000 0000000 00000041513 14437413106 0020233 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
from binascii import hexlify
import os
import subprocess as sp
import sys
import warnings
from time import sleep
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
from gi.repository import Gio
except ImportError:
Colord = None
Gio = None
else:
cancellable = Gio.Cancellable.new()
from DisplayCAL.util_dbus import DBusObject, DBusException, BUSTYPE_SYSTEM
from DisplayCAL.util_os import which
from DisplayCAL.util_str import safe_str
from DisplayCAL import localization as lang
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)
# 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():
"""Connect to colord"""
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, device_id):
"""Connect to device"""
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])
# Connect to device
if not device.connect_sync(cancellable):
raise CDError("Couldn't connect to device with ID %r" % device_id)
return device
def device_id_from_edid(
edid,
quirk=False,
use_serial_32=True,
truncate_edid_strings=False,
omit_manufacturer=False,
query=False,
):
"""Assemble device key from EDID"""
# 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 "hash" in edid:
device_id = device_ids.get(edid["hash"])
if device_id:
return device_id
elif (
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)
else:
if device_id:
device_ids[edid["hash"]] = device_id
return device_id
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:
value = edid.get(name)
if value:
if name == "serial_32" and "serial_ascii" in edid:
# Only add numeric serial if no ascii serial
continue
elif name == "manufacturer":
if quirk:
value = quirk_manufacturer(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))
if len(parts) > 1:
device_id = "-".join(parts)
return device_id
def find(what, search):
"""Find device or profile and return object path"""
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))
else:
raise CDObjectQueryError(safe_str(exception))
raise CDError(safe_str(exception))
def get_default_profile(device_id):
"""Get default profile for 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))
else:
if properties.get("ProfilingInhibitors"):
return None
profiles = properties.get("Profiles")
if profiles:
return profiles[0]
else:
raise CDError("Couldn't get default profile for device ID %r" % device_id)
def get_devices_by_kind(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():
return get_devices_by_kind("display")
def get_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, object_type):
"""Get object path for profile or device ID"""
result = find(object_type + "-by-id", search)
if not result:
raise CDObjectNotFoundError("Could not find object path for %s" % search)
return result
def install_profile(
device_id, profile, timeout=CD_CLIENT_IMPORT_DAEMON_TIMEOUT / 1000.0, logfn=None
):
"""Install profile for device.
timeout: Time to allow for colord to pick up new profiles (recommended not below 2
secs).
"""
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.calculateID()
profile.fileName = None
profile_id = "icc-" + hexlify(profile.ID).decode()
# Write profile to destination
profile_installdir = os.path.dirname(profile_install_name)
if not os.path.isdir(profile_installdir):
os.makedirs(profile_installdir)
# 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()
cdprofile = None
if Colord and not isinstance(Colord, DBusObject):
client = client_connect()
else:
# Query colord for profile
try:
cdprofile = get_object_path(profile_id, "profile")
except CDObjectQueryError:
# Profile not found
pass
colormgr = which("colormgr")
if not colormgr:
raise CDError("colormgr helper program not found")
from DisplayCAL.worker import printcmdline
cmd = str(colormgr)
if not cdprofile:
# Import profile
if logfn:
logfn("-" * 80)
logfn(lang.getstr("commandline"))
args = [cmd, "import-profile", safe_str(profile.fileName)]
printcmdline(args[0], args[1:], fn=logfn)
if logfn:
logfn("")
# ts = time.time()
maxtries = 3
for n in range(1, maxtries + 1):
if logfn:
logfn("Trying to import profile, attempt %i..." % n)
try:
p = sp.Popen(args, stdout=sp.PIPE, stderr=sp.STDOUT)
stdout, stderr = p.communicate()
except Exception as exception:
raise CDError(safe_str(exception))
if logfn and stdout.strip():
logfn(stdout.strip())
if p.returncode == 0 or os.path.isfile(profile_install_name):
if logfn:
logfn("...ok")
break
elif logfn:
logfn("...failed!")
if p.returncode != 0 and not os.path.isfile(profile_install_name):
raise CDTimeout(
"Trying to import profile '%s' failed after "
"%i tries." % (profile.fileName, n)
)
if not cdprofile:
# Query colord for newly added profile
for _i in range(int(timeout / 1.0)):
try:
if Colord and not isinstance(Colord, DBusObject):
cdprofile = client.find_profile_sync(profile_id, cancellable)
else:
cdprofile = get_object_path(profile_id, "profile")
except CDObjectQueryError:
# Profile not found
pass
if cdprofile:
break
# Give colord time to pick up the profile
sleep(1)
if not cdprofile:
raise CDTimeout(
"Querying for profile %r returned no result for %s "
"secs" % (profile_id, timeout)
)
errmsg = "Could not make profile %s default for device %s" % (profile_id, device_id)
if Colord and not isinstance(Colord, DBusObject):
# 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)
# Make profile default for device
if not device.make_profile_default_sync(cdprofile, cancellable):
raise CDError(errmsg)
else:
# Find device object path
device = get_object_path(device_id, "device")
if logfn:
logfn("-" * 80)
logfn(lang.getstr("commandline"))
# Add profile to device
# (Ignore returncode as profile may already have been added)
args = [cmd, "device-add-profile", device, cdprofile]
printcmdline(args[0], args[1:], fn=logfn)
if 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))
if logfn and stdout.strip():
logfn(stdout.strip())
if logfn:
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)
if 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))
else:
if p.returncode != 0:
raise CDError(stdout.strip() or errmsg)
if logfn and stdout.strip():
logfn(stdout.strip())
def quirk_manufacturer(manufacturer):
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)]
manufacturer = manufacturer.rstrip()
return manufacturer
class Object(DBusObject):
def __init__(self, object_path, object_type):
try:
DBusObject.__init__(
self,
BUSTYPE_SYSTEM,
"org.freedesktop.ColorManager",
object_path,
object_type,
)
except DBusException as exception:
raise CDError(safe_str(exception))
self._object_type = object_type
_properties = DBusObject.properties
@property
def properties(self):
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))
class Device(Object):
def __init__(self, object_path):
Object.__init__(self, object_path, "Device")
class Profile(Object):
def __init__(self, object_path):
Object.__init__(self, object_path, "Profile")
class CDError(Exception):
pass
class CDObjectQueryError(CDError):
pass
class CDObjectNotFoundError(CDObjectQueryError):
pass
class CDTimeout(CDError):
pass
if __name__ == "__main__":
import sys
for arg in sys.argv[1:]:
print(get_default_profile(arg))
displaycal-py3-3.9.11/DisplayCAL/colormath.py 0000664 0000000 0000000 00000376743 14437413106 0020761 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
"""
Diverse color mathematical functions.
Note:
In most cases, unless otherwise stated RGB is R'G'B' (gamma-compressed)
"""
import colorsys
import logging
import math
import sys
import warnings
def get_transfer_function_phi(alpha, gamma):
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 specialpow(a, b, slope_limit=0):
"""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)
"""
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)
else:
if slope_limit:
return max(math.pow(a, b), a / slope_limit)
return math.pow(a, b)
if a < 0.0:
signScale = -1.0
a = -a
else:
signScale = 1.0
if b in (1.0 / -601, 1.0 / -709):
# XYZ -> RGB, Rec. 601/709 TRC
if a < REC709_K0 / REC709_P:
v = a * REC709_P
else:
v = 1.099 * math.pow(a, 0.45) - 0.099
elif b == 1.0 / -240:
# XYZ -> RGB, SMPTE 240M TRC
if a < SMPTE240M_K0 / SMPTE240M_P:
v = a * SMPTE240M_P
else:
v = 1.1115 * math.pow(a, 0.45) - 0.1115
elif b == 1.0 / -3.0:
# XYZ -> RGB, L* TRC
if a <= LSTAR_E:
v = 0.01 * a * LSTAR_K
else:
v = 1.16 * math.pow(a, 1.0 / 3.0) - 0.16
elif b == 1.0 / -2.4:
# XYZ -> RGB, sRGB TRC
if a <= SRGB_K0 / SRGB_P:
v = a * SRGB_P
else:
v = 1.055 * math.pow(a, 1.0 / 2.4) - 0.055
elif b == 1.0 / -2084:
# XYZ -> RGB, SMPTE 2084 (PQ)
v = (
(2413.0 * (a**SMPTE2084_M1) + 107) / (2392.0 * (a**SMPTE2084_M1) + 128)
) ** SMPTE2084_M2
elif b == -2.4:
# RGB -> XYZ, sRGB TRC
if a <= SRGB_K0:
v = a / SRGB_P
else:
v = math.pow((a + 0.055) / 1.055, 2.4)
elif b == -3.0:
# RGB -> XYZ, L* TRC
if a <= 0.08: # E * K * 0.01
v = 100.0 * a / LSTAR_K
else:
v = math.pow((a + 0.16) / 1.16, 3.0)
elif b == -240:
# RGB -> XYZ, SMPTE 240M TRC
if a < SMPTE240M_K0:
v = a / SMPTE240M_P
else:
v = math.pow((0.1115 + a) / 1.1115, 1.0 / 0.45)
elif b in (-601, -709):
# RGB -> XYZ, Rec. 601/709 TRC
if a < REC709_K0:
v = a / REC709_P
else:
v = math.pow((a + 0.099) / 1.099, 1.0 / 0.45)
elif b == -2084:
# RGB -> XYZ, SMPTE 2084 (PQ)
# See https://www.smpte.org/sites/default/files/2014-05-06-EOTF-Miller-1-2-handout.pdf
v = (
max(a ** (1.0 / SMPTE2084_M2) - SMPTE2084_C1, 0)
/ (SMPTE2084_C2 - SMPTE2084_C3 * a ** (1.0 / SMPTE2084_M2))
) ** (1.0 / SMPTE2084_M1)
else:
raise ValueError("Invalid gamma %r" % b)
return v * signScale
def DICOM(j, inverse=False):
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)
)
else:
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(object):
"""Hybrid Log Gamma (HLG) as defined in Rec BT.2100
and BT.2390-4
"""
def __init__(
self,
black_cdm2=0.0,
white_cdm2=1000.0,
system_gamma=1.2,
ambient_cdm2=5,
rgb_space="Rec. 2020",
):
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):
"""System gamma for nominal peak luminance and ambient"""
# 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, inverse=False):
"""Hybrid Log Gamma (HLG) OETF
Relative scene linear light to non-linear HLG signal, or inverse
Input domain 0..1
Output range 0..1
"""
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
if 0 <= v <= 1 / 12.0:
v = math.sqrt(3 * v)
else:
v = a * math.log(12 * v - b) + c
return v
def eotf(self, RGB, inverse=False, apply_black_offset=True):
"""Hybrid Log Gamma (HLG) EOTF
Non-linear HLG signal to display light, or inverse
Input domain 0..1
Output range 0..1
"""
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)
def ootf(self, RGB, inverse=False, apply_black_offset=True):
"""Hybrid Log Gamma (HLG) OOTF
Relative scene linear light to display light, or inverse
Input domain 0..1
Output range 0..1
"""
if isinstance(RGB, (float, int)):
R, G, B = (RGB,) * 3
else:
R, G, B = RGB
if apply_black_offset:
black_cdm2 = float(self.black_cdm2)
else:
black_cdm2 = 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 Y > beta:
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(self, R, G, B, apply_black_offset=True):
"""Non-linear HLG signal to 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(self, X, Y, Z, apply_black_offset=True):
"""Display XYZ to 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])
Yy = self.ootf(Y, True, apply_black_offset=False)
if Y:
X, Y, Z = (v / Y * Yy for v in (X, Y, Z))
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 = {
# 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
"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),
),
}
def get_cat_matrix(cat="Bradford"):
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):
return math.pow(x, 1.0 / 3.0) if x >= 0 else -math.pow(-x, 1.0 / 3.0)
def var(a):
"""Variance"""
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(X, Y, Z, cat="Bradford"):
"""Convert from XYZ to cone response domain
:param X:
:param Y:
:param Z:
:param str, Matrix3x3 cat:
"""
cat = get_cat_matrix(cat)
p, y, b = cat * [X, Y, Z]
return p, y, b
def LMS_wp_adaption_matrix(
whitepoint_source=None, whitepoint_destination=None, cat="Bradford"
):
"""Prepare a matrix to match the whitepoints in cone response domain"""
# 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)
XYZWS = get_whitepoint(whitepoint_source)
XYZWD = get_whitepoint(whitepoint_destination)
if XYZWS[1] <= 1.0 < XYZWD[1]:
# make sure the scaling is identical
XYZWD = [v / XYZWD[1] * XYZWS[1] for v in XYZWD]
if XYZWD[1] <= 1.0 < XYZWS[1]:
# make sure the scaling is identical
XYZWS = [v / XYZWS[1] * XYZWD[1] for v in XYZWS]
Ls, Ms, Ss = XYZ2LMS(XYZWS[0], XYZWS[1], XYZWS[2], cat)
Ld, Md, Sd = XYZ2LMS(XYZWD[0], XYZWD[1], XYZWD[2], cat)
return Matrix3x3([[Ld / Ls, 0, 0], [0, Md / Ms, 0], [0, 0, Sd / Ss]])
def wp_adaption_matrix(
whitepoint_source=None, whitepoint_destination=None, cat="Bradford"
):
"""Prepare a matrix to match the whitepoints in cone response doamin and
transform back to XYZ
"""
# 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'
cachehash = (
tuple(whitepoint_source)
if isinstance(whitepoint_source, (list, tuple))
else whitepoint_source,
tuple(whitepoint_destination)
if isinstance(whitepoint_destination, (list, tuple))
else whitepoint_destination,
cat if isinstance(cat, str) else id(cat),
)
if cachehash in wp_adaption_matrix.cache:
return wp_adaption_matrix.cache[cachehash]
cat = get_cat_matrix(cat)
wpam = (
cat.inverted()
* LMS_wp_adaption_matrix(whitepoint_source, whitepoint_destination, cat)
* cat
)
wp_adaption_matrix.cache[cachehash] = wpam
return wpam
wp_adaption_matrix.cache = {}
def adapt(X, Y, Z, whitepoint_source=None, whitepoint_destination=None, cat="Bradford"):
"""Transform XYZ under source illuminant to XYZ under destination illuminant"""
# 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, Y, Z, bp_in=None, bp_out=None, wp_out="D50", weight=False, pin_chromaticity=False
):
"""Apply black point compensation"""
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]
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]
for i, v in enumerate(XYZ):
XYZ[i] = ((wp_out[i] - bp_out[i]) * v - wp_out[i] * (bp_in[i] - bp_out[i])) / (
wp_out[i] - bp_in[i]
)
if pin_chromaticity:
XYZ = xyY2XYZ(x, y, XYZ[0])
return XYZ
def avg(*args):
return float(sum(args)) / len(args)
def blend_ab(X, Y, Z, bp, wp, power=40.0, signscale=1):
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, Y, Z, bp_in=None, bp_out=None, wp=None, power=40.0, pin_chromaticity=False
):
"""Blend to destination black as L approaches black, optionally compensating
for input black first
"""
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)
X, Y, Z = apply_bpc(X, Y, Z, bp_wp, None, wp, pin_chromaticity)
else:
X, Y, Z = apply_bpc(X, Y, Z, None, bp_wp, wp, pin_chromaticity)
X, Y, Z = blend_ab(X, Y, Z, bp, wp, power, 1)
return X, Y, Z
def interp_old(x, xp, fp, left=None, right=None):
"""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
"""
if not isinstance(x, (int, float, complex)):
yi = []
for n in x:
yi.append(interp_old(n, xp, fp, left, right))
return yi
if x in xp:
return fp[xp.index(x)]
elif x < xp[0]:
return fp[0] if left is None else left
elif x > xp[-1]:
return fp[-1] if right is None else right
else:
# 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, xp, fp, left=None, right=None, period=None):
"""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
"""
# 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.
import numpy
return numpy.interp(x, xp, fp, left, right, period)
def interp_resize(iterable, new_size, use_numpy=False):
"""Change size of iterable through linear interpolation"""
result = []
x_new = list(range(len(iterable)))
# interp = Interp(x_new, iterable, use_numpy=use_numpy)
for i in range(new_size):
result.append(
interp(
i / (new_size - 1.0) * (len(iterable) - 1.0),
x_new,
iterable,
)
)
return result
def interp_fill(xp, fp, new_size, use_numpy=False):
"""Fill missing points by interpolation"""
result = []
last = xp[-1]
# interp = Interp(xp, fp, use_numpy=use_numpy)
for i in range(new_size):
result.append(
interp(
i / (new_size - 1.0) * last,
xp,
fp
)
)
return result
def smooth_avg_old(values, passes=1, window=None, protect=None):
"""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.
"""
if not window or len(window) < 3 or len(window) % 2 != 1:
if window:
warnings.warn(
"Invalid window %r, size %i - using default (1, 1, 1)"
% (window, len(window)),
Warning,
)
window = (1.0, 1.0, 1.0)
for _x in range(0, 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
else:
tmp_window = tmp_window[1:-1]
data.append(v)
values = data
return values
def smooth_avg(values, passes=1, window=None, protect=None):
"""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.
"""
if not window or len(window) < 3 or len(window) % 2 != 1:
if window:
warnings.warn(
"Invalid window %r, size %i - using default (1, 1, 1)"
% (window, len(window)),
Warning,
)
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]
import numpy
for i 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, bp_out):
"""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
"""
# 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,
a1,
b1,
L2,
a2,
b2,
method="1976",
p1=None,
p2=None,
p3=None,
cie94_use_symmetric_chrominance=True,
):
"""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
method: either "CIE94", "CMC", "CIE2K" or "CIE76"
(default if method is not set)
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)
"""
if isinstance(method, str):
method = method.lower()
else:
method = 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
if cie94_use_symmetric_chrominance:
C_ = math.sqrt(C1 * C2)
else:
C_ = 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_
dH_ = 2 * math.sqrt(C1_ * C2_) * math.sin(math.radians(dh_ / 2.0))
dH = dH_
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 = dH_ / 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(
X1,
Y1,
Z1,
X2,
Y2,
Z2,
method="76",
whitepoint1="D50",
whitepoint2="D50",
whitepoint_reference="D50",
cat="Bradford",
):
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)
if whitepoint2 != whitepoint_reference:
X2, Y2, Z2 = adapt(X2, Y2, Z2, whitepoint2, whitepoint_reference, cat)
L1, a1, b1 = XYZ2Lab(X1, Y1, Z1, whitepoint_reference)
L2, a2, b2 = XYZ2Lab(X2, Y2, Z2, whitepoint_reference)
logging.debug(
"L*a*b*[1] %.4f %.4f %.4f L*a*b*[2] %.4f %.4f %.4f" % (L1, a1, b1, L2, a2, b2)
)
return delta(L1, a1, b1, L2, a2, b2, method)
def is_similar_matrix(matrix1, matrix2, digits=3):
"""Compare two matrices and check if they are the same
up to n digits after the decimal point"""
return matrix1.rounded(digits) == matrix2.rounded(digits)
def is_equal(values1, values2, quantizer=lambda v: round(v, 4)):
"""Compare two sets of values and check if they are the same
after applying quantization"""
return [quantizer(v) for v in values1] == [quantizer(v) for v in values2]
def four_color_matrix(
XrR,
YrR,
ZrR,
XrG,
YrG,
ZrG,
XrB,
YrB,
ZrB,
XrW,
YrW,
ZrW,
XmR,
YmR,
ZmR,
XmG,
YmG,
ZmG,
XmB,
YmB,
ZmB,
XmW,
YmW,
ZmW,
Y_correction=True,
):
"""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).
"""
XYZ = locals()
xyz = {}
M = {}
k = {}
for s in "mr":
xyz[s] = {}
for color in "RGBW":
X, Y, Z = (XYZ[component + s + color] for component in "XYZ")
x, y = XYZ2xyY(X, Y, Z)[:2]
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[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, scale=1.0, vmin=0.0, vmax=1.0, average=True, least_squares=False):
"""Return 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)
else:
if not gammas:
return 0
return sum(gammas) / len(gammas)
else:
return gammas
def guess_cat(chad, whitepoint_source=None, whitepoint_destination=None):
"""Try and guess the chromatic adaption transform used in a chromatic
adaption matrix as found in an ICC profile's 'chad' tag"""
if chad == [[1, 0, 0], [0, 1, 0], [0, 0, 1]]:
# Cannot figure out CAT from identity chad
return
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
def CIEDCCT2xyY(T, scale=1.0):
"""Convert from CIE correlated daylight temperature to xyY.
T = temperature in Kelvin.
Based on formula from http://brucelindbloom.com/Eqn_T_to_xy.html
"""
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)
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, scale=1.0):
"""Convert from CIE correlated daylight temperature to XYZ.
T = temperature in Kelvin.
"""
xyY = CIEDCCT2xyY(T, scale)
if xyY:
return xyY2XYZ(*xyY)
# cLUT Input value tweaks to make Video encoded black land on
# 65 res grid nodes, which should help 33 and 17 res cLUTs too
def cLUT65_to_VidRGB(v, size=65):
if v <= 236.0 / 256:
# Scale up to near black point
return v * 256.0 / 255
else:
return 1 - (1 - v) * (1 - 236.0 / 255) / (1 - 236.0 / 256)
def VidRGB_to_cLUT65(v, size=65):
if v <= 236.0 / 255.0:
return v * 255.0 / 256
else:
return 1 - (1 - v) * (1 - 236.0 / 256) / (1 - 236.0 / 255)
def VidRGB_to_eeColor(v):
return v * 255.0 / 256.0
def eeColor_to_VidRGB(v):
return v * 256.0 / 255.0
def DIN992Lab(L99, a99, b99, kCH=1.0, kE=1.0):
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, a99, b99):
C99, H99 = DIN99familyab2DIN99CH(a99, b99)
return DIN99familyLCH2Lab(L99, C99, H99, 0, 303.67, 0.0039, 26, 0.83, 23, 0.075)
def DIN99o2Lab(L99, a99, b99, kCH=1.0, kE=1.0):
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, C99, H99):
return DIN99familyLCH2Lab(L99, C99, H99, 0, 303.67, 0.0039, 26, 0.83, 23, 0.075)
def DIN99c2Lab(L99, a99, b99, whitepoint=None):
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(L99, a99, b99, whitepoint=None):
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(L99, C99, H99, whitepoint=None):
return DIN99familyLCH2Lab(
L99, C99, H99, 0.12, 325.221, 0.0036, 50, 1.14, 22.5, 0.06, whitepoint
)
def DIN99familyLCH2Lab(
L99, C99, H99, x, l1, l2, deg, f1, c1, c2, whitepoint=None, kE=1.0, hdeg=None
):
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)
X, Y, Z = DIN99cdXYZ2XYZ(X, Y, Z, x)
L, a, b = XYZ2Lab(X, Y, Z, whitepoint)
return L, a, b
def DIN99cdXYZ2XYZ(X, Y, Z, x):
X = (X + x * Z) / (1 + x)
return X, Y, Z
def DIN99familyLHCG2Lab(L99, H99, C99, G, kE, l1, l2, deg, f1):
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, H99):
h99ef = H99 * math.pi / 180
return C99 * math.cos(h99ef), C99 * math.sin(h99ef)
def DIN99familyab2DIN99CH(a99, b99):
C99 = math.sqrt(math.pow(a99, 2) + math.pow(b99, 2))
if a99 > 0:
if b99 >= 0:
h99ef = math.atan2(b99, a99)
else:
h99ef = 2 * math.pi + math.atan2(b99, a99)
elif a99 < 0:
h99ef = math.atan2(b99, a99)
else:
if 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(H, S, I, scale=1.0):
H *= 360
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(H, S, L, scale=1.0):
return tuple(v * scale for v in colorsys.hls_to_rgb(H, L, S))
def HSV2RGB(H, S, V, scale=1.0):
return tuple(v * scale for v in colorsys.hsv_to_rgb(H, S, V))
def get_DBL_MIN():
t = "0.0"
i = 10
n = 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, C, H):
a = C * math.cos(H * math.pi / 180.0)
b = C * math.sin(H * math.pi / 180.0)
return L, a, b
def Lab2DIN99(L, a, b, kCH=1.0, kE=1.0):
L99, C99, H99 = Lab2DIN99LCH(L, a, b, kCH, kE)
a99, b99 = DIN99familyCH2DIN99ab(C99, H99)
return L99, a99, b99
def Lab2DIN99b(L, a, b, kE=1.0):
L99, C99, H99 = Lab2DIN99bLCH(L, a, b, kE)
a99, b99 = DIN99familyCH2DIN99ab(C99, H99)
return L99, a99, b99
def Lab2DIN99o(L, a, b, kCH=1.0, kE=1.0):
L99, C99, H99 = Lab2DIN99oLCH(L, a, b, kCH, kE)
a99, b99 = DIN99familyCH2DIN99ab(C99, H99)
return L99, a99, b99
def Lab2DIN99c(L, a, b, kE=1.0, whitepoint=None):
X, Y, Z = Lab2XYZ(L, a, b, whitepoint, scale=100)
return XYZ2DIN99c(X, Y, Z, whitepoint)
def Lab2DIN99d(L, a, b, kE=1.0, whitepoint=None):
X, Y, Z = Lab2XYZ(L, a, b, whitepoint, scale=100)
return XYZ2DIN99d(X, Y, Z, whitepoint)
def Lab2DIN99LCH(L, a, b, kCH=1.0, kE=1.0):
return Lab2DIN99familyLCH(
L, a, b, 105.51, 0.0158, 16, 0.7, 1 / (0.045 * kCH * kE), 0.045, kE, 0
)
def Lab2DIN99bLCH(L, a, b, kE=1.0):
return Lab2DIN99familyLCH(L, a, b, 303.67, 0.0039, 26, 0.83, 23, 0.075)
def Lab2DIN99oLCH(L, a, b, kCH=1.0, kE=1.0):
return Lab2DIN99familyLCH(
L, a, b, 303.67, 0.0039, 26, 0.83, 1 / (0.0435 * kCH * kE), 0.075, kE
)
def Lab2DIN99familyLCH(L, a, b, l1, l2, deg, f1, c1, c2, kE=1.0, hdeg=None):
L99, G, h99ef, rad = 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(L, a, b, kE, l1, l2, deg, f1):
L99 = (1.0 / kE) * l1 * math.log(1 + l2 * L)
rad = deg * math.pi / 180
if rad:
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, a, b):
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(L, a, b, whitepoint=None, scale=100):
X, Y, Z = Lab2XYZ(L, a, b, whitepoint, scale)
return XYZ2Luv(X, Y, Z, whitepoint)
def Lab2RGB(
L,
a,
b,
rgb_space=None,
scale=1.0,
round_=False,
clamp=True,
whitepoint=None,
whitepoint_source=None,
noadapt=False,
cat="Bradford",
):
"""Convert from Lab to RGB"""
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(L, a, b, whitepoint=None, scale=1.0):
"""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
"""
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
if L > LSTAR_K * LSTAR_E:
yr = math.pow((L + 16) / 116.0, 3.0)
else:
yr = L / LSTAR_K
if math.pow(fz, 3.0) > LSTAR_E:
zr = math.pow(fz, 3.0)
else:
zr = (116.0 * fz - 16) / LSTAR_K
Xr, Yr, Zr = get_whitepoint(whitepoint, scale)
X = xr * Xr
Y = yr * Yr
Z = zr * Zr
return X, Y, Z
def Lab2xyY(L, a, b, whitepoint=None, scale=1.0):
X, Y, Z = Lab2XYZ(L, a, b, whitepoint, scale)
return XYZ2xyY(X, Y, Z, whitepoint)
def Luv2LCHuv(L, u, v):
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(
L, u, v, rgb_space=None, scale=1.0, round_=False, clamp=True, whitepoint=None
):
"""Convert from Luv to RGB"""
X, Y, Z = Luv2XYZ(L, u, v, whitepoint)
return XYZ2RGB(X, Y, Z, rgb_space, scale, round_, clamp)
def u_v_2xy(u, v):
"""Convert from u'v' to xy"""
x = (9.0 * u) / (6 * u - 16 * v + 12)
y = (4 * v) / (6 * u - 16 * v + 12)
return x, y
def Luv2XYZ(L, u, v, whitepoint=None, scale=1.0):
"""Convert from Luv to XYZ"""
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(R, G, B, scale=1.0):
I = (R + G + B) / 3.0
if I:
S = 1 - min(R, G, B) / I
else:
S = 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(R, G, B, scale=1.0):
H, L, S = colorsys.rgb_to_hls(R, G, B)
return tuple(v * scale for v in (H, S, L))
def RGB2HSV(R, G, B, scale=1.0):
return tuple(v * scale for v in colorsys.rgb_to_hsv(R, G, B))
def LinearRGB2ICtCp(R, G, B, oetf=lambda FD: specialpow(FD, 1.0 / -2084)):
"""Rec. 2020 linear RGB to non-linear ICtCp"""
# http://www.dolby.com/us/en/technologies/dolby-vision/ICtCp-white-paper.pdf
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(I, Ct, Cp, eotf=lambda v: specialpow(v, -2084)):
"""Non-linear ICtCp to Rec. 2020 linear RGB"""
# http://www.dolby.com/us/en/technologies/dolby-vision/ICtCp-white-paper.pdf
L_M_S_ = ICtCp2L_M_S__matrix * (I, Ct, Cp)
L, M, S = (eotf(v) for v in L_M_S_)
R, G, B = LMS2LinearRGB_matrix * (L, M, S)
return R, G, B
def RGB2ICtCp(
R,
G,
B,
rgb_space="Rec. 2020",
eotf=lambda v: specialpow(v, -2084),
clamp=False,
oetf=lambda E: specialpow(E, 1.0 / -2084),
):
"""R'G'B' to ICtCp"""
X, Y, Z = RGB2XYZ(R, G, B, rgb_space, eotf=eotf)
return XYZ2ICtCp(X, Y, Z, clamp, oetf)
def ICtCp2RGB(
I,
Ct,
Cp,
rgb_space="Rec. 2020",
eotf=lambda v: specialpow(v, -2084),
clamp=False,
oetf=lambda E: specialpow(E, 1.0 / -2084),
):
"""ICtCp to R'G'B'"""
X, Y, Z = ICtCp2XYZ(I, Ct, Cp, eotf)
return XYZ2RGB(X, Y, Z, rgb_space, clamp=clamp, oetf=oetf)
def XYZ2ICtCp(X, Y, Z, clamp=False, oetf=lambda E: specialpow(E, 1.0 / -2084)):
R, G, B = XYZ2RGB(X, Y, Z, "Rec. 2020", clamp=clamp, oetf=lambda v: v)
return LinearRGB2ICtCp(R, G, B, oetf)
def ICtCp2XYZ(I, Ct, Cp, eotf=lambda v: specialpow(v, -2084)):
R, G, B = ICtCp2LinearRGB(I, Ct, Cp, eotf)
return RGB2XYZ(R, G, B, "Rec. 2020", eotf=lambda v: v)
def RGB2Lab(R, G, B, rgb_space=None, whitepoint=None, noadapt=False, cat="Bradford"):
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(R, G, B, rgb_space=None, scale=1.0, eotf=None):
"""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.
"""
trc, whitepoint, rxyY, gxyY, bxyY, matrix = get_rgb_space(rgb_space)
RGB = [R, G, B]
is_trc = isinstance(trc, (list, tuple))
for i, v in enumerate(RGB):
if is_trc:
gamma = trc[i]
else:
gamma = 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] = specialpow(v, gamma)
XYZ = matrix * RGB
return tuple(v * scale for v in XYZ)
def RGB2xyY(R, G, B, rgb_space=None, scale=1.0, eotf=None):
"""Convert RGB to xyY"""
return XYZ2xyY(
*RGB2XYZ(R, G, B, rgb_space, scale, eotf),
whitepoint=RGB2XYZ(1, 1, 1, rgb_space, scale, eotf)
)
def RGB2YCbCr(R, G, B, rgb_space="NTSC 1953", bits=8, fullrange=False):
"""R'G'B' to Y'CbCr quantized to n bits"""
return YPbPr2YCbCr(*RGB2YPbPr(R, G, B, rgb_space), bits=bits, fullrange=fullrange)
def RGB2YPbPr(R, G, B, rgb_space="NTSC 1953"):
"""R'G'B' to Y'PbPr"""
return RGB2YPbPr_matrix(rgb_space) * (R, G, B)
def RGB2YPbPr_matrix(rgb_space="NTSC 1953"):
(trc, whitepoint, (rx, ry, rY), (gx, gy, gY), (bx, by, bY), matrix) = get_rgb_space(
rgb_space
)
if matrix == get_rgb_space("NTSC 1953")[-1]:
ndigits = 3
else:
ndigits = 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(Y, Cb, Cr, bits=8, fullrange=False):
"""Y'CbCr to Y'PbPr"""
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
Y /= Yscale
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(
Y,
Cb,
Cr,
rgb_space="NTSC 1953",
bits=8,
fullrange=False,
scale=1.0,
round_=False,
clamp=True,
):
"""Y'CbCr to R'G'B'"""
Y, Pb, Pr = YCbCr2YPbPr(Y, Cb, Cr, bits, fullrange)
return YPbPr2RGB(Y, Pb, Pr, rgb_space, scale, round_, clamp)
def YPbPr2RGB(Y, Pb, Pr, rgb_space="NTSC 1953", scale=1.0, round_=False, clamp=True):
"""Y'PbPr to R'G'B'"""
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(Y, Pb, Pr, bits=8, fullrange=False):
"""Y'PbPr to Y'CbCr quantized to n bits"""
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
Cneutral = 128 / 256.0 * bitlevels
Cscale = (Cmax - Yblack) / 256.0 * bitlevels
Cb = Cneutral + Cscale * Pb
Cr = Cneutral + Cscale * Pr
# In fullrange mode, Cb and Cr can reach 255.5, so we need to clamp
# Follow ITU-T Rec. T.871 (JPEG)
Y, Cb, Cr = (min(max(int(round(v)), 0), bitlevels - 1) for v in (Y, Cb, Cr))
return Y, Cb, Cr
def RGBsaturation(R, G, B, saturation, rgb_space=None):
"""(De)saturate a RGB color in CIE xy and return the RGB and xyY values"""
whitepoint = RGB2XYZ(1, 1, 1, rgb_space=rgb_space)
X, Y, Z = RGB2XYZ(R, G, B, rgb_space=rgb_space)
XYZ, xyY = XYZsaturation(X, Y, Z, saturation, whitepoint)
return XYZ2RGB(*XYZ, rgb_space=rgb_space), xyY
def XYZsaturation(X, Y, Z, saturation, whitepoint=None):
"""(De)saturate a XYZ color in CIE xy and return the RGB and xyY values"""
wx, wy, wY = XYZ2xyY(*get_whitepoint(whitepoint))
x, y, Y = XYZ2xyY(X, Y, Z)
x, y, Y = xyYsaturation(x, y, Y, wx, wy, saturation)
return xyY2XYZ(x, y, Y), (x, y, Y)
def xyYsaturation(x, y, Y, wx, wy, saturation):
"""(De)saturate a color in CIE xy and return the RGB and xyY values"""
return wx + (x - wx) * saturation, wy + (y - wy) * saturation, Y
def convert_range(v, oldmin=0, oldmax=1, newmin=0, newmax=1):
oldrange = float(oldmax - oldmin)
newrange = newmax - newmin
return (((v - oldmin) * newrange) / oldrange) + newmin
def rgb_to_xyz_matrix(rx, ry, gx, gy, bx, by, whitepoint=None, scale=1.0):
"""Create and return an RGB to XYZ matrix."""
whitepoint = get_whitepoint(whitepoint, scale)
Xr, Yr, Zr = xyY2XYZ(rx, ry, scale)
Xg, Yg, Zg = xyY2XYZ(gx, gy, scale)
Xb, Yb, Zb = xyY2XYZ(bx, by, scale)
Sr, Sg, Sb = (
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, rgb_space_names=None, digits=4):
"""Given primaries and whitepoint xy as list, find matching RGB space by
comparing primaries and whitepoint (fuzzy match rounded to n digits) and
return its name (or None if no match)
"""
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
def get_rgb_space(rgb_space=None, scale=1.0):
"""Return gamma, whitepoint, primaries and RGB -> XYZ matrix"""
if not rgb_space:
rgb_space = "sRGB"
if isinstance(rgb_space, str):
rgb_space = rgb_spaces[rgb_space]
cachehash = tuple(map(id, rgb_space[:5])), scale
if cachehash in get_rgb_space.cache:
return get_rgb_space.cache[cachehash]
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]
gx, gy, gY = gxyY = rgb_space[3] or rgb_spaces["sRGB"][3]
bx, by, bY = bxyY = rgb_space[4] or rgb_spaces["sRGB"][4]
matrix = rgb_to_xyz_matrix(rx, ry, gx, gy, bx, by, whitepoint, scale)
rgb_space = gamma, whitepoint, rxyY, gxyY, bxyY, matrix
get_rgb_space.cache[cachehash] = rgb_space
return rgb_space
def get_rgb_space_primaries_wp_xy(rgb_space=None, digits=4):
"""Given RGB space, get primaries and whitepoint xy, optionally rounded to n
digits (default 4)
"""
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
get_rgb_space.cache = {}
def get_standard_illuminant(
illuminant_name="D50",
priority=("ISO 11664-2:2007", "ICC", "ASTM E308-01", "Wyszecki & Stiles", None),
scale=1.0,
):
"""Return a standard illuminant as XYZ coordinates."""
cachehash = illuminant_name, tuple(priority), scale
if cachehash in get_standard_illuminant.cache:
return get_standard_illuminant.cache[cachehash]
illuminant = None
for standard_name in priority:
if standard_name not in standard_illuminants:
raise ValueError('Unrecognized standard "%s"' % standard_name)
illuminant = standard_illuminants.get(standard_name).get(
illuminant_name.upper(), None
)
if illuminant:
illuminant = illuminant["X"] * scale, 1.0 * scale, illuminant["Z"] * scale
get_standard_illuminant.cache[cachehash] = illuminant
return illuminant
raise ValueError('Unrecognized illuminant "%s"' % illuminant_name)
get_standard_illuminant.cache = {}
def get_whitepoint(whitepoint=None, scale=1.0, planckian=False):
"""Return a whitepoint as XYZ coordinates"""
if isinstance(whitepoint, (list, tuple)):
return whitepoint
if not whitepoint:
whitepoint = "D50"
cachehash = whitepoint, scale, planckian
if cachehash in get_whitepoint.cache:
return get_whitepoint.cache[cachehash]
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(
"Planckian color temperature %s out of range (1667, 25000)" % cct
)
else:
whitepoint = CIEDCCT2XYZ(cct)
if not whitepoint:
raise ValueError(
"Daylight color temperature %s out of range (2500, 25000)" % cct
)
if scale > 1.0 and whitepoint[1] == 100:
scale = 1.0
whitepoint = tuple(v * scale for v in whitepoint)
get_whitepoint.cache[cachehash] = whitepoint
return whitepoint
get_whitepoint.cache = {}
def make_monotonically_increasing(iterable, passes=0, window=None):
"""Given an iterable or sequence, make the values strictly monotonically
increasing (no repeated successive values) 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.
"""
if isinstance(iterable, dict):
keys = list(iterable.keys())
values = list(iterable.values())
else:
if hasattr(iterable, "next"):
values = list(iterable)
else:
values = 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, m1, m2):
XYZ = m1 * (m2 * XYZ)
return XYZ
def planckianCT2XYZ(T, scale=1.0):
"""Convert from planckian temperature to XYZ.
T = temperature in Kelvin.
"""
xyY = planckianCT2xyY(T, scale)
if xyY:
return xyY2XYZ(*xyY)
def planckianCT2xyY(T, scale=1.0):
"""Convert from planckian temperature to xyY.
T = temperature in Kelvin.
Formula from http://en.wikipedia.org/wiki/Planckian_locus
"""
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, y, Y=1.0):
"""Convert from xyY to correlated color temperature."""
return XYZ2CCT(*xyY2XYZ(x, y, Y))
def xyY2Lab(x, y, Y=1.0, whitepoint=None):
X, Y, Z = xyY2XYZ(x, y, Y)
return XYZ2Lab(X, Y, Z, whitepoint)
def xyY2Lu_v_(x, y, Y=1.0, whitepoint=None):
X, Y, Z = xyY2XYZ(x, y, Y)
return XYZ2Lu_v_(X, Y, Z, whitepoint)
def xyY2RGB(x, y, Y, rgb_space=None, scale=1.0, round_=False, clamp=True):
"""Convert from xyY to RGB"""
X, Y, Z = xyY2XYZ(x, y, Y)
return XYZ2RGB(X, Y, Z, rgb_space, scale, round_, clamp)
def xyY2XYZ(x, y, Y=1.0):
"""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]].
"""
if y == 0:
return 0, 0, 0
X = float(x * Y) / y
Z = float((1 - x - y) * Y) / y
return X, Y, Z
def LERP(a, b, c):
"""LERP(a,b,c) = linear interpolation macro.
Is 'a' when c == 0.0 and 'b' when c == 1.0
"""
return (b - a) * c + a
def XYZ2CCT(X, Y, Z):
"""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.
"""
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
def XYZ2DIN99(X, Y, Z, whitepoint=None):
X, Y, Z = (max(v, 0) for v in (X, Y, Z))
L, a, b = XYZ2Lab(X, Y, Z, whitepoint)
return Lab2DIN99(L, a, b)
def XYZ2DIN99b(X, Y, Z, whitepoint=None):
L, a, b = XYZ2Lab(X, Y, Z, whitepoint)
return Lab2DIN99b(L, a, b)
def XYZ2DIN99o(X, Y, Z, whitepoint=None):
L, a, b = XYZ2Lab(X, Y, Z, whitepoint)
return Lab2DIN99o(L, a, b)
def XYZ2DIN99bLCH(X, Y, Z, whitepoint=None):
L, a, b = XYZ2Lab(X, Y, Z, whitepoint)
return Lab2DIN99bLCH(L, a, b)
def XYZ2DIN99oLCH(X, Y, Z, whitepoint=None):
L, a, b = XYZ2Lab(X, Y, Z, whitepoint)
return Lab2DIN99oLCH(L, a, b)
def XYZ2DIN99c(X, Y, Z, whitepoint=None):
return XYZ2DIN99cd(X, Y, Z, 0.1, 317.651, 0.0037, 0, 0.94, 23, 0.066, whitepoint)
def XYZ2DIN99cd(X, Y, Z, x, l1, l2, deg, f1, c1, c2, whitepoint=None):
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(X, Y, Z, x, l1, l2, deg, f1, c1, c2, whitepoint=None):
X, Y, Z = XYZ2DIN99cdXYZ(X, Y, Z, x)
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(X, Y, Z, x):
X = (1 + x) * X - x * Z
return X, Y, Z
def XYZ2DIN99d(X, Y, Z, whitepoint=None):
return XYZ2DIN99cd(X, Y, Z, 0.12, 325.221, 0.0036, 50, 1.14, 22.5, 0.06, whitepoint)
def XYZ2DIN99dLCH(X, Y, Z, whitepoint=None):
return XYZ2DIN99cdLCH(
X, Y, Z, 0.12, 325.221, 0.0036, 50, 1.14, 22.5, 0.06, whitepoint
)
def XYZ2IPT(X, Y, Z):
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, P, T):
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(X, Y, Z, whitepoint=None, scale=100):
"""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
"""
Xr, Yr, Zr = get_whitepoint(whitepoint, scale)
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(X, Y, Z, whitepoint=None):
"""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.
"""
# Adapted from Argyll/icc/icc.c
xyz2lms = get_cat_matrix("CIE2012_2")
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(L, p, t, whitepoint=None, scale=1.0):
"""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.
"""
# Adapted from Argyll/icc/icc.c
xyz2lms = get_cat_matrix("CIE2012_2")
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_(X, Y, Z, whitepoint=None):
"""Convert from XYZ to CIE Lu'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)
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(X, Y, Z, whitepoint=None):
"""Convert from XYZ to Luv"""
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 = XYZ2Luv(*get_whitepoint(whitepoint))
return 0.0, u, v
Xr, Yr, Zr = get_whitepoint(whitepoint, 100)
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(X, Y, Z, rgb_space=None, scale=1.0, round_=False, clamp=True, oetf=None):
"""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.
"""
trc, whitepoint, rxyY, gxyY, bxyY, matrix = get_rgb_space(rgb_space)
RGB = matrix.inverted() * [X, Y, Z]
is_trc = isinstance(trc, (list, tuple))
for i, v in enumerate(RGB):
if is_trc:
gamma = trc[i]
else:
gamma = 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] = specialpow(v, 1.0 / gamma)
RGB[i] *= scale
if round_ is not False:
RGB[i] = round(RGB[i], round_)
return RGB
XYZ2RGB.interp = {}
def XYZ2xyY(X, Y, Z, whitepoint=None):
"""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]].
"""
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))
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(x, y, daylight=True, method=2000):
"""Return 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)
else:
# Planckian locus
if 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, nrh, ncl, nch):
# Adapted from ArgyllCMS numlib/numsup.c
# nrl # Row low index
# nrh # Row high index
# ncl # Col low index
# nch # Col high index
m = {}
if nrh < nrl: # Prevent failure for 0 dimension
nrh = nrl
if nch < ncl:
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, nh):
# Adapted from ArgyllCMS numlib/numsup.c
# nl # Lowest index
# nh # Highest index
return {}
def gam_fit(gf, v):
# Adapted from ArgyllCMS xicc/xicc.c
"""gamma + input offset function handed to powell()"""
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, xi, di, ftol, func, fdata):
# Adapted from ArgyllCMS numlib/powell.c
"""
Line bracketing and minimisation routine.
Return value at minimum.
"""
POWELL_GOLD = 1.618034
POWELL_CGOLD = 0.3819660
POWELL_MAXIT = 100
# cp # Start point, and returned value
# xi[] # Search vector
# di # Dimensionality
# ftol # Tolerance to stop on
# func # Error function to evaluate
# fdata # Opaque data for func()
# ax, xx, bx # Search vector multipliers
# af, xf, bf # Function values at those points
# xt, XT # Trial point
XT = {}
if di <= 10:
xt = XT
else:
xt = dvector(0, di - 1) # Vector for trial point
# --------------------------
# First bracket the solution
logging.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)
logging.debug("linmin: Initial points a:%f:%f -> b:%f:%f" % (ax, af, xx, xf))
# 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
logging.debug(
"linmin: Ordered Initial points a:%f:%f -> b:%f:%f" % (ax, af, xx, xf)
)
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)
logging.debug(
"linmin: Initial bracket a:%f:%f x:%f:%f b:%f:%f" % (ax, af, xx, xf, bx, bf)
)
# While not bracketed
while xf > bf:
logging.debug("linmin: Not bracketed because xf %f > bf %f" % (xf, bf))
logging.debug(" ax = %f, xx = %f, bx = %f" % (ax, xx, bx))
# 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
elif 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
logging.debug(
"linmin: Got bracket a:%f:%f x:%f:%f b:%f:%f" % (ax, af, xx, xf, bx, bf)
)
# Got bracketed minimum between a -> x -> b
# ---------------------------------------
# Now use brent minimiser bewteen a and b
if True:
# 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_MAXIT + 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
logging.debug(
"linmin: Got bracket a:%f:%f x:%f:%f b:%f:%f" % (ax, af, xx, xf, bx, bf)
)
# See if we're done
if abs(xx - mx) <= (tol2 - 0.5 * (bx - ax)):
logging.debug(
"linmin: We're done because %f <= %f"
% (abs(xx - mx), tol2 - 0.5 * (bx - ax))
)
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
logging.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
logging.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:
if (mx - xx) > 0.0: # Don't use parabolic, use tol1
de = tol1 # tol1 is +ve
else:
de = -tol1
logging.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
logging.debug("linmin: Continuing golden section search")
if abs(de) >= tol1: # If de moves as much as tol1 would
ux = xx + de # use it
logging.debug("linmin: ux = %f = xx %f + de %f" % (ux, xx, de))
else: # else move by tol1 in direction de
if de > 0.0:
ux = xx + tol1
logging.debug("linmin: ux = %f = xx %f + tol1 %f" % (ux, xx, tol1))
else:
ux = xx - tol1
logging.debug("linmin: ux = %f = xx %f - tol1 %f" % (ux, xx, tol1))
# 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
logging.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 == xx or vx == wx
): # New 3rd best, or equal 1st & 2nd
vx = ux
vf = uf # New previous 2nd best from latest
logging.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
def powell(di, cp, s, ftol, maxit, func, fdata, prog=None, pdata=None):
# Adapted from ArgyllCMS powell.c
"""
Standard interface for powell function
return True on sucess, False on failure due to excessive iterions
Result will be in cp
"""
DBL_EPSILON = 2.2204460492503131e-016
# di # Dimentionality
# cp # Initial starting point
# s # Size of initial search area
# ftol # Tolerance of error change to stop on
# maxit # Maximum iterations allowed
# func # Error function to evaluate
# fdata # Opaque data needed by function
# prog # Optional progress percentage callback
# pdata # Opaque data needed by prog()
# 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]
if prog: # 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):
logging.debug("Looping over direction %d" % 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 occured 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
if prog: # 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:
logging.debug(
"Reached stop tollerance because curdel %f <= stopth "
"%f" % (curdel, stopth)
)
break
logging.debug("Not stopping because curdel %f > stopth %f" % (curdel, stopth))
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 an improvement
t1 = pretv - retv - del_
t2 = pretv - lretv
t = 2.0 * (pretv - 2.0 * retv + lretv) * t1 * t1 - del_ * t2 * t2
if t < 0.0:
# 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
if prog: # Report final progress
prog(pdata, 100)
if iter < maxit:
return True
logging.debug("powell: returning False due to excessive iterations")
return False # Failed due to execessive iterations
def xicc_tech_gamma(egamma, off, outoffset=0.0):
# Adapted from ArgyllCMS xicc.c
"""
Given the effective gamma and the output offset Y,
return the technical gamma needed for the correct 50% response.
"""
gf = gam_fits()
op = {}
sa = {}
if off <= 0.0:
return egamma
# We set up targets without outo being added
outo = off * outoffset # Offset acounted for in output
gf.bp = off - 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):
logging.warning("Computing effective gamma and input offset is inaccurate")
return op[0]
class gam_fits(object):
# Adapted from ArgyllCMS xicc/xicc.c
def __init__(self, wp=1.0, thyr=0.2, bp=0.0):
self.wp = wp # 100% input target
self.thyr = thyr # 50% input target
self.bp = bp # 0% input target
class Interp(object):
def __init__(self, xp, fp, left=None, right=None, use_numpy=False):
if use_numpy:
# Use numpy for speed
import numpy
xp = numpy.array(xp)
fp = numpy.array(fp)
self.numpy = numpy
self.xp = xp
self.fp = fp
self.left = left
self.right = right
self.lookup = {}
self.use_numpy = use_numpy
def __call__(self, x):
if x not in self.lookup:
self.lookup[x] = self._interp(x)
return self.lookup[x]
def _interp(self, x):
if self.use_numpy:
import numpy
return self.numpy.interp(x, self.xp, self.fp, self.left, self.right)
else:
return interp(x, self.xp, self.fp, self.left, self.right)
class BT1886(object):
# Adapted from ArgyllCMS xicc/xicc.c
"""BT.1886 like transfer function"""
def __init__(self, matrix, XYZbp, outoffset=0.0, gamma=2.4, apply_trc=True):
"""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)
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, Y, Z):
"""Apply BT.1886 black offset and 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)
"""
logging.debug("bt1886 XYZ in %f %f %f" % (X, Y, Z))
out = self.bwd_matrix * (X, Y, Z)
logging.debug("bt1886 RGB in %f %f %f" % (out[0], out[1], out[2]))
for j in range(3):
vv = out[j]
if self.apply_trc:
# Convert linear light to Rec709 transfer curve
if vv < 0.018:
vv = 4.5 * vv
else:
vv = 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
logging.debug("bt1886 RGB bt.1886 %f %f %f" % (out[0], out[1], out[2]))
out = list(XYZ2Lab(*[v * 100 for v in out]))
logging.debug("bt1886 Lab after Y adj. %f %f %f" % (out[0], out[1], out[2]))
# 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]
logging.debug("bt1886 Lab after wp adj. %f %f %f" % (out[0], out[1], out[2]))
out = Lab2XYZ(*out)
logging.debug("bt1886 XYZ out %f %f %f" % (out[0], out[1], out[2]))
return out
class BT2390(object):
"""Roll-off for SMPTE 2084 (PQ) according to Report ITU-R BT.2390-2 HDR TV"""
def __init__(
self,
black_cdm2,
white_cdm2,
master_black_cdm2=0,
master_white_cdm2=10000,
use_alternate_master_white_clip=True,
):
"""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)
"""
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 = specialpow(self.ominv, 1.0 / -2084) # Original minLum
self.omaxv = white_cdm2 / 10000.0 # Lmax
self.omaxi = specialpow(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 = specialpow(self.mminv, 1.0 / -2084)
self.mmaxv = master_white_cdm2 / 10000.0 # LW
mmaxi = specialpow(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 = specialpow(self.mini, -2084)
self.maxi = (self.omaxi - self.mmini) / (
self.mmaxi - self.mmini
) # Normalized maxLum
self.maxv = specialpow(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, KS, maxi, maxci=1.0):
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,
KS=None,
maxi=None,
maxci=None,
mini=None,
mmaxi=None,
mmini=None,
bpc=False,
normalize=True,
):
"""Apply roll-off (E' in, E' out)
maxci if < 1.0 applies alterante clip.
"""
if KS is None:
KS = self.KS
if maxi is None:
maxi = self.maxi
if mini is None:
mini = self.mini
if mmaxi is None:
mmaxi = self.mmaxi
if mmini is None:
mmini = self.mmini
if maxci is None:
maxci = self.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
minLum = mini
# maxLum = maxi
b = minLum
# 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
if b >= 0:
# Only for positive b i.e. minLum >= LB
p = min(1.0 / b, 4)
else:
# For negative b i.e. minLum < LB
p = 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"""
def __init__(self, matrix=None):
super(Matrix3x3, self).__init__()
if matrix:
self.update(matrix)
else:
self._reset()
def update(self, matrix):
if len(matrix) != 3:
raise ValueError("Invalid number of rows for 3x3 matrix: %i" % len(matrix))
self._reset()
while len(self):
self.pop()
for row in matrix:
if len(row) != 3:
raise ValueError(
"Invalid number of columns for 3x3 matrix: %i" % len(row)
)
self.append([])
for column in row:
self[-1].append(column)
def _reset(self):
self._inverted = None
self._transposed = None
self._rounded = {}
self._applied = {}
def __add__(self, matrix):
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):
# inplace
self.update(self.__add__(matrix))
return self
def __imul__(self, matrix):
# inplace
self.update(self.__mul__(matrix))
return self
def __mul__(self, matrix):
if not isinstance(matrix[0], (list, tuple)):
return [
matrix[0] * self[0][0]
+ matrix[1] * self[0][1]
+ matrix[2] * self[0][2],
matrix[0] * self[1][0]
+ matrix[1] * self[1][1]
+ matrix[2] * self[1][2],
matrix[0] * self[2][0]
+ matrix[1] * self[2][1]
+ matrix[2] * self[2][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):
return self.cofactors().transposed()
def applied(self, fn):
"""Apply function to every element, return new matrix"""
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):
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):
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):
# inplace
self.update(self.inverted())
def inverted(self):
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=3):
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):
self.update(self.transposed())
def transposed(self):
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
class NumberTuple(tuple):
def __repr__(self):
return "(%s)" % ", ".join(str(value) for value in self)
def round(self, digits=4):
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],
]
),
# 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),
]
optimalcolors_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():
for cache in (
"XYZ2RGB.interp",
"wp_adaption_matrix.cache",
"get_rgb_space.cache",
"get_standard_illuminant.cache",
"get_whitepoint.cache",
):
cn, ck = cache.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, 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)
def test():
for i in range(4):
if i == 0:
wp = "native"
elif i == 1:
wp = "D50"
XYZ = get_standard_illuminant(wp)
elif i == 2:
wp = "D65"
XYZ = get_standard_illuminant(wp)
elif i == 3:
XYZ = get_standard_illuminant("D65", ("ASTM E308-01",))
wp = " ".join([str(v) for v in XYZ])
print(
(
"RGB and corresponding XYZ (nominal range 0.0 - 1.0) with whitepoint %s"
% wp
)
)
for name in rgb_spaces:
spc = rgb_spaces[name]
if i == 0:
XYZ = CIEDCCT2XYZ(spc[1])
spc = spc[0], XYZ, spc[2], spc[3], spc[4]
print(
"%s 1.0, 1.0, 1.0 = XYZ" % name,
[str(round(v, 4)) for v in RGB2XYZ(1.0, 1.0, 1.0, spc)],
)
print(
"%s 1.0, 0.0, 0.0 = XYZ" % name,
[str(round(v, 4)) for v in RGB2XYZ(1.0, 0.0, 0.0, spc)],
)
print(
"%s 0.0, 1.0, 0.0 = XYZ" % name,
[str(round(v, 4)) for v in RGB2XYZ(0.0, 1.0, 0.0, spc)],
)
print(
"%s 0.0, 0.0, 1.0 = XYZ" % name,
[str(round(v, 4)) for v in RGB2XYZ(0.0, 0.0, 1.0, spc)],
)
print("")
if __name__ == "__main__":
test()
displaycal-py3-3.9.11/DisplayCAL/config.py 0000664 0000000 0000000 00000240103 14437413106 0020212 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
"""Runtime configuration and user settings parser
"""
import configparser
from decimal import Decimal
import locale
import math
import os
import pprint
import re
import string
import sys
from DisplayCAL.log import logger
if sys.platform == "win32":
import winreg
configparser.DEFAULTSECT = "Default" # Sadly, this line needs to be here.
from DisplayCAL.argyll_names import observers, viewconds, intents, video_encodings
from DisplayCAL.defaultpaths import appdata, commonappdata
if sys.platform == "win32":
from DisplayCAL.defaultpaths import commonprogramfiles
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_home,
xdg_data_home_default,
xdg_data_dirs,
)
from DisplayCAL.defaultpaths import (
autostart, # don't remove this, imported by other modules
autostart_home, # don't remove this, imported by other modules
home, # don't remove this, imported by other modules
iccprofiles,
iccprofiles_home,
)
from DisplayCAL.meta import name as appname, build, lastmod, version
from DisplayCAL.options import ascii, debug, verbose
from DisplayCAL.safe_print import enc, fs_enc, original_codepage
from DisplayCAL.util_io import StringIOu as StringIO
from DisplayCAL.util_os import (
expanduseru,
getenvu,
is_superuser,
listdir_re,
which,
)
from DisplayCAL.util_str import create_replace_function, strtr
from DisplayCAL import colormath, encodedstdio
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 os.getenv("_MEIPASS2"):
os.environ["_MEIPASS2"] = os.getenv("_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(__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/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))
datahome = 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 nee 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)
confighome = os.path.join(appdata, appbasename)
logdir = os.path.join(datahome, "logs")
if appbasename != appname:
data_dirs.extend(os.path.join(dir_, appname) for dir_ in commonappdata)
data_dirs.append(os.path.join(commonprogramfiles, appname))
data_dirs.append(datahome)
data_dirs.extend(os.path.join(dir_, appbasename) for dir_ in commonappdata)
data_dirs.append(os.path.join(commonprogramfiles, appbasename))
exe_ext = ".exe"
profile_ext = ".icm"
else:
if sys.platform == "darwin":
script_ext = ".command"
mac_create_app = True
scale_adjustment_factor = 1.0
config_sys = os.path.join(prefs, appbasename)
confighome = 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(datahome)
data_dirs.append(os.path.join(commonappdata[0], appbasename))
else:
script_ext = ".sh"
scale_adjustment_factor = 1.0
config_sys = os.path.join(xdg_config_dir_default, appbasename)
confighome = os.path.join(xdg_config_home, appbasename)
logdir = os.path.join(datahome, "logs")
if appbasename != appname:
datahome_default = os.path.join(xdg_data_home_default, appname)
if datahome_default not in data_dirs:
data_dirs.append(datahome_default)
data_dirs.extend(os.path.join(dir_, appname) for dir_ in xdg_data_dirs)
data_dirs.append(datahome)
datahome_default = os.path.join(xdg_data_home_default, appbasename)
if datahome_default not in data_dirs:
data_dirs.append(datahome_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(datahome, "storage")
resfiles = [
# 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?
patterngenerators = ("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$",)
def is_special_display(display=None, tests=virtual_displays):
if not isinstance(display, str):
display = get_display_name(display)
for test in tests:
if re.match(test, display):
return True
return False
def is_uncalibratable_display(display=None):
return is_special_display(display, uncalibratable_displays)
def is_patterngenerator(display=None):
return is_special_display(display, patterngenerators)
def is_non_argyll_display(display=None):
return is_special_display(display, non_argyll_displays)
def is_untethered_display(display=None):
return is_special_display(display, untethered_displays)
def is_virtual_display(display=None):
return is_special_display(display, virtual_displays)
def check_3dlut_format(devicename):
if get_display_name(None, True) == devicename:
if devicename == "Prisma":
return (
getcfg("3dlut.format") == "3dl"
and getcfg("3dlut.size") == 17
and getcfg("3dlut.bitdepth.input") == 10
and getcfg("3dlut.bitdepth.output") == 12
)
def getbitmap(name, display_missing_icon=True, scale=True, use_mask=False):
"""Create (if necessary) and return a named bitmap.
name 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).
"""
from DisplayCAL.wxaddons import wx
if name not in bitmaps:
parts = name.split("/")
w = 16
h = 16
size = []
if len(parts) > 1:
size = parts[-2].split("x")
if len(size) == 2:
try:
w, h = list(map(int, size))
except ValueError:
size = []
ow, oh = w, h
set_default_app_dpi()
if scale:
scale = getcfg("app.dpi") / get_default_dpi()
else:
scale = 1
if scale > 1:
# HighDPI support
w = int(round(w * scale))
h = int(round(h * scale))
if parts[-1] == "empty":
if wx.VERSION < (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)
else:
if parts[-1].startswith(appname):
parts[-1] = parts[-1].lower()
oname = parts[-1]
if "#" in oname:
# Hex format, RRGGBB or RRGGBBAA
oname, color = oname.split("#", 1)
parts[-1] = oname
else:
color = None
inverted = oname.endswith("-inverted")
if inverted:
oname = parts[-1] = oname.split("-inverted")[0]
name2x = f"{oname}@2x"
name4x = f"{oname}@4x"
path = None
for i in range(5):
if scale > 1:
if len(size) == 2:
# Icon
if i == 0:
# HighDPI support. Try scaled size
parts[-2] = "%ix%i" % (w, h)
elif i == 1:
if scale < 1.75 or scale == 2:
continue
# HighDPI support. Try @4x version
parts[-2] = "%ix%i" % (ow, oh)
parts[-1] = name4x
elif i == 2:
# HighDPI support. Try @2x version
parts[-2] = "%ix%i" % (ow, oh)
parts[-1] = name2x
elif i == 3:
# HighDPI support. Try original size times two
parts[-2] = "%ix%i" % (ow * 2, oh * 2)
parts[-1] = oname
else:
# Try original size
parts[-2] = "%ix%i" % (ow, oh)
else:
# Theme graphic
if i in (0, 3):
continue
elif i == 1:
if scale < 1.75 or scale == 2:
continue
# HighDPI support. Try @4x version
parts[-1] = name4x
elif i == 2:
# HighDPI support. Try @2x version
parts[-1] = name2x
else:
# Try original size
parts[-1] = oname
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("{}.png".format(os.path.sep.join(parts)))
if path or scale == 1:
break
if path:
bmp = wx.Bitmap(path)
if not bmp.IsOk():
path = None
if path:
img = None
if scale > 1 and i:
rescale = False
if i in (1, 2):
# HighDPI support. 4x/2x version, determine scaled size
w, h = [int(round(v / (2 * (3 - i)) * 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):
# HighDPI support. Rescale
img = bmp.ConvertToImage()
if (
not hasattr(wx, "IMAGE_QUALITY_BILINEAR")
or oname == "list-add"
):
# In case bilinear is not supported, and to prevent
# black borders after resizing for some images
quality = wx.IMAGE_QUALITY_NORMAL
elif oname 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 i == 1:
quality = wx.IMAGE_QUALITY_BICUBIC
else:
quality = wx.IMAGE_QUALITY_BILINEAR
img.Rescale(w, h, quality=quality)
factors = None
if (
not inverted
and len(parts) > 2
and parts[-3] == "icons"
and (ow, oh) != (10, 10)
and oname
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:
if not img:
img = bmp.ConvertToImage()
alpha = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNTEXT).alpha
if oname 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]
if len(factors) > 3:
alpha = factors[3]
else:
alpha = 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
if len(color) > 6:
alpha = int(color[6:8], 16) / 255.0
else:
alpha = 1.0
img = img.AdjustChannels(R, G, B, alpha)
if img:
bmp = img.ConvertToBitmap()
if not bmp.IsOk():
path = None
if not path:
print("Warning: Missing bitmap '%s'" % name)
img = wx.Image(w, h)
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=(w, h))
dc.DrawBitmap(art, 0, 0, True)
dc.SelectObject(wx.NullBitmap)
bitmaps[name] = bmp
return bitmaps[name]
def get_bitmap_as_icon(size, name, scale=True):
"""Like geticon, but return a wx.Icon instance"""
from DisplayCAL.wxaddons 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 = geticon(size, name, scale)
icon.CopyFromBitmap(bmp)
return icon
def get_argyll_data_dir():
if getcfg("argyll.version") < "1.5.0":
argyll_data_dirname = "color"
else:
argyll_data_dirname = "ArgyllCMS"
if sys.platform == "darwin" and getcfg("argyll.version") < "1.5.0":
return os.path.join(
library if is_superuser() else library_home, argyll_data_dirname
)
else:
return os.path.join(
commonappdata[0] if is_superuser() else appdata, argyll_data_dirname
)
def get_display_name(disp_index=None, include_geometry=False):
"""Return name of currently configured 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):
"""Split and return name part of 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):
"""Translate from wx display geometry to Argyll display index"""
geometry = "%i, %i, %ix%i" % tuple(geometry)
for i, display in enumerate(getcfg("displays")):
if display.find(f"@ {geometry}") > -1:
if debug:
print("[D] Found display %s at index %i" % (geometry, i))
return i
def get_display_number(display_no):
"""Translate from Argyll display index to wx display index"""
if is_virtual_display(display_no):
return 0
from DisplayCAL.wxaddons 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 = "%i, %i, %ix%i" % tuple(wx.Display(i).Geometry)
if display.endswith(f"@ {geometry}"):
if debug:
print(f"[D] Found display {geometry} at index {i}")
return i
return 0
def get_display_rects():
"""Return the Argyll enumerated display coordinates and sizes"""
from DisplayCAL.wxaddons 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, name):
"""Return a wx.IconBundle with given icon sizes"""
from DisplayCAL.wxaddons import wx
iconbundle = wx.IconBundle()
if not sizes:
# Assume ICO format
pth = get_data_path("theme/icons/%s.ico" % name)
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():
"""Return name of currently configured 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, percent=10):
"""return measurement area size adjusted for percentage of screen area"""
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 geticon(size, name, scale=True, use_mask=False):
"""Convenience function for getbitmap('theme/icons//')."""
return getbitmap(
"theme/icons/%(size)sx%(size)s/%(name)s" % {"size": size, "name": name},
scale=scale,
use_mask=use_mask,
)
def get_data_path(relpath, rex=None):
"""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.
"""
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]
if pth != "ref":
curpath = os.path.join(dir_, pth)
else:
curpath = dir_
if os.path.exists(curpath):
curpath = os.path.normpath(curpath)
if os.path.isdir(curpath):
try:
filelist = listdir_re(curpath, rex)
except Exception as exception:
print(
"Error - directory '%s' listing failed: %s"
% (curpath, 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():
if sys.platform == "darwin":
return 72.0
else:
return 96.0
def runtimeconfig(pyfile):
"""Configure remaining runtime options and return runtype.
You need to pass in a path to the calling script (e.g. use the __file__
attribute).
"""
# global safe_log
from DisplayCAL.log import setup_logging
setup_logging(logdir, pyname, pyext, confighome=confighome)
if debug:
print("[D] pydir:", pydir)
if isapp:
runtype = ".app"
elif isexe:
if 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)
if debug:
print(
"[D] dirname(os.path.abspath(sys.argv[0])):",
os.path.dirname(os.path.abspath(sys.argv[0])),
)
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_)
if 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}")
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]
]
)
if 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
# User settings
cfg = configparser.RawConfigParser()
cfg["Default"] = {}
cfg.optionxform = str
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",
"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": "No copyright. Created with %s %s and ArgyllCMS" % (appname, version),
"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.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_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) # or
# (sys.platform == "win32" and
# sys.getwindowsversion() >= (6, ))
else "u", # Linux, OSX
"profile.license": "Public Domain",
"profile.load_on_login": 1,
"profile.name": " ".join(
[
"%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": ";".join(["*"]),
"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(
[
"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": ";".join(["CalClient.exe"]),
"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,
"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.getdefaultlocale()
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():
for testcharts in list(testchart_defaults.values()):
for chart in [value for value in list(testcharts.values()) if value != "auto"]:
resfiles.append(os.path.join("ti1", chart))
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, fallback=True, raw=False, cfg=cfg):
"""Get and return an option value from the configuration.
If fallback evaluates to True and the option is not set,
return its default value.
"""
if name == "profile.name.expanded" and is_ccxx_testchart():
name = "measurement.name.expanded"
value = None
hasdef = name in defaults
if hasdef:
defval = defaults[name]
deftype = type(defval)
if cfg.has_option(configparser.DEFAULTSECT, name):
try:
value = cfg.get(configparser.DEFAULTSECT, name)
except UnicodeDecodeError:
pass
else:
# Check for invalid types and return default if wrong type
if raw:
pass
elif (
(name != "trc" or value not in valid_values["trc"])
and hasdef
and deftype in (Decimal, int, float)
):
try:
value = deftype(value)
except ValueError:
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
elif name.startswith("dimensions.measureframe"):
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])
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]:
if debug:
print("Invalid config value for %s: %s" % (name, value), end=" ")
value = None
elif name == "copyright":
# Make sure DisplayCAL and Argyll version are up-to-date
pattern = re.compile(
r"(%s(?:\s*v(?:ersion|\.)?)?\s*)\d+(?:\.\d+)*" % appname, re.I
)
repl = create_replace_function("\\1%s", version)
value = re.sub(pattern, repl, value)
if appbasename != appname:
pattern = re.compile(
r"(%s(?:\s*v(?:ersion|\.)?)?\s*)\d+(?:\.\d+)*" % appbasename,
re.I,
)
repl = create_replace_function("\\1%s", version)
value = re.sub(pattern, repl, value)
pattern = re.compile(
r"(Argyll(?:\s*CMS)?)((?:\s*v(?:ersion|\.)?)?\s*)\d+(?:\.\d+)*",
re.I,
)
if defval.split()[-1] != "CMS":
repl = create_replace_function("\\1\\2%s", defval.split()[-1])
else:
repl = "\\1"
value = re.sub(pattern, repl, value)
elif 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)
if value is None:
if hasdef and fallback:
value = defval
if debug > 1:
print(name, "- falling back to", value)
else:
if debug and not hasdef:
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))
):
# colorimeter_correction_matrix_file is special because it's
# not (only) a path
if debug:
print("%s does not exist: %s" % (name, 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
if (
value.split(os.path.sep)[-3:-2] == [appname] or not os.path.isabs(value)
) and (
value.split(os.path.sep)[-2:-1] == ["presets"]
or value.split(os.path.sep)[-2:-1] == ["ref"]
or value.split(os.path.sep)[-2:-1] == ["ti1"]
):
value = os.path.join(*value.split(os.path.sep)[-2:])
value = get_data_path(value)
elif hasdef:
value = None
if not value and hasdef:
value = defval
if debug > 1:
print(name, "- falling back to", value)
elif name in ("displays", "instruments"):
if not value:
return []
value = [
strtr(
v,
[
("%{}".format(hex(ord(os.pathsep))[2:].upper()), os.pathsep),
("%25", "%"),
],
)
for v in value.split(os.pathsep)
]
return value
def hascfg(name, fallback=True, cfg=cfg):
"""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.
"""
if cfg.has_option(configparser.DEFAULTSECT, name):
return True
elif fallback:
return name in defaults
return False
def get_ccxx_testchart():
"""Get the path to the default chart for CCMX/CCSS creation"""
return get_data_path(
os.path.join("ti1", defaults["colorimeter_correction.testchart"])
)
def get_current_profile(include_display_profile=False):
"""Get the currently selected profile (if any)"""
path = getcfg("calibration.file", False)
if path:
from DisplayCAL import ICCProfile as ICCP
try:
profile = ICCP.ICCProfile(path, use_cache=True)
except (IOError, ICCP.ICCProfileInvalidError):
return
return profile
elif include_display_profile:
return get_display_profile()
def get_display_profile(display_no=None):
if display_no is None:
display_no = max(getcfg("display.number") - 1, 0)
if is_virtual_display(display_no):
return None
from DisplayCAL import ICCProfile as ICCP
try:
return ICCP.get_display_profile(display_no)
except Exception:
from DisplayCAL.log import log
print("ICCP.get_display_profile(%s):" % display_no, file=log)
standard_profiles = []
def get_standard_profiles(paths_only=False):
if not standard_profiles:
from DisplayCAL import ICCProfile as ICCP
# Reference profiles (Argyll + DisplayCAL)
ref_icc = get_data_path("ref", r"\.ic[cm]$") or []
# Other profiles installed on the system
other_icc = []
rex = 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(rex.search, basenames):
filename, ext = os.path.splitext(basename.lower())
if (
filename.endswith("_bas")
or filename.endswith("_eci")
or filename.endswith("adobergb1998")
or filename.startswith("eci-rgb")
or filename.startswith("ecirgb")
or filename.startswith("ekta space")
or filename.startswith("ektaspace")
or filename.startswith("fogra")
or filename.startswith("gracol")
or filename.startswith("iso")
or filename.startswith("lstar-")
or filename.startswith("pso")
or filename.startswith("prophoto")
or filename.startswith("psr_")
or filename.startswith("psrgravure")
or filename.startswith("snap")
or filename.startswith("srgb")
or filename.startswith("swop")
or filename
in (
"applergb",
"bestrgb",
"betargb",
"brucergb",
"ciergb",
"cie-rgb",
"colormatchrgb",
"donrgb",
"widegamutrgb",
)
):
other_icc.append(os.path.join(dirpath, basename))
for path in ref_icc + other_icc:
try:
profile = ICCP.ICCProfile(path, load=False, use_cache=True)
except EnvironmentError:
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,
black_patches=None,
single_channel_patches=None,
gray_patches=None,
multi_steps=None,
multi_bcc_steps=None,
fullspread_patches=None,
):
if white_patches is None:
white_patches = getcfg("tc_white_patches")
if black_patches is None and getcfg("argyll.version") >= "1.6":
black_patches = getcfg("tc_black_patches")
if single_channel_patches is None:
single_channel_patches = getcfg("tc_single_channel_patches")
single_channel_patches_total = single_channel_patches * 3
if gray_patches is None:
gray_patches = getcfg("tc_gray_patches")
if gray_patches == 0 and single_channel_patches > 0 and white_patches > 0:
gray_patches = 2
if multi_steps is None:
multi_steps = getcfg("tc_multi_steps")
if multi_bcc_steps is None and getcfg("argyll.version") >= "1.6":
multi_bcc_steps = getcfg("tc_multi_bcc_steps")
if fullspread_patches is None:
fullspread_patches = getcfg("tc_fullspread_patches")
total_patches = 0
if multi_steps > 1:
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
for i in range(multi_bcc_steps):
multi_values.append(str(multi_bcc_step * i))
for i in range(multi_bcc_steps * 2 - 1):
multi_bcc_values.append(str(multi_bcc_step / 2.0 * i))
else:
for i in range(multi_steps):
multi_values.append(str(multi_step * i))
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
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 get_verified_path(cfg_item_name, path=None):
"""Verify and return dir and filename for a path from the user cfg,
or a given path"""
defaultPath = path or getcfg(cfg_item_name)
defaultDir = expanduseru("~")
defaultFile = ""
if defaultPath:
if os.path.exists(defaultPath):
defaultDir, defaultFile = (
os.path.dirname(defaultPath),
os.path.basename(defaultPath),
)
elif defaults.get(cfg_item_name) and os.path.exists(defaults[cfg_item_name]):
defaultDir, defaultFile = (
os.path.dirname(defaults[cfg_item_name]),
os.path.basename(defaults[cfg_item_name]),
)
elif os.path.exists(os.path.dirname(defaultPath)):
defaultDir = os.path.dirname(defaultPath)
return defaultDir, defaultFile
def is_ccxx_testchart(testchart=None):
"""Check whether the testchart is the default chart for CCMX/CCSS creation"""
testchart = testchart or getcfg("testchart.file")
return testchart == get_ccxx_testchart()
def is_profile(filename=None, include_display_profile=False):
filename = filename or getcfg("calibration.file", False)
if filename:
if os.path.exists(filename):
from DisplayCAL import ICCProfile as ICCP
try:
ICCP.ICCProfile(filename, use_cache=True)
except (IOError, ICCP.ICCProfileInvalidError):
pass
else:
return True
elif include_display_profile:
return bool(get_display_profile())
return False
def makecfgdir(which="user", worker=None):
if which == "user":
if not os.path.exists(confighome):
try:
os.makedirs(confighome)
except Exception as exception:
print(
"Warning - could not create configuration directory '%s': %s"
% (confighome, 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 '%s': %s"
% (config_sys, exception)
)
return False
return True
cfginited = {}
def initcfg(module=None, cfg=cfg, force_load=False):
"""Initialize the configuration.
Read in settings if the configuration file exists, else create the
settings directory if nonexistent.
"""
if module:
cfgbasename = "%s-%s" % (appbasename, module)
else:
cfgbasename = appbasename
makecfgdir()
if os.path.exists(confighome) and not os.path.exists(
os.path.join(confighome, f"{cfgbasename}.ini")
):
# Set default preset
setcfg("calibration.file", defaults["calibration.file"], cfg=cfg)
# Read cfg
cfgnames = [appbasename]
if module:
cfgnames.append(cfgbasename)
else:
cfgnames.extend(
"%s-%s" % (appbasename, othermod) for othermod in ("testchart-editor",)
)
cfgroots = [confighome]
if module == "apply-profiles":
cfgroots.append(config_sys)
cfgfiles = []
for cfgname in cfgnames:
for cfgroot in cfgroots:
cfgfile = os.path.join(cfgroot, f"{cfgname}.ini")
if os.path.isfile(cfgfile):
try:
mtime = os.stat(cfgfile).st_mtime
except EnvironmentError as exception:
print("Warning - os.stat('%s') failed: %s" % (cfgfile, exception))
last_checked = cfginited.get(cfgfile)
if force_load or mtime != last_checked:
cfginited[cfgfile] = mtime
cfgfiles.append(cfgfile)
if force_load:
msg = "Force loading"
elif last_checked:
msg = "Reloading"
else:
msg = "Loading"
# logger.debug(msg, cfgfile)
print(msg, cfgfile)
# Make user config take precedence
break
if not cfgfiles:
return
if not module:
# Make most recent file take precedence
cfgfiles.sort(key=lambda cfgfile: cfginited.get(cfgfile))
try:
cfg.read(cfgfiles)
# 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%s" % "\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 and not getcfg("calibration.ambient_viewcond_adjust"):
# Reset to default
setcfg("calibration.ambient_viewcond_adjust.lux", None, cfg=cfg)
dpiset = False
def set_default_app_dpi():
"""Set application DPI"""
# Only call this after creating the wx.App object!
global dpiset
if not dpiset and not getcfg("app.dpi", False):
# HighDPI support
from DisplayCAL.wxaddons 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(
[
"gsettings",
"get",
"org.gnome.desktop.interface",
"text-scaling-factor",
],
stdin=sp.PIPE,
stdout=sp.PIPE,
stderr=sp.PIPE,
)
factor, stderr = p.communicate()
try:
txt_scale = float(factor)
except ValueError:
pass
dpi = get_default_dpi()
if txt_scale:
dpi = int(round(dpi * txt_scale))
defaults["app.dpi"] = dpi
dpiset = True
def get_hidpi_scaling_factor():
if sys.platform in ("darwin", "win32"):
return 1.0 # Handled via app DPI
else:
# Linux
from DisplayCAL.util_os import which
if which("xrdb"):
import subprocess as sp
p = sp.Popen(
["xrdb", "-query"], stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE
)
# Format: 'Xft.dpi: 192'
stdout, stderr = 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
factor = None
# XDG_CURRENT_DESKTOP delimiter is colon (':')
desktop = os.getenv("XDG_CURRENT_DESKTOP", "").split(":")
if desktop[0] == "KDE":
# 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 screen_scale_factors:
from DisplayCAL.wxaddons import wx
match = False
app = wx.GetApp()
if app:
from DisplayCAL import RealDisplaySizeMM as RDSMM
if not RDSMM._displays:
RDSMM.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
if "=" in item:
name, factor = item.split("=", 1)
else:
name, factor = None, item
for display in RDSMM._displays:
if display.get("pos") != pos or display.get("size") != size:
# No match
continue
if name and display.get("xrandr_name") != name:
# No match
continue
# Match found
match = True
break
if match:
break
if not match:
# Use first one
factor = screen_scale_factors[0].split("=")[-1]
if not factor and which("gsettings"):
# GNOME
import subprocess as sp
p = sp.Popen(
["gsettings", "get", "org.gnome.desktop.interface", "scaling-factor"],
stdin=sp.PIPE,
stdout=sp.PIPE,
stderr=sp.PIPE,
)
# Format: 'unint32 1'
stdout, stderr = p.communicate()
split = stdout.split()
if split:
factor = split[-1]
if factor is not None:
try:
factor = float(factor)
except ValueError:
factor = None
return factor
def setcfg(name, value, cfg=cfg):
"""Set an option value in the configuration."""
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, "%{}".format(hex(ord(os.pathsep))[2:].upper())),
],
)
for v in value
)
cfg.set(configparser.DEFAULTSECT, name, value)
def setcfg_cond(condition, name, value, set_if_backup_exists=False, restore=True):
"""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
"""
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="user", worker=None, module=None, options=(), cfg=cfg):
"""Write configuration file.
which: 'user' or 'system'
worker: worker instance if ``which == 'system'``
"""
if module:
cfgbasename = "%s-%s" % (appbasename, module)
else:
cfgbasename = 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(confighome, f"{cfgbasename}.ini")
try:
io = StringIO()
cfg.write(io)
io.seek(0)
lines = io.read().strip("\n").split("\n")
if options:
optionlines = []
for optionline in lines[1:]:
for option in options:
if optionline.startswith(option):
optionlines.append(optionline)
else:
optionlines = lines[1:]
# Sorting works as long as config has only one section
lines = lines[:1] + sorted(optionlines)
cfgfile = open(cfgfilename, "wb")
cfgfile.write((os.linesep.join(lines) + os.linesep).encode())
cfgfile.close()
except Exception as exception:
print(
"Warning - could not write user configuration file "
"'%s': %s" % (cfgfilename, exception)
)
return False
else:
# system-wide config - only stores essentials ie. Argyll directory
cfgfilename1 = os.path.join(confighome, f"{cfgbasename}.local.ini")
cfgfilename2 = os.path.join(config_sys, f"{cfgbasename}.ini")
if sys.platform == "win32":
cfgfilename = cfgfilename2
else:
cfgfilename = cfgfilename1
try:
cfgfile = open(cfgfilename, "wb")
if getcfg("argyll.dir"):
cfgfile.write(
(
"%s%s"
% (
os.linesep.join(
[
"[Default]",
"%s = %s" % ("argyll.dir", getcfg("argyll.dir")),
]
),
os.linesep,
)
).encode()
)
cfgfile.close()
if sys.platform != "win32":
# on Linux and OS X, we write the file to the users'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 '%s': %s"
% (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:
cafile = cafile.encode(fs_enc, "replace")
if cafile:
os.environ["SSL_CERT_FILE"] = cafile
displaycal-py3-3.9.11/DisplayCAL/cubeiterator.py 0000664 0000000 0000000 00000006320 14437413106 0021436 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
class Cube3D(object):
def __init__(self, size=65, start=0, end=None):
orange = start, end
numentries = size**3
if end is None:
end = numentries
for name in ("start", "end"):
v = locals()[name]
if not isinstance(v, int):
raise TypeError(
"integer %s argument expected, got %s"
% (name, v.__class__.__name__)
)
start = self._clamp(start, 0, numentries, -1)
end = self._clamp(end, 0, numentries, -1)
for i, name in enumerate(("start", "end")):
v = locals()[name]
if v == -1:
raise ValueError("%s argument %i out of range" % (name, orange[i]))
self._size = size
self._start = start
self._len = end - start
def get(self, i, default=None):
if i < 0:
i = self._len + i
if i < 0 or i > self._len - 1:
return default
return self[i]
def index(self, xxx_todo_changeme):
(c0, c1, c2) = xxx_todo_changeme
if (c0, c1, c2) not in self:
raise ValueError("%r not in %r" % ((c0, c1, c2), self))
i = c0 * self._size**2 + c1 * self._size + c2
return int(i) - self._start
def _clamp(self, v, lower=0, upper=None, fallback=None):
if not upper:
upper = self._len
if v < lower:
if v < -upper:
v = fallback or lower
else:
v = upper + v
elif v > upper:
v = fallback or upper
return v
def __contains__(self, xxx_todo_changeme1):
(c0, c1, c2) = xxx_todo_changeme1
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):
oi = i
if i < 0:
i = self._len + i
if i < 0 or i > self._len - 1:
raise IndexError("index %i out of range" % oi)
i += self._start
return (
i // self._size // self._size,
i // self._size % self._size,
i % self._size,
)
def __getslice__(self, i, j):
i = self._clamp(i)
j = self._clamp(j)
return self.__class__(self._size, self._start + i, self._start + j)
def __len__(self):
return self._len
def __repr__(self):
return self.__class__.__name__ + "(size=%i, start=%i, end=%i)" % (
self._size,
self._start,
self._start + self._len,
)
class Cube3DIterator(Cube3D):
# This iterator is actually slightly slower especially with large cubes
# than using iter()
def __init__(self, *args, **kwargs):
Cube3D.__init__(self, *args, **kwargs)
self._next = 0
def __iter__(self):
return self
def __next__(self):
if self._next == self._len:
raise StopIteration
else:
result = self[self._next]
self._next += 1
return result
displaycal-py3-3.9.11/DisplayCAL/debughelpers.py 0000664 0000000 0000000 00000011606 14437413106 0021422 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
import traceback
from DisplayCAL import config
from DisplayCAL.config import fs_enc
from DisplayCAL.log import logbuffer
from DisplayCAL.meta import name as appname, wx_recversion
from DisplayCAL.options import debug
from DisplayCAL.util_str import box
wxEventTypes = {}
def getevtobjname(event, window=None):
"""Get and return the event object's name."""
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):
"""Get and return the event object's type."""
if not wxEventTypes:
from DisplayCAL.wxaddons import wx
try:
for name in dir(wx):
if name.find("EVT_") == 0:
attr = getattr(wx, name)
if hasattr(attr, "evtType"):
wxEventTypes[attr.evtType[0]] = name
except Exception:
pass
typeId = event.GetEventType()
if typeId in wxEventTypes:
return wxEventTypes[typeId]
def handle_error(error, parent=None, silent=False, tb=True):
"""Log an error string and show an error dialog."""
traceback.print_exc()
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, EnvironmentError)
or not getattr(error, "filename", None)
)
):
# Print a traceback if in debug mode, for non environment errors, and
# for environment errors not related to files
errstr, tbstr = (str(v) for v in (error, tbstr))
msg = "\n\n".join((errstr, tbstr))
if msg.startswith(errstr):
print(box(tbstr))
else:
print(box(msg))
else:
msg = str(error)
print(box(msg))
if not silent:
try:
from DisplayCAL.wxaddons import wx
if wx.VERSION < wx_recversion:
msg += (
"\n\nWARNING: Your version of wxPython (%s) is outdated "
"and no longer supported. You should consider updating "
"to wxPython %s or newer."
% (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
if parent is None:
parent = wx.GetActiveWindow()
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()
except Exception as exception:
traceback.print_exc()
print("Warning: handle_error():", str(exception))
def print_callstack():
"""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):
pass
class Error(Exception):
pass
class Info(UserWarning):
pass
class UnloggedError(Error):
pass
class UnloggedInfo(Info):
pass
class UnloggedWarning(UserWarning):
pass
class DownloadError(Error):
def __init__(self, *args):
Error.__init__(self, *args[:-1])
self.url = args[1]
class UntracedError(Error):
pass
class Warn(UserWarning):
pass
displaycal-py3-3.9.11/DisplayCAL/defaultpaths.py 0000664 0000000 0000000 00000023312 14437413106 0021432 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
import os
import sys
if sys.platform not in ("darwin", "win32"):
# Linux
import codecs
import locale
import gettext
LOCALEDIR = os.path.join(sys.prefix, "share", "locale")
elif sys.platform == "win32":
try:
from win32com.shell.shell import SHGetSpecialFolderPath
from win32com.shell.shellcon import (
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,
)
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(hwndOwner, nFolder, create=0):
"""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, waccess
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(
"FATAL - Could not get/create user application data folder: %s" % 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: %s"
% exception
)
library = commonappdata[0]
try:
commonprogramfiles = SHGetSpecialFolderPath(0, CSIDL_PROGRAM_FILES_COMMON, 1)
except Exception as exception:
raise Exception(
"FATAL - Could not get/create common program files folder: %s" % 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("FATAL - Could not get system folder: %s" % exception)
iccprofiles_home = iccprofiles
try:
programs = SHGetSpecialFolderPath(0, CSIDL_PROGRAMS, 1)
except Exception:
programs = None
try:
commonprograms = [SHGetSpecialFolderPath(0, CSIDL_COMMON_PROGRAMS, 1)]
except Exception:
commonprograms = []
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")
commonprograms = []
else:
# Linux
class XDG:
cache_home = getenvu("XDG_CACHE_HOME", expandvarsu("$HOME/.cache"))
config_home = getenvu("XDG_CONFIG_HOME", expandvarsu("$HOME/.config"))
config_dir_default = "/etc/xdg"
config_dirs = list(
map(
os.path.normpath,
getenvu("XDG_CONFIG_DIRS", config_dir_default).split(os.pathsep),
)
)
if config_dir_default not in config_dirs:
config_dirs.append(config_dir_default)
data_home_default = expandvarsu("$HOME/.local/share")
data_home = getenvu("XDG_DATA_HOME", data_home_default)
data_dirs_default = "/usr/local/share:/usr/share:/var/lib"
data_dirs = list(
map(
os.path.normpath,
getenvu("XDG_DATA_DIRS", data_dirs_default).split(os.pathsep),
)
)
data_dirs.extend(
list(
filter(
lambda data_dir, data_dirs=data_dirs: data_dir not in data_dirs,
data_dirs_default.split(os.pathsep),
)
)
)
@staticmethod
def set_translation(obj):
locale_dir = LOCALEDIR
if not os.path.isdir(locale_dir):
for path in XDG.data_dirs:
path = os.path.join(path, "locale")
if os.path.isdir(path):
locale_dir = path
break
# codeset is deprecated with python 3.11
try:
obj.translation = gettext.translation(
obj.GETTEXT_PACKAGE, locale_dir, codeset="UTF-8"
)
except TypeError:
try:
obj.translation = gettext.translation(
obj.GETTEXT_PACKAGE, locale_dir
)
except FileNotFoundError as exc:
print("XDG:", exc)
obj.translation = gettext.NullTranslations()
return False
except IOError as exception:
print("XDG:", exception)
obj.translation = gettext.NullTranslations()
return False
return True
@staticmethod
def is_true(s):
return s == "1" or s.startswith("True") or s.startswith("true")
@staticmethod
def get_config_files(filename):
paths = []
for xdg_config_dir in [XDG.config_home] + XDG.config_dirs:
path = os.path.join(xdg_config_dir, filename)
if os.path.isfile(path):
paths.append(path)
return paths
@staticmethod
def shell_unescape(s):
a = [c for i, c in enumerate(s) if c != "\\" or len(s) <= i + 1]
return "".join(a)
@staticmethod
def config_file_parser(f):
for line in f:
line = line.strip()
if line.startswith("#") or "=" not in line:
continue
yield tuple(s.strip() for s in line.split("=", 1))
@staticmethod
def process_config_file(path, fn):
try:
with open(path, "r") as f:
for key, value in XDG.config_file_parser(f):
fn(key, value)
except EnvironmentError as exception:
print("XDG: Couldn't read '%s':" % path, exception)
return False
return True
for name in dir(XDG):
attr = getattr(XDG, name)
if isinstance(attr, (str, list)):
locals()["xdg_" + name] = attr
del name, attr
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")
commonprograms = [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.11/DisplayCAL/demjson_compat.py 0000664 0000000 0000000 00000013046 14437413106 0021753 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-c
"""demjson 1.3 compatibility module"""
from io import StringIO
import json
import sys
DEBUG = False
def decode(txt, strict=False, encoding=None, **kw):
"""Decodes 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 convertable 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.
"""
if not strict:
# Remove comments
io = StringIO()
escape = False
prev = None
expect_comment = False
in_comment = False
comment_multiline = False
in_quote = False
write = True
for c in txt:
if DEBUG:
sys.stdout.write(c)
write = True
if c == "\\":
if DEBUG:
sys.stdout.write("")
escape = True
elif escape:
if DEBUG:
sys.stdout.write("")
escape = False
else:
if not in_quote:
if c == "/":
if expect_comment:
if DEBUG:
sys.stdout.write("")
in_comment = True
comment_multiline = False
expect_comment = False
elif in_comment and prev == "*":
if DEBUG:
sys.stdout.write("")
in_comment = False
comment_multiline = False
write = False
elif not in_comment:
if DEBUG:
sys.stdout.write("")
expect_comment = True
elif c == "*":
if expect_comment:
if DEBUG:
sys.stdout.write("")
in_comment = True
comment_multiline = True
expect_comment = False
elif expect_comment:
if DEBUG:
sys.stdout.write("")
expect_comment = False
if c == "\n":
if in_comment and not comment_multiline:
if DEBUG:
sys.stdout.write("")
in_comment = False
write = False
elif c == '"' and not in_comment:
if in_quote:
if DEBUG:
sys.stdout.write("")
in_quote = False
else:
if DEBUG:
sys.stdout.write("")
in_quote = True
if write and not expect_comment and not in_comment:
io.write(c)
prev = c
txt = io.getvalue()
if DEBUG:
sys.stdout.write("\n")
print("JSON:", txt)
return json.loads(txt, encoding=encoding, strict=strict)
def encode(obj, strict=False, compactly=True, escape_unicode=False, encoding=None):
"""Encodes 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'.
"""
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,
encoding=encoding or "utf-8",
)
displaycal-py3-3.9.11/DisplayCAL/dev/ 0000775 0000000 0000000 00000000000 14437413106 0017151 5 ustar 00root root 0000000 0000000 displaycal-py3-3.9.11/DisplayCAL/dev/__init__.py 0000664 0000000 0000000 00000000000 14437413106 0021250 0 ustar 00root root 0000000 0000000 displaycal-py3-3.9.11/DisplayCAL/dev/mocks.py 0000664 0000000 0000000 00000013212 14437413106 0020636 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
"""
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 types import ModuleType
from typing import Any, Callable, Dict, Generator, List, Tuple, Type, overload
from _pytest.monkeypatch import MonkeyPatch
from mypy_extensions import KwArg, VarArg
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,
as_property: bool,
) -> CallList:
...
@overload
@contextlib.contextmanager
def _mp_call(
monkeypatch: MonkeyPatch,
mock_class: str,
method: Any, # return value in this case
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:
"""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: Callable[[VarArg(Any), KwArg(Any)], Any] | property = 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,
call_args_list: List[Tuple[Any, ...]] | None = None,
call_kwargs_list: List[Dict[str, Any]] | None = 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 (
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)
yield calls
m_name = f"{mock_class.__name__}.{method}"
assert_calls(call_count, call_args_list, call_kwargs_list, calls, m_name)
monkeypatch.undo()
# 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,
call_args_list: List[Tuple[Any, ...]] | None = None,
call_kwargs_list: List[Dict[str, Any]] | None = 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 (
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
assert_calls(call_count, call_args_list, call_kwargs_list, calls, m_name)
monkeypatch.undo()
def assert_calls(
call_count: int,
call_args_list: List[Tuple[Any, ...]] | None,
call_kwargs_list: List[Dict[str, Any]] | None,
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
), 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]
), 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]
), f"Kwargs to {m_name}: {call_kwargs} expected: {call_kwargs}"
displaycal-py3-3.9.11/DisplayCAL/display_cal.py 0000664 0000000 0000000 00003133521 14437413106 0021241 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
"""
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
"""
import sys
# Standard modules
from io import StringIO, BytesIO
import datetime
from decimal import Decimal
import json as json_module
import math
import os
import platform
import re
import shutil
import socket
import subprocess as sp
import threading
import traceback
import urllib.request
import urllib.error
import urllib.parse
import zipfile
from send2trash import send2trash
from DisplayCAL.util_dict import dict_sort
if sys.platform == "win32":
import winreg
from hashlib import md5
from time import localtime, sleep, strftime, strptime, struct_time
from zlib import crc32
# Import the useful webbrowser module for platform-independent results
import webbrowser
# Set no delay time to open the web page
webbrowser.PROCESS_CREATION_DELAY = 0
APP_IS_UPTODATE = True
# Config
from DisplayCAL import config
from DisplayCAL.config import (
appbasename,
autostart,
autostart_home,
build,
script_ext,
defaults,
enc,
exe,
exe_ext,
fs_enc,
getbitmap,
geticon,
get_ccxx_testchart,
get_current_profile,
get_display_profile,
get_data_path,
getcfg,
get_total_patches,
get_verified_path,
hascfg,
is_ccxx_testchart,
is_profile,
initcfg,
isapp,
isexe,
profile_ext,
pydir,
resfiles,
setcfg,
setcfg_cond,
writecfg,
)
# Custom modules
from DisplayCAL import CGATS
from DisplayCAL import ICCProfile as ICCP
from DisplayCAL import audio
from DisplayCAL import ccmx
from DisplayCAL import colord
from DisplayCAL import colormath
from DisplayCAL import localization as lang
from DisplayCAL import madvr
from DisplayCAL import pyi_md5pickuphelper
from DisplayCAL import report
if sys.platform == "win32":
from DisplayCAL import util_win
elif sys.platform == "darwin":
from DisplayCAL import util_mac
from DisplayCAL import wexpect
from DisplayCAL.argyll_cgats import (
cal_to_fake_profile,
can_update_cal,
ti3_to_ti1,
extract_cal_from_profile,
verify_ti1_rgb_xyz,
)
from DisplayCAL.argyll_instruments import get_canonical_instrument_name, instruments
from DisplayCAL.argyll_names import viewconds
from DisplayCAL.colormath import (
CIEDCCT2xyY,
planckianCT2xyY,
xyY2CCT,
XYZ2CCT,
XYZ2Lab,
XYZ2xyY,
)
from DisplayCAL.debughelpers import (
ResourceError,
getevtobjname,
getevttype,
handle_error,
)
from DisplayCAL.edid import pnpidcache, get_manufacturer_name
from DisplayCAL.log import log, logbuffer
from DisplayCAL.meta import (
VERSION,
VERSION_BASE,
author,
development_home_page,
name as appname,
DOMAIN,
version,
version_short,
get_latest_changelog_entry,
)
from DisplayCAL.options import (
debug,
force_skip_initial_instrument_detection,
test,
test_update,
verbose,
)
from DisplayCAL.patterngenerators import WebWinHTTPPatternGeneratorServer
try:
from DisplayCAL.chromecast_patterngenerator import (
ChromeCastPatternGenerator as CCPG,
)
except ImportError:
from types import NoneType
CCPG = NoneType
from DisplayCAL.util_decimal import float2dec, stripzeros
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 import util_x
from DisplayCAL.worker import (
Error,
Info,
UnloggedError,
UnloggedInfo,
UnloggedWarning,
Warn,
Worker,
check_create_dir,
check_file_isfile,
check_set_argyll_bin,
check_ti3,
check_ti3_criteria1,
check_ti3_criteria2,
get_arg,
get_argyll_util,
get_cfg_option_from_args,
get_options_from_cal,
get_argyll_version,
get_current_profile_path,
get_options_from_profile,
get_options_from_ti3,
make_argyll_compatible_path,
parse_argument_string,
set_argyll_bin,
show_result_dialog,
check_argyll_bin,
http_request,
FilteredStream,
_applycal_bug_workaround,
)
from DisplayCAL.wxLUT3DFrame import LUT3DFrame, LUT3DMixin
try:
from DisplayCAL.wxLUTViewer import LUTFrame
except ImportError:
LUTFrame = None
from DisplayCAL.wxMeasureFrame import MeasureFrame
try:
from DisplayCAL.wxCCXXPlot import CCXXPlot
except ImportError:
CCXXPlot = None
from DisplayCAL.wxDisplayUniformityFrame import DisplayUniformityFrame
from DisplayCAL.wxMeasureFrame import get_default_size
try:
from DisplayCAL.wxProfileInfo import ProfileInfoFrame
except ImportError:
ProfileInfoFrame = None
from DisplayCAL.wxReportFrame import ReportFrame
from DisplayCAL.wxSynthICCFrame import SynthICCFrame
from DisplayCAL.wxTestchartEditor import TestchartEditor
from DisplayCAL.wxVisualWhitepointEditor import VisualWhitepointEditor
from DisplayCAL.wxaddons import (
wx,
BetterWindowDisabler,
CustomEvent,
CustomGridCellEvent,
IdFactory,
PopupMenu,
)
from DisplayCAL.wxfixes import (
ThemedGenButton,
BitmapWithThemedButton,
set_bitmap_labels,
TempXmlResource,
wx_Panel,
PlateButton,
get_bitmap_disabled,
set_maxsize,
)
from DisplayCAL.wxwindows import (
AboutDialog,
AuiBetterTabArt,
BaseApp,
BaseFrame,
BetterStaticFancyText,
BorderGradientButton,
BitmapBackgroundPanel,
BitmapBackgroundPanelText,
ConfirmDialog,
CustomGrid,
CustomCellBoolRenderer,
FileBrowseBitmapButtonWithChoiceHistory,
FileDrop,
FlatShadedButton,
HtmlWindow,
HyperLinkCtrl,
InfoDialog,
LogWindow,
ProgressDialog,
TabButton,
TooltipWindow,
get_gradient_panel,
get_dialogs,
AutocompleteComboBox,
)
from DisplayCAL import floatspin
from DisplayCAL import wxenhancedplot as plot
from DisplayCAL import xh_fancytext
from DisplayCAL import xh_filebrowsebutton
from DisplayCAL import xh_floatspin
from DisplayCAL import xh_hstretchstatbmp
from DisplayCAL import xh_bitmapctrls
# 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
from wx import xrc
from wx.lib import delayedresult, platebtn
from wx.lib.art import flagart
from wx.lib.scrolledpanel import ScrolledPanel
def show_ccxx_error_dialog(exception, path, parent):
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 swap_dict_keys_values(mydict):
"""Swap dictionary keys and values"""
return dict([(v, k) for (k, v) in mydict.items()])
def app_update_check(parent=None, silent=False, snapshot=False, argyll=False):
"""Check for application update. Show an error dialog if a failure
occurs."""
global APP_IS_UPTODATE
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)
version_file = "Argyll/VERSION"
chglog_file = "Argyll/ChangesSummary.html"
elif snapshot:
# Snapshot
curversion_tuple = VERSION
version_file = "SNAPSHOT_VERSION"
chglog_file = "SNAPSHOT_CHANGES.html"
else:
# Stable
print(lang.getstr("update_check"))
curversion_tuple = VERSION_BASE
version_file = "VERSION"
chglog_file = "CHANGES.html"
resp = http_request(
parent,
DOMAIN,
"GET",
"/" + version_file,
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:
newversion_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=geticon(32, "dialog-error"),
log=False,
)
return
newversion_tuple = (0, 0, 0, 0)
if not argyll:
APP_IS_UPTODATE = newversion_tuple <= curversion_tuple
if newversion_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 = (
"""
%s
"""
% 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):
"""Convert all-lowercase script name to mixed-case pyw name"""
a2b = {
name + "-3dlut-maker": name + "-3DLUT-maker",
name + "-vrml-to-x3d-converter": name + "-VRML-to-X3D-converter",
name + "-eecolor-to-madvr-converter": name + "-eeColor-to-madVR-converter",
}
if script.lower().startswith(name.lower()):
pyw = name + script[len(name) :]
return a2b.get(pyw, pyw)
return script
displaycal-py3-3.9.11/DisplayCAL/multiprocess.py 0000664 0000000 0000000 00000023635 14437413106 0021507 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
from queue import Empty
import atexit
import errno
import logging
import math
import multiprocessing as mp
import multiprocessing.pool
import sys
import threading
def cpu_count(limit_by_total_vmem=True):
"""Returns 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.
"""
max_cpus = sys.maxsize
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.
try:
max_cpus = int(psutil.virtual_memory().total / (1024**3) - 1)
except Exception:
pass
try:
return max(min(mp.cpu_count(), max_cpus), 1)
except Exception:
return 1
def pool_slice(
func,
data_in,
args=None,
kwds=None,
num_workers=None,
thread_abort=None,
logfile=None,
num_batches=1,
progress=0,
):
"""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'.
"""
if args is None:
args = ()
if kwds is None:
kwds = {}
from DisplayCAL.config import getcfg
if num_workers is None:
num_workers = cpu_count()
num_workers = max(min(int(num_workers), len(data_in)), 1)
max_workers = getcfg("multiprocessing.max_cpus")
if max_workers:
num_workers = min(num_workers, max_workers)
if num_workers == 1 or not num_batches:
# Splitting the workload into batches only makes sense if there are
# multiple workers
num_batches = 1
chunksize = float(len(data_in)) / (num_workers * num_batches)
if chunksize < 1:
num_batches = 1
chunksize = float(len(data_in)) / num_workers
if num_workers > 1:
Pool = 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 = manager.Queue
else:
# Do it all in in the main thread of the current instance
Pool = FakePool
manager = None
Queue = FakeQueue
if thread_abort is not None:
thread_abort_event = thread_abort.event
else:
thread_abort_event = None
progress_queue = Queue()
if logfile:
def progress_logger(num_workers, progress=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 IOError:
break
except EOFError:
eof_count += 1
if eof_count == num_workers:
break
perc = round(progress / num_workers)
if perc > prevperc:
logfile.write("\r%i%%" % perc)
prevperc = perc
threading.Thread(
target=progress_logger,
args=(num_workers * num_batches, progress * num_workers * num_batches),
name="ProcessProgressLogger",
group=None,
).start()
pool = Pool(num_workers)
results = []
start = 0
for batch in range(num_batches):
for i in range(batch * num_workers, (batch + 1) * num_workers):
end = int(math.ceil(chunksize * (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
# 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(object):
def __init__(self, func, exit=False):
self.func = func
self.exit = exit
def __call__(self, data, thread_abort_event, progress_queue, *args, **kwds):
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().
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(object):
"""Wrap 'func' with optional arguments.
To be used as function argument for Pool.map
"""
def __init__(self, func, *args, **kwds):
self.func = WorkerFunc(func)
self.args = args
self.kwds = kwds
def __call__(self, iterable):
return self.func(iterable, *self.args, **self.kwds)
class NonDaemonicProcess(mp.Process):
@property
def daemon(self):
return False
@daemon.setter
def daemon(self, daemonic):
return
class NonDaemonicPool(mp.pool.Pool):
"""Pool that has non-daemonic workers"""
def Process(self, *args, **kwargs):
# Process is a function after Python 3.7+
# Process = NonDaemonicProcess -- This will not work with Python3.7+
proc = super(NonDaemonicPool, self).Process(*args, **kwargs)
proc.__class__ = NonDaemonicProcess # TODO: This is not cool, find a better way
# of doing it.
return proc
class FakeManager(object):
"""Fake manager"""
def Queue(self):
return FakeQueue()
def Value(self, typecode, *args, **kwds):
return mp.managers.Value(typecode, *args, **kwds)
def shutdown(self):
pass
class FakePool(object):
"""Fake pool."""
def __init__(
self, processes=None, initializer=None, initargs=(), maxtasksperchild=None
):
pass
def apply_async(self, func, args, kwds):
return Result(func(*args, **kwds))
def close(self):
pass
def join(self):
pass
def map(self, func, iterable, chunksize=None):
return func(iterable)
def terminate(self):
pass
class FakeQueue(object):
"""Fake queue."""
def __init__(self):
self.queue = []
def get(self, block=True, timeout=None):
try:
return self.queue.pop()
except Exception:
raise Empty
def join(self):
pass
def put(self, item, block=True, timeout=None):
self.queue.append(item)
class Result(object):
"""Result proxy."""
def __init__(self, result):
self.result = result
def get(self):
"""Return result.
Returns:
WorkerFunc: WorkerFunc instance as the result.
"""
return self.result
displaycal-py3-3.9.11/DisplayCAL/network.py 0000664 0000000 0000000 00000011606 14437413106 0020442 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
import errno
import os
import socket
import urllib.request
import urllib.error
import urllib.parse
from DisplayCAL import localization as lang
from DisplayCAL.util_str import safe_str
def get_network_addr():
"""Tries 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(("8.8.8.8", 53))
return s.getsockname()[0] # Return network address
finally:
s.close()
def get_valid_host(hostname=None):
"""Tries to verify the hostname by resolving to an IPv4 address.
Both hostname with and without .local suffix will be tried if necessary.
Returns a tuple 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, hostname + ".local")
while hostnames:
hostname = hostnames.pop()
try:
addr = socket.gethostbyname(hostname)
except socket.error:
if not hostnames:
raise
else:
return hostname, addr
class LoggingHTTPRedirectHandler(urllib.request.HTTPRedirectHandler):
"""Like urllib2.HTTPRedirectHandler, but logs redirections"""
# 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, fp, code, msg, headers):
# 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
# 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"""
def http_error_302(self, req, fp, code, msg, headers):
# 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 + " - Redirection to url '%s' is not allowed" % newurl,
headers,
fp,
)
http_error_301 = http_error_303 = http_error_307 = http_error_302
class ScriptingClientSocket(socket.socket):
def __del__(self):
self.disconnect()
def __enter__(self):
return self
def __exit__(self, etype, value, tb):
self.disconnect()
def __init__(self):
socket.socket.__init__(self)
self.recv_buffer = ""
def disconnect(self):
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 socket.error as exception:
if exception.errno != errno.ENOTCONN:
print(exception)
self.close()
def get_single_response(self):
# Buffer received data until EOT (response end marker) and return
# single response (additional data will still be in the buffer)
while "\4" not in self.recv_buffer:
incoming = self.recv(4096)
if incoming == "":
raise socket.error(lang.getstr("connection.broken"))
self.recv_buffer += incoming
end = self.recv_buffer.find("\4")
single_response = self.recv_buffer[:end]
self.recv_buffer = self.recv_buffer[end + 1:]
return str(single_response)
def send_command(self, command):
# Automatically append newline (command end marker)
self.sendall(safe_str(command, "UTF-8") + "\n")
displaycal-py3-3.9.11/DisplayCAL/options.py 0000664 0000000 0000000 00000004466 14437413106 0020452 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
"""
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.11/DisplayCAL/patterngenerators.py 0000664 0000000 0000000 00000053743 14437413106 0022530 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
from socketserver import TCPServer
from socket import (
AF_INET,
SHUT_RDWR,
SO_BROADCAST,
SO_REUSEADDR,
SOCK_DGRAM,
SOCK_STREAM,
SOL_SOCKET,
error,
gethostname,
gethostbyname,
socket,
timeout,
)
from time import sleep
import errno
import http.client
import json
import select
import struct
import sys
import threading
import urllib.request
import urllib.error
import urllib.parse
from DisplayCAL import localization as lang
from DisplayCAL.network import get_network_addr
from DisplayCAL.util_http import encode_multipart_formdata
from DisplayCAL import webwin
_lock = threading.RLock()
def _eintr_retry(func, *args):
"""restart a system call interrupted by EINTR"""
while True:
try:
return func(*args)
except (OSError, select.error) as e:
if e.args[0] != errno.EINTR:
raise
def _shutdown(sock, addr):
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 error as exception:
if exception.errno != errno.ENOTCONN:
print("PatternGenerator: SHUT_RDWR for %s:%i failed:" % addr[:2], exception)
sock.close()
class GenHTTPPatternGeneratorClient(object):
"""Generic pattern generator client using HTTP REST interface"""
def __init__(self, host, port, bits, use_video_levels=False, logfile=None):
self.host = host
self.port = port
self.bits = bits
self.use_video_levels = use_video_levels
self.logfile = logfile
def wait(self):
self.connect()
def __del__(self):
self.disconnect_client()
def _request(self, method, url, params=None, headers=None, validate=None):
try:
self.conn.request(method, url, params, headers or {})
resp = self.conn.getresponse()
except (error, 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)
else:
raise http.client.HTTPException("%s %s" % (resp.status, resp.reason))
def _shutdown(self):
# Override this method in subclass!
pass
def _validate(self, resp, url, validate):
# Override this method in subclass!
pass
def connect(self):
self.ip = gethostbyname(self.host)
self.conn = http.client.HTTPConnection(self.ip, self.port)
try:
self.conn.connect()
except (error, http.client.HTTPException):
del self.conn
raise
def disconnect_client(self):
self.listening = False
if hasattr(self, "conn"):
self._shutdown()
self.conn.close()
del self.conn
def send(
self,
rgb=(0, 0, 0),
bgrgb=(0, 0, 0),
bits=None,
use_video_levels=None,
x=0,
y=0,
w=1,
h=1,
):
rgb, bgrgb, bits = self._get_rgb(rgb, bgrgb, bits, use_video_levels)
# Override this method in subclass!
# raise NotImplementedError
class GenTCPSockPatternGeneratorServer(object):
"""Generic pattern generator server using TCP sockets"""
def __init__(self, port, bits, use_video_levels=False, logfile=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):
self.listening = True
if self.logfile:
try:
host = get_network_addr()
except error:
host = gethostname()
self.logfile.write(
lang.getstr("connection.waiting") + (" %s:%s\n" % (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):
self.disconnect_client()
self.socket.close()
def _get_rgb(self, rgb, bgrgb, bits=None, use_video_levels=None):
"""The RGB range should be 0..1"""
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):
self.listening = False
if hasattr(self, "conn"):
try:
self.conn.shutdown(SHUT_RDWR)
except error 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=(0, 0, 0), bgrgb=(0, 0, 0), use_video_levels=None, x=0, y=0, w=1, h=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"""
def __init__(self, host, port=80, use_video_levels=False, logfile=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("'
''
''
"" % tuple(rgb + [x, y, w, h])
)
self.conn.sendall("%s%s" % (struct.pack(">I", len(xml)), xml))
class ResolveCMPatternGeneratorServer(GenTCPSockPatternGeneratorServer):
def __init__(self, port=20002, bits=10, use_video_levels=False, logfile=None):
GenTCPSockPatternGeneratorServer.__init__(
self, port, bits, use_video_levels, logfile
)
def send(
self,
rgb=(0, 0, 0),
bgrgb=(0, 0, 0),
bits=None,
use_video_levels=None,
x=0,
y=0,
w=1,
h=1,
):
"""Send an RGB color to the pattern generator. The RGB range should be 0..1"""
rgb, bgrgb, bits = self._get_rgb(rgb, bgrgb, bits, use_video_levels)
xml = (
''
''
''
''
"" % tuple(rgb + [bits] + bgrgb + [bits, x, y, w, h])
)
self.conn.sendall(struct.pack(">I", len(xml)) + xml.encode("utf-8"))
class WebWinHTTPPatternGeneratorServer(TCPServer, object):
def __init__(self, port, logfile=None):
self.port = port
Handler = webwin.WebWinHTTPRequestHandler
TCPServer.__init__(self, ("", port), Handler)
self.timeout = 1
self.patterngenerator = self
self._listening = threading.Event()
self.logfile = logfile
self.pattern = "#808080|#808080|0|0|1|1"
def disconnect_client(self):
self.listening = False
def handle_error(self, request, client_address):
print(
"Exception happened during processing of request from %s:%s:"
% client_address,
sys.exc_info()[1],
)
@property
def listening(self):
return self._listening.is_set()
@listening.setter
def listening(self, value):
if value:
self._listening.set()
else:
self._listening.clear()
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=(0, 0, 0),
bgrgb=(0, 0, 0),
bits=None,
use_video_levels=None,
x=0,
y=0,
w=1,
h=1,
):
pattern = [
"#%02X%02X%02X" % tuple(round(v * 255) for v in rgb),
"#%02X%02X%02X" % tuple(round(v * 255) for v in bgrgb),
"%.4f|%.4f|%.4f|%.4f" % (x, y, w, h),
]
self.pattern = "|".join(pattern)
def serve_forever(self, poll_interval=0.5):
"""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):
"""Stops 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):
self.listening = True
if self.logfile:
try:
host = get_network_addr()
except error:
host = gethostname()
self.logfile.write(
lang.getstr("webserver.waiting") + (" %s:%s\n" % (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 self.listening:
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.11/DisplayCAL/pnp.ids 0000664 0000000 0000000 00000167743 14437413106 0017713 0 ustar 00root root 0000000 0000000 3GV VR Technology Holdings Limited
3NO Shenzhen three Connaught Information Technology Co., Ltd. (3nod Group)
AAA Avolites Ltd
AAC AcerView
AAE Anatek Electronics Inc.
AAM Aava Mobile Oy
AAN AAEON Technology Inc.
AAT Ann Arbor Technologies
AAV Aava Mobile Oy
ABA ABBAHOME INC.
ABC AboCom System Inc.
ABD Allen Bradley Company
ABE Alcatel Bell
ABO D-Link Systems Inc
ABP Advansys
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
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 Electric Company 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 AMD
AMI American Megatrends Inc
AML Anderson Multimedia Communications (HK) Limited
AMN Amimon LTD.
AMO Amino Technologies PLC and Amino Communications Limited
AMP Ampere Computing
AMR AmTRAN Technology Co., Ltd.
AMS ARMSTEL, Inc.
AMT AMT International Industry
AMW AMW
AMX AMX LLC
AMZ Amazon Corporation
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.
AOC AOC
AOE Advanced Optics Electronics, Inc.
AOL America OnLine
AOT Alcatel
APA Adaptec
APC American Power Conversion
APD AppliAdata
APE Alpine Electronics, Inc.
APG Horner Electric Inc
API A Plus Info Corporation
APL Aplicom Oy
APM Applied Micro Circuits Corporation
APN Appian Tech Inc
APP Apple Computer Inc
APR Aprilia s.p.a.
APS Autologic Inc
APT Aptina Imaging Corporation
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 ARM Ltd.
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 ASUS
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 Atmel
ATN Athena Smartcard Solutions Ltd.
ATO ASTRO DESIGN, INC.
ATP Alpha-Top Corporation
ATT AT&T
ATV Office Depot, Inc.
ATX Athenix Corporation
AUG August Home, Inc.
AUI Alps Electric Inc
AUO AU Optronics
AUR Aureal Semiconductor
AUS ASUSTek COMPUTER INC
AUT AuthenTec
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.
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
BII Boeckeler Instruments Inc
BIL Billion Electric Company Ltd
BIO BioLink Technologies International, Inc.
BIT Bit 3 Computer
BLI Busicom
BLN BioLink Technologies
BLP Bloomberg L.P.
BMD Blackmagic Design
BMI Benson Medical Instruments Company
BML BIOMED Lab
BMM BMM
BMS BIOMEDISYS
BNE Bull AB
BNK Banksia Tech Pty Ltd
BNO Bang & Olufsen
BNQ BenQ Corporation
BNS Boulder Nonlinear Systems
BOB Rainy Orchard
BOE BOE
BOI NINGBO BOIGLE DIGITAL TECHNOLOGY CO.,LTD
BOO Coreboot Project
BOS Robert Bosch GmbH
BPD Micro Solutions, Inc.
BPS Barco, N.V.
BPU Best Power
BRA Braemac Pty Ltd
BRC Broadcom Corporation
BRG Bridge Information Co., Ltd
BRI Boca Research Inc
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 Bernecker & Rainer Ind-Eletronik 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
CGA Chunghwa Picture Tubes, LTD
CGS Chyron Corp
CGT congatec AG
CHA Chase Research PLC
CHC Chic Technology Corp.
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
CLT automated computer control systems
CLV Clevo Company
CLX CardLogix
CMC CMC Ltd
CMD Colorado MicroDisplay, Inc.
CMG Chenming Mold Ind. Corp.
CMH COMHEAR, INC.
CMI C-Media Electronics
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
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.
COG Cogent
COI Codec Inc.
COL Rockwell Collins, Inc.
COM Comtrol Corporation
CON Contec Company Ltd
COO coolux GmbH
COR CoreOS, Inc
COS CoStar Corporation
COT Core Technology Inc
COW Polycow Productions
COX Comrex
CPC Ciprico Inc
CPD CompuAdd
CPI Computer Peripherals Inc
CPL Capella Microsystems 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
CRN Cornerstone Imaging
CRO Extraordinary Technologies PTY Limited
CRQ Cirque Corporation
CRS Crescendo Communication Inc
CRV Cerevo Inc.
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
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.
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 Visual Product Development
DJP Maygay Machines, Ltd
DKY Datakey Inc
DLB Dolby Laboratories Inc.
DLC Diamond Lane Comm. Corporation
DLG Dialog Semiconductor PLC
DLK D-Link Systems Inc
DLL Dell, Inc.
DLT Digitelec Informatique Park Cadera
DMB Digicom Systems Inc
DMC Dune Microsystems Corporation
DMM Dimond Multimedia Systems Inc
DMN Dimension Engineering LLC
DMO Data Modul AG
DMP D&M Holdings Inc, Professional Business Company
DMS DMIST RESEARCH LTD
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
DSI Digitan Systems Inc
DSJ VR Technology Holdings Limited
DSM DSM Digital Services GmbH
DSP Domain Technology Inc
DSU Shenzhen DSO Microelectronics Co.,Ltd.
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
DXP Data Expert Corporation
DXS Signet
DYC Dycam Inc
DYM Dymo-CoStar Corporation
DYN Askey Computer Corporation
DYX Dynax Electronics (HK) Ltd
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
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
EIZ Eizo
EKA MagTek Inc.
EKC Eastman Kodak Company
EKS EKSEN YAZILIM
ELA ELAN MICROELECTRONICS CORPORATION
ELC Electro Scientific Ind
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
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 Esterline Belgium BVBA
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 Everest Semiconductor Co., Ltd.
EST Embedded Solution Technology
ESY E-Systems Inc
ETC Everton Technology Company Ltd
ETD ELAN MICROELECTRONICS CORPORATION
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
EVX Everex
EXA Exar Corporation
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
FCM Funai
FCS Focus Enhancements, Inc.
FDC Future Domain
FDD Forth Dimension Displays Ltd
FDI Future Designs, Inc.
FDT Fujitsu Display Technologies Corp.
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 Fujitsu Takamisawa Component Limited
FJS Fujitsu Spain
FJT F.J. Tieman BV
FLE ADTI Media, 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 Freescale, Inc
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
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
GHS Green Hills Software
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
GOO Google, Inc.
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 LG Electronics
GSN Grandstream Networks, Inc.
GST Graphic SystemTechnology
GSY Grossenbacher Systeme AG
GTC G2touch Co., LTD
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
GUZ Guzik Technical Enterprises
GVC GVC Corporation
GVL Global Village Communication
GWI GW Instruments
GWK Gateworks Corporation
GWY Gateway 2000
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.
HEI Hyundai
HEL Hitachi Micro Systems Europe Ltd
HER Ascom Business Systems
HET HETEC Datensysteme GmbH
HHC HIRAKAWA HEWTECH CORP.
HHI Fraunhofer Heinrich-Hertz-Institute
HIB Hibino Corporation
HIC Hitachi Information Technology Co., Ltd.
HII Harman International Industries, Inc
HIK Hikom Co., Ltd.
HIL Hilevel Technology
HIM Himax Technologies, Inc.
HIQ Kaohsiung Opto Electronics Americas, Inc.
HIS HiSilicon Technologies Co., Ltd.
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.
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 HP Inc.
HPK HAMAMATSU PHOTONICS K.K.
HPN HP Inc.
HPQ Hewlett-Packard Company
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
HSL Hansol
HSM AT&T Microelectronics
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 Enterprise
HWV Huawei Technologies Co., Inc.
HXM Hexium Ltd.
HXT Guizhou Huaxintong Semiconductor Technology Co., 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
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
ICL Fujitsu ICL
ICM Intracom SA
ICN Sanyo Icon
ICO Intel Corp
ICP ICP Electronics, Inc./iEi Technology Corp.
ICS Integrated Circuit Systems
ICV Inside Contactless
ICX ICCC A/S
IDC International Datacasting Corporation
IDE Lenovo Beijing Co. Ltd.
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
IHS IHSE GmbH
IIC ISIC Innoscan Industrial Computers A/S
III Intelligent Instrumentation
IIN IINFRA Co., Ltd
IIT Informatik Information Technologies
IKE Ikegami Tsushinki Co. Ltd.
IKN IKON
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
IMS Integrated Micro Solution Inc.
IMT Inmax Technology Corporation
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 Insyde Software
INT Intel Corporation
INV Invensense, Inc
INX Communications Supply Corporation (A division of WESCO)
INZ Best Buy
IOA CRE Technology Corporation
IOD I-O Data Device Inc
IOM Iomega
ION Inside Out Networks
IOS i-O Display System
IOT I/OTech Inc
IP3 IP3 Technology Ltd.
IPC IPC Corporation
IPD Industrial Products Design, Inc.
IPH Inphi Corporation
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
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
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.
KIO Kionix, Inc.
KIS KiSS Technology A/S
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
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
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
LAP BenQ
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
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
LHE Lung Hwa Electronics Company Ltd
LHT Lighthouse Technologies Limited
LIN Lenovo Beijing Co. Ltd.
LIP Linked IP GmbH
LIT Lithics Silicon Technology
LJX Datalogic Corporation
LKM Likom Technology Sdn. Bhd.
LLL L-3 Communications
LMG Lucent Technologies
LMI Lexmark Int'l Inc
LMP Leda Media Products
LMT Laser Master
LND Land Computer Company Ltd
LNE Linksys
LNK Link Tech Inc
LNR Linaro, Ltd.
LNT LANETCO International
LNU The Linux Foundation
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
LPL LG Philips
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 Matsushita Electric Ind. Company 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
MCH Microchip Technology Inc
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.
MCY Microdyne
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
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 MIPI Alliance
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
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
MNC Mini Micro Methods Ltd
MNI Marseille, Inc.
MNL Monorail Inc
MNP Microcom
MOC Matrix Orbital Corporation
MOD Modular Technology
MOM Momentum Data Systems
MON Daewoo
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
MPX Micropix Technologies, Ltd.
MQP MultiQ Products AB
MRA Miranda Technologies Inc
MRC Marconi Simulation & Ty-Coch Way Training
MRD MicroDisplay Corporation
MRK Maruko & Company Ltd
MRL Miratel
MRO Medikro Oy
MRT Merging Technologies
MRV Marvell Technology Group Ltd.
MSA Microsoft Corporation
MSC Mouse Systems Corporation
MSD Datenerfassungs- und Informationssysteme
MSF Microsoft Corporation
MSG MSI GmbH
MSH Microsoft Corporation
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
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 Maxim Integrated
MXL Hitachi Maxell, Ltd.
MXP Maxpeed Corporation
MXT Maxtech Corporation
MXV MaxVision Corporation
MYA Monydata
MYR Myriad Solutions Ltd
MYX Micronyx Inc
NAC Ncast Corporation
NAD NAD Electronics
NAK Nakano Engineering Co.,Ltd.
NAL Network Alchemy
NAN Nanao
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.
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
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
NVT Nuvoton Technology Corporation
NWC NW Computer Engineering
NWP NovaWeb Technologies Inc
NWS Newisys, Inc.
NXC NextCom K.K.
NXG Nexstgo Company Limited
NXP NXP Semiconductors bv.
NXQ Nexiq Technologies, Inc.
NXS Technology Nexus Secure Open Systems AB
NYC Nakayo Relecommunications, Inc.
OAK Oak Tech Inc
OAS Oasys Technology Company
OBD REALTEK Semiconductor Corp.
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.
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
OMN Omnitel
OMP OmniPreSense
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
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.
OVT OmniVision Technologies, Inc.
OWL Mediacom Technologies Pte Ltd
OXU Oxus Research S.A.
OYO Shadow Systems
OZC OZ Corporation
OZO Tribe Computer Works Inc
PAC Pacific Avionics Corporation
PAD Promotion and Display Technology Ltd.
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
PDC Polaroid
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
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.
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
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
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
QCC QuakeCom Company Ltd
QCH Metronics Inc
QCI Quanta Computer Inc
QCK Quick Corporation
QCL Quadrant Components Inc
QCO Qualcomm Inc
QCP Qualcomm Inc
QDI Quantum Data Incorporated
QDL QD Laser, Inc.
QDM Quadram
QDS Quanta Display Inc.
QEM Red Hat, 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 Raydium Semiconductor Corporation
RCE Parc d'Activite des Bellevues
RCH Reach Technology Inc
RCI RC International
RCN Radio Consult SRL
RCO Rockwell Collins
RDI Rainbow Displays, 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 Fuzhou Rockchip Electronics Co., Ltd.
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
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
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
SCB SeeCubic B.V.
SCC SORD Computer Corporation
SCD Sanyo Electric Company Ltd
SCE Sun Corporation
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)
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
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
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.
SHG Soft & Hardware development Goldammer GmbH
SHI Jiangsu Shinco Electronic Group Co., Ltd
SHP Sharp Corporation
SHR Sharp Corporation
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
SKM Guangzhou Teclast Information Technology Limited
SKT Samsung Electro-Mechanics Company Ltd
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
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 Sensel, Inc.
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 Corporation
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
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.
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
ST8 Shenzhen South-Top Computer Co., Ltd.
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
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
SVE SVEC
SVI Sun Microsystems
SVR Sensics, Inc.
SVS SVSI
SVT SEVIT Co., Ltd.
SWC Software Café
SWE Sierra Wireless
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
SZV OvisLink
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
TCA Teracue AG
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
TDK TDK USA Corporation
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.
TEX Texas Instruments
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
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
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
TMC Techmedia Computer Systems Corporation
TME AT&T Microelectronics
TMI Texas Microsystem
TMM Time Management, Inc.
TMR Taicom International Inc
TMS Trident Microsystems Ltd
TMT T-Metrics Inc.
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 Toshiba Corporation
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
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 u-blox AG
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
UND Unisys Corporation
UNE Unisys Corporation
UNF 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
USC UltraStor
USD U.S. Digital Corporation
USE U. S. Electronics Inc.
USI Universal Scientific Industrial Co., Ltd.
USR U.S. Robotics Inc
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
VBR VBrick Systems Inc.
VBT Valley Board Ltda
VCC Virtual Computer Corporation
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
VFS Validity Sensors, 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
VIR Visual Interface, Inc
VIS Visioneer
VIT Visitech AS
VIZ VIZIO, Inc
VLB ValleyBoard Ltda.
VLC VersaLogic Corporation
VLK Vislink International Ltd
VLT VideoLan Technologies
VLV Valve Corporation
VMI Vermont Microsystems
VML Vine Micros Limited
VMW VMware Inc.,
VNC Vinca 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
VSH Vishay Intertechnology, Inc.
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
VWB Vweb Corp.
WAC Wacom Tech
WAL Wave Access
WAV Wavephore
WBN MicroSoftWare
WBS WB Systemtechnik GmbH
WCI Wisecom Inc
WCO Wacom
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
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
WSD Winsider Seminars & Solutions 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 Wyse 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.
XMC Xiaomi 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
ZCM Zenith
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
inu Inovatec S.p.A.
displaycal-py3-3.9.11/DisplayCAL/postinstall.py 0000664 0000000 0000000 00000045314 14437413106 0021330 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
from io import StringIO
from subprocess import call
from os.path import basename, splitext
import os
import shutil
import sys
import traceback
from DisplayCAL.meta import name
from DisplayCAL.util_os import relpath, safe_glob, which
recordfile_name = "INSTALLED_FILES"
if not sys.stdout.isatty():
sys.stdout = StringIO()
if sys.platform == "win32":
try:
create_shortcut
# this function is only available within bdist_wininst installers
except NameError:
try:
from pythoncom import (
CoCreateInstance,
CLSCTX_INPROC_SERVER,
IID_IPersistFile,
)
from win32com.shell import shell
import win32con
except ImportError:
def create_shortcut(*args):
pass
else:
def create_shortcut(*args):
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)
try:
directory_created
# this function is only available within bdist_wininst installers
except NameError:
def directory_created(path):
pass
try:
file_created
# this function is only available within bdist_wininst installers
except NameError:
try:
import win32api
except ImportError:
def file_created(path):
pass
else:
def file_created(path):
if os.path.exists(recordfile_name):
installed_files = []
if os.path.exists(recordfile_name):
recordfile = open(recordfile_name, "r")
installed_files.extend(line.rstrip("\n") for line in recordfile)
recordfile.close()
try:
path.decode("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)
recordfile = open(recordfile_name, "w")
recordfile.write("\n".join(installed_files))
recordfile.close()
try:
get_special_folder_path
# this function is only available within bdist_wininst installers
except NameError:
try:
from win32com.shell import shell, shellcon
except ImportError:
def get_special_folder_path(csidl_string):
pass
else:
def get_special_folder_path(csidl_string):
return shell.SHGetSpecialFolderPath(
0, getattr(shellcon, csidl_string), 1
)
def postinstall(prefix=None):
if sys.platform == "darwin":
# TODO: implement
pass
elif sys.platform == "win32":
if prefix is None:
# assume we are running from bdist_wininst installer
modpath = os.path.dirname(os.path.abspath(__file__))
else:
# assume we are running from source dir,
# or from install dir
modpath = prefix
if os.path.exists(modpath):
mainicon = os.path.join(modpath, "theme", "icons", name + ".ico")
if os.path.exists(mainicon):
try:
startmenu_programs_common = get_special_folder_path(
"CSIDL_COMMON_PROGRAMS"
)
startmenu_programs = get_special_folder_path("CSIDL_PROGRAMS")
startmenu_common = get_special_folder_path("CSIDL_COMMON_STARTMENU")
startmenu = get_special_folder_path("CSIDL_STARTMENU")
except OSError:
traceback.print_exc()
return
else:
filenames = [
filename
for filename in safe_glob(
os.path.join(sys.prefix, "Scripts", 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 (startmenu_programs_common, startmenu_programs):
if path:
grppath = os.path.join(path, name)
if path == startmenu_programs:
group = relpath(grppath, startmenu)
else:
group = relpath(grppath, startmenu_common)
if not os.path.exists(grppath):
try:
os.makedirs(grppath)
except Exception:
# maybe insufficient privileges?
pass
if os.path.exists(grppath):
print(
("Created start menu group '%s' in " "%s")
% (
name,
(
str(path, "MBCS", "replace")
if type(path) != str
else path
).encode("MBCS", "replace"),
)
)
else:
print(
("Failed to create start menu group '%s' in " "%s")
% (
name,
(
str(path, "MBCS", "replace")
if type(path) != str
else path
).encode("MBCS", "replace"),
)
)
continue
directory_created(grppath)
for filename in filenames:
lnkname = splitext(basename(filename))[0]
lnkpath = os.path.join(grppath, lnkname + ".lnk")
if os.path.exists(lnkpath):
try:
os.remove(lnkpath)
except Exception:
# maybe insufficient privileges?
print(
(
"Failed to create start menu entry '%s' in "
"%s"
)
% (
lnkname,
(
str(grppath, "MBCS", "replace")
if type(grppath) != str
else grppath
).encode("MBCS", "replace"),
)
)
continue
if not os.path.exists(lnkpath):
if lnkname != "Uninstall":
tgtpath = os.path.join(modpath, filename)
try:
if lnkname == "Uninstall":
uninstaller = os.path.join(
sys.prefix, "Remove%s.exe" % name
)
if os.path.exists(uninstaller):
create_shortcut(
uninstaller,
lnkname,
lnkpath,
'-u "%s-wininst.log"'
% os.path.join(sys.prefix, name),
sys.prefix,
os.path.join(
modpath,
"theme",
"icons",
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"
),
lnkname,
lnkpath,
'"%s" uninstall '
'--record="%s"'
% (
os.path.join(
modpath, "setup.py"
),
os.path.join(
modpath, "INSTALLED_FILES"
),
),
sys.prefix,
os.path.join(
modpath,
"theme",
"icons",
name + "-uninstall.ico",
),
)
elif lnkname.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(
modpath,
"theme",
"icons",
lnkname + ".ico",
)
if not os.path.isfile(icon):
icon = mainicon
if filename.endswith(".exe"):
exe = filename
args = ""
else:
exe = os.path.join(
sys.prefix, "pythonw.exe"
)
args = '"%s"' % tgtpath
create_shortcut(
exe,
lnkname,
lnkpath,
args,
modpath,
icon,
)
else:
create_shortcut(
tgtpath, lnkname, lnkpath, "", modpath
)
except Exception:
# maybe insufficient privileges?
print(
(
"Failed to create start menu entry '%s' in "
"%s"
)
% (
lnkname,
(
str(grppath, "MBCS", "replace")
if type(grppath) != str
else grppath
).encode("MBCS", "replace"),
)
)
continue
print(
("Installed start menu entry '%s' to " "%s")
% (
lnkname,
(
str(group, "MBCS", "replace")
if type(group) != str
else group
).encode("MBCS", "replace"),
)
)
file_created(lnkpath)
installed_shortcuts.append(filename)
if installed_shortcuts == filenames:
break
else:
print("warning - '%s' not found" % icon.encode("MBCS", "replace"))
if os.path.exists(recordfile_name):
irecordfile_name = os.path.join(modpath, "INSTALLED_FILES")
irecordfile = open(irecordfile_name, "w")
irecordfile.close()
file_created(irecordfile_name)
shutil.copy2(recordfile_name, irecordfile_name)
else:
print("warning - '%s' not found" % modpath.encode("MBCS", "replace"))
else:
# Linux/Unix
if prefix is None:
prefix = sys.prefix
if which("touch"):
call(["touch", "--no-create", prefix + "/share/icons/hicolor"])
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), prefix +
# ("/share/%s/theme/icons/%sx%s/%s.png" % (name, size, size,
# name))])
call(["xdg-icon-resource", "forceupdate"])
if which("xdg-desktop-menu"):
# print "installing desktop menu entry..."
# call(["xdg-desktop-menu", "install", "--novendor", (prefix +
# "/share/%s/%s.desktop" % (name, name))])
call(["xdg-desktop-menu", "forceupdate"])
def postuninstall(prefix=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 +
# ("/share/applications/%s.desktop" % name)])
call(["xdg-desktop-menu", "forceupdate"])
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"])
def main():
prefix = None
for arg in sys.argv[1:]:
arg = arg.split("=")
if len(arg) == 2:
if 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.11/DisplayCAL/presets/ 0000775 0000000 0000000 00000000000 14437413106 0020060 5 ustar 00root root 0000000 0000000 displaycal-py3-3.9.11/DisplayCAL/presets/default.icc 0000664 0000000 0000000 00000047420 14437413106 0022173 0 ustar 00root root 0000000 0000000 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
'
]);
var result_start = this.report_html.length;
this.report_html = this.report_html.concat([
'
');
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.11/DisplayCAL/theme/cross-2px-12x12-fff.png 0000664 0000000 0000000 00000000264 14437413106 0023357 0 ustar 00root root 0000000 0000000 PNG
IHDR a tEXtSoftware Adobe ImageReadyqe< PLTEfff Ɔ{ tRNS S *IDATxb`f&0 0adB Ff`FF0` >.> IENDB` displaycal-py3-3.9.11/DisplayCAL/theme/dashed-16x2-666.png 0000664 0000000 0000000 00000000223 14437413106 0022445 0 ustar 00root root 0000000 0000000 PNG
IHDR f3 tEXtSoftware Adobe ImageReadyqe< PLTEfff s tRNS 0J IDATxb` F0`@ $
IENDB` displaycal-py3-3.9.11/DisplayCAL/theme/dropdown-arrow.png 0000664 0000000 0000000 00000000406 14437413106 0023167 0 ustar 00root root 0000000 0000000 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.11/DisplayCAL/theme/dropdown-arrow@2x.png 0000664 0000000 0000000 00000000766 14437413106 0023552 0 ustar 00root root 0000000 0000000 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.11/DisplayCAL/theme/engine_hum_loop.wav 0000664 0000000 0000000 00002224054 14437413106 0023374 0 ustar 00root root 0000000 0000000 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 [+
