From 894c6a448923dfe6ab7668d33a8a55a83a9b54b3 Mon Sep 17 00:00:00 2001 From: EyeOdin <59078314+EyeOdin@users.noreply.github.com> Date: Wed, 20 Apr 2022 06:54:07 +0100 Subject: [PATCH] Add files via upload --- pigment_o/pigment_o_docker.py | 24855 ++++++++++++++++++++++++++++++ pigment_o/pigment_o_manual.html | 208 + 2 files changed, 25063 insertions(+) create mode 100644 pigment_o/pigment_o_docker.py create mode 100644 pigment_o/pigment_o_manual.html diff --git a/pigment_o/pigment_o_docker.py b/pigment_o/pigment_o_docker.py new file mode 100644 index 0000000..d2dddaa --- /dev/null +++ b/pigment_o/pigment_o_docker.py @@ -0,0 +1,24855 @@ +# Pigment.O is a Krita plugin and it is a Color Picker and Color Mixer. +# Copyright (C) 2020 Ricardo Jeremias. +# +# 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 Modules ############################################################# +# Python Modules +import math +import random +import os +import time +import sys +# Krita Modules +from krita import * +# PyQt5 Modules +from PyQt5 import QtWidgets, QtCore, QtGui, QtSvg, uic +# Pigment.O Modules +from .pigment_o_names import * +from .pigment_o_modulo import ( + Color_Header, + Harmony_Color, + Harmony_Span, + Apply_RGB, + Panel_SWA, + Panel_UVD, + Panel_YUV, + Panel_ARD, + Panel_HSV_4, + Panel_HSL_3, + Panel_HSL_4, + Panel_HSL_4D, + Panel_HCY_4, + Panel_HUE_Circle, + Panel_GAM_Circle, + Panel_GAM_Polygon, + Panel_DOT, + Panel_OBJ, + Panel_IMG, + Channel_Linear, + Channel_Interval, + Clicks, + Mixer_Linear, + Dialog_UI, + Dialog_CR, + ) +from .pigment_o_extension import PigmentO_Extension + +#// +#\\ Global Variables ########################################################### +# Set Window Title Name +DOCKER_NAME = "Pigment.O" +# Timer +check_timer = 30 # 1000 = 1 SECOND (Zero will Disable checks) +# Pigment.O Version Date +pigment_o_version = "2022_04_20" + +# Color Space Constants +k_AAA = 255 +k_RGB = 255 # 65535 or 100 or 255 +k_CMY = 255 +k_CMYK = 255 +k_RYB = 255 +k_YYY = 255 +k_UV = 255 +k_UVD = 255 # U(horizontal) V(Vertical) Diagonal +k_HUE = 360 # Hue + Angle +k_SVL = 255 # Saturation + Value + Lightness + Chroma + Luma +k_XYZ = 255 +k_XYY = 255 +k_LUV = 255 +k_HLAB = 255 +k_LLL = 255 +k_AB = 255 +k_LCH = 255 +# Unit Constants +u_AAA = 1 / k_AAA +u_RGB = 1 / k_RGB +u_CMY = 1 / k_CMY +u_CMYK = 1 / k_CMYK +u_RYB = 1 / k_RYB +u_YYY = 1 / k_YYY +u_UV = 1 / k_UV +u_UVD = 1 / k_UVD +u_HUE = 1 / k_HUE +u_SVL = 1 / k_SVL +u_XYZ = 1 / k_XYZ +u_XYY = 1 / k_XYY +u_LUV = 1 / k_LUV +u_HLAB = 1 / k_HLAB +u_LLL = 1 / k_LLL +u_AB = 1 / k_AB +u_LCH = 1 / k_LCH +# HEX constants +hex_AAA = 100 # DO NOT TOUCH ! +hex_RGB = 255 # DO NOT TOUCH ! +hex_CMYK = 100 # DO NOT TOUCH ! +hex_YYY = 255 # DO NOT TOUCH ! +hex_UV = 255 # DO NOT TOUCH ! +hex_XYZ = 100 # DO NOT TOUCH ! +hex_LLL = 100 # DO NOT TOUCH ! +hex_AB = 128 # DO NOT TOUCH ! +# RYB angle conversion stops +cmy_step = [0, 35/360, 60/360, 120/360, 180/360, 240/360, 300/360, 1] +ryb_step = [0, 60/360, 122/360, 165/360, 218/360, 275/360, 330/360, 1] +# Kalvin Table +k_KKKmin = 1000 +k_KKKmax = 12000 +k_KKKdelta = k_KKKmax - k_KKKmin +k_KKKhalf = 6500 +k_KKKunit = 100 +kelvin_rgb = [ + [1000, 255, 56, 0], + [1100, 255, 71, 0], + [1200, 255, 83, 0], + [1300, 255, 93, 0], + [1400, 255, 101, 0], + [1500, 255, 109, 0], + [1600, 255, 115, 0], + [1700, 255, 121, 0], + [1800, 255, 126, 0], + [1900, 255, 131, 0], + [2000, 255, 138, 18], + [2100, 255, 142, 33], + [2200, 255, 147, 44], + [2300, 255, 152, 54], + [2400, 255, 157, 63], + [2500, 255, 161, 72], + [2600, 255, 165, 79], + [2700, 255, 169, 87], + [2800, 255, 173, 94], + [2900, 255, 177, 101], + [3000, 255, 180, 107], + [3100, 255, 184, 114], + [3200, 255, 187, 120], + [3300, 255, 190, 126], + [3400, 255, 193, 132], + [3500, 255, 196, 137], + [3600, 255, 199, 143], + [3700, 255, 201, 148], + [3800, 255, 204, 153], + [3900, 255, 206, 159], + [4000, 255, 209, 163], + [4100, 255, 211, 168], + [4200, 255, 213, 173], + [4300, 255, 215, 177], + [4400, 255, 217, 182], + [4500, 255, 219, 186], + [4600, 255, 221, 190], + [4700, 255, 223, 194], + [4800, 255, 225, 198], + [4900, 255, 227, 202], + [5000, 255, 228, 206], + [5100, 255, 230, 210], + [5200, 255, 232, 213], + [5300, 255, 233, 217], + [5400, 255, 235, 220], + [5500, 255, 236, 224], + [5600, 255, 238, 227], + [5700, 255, 239, 230], + [5800, 255, 240, 233], + [5900, 255, 242, 236], + [6000, 255, 243, 239], + [6100, 255, 244, 242], + [6200, 255, 245, 245], + [6300, 255, 246, 247], + [6400, 255, 248, 251], + [6500, 255, 249, 253], + [6600, 254, 249, 255], + [6700, 252, 247, 255], + [6800, 249, 246, 255], + [6900, 247, 245, 255], + [7000, 245, 243, 255], + [7100, 243, 242, 255], + [7200, 240, 241, 255], + [7300, 239, 240, 255], + [7400, 237, 239, 255], + [7500, 235, 238, 255], + [7600, 233, 237, 255], + [7700, 231, 236, 255], + [7800, 230, 235, 255], + [7900, 228, 234, 255], + [8000, 227, 233, 255], + [8100, 225, 232, 255], + [8200, 224, 231, 255], + [8300, 222, 230, 255], + [8400, 221, 230, 255], + [8500, 220, 229, 255], + [8600, 218, 229, 255], + [8700, 217, 227, 255], + [8800, 216, 227, 255], + [8900, 215, 226, 255], + [9000, 214, 225, 255], + [9100, 212, 225, 255], + [9200, 211, 224, 255], + [9300, 210, 223, 255], + [9400, 209, 223, 255], + [9500, 208, 222, 255], + [9600, 207, 221, 255], + [9700, 207, 221, 255], + [9800, 207, 220, 255], + [9900, 206, 220, 255], + [10000, 206, 218, 255], + [10100, 206, 218, 255], + [10200, 205, 217, 255], + [10300, 205, 217, 255], + [10400, 204, 216, 255], + [10500, 204, 216, 255], + [10600, 203, 215, 255], + [10700, 202, 215, 255], + [10800, 202, 214, 255], + [10900, 201, 214, 255], + [11000, 200, 213, 255], + [11100, 200, 213, 255], + [11200, 199, 212, 255], + [11300, 198, 212, 255], + [11400, 198, 212, 255], + [11500, 197, 211, 255], + [11600, 197, 211, 255], + [11700, 197, 210, 255], + [11800, 196, 210, 255], + [11900, 195, 210, 255], + [12000, 195, 209, 255]] +kelvin_illuminants = [ + [1000, ""], + [2724, "LED-V1 - phosphor-converted violet"], + [2733, "LED-B1 - phosphor-converted blue"], + [2840, "LED-RGB1 - mixing of red, green, and blue LEDs"], + [2851, "LED-BH1 - mixing of phosphor-converted blue LED and red LED (blue-hybrid)"], + [2856, "A - incandescent / tungsten"], + [2940, "F4 - warm white fluorescent"], + [2998, "LED-B2 - phosphor-converted blue"], + [3000, "F12 - Philips TL83, Ultralume 30"], + [3450, "F3 - white fluorescent"], + [4000, "F11 - Philips TL84, Ultralume 40"], + [4070, "LED-V2 - phosphor-converted violet"], + [4103, "LED-B3 - phosphor-converted blue"], + [4150, "F6 / F9 - light white fluorescent / cool white deluxe fluorescent"], + [4230, "F2 - cool white fluorescent"], + [4874, "B - obsolete, direct sunlight at noon"], + [5000, "F8 / F10 - D50 simulator, Sylvania F40 Design 50 / Philips TL85, Ultralume 50"], + [5003, "D50 - horizon light, ICC profile PCS"], + [5109, "LED-B4 - phosphor-converted blue"], + [5454, "E - equal energy"], + [5503, "D55 - mid-morning / mid-afternoon daylight"], + [6350, "F5 - daylight fluorescent"], + [6430, "F1 - daylight fluorescent"], + [6500, "F7 - D65 simulator, daylight simulator"], + [6504, "D65 - noon daylight: television, sRGB color space"], + [6598, "LED-B5 - phosphor-converted blue"], + [6774, "C - obsolete, average / North sky daylight"], + [7504, "D75 - North sky daylight"], + [9305, "D93 - high-efficiency blue phosphor monitors, BT.2035"], + [12000, ""], + ] +kelvin_xyz = { + # Illuminant - Kelvin - CIE*1931 ( X - Y - Z ) - CIE*1964 ( X - Y - Z ) + "A" : [2856, 109.850, 100.000, 35.585, 111.144, 100.000, 35.200], + "B" : [4874, 99.0927, 100.000, 85.313, 99.178, 100.000, 84.3493], + "C" : [6774, 98.074, 100.000, 118.232, 97.285, 100.000, 116.145], + "D50" : [5003, 96.422, 100.000, 82.521, 96.720, 100.000, 81.427], + "D55" : [5503, 95.682, 100.000, 92.149, 95.799, 100.000, 90.926], + "D65" : [6504, 95.047, 100.000, 108.883, 94.811, 100.000, 107.304], + "D75" : [7504, 94.972, 100.000, 122.638, 94.416, 100.000, 120.641], + "E" : [5454, 100.000, 100.000, 100.000, 100.000, 100.000, 100.000], + "F1" : [6430, 92.834, 100.000, 103.665, 94.791, 100.000, 103.191], + "F2" : [4230, 99.187, 100.000, 67.395, 103.280, 100.000, 69.026], + "F3" : [3450, 103.754, 100.000, 49.861, 108.968, 100.000, 51.965], + "F4" : [2940, 109.147, 100.000, 38.813, 114.961, 100.000, 40.963], + "F5" : [6350, 90.872, 100.000, 98.723, 93.369, 100.000, 98.636], + "F6" : [4150, 97.309, 100.000, 60.191, 102.148, 100.000, 62.074], + "F7" : [6500, 95.044, 100.000, 108.755, 95.792, 100.000, 107.687], + "F8" : [5000, 96.413, 100.000, 82.333, 97.115, 100.000, 81.135], + "F9" : [4150, 100.365, 100.000, 67.868, 102.116, 100.000, 67.826], + "F10" : [5000, 96.174, 100.000, 81.712, 99.001, 100.000, 83.134], + "F11" : [4000, 100.966, 100.000, 64.370, 103.866, 100.000, 65.627], + "F12" : [3000, 108.046, 100.000, 39.228, 111.428, 100.000, 40.353], + } +# Luma Coefficients (ITU-R BT.601) +luma_r = 0.299 +luma_b = 0.114 +luma_g = 1 - luma_r - luma_b # 0.587 +luma_pr = 1.402 +luma_pb = 1.772 +gamma_y = 2.2 # Y (Luma) +gamma_l = 2.4 # linear to standard RGB conversion + +# Numbers +zero = 0 +half = 0.5 +unit = 1 +two = 2 +max_val = 16777215 + +#// + + +# Create Docker +class PigmentO_Docker(DockWidget): + """ + Docker Color Picker and Mixer. + """ + + #\\ Initialize the Docker Window ########################################### + def __init__(self): + super(PigmentO_Docker, self).__init__() + + # Construct + self.Variables() + self.User_Interface() + self.Connects() + self.Menu_Shrink() + + # Modules and Connections + self.Header() + self.Harmonys() + self.Color_ofthe_Day() + self.Panels() + self.Gamut() + self.Dots() + self.Object() + self.Images() + self.Channels() + self.Palette() + self.Mixers() + self.History() + self.Style() + self.Extension() + self.Pulse() + + # Settings + self.Version_Settings() + + def Variables(self): + # State + self.timer_state = 0 + self.fill = False + # Debugging + self.counter = 0 + # UI variables + self.ui_05 = 5 + self.ui_10 = 10 + self.ui_15 = 15 + self.ui_17 = 17 + self.ui_20 = 20 + self.ui_25 = 25 + self.ui_30 = 30 + self.ui_35 = 35 + self.ui_40 = 40 + self.ui_45 = 45 + self.ui_47 = 47 + self.ui_50 = 50 + self.ui_55 = 55 + self.ui_60 = 60 + self.ui_65 = 65 + self.ui_70 = 70 + self.ui_75 = 75 + self.ui_80 = 80 + self.ui_85 = 85 + self.ui_90 = 90 + self.ui_95 = 95 + self.ui_100 = 100 + self.menu_update = 0 + # Color Reference + self.color_white = [1, 1, 1] + self.color_grey = [0.5, 0.5, 0.5] + self.color_black = [0, 0, 0] + # Style Sheets + self.bg_alpha = str("background-color: rgba(0, 0, 0, 50); ") + self.bg_unseen = str("background-color: rgba(0,0,0,0);") + self.bg_white = str("background-color: rgba(255, 255, 255, 255); border: 1px solid rgba(56, 56, 56, 255) ;") + self.bg_black = str("background-color: rgba(0, 0, 0, 255); border: 1px solid rgba(56, 56, 56, 255) ;") + # Luma Coefficients - ITU-R BT.601 + self.luma_r = luma_r + self.luma_b = luma_b + self.luma_g = 1 - luma_r - luma_b # 0.587 + self.luma_pr = luma_pr + self.luma_pb = luma_pb + self.gamma_y = gamma_y + self.gamma_l = gamma_l + # Interface + self.harmony_status = 0 + self.harmony_slot = zero + def User_Interface(self): + # Operating System + self.OS = str(QSysInfo.kernelType()) # WINDOWS=winnt & LINUX=linux + # Krita Version + self.krita_version = str(Krita.instance().version()) + # Window Title + self.setWindowTitle(DOCKER_NAME) + # Path Name + self.dir_name = str(os.path.dirname(os.path.realpath(__file__))) + + # Pigmento Widget Docker + self.window = QWidget() + self.layout = uic.loadUi(self.dir_name + '/pigment_o_docker.ui', self.window) + self.setWidget(self.window) + # Pigmento Dialog Settings + self.dialog = Dialog_UI(self) + self.dialog.accept() # Hides the Dialog + # Pigmento Dialog Copyright + self.copyright = Dialog_CR(self) + self.copyright.accept() + + # Theme Variables + self.krita_value = 59 + self.krita_contrast = 196 + self.gray_natural = self.HEX_6string(self.krita_value/255,self.krita_value/255,self.krita_value/255) + self.gray_contrast = self.HEX_6string(self.krita_contrast/255,self.krita_contrast/255,self.krita_contrast/255) + def Connects(self): + # Dialog 1 + self.dialog.har.toggled.connect(self.Menu_HARMONY) + self.dialog.pan.toggled.connect(self.Menu_PANEL) + self.dialog.cha.toggled.connect(self.Menu_CHANNEL) + self.dialog.cor.toggled.connect(self.Menu_COR) + self.dialog.mix.toggled.connect(self.Menu_MIX) + self.dialog.his.toggled.connect(self.Menu_HISTORY) + # Dialog 2 + self.dialog.har_rule.currentTextChanged.connect(self.HARMONY_Rule) + self.dialog.har_edit.toggled.connect(self.HARMONY_Edit) + + self.dialog.cotd_date.clicked.connect(self.Color_ofthe_Day) + + self.dialog.pan_index.currentTextChanged.connect(self.Menu_PANEL) + self.dialog.hue_secondary.currentTextChanged.connect(self.Menu_Hue_Secondary) + self.dialog.gam_space.currentTextChanged.connect(self.GAM_Space) + self.dialog.gam_shape.currentTextChanged.connect(self.GAM_Shape) + self.dialog.gam_reset.clicked.connect(self.GAM_Reset) + self.dialog.dot_interpolation.currentTextChanged.connect(self.DOT_Interpolation) + self.dialog.dot_resolution.currentTextChanged.connect(self.DOT_Resolution) + self.dialog.dot_set.toggled.connect(self.DOT_SET) + self.dialog.obj_index.currentTextChanged.connect(self.OBJ_Index) + self.dialog.obj_set.toggled.connect(self.OBJ_SET) + self.dialog.img_file.clicked.connect(self.IMG_File) + self.dialog.img_grayscale.toggled.connect(self.IMG_GrayScale) + # Dialog 3 + self.dialog.aaa.toggled.connect(self.Menu_AAA) + self.dialog.rgb.toggled.connect(self.Menu_RGB) + self.dialog.cmy.toggled.connect(self.Menu_CMY) + self.dialog.cmyk.toggled.connect(self.Menu_CMYK) + self.dialog.ryb.toggled.connect(self.Menu_RYB) + self.dialog.yuv.toggled.connect(self.Menu_YUV) + self.dialog.kkk.toggled.connect(self.Menu_KKK) + self.dialog.ard.toggled.connect(self.Menu_ARD) + self.dialog.hsv.toggled.connect(self.Menu_HSV) + self.dialog.hsl.toggled.connect(self.Menu_HSL) + self.dialog.hcy.toggled.connect(self.Menu_HCY) + self.dialog.sel.toggled.connect(self.Menu_SEL) + self.dialog.xyz.toggled.connect(self.Menu_XYZ) + self.dialog.xyy.toggled.connect(self.Menu_XYY) + self.dialog.luv.toggled.connect(self.Menu_LUV) + self.dialog.hlab.toggled.connect(self.Menu_HLAB) + self.dialog.lab.toggled.connect(self.Menu_LAB) + self.dialog.lch.toggled.connect(self.Menu_LCH) + # Dialog 4 + self.dialog.display_values.toggled.connect(self.Menu_Display_Value) + self.dialog.display_hex.toggled.connect(self.Menu_Display_Hex) + self.dialog.hex_copy_paste.toggled.connect(self.Menu_HEX_Copy) + self.dialog.hue_shine.toggled.connect(self.Menu_Hue_Shine) + self.dialog.cursor.toggled.connect(self.Menu_Cursor) + # Dialog 5 + self.dialog.mix_index.currentTextChanged.connect(self.Menu_MIX) + self.dialog.history_clear.clicked.connect(self.History_CLEAR) + # Dialog 6 + self.dialog.wheel_index.currentTextChanged.connect(self.Menu_Wheel) + self.dialog.wheel_space.currentTextChanged.connect(self.Wheel_Space) + self.dialog.luminosity.currentTextChanged.connect(self.Menu_Luminosity) + self.dialog.xyz_matrix.currentTextChanged.connect(self.Menu_XYZ_Conversion) + self.dialog.xyz_illuminant.currentTextChanged.connect(self.Menu_XYZ_Conversion) + self.dialog.key_1.currentTextChanged.connect(self.Menu_Key_1) + self.dialog.key_2.currentTextChanged.connect(self.Menu_Key_2) + self.dialog.key_3.currentTextChanged.connect(self.Menu_Key_3) + self.dialog.key_4.currentTextChanged.connect(self.Menu_Key_4) + # Dialog 7 + self.dialog.names_closest.clicked.connect(self.HEX_Closest) + # Dialog 8 + self.dialog.release.toggled.connect(self.Menu_Release) + self.dialog.inaccurate.toggled.connect(self.Menu_Inaccurate) + # Dialog 9 + self.dialog.zzz.clicked.connect(self.Menu_COPYRIGHT) + + # UI Footer Options + self.layout.state.currentTextChanged.connect(self.Krita_TIMER) + self.layout.fill.toggled.connect(self.Menu_FILL) + self.layout.selection.toggled.connect(self.Menu_SELECTION) + self.layout.docker.clicked.connect(self.Menu_DOCKER) + def Header(self): + # Luminosity Lock + self.color_1 = Color_Header(self.layout.color_1) + self.color_1.SIGNAL_COLOR_LUMALOCK.connect(self.Pigment_AAA_1_Lock) + self.color_1.SIGNAL_COLOR_COMPLEMENTARY.connect(self.Color_Complementary) + self.color_1.SIGNAL_COLOR_SHOW.connect(self.Pigment_BG_Show) + self.color_1.SIGNAL_COLOR_HIDE.connect(self.Pigment_BG_Hide) + self.color_1.Setup(1) + self.color_2 = Color_Header(self.layout.color_2) + self.color_2.SIGNAL_COLOR_LUMALOCK.connect(self.Pigment_AAA_1_Lock) + self.color_2.SIGNAL_COLOR_COMPLEMENTARY.connect(self.Color_Complementary) + self.color_2.SIGNAL_COLOR_SHOW.connect(self.Pigment_BG_Show) + self.color_2.SIGNAL_COLOR_HIDE.connect(self.Pigment_BG_Hide) + self.color_2.Setup(2) + self.color_3 = Color_Header(self.layout.color_3) + self.color_3.SIGNAL_COLOR_SWAP.connect(self.Swap_BG) + self.color_3.SIGNAL_COLOR_SHOW.connect(self.Pigment_BG_Show) + self.color_3.SIGNAL_COLOR_HIDE.connect(self.Pigment_BG_Hide) + self.color_3.Setup(3) + def Harmonys(self): + self.harmony_0 = Harmony_Span(self.layout.harmony_0) + self.harmony_0.SIGNAL_ACTIVE.connect(self.Harmony_Span) + + self.harmony_1 = Harmony_Color(self.layout.harmony_1) + self.harmony_2 = Harmony_Color(self.layout.harmony_2) + self.harmony_3 = Harmony_Color(self.layout.harmony_3) + self.harmony_4 = Harmony_Color(self.layout.harmony_4) + self.harmony_5 = Harmony_Color(self.layout.harmony_5) + self.harmony_1.SIGNAL_ACTIVE.connect(self.Harmony_1_Active) + self.harmony_2.SIGNAL_ACTIVE.connect(self.Harmony_2_Active) + self.harmony_3.SIGNAL_ACTIVE.connect(self.Harmony_3_Active) + self.harmony_4.SIGNAL_ACTIVE.connect(self.Harmony_4_Active) + self.harmony_5.SIGNAL_ACTIVE.connect(self.Harmony_5_Active) + def Color_ofthe_Day(self): + # What day is for the User + self.year = QDate.currentDate().year() + self.month = QDate.currentDate().month() + self.day = QDate.currentDate().day() + self.dialog.cotd_date.setText(str(self.year)+"-"+str(self.month)+"-"+str(self.day)) + # Random Seed + lista = [] + for i in range(0, 15): + random.seed(self.year + self.month + self.day + (i*10000)) + lista.append(random.randrange(0,255)/255) + # Color of the Day Swatch + self.cotd_1 = [lista[0], lista[1], lista[2]] + self.cotd_2 = [lista[3], lista[4], lista[5]] + self.cotd_3 = [lista[6], lista[7], lista[8]] + self.cotd_4 = [lista[9], lista[10], lista[11]] + self.cotd_5 = [lista[12], lista[13], lista[14]] + def Panels(self): + # Panel SWA + self.panel_swa = Panel_SWA(self.layout.panel_swa) + + # Panel UVD + self.panel_uvd = Panel_UVD(self.layout.panel_uvd) + self.panel_uvd.SIGNAL_UVD_VALUE.connect(self.Signal_UVD) + self.panel_uvd.SIGNAL_UVD_RELEASE.connect(self.Pigment_Release) + self.panel_uvd.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + + # Panel YUV + self.panel_yuv = Panel_YUV(self.layout.panel_yuv) + self.panel_yuv.SIGNAL_YUV_VALUE.connect(self.Signal_YUV) + self.panel_yuv.SIGNAL_YUV_RELEASE.connect(self.Pigment_Release) + self.panel_yuv.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + + # Panel ARD + self.panel_ard = Panel_ARD(self.layout.panel_ard) + self.panel_ard.SIGNAL_ARD_VALUE.connect(self.Signal_ARD) + self.panel_ard.SIGNAL_ARD_RELEASE.connect(self.Pigment_Release) + self.panel_ard.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + + # Panel HSV + self.panel_hsv = Panel_HSV_4(self.layout.panel_hsv) + self.panel_hsv.SIGNAL_HSV_4_VALUE.connect(self.Signal_HSV_4) + self.panel_hsv.SIGNAL_HSV_4_RELEASE.connect(self.Pigment_Release) + self.panel_hsv.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + + # Panel HSL + self.panel_hsl = Panel_HSL_4(self.layout.panel_hsl) + self.panel_hsl.SIGNAL_HSL_4_VALUE.connect(self.Signal_HSL_4) + self.panel_hsl.SIGNAL_HSL_4_RELEASE.connect(self.Pigment_Release) + self.panel_hsl.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + + # Panel HCY + self.panel_hcy = Panel_HCY_4(self.layout.panel_hcy) + self.panel_hcy.SIGNAL_HCY_4_VALUE.connect(self.Signal_HCY_4) + self.panel_hcy.SIGNAL_HCY_4_RELEASE.connect(self.Pigment_Release) + self.panel_hcy.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + + # Panel HUE Circle + self.panel_hue_circle = Panel_HUE_Circle(self.layout.panel_hue_circle) + self.panel_hue_circle.SIGNAL_HUE_C_VALUE.connect(self.Signal_HUE_Circle) + self.panel_hue_circle.SIGNAL_HUE_C_RELEASE.connect(self.Pigment_Release) + self.panel_hue_circle.SIGNAL_HUE_C_HARMONY_ACTIVE.connect(self.Signal_HUE_Active) + self.panel_hue_circle.Active(self.harmony_slot) + + # Panel HUE Regular + self.panel_triangle = Panel_HSL_3(self.layout.panel_triangle) + self.panel_triangle.SIGNAL_HSL_3_VALUE.connect(self.Signal_HSL_3) + self.panel_triangle.SIGNAL_HSL_3_RELEASE.connect(self.Pigment_Release) + self.panel_triangle.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + + self.panel_square = Panel_HSV_4(self.layout.panel_square) + self.panel_square.SIGNAL_HSV_4_VALUE.connect(self.Signal_HSV_4) + self.panel_square.SIGNAL_HSV_4_RELEASE.connect(self.Pigment_Release) + self.panel_square.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + + self.panel_diamond = Panel_HSL_4D(self.layout.panel_diamond) + self.panel_diamond.SIGNAL_HSL_4D_VALUE.connect(self.Signal_HSL_4D) + self.panel_diamond.SIGNAL_HSL_4D_RELEASE.connect(self.Pigment_Release) + self.panel_diamond.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + def Gamut(self): + # Panel GAMut Circle + self.panel_gam_circle = Panel_GAM_Circle(self.layout.panel_gam_circle) + self.panel_gam_circle.SIGNAL_GAM_C_VALUE.connect(self.Signal_GAM_Circle) + self.panel_gam_circle.SIGNAL_GAM_C_RELEASE.connect(self.Pigment_Release) + # Panel GAMut Poly + self.panel_gam_polygon = Panel_GAM_Polygon(self.layout.panel_gam_polygon) + self.panel_gam_polygon.SIGNAL_GAM_P_POINTS.connect(self.Signal_GAM_Points) + self.panel_gam_polygon.SIGNAL_GAM_P_VALUE.connect(self.Signal_GAM_Polygon) + self.panel_gam_polygon.SIGNAL_GAM_P_RELEASE.connect(self.Pigment_Release) + self.panel_gam_polygon.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + def Dots(self): + self.panel_dots = Panel_DOT(self.layout.panel_dot_mix) + self.panel_dots.SIGNAL_DOT_COLOR.connect(self.Signal_DOT_Color) + self.panel_dots.SIGNAL_DOT_CURSOR.connect(self.Signal_DOT_Cursor) + self.panel_dots.SIGNAL_DOT_RELEASE.connect(self.Pigment_Release) + + self.color_dot_1 = Clicks(self.layout.dot_1) + self.color_dot_1.SIGNAL_APPLY.connect(self.DOT_1_APPLY) + self.color_dot_1.SIGNAL_SAVE.connect(self.DOT_1_SAVE) + self.color_dot_1.SIGNAL_CLEAN.connect(self.DOT_1_CLEAN) + + self.color_dot_2 = Clicks(self.layout.dot_2) + self.color_dot_2.SIGNAL_APPLY.connect(self.DOT_2_APPLY) + self.color_dot_2.SIGNAL_SAVE.connect(self.DOT_2_SAVE) + self.color_dot_2.SIGNAL_CLEAN.connect(self.DOT_2_CLEAN) + + self.color_dot_3 = Clicks(self.layout.dot_3) + self.color_dot_3.SIGNAL_APPLY.connect(self.DOT_3_APPLY) + self.color_dot_3.SIGNAL_SAVE.connect(self.DOT_3_SAVE) + self.color_dot_3.SIGNAL_CLEAN.connect(self.DOT_3_CLEAN) + + self.color_dot_4 = Clicks(self.layout.dot_4) + self.color_dot_4.SIGNAL_APPLY.connect(self.DOT_4_APPLY) + self.color_dot_4.SIGNAL_SAVE.connect(self.DOT_4_SAVE) + self.color_dot_4.SIGNAL_CLEAN.connect(self.DOT_4_CLEAN) + + self.layout.dot_swap.setIcon(Krita.instance().icon('fileLayer')) + self.layout.dot_swap.clicked.connect(self.DOT_SWAP) + def Object(self): + # Panel OBJ (Only updates the Cursor location) + self.panel_obj_display = Panel_OBJ(self.layout.panel_obj_display) + self.panel_obj_display.SIGNAL_OBJ_COLOR.connect(self.Signal_OBJ_Color) + self.panel_obj_display.SIGNAL_OBJ_CURSOR.connect(self.Signal_OBJ_Cursor) + self.panel_obj_display.SIGNAL_OBJ_RELEASE.connect(self.Pigment_Release) + + # Background 1 + self.layout.b1_live.clicked.connect(self.BG_1_Exclusion) + self.b1_color = Clicks(self.layout.b1_color) + self.b1_color.SIGNAL_APPLY.connect(self.BG_1_APPLY) + self.b1_color.SIGNAL_SAVE.connect(lambda: self.BG_1_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.bg_1[self.obj_index][4])) + self.b1_color.SIGNAL_CLEAN.connect(self.BG_1_CLEAN) + self.b1_alpha = Channel_Linear(self.layout.b1_alpha) + self.b1_alpha.Setup("NEU", 0, "NEU") + self.b1_alpha.SIGNAL_VALUE.connect(self.BG_1_ALPHA) + # Background 2 + self.layout.b2_live.clicked.connect(self.BG_2_Exclusion) + self.b2_color = Clicks(self.layout.b2_color) + self.b2_color.SIGNAL_APPLY.connect(self.BG_2_APPLY) + self.b2_color.SIGNAL_SAVE.connect(lambda: self.BG_2_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.bg_2[self.obj_index][4])) + self.b2_color.SIGNAL_CLEAN.connect(self.BG_2_CLEAN) + self.b2_alpha = Channel_Linear(self.layout.b2_alpha) + self.b2_alpha.Setup("NEU", 0, "NEU") + self.b2_alpha.SIGNAL_VALUE.connect(self.BG_2_ALPHA) + # Background 3 + self.layout.b3_live.clicked.connect(self.BG_3_Exclusion) + self.b3_color = Clicks(self.layout.b3_color) + self.b3_color.SIGNAL_APPLY.connect(self.BG_3_APPLY) + self.b3_color.SIGNAL_SAVE.connect(lambda: self.BG_3_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.bg_3[self.obj_index][4])) + self.b3_color.SIGNAL_CLEAN.connect(self.BG_3_CLEAN) + self.b3_alpha = Channel_Linear(self.layout.b3_alpha) + self.b3_alpha.Setup("NEU", 0, "NEU") + self.b3_alpha.SIGNAL_VALUE.connect(self.BG_3_ALPHA) + + # Diffuse 1 + self.layout.d1_live.clicked.connect(self.DIF_1_Exclusion) + self.d1_color = Clicks(self.layout.d1_color) + self.d1_color.SIGNAL_APPLY.connect(self.DIF_1_APPLY) + self.d1_color.SIGNAL_SAVE.connect(lambda: self.DIF_1_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_1[self.obj_index][4])) + self.d1_color.SIGNAL_CLEAN.connect(self.DIF_1_CLEAN) + self.d1_alpha = Channel_Linear(self.layout.d1_alpha) + self.d1_alpha.Setup("NEU", 0, "NEU") + self.d1_alpha.SIGNAL_VALUE.connect(self.DIF_1_ALPHA) + # Diffuse 2 + self.layout.d2_live.clicked.connect(self.DIF_2_Exclusion) + self.d2_color = Clicks(self.layout.d2_color) + self.d2_color.SIGNAL_APPLY.connect(self.DIF_2_APPLY) + self.d2_color.SIGNAL_SAVE.connect(lambda: self.DIF_2_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_2[self.obj_index][4])) + self.d2_color.SIGNAL_CLEAN.connect(self.DIF_2_CLEAN) + self.d2_alpha = Channel_Linear(self.layout.d2_alpha) + self.d2_alpha.Setup("NEU", 0, "NEU") + self.d2_alpha.SIGNAL_VALUE.connect(self.DIF_2_ALPHA) + # Diffuse 3 + self.layout.d3_live.clicked.connect(self.DIF_3_Exclusion) + self.d3_color = Clicks(self.layout.d3_color) + self.d3_color.SIGNAL_APPLY.connect(self.DIF_3_APPLY) + self.d3_color.SIGNAL_SAVE.connect(lambda: self.DIF_3_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_3[self.obj_index][4])) + self.d3_color.SIGNAL_CLEAN.connect(self.DIF_3_CLEAN) + self.d3_alpha = Channel_Linear(self.layout.d3_alpha) + self.d3_alpha.Setup("NEU", 0, "NEU") + self.d3_alpha.SIGNAL_VALUE.connect(self.DIF_3_ALPHA) + # Diffuse 4 + self.layout.d4_live.clicked.connect(self.DIF_4_Exclusion) + self.d4_color = Clicks(self.layout.d4_color) + self.d4_color.SIGNAL_APPLY.connect(self.DIF_4_APPLY) + self.d4_color.SIGNAL_SAVE.connect(lambda: self.DIF_4_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_4[self.obj_index][4])) + self.d4_color.SIGNAL_CLEAN.connect(self.DIF_4_CLEAN) + self.d4_alpha = Channel_Linear(self.layout.d4_alpha) + self.d4_alpha.Setup("NEU", 0, "NEU") + self.d4_alpha.SIGNAL_VALUE.connect(self.DIF_4_ALPHA) + # Diffuse 5 + self.layout.d5_live.clicked.connect(self.DIF_5_Exclusion) + self.d5_color = Clicks(self.layout.d5_color) + self.d5_color.SIGNAL_APPLY.connect(self.DIF_5_APPLY) + self.d5_color.SIGNAL_SAVE.connect(lambda: self.DIF_5_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_5[self.obj_index][4])) + self.d5_color.SIGNAL_CLEAN.connect(self.DIF_5_CLEAN) + self.d5_alpha = Channel_Linear(self.layout.d5_alpha) + self.d5_alpha.Setup("NEU", 0, "NEU") + self.d5_alpha.SIGNAL_VALUE.connect(self.DIF_5_ALPHA) + # Diffuse 6 + self.layout.d6_live.clicked.connect(self.DIF_6_Exclusion) + self.d6_color = Clicks(self.layout.d6_color) + self.d6_color.SIGNAL_APPLY.connect(self.DIF_6_APPLY) + self.d6_color.SIGNAL_SAVE.connect(lambda: self.DIF_6_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_6[self.obj_index][4])) + self.d6_color.SIGNAL_CLEAN.connect(self.DIF_6_CLEAN) + self.d6_alpha = Channel_Linear(self.layout.d6_alpha) + self.d6_alpha.Setup("NEU", 0, "NEU") + self.d6_alpha.SIGNAL_VALUE.connect(self.DIF_6_ALPHA) + + # Foreground 1 + self.layout.f1_live.clicked.connect(self.FG_1_Exclusion) + self.f1_color = Clicks(self.layout.f1_color) + self.f1_color.SIGNAL_APPLY.connect(self.FG_1_APPLY) + self.f1_color.SIGNAL_SAVE.connect(lambda: self.FG_1_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.fg_1[self.obj_index][4])) + self.f1_color.SIGNAL_CLEAN.connect(self.FG_1_CLEAN) + self.f1_alpha = Channel_Linear(self.layout.f1_alpha) + self.f1_alpha.Setup("NEU", 0, "NEU") + self.f1_alpha.SIGNAL_VALUE.connect(self.FG_1_ALPHA) + # Foreground 2 + self.layout.f2_live.clicked.connect(self.FG_2_Exclusion) + self.f2_color = Clicks(self.layout.f2_color) + self.f2_color.SIGNAL_APPLY.connect(self.FG_2_APPLY) + self.f2_color.SIGNAL_SAVE.connect(lambda: self.FG_2_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.fg_2[self.obj_index][4])) + self.f2_color.SIGNAL_CLEAN.connect(self.FG_2_CLEAN) + self.f2_alpha = Channel_Linear(self.layout.f2_alpha) + self.f2_alpha.Setup("NEU", 0, "NEU") + self.f2_alpha.SIGNAL_VALUE.connect(self.FG_2_ALPHA) + # Foreground 3 + self.layout.f3_live.clicked.connect(self.FG_3_Exclusion) + self.f3_color = Clicks(self.layout.f3_color) + self.f3_color.SIGNAL_APPLY.connect(self.FG_3_APPLY) + self.f3_color.SIGNAL_SAVE.connect(lambda: self.FG_3_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.fg_3[self.obj_index][4])) + self.f3_color.SIGNAL_CLEAN.connect(self.FG_3_CLEAN) + self.f3_alpha = Channel_Linear(self.layout.f3_alpha) + self.f3_alpha.Setup("NEU", 0, "NEU") + self.f3_alpha.SIGNAL_VALUE.connect(self.FG_3_ALPHA) + + # Style Sheets + self.layout.b1_color.setStyleSheet(self.bg_alpha) + self.layout.b2_color.setStyleSheet(self.bg_alpha) + self.layout.b3_color.setStyleSheet(self.bg_alpha) + self.layout.d1_color.setStyleSheet(self.bg_alpha) + self.layout.d2_color.setStyleSheet(self.bg_alpha) + self.layout.d3_color.setStyleSheet(self.bg_alpha) + self.layout.d4_color.setStyleSheet(self.bg_alpha) + self.layout.d5_color.setStyleSheet(self.bg_alpha) + self.layout.d6_color.setStyleSheet(self.bg_alpha) + self.layout.f1_color.setStyleSheet(self.bg_alpha) + self.layout.f2_color.setStyleSheet(self.bg_alpha) + self.layout.f3_color.setStyleSheet(self.bg_alpha) + self.layout.b1_alpha.setStyleSheet(self.bg_alpha) + self.layout.b2_alpha.setStyleSheet(self.bg_alpha) + self.layout.b3_alpha.setStyleSheet(self.bg_alpha) + self.layout.d1_alpha.setStyleSheet(self.bg_alpha) + self.layout.d2_alpha.setStyleSheet(self.bg_alpha) + self.layout.d3_alpha.setStyleSheet(self.bg_alpha) + self.layout.d4_alpha.setStyleSheet(self.bg_alpha) + self.layout.d5_alpha.setStyleSheet(self.bg_alpha) + self.layout.d6_alpha.setStyleSheet(self.bg_alpha) + self.layout.f1_alpha.setStyleSheet(self.bg_alpha) + self.layout.f2_alpha.setStyleSheet(self.bg_alpha) + self.layout.f3_alpha.setStyleSheet(self.bg_alpha) + def Images(self): + self.panel_img = Panel_IMG(self.layout.panel_img) + self.panel_img.Set_Default( os.path.normpath(self.dir_name + "/IMAGE/default.png") ) + self.panel_img.Set_Save( os.path.normpath(self.dir_name + "/IMAGE/save.png") ) + self.panel_img.SIGNAL_IMG_FILE.connect(self.IMG_File) + self.panel_img.SIGNAL_IMG_STATE.connect(self.Signal_IMG_State) + self.panel_img.SIGNAL_IMG_COLOR.connect(self.Signal_IMG_Color) + self.panel_img.SIGNAL_IMG_RELEASE.connect(self.Pigment_Release) + self.panel_img.SIGNAL_SCAN_VAL.connect(self.Signal_Scan_Value) + self.panel_img.SIGNAL_SCAN_MAX.connect(self.Pigment_Scan_Maximum) + def Channels(self): + #\\ Hex ################################################################ + self.layout.hex_string.returnPressed.connect(self.HEX_Code) + + #// + #\\ Values ############################################################# + # Channels Range Minimum + self.layout.aaa_1_value.setMinimum(0) + self.layout.rgb_1_value.setMinimum(0) + self.layout.rgb_2_value.setMinimum(0) + self.layout.rgb_3_value.setMinimum(0) + self.layout.cmy_1_value.setMinimum(0) + self.layout.cmy_2_value.setMinimum(0) + self.layout.cmy_3_value.setMinimum(0) + self.layout.cmyk_1_value.setMinimum(0) + self.layout.cmyk_2_value.setMinimum(0) + self.layout.cmyk_3_value.setMinimum(0) + self.layout.cmyk_4_value.setMinimum(0) + self.layout.ryb_1_value.setMinimum(0) + self.layout.ryb_2_value.setMinimum(0) + self.layout.ryb_3_value.setMinimum(0) + self.layout.yuv_1_value.setMinimum(0) + self.layout.yuv_2_value.setMinimum(0) + self.layout.yuv_3_value.setMinimum(0) + self.layout.kkk_1_value.setMinimum(k_KKKmin) + + self.layout.ard_1_value.setMinimum(0) + self.layout.ard_2_value.setMinimum(0) + self.layout.ard_3_value.setMinimum(0) + self.layout.hsv_1_value.setMinimum(0) + self.layout.hsv_2_value.setMinimum(0) + self.layout.hsv_3_value.setMinimum(0) + self.layout.hsl_1_value.setMinimum(0) + self.layout.hsl_2_value.setMinimum(0) + self.layout.hsl_3_value.setMinimum(0) + self.layout.hcy_1_value.setMinimum(0) + self.layout.hcy_2_value.setMinimum(0) + self.layout.hcy_3_value.setMinimum(0) + self.layout.sel_1_value.setMinimum(0) + self.layout.sel_2_value.setMinimum(0) + self.layout.sel_3_value.setMinimum(0) + + self.layout.xyz_1_value.setMinimum(0) + self.layout.xyz_2_value.setMinimum(0) + self.layout.xyz_3_value.setMinimum(0) + self.layout.xyy_1_value.setMinimum(0) + self.layout.xyy_2_value.setMinimum(0) + self.layout.xyy_3_value.setMinimum(0) + self.layout.luv_1_value.setMinimum(0) + self.layout.luv_2_value.setMinimum(0) + self.layout.luv_3_value.setMinimum(0) + self.layout.hlab_1_value.setMinimum(0) + self.layout.hlab_2_value.setMinimum(0) + self.layout.hlab_3_value.setMinimum(0) + self.layout.lab_1_value.setMinimum(0) + self.layout.lab_2_value.setMinimum(0) + self.layout.lab_3_value.setMinimum(0) + self.layout.lch_1_value.setMinimum(0) + self.layout.lch_2_value.setMinimum(0) + self.layout.lch_3_value.setMinimum(0) + + # Channels Range Maximum + self.layout.aaa_1_value.setMaximum(k_AAA) + self.layout.rgb_1_value.setMaximum(k_RGB) + self.layout.rgb_2_value.setMaximum(k_RGB) + self.layout.rgb_3_value.setMaximum(k_RGB) + self.layout.cmy_1_value.setMaximum(k_CMY) + self.layout.cmy_2_value.setMaximum(k_CMY) + self.layout.cmy_3_value.setMaximum(k_CMY) + self.layout.cmyk_1_value.setMaximum(k_CMYK) + self.layout.cmyk_2_value.setMaximum(k_CMYK) + self.layout.cmyk_3_value.setMaximum(k_CMYK) + self.layout.cmyk_4_value.setMaximum(k_CMYK) + self.layout.ryb_1_value.setMaximum(k_RYB) + self.layout.ryb_2_value.setMaximum(k_RYB) + self.layout.ryb_3_value.setMaximum(k_RYB) + self.layout.yuv_1_value.setMaximum(k_YYY) + self.layout.yuv_2_value.setMaximum(k_UV) + self.layout.yuv_3_value.setMaximum(k_UV) + self.layout.kkk_1_value.setMaximum(k_KKKmax) + + self.layout.ard_1_value.setMaximum(k_HUE) + self.layout.ard_2_value.setMaximum(k_SVL) + self.layout.ard_3_value.setMaximum(k_SVL) + self.layout.hsv_1_value.setMaximum(k_HUE) + self.layout.hsv_2_value.setMaximum(k_SVL) + self.layout.hsv_3_value.setMaximum(k_SVL) + self.layout.hsl_1_value.setMaximum(k_HUE) + self.layout.hsl_2_value.setMaximum(k_SVL) + self.layout.hsl_3_value.setMaximum(k_SVL) + self.layout.hcy_1_value.setMaximum(k_HUE) + self.layout.hcy_2_value.setMaximum(k_SVL) + self.layout.hcy_3_value.setMaximum(k_SVL) + self.layout.sel_1_value.setMaximum(k_HUE) + self.layout.sel_2_value.setMaximum(k_SVL) + self.layout.sel_3_value.setMaximum(k_SVL) + + self.layout.xyz_1_value.setMaximum(k_XYZ) + self.layout.xyz_2_value.setMaximum(k_XYZ) + self.layout.xyz_3_value.setMaximum(k_XYZ) + self.layout.xyy_1_value.setMaximum(k_XYY) + self.layout.xyy_2_value.setMaximum(k_XYY) + self.layout.xyy_3_value.setMaximum(k_XYY) + self.layout.luv_1_value.setMaximum(k_LUV) + self.layout.luv_2_value.setMaximum(k_LUV) + self.layout.luv_3_value.setMaximum(k_LUV) + self.layout.hlab_1_value.setMaximum(k_HLAB) + self.layout.hlab_2_value.setMaximum(k_HLAB) + self.layout.hlab_3_value.setMaximum(k_HLAB) + self.layout.lab_1_value.setMaximum(k_LLL) + self.layout.lab_2_value.setMaximum(k_AB) + self.layout.lab_3_value.setMaximum(k_AB) + self.layout.lch_1_value.setMaximum(k_LCH) + self.layout.lch_2_value.setMaximum(k_LCH) + self.layout.lch_3_value.setMaximum(k_LCH) + + #// + #\\ Modules ############################################################ + # Module Channel + self.aaa_1_slider = Channel_Linear(self.layout.aaa_1_slider) + self.rgb_1_slider = Channel_Linear(self.layout.rgb_1_slider) + self.rgb_2_slider = Channel_Linear(self.layout.rgb_2_slider) + self.rgb_3_slider = Channel_Linear(self.layout.rgb_3_slider) + self.cmy_1_slider = Channel_Linear(self.layout.cmy_1_slider) + self.cmy_2_slider = Channel_Linear(self.layout.cmy_2_slider) + self.cmy_3_slider = Channel_Linear(self.layout.cmy_3_slider) + self.cmyk_1_slider = Channel_Linear(self.layout.cmyk_1_slider) + self.cmyk_2_slider = Channel_Linear(self.layout.cmyk_2_slider) + self.cmyk_3_slider = Channel_Linear(self.layout.cmyk_3_slider) + self.cmyk_4_slider = Channel_Linear(self.layout.cmyk_4_slider) + self.ryb_1_slider = Channel_Linear(self.layout.ryb_1_slider) + self.ryb_2_slider = Channel_Linear(self.layout.ryb_2_slider) + self.ryb_3_slider = Channel_Linear(self.layout.ryb_3_slider) + self.yuv_1_slider = Channel_Linear(self.layout.yuv_1_slider) + self.yuv_2_slider = Channel_Linear(self.layout.yuv_2_slider) + self.yuv_3_slider = Channel_Linear(self.layout.yuv_3_slider) + self.kkk_1_slider = Channel_Linear(self.layout.kkk_1_slider) + + self.ard_1_slider = Channel_Linear(self.layout.ard_1_slider) + self.ard_2_slider = Channel_Linear(self.layout.ard_2_slider) + self.ard_3_slider = Channel_Linear(self.layout.ard_3_slider) + self.hsv_1_slider = Channel_Linear(self.layout.hsv_1_slider) + self.hsv_2_slider = Channel_Linear(self.layout.hsv_2_slider) + self.hsv_3_slider = Channel_Linear(self.layout.hsv_3_slider) + self.hsl_1_slider = Channel_Linear(self.layout.hsl_1_slider) + self.hsl_2_slider = Channel_Linear(self.layout.hsl_2_slider) + self.hsl_3_slider = Channel_Linear(self.layout.hsl_3_slider) + self.hcy_1_slider = Channel_Linear(self.layout.hcy_1_slider) + self.hcy_2_slider = Channel_Linear(self.layout.hcy_2_slider) + self.hcy_3_slider = Channel_Linear(self.layout.hcy_3_slider) + self.sel_1_slider = Channel_Interval(self.layout.sel_1_slider) + self.sel_2_slider = Channel_Interval(self.layout.sel_2_slider) + self.sel_3_slider = Channel_Interval(self.layout.sel_3_slider) + + self.xyz_1_slider = Channel_Linear(self.layout.xyz_1_slider) + self.xyz_2_slider = Channel_Linear(self.layout.xyz_2_slider) + self.xyz_3_slider = Channel_Linear(self.layout.xyz_3_slider) + self.xyy_1_slider = Channel_Linear(self.layout.xyy_1_slider) + self.xyy_2_slider = Channel_Linear(self.layout.xyy_2_slider) + self.xyy_3_slider = Channel_Linear(self.layout.xyy_3_slider) + self.luv_1_slider = Channel_Linear(self.layout.luv_1_slider) + self.luv_2_slider = Channel_Linear(self.layout.luv_2_slider) + self.luv_3_slider = Channel_Linear(self.layout.luv_3_slider) + self.hlab_1_slider = Channel_Linear(self.layout.hlab_1_slider) + self.hlab_2_slider = Channel_Linear(self.layout.hlab_2_slider) + self.hlab_3_slider = Channel_Linear(self.layout.hlab_3_slider) + self.lab_1_slider = Channel_Linear(self.layout.lab_1_slider) + self.lab_2_slider = Channel_Linear(self.layout.lab_2_slider) + self.lab_3_slider = Channel_Linear(self.layout.lab_3_slider) + self.lch_1_slider = Channel_Linear(self.layout.lch_1_slider) + self.lch_2_slider = Channel_Linear(self.layout.lch_2_slider) + self.lch_3_slider = Channel_Linear(self.layout.lch_3_slider) + + # Cursor + self.CHANNEL_Setup("DIAMOND_1") + + #// + #\\ Functions ########################################################## + # Channel ALPHA ######################################################## + self.aaa_1_slider.SIGNAL_HALF.connect(self.Pigment_AAA_1_Half) + self.aaa_1_slider.SIGNAL_MINUS.connect(self.Pigment_AAA_1_Minus) + self.aaa_1_slider.SIGNAL_PLUS.connect(self.Pigment_AAA_1_Plus) + self.aaa_1_slider.SIGNAL_VALUE.connect(self.Pigment_AAA_1_Slider_Modify) + self.aaa_1_slider.SIGNAL_RELEASE.connect(self.Pigment_AAA_1_Slider_Release) + self.aaa_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.aaa_1_value.valueChanged.connect(self.Pigment_AAA_1_Value_Modify) + self.layout.aaa_1_value.editingFinished.connect(self.Pigment_AAA_1_Value_Release) + + # Channel RED + self.rgb_1_slider.SIGNAL_HALF.connect(self.Pigment_RGB_1_Half) + self.rgb_1_slider.SIGNAL_MINUS.connect(self.Pigment_RGB_1_Minus) + self.rgb_1_slider.SIGNAL_PLUS.connect(self.Pigment_RGB_1_Plus) + self.rgb_1_slider.SIGNAL_VALUE.connect(self.Pigment_RGB_1_Slider_Modify) + self.rgb_1_slider.SIGNAL_RELEASE.connect(self.Pigment_RGB_1_Slider_Release) + self.rgb_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.rgb_1_value.valueChanged.connect(self.Pigment_RGB_1_Value_Modify) + self.layout.rgb_1_value.editingFinished.connect(self.Pigment_RGB_1_Value_Release) + # Channel GREEN + self.rgb_2_slider.SIGNAL_HALF.connect(self.Pigment_RGB_2_Half) + self.rgb_2_slider.SIGNAL_MINUS.connect(self.Pigment_RGB_2_Minus) + self.rgb_2_slider.SIGNAL_PLUS.connect(self.Pigment_RGB_2_Plus) + self.rgb_2_slider.SIGNAL_VALUE.connect(self.Pigment_RGB_2_Slider_Modify) + self.rgb_2_slider.SIGNAL_RELEASE.connect(self.Pigment_RGB_2_Slider_Release) + self.rgb_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.rgb_2_value.valueChanged.connect(self.Pigment_RGB_2_Value_Modify) + self.layout.rgb_2_value.editingFinished.connect(self.Pigment_RGB_2_Value_Release) + # Channel BLUE + self.rgb_3_slider.SIGNAL_HALF.connect(self.Pigment_RGB_3_Half) + self.rgb_3_slider.SIGNAL_MINUS.connect(self.Pigment_RGB_3_Minus) + self.rgb_3_slider.SIGNAL_PLUS.connect(self.Pigment_RGB_3_Plus) + self.rgb_3_slider.SIGNAL_VALUE.connect(self.Pigment_RGB_3_Slider_Modify) + self.rgb_3_slider.SIGNAL_RELEASE.connect(self.Pigment_RGB_3_Slider_Release) + self.rgb_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.rgb_3_value.valueChanged.connect(self.Pigment_RGB_3_Value_Modify) + self.layout.rgb_3_value.editingFinished.connect(self.Pigment_RGB_3_Value_Release) + + # Channel CYAN + self.cmy_1_slider.SIGNAL_HALF.connect(self.Pigment_CMY_1_Half) + self.cmy_1_slider.SIGNAL_MINUS.connect(self.Pigment_CMY_1_Minus) + self.cmy_1_slider.SIGNAL_PLUS.connect(self.Pigment_CMY_1_Plus) + self.cmy_1_slider.SIGNAL_VALUE.connect(self.Pigment_CMY_1_Slider_Modify) + self.cmy_1_slider.SIGNAL_RELEASE.connect(self.Pigment_CMY_1_Slider_Release) + self.cmy_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.cmy_1_value.valueChanged.connect(self.Pigment_CMY_1_Value_Modify) + self.layout.cmy_1_value.editingFinished.connect(self.Pigment_CMY_1_Value_Release) + # Channel MAGENTA + self.cmy_2_slider.SIGNAL_HALF.connect(self.Pigment_CMY_2_Half) + self.cmy_2_slider.SIGNAL_MINUS.connect(self.Pigment_CMY_2_Minus) + self.cmy_2_slider.SIGNAL_PLUS.connect(self.Pigment_CMY_2_Plus) + self.cmy_2_slider.SIGNAL_VALUE.connect(self.Pigment_CMY_2_Slider_Modify) + self.cmy_2_slider.SIGNAL_RELEASE.connect(self.Pigment_CMY_2_Slider_Release) + self.cmy_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.cmy_2_value.valueChanged.connect(self.Pigment_CMY_2_Value_Modify) + self.layout.cmy_2_value.editingFinished.connect(self.Pigment_CMY_2_Value_Release) + # Channel YELLOW + self.cmy_3_slider.SIGNAL_HALF.connect(self.Pigment_CMY_3_Half) + self.cmy_3_slider.SIGNAL_MINUS.connect(self.Pigment_CMY_3_Minus) + self.cmy_3_slider.SIGNAL_PLUS.connect(self.Pigment_CMY_3_Plus) + self.cmy_3_slider.SIGNAL_VALUE.connect(self.Pigment_CMY_3_Slider_Modify) + self.cmy_3_slider.SIGNAL_RELEASE.connect(self.Pigment_CMY_3_Slider_Release) + self.cmy_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.cmy_3_value.valueChanged.connect(self.Pigment_CMY_3_Value_Modify) + self.layout.cmy_3_value.editingFinished.connect(self.Pigment_CMY_3_Value_Release) + + # Channel CYAN + self.cmyk_1_slider.SIGNAL_HALF.connect(self.Pigment_CMYK_1_Half) + self.cmyk_1_slider.SIGNAL_MINUS.connect(self.Pigment_CMYK_1_Minus) + self.cmyk_1_slider.SIGNAL_PLUS.connect(self.Pigment_CMYK_1_Plus) + self.cmyk_1_slider.SIGNAL_VALUE.connect(self.Pigment_CMYK_1_Slider_Modify) + self.cmyk_1_slider.SIGNAL_RELEASE.connect(self.Pigment_CMYK_1_Slider_Release) + self.cmyk_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.cmyk_1_value.valueChanged.connect(self.Pigment_CMYK_1_Value_Modify) + self.layout.cmyk_1_value.editingFinished.connect(self.Pigment_CMYK_1_Value_Release) + # Channel MAGENTA + self.cmyk_2_slider.SIGNAL_HALF.connect(self.Pigment_CMYK_2_Half) + self.cmyk_2_slider.SIGNAL_MINUS.connect(self.Pigment_CMYK_2_Minus) + self.cmyk_2_slider.SIGNAL_PLUS.connect(self.Pigment_CMYK_2_Plus) + self.cmyk_2_slider.SIGNAL_VALUE.connect(self.Pigment_CMYK_2_Slider_Modify) + self.cmyk_2_slider.SIGNAL_RELEASE.connect(self.Pigment_CMYK_2_Slider_Release) + self.cmyk_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.cmyk_2_value.valueChanged.connect(self.Pigment_CMYK_2_Value_Modify) + self.layout.cmyk_2_value.editingFinished.connect(self.Pigment_CMYK_2_Value_Release) + # Channel YELLOW + self.cmyk_3_slider.SIGNAL_HALF.connect(self.Pigment_CMYK_3_Half) + self.cmyk_3_slider.SIGNAL_MINUS.connect(self.Pigment_CMYK_3_Minus) + self.cmyk_3_slider.SIGNAL_PLUS.connect(self.Pigment_CMYK_3_Plus) + self.cmyk_3_slider.SIGNAL_VALUE.connect(self.Pigment_CMYK_3_Slider_Modify) + self.cmyk_3_slider.SIGNAL_RELEASE.connect(self.Pigment_CMYK_3_Slider_Release) + self.cmyk_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.cmyk_3_value.valueChanged.connect(self.Pigment_CMYK_3_Value_Modify) + self.layout.cmyk_3_value.editingFinished.connect(self.Pigment_CMYK_3_Value_Release) + # Channel KEY + self.cmyk_4_slider.SIGNAL_HALF.connect(self.Pigment_CMYK_4_Half) + self.cmyk_4_slider.SIGNAL_MINUS.connect(self.Pigment_CMYK_4_Minus) + self.cmyk_4_slider.SIGNAL_PLUS.connect(self.Pigment_CMYK_4_Plus) + self.cmyk_4_slider.SIGNAL_VALUE.connect(self.Pigment_CMYK_4_Slider_Modify) + self.cmyk_4_slider.SIGNAL_RELEASE.connect(self.Pigment_CMYK_4_Slider_Release) + self.cmyk_4_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.cmyk_4_value.valueChanged.connect(self.Pigment_CMYK_4_Value_Modify) + self.layout.cmyk_4_value.editingFinished.connect(self.Pigment_CMYK_4_Value_Release) + self.layout.cmyk_4_lock.toggled.connect(self.Pigment_CMYK_4_Lock) + + # Channel RED + self.ryb_1_slider.SIGNAL_HALF.connect(self.Pigment_RYB_1_Half) + self.ryb_1_slider.SIGNAL_MINUS.connect(self.Pigment_RYB_1_Minus) + self.ryb_1_slider.SIGNAL_PLUS.connect(self.Pigment_RYB_1_Plus) + self.ryb_1_slider.SIGNAL_VALUE.connect(self.Pigment_RYB_1_Slider_Modify) + self.ryb_1_slider.SIGNAL_RELEASE.connect(self.Pigment_RYB_1_Slider_Release) + self.ryb_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.ryb_1_value.valueChanged.connect(self.Pigment_RYB_1_Value_Modify) + self.layout.ryb_1_value.editingFinished.connect(self.Pigment_RYB_1_Value_Release) + # Channel YELLOW + self.ryb_2_slider.SIGNAL_HALF.connect(self.Pigment_RYB_2_Half) + self.ryb_2_slider.SIGNAL_MINUS.connect(self.Pigment_RYB_2_Minus) + self.ryb_2_slider.SIGNAL_PLUS.connect(self.Pigment_RYB_2_Plus) + self.ryb_2_slider.SIGNAL_VALUE.connect(self.Pigment_RYB_2_Slider_Modify) + self.ryb_2_slider.SIGNAL_RELEASE.connect(self.Pigment_RYB_2_Slider_Release) + self.ryb_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.ryb_2_value.valueChanged.connect(self.Pigment_RYB_2_Value_Modify) + self.layout.ryb_2_value.editingFinished.connect(self.Pigment_RYB_2_Value_Release) + # Channel BLUE + self.ryb_3_slider.SIGNAL_HALF.connect(self.Pigment_RYB_3_Half) + self.ryb_3_slider.SIGNAL_MINUS.connect(self.Pigment_RYB_3_Minus) + self.ryb_3_slider.SIGNAL_PLUS.connect(self.Pigment_RYB_3_Plus) + self.ryb_3_slider.SIGNAL_VALUE.connect(self.Pigment_RYB_3_Slider_Modify) + self.ryb_3_slider.SIGNAL_RELEASE.connect(self.Pigment_RYB_3_Slider_Release) + self.ryb_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.ryb_3_value.valueChanged.connect(self.Pigment_RYB_3_Value_Modify) + self.layout.ryb_3_value.editingFinished.connect(self.Pigment_RYB_3_Value_Release) + + # Channel Y (LUMA) + self.yuv_1_slider.SIGNAL_HALF.connect(self.Pigment_YUV_1_Half) + self.yuv_1_slider.SIGNAL_MINUS.connect(self.Pigment_YUV_1_Minus) + self.yuv_1_slider.SIGNAL_PLUS.connect(self.Pigment_YUV_1_Plus) + self.yuv_1_slider.SIGNAL_VALUE.connect(self.Pigment_YUV_1_Slider_Modify) + self.yuv_1_slider.SIGNAL_RELEASE.connect(self.Pigment_YUV_1_Slider_Release) + self.yuv_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.yuv_1_value.valueChanged.connect(self.Pigment_YUV_1_Value_Modify) + self.layout.yuv_1_value.editingFinished.connect(self.Pigment_YUV_1_Value_Release) + # Channel U (BLUE Projection) + self.yuv_2_slider.SIGNAL_HALF.connect(self.Pigment_YUV_2_Half) + self.yuv_2_slider.SIGNAL_MINUS.connect(self.Pigment_YUV_2_Minus) + self.yuv_2_slider.SIGNAL_PLUS.connect(self.Pigment_YUV_2_Plus) + self.yuv_2_slider.SIGNAL_VALUE.connect(self.Pigment_YUV_2_Slider_Modify) + self.yuv_2_slider.SIGNAL_RELEASE.connect(self.Pigment_YUV_2_Slider_Release) + self.yuv_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.yuv_2_value.valueChanged.connect(self.Pigment_YUV_2_Value_Modify) + self.layout.yuv_2_value.editingFinished.connect(self.Pigment_YUV_2_Value_Release) + # Channel V (RED Projection) + self.yuv_3_slider.SIGNAL_HALF.connect(self.Pigment_YUV_3_Half) + self.yuv_3_slider.SIGNAL_MINUS.connect(self.Pigment_YUV_3_Minus) + self.yuv_3_slider.SIGNAL_PLUS.connect(self.Pigment_YUV_3_Plus) + self.yuv_3_slider.SIGNAL_VALUE.connect(self.Pigment_YUV_3_Slider_Modify) + self.yuv_3_slider.SIGNAL_RELEASE.connect(self.Pigment_YUV_3_Slider_Release) + self.yuv_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.yuv_3_value.valueChanged.connect(self.Pigment_YUV_3_Value_Modify) + self.layout.yuv_3_value.editingFinished.connect(self.Pigment_YUV_3_Value_Release) + + # Channel KELVIN + self.kkk_1_slider.SIGNAL_HALF.connect(self.Pigment_KKK_1_Half) + self.kkk_1_slider.SIGNAL_MINUS.connect(self.Pigment_KKK_1_Minus) + self.kkk_1_slider.SIGNAL_PLUS.connect(self.Pigment_KKK_1_Plus) + self.kkk_1_slider.SIGNAL_VALUE.connect(self.Pigment_KKK_1_Slider_Modify) + self.kkk_1_slider.SIGNAL_RELEASE.connect(self.Pigment_KKK_1_Slider_Release) + self.kkk_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.kkk_1_value.valueChanged.connect(self.Pigment_KKK_1_Value_Modify) + self.layout.kkk_1_value.editingFinished.connect(self.Pigment_KKK_1_Value_Release) + self.layout.kkk_1_lock.toggled.connect(self.Pigment_KKK_1_Lock) + + + + # Channel ANGLE ######################################################## + self.ard_1_slider.SIGNAL_HALF.connect(self.Pigment_ARD_1_Half) + self.ard_1_slider.SIGNAL_MINUS.connect(self.Pigment_ARD_1_Minus) + self.ard_1_slider.SIGNAL_PLUS.connect(self.Pigment_ARD_1_Plus) + self.ard_1_slider.SIGNAL_VALUE.connect(self.Pigment_ARD_1_Slider_Modify) + self.ard_1_slider.SIGNAL_RELEASE.connect(self.Pigment_ARD_1_Slider_Release) + self.ard_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.ard_1_value.valueChanged.connect(self.Pigment_ARD_1_Value_Modify) + self.layout.ard_1_value.editingFinished.connect(self.Pigment_ARD_1_Value_Release) + self.layout.ard_1_lock.toggled.connect(self.Pigment_ARD_1_Lock) + # Channel RATIO + self.ard_2_slider.SIGNAL_HALF.connect(self.Pigment_ARD_2_Half) + self.ard_2_slider.SIGNAL_MINUS.connect(self.Pigment_ARD_2_Minus) + self.ard_2_slider.SIGNAL_PLUS.connect(self.Pigment_ARD_2_Plus) + self.ard_2_slider.SIGNAL_VALUE.connect(self.Pigment_ARD_2_Slider_Modify) + self.ard_2_slider.SIGNAL_RELEASE.connect(self.Pigment_ARD_2_Slider_Release) + self.ard_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.ard_2_value.valueChanged.connect(self.Pigment_ARD_2_Value_Modify) + self.layout.ard_2_value.editingFinished.connect(self.Pigment_ARD_2_Value_Release) + # Channel DIAGONAL + self.ard_3_slider.SIGNAL_HALF.connect(self.Pigment_ARD_3_Half) + self.ard_3_slider.SIGNAL_MINUS.connect(self.Pigment_ARD_3_Minus) + self.ard_3_slider.SIGNAL_PLUS.connect(self.Pigment_ARD_3_Plus) + self.ard_3_slider.SIGNAL_VALUE.connect(self.Pigment_ARD_3_Slider_Modify) + self.ard_3_slider.SIGNAL_RELEASE.connect(self.Pigment_ARD_3_Slider_Release) + self.ard_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.ard_3_value.valueChanged.connect(self.Pigment_ARD_3_Value_Modify) + self.layout.ard_3_value.editingFinished.connect(self.Pigment_ARD_3_Value_Release) + + # Channel HUE + self.hsv_1_slider.SIGNAL_HALF.connect(self.Pigment_HSV_1_Half) + self.hsv_1_slider.SIGNAL_MINUS.connect(self.Pigment_HSV_1_Minus) + self.hsv_1_slider.SIGNAL_PLUS.connect(self.Pigment_HSV_1_Plus) + self.hsv_1_slider.SIGNAL_VALUE.connect(self.Pigment_HSV_1_Slider_Modify) + self.hsv_1_slider.SIGNAL_RELEASE.connect(self.Pigment_HSV_1_Slider_Release) + self.hsv_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.hsv_1_value.valueChanged.connect(self.Pigment_HSV_1_Value_Modify) + self.layout.hsv_1_value.editingFinished.connect(self.Pigment_HSV_1_Value_Release) + # Channel SATURATION + self.hsv_2_slider.SIGNAL_HALF.connect(self.Pigment_HSV_2_Half) + self.hsv_2_slider.SIGNAL_MINUS.connect(self.Pigment_HSV_2_Minus) + self.hsv_2_slider.SIGNAL_PLUS.connect(self.Pigment_HSV_2_Plus) + self.hsv_2_slider.SIGNAL_VALUE.connect(self.Pigment_HSV_2_Slider_Modify) + self.hsv_2_slider.SIGNAL_RELEASE.connect(self.Pigment_HSV_2_Slider_Release) + self.hsv_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.hsv_2_value.valueChanged.connect(self.Pigment_HSV_2_Value_Modify) + self.layout.hsv_2_value.editingFinished.connect(self.Pigment_HSV_2_Value_Release) + # Channel VALUE + self.hsv_3_slider.SIGNAL_HALF.connect(self.Pigment_HSV_3_Half) + self.hsv_3_slider.SIGNAL_MINUS.connect(self.Pigment_HSV_3_Minus) + self.hsv_3_slider.SIGNAL_PLUS.connect(self.Pigment_HSV_3_Plus) + self.hsv_3_slider.SIGNAL_VALUE.connect(self.Pigment_HSV_3_Slider_Modify) + self.hsv_3_slider.SIGNAL_RELEASE.connect(self.Pigment_HSV_3_Slider_Release) + self.hsv_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.hsv_3_value.valueChanged.connect(self.Pigment_HSV_3_Value_Modify) + self.layout.hsv_3_value.editingFinished.connect(self.Pigment_HSV_3_Value_Release) + + # Channel HUE + self.hsl_1_slider.SIGNAL_HALF.connect(self.Pigment_HSL_1_Half) + self.hsl_1_slider.SIGNAL_MINUS.connect(self.Pigment_HSL_1_Minus) + self.hsl_1_slider.SIGNAL_PLUS.connect(self.Pigment_HSL_1_Plus) + self.hsl_1_slider.SIGNAL_VALUE.connect(self.Pigment_HSL_1_Slider_Modify) + self.hsl_1_slider.SIGNAL_RELEASE.connect(self.Pigment_HSL_1_Slider_Release) + self.hsl_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.hsl_1_value.valueChanged.connect(self.Pigment_HSL_1_Value_Modify) + self.layout.hsl_1_value.editingFinished.connect(self.Pigment_HSL_1_Value_Release) + # Channel SATURATION + self.hsl_2_slider.SIGNAL_HALF.connect(self.Pigment_HSL_2_Half) + self.hsl_2_slider.SIGNAL_MINUS.connect(self.Pigment_HSL_2_Minus) + self.hsl_2_slider.SIGNAL_PLUS.connect(self.Pigment_HSL_2_Plus) + self.hsl_2_slider.SIGNAL_VALUE.connect(self.Pigment_HSL_2_Slider_Modify) + self.hsl_2_slider.SIGNAL_RELEASE.connect(self.Pigment_HSL_2_Slider_Release) + self.hsl_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.hsl_2_value.valueChanged.connect(self.Pigment_HSL_2_Value_Modify) + self.layout.hsl_2_value.editingFinished.connect(self.Pigment_HSL_2_Value_Release) + # Channel LIGHTNESS + self.hsl_3_slider.SIGNAL_HALF.connect(self.Pigment_HSL_3_Half) + self.hsl_3_slider.SIGNAL_MINUS.connect(self.Pigment_HSL_3_Minus) + self.hsl_3_slider.SIGNAL_PLUS.connect(self.Pigment_HSL_3_Plus) + self.hsl_3_slider.SIGNAL_VALUE.connect(self.Pigment_HSL_3_Slider_Modify) + self.hsl_3_slider.SIGNAL_RELEASE.connect(self.Pigment_HSL_3_Slider_Release) + self.hsl_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.hsl_3_value.valueChanged.connect(self.Pigment_HSL_3_Value_Modify) + self.layout.hsl_3_value.editingFinished.connect(self.Pigment_HSL_3_Value_Release) + + # Channel HUE + self.hcy_1_slider.SIGNAL_HALF.connect(self.Pigment_HCY_1_Half) + self.hcy_1_slider.SIGNAL_MINUS.connect(self.Pigment_HCY_1_Minus) + self.hcy_1_slider.SIGNAL_PLUS.connect(self.Pigment_HCY_1_Plus) + self.hcy_1_slider.SIGNAL_VALUE.connect(self.Pigment_HCY_1_Slider_Modify) + self.hcy_1_slider.SIGNAL_RELEASE.connect(self.Pigment_HCY_1_Slider_Release) + self.hcy_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.hcy_1_value.valueChanged.connect(self.Pigment_HCY_1_Value_Modify) + self.layout.hcy_1_value.editingFinished.connect(self.Pigment_HCY_1_Value_Release) + # Channel CHROMA + self.hcy_2_slider.SIGNAL_HALF.connect(self.Pigment_HCY_2_Half) + self.hcy_2_slider.SIGNAL_MINUS.connect(self.Pigment_HCY_2_Minus) + self.hcy_2_slider.SIGNAL_PLUS.connect(self.Pigment_HCY_2_Plus) + self.hcy_2_slider.SIGNAL_VALUE.connect(self.Pigment_HCY_2_Slider_Modify) + self.hcy_2_slider.SIGNAL_RELEASE.connect(self.Pigment_HCY_2_Slider_Release) + self.hcy_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.hcy_2_value.valueChanged.connect(self.Pigment_HCY_2_Value_Modify) + self.layout.hcy_2_value.editingFinished.connect(self.Pigment_HCY_2_Value_Release) + # Channel Y (LUMA) + self.hcy_3_slider.SIGNAL_HALF.connect(self.Pigment_HCY_3_Half) + self.hcy_3_slider.SIGNAL_MINUS.connect(self.Pigment_HCY_3_Minus) + self.hcy_3_slider.SIGNAL_PLUS.connect(self.Pigment_HCY_3_Plus) + self.hcy_3_slider.SIGNAL_VALUE.connect(self.Pigment_HCY_3_Slider_Modify) + self.hcy_3_slider.SIGNAL_RELEASE.connect(self.Pigment_HCY_3_Slider_Release) + self.hcy_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.hcy_3_value.valueChanged.connect(self.Pigment_HCY_3_Value_Modify) + self.layout.hcy_3_value.editingFinished.connect(self.Pigment_HCY_3_Value_Release) + + + + # Channel X ############################################################ + self.xyz_1_slider.SIGNAL_HALF.connect(self.Pigment_XYZ_1_Half) + self.xyz_1_slider.SIGNAL_MINUS.connect(self.Pigment_XYZ_1_Minus) + self.xyz_1_slider.SIGNAL_PLUS.connect(self.Pigment_XYZ_1_Plus) + self.xyz_1_slider.SIGNAL_VALUE.connect(self.Pigment_XYZ_1_Slider_Modify) + self.xyz_1_slider.SIGNAL_RELEASE.connect(self.Pigment_XYZ_1_Slider_Release) + self.xyz_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.xyz_1_value.valueChanged.connect(self.Pigment_XYZ_1_Value_Modify) + self.layout.xyz_1_value.editingFinished.connect(self.Pigment_XYZ_1_Value_Release) + # Channel Y + self.xyz_2_slider.SIGNAL_HALF.connect(self.Pigment_XYZ_2_Half) + self.xyz_2_slider.SIGNAL_MINUS.connect(self.Pigment_XYZ_2_Minus) + self.xyz_2_slider.SIGNAL_PLUS.connect(self.Pigment_XYZ_2_Plus) + self.xyz_2_slider.SIGNAL_VALUE.connect(self.Pigment_XYZ_2_Slider_Modify) + self.xyz_2_slider.SIGNAL_RELEASE.connect(self.Pigment_XYZ_2_Slider_Release) + self.xyz_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.xyz_2_value.valueChanged.connect(self.Pigment_XYZ_2_Value_Modify) + self.layout.xyz_2_value.editingFinished.connect(self.Pigment_XYZ_2_Value_Release) + # Channel Z + self.xyz_3_slider.SIGNAL_HALF.connect(self.Pigment_XYZ_3_Half) + self.xyz_3_slider.SIGNAL_MINUS.connect(self.Pigment_XYZ_3_Minus) + self.xyz_3_slider.SIGNAL_PLUS.connect(self.Pigment_XYZ_3_Plus) + self.xyz_3_slider.SIGNAL_VALUE.connect(self.Pigment_XYZ_3_Slider_Modify) + self.xyz_3_slider.SIGNAL_RELEASE.connect(self.Pigment_XYZ_3_Slider_Release) + self.xyz_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.xyz_3_value.valueChanged.connect(self.Pigment_XYZ_3_Value_Modify) + self.layout.xyz_3_value.editingFinished.connect(self.Pigment_XYZ_3_Value_Release) + + # Channel Y + self.xyy_1_slider.SIGNAL_HALF.connect(self.Pigment_XYY_1_Half) + self.xyy_1_slider.SIGNAL_MINUS.connect(self.Pigment_XYY_1_Minus) + self.xyy_1_slider.SIGNAL_PLUS.connect(self.Pigment_XYY_1_Plus) + self.xyy_1_slider.SIGNAL_VALUE.connect(self.Pigment_XYY_1_Slider_Modify) + self.xyy_1_slider.SIGNAL_RELEASE.connect(self.Pigment_XYY_1_Slider_Release) + self.xyy_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.xyy_1_value.valueChanged.connect(self.Pigment_XYY_1_Value_Modify) + self.layout.xyy_1_value.editingFinished.connect(self.Pigment_XYY_1_Value_Release) + # Channel x + self.xyy_2_slider.SIGNAL_HALF.connect(self.Pigment_XYY_2_Half) + self.xyy_2_slider.SIGNAL_MINUS.connect(self.Pigment_XYY_2_Minus) + self.xyy_2_slider.SIGNAL_PLUS.connect(self.Pigment_XYY_2_Plus) + self.xyy_2_slider.SIGNAL_VALUE.connect(self.Pigment_XYY_2_Slider_Modify) + self.xyy_2_slider.SIGNAL_RELEASE.connect(self.Pigment_XYY_2_Slider_Release) + self.xyy_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.xyy_2_value.valueChanged.connect(self.Pigment_XYY_2_Value_Modify) + self.layout.xyy_2_value.editingFinished.connect(self.Pigment_XYY_2_Value_Release) + # Channel y + self.xyy_3_slider.SIGNAL_HALF.connect(self.Pigment_XYY_3_Half) + self.xyy_3_slider.SIGNAL_MINUS.connect(self.Pigment_XYY_3_Minus) + self.xyy_3_slider.SIGNAL_PLUS.connect(self.Pigment_XYY_3_Plus) + self.xyy_3_slider.SIGNAL_VALUE.connect(self.Pigment_XYY_3_Slider_Modify) + self.xyy_3_slider.SIGNAL_RELEASE.connect(self.Pigment_XYY_3_Slider_Release) + self.xyy_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.xyy_3_value.valueChanged.connect(self.Pigment_XYY_3_Value_Modify) + self.layout.xyy_3_value.editingFinished.connect(self.Pigment_XYY_3_Value_Release) + + # Channel Lightness + self.lab_1_slider.SIGNAL_HALF.connect(self.Pigment_LAB_1_Half) + self.lab_1_slider.SIGNAL_MINUS.connect(self.Pigment_LAB_1_Minus) + self.lab_1_slider.SIGNAL_PLUS.connect(self.Pigment_LAB_1_Plus) + self.lab_1_slider.SIGNAL_VALUE.connect(self.Pigment_LAB_1_Slider_Modify) + self.lab_1_slider.SIGNAL_RELEASE.connect(self.Pigment_LAB_1_Slider_Release) + self.lab_1_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.lab_1_value.valueChanged.connect(self.Pigment_LAB_1_Value_Modify) + self.layout.lab_1_value.editingFinished.connect(self.Pigment_LAB_1_Value_Release) + # Channel A + self.lab_2_slider.SIGNAL_HALF.connect(self.Pigment_LAB_2_Half) + self.lab_2_slider.SIGNAL_MINUS.connect(self.Pigment_LAB_2_Minus) + self.lab_2_slider.SIGNAL_PLUS.connect(self.Pigment_LAB_2_Plus) + self.lab_2_slider.SIGNAL_VALUE.connect(self.Pigment_LAB_2_Slider_Modify) + self.lab_2_slider.SIGNAL_RELEASE.connect(self.Pigment_LAB_2_Slider_Release) + self.lab_2_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.lab_2_value.valueChanged.connect(self.Pigment_LAB_2_Value_Modify) + self.layout.lab_2_value.editingFinished.connect(self.Pigment_LAB_2_Value_Release) + # Channel B + self.lab_3_slider.SIGNAL_HALF.connect(self.Pigment_LAB_3_Half) + self.lab_3_slider.SIGNAL_MINUS.connect(self.Pigment_LAB_3_Minus) + self.lab_3_slider.SIGNAL_PLUS.connect(self.Pigment_LAB_3_Plus) + self.lab_3_slider.SIGNAL_VALUE.connect(self.Pigment_LAB_3_Slider_Modify) + self.lab_3_slider.SIGNAL_RELEASE.connect(self.Pigment_LAB_3_Slider_Release) + self.lab_3_slider.SIGNAL_ZOOM.connect(self.Signal_Panel_Zoom) + self.layout.lab_3_value.valueChanged.connect(self.Pigment_LAB_3_Value_Modify) + self.layout.lab_3_value.editingFinished.connect(self.Pigment_LAB_3_Value_Release) + + #// + def Palette(self): + # Palette Colors + self.palette_cor_00 = Clicks(self.layout.cor_00) + self.palette_cor_01 = Clicks(self.layout.cor_01) + self.palette_cor_02 = Clicks(self.layout.cor_02) + self.palette_cor_03 = Clicks(self.layout.cor_03) + self.palette_cor_04 = Clicks(self.layout.cor_04) + self.palette_cor_05 = Clicks(self.layout.cor_05) + self.palette_cor_06 = Clicks(self.layout.cor_06) + self.palette_cor_07 = Clicks(self.layout.cor_07) + self.palette_cor_08 = Clicks(self.layout.cor_08) + self.palette_cor_09 = Clicks(self.layout.cor_09) + self.palette_cor_10 = Clicks(self.layout.cor_10) + # Palette Signal + self.palette_cor_00.SIGNAL_APPLY.connect(self.Cor_00_APPLY) + self.palette_cor_01.SIGNAL_APPLY.connect(self.Cor_01_APPLY) + self.palette_cor_02.SIGNAL_APPLY.connect(self.Cor_02_APPLY) + self.palette_cor_03.SIGNAL_APPLY.connect(self.Cor_03_APPLY) + self.palette_cor_04.SIGNAL_APPLY.connect(self.Cor_04_APPLY) + self.palette_cor_05.SIGNAL_APPLY.connect(self.Cor_05_APPLY) + self.palette_cor_06.SIGNAL_APPLY.connect(self.Cor_06_APPLY) + self.palette_cor_07.SIGNAL_APPLY.connect(self.Cor_07_APPLY) + self.palette_cor_08.SIGNAL_APPLY.connect(self.Cor_08_APPLY) + self.palette_cor_09.SIGNAL_APPLY.connect(self.Cor_09_APPLY) + self.palette_cor_10.SIGNAL_APPLY.connect(self.Cor_10_APPLY) + self.palette_cor_00.SIGNAL_SAVE.connect(self.Cor_00_SAVE) + self.palette_cor_01.SIGNAL_SAVE.connect(self.Cor_01_SAVE) + self.palette_cor_02.SIGNAL_SAVE.connect(self.Cor_02_SAVE) + self.palette_cor_03.SIGNAL_SAVE.connect(self.Cor_03_SAVE) + self.palette_cor_04.SIGNAL_SAVE.connect(self.Cor_04_SAVE) + self.palette_cor_05.SIGNAL_SAVE.connect(self.Cor_05_SAVE) + self.palette_cor_06.SIGNAL_SAVE.connect(self.Cor_06_SAVE) + self.palette_cor_07.SIGNAL_SAVE.connect(self.Cor_07_SAVE) + self.palette_cor_08.SIGNAL_SAVE.connect(self.Cor_08_SAVE) + self.palette_cor_09.SIGNAL_SAVE.connect(self.Cor_09_SAVE) + self.palette_cor_10.SIGNAL_SAVE.connect(self.Cor_10_SAVE) + self.palette_cor_00.SIGNAL_CLEAN.connect(self.Cor_00_CLEAN) + self.palette_cor_01.SIGNAL_CLEAN.connect(self.Cor_01_CLEAN) + self.palette_cor_02.SIGNAL_CLEAN.connect(self.Cor_02_CLEAN) + self.palette_cor_03.SIGNAL_CLEAN.connect(self.Cor_03_CLEAN) + self.palette_cor_04.SIGNAL_CLEAN.connect(self.Cor_04_CLEAN) + self.palette_cor_05.SIGNAL_CLEAN.connect(self.Cor_05_CLEAN) + self.palette_cor_06.SIGNAL_CLEAN.connect(self.Cor_06_CLEAN) + self.palette_cor_07.SIGNAL_CLEAN.connect(self.Cor_07_CLEAN) + self.palette_cor_08.SIGNAL_CLEAN.connect(self.Cor_08_CLEAN) + self.palette_cor_09.SIGNAL_CLEAN.connect(self.Cor_09_CLEAN) + self.palette_cor_10.SIGNAL_CLEAN.connect(self.Cor_10_CLEAN) + def Mixers(self): + #\\ Module Mixer Colors ################################################ + self.mixer_tts = Clicks(self.layout.tts_l1) + self.mixer_rgb_l1 = Clicks(self.layout.rgb_l1) + self.mixer_rgb_l2 = Clicks(self.layout.rgb_l2) + self.mixer_rgb_l3 = Clicks(self.layout.rgb_l3) + self.mixer_rgb_r1 = Clicks(self.layout.rgb_r1) + self.mixer_rgb_r2 = Clicks(self.layout.rgb_r2) + self.mixer_rgb_r3 = Clicks(self.layout.rgb_r3) + self.mixer_cmyk_l1 = Clicks(self.layout.cmyk_l1) + self.mixer_cmyk_l2 = Clicks(self.layout.cmyk_l2) + self.mixer_cmyk_l3 = Clicks(self.layout.cmyk_l3) + self.mixer_cmyk_r1 = Clicks(self.layout.cmyk_r1) + self.mixer_cmyk_r2 = Clicks(self.layout.cmyk_r2) + self.mixer_cmyk_r3 = Clicks(self.layout.cmyk_r3) + self.mixer_ryb_l1 = Clicks(self.layout.ryb_l1) + self.mixer_ryb_l2 = Clicks(self.layout.ryb_l2) + self.mixer_ryb_l3 = Clicks(self.layout.ryb_l3) + self.mixer_ryb_r1 = Clicks(self.layout.ryb_r1) + self.mixer_ryb_r2 = Clicks(self.layout.ryb_r2) + self.mixer_ryb_r3 = Clicks(self.layout.ryb_r3) + self.mixer_yuv_l1 = Clicks(self.layout.yuv_l1) + self.mixer_yuv_l2 = Clicks(self.layout.yuv_l2) + self.mixer_yuv_l3 = Clicks(self.layout.yuv_l3) + self.mixer_yuv_r1 = Clicks(self.layout.yuv_r1) + self.mixer_yuv_r2 = Clicks(self.layout.yuv_r2) + self.mixer_yuv_r3 = Clicks(self.layout.yuv_r3) + + self.mixer_ard_l1 = Clicks(self.layout.ard_l1) + self.mixer_ard_l2 = Clicks(self.layout.ard_l2) + self.mixer_ard_l3 = Clicks(self.layout.ard_l3) + self.mixer_ard_r1 = Clicks(self.layout.ard_r1) + self.mixer_ard_r2 = Clicks(self.layout.ard_r2) + self.mixer_ard_r3 = Clicks(self.layout.ard_r3) + self.mixer_hsv_l1 = Clicks(self.layout.hsv_l1) + self.mixer_hsv_l2 = Clicks(self.layout.hsv_l2) + self.mixer_hsv_l3 = Clicks(self.layout.hsv_l3) + self.mixer_hsv_r1 = Clicks(self.layout.hsv_r1) + self.mixer_hsv_r2 = Clicks(self.layout.hsv_r2) + self.mixer_hsv_r3 = Clicks(self.layout.hsv_r3) + self.mixer_hsl_l1 = Clicks(self.layout.hsl_l1) + self.mixer_hsl_l2 = Clicks(self.layout.hsl_l2) + self.mixer_hsl_l3 = Clicks(self.layout.hsl_l3) + self.mixer_hsl_r1 = Clicks(self.layout.hsl_r1) + self.mixer_hsl_r2 = Clicks(self.layout.hsl_r2) + self.mixer_hsl_r3 = Clicks(self.layout.hsl_r3) + self.mixer_hcy_l1 = Clicks(self.layout.hcy_l1) + self.mixer_hcy_l2 = Clicks(self.layout.hcy_l2) + self.mixer_hcy_l3 = Clicks(self.layout.hcy_l3) + self.mixer_hcy_r1 = Clicks(self.layout.hcy_r1) + self.mixer_hcy_r2 = Clicks(self.layout.hcy_r2) + self.mixer_hcy_r3 = Clicks(self.layout.hcy_r3) + + # TTS connection + self.mixer_tts.SIGNAL_APPLY.connect(self.Mixer_TTS_APPLY) + self.mixer_tts.SIGNAL_SAVE.connect(self.Mixer_TTS_SAVE) + self.mixer_tts.SIGNAL_CLEAN.connect(self.Mixer_TTS_CLEAN) + # RGB connection + self.mixer_rgb_l1.SIGNAL_APPLY.connect(self.Mixer_RGB_L1_APPLY) + self.mixer_rgb_r1.SIGNAL_APPLY.connect(self.Mixer_RGB_R1_APPLY) + self.mixer_rgb_l2.SIGNAL_APPLY.connect(self.Mixer_RGB_L2_APPLY) + self.mixer_rgb_r2.SIGNAL_APPLY.connect(self.Mixer_RGB_R2_APPLY) + self.mixer_rgb_l3.SIGNAL_APPLY.connect(self.Mixer_RGB_L3_APPLY) + self.mixer_rgb_r3.SIGNAL_APPLY.connect(self.Mixer_RGB_R3_APPLY) + self.mixer_rgb_l1.SIGNAL_SAVE.connect(self.Mixer_RGB_L1_SAVE) + self.mixer_rgb_r1.SIGNAL_SAVE.connect(self.Mixer_RGB_R1_SAVE) + self.mixer_rgb_l2.SIGNAL_SAVE.connect(self.Mixer_RGB_L2_SAVE) + self.mixer_rgb_r2.SIGNAL_SAVE.connect(self.Mixer_RGB_R2_SAVE) + self.mixer_rgb_l3.SIGNAL_SAVE.connect(self.Mixer_RGB_L3_SAVE) + self.mixer_rgb_r3.SIGNAL_SAVE.connect(self.Mixer_RGB_R3_SAVE) + self.mixer_rgb_l1.SIGNAL_CLEAN.connect(self.Mixer_RGB_L1_CLEAN) + self.mixer_rgb_r1.SIGNAL_CLEAN.connect(self.Mixer_RGB_R1_CLEAN) + self.mixer_rgb_l2.SIGNAL_CLEAN.connect(self.Mixer_RGB_L2_CLEAN) + self.mixer_rgb_r2.SIGNAL_CLEAN.connect(self.Mixer_RGB_R2_CLEAN) + self.mixer_rgb_l3.SIGNAL_CLEAN.connect(self.Mixer_RGB_L3_CLEAN) + self.mixer_rgb_r3.SIGNAL_CLEAN.connect(self.Mixer_RGB_R3_CLEAN) + # CMYK connection + self.mixer_cmyk_l1.SIGNAL_APPLY.connect(self.Mixer_CMYK_L1_APPLY) + self.mixer_cmyk_r1.SIGNAL_APPLY.connect(self.Mixer_CMYK_R1_APPLY) + self.mixer_cmyk_l2.SIGNAL_APPLY.connect(self.Mixer_CMYK_L2_APPLY) + self.mixer_cmyk_r2.SIGNAL_APPLY.connect(self.Mixer_CMYK_R2_APPLY) + self.mixer_cmyk_l3.SIGNAL_APPLY.connect(self.Mixer_CMYK_L3_APPLY) + self.mixer_cmyk_r3.SIGNAL_APPLY.connect(self.Mixer_CMYK_R3_APPLY) + self.mixer_cmyk_l1.SIGNAL_SAVE.connect(self.Mixer_CMYK_L1_SAVE) + self.mixer_cmyk_r1.SIGNAL_SAVE.connect(self.Mixer_CMYK_R1_SAVE) + self.mixer_cmyk_l2.SIGNAL_SAVE.connect(self.Mixer_CMYK_L2_SAVE) + self.mixer_cmyk_r2.SIGNAL_SAVE.connect(self.Mixer_CMYK_R2_SAVE) + self.mixer_cmyk_l3.SIGNAL_SAVE.connect(self.Mixer_CMYK_L3_SAVE) + self.mixer_cmyk_r3.SIGNAL_SAVE.connect(self.Mixer_CMYK_R3_SAVE) + self.mixer_cmyk_l1.SIGNAL_CLEAN.connect(self.Mixer_CMYK_L1_CLEAN) + self.mixer_cmyk_r1.SIGNAL_CLEAN.connect(self.Mixer_CMYK_R1_CLEAN) + self.mixer_cmyk_l2.SIGNAL_CLEAN.connect(self.Mixer_CMYK_L2_CLEAN) + self.mixer_cmyk_r2.SIGNAL_CLEAN.connect(self.Mixer_CMYK_R2_CLEAN) + self.mixer_cmyk_l3.SIGNAL_CLEAN.connect(self.Mixer_CMYK_L3_CLEAN) + self.mixer_cmyk_r3.SIGNAL_CLEAN.connect(self.Mixer_CMYK_R3_CLEAN) + # RYB connection + self.mixer_ryb_l1.SIGNAL_APPLY.connect(self.Mixer_RYB_L1_APPLY) + self.mixer_ryb_r1.SIGNAL_APPLY.connect(self.Mixer_RYB_R1_APPLY) + self.mixer_ryb_l2.SIGNAL_APPLY.connect(self.Mixer_RYB_L2_APPLY) + self.mixer_ryb_r2.SIGNAL_APPLY.connect(self.Mixer_RYB_R2_APPLY) + self.mixer_ryb_l3.SIGNAL_APPLY.connect(self.Mixer_RYB_L3_APPLY) + self.mixer_ryb_r3.SIGNAL_APPLY.connect(self.Mixer_RYB_R3_APPLY) + self.mixer_ryb_l1.SIGNAL_SAVE.connect(self.Mixer_RYB_L1_SAVE) + self.mixer_ryb_r1.SIGNAL_SAVE.connect(self.Mixer_RYB_R1_SAVE) + self.mixer_ryb_l2.SIGNAL_SAVE.connect(self.Mixer_RYB_L2_SAVE) + self.mixer_ryb_r2.SIGNAL_SAVE.connect(self.Mixer_RYB_R2_SAVE) + self.mixer_ryb_l3.SIGNAL_SAVE.connect(self.Mixer_RYB_L3_SAVE) + self.mixer_ryb_r3.SIGNAL_SAVE.connect(self.Mixer_RYB_R3_SAVE) + self.mixer_ryb_l1.SIGNAL_CLEAN.connect(self.Mixer_RYB_L1_CLEAN) + self.mixer_ryb_r1.SIGNAL_CLEAN.connect(self.Mixer_RYB_R1_CLEAN) + self.mixer_ryb_l2.SIGNAL_CLEAN.connect(self.Mixer_RYB_L2_CLEAN) + self.mixer_ryb_r2.SIGNAL_CLEAN.connect(self.Mixer_RYB_R2_CLEAN) + self.mixer_ryb_l3.SIGNAL_CLEAN.connect(self.Mixer_RYB_L3_CLEAN) + self.mixer_ryb_r3.SIGNAL_CLEAN.connect(self.Mixer_RYB_R3_CLEAN) + # YUV connection + self.mixer_yuv_l1.SIGNAL_APPLY.connect(self.Mixer_YUV_L1_APPLY) + self.mixer_yuv_r1.SIGNAL_APPLY.connect(self.Mixer_YUV_R1_APPLY) + self.mixer_yuv_l2.SIGNAL_APPLY.connect(self.Mixer_YUV_L2_APPLY) + self.mixer_yuv_r2.SIGNAL_APPLY.connect(self.Mixer_YUV_R2_APPLY) + self.mixer_yuv_l3.SIGNAL_APPLY.connect(self.Mixer_YUV_L3_APPLY) + self.mixer_yuv_r3.SIGNAL_APPLY.connect(self.Mixer_YUV_R3_APPLY) + self.mixer_yuv_l1.SIGNAL_SAVE.connect(self.Mixer_YUV_L1_SAVE) + self.mixer_yuv_r1.SIGNAL_SAVE.connect(self.Mixer_YUV_R1_SAVE) + self.mixer_yuv_l2.SIGNAL_SAVE.connect(self.Mixer_YUV_L2_SAVE) + self.mixer_yuv_r2.SIGNAL_SAVE.connect(self.Mixer_YUV_R2_SAVE) + self.mixer_yuv_l3.SIGNAL_SAVE.connect(self.Mixer_YUV_L3_SAVE) + self.mixer_yuv_r3.SIGNAL_SAVE.connect(self.Mixer_YUV_R3_SAVE) + self.mixer_yuv_l1.SIGNAL_CLEAN.connect(self.Mixer_YUV_L1_CLEAN) + self.mixer_yuv_r1.SIGNAL_CLEAN.connect(self.Mixer_YUV_R1_CLEAN) + self.mixer_yuv_l2.SIGNAL_CLEAN.connect(self.Mixer_YUV_L2_CLEAN) + self.mixer_yuv_r2.SIGNAL_CLEAN.connect(self.Mixer_YUV_R2_CLEAN) + self.mixer_yuv_l3.SIGNAL_CLEAN.connect(self.Mixer_YUV_L3_CLEAN) + self.mixer_yuv_r3.SIGNAL_CLEAN.connect(self.Mixer_YUV_R3_CLEAN) + + # ARD connection + self.mixer_ard_l1.SIGNAL_APPLY.connect(self.Mixer_ARD_L1_APPLY) + self.mixer_ard_r1.SIGNAL_APPLY.connect(self.Mixer_ARD_R1_APPLY) + self.mixer_ard_l2.SIGNAL_APPLY.connect(self.Mixer_ARD_L2_APPLY) + self.mixer_ard_r2.SIGNAL_APPLY.connect(self.Mixer_ARD_R2_APPLY) + self.mixer_ard_l3.SIGNAL_APPLY.connect(self.Mixer_ARD_L3_APPLY) + self.mixer_ard_r3.SIGNAL_APPLY.connect(self.Mixer_ARD_R3_APPLY) + self.mixer_ard_l1.SIGNAL_SAVE.connect(self.Mixer_ARD_L1_SAVE) + self.mixer_ard_r1.SIGNAL_SAVE.connect(self.Mixer_ARD_R1_SAVE) + self.mixer_ard_l2.SIGNAL_SAVE.connect(self.Mixer_ARD_L2_SAVE) + self.mixer_ard_r2.SIGNAL_SAVE.connect(self.Mixer_ARD_R2_SAVE) + self.mixer_ard_l3.SIGNAL_SAVE.connect(self.Mixer_ARD_L3_SAVE) + self.mixer_ard_r3.SIGNAL_SAVE.connect(self.Mixer_ARD_R3_SAVE) + self.mixer_ard_l1.SIGNAL_CLEAN.connect(self.Mixer_ARD_L1_CLEAN) + self.mixer_ard_r1.SIGNAL_CLEAN.connect(self.Mixer_ARD_R1_CLEAN) + self.mixer_ard_l2.SIGNAL_CLEAN.connect(self.Mixer_ARD_L2_CLEAN) + self.mixer_ard_r2.SIGNAL_CLEAN.connect(self.Mixer_ARD_R2_CLEAN) + self.mixer_ard_l3.SIGNAL_CLEAN.connect(self.Mixer_ARD_L3_CLEAN) + self.mixer_ard_r3.SIGNAL_CLEAN.connect(self.Mixer_ARD_R3_CLEAN) + # HSV connection + self.mixer_hsv_l1.SIGNAL_APPLY.connect(self.Mixer_HSV_L1_APPLY) + self.mixer_hsv_r1.SIGNAL_APPLY.connect(self.Mixer_HSV_R1_APPLY) + self.mixer_hsv_l2.SIGNAL_APPLY.connect(self.Mixer_HSV_L2_APPLY) + self.mixer_hsv_r2.SIGNAL_APPLY.connect(self.Mixer_HSV_R2_APPLY) + self.mixer_hsv_l3.SIGNAL_APPLY.connect(self.Mixer_HSV_L3_APPLY) + self.mixer_hsv_r3.SIGNAL_APPLY.connect(self.Mixer_HSV_R3_APPLY) + self.mixer_hsv_l1.SIGNAL_SAVE.connect(self.Mixer_HSV_L1_SAVE) + self.mixer_hsv_r1.SIGNAL_SAVE.connect(self.Mixer_HSV_R1_SAVE) + self.mixer_hsv_l2.SIGNAL_SAVE.connect(self.Mixer_HSV_L2_SAVE) + self.mixer_hsv_r2.SIGNAL_SAVE.connect(self.Mixer_HSV_R2_SAVE) + self.mixer_hsv_l3.SIGNAL_SAVE.connect(self.Mixer_HSV_L3_SAVE) + self.mixer_hsv_r3.SIGNAL_SAVE.connect(self.Mixer_HSV_R3_SAVE) + self.mixer_hsv_l1.SIGNAL_CLEAN.connect(self.Mixer_HSV_L1_CLEAN) + self.mixer_hsv_r1.SIGNAL_CLEAN.connect(self.Mixer_HSV_R1_CLEAN) + self.mixer_hsv_l2.SIGNAL_CLEAN.connect(self.Mixer_HSV_L2_CLEAN) + self.mixer_hsv_r2.SIGNAL_CLEAN.connect(self.Mixer_HSV_R2_CLEAN) + self.mixer_hsv_l3.SIGNAL_CLEAN.connect(self.Mixer_HSV_L3_CLEAN) + self.mixer_hsv_r3.SIGNAL_CLEAN.connect(self.Mixer_HSV_R3_CLEAN) + # HSL connection + self.mixer_hsl_l1.SIGNAL_APPLY.connect(self.Mixer_HSL_L1_APPLY) + self.mixer_hsl_r1.SIGNAL_APPLY.connect(self.Mixer_HSL_R1_APPLY) + self.mixer_hsl_l2.SIGNAL_APPLY.connect(self.Mixer_HSL_L2_APPLY) + self.mixer_hsl_r2.SIGNAL_APPLY.connect(self.Mixer_HSL_R2_APPLY) + self.mixer_hsl_l3.SIGNAL_APPLY.connect(self.Mixer_HSL_L3_APPLY) + self.mixer_hsl_r3.SIGNAL_APPLY.connect(self.Mixer_HSL_R3_APPLY) + self.mixer_hsl_l1.SIGNAL_SAVE.connect(self.Mixer_HSL_L1_SAVE) + self.mixer_hsl_r1.SIGNAL_SAVE.connect(self.Mixer_HSL_R1_SAVE) + self.mixer_hsl_l2.SIGNAL_SAVE.connect(self.Mixer_HSL_L2_SAVE) + self.mixer_hsl_r2.SIGNAL_SAVE.connect(self.Mixer_HSL_R2_SAVE) + self.mixer_hsl_l3.SIGNAL_SAVE.connect(self.Mixer_HSL_L3_SAVE) + self.mixer_hsl_r3.SIGNAL_SAVE.connect(self.Mixer_HSL_R3_SAVE) + self.mixer_hsl_l1.SIGNAL_CLEAN.connect(self.Mixer_HSL_L1_CLEAN) + self.mixer_hsl_r1.SIGNAL_CLEAN.connect(self.Mixer_HSL_R1_CLEAN) + self.mixer_hsl_l2.SIGNAL_CLEAN.connect(self.Mixer_HSL_L2_CLEAN) + self.mixer_hsl_r2.SIGNAL_CLEAN.connect(self.Mixer_HSL_R2_CLEAN) + self.mixer_hsl_l3.SIGNAL_CLEAN.connect(self.Mixer_HSL_L3_CLEAN) + self.mixer_hsl_r3.SIGNAL_CLEAN.connect(self.Mixer_HSL_R3_CLEAN) + # HCY connection + self.mixer_hcy_l1.SIGNAL_APPLY.connect(self.Mixer_HCY_L1_APPLY) + self.mixer_hcy_r1.SIGNAL_APPLY.connect(self.Mixer_HCY_R1_APPLY) + self.mixer_hcy_l2.SIGNAL_APPLY.connect(self.Mixer_HCY_L2_APPLY) + self.mixer_hcy_r2.SIGNAL_APPLY.connect(self.Mixer_HCY_R2_APPLY) + self.mixer_hcy_l3.SIGNAL_APPLY.connect(self.Mixer_HCY_L3_APPLY) + self.mixer_hcy_r3.SIGNAL_APPLY.connect(self.Mixer_HCY_R3_APPLY) + self.mixer_hcy_l1.SIGNAL_SAVE.connect(self.Mixer_HCY_L1_SAVE) + self.mixer_hcy_r1.SIGNAL_SAVE.connect(self.Mixer_HCY_R1_SAVE) + self.mixer_hcy_l2.SIGNAL_SAVE.connect(self.Mixer_HCY_L2_SAVE) + self.mixer_hcy_r2.SIGNAL_SAVE.connect(self.Mixer_HCY_R2_SAVE) + self.mixer_hcy_l3.SIGNAL_SAVE.connect(self.Mixer_HCY_L3_SAVE) + self.mixer_hcy_r3.SIGNAL_SAVE.connect(self.Mixer_HCY_R3_SAVE) + self.mixer_hcy_l1.SIGNAL_CLEAN.connect(self.Mixer_HCY_L1_CLEAN) + self.mixer_hcy_r1.SIGNAL_CLEAN.connect(self.Mixer_HCY_R1_CLEAN) + self.mixer_hcy_l2.SIGNAL_CLEAN.connect(self.Mixer_HCY_L2_CLEAN) + self.mixer_hcy_r2.SIGNAL_CLEAN.connect(self.Mixer_HCY_R2_CLEAN) + self.mixer_hcy_l3.SIGNAL_CLEAN.connect(self.Mixer_HCY_L3_CLEAN) + self.mixer_hcy_r3.SIGNAL_CLEAN.connect(self.Mixer_HCY_R3_CLEAN) + + #// + #\\ Module Mixer Gradients ############################################# + self.mixer_tint = Mixer_Linear(self.layout.tint) + self.mixer_tone = Mixer_Linear(self.layout.tone) + self.mixer_shade = Mixer_Linear(self.layout.shade) + + self.mixer_rgb_g1 = Mixer_Linear(self.layout.rgb_g1) + self.mixer_rgb_g2 = Mixer_Linear(self.layout.rgb_g2) + self.mixer_rgb_g3 = Mixer_Linear(self.layout.rgb_g3) + self.mixer_cmyk_g1 = Mixer_Linear(self.layout.cmyk_g1) + self.mixer_cmyk_g2 = Mixer_Linear(self.layout.cmyk_g2) + self.mixer_cmyk_g3 = Mixer_Linear(self.layout.cmyk_g3) + self.mixer_ryb_g1 = Mixer_Linear(self.layout.ryb_g1) + self.mixer_ryb_g2 = Mixer_Linear(self.layout.ryb_g2) + self.mixer_ryb_g3 = Mixer_Linear(self.layout.ryb_g3) + self.mixer_yuv_g1 = Mixer_Linear(self.layout.yuv_g1) + self.mixer_yuv_g2 = Mixer_Linear(self.layout.yuv_g2) + self.mixer_yuv_g3 = Mixer_Linear(self.layout.yuv_g3) + + self.mixer_ard_g1 = Mixer_Linear(self.layout.ard_g1) + self.mixer_ard_g2 = Mixer_Linear(self.layout.ard_g2) + self.mixer_ard_g3 = Mixer_Linear(self.layout.ard_g3) + self.mixer_hsv_g1 = Mixer_Linear(self.layout.hsv_g1) + self.mixer_hsv_g2 = Mixer_Linear(self.layout.hsv_g2) + self.mixer_hsv_g3 = Mixer_Linear(self.layout.hsv_g3) + self.mixer_hsl_g1 = Mixer_Linear(self.layout.hsl_g1) + self.mixer_hsl_g2 = Mixer_Linear(self.layout.hsl_g2) + self.mixer_hsl_g3 = Mixer_Linear(self.layout.hsl_g3) + self.mixer_hcy_g1 = Mixer_Linear(self.layout.hcy_g1) + self.mixer_hcy_g2 = Mixer_Linear(self.layout.hcy_g2) + self.mixer_hcy_g3 = Mixer_Linear(self.layout.hcy_g3) + + self.mixer_xyz_g1 = Mixer_Linear(self.layout.xyz_g1) + self.mixer_xyz_g2 = Mixer_Linear(self.layout.xyz_g2) + self.mixer_xyz_g3 = Mixer_Linear(self.layout.xyz_g3) + self.mixer_xyy_g1 = Mixer_Linear(self.layout.xyy_g1) + self.mixer_xyy_g2 = Mixer_Linear(self.layout.xyy_g2) + self.mixer_xyy_g3 = Mixer_Linear(self.layout.xyy_g3) + self.mixer_luv_g1 = Mixer_Linear(self.layout.luv_g1) + self.mixer_luv_g2 = Mixer_Linear(self.layout.luv_g2) + self.mixer_luv_g3 = Mixer_Linear(self.layout.luv_g3) + self.mixer_hlab_g1 = Mixer_Linear(self.layout.hlab_g1) + self.mixer_hlab_g2 = Mixer_Linear(self.layout.hlab_g2) + self.mixer_hlab_g3 = Mixer_Linear(self.layout.hlab_g3) + self.mixer_lab_g1 = Mixer_Linear(self.layout.lab_g1) + self.mixer_lab_g2 = Mixer_Linear(self.layout.lab_g2) + self.mixer_lab_g3 = Mixer_Linear(self.layout.lab_g3) + self.mixer_lch_g1 = Mixer_Linear(self.layout.lch_g1) + self.mixer_lch_g2 = Mixer_Linear(self.layout.lch_g2) + self.mixer_lch_g3 = Mixer_Linear(self.layout.lch_g3) + + # Mixer Gradient Connect + self.mixer_tint.SIGNAL_MIXER_VALUE.connect(self.Mixer_Tint) + self.mixer_tone.SIGNAL_MIXER_VALUE.connect(self.Mixer_Tone) + self.mixer_shade.SIGNAL_MIXER_VALUE.connect(self.Mixer_Shade) + + self.mixer_rgb_g1.SIGNAL_MIXER_VALUE.connect(self.Mixer_RGB_G1) + self.mixer_rgb_g2.SIGNAL_MIXER_VALUE.connect(self.Mixer_RGB_G2) + self.mixer_rgb_g3.SIGNAL_MIXER_VALUE.connect(self.Mixer_RGB_G3) + self.mixer_cmyk_g1.SIGNAL_MIXER_VALUE.connect(self.Mixer_CMYK_G1) + self.mixer_cmyk_g2.SIGNAL_MIXER_VALUE.connect(self.Mixer_CMYK_G2) + self.mixer_cmyk_g3.SIGNAL_MIXER_VALUE.connect(self.Mixer_CMYK_G3) + self.mixer_ryb_g1.SIGNAL_MIXER_VALUE.connect(self.Mixer_RYB_G1) + self.mixer_ryb_g2.SIGNAL_MIXER_VALUE.connect(self.Mixer_RYB_G2) + self.mixer_ryb_g3.SIGNAL_MIXER_VALUE.connect(self.Mixer_RYB_G3) + self.mixer_yuv_g1.SIGNAL_MIXER_VALUE.connect(self.Mixer_YUV_G1) + self.mixer_yuv_g2.SIGNAL_MIXER_VALUE.connect(self.Mixer_YUV_G2) + self.mixer_yuv_g3.SIGNAL_MIXER_VALUE.connect(self.Mixer_YUV_G3) + + self.mixer_ard_g1.SIGNAL_MIXER_VALUE.connect(self.Mixer_ARD_G1) + self.mixer_ard_g2.SIGNAL_MIXER_VALUE.connect(self.Mixer_ARD_G2) + self.mixer_ard_g3.SIGNAL_MIXER_VALUE.connect(self.Mixer_ARD_G3) + self.mixer_hsv_g1.SIGNAL_MIXER_VALUE.connect(self.Mixer_HSV_G1) + self.mixer_hsv_g2.SIGNAL_MIXER_VALUE.connect(self.Mixer_HSV_G2) + self.mixer_hsv_g3.SIGNAL_MIXER_VALUE.connect(self.Mixer_HSV_G3) + self.mixer_hsl_g1.SIGNAL_MIXER_VALUE.connect(self.Mixer_HSL_G1) + self.mixer_hsl_g2.SIGNAL_MIXER_VALUE.connect(self.Mixer_HSL_G2) + self.mixer_hsl_g3.SIGNAL_MIXER_VALUE.connect(self.Mixer_HSL_G3) + self.mixer_hcy_g1.SIGNAL_MIXER_VALUE.connect(self.Mixer_HCY_G1) + self.mixer_hcy_g2.SIGNAL_MIXER_VALUE.connect(self.Mixer_HCY_G2) + self.mixer_hcy_g3.SIGNAL_MIXER_VALUE.connect(self.Mixer_HCY_G3) + + # Previous Selected Mixer Sliders + self.mixer_tint.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_tone.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_shade.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + + self.mixer_rgb_g1.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_rgb_g2.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_rgb_g3.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_cmyk_g1.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_cmyk_g2.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_cmyk_g3.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_ryb_g1.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_ryb_g2.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_ryb_g3.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_yuv_g1.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_yuv_g2.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_yuv_g3.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + + self.mixer_ard_g1.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_ard_g2.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_ard_g3.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_hsv_g1.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_hsv_g2.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_hsv_g3.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_hsl_g1.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_hsl_g2.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_hsl_g3.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_hcy_g1.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_hcy_g2.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + self.mixer_hcy_g3.SIGNAL_MIXER_RELEASE.connect(self.Pigment_Release) + + #// + def History(self): + self.layout.color_history.clicked.connect(self.History_APPLY) + def Style(self): + # Size + if self.OS == "winnt": + self.layout.state.setMaximumWidth(50) + else: + self.layout.state.setMaximumWidth(46) + + # UI Percentage Gradients Display + p4 = self.Percentage("P4L") + p6 = self.Percentage("P6L") + p10 = self.Percentage("P10A") + ten = self.Percentage("P10B") + thirds = self.Percentage("P3B") + + # Panels + self.layout.panel_uvd.setStyleSheet(self.bg_alpha) + self.layout.panel_ard.setStyleSheet(thirds) + self.layout.panel_hue.setStyleSheet(self.bg_alpha) + self.layout.panel_hue_box.setStyleSheet(self.bg_unseen) + self.layout.panel_gam.setStyleSheet(self.bg_alpha) + self.layout.panel_gam_box.setStyleSheet(self.bg_unseen) + self.layout.panel_dot_mix.setStyleSheet(self.bg_alpha) + self.layout.dot_1.setStyleSheet(self.bg_alpha) + self.layout.dot_2.setStyleSheet(self.bg_alpha) + self.layout.dot_3.setStyleSheet(self.bg_alpha) + self.layout.dot_4.setStyleSheet(self.bg_alpha) + + # Color Spaces + self.layout.aaa_1_tick.setStyleSheet(p10) + self.layout.rgb_1_tick.setStyleSheet(p10) + self.layout.rgb_2_tick.setStyleSheet(p10) + self.layout.rgb_3_tick.setStyleSheet(p10) + self.layout.cmy_1_tick.setStyleSheet(p10) + self.layout.cmy_2_tick.setStyleSheet(p10) + self.layout.cmy_3_tick.setStyleSheet(p10) + self.layout.cmyk_1_tick.setStyleSheet(p10) + self.layout.cmyk_2_tick.setStyleSheet(p10) + self.layout.cmyk_3_tick.setStyleSheet(p10) + self.layout.cmyk_4_tick.setStyleSheet(p10) + self.layout.ryb_1_tick.setStyleSheet(p10) + self.layout.ryb_2_tick.setStyleSheet(p10) + self.layout.ryb_3_tick.setStyleSheet(p10) + self.layout.yuv_1_tick.setStyleSheet(p10) + self.layout.yuv_2_tick.setStyleSheet(p10) + self.layout.yuv_3_tick.setStyleSheet(p10) + self.layout.kkk_1_tick.setStyleSheet(p10) + + self.layout.ard_1_tick.setStyleSheet(p6) + self.layout.ard_2_tick.setStyleSheet(p10) + self.layout.ard_3_tick.setStyleSheet(p6) + self.layout.hsv_1_tick.setStyleSheet(p6) + self.layout.hsv_2_tick.setStyleSheet(p10) + self.layout.hsv_3_tick.setStyleSheet(p10) + self.layout.hsl_1_tick.setStyleSheet(p6) + self.layout.hsl_2_tick.setStyleSheet(p10) + self.layout.hsl_3_tick.setStyleSheet(p10) + self.layout.hcy_1_tick.setStyleSheet(p6) + self.layout.hcy_2_tick.setStyleSheet(p10) + self.layout.hcy_3_tick.setStyleSheet(p10) + + self.layout.xyz_1_tick.setStyleSheet(p10) + self.layout.xyz_2_tick.setStyleSheet(p10) + self.layout.xyz_3_tick.setStyleSheet(p10) + self.layout.xyy_1_tick.setStyleSheet(p10) + self.layout.xyy_2_tick.setStyleSheet(p10) + self.layout.xyy_3_tick.setStyleSheet(p10) + self.layout.luv_1_tick.setStyleSheet(p10) + self.layout.luv_2_tick.setStyleSheet(p10) + self.layout.luv_3_tick.setStyleSheet(p10) + self.layout.hlab_1_tick.setStyleSheet(p10) + self.layout.hlab_2_tick.setStyleSheet(p10) + self.layout.hlab_3_tick.setStyleSheet(p10) + self.layout.lab_1_tick.setStyleSheet(p10) + self.layout.lab_2_tick.setStyleSheet(p10) + self.layout.lab_3_tick.setStyleSheet(p10) + self.layout.lch_1_tick.setStyleSheet(p10) + self.layout.lch_2_tick.setStyleSheet(p10) + self.layout.lch_3_tick.setStyleSheet(p10) + + # Icons + self.layout.cmyk_4_lock.setIcon(Krita.instance().icon('docker_lock_a')) + self.layout.kkk_1_lock.setIcon(Krita.instance().icon('docker_lock_a')) + self.layout.ard_1_lock.setIcon(Krita.instance().icon('docker_lock_a')) + self.layout.state.setItemIcon(0, Krita.instance().icon('showColoring')) # ON + self.layout.state.setItemIcon(1, Krita.instance().icon('media-playback-start')) # P>K + self.layout.state.setItemIcon(2, Krita.instance().icon('showColoringOff')) # OFF + self.layout.fill.setIcon(Krita.instance().icon('folder-documents')) + self.layout.selection.setIcon(Krita.instance().icon('local-selection-inactive')) + self.layout.docker.setIcon(Krita.instance().icon('settings-button')) + # Tool Tips + self.layout.fill.setToolTip("Fill Pixel") + self.layout.selection.setToolTip("Color Selection") + self.layout.docker.setToolTip("Settings") + + # Settings + self.dialog.group_a.setStyleSheet("#group_a{background-color: rgba(0, 0, 0, 20);}") + self.dialog.group_b.setStyleSheet("#group_b{background-color: rgba(0, 0, 0, 20);}") + self.dialog.group_c.setStyleSheet("#group_c{background-color: rgba(0, 0, 0, 20);}") + self.dialog.group_d.setStyleSheet("#group_d{background-color: rgba(0, 0, 0, 20);}") + def Extension(self): + # Install Extension for Pigmento Docker + extension = PigmentO_Extension(parent = Krita.instance()) + Krita.instance().addExtension(extension) + # Connect Extension Signals + extension.SIGNAL_COR.connect(self.Signal_Extension_COR) + extension.SIGNAL_KEY.connect(self.Signal_Extension_KEY) + extension.SIGNAL_LOK.connect(self.Signal_Extension_LOK) + def Pulse(self): + # Start Timer and Connect Switch + if check_timer >= 1: + self.timer = QtCore.QTimer(self) + self.timer.timeout.connect(self.Krita_2_Pigment) + self.timer.start(check_timer) + # Method ON/OFF switch boot + self.Krita_TIMER() + # Stop Timer so it does NOT work without the Docker Present + self.timer.stop() + + #// + #\\ Menu Displays ########################################################## + # Header + def Pigment_BG_Show(self, SIGNAL_COLOR_SHOW): + self.layout.color_3.setMinimumWidth(zero) + self.layout.color_3.setMaximumWidth(self.ui_80) + self.Update_Color_Header_1() + self.Update_Color_Header_2() + self.Update_Color_Header_3() + self.layout.color_1.update() + self.layout.color_2.update() + self.layout.color_3.update() + def Pigment_BG_Hide(self, SIGNAL_COLOR_HIDE): + self.layout.color_3.setMaximumWidth(zero) + self.Update_Color_Header_1() + self.Update_Color_Header_2() + self.Update_Color_Header_3() + self.layout.color_1.update() + self.layout.color_2.update() + self.layout.color_3.update() + + # Harmony + def Menu_HARMONY(self): + self.harmony_menu = self.dialog.har.isChecked() # Boolean + self.HARMONY_Rule() + # UI and Text + font = self.dialog.har.font() + if self.harmony_menu == False: + self.harmony_render = "COLOR" + font.setBold(False) + self.dialog.har.setText("HARMONY") + self.layout.color_1.setMinimumHeight(self.ui_30) + self.layout.color_1.setMaximumHeight(self.ui_30) + self.layout.color_2.setMinimumHeight(self.ui_30) + self.layout.color_2.setMaximumHeight(self.ui_30) + self.layout.color_3.setMinimumHeight(self.ui_30) + self.layout.color_3.setMaximumHeight(self.ui_30) + self.layout.harmony_1.setMinimumHeight(zero) + self.layout.harmony_1.setMaximumHeight(zero) + self.layout.harmony_2.setMinimumHeight(zero) + self.layout.harmony_2.setMaximumHeight(zero) + self.layout.harmony_3.setMinimumHeight(zero) + self.layout.harmony_3.setMaximumHeight(zero) + self.layout.harmony_4.setMinimumHeight(zero) + self.layout.harmony_4.setMaximumHeight(zero) + self.layout.harmony_5.setMinimumHeight(zero) + self.layout.harmony_5.setMaximumHeight(zero) + # self.layout.harmony_0.setMinimumHeight(zero) + # self.layout.harmony_0.setMaximumHeight(zero) + self.layout.color_harmonys.setContentsMargins(zero, zero, zero, zero) + else: + self.harmony_render = "HARMONY" + font.setBold(True) + self.dialog.har.setText("[HARMONY]") + self.layout.color_1.setMinimumHeight(self.ui_10) + self.layout.color_1.setMaximumHeight(self.ui_10) + self.layout.color_2.setMinimumHeight(self.ui_10) + self.layout.color_2.setMaximumHeight(self.ui_10) + self.layout.color_3.setMinimumHeight(self.ui_10) + self.layout.color_3.setMaximumHeight(self.ui_10) + self.layout.harmony_1.setMinimumHeight(self.ui_20) + self.layout.harmony_1.setMaximumHeight(self.ui_20) + self.layout.harmony_2.setMinimumHeight(self.ui_20) + self.layout.harmony_2.setMaximumHeight(self.ui_20) + self.layout.harmony_3.setMinimumHeight(self.ui_20) + self.layout.harmony_3.setMaximumHeight(self.ui_20) + self.layout.harmony_4.setMinimumHeight(self.ui_20) + self.layout.harmony_4.setMaximumHeight(self.ui_20) + self.layout.harmony_5.setMinimumHeight(self.ui_20) + self.layout.harmony_5.setMaximumHeight(self.ui_20) + # self.layout.harmony_0.setMinimumHeight(self.ui_10) + # self.layout.harmony_0.setMaximumHeight(self.ui_10) + self.layout.color_harmonys.setContentsMargins(zero, zero, zero, zero) + self.dialog.har.setFont(font) + self.menu_update = 5 + # Update + self.Update_Harmony_Colors() + self.Update_Harmony_Span() + # Apply Color/Harmony Colors + self.Harmony_Slots(self.harmony_slot) + def HARMONY_Rule(self): + self.harmony_rule = self.dialog.har_rule.currentText() # Text + if self.harmony_menu == False: + self.harmony_slot = 0 + self.harmony_status = 0 + if (self.harmony_menu == True and self.harmony_rule == "Monochromatic"): + self.harmony_status = 1 + if (self.harmony_menu == True and self.harmony_rule == "Complemantary"): + self.harmony_status = 2 + if (self.harmony_menu == True and self.harmony_rule == "Analogous"): + self.harmony_status = 3 + if (self.harmony_menu == True and self.harmony_rule == "Split Complemantary"): + self.harmony_status = 4 + if (self.harmony_menu == True and self.harmony_rule == "Double Split Complemantary"): + self.harmony_status = 5 + self.Harmony_Refresh() + self.Pigment_Display() + self.Ratio() + def HARMONY_Edit(self): + self.harmony_edit = self.dialog.har_edit.isChecked() # Boolean + self.Harmony_Refresh() + self.Pigment_Display() + self.Ratio() + + # Panels + def Menu_PANEL(self): + font = self.dialog.pan.font() + # Document Status (needs to update using the Color Space used by the document since those are the stable values) + if ((self.canvas() is not None) and (self.canvas().view() is not None)): + doc = self.d_cm + else: + doc = "RGB" + # Panel States + self.PANEL_Shrink() + panel = self.dialog.pan.isChecked() + self.panel_active = self.dialog.pan_index.currentText() + self.panel_secondary = self.dialog.hue_secondary.currentText() + if panel == False: + self.panel_active = "None" + if (panel == True and self.panel_active == "FGC"): + self.layout.panel_fgc.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + self.Pigment_Display() + if (panel == True and self.panel_active == "SWA"): + self.layout.panel_swa.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + if (panel == True and self.panel_active == "RGB"): + self.layout.panel_uvd.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + if (panel == True and self.panel_active == "YUV"): + self.layout.panel_yuv.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + if (panel == True and self.panel_active == "ARD"): + self.layout.panel_ard.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + if (panel == True and self.panel_active == "HSV"): + self.layout.panel_hsv.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + if (panel == True and self.panel_active == "HSL"): + self.layout.panel_hsl.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + if (panel == True and self.panel_active == "HCY"): + self.layout.panel_hcy.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + if (panel == True and self.panel_active == "HUE"): + self.layout.panel_hue.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + if (panel == True and self.panel_active == "GAM"): + self.layout.panel_gam.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + if (panel == True and self.panel_active == "DOT"): + self.layout.panel_dot_mix.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + self.DOT_SET() + if (panel == True and self.panel_active == "OBJ"): + self.layout.panel_obj_display.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + self.OBJ_SET() + if (panel == True and self.panel_active == "IMG"): + self.layout.panel_img.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + self.IMG_Scale() + self.Update_Panel_IMG() + # Secondary Menu Options + if self.panel_active == "SWA": + self.dialog.cotd_date.setEnabled(True) + self.dialog.cotd_date.setMaximumWidth(max_val) + if self.panel_active == "HUE": + self.dialog.hue_secondary.setEnabled(True) + self.dialog.hue_secondary.setMaximumWidth(max_val) + if self.panel_active == "GAM": + self.dialog.gam_space.setEnabled(True) + self.dialog.gam_space.setMaximumWidth(max_val) + self.dialog.gam_shape.setEnabled(True) + self.dialog.gam_shape.setMaximumWidth(max_val) + self.dialog.gam_reset.setEnabled(True) + self.dialog.gam_reset.setMaximumWidth(max_val) + if self.panel_active == "DOT": + self.dialog.dot_interpolation.setEnabled(True) + self.dialog.dot_interpolation.setMaximumWidth(max_val) + self.dialog.dot_resolution.setEnabled(True) + self.dialog.dot_resolution.setMaximumWidth(max_val) + self.dialog.dot_set.setEnabled(True) + self.dialog.dot_set.setMaximumWidth(max_val) + if self.panel_active == "OBJ": + self.dialog.obj_index.setEnabled(True) + self.dialog.obj_index.setMaximumWidth(max_val) + self.dialog.obj_set.setEnabled(True) + self.dialog.obj_set.setMaximumWidth(max_val) + if self.panel_active == "IMG": + self.dialog.img_file.setEnabled(True) + self.dialog.img_file.setMaximumWidth(max_val) + self.dialog.img_grayscale.setEnabled(True) + self.dialog.img_grayscale.setMaximumWidth(max_val) + # Text + if panel == True: + font.setBold(True) + self.dialog.pan.setText("[PANEL]") + else: + font.setBold(False) + self.dialog.pan.setText("PANEL") + self.dialog.pan.setFont(font) + self.menu_update = 5 + self.Menu_CHANNEL() + self.Signal_HUE_Active(self.harmony_slot) + def PANEL_Shrink(self): + # SINGLE + self.layout.panel_fgc.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_uvd.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_yuv.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_ard.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_hsv.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_hsl.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_hcy.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + # SWA + self.layout.panel_swa.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.dialog.cotd_date.setEnabled(False) + self.dialog.cotd_date.setMaximumWidth(zero) + # HUE + self.layout.panel_hue.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.dialog.hue_secondary.setEnabled(False) + self.dialog.hue_secondary.setMaximumWidth(zero) + # GAM + self.layout.panel_gam.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.dialog.gam_space.setEnabled(False) + self.dialog.gam_space.setMaximumWidth(zero) + self.dialog.gam_shape.setEnabled(False) + self.dialog.gam_shape.setMaximumWidth(zero) + self.dialog.gam_reset.setEnabled(False) + self.dialog.gam_reset.setMaximumWidth(zero) + # DOT + self.layout.panel_dot_mix.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.dialog.dot_interpolation.setEnabled(False) + self.dialog.dot_interpolation.setMaximumWidth(zero) + self.dialog.dot_resolution.setEnabled(False) + self.dialog.dot_resolution.setMaximumWidth(zero) + self.dialog.dot_set.setEnabled(False) + self.dialog.dot_set.setMaximumWidth(zero) + self.DOT_Shrink() + # OBJ + self.layout.panel_obj_display.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.dialog.obj_index.setEnabled(False) + self.dialog.obj_index.setMaximumWidth(zero) + self.dialog.obj_set.setEnabled(False) + self.dialog.obj_set.setMaximumWidth(zero) + self.OBJ_Shrink_Top() + self.OBJ_Shrink_Bot() + # IMG + self.layout.panel_img.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.dialog.img_file.setEnabled(False) + self.dialog.img_file.setMaximumWidth(zero) + self.dialog.img_grayscale.setEnabled(False) + self.dialog.img_grayscale.setMaximumWidth(zero) + self.IMG_Shrink() + # Panel HUE + def Menu_Wheel(self): + wheel = self.dialog.wheel_index.currentText() + if wheel == "HUE_CMY": + self.wheel = "CMY" + if wheel == "HUE_RYB": + self.wheel = "RYB" + self.Signal_Send_Panels() + self.Color_Harmony_Delta() + def Menu_Hue_Secondary(self): + self.panel_secondary = self.dialog.hue_secondary.currentText() + if self.panel_secondary == "DOT": + self.layout.panel_triangle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_square.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_diamond.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + if self.panel_secondary == "TRIANGLE": + self.layout.panel_triangle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + self.layout.panel_square.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_diamond.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + if self.panel_secondary == "SQUARE": + self.layout.panel_triangle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_square.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + self.layout.panel_diamond.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + if self.panel_secondary == "DIAMOND": + self.layout.panel_triangle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_square.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_diamond.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + self.Ratio_Box() + self.Update_Panel_HUE() + self.menu_update = 5 + # Panel Gamut + def GAM_Space(self): + space = self.dialog.gam_space.currentText() + if space == "ARD": + self.gamut_space = "ARD" + if space == "HSV": + self.gamut_space = "HSV" + if space == "HSL": + self.gamut_space = "HSL" + if space == "HCY": + self.gamut_space = "HCY" + self.Update_Panel_GAM_Circle() + self.Update_Panel_GAM_Polygon(self.P1_S1, self.P1_S3, self.P1_S4, self.P2_S1, self.P3_S3) + self.panel_gam_circle.update() + self.panel_gam_polygon.update() + def GAM_Shape(self): + gamut = self.dialog.gam_shape.currentText() + if gamut == "None": + self.gamut_shape = "None" + if gamut == "Circle": + self.gamut_shape = "P1_S1" # 1Polygon 1Side + if gamut == "Triangle": + self.gamut_shape = "P1_S3" # 1Polygon 3Sides + if gamut == "Square": + self.gamut_shape = "P1_S4" # 1Polygon 4Sides + if gamut == "2 Circles": + self.gamut_shape = "P2_S1" # 1Polygon 1Sides + if gamut == "3 Pies": + self.gamut_shape = "P3_S3" # 3Polygon 3Sides + self.Update_Panel_GAM_Circle() + self.Update_Panel_GAM_Polygon(self.P1_S1, self.P1_S3, self.P1_S4, self.P2_S1, self.P3_S3) + self.panel_gam_circle.update() + self.panel_gam_polygon.update() + def GAM_Reset(self): + # Variables Reset + self.P1_S1 = [ + 0.5,0.1, + 0.9,0.5, + 0.5,0.9, + 0.1,0.5] + self.P1_S3 = [ + 0.5,0.1, + 0.84641,0.7, + 0.15359,0.7] + self.P1_S4 = [ + 0.5,0.1, + 0.9,0.5, + 0.5,0.9, + 0.1,0.5] + self.P2_S1 = [ + # Circle 1 + 0.5,0.1, + 0.675,0.275, + 0.5,0.45, + 0.325,0.275, + # Circle 2 + 0.5,0.55, + 0.675,0.725, + 0.5,0.9, + 0.325,0.725] + self.P3_S3 = [ + # Center + 0.5,0.5, + # Hexagon + 0.5,0.15359, + 0.8,0.32679, + 0.8,0.67321, + 0.5,0.84641, + 0.2,0.67321, + 0.2,0.32679] + # Rotation + self.P1_S1_r = [ + 0.5,0.1, + 0.9,0.5, + 0.5,0.9, + 0.1,0.5] + self.P1_S3_r = [ + 0.5,0.1, + 0.84641,0.7, + 0.15359,0.7] + self.P1_S4_r = [ + 0.5,0.1, + 0.9,0.5, + 0.5,0.9, + 0.1,0.5] + self.P2_S1_r = [ + # Circle 1 + 0.5,0.1, + 0.675,0.275, + 0.5,0.45, + 0.325,0.275, + # Circle 2 + 0.5,0.55, + 0.675,0.725, + 0.5,0.9, + 0.325,0.725] + self.P3_S3_r = [ + # Center + 0.5,0.5, + # Hexagon + 0.5,0.15359, + 0.8,0.32679, + 0.8,0.67321, + 0.5,0.84641, + 0.2,0.67321, + 0.2,0.32679] + # Reset Dropdown Index to previous + if self.gamut_shape == "None": + index = 0 + if self.gamut_shape == "P1_S1": + index = 1 + if self.gamut_shape == "P1_S3": + index = 2 + if self.gamut_shape == "P1_S4": + index = 3 + if self.gamut_shape == "P2_S1": + index = 4 + if self.gamut_shape == "P3_S3": + index = 5 + self.dialog.gam_shape.setCurrentIndex(index) + self.Update_Panel_GAM_Circle() + self.Update_Panel_GAM_Polygon(self.P1_S1, self.P1_S3, self.P1_S4, self.P2_S1, self.P3_S3) + self.panel_gam_circle.update() + self.panel_gam_polygon.update() + # Panel DOT + def DOT_SET(self): + if (self.dialog.dot_set.isChecked() == True and self.panel_active == "DOT"): + self.DOT_Scale() + if (self.dialog.dot_set.isChecked() == False and self.panel_active == "DOT"): + self.DOT_Shrink() + self.Update_Panel_OBJ() + self.layout.panel_obj_display.update() + self.menu_update = 5 + def DOT_Shrink(self): + self.layout.dot_1.setMinimumHeight(zero) + self.layout.dot_1.setMaximumHeight(zero) + self.layout.dot_2.setMinimumHeight(zero) + self.layout.dot_2.setMaximumHeight(zero) + self.layout.dot_3.setMinimumHeight(zero) + self.layout.dot_3.setMaximumHeight(zero) + self.layout.dot_4.setMinimumHeight(zero) + self.layout.dot_4.setMaximumHeight(zero) + self.layout.dot_swap.setMinimumHeight(zero) + self.layout.dot_swap.setMaximumHeight(zero) + self.layout.panel_dot_colors.setContentsMargins(zero, zero, zero, zero) + self.layout.panel_dot_colors.setSpacing(zero) + def DOT_Scale(self): + self.layout.dot_1.setMinimumHeight(self.ui_25) + self.layout.dot_1.setMaximumHeight(self.ui_25) + self.layout.dot_2.setMinimumHeight(self.ui_25) + self.layout.dot_2.setMaximumHeight(self.ui_25) + self.layout.dot_3.setMinimumHeight(self.ui_25) + self.layout.dot_3.setMaximumHeight(self.ui_25) + self.layout.dot_4.setMinimumHeight(self.ui_25) + self.layout.dot_4.setMaximumHeight(self.ui_25) + self.layout.dot_swap.setMinimumHeight(self.ui_25) + self.layout.dot_swap.setMaximumHeight(self.ui_25) + self.layout.panel_dot_colors.setContentsMargins(zero, unit, zero, unit) + self.layout.panel_dot_colors.setSpacing(2) + # Panel OBJ + def OBJ_Index(self): + self.obj_index = self.dialog.obj_index.currentIndex() + self.obj_text = self.dialog.obj_index.currentText() + self.OBJ_Shrink_Top() + self.OBJ_Shrink_Bot() + # Paths + if self.obj_text == "SPHERE": + self.path_bg_1 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/bg_1.png") + self.path_bg_2 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/bg_2.png") + self.path_bg_3 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/bg_3.png") + self.path_dif_1 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/dif_1.png") + self.path_dif_2 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/dif_2.png") + self.path_dif_3 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/dif_3.png") + self.path_dif_4 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/dif_4.png") + self.path_dif_5 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/dif_5.png") + self.path_dif_6 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/dif_6.png") + self.path_fg_1 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/fg_1.png") + self.path_fg_2 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/fg_2.png") + self.path_fg_3 = os.path.normpath(self.dir_name + "/OBJECT/SPHERE/fg_3.png") + if self.obj_text == "USER": + self.path_bg_1 = os.path.normpath(self.dir_name + "/OBJECT/USER/bg_1.png") + self.path_bg_2 = os.path.normpath(self.dir_name + "/OBJECT/USER/bg_2.png") + self.path_bg_3 = os.path.normpath(self.dir_name + "/OBJECT/USER/bg_3.png") + self.path_dif_1 = os.path.normpath(self.dir_name + "/OBJECT/USER/dif_1.png") + self.path_dif_2 = os.path.normpath(self.dir_name + "/OBJECT/USER/dif_2.png") + self.path_dif_3 = os.path.normpath(self.dir_name + "/OBJECT/USER/dif_3.png") + self.path_dif_4 = os.path.normpath(self.dir_name + "/OBJECT/USER/dif_4.png") + self.path_dif_5 = os.path.normpath(self.dir_name + "/OBJECT/USER/dif_5.png") + self.path_dif_6 = os.path.normpath(self.dir_name + "/OBJECT/USER/dif_6.png") + self.path_fg_1 = os.path.normpath(self.dir_name + "/OBJECT/USER/fg_1.png") + self.path_fg_2 = os.path.normpath(self.dir_name + "/OBJECT/USER/fg_2.png") + self.path_fg_3 = os.path.normpath(self.dir_name + "/OBJECT/USER/fg_3.png") + # Display + if self.panel_active == "OBJ": + # Adjust UI + self.OBJ_Scale_Top() + if self.dialog.obj_set.isChecked() == True: + self.OBJ_Scale_Bot() + # Update + self.Object_Save() + self.Update_Panel_OBJ() + self.menu_update = 5 + def OBJ_SET(self): + if (self.dialog.obj_set.isChecked() == True and self.panel_active == "OBJ"): + self.OBJ_Scale_Bot() + if (self.dialog.obj_set.isChecked() == False and self.panel_active == "OBJ"): + self.OBJ_Shrink_Bot() + self.Update_Panel_OBJ() + self.menu_update = 5 + def OBJ_Shrink_Top(self): + # Object View Shrink + self.layout.panel_obj_display.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + def OBJ_Shrink_Bot(self): + # Margins + self.layout.panel_obj_colors.setContentsMargins(zero, zero, zero, zero) + # Close Live + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + # BackGround 1 + self.layout.b1_live.setMinimumHeight(zero) + self.layout.b1_live.setMaximumHeight(zero) + self.layout.b1_color.setMinimumHeight(zero) + self.layout.b1_color.setMaximumHeight(zero) + self.layout.b1_alpha.setMinimumHeight(zero) + self.layout.b1_alpha.setMaximumHeight(zero) + # BackGround 2 + self.layout.b2_live.setMinimumHeight(zero) + self.layout.b2_live.setMaximumHeight(zero) + self.layout.b2_color.setMinimumHeight(zero) + self.layout.b2_color.setMaximumHeight(zero) + self.layout.b2_alpha.setMinimumHeight(zero) + self.layout.b2_alpha.setMaximumHeight(zero) + # BackGround 3 + self.layout.b3_live.setMinimumHeight(zero) + self.layout.b3_live.setMaximumHeight(zero) + self.layout.b3_color.setMinimumHeight(zero) + self.layout.b3_color.setMaximumHeight(zero) + self.layout.b3_alpha.setMinimumHeight(zero) + self.layout.b3_alpha.setMaximumHeight(zero) + # Diffuse 1 + self.layout.d1_live.setMinimumHeight(zero) + self.layout.d1_live.setMaximumHeight(zero) + self.layout.d1_color.setMinimumHeight(zero) + self.layout.d1_color.setMaximumHeight(zero) + self.layout.d1_alpha.setMinimumHeight(zero) + self.layout.d1_alpha.setMaximumHeight(zero) + # Diffuse 2 + self.layout.d2_live.setMinimumHeight(zero) + self.layout.d2_live.setMaximumHeight(zero) + self.layout.d2_color.setMinimumHeight(zero) + self.layout.d2_color.setMaximumHeight(zero) + self.layout.d2_alpha.setMinimumHeight(zero) + self.layout.d2_alpha.setMaximumHeight(zero) + # Diffuse 3 + self.layout.d3_live.setMinimumHeight(zero) + self.layout.d3_live.setMaximumHeight(zero) + self.layout.d3_color.setMinimumHeight(zero) + self.layout.d3_color.setMaximumHeight(zero) + self.layout.d3_alpha.setMinimumHeight(zero) + self.layout.d3_alpha.setMaximumHeight(zero) + # Diffuse 4 + self.layout.d4_live.setMinimumHeight(zero) + self.layout.d4_live.setMaximumHeight(zero) + self.layout.d4_color.setMinimumHeight(zero) + self.layout.d4_color.setMaximumHeight(zero) + self.layout.d4_alpha.setMinimumHeight(zero) + self.layout.d4_alpha.setMaximumHeight(zero) + # Diffuse 5 + self.layout.d5_live.setMinimumHeight(zero) + self.layout.d5_live.setMaximumHeight(zero) + self.layout.d5_color.setMinimumHeight(zero) + self.layout.d5_color.setMaximumHeight(zero) + self.layout.d5_alpha.setMinimumHeight(zero) + self.layout.d5_alpha.setMaximumHeight(zero) + # Diffuse 6 + self.layout.d6_live.setMinimumHeight(zero) + self.layout.d6_live.setMaximumHeight(zero) + self.layout.d6_color.setMinimumHeight(zero) + self.layout.d6_color.setMaximumHeight(zero) + self.layout.d6_alpha.setMinimumHeight(zero) + self.layout.d6_alpha.setMaximumHeight(zero) + # ForeGround 1 + self.layout.f1_live.setMinimumHeight(zero) + self.layout.f1_live.setMaximumHeight(zero) + self.layout.f1_color.setMinimumHeight(zero) + self.layout.f1_color.setMaximumHeight(zero) + self.layout.f1_alpha.setMinimumHeight(zero) + self.layout.f1_alpha.setMaximumHeight(zero) + # ForeGround 2 + self.layout.f2_live.setMinimumHeight(zero) + self.layout.f2_live.setMaximumHeight(zero) + self.layout.f2_color.setMinimumHeight(zero) + self.layout.f2_color.setMaximumHeight(zero) + self.layout.f2_alpha.setMinimumHeight(zero) + self.layout.f2_alpha.setMaximumHeight(zero) + # ForeGround 3 + self.layout.f3_live.setMinimumHeight(zero) + self.layout.f3_live.setMaximumHeight(zero) + self.layout.f3_color.setMinimumHeight(zero) + self.layout.f3_color.setMaximumHeight(zero) + self.layout.f3_alpha.setMinimumHeight(zero) + self.layout.f3_alpha.setMaximumHeight(zero) + def OBJ_Scale_Top(self): + # Object View Scales + self.layout.panel_obj_display.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + def OBJ_Scale_Bot(self): + # Margins + self.layout.panel_obj_colors.setContentsMargins(zero, unit, zero, unit) + # BackGround 1 + self.layout.b1_live.setMinimumHeight(self.ui_20) + self.layout.b1_live.setMaximumHeight(self.ui_20) + self.layout.b1_color.setMinimumHeight(self.ui_25) + self.layout.b1_color.setMaximumHeight(self.ui_25) + self.layout.b1_alpha.setMinimumHeight(self.ui_10) + self.layout.b1_alpha.setMaximumHeight(self.ui_10) + # BackGround 2 + self.layout.b2_live.setMinimumHeight(self.ui_20) + self.layout.b2_live.setMaximumHeight(self.ui_20) + self.layout.b2_color.setMinimumHeight(self.ui_25) + self.layout.b2_color.setMaximumHeight(self.ui_25) + self.layout.b2_alpha.setMinimumHeight(self.ui_10) + self.layout.b2_alpha.setMaximumHeight(self.ui_10) + # BackGround 3 + self.layout.b3_live.setMinimumHeight(self.ui_20) + self.layout.b3_live.setMaximumHeight(self.ui_20) + self.layout.b3_color.setMinimumHeight(self.ui_25) + self.layout.b3_color.setMaximumHeight(self.ui_25) + self.layout.b3_alpha.setMinimumHeight(self.ui_10) + self.layout.b3_alpha.setMaximumHeight(self.ui_10) + # Diffuse 1 + self.layout.d1_live.setMinimumHeight(self.ui_20) + self.layout.d1_live.setMaximumHeight(self.ui_20) + self.layout.d1_color.setMinimumHeight(self.ui_25) + self.layout.d1_color.setMaximumHeight(self.ui_25) + self.layout.d1_alpha.setMinimumHeight(self.ui_10) + self.layout.d1_alpha.setMaximumHeight(self.ui_10) + # Diffuse 2 + self.layout.d2_live.setMinimumHeight(self.ui_20) + self.layout.d2_live.setMaximumHeight(self.ui_20) + self.layout.d2_color.setMinimumHeight(self.ui_25) + self.layout.d2_color.setMaximumHeight(self.ui_25) + self.layout.d2_alpha.setMinimumHeight(self.ui_10) + self.layout.d2_alpha.setMaximumHeight(self.ui_10) + # Diffuse 3 + self.layout.d3_live.setMinimumHeight(self.ui_20) + self.layout.d3_live.setMaximumHeight(self.ui_20) + self.layout.d3_color.setMinimumHeight(self.ui_25) + self.layout.d3_color.setMaximumHeight(self.ui_25) + self.layout.d3_alpha.setMinimumHeight(self.ui_10) + self.layout.d3_alpha.setMaximumHeight(self.ui_10) + # Diffuse 4 + self.layout.d4_live.setMinimumHeight(self.ui_20) + self.layout.d4_live.setMaximumHeight(self.ui_20) + self.layout.d4_color.setMinimumHeight(self.ui_25) + self.layout.d4_color.setMaximumHeight(self.ui_25) + self.layout.d4_alpha.setMinimumHeight(self.ui_10) + self.layout.d4_alpha.setMaximumHeight(self.ui_10) + # Diffuse 5 + self.layout.d5_live.setMinimumHeight(self.ui_20) + self.layout.d5_live.setMaximumHeight(self.ui_20) + self.layout.d5_color.setMinimumHeight(self.ui_25) + self.layout.d5_color.setMaximumHeight(self.ui_25) + self.layout.d5_alpha.setMinimumHeight(self.ui_10) + self.layout.d5_alpha.setMaximumHeight(self.ui_10) + # Diffuse 6 + self.layout.d6_live.setMinimumHeight(self.ui_20) + self.layout.d6_live.setMaximumHeight(self.ui_20) + self.layout.d6_color.setMinimumHeight(self.ui_25) + self.layout.d6_color.setMaximumHeight(self.ui_25) + self.layout.d6_alpha.setMinimumHeight(self.ui_10) + self.layout.d6_alpha.setMaximumHeight(self.ui_10) + # ForeGround 1 + self.layout.f1_live.setMinimumHeight(self.ui_20) + self.layout.f1_live.setMaximumHeight(self.ui_20) + self.layout.f1_color.setMinimumHeight(self.ui_25) + self.layout.f1_color.setMaximumHeight(self.ui_25) + self.layout.f1_alpha.setMinimumHeight(self.ui_10) + self.layout.f1_alpha.setMaximumHeight(self.ui_10) + # ForeGround 2 + self.layout.f2_live.setMinimumHeight(self.ui_20) + self.layout.f2_live.setMaximumHeight(self.ui_20) + self.layout.f2_color.setMinimumHeight(self.ui_25) + self.layout.f2_color.setMaximumHeight(self.ui_25) + self.layout.f2_alpha.setMinimumHeight(self.ui_10) + self.layout.f2_alpha.setMaximumHeight(self.ui_10) + # ForeGround 3 + self.layout.f3_live.setMinimumHeight(self.ui_20) + self.layout.f3_live.setMaximumHeight(self.ui_20) + self.layout.f3_color.setMinimumHeight(self.ui_25) + self.layout.f3_color.setMaximumHeight(self.ui_25) + self.layout.f3_alpha.setMinimumHeight(self.ui_10) + self.layout.f3_alpha.setMaximumHeight(self.ui_10) + # Panel IMG + def IMG_Shrink(self): + self.layout.scan_progress.setMinimumHeight(zero) + self.layout.scan_progress.setMaximumHeight(zero) + def IMG_Scale(self): + self.layout.scan_progress.setMinimumHeight(self.ui_05) + self.layout.scan_progress.setMaximumHeight(self.ui_05) + + # Channels + def Menu_CHANNEL(self): + # Font + font = self.dialog.cha.font() + if self.dialog.cha.isChecked(): + font.setBold(True) + self.dialog.cha.setText("[CHANNEL]") + self.chan = True + else: + font.setBold(False) + self.dialog.cha.setText("CHANNEL") + self.chan = False + self.dialog.cha.setFont(font) + self.Menu_AAA() + self.Menu_RGB() + self.Menu_CMY() + self.Menu_CMYK() + self.Menu_RYB() + self.Menu_YUV() + self.Menu_KKK() + + self.Menu_ARD() + self.Menu_HSV() + self.Menu_HSL() + self.Menu_HCY() + + self.Menu_XYZ() + self.Menu_XYY() + self.Menu_LUV() + self.Menu_HLAB() + self.Menu_LAB() + self.Menu_LCH() + try: + self.Pigment_Display() + except: + pass + def Menu_Display_Value(self): + val = self.dialog.display_values.isChecked() + if val == True: + # AAA + self.layout.aaa_1_label.setMinimumWidth(self.ui_15) + self.layout.aaa_1_label.setMaximumWidth(self.ui_15) + self.layout.aaa_1_value.setMinimumWidth(self.ui_70) + self.layout.aaa_1_value.setMaximumWidth(self.ui_70) + # RGB + self.layout.rgb_1_label.setMinimumWidth(self.ui_15) + self.layout.rgb_1_label.setMaximumWidth(self.ui_15) + self.layout.rgb_2_label.setMinimumWidth(self.ui_15) + self.layout.rgb_2_label.setMaximumWidth(self.ui_15) + self.layout.rgb_3_label.setMinimumWidth(self.ui_15) + self.layout.rgb_3_label.setMaximumWidth(self.ui_15) + self.layout.rgb_1_value.setMinimumWidth(self.ui_70) + self.layout.rgb_1_value.setMaximumWidth(self.ui_70) + self.layout.rgb_2_value.setMinimumWidth(self.ui_70) + self.layout.rgb_2_value.setMaximumWidth(self.ui_70) + self.layout.rgb_3_value.setMinimumWidth(self.ui_70) + self.layout.rgb_3_value.setMaximumWidth(self.ui_70) + # CMY + self.layout.cmy_1_label.setMinimumWidth(self.ui_15) + self.layout.cmy_1_label.setMaximumWidth(self.ui_15) + self.layout.cmy_2_label.setMinimumWidth(self.ui_15) + self.layout.cmy_2_label.setMaximumWidth(self.ui_15) + self.layout.cmy_3_label.setMinimumWidth(self.ui_15) + self.layout.cmy_3_label.setMaximumWidth(self.ui_15) + self.layout.cmy_1_value.setMinimumWidth(self.ui_70) + self.layout.cmy_1_value.setMaximumWidth(self.ui_70) + self.layout.cmy_2_value.setMinimumWidth(self.ui_70) + self.layout.cmy_2_value.setMaximumWidth(self.ui_70) + self.layout.cmy_3_value.setMinimumWidth(self.ui_70) + self.layout.cmy_3_value.setMaximumWidth(self.ui_70) + # CMYK + self.layout.cmyk_1_label.setMinimumWidth(self.ui_15) + self.layout.cmyk_1_label.setMaximumWidth(self.ui_15) + self.layout.cmyk_2_label.setMinimumWidth(self.ui_15) + self.layout.cmyk_2_label.setMaximumWidth(self.ui_15) + self.layout.cmyk_3_label.setMinimumWidth(self.ui_15) + self.layout.cmyk_3_label.setMaximumWidth(self.ui_15) + self.layout.cmyk_4_label.setMinimumWidth(self.ui_15) + self.layout.cmyk_4_label.setMaximumWidth(self.ui_15) + self.layout.cmyk_1_value.setMinimumWidth(self.ui_70) + self.layout.cmyk_1_value.setMaximumWidth(self.ui_70) + self.layout.cmyk_2_value.setMinimumWidth(self.ui_70) + self.layout.cmyk_2_value.setMaximumWidth(self.ui_70) + self.layout.cmyk_3_value.setMinimumWidth(self.ui_70) + self.layout.cmyk_3_value.setMaximumWidth(self.ui_70) + self.layout.cmyk_4_value.setMinimumWidth(self.ui_55) + self.layout.cmyk_4_value.setMaximumWidth(self.ui_55) + self.layout.cmyk_4_lock.setMinimumWidth(self.ui_15) + self.layout.cmyk_4_lock.setMaximumWidth(self.ui_15) + # RYB + self.layout.ryb_1_label.setMinimumWidth(self.ui_15) + self.layout.ryb_1_label.setMaximumWidth(self.ui_15) + self.layout.ryb_2_label.setMinimumWidth(self.ui_15) + self.layout.ryb_2_label.setMaximumWidth(self.ui_15) + self.layout.ryb_3_label.setMinimumWidth(self.ui_15) + self.layout.ryb_3_label.setMaximumWidth(self.ui_15) + self.layout.ryb_1_value.setMinimumWidth(self.ui_70) + self.layout.ryb_1_value.setMaximumWidth(self.ui_70) + self.layout.ryb_2_value.setMinimumWidth(self.ui_70) + self.layout.ryb_2_value.setMaximumWidth(self.ui_70) + self.layout.ryb_3_value.setMinimumWidth(self.ui_70) + self.layout.ryb_3_value.setMaximumWidth(self.ui_70) + # YUV + self.layout.yuv_1_label.setMinimumWidth(self.ui_15) + self.layout.yuv_1_label.setMaximumWidth(self.ui_15) + self.layout.yuv_2_label.setMinimumWidth(self.ui_15) + self.layout.yuv_2_label.setMaximumWidth(self.ui_15) + self.layout.yuv_3_label.setMinimumWidth(self.ui_15) + self.layout.yuv_3_label.setMaximumWidth(self.ui_15) + self.layout.yuv_1_value.setMinimumWidth(self.ui_70) + self.layout.yuv_1_value.setMaximumWidth(self.ui_70) + self.layout.yuv_2_value.setMinimumWidth(self.ui_70) + self.layout.yuv_2_value.setMaximumWidth(self.ui_70) + self.layout.yuv_3_value.setMinimumWidth(self.ui_70) + self.layout.yuv_3_value.setMaximumWidth(self.ui_70) + # KKK + self.layout.kkk_1_label.setMinimumWidth(self.ui_15) + self.layout.kkk_1_label.setMaximumWidth(self.ui_15) + self.layout.kkk_1_value.setMinimumWidth(self.ui_55) + self.layout.kkk_1_value.setMaximumWidth(self.ui_55) + self.layout.kkk_1_lock.setMinimumWidth(self.ui_15) + self.layout.kkk_1_lock.setMaximumWidth(self.ui_15) + self.layout.kkk_1_value_w.setMinimumWidth(self.ui_70) + self.layout.kkk_1_value_w.setMaximumWidth(self.ui_70) + + # ARD + self.layout.ard_1_label.setMinimumWidth(self.ui_15) + self.layout.ard_1_label.setMaximumWidth(self.ui_15) + self.layout.ard_2_label.setMinimumWidth(self.ui_15) + self.layout.ard_2_label.setMaximumWidth(self.ui_15) + self.layout.ard_3_label.setMinimumWidth(self.ui_15) + self.layout.ard_3_label.setMaximumWidth(self.ui_15) + self.layout.ard_1_value.setMinimumWidth(self.ui_55) + self.layout.ard_1_value.setMaximumWidth(self.ui_55) + self.layout.ard_2_value.setMinimumWidth(self.ui_70) + self.layout.ard_2_value.setMaximumWidth(self.ui_70) + self.layout.ard_3_value.setMinimumWidth(self.ui_70) + self.layout.ard_3_value.setMaximumWidth(self.ui_70) + self.layout.ard_1_lock.setMinimumWidth(self.ui_15) + self.layout.ard_1_lock.setMaximumWidth(self.ui_15) + # HSV + self.layout.hsv_1_label.setMinimumWidth(self.ui_15) + self.layout.hsv_1_label.setMaximumWidth(self.ui_15) + self.layout.hsv_2_label.setMinimumWidth(self.ui_15) + self.layout.hsv_2_label.setMaximumWidth(self.ui_15) + self.layout.hsv_3_label.setMinimumWidth(self.ui_15) + self.layout.hsv_3_label.setMaximumWidth(self.ui_15) + self.layout.hsv_1_value.setMinimumWidth(self.ui_70) + self.layout.hsv_1_value.setMaximumWidth(self.ui_70) + self.layout.hsv_2_value.setMinimumWidth(self.ui_70) + self.layout.hsv_2_value.setMaximumWidth(self.ui_70) + self.layout.hsv_3_value.setMinimumWidth(self.ui_70) + self.layout.hsv_3_value.setMaximumWidth(self.ui_70) + # HSL + self.layout.hsl_1_label.setMinimumWidth(self.ui_15) + self.layout.hsl_1_label.setMaximumWidth(self.ui_15) + self.layout.hsl_2_label.setMinimumWidth(self.ui_15) + self.layout.hsl_2_label.setMaximumWidth(self.ui_15) + self.layout.hsl_3_label.setMinimumWidth(self.ui_15) + self.layout.hsl_3_label.setMaximumWidth(self.ui_15) + self.layout.hsl_1_value.setMinimumWidth(self.ui_70) + self.layout.hsl_1_value.setMaximumWidth(self.ui_70) + self.layout.hsl_2_value.setMinimumWidth(self.ui_70) + self.layout.hsl_2_value.setMaximumWidth(self.ui_70) + self.layout.hsl_3_value.setMinimumWidth(self.ui_70) + self.layout.hsl_3_value.setMaximumWidth(self.ui_70) + # HCY + self.layout.hcy_1_label.setMinimumWidth(self.ui_15) + self.layout.hcy_1_label.setMaximumWidth(self.ui_15) + self.layout.hcy_2_label.setMinimumWidth(self.ui_15) + self.layout.hcy_2_label.setMaximumWidth(self.ui_15) + self.layout.hcy_3_label.setMinimumWidth(self.ui_15) + self.layout.hcy_3_label.setMaximumWidth(self.ui_15) + self.layout.hcy_1_value.setMinimumWidth(self.ui_70) + self.layout.hcy_1_value.setMaximumWidth(self.ui_70) + self.layout.hcy_2_value.setMinimumWidth(self.ui_70) + self.layout.hcy_2_value.setMaximumWidth(self.ui_70) + self.layout.hcy_3_value.setMinimumWidth(self.ui_70) + self.layout.hcy_3_value.setMaximumWidth(self.ui_70) + # SEL + self.layout.sel_1_label.setMinimumWidth(self.ui_15) + self.layout.sel_1_label.setMaximumWidth(self.ui_15) + self.layout.sel_2_label.setMinimumWidth(self.ui_15) + self.layout.sel_2_label.setMaximumWidth(self.ui_15) + self.layout.sel_3_label.setMinimumWidth(self.ui_15) + self.layout.sel_3_label.setMaximumWidth(self.ui_15) + self.layout.sel_1_value.setMinimumWidth(self.ui_70) + self.layout.sel_1_value.setMaximumWidth(self.ui_70) + self.layout.sel_2_value.setMinimumWidth(self.ui_70) + self.layout.sel_2_value.setMaximumWidth(self.ui_70) + self.layout.sel_3_value.setMinimumWidth(self.ui_70) + self.layout.sel_3_value.setMaximumWidth(self.ui_70) + + # XYZ + self.layout.xyz_1_label.setMinimumWidth(self.ui_15) + self.layout.xyz_1_label.setMaximumWidth(self.ui_15) + self.layout.xyz_2_label.setMinimumWidth(self.ui_15) + self.layout.xyz_2_label.setMaximumWidth(self.ui_15) + self.layout.xyz_3_label.setMinimumWidth(self.ui_15) + self.layout.xyz_3_label.setMaximumWidth(self.ui_15) + self.layout.xyz_1_value.setMinimumWidth(self.ui_70) + self.layout.xyz_1_value.setMaximumWidth(self.ui_70) + self.layout.xyz_2_value.setMinimumWidth(self.ui_70) + self.layout.xyz_2_value.setMaximumWidth(self.ui_70) + self.layout.xyz_3_value.setMinimumWidth(self.ui_70) + self.layout.xyz_3_value.setMaximumWidth(self.ui_70) + # XYY + self.layout.xyy_1_label.setMinimumWidth(self.ui_15) + self.layout.xyy_1_label.setMaximumWidth(self.ui_15) + self.layout.xyy_2_label.setMinimumWidth(self.ui_15) + self.layout.xyy_2_label.setMaximumWidth(self.ui_15) + self.layout.xyy_3_label.setMinimumWidth(self.ui_15) + self.layout.xyy_3_label.setMaximumWidth(self.ui_15) + self.layout.xyy_1_value.setMinimumWidth(self.ui_70) + self.layout.xyy_1_value.setMaximumWidth(self.ui_70) + self.layout.xyy_2_value.setMinimumWidth(self.ui_70) + self.layout.xyy_2_value.setMaximumWidth(self.ui_70) + self.layout.xyy_3_value.setMinimumWidth(self.ui_70) + self.layout.xyy_3_value.setMaximumWidth(self.ui_70) + # LUV + self.layout.luv_1_label.setMinimumWidth(self.ui_15) + self.layout.luv_1_label.setMaximumWidth(self.ui_15) + self.layout.luv_2_label.setMinimumWidth(self.ui_15) + self.layout.luv_2_label.setMaximumWidth(self.ui_15) + self.layout.luv_3_label.setMinimumWidth(self.ui_15) + self.layout.luv_3_label.setMaximumWidth(self.ui_15) + self.layout.luv_1_value.setMinimumWidth(self.ui_70) + self.layout.luv_1_value.setMaximumWidth(self.ui_70) + self.layout.luv_2_value.setMinimumWidth(self.ui_70) + self.layout.luv_2_value.setMaximumWidth(self.ui_70) + self.layout.luv_3_value.setMinimumWidth(self.ui_70) + self.layout.luv_3_value.setMaximumWidth(self.ui_70) + # HLAB + self.layout.hlab_1_label.setMinimumWidth(self.ui_15) + self.layout.hlab_1_label.setMaximumWidth(self.ui_15) + self.layout.hlab_2_label.setMinimumWidth(self.ui_15) + self.layout.hlab_2_label.setMaximumWidth(self.ui_15) + self.layout.hlab_3_label.setMinimumWidth(self.ui_15) + self.layout.hlab_3_label.setMaximumWidth(self.ui_15) + self.layout.hlab_1_value.setMinimumWidth(self.ui_70) + self.layout.hlab_1_value.setMaximumWidth(self.ui_70) + self.layout.hlab_2_value.setMinimumWidth(self.ui_70) + self.layout.hlab_2_value.setMaximumWidth(self.ui_70) + self.layout.hlab_3_value.setMinimumWidth(self.ui_70) + self.layout.hlab_3_value.setMaximumWidth(self.ui_70) + # LAB + self.layout.lab_1_label.setMinimumWidth(self.ui_15) + self.layout.lab_1_label.setMaximumWidth(self.ui_15) + self.layout.lab_2_label.setMinimumWidth(self.ui_15) + self.layout.lab_2_label.setMaximumWidth(self.ui_15) + self.layout.lab_3_label.setMinimumWidth(self.ui_15) + self.layout.lab_3_label.setMaximumWidth(self.ui_15) + self.layout.lab_1_value.setMinimumWidth(self.ui_70) + self.layout.lab_1_value.setMaximumWidth(self.ui_70) + self.layout.lab_2_value.setMinimumWidth(self.ui_70) + self.layout.lab_2_value.setMaximumWidth(self.ui_70) + self.layout.lab_3_value.setMinimumWidth(self.ui_70) + self.layout.lab_3_value.setMaximumWidth(self.ui_70) + # LCH + self.layout.lch_1_label.setMinimumWidth(self.ui_15) + self.layout.lch_1_label.setMaximumWidth(self.ui_15) + self.layout.lch_2_label.setMinimumWidth(self.ui_15) + self.layout.lch_2_label.setMaximumWidth(self.ui_15) + self.layout.lch_3_label.setMinimumWidth(self.ui_15) + self.layout.lch_3_label.setMaximumWidth(self.ui_15) + self.layout.lch_1_value.setMinimumWidth(self.ui_70) + self.layout.lch_1_value.setMaximumWidth(self.ui_70) + self.layout.lch_2_value.setMinimumWidth(self.ui_70) + self.layout.lch_2_value.setMaximumWidth(self.ui_70) + self.layout.lch_3_value.setMinimumWidth(self.ui_70) + self.layout.lch_3_value.setMaximumWidth(self.ui_70) + else: + # AAA + self.layout.aaa_1_label.setMinimumWidth(zero) + self.layout.aaa_1_label.setMaximumWidth(zero) + self.layout.aaa_1_value.setMinimumWidth(zero) + self.layout.aaa_1_value.setMaximumWidth(zero) + # RGB + self.layout.rgb_1_label.setMinimumWidth(zero) + self.layout.rgb_1_label.setMaximumWidth(zero) + self.layout.rgb_2_label.setMinimumWidth(zero) + self.layout.rgb_2_label.setMaximumWidth(zero) + self.layout.rgb_3_label.setMinimumWidth(zero) + self.layout.rgb_3_label.setMaximumWidth(zero) + self.layout.rgb_1_value.setMinimumWidth(zero) + self.layout.rgb_1_value.setMaximumWidth(zero) + self.layout.rgb_2_value.setMinimumWidth(zero) + self.layout.rgb_2_value.setMaximumWidth(zero) + self.layout.rgb_3_value.setMinimumWidth(zero) + self.layout.rgb_3_value.setMaximumWidth(zero) + # CMY + self.layout.cmy_1_label.setMinimumWidth(zero) + self.layout.cmy_1_label.setMaximumWidth(zero) + self.layout.cmy_2_label.setMinimumWidth(zero) + self.layout.cmy_2_label.setMaximumWidth(zero) + self.layout.cmy_3_label.setMinimumWidth(zero) + self.layout.cmy_3_label.setMaximumWidth(zero) + self.layout.cmy_1_value.setMinimumWidth(zero) + self.layout.cmy_1_value.setMaximumWidth(zero) + self.layout.cmy_2_value.setMinimumWidth(zero) + self.layout.cmy_2_value.setMaximumWidth(zero) + self.layout.cmy_3_value.setMinimumWidth(zero) + self.layout.cmy_3_value.setMaximumWidth(zero) + # CMYK + self.layout.cmyk_1_label.setMinimumWidth(zero) + self.layout.cmyk_1_label.setMaximumWidth(zero) + self.layout.cmyk_2_label.setMinimumWidth(zero) + self.layout.cmyk_2_label.setMaximumWidth(zero) + self.layout.cmyk_3_label.setMinimumWidth(zero) + self.layout.cmyk_3_label.setMaximumWidth(zero) + self.layout.cmyk_4_label.setMinimumWidth(zero) + self.layout.cmyk_4_label.setMaximumWidth(zero) + self.layout.cmyk_1_value.setMinimumWidth(zero) + self.layout.cmyk_1_value.setMaximumWidth(zero) + self.layout.cmyk_2_value.setMinimumWidth(zero) + self.layout.cmyk_2_value.setMaximumWidth(zero) + self.layout.cmyk_3_value.setMinimumWidth(zero) + self.layout.cmyk_3_value.setMaximumWidth(zero) + self.layout.cmyk_4_value.setMinimumWidth(zero) + self.layout.cmyk_4_value.setMaximumWidth(zero) + self.layout.cmyk_4_lock.setMinimumWidth(zero) + self.layout.cmyk_4_lock.setMaximumWidth(zero) + # RYB + self.layout.ryb_1_label.setMinimumWidth(zero) + self.layout.ryb_1_label.setMaximumWidth(zero) + self.layout.ryb_2_label.setMinimumWidth(zero) + self.layout.ryb_2_label.setMaximumWidth(zero) + self.layout.ryb_3_label.setMinimumWidth(zero) + self.layout.ryb_3_label.setMaximumWidth(zero) + self.layout.ryb_1_value.setMinimumWidth(zero) + self.layout.ryb_1_value.setMaximumWidth(zero) + self.layout.ryb_2_value.setMinimumWidth(zero) + self.layout.ryb_2_value.setMaximumWidth(zero) + self.layout.ryb_3_value.setMinimumWidth(zero) + self.layout.ryb_3_value.setMaximumWidth(zero) + # YUV + self.layout.yuv_1_label.setMinimumWidth(zero) + self.layout.yuv_1_label.setMaximumWidth(zero) + self.layout.yuv_2_label.setMinimumWidth(zero) + self.layout.yuv_2_label.setMaximumWidth(zero) + self.layout.yuv_3_label.setMinimumWidth(zero) + self.layout.yuv_3_label.setMaximumWidth(zero) + self.layout.yuv_1_value.setMinimumWidth(zero) + self.layout.yuv_1_value.setMaximumWidth(zero) + self.layout.yuv_2_value.setMinimumWidth(zero) + self.layout.yuv_2_value.setMaximumWidth(zero) + self.layout.yuv_3_value.setMinimumWidth(zero) + self.layout.yuv_3_value.setMaximumWidth(zero) + # KKK + self.layout.kkk_1_label.setMinimumWidth(zero) + self.layout.kkk_1_label.setMaximumWidth(zero) + self.layout.kkk_1_value.setMinimumWidth(zero) + self.layout.kkk_1_value.setMaximumWidth(zero) + self.layout.kkk_1_lock.setMinimumWidth(zero) + self.layout.kkk_1_lock.setMaximumWidth(zero) + self.layout.kkk_1_value_w.setMinimumWidth(zero) + self.layout.kkk_1_value_w.setMaximumWidth(zero) + + # ARD + self.layout.ard_1_label.setMinimumWidth(zero) + self.layout.ard_1_label.setMaximumWidth(zero) + self.layout.ard_2_label.setMinimumWidth(zero) + self.layout.ard_2_label.setMaximumWidth(zero) + self.layout.ard_3_label.setMinimumWidth(zero) + self.layout.ard_3_label.setMaximumWidth(zero) + self.layout.ard_1_value.setMinimumWidth(zero) + self.layout.ard_1_value.setMaximumWidth(zero) + self.layout.ard_2_value.setMinimumWidth(zero) + self.layout.ard_2_value.setMaximumWidth(zero) + self.layout.ard_3_value.setMinimumWidth(zero) + self.layout.ard_3_value.setMaximumWidth(zero) + self.layout.ard_1_lock.setMinimumWidth(zero) + self.layout.ard_1_lock.setMaximumWidth(zero) + # HSV + self.layout.hsv_1_label.setMinimumWidth(zero) + self.layout.hsv_1_label.setMaximumWidth(zero) + self.layout.hsv_2_label.setMinimumWidth(zero) + self.layout.hsv_2_label.setMaximumWidth(zero) + self.layout.hsv_3_label.setMinimumWidth(zero) + self.layout.hsv_3_label.setMaximumWidth(zero) + self.layout.hsv_1_value.setMinimumWidth(zero) + self.layout.hsv_1_value.setMaximumWidth(zero) + self.layout.hsv_2_value.setMinimumWidth(zero) + self.layout.hsv_2_value.setMaximumWidth(zero) + self.layout.hsv_3_value.setMinimumWidth(zero) + self.layout.hsv_3_value.setMaximumWidth(zero) + # HSL + self.layout.hsl_1_label.setMinimumWidth(zero) + self.layout.hsl_1_label.setMaximumWidth(zero) + self.layout.hsl_2_label.setMinimumWidth(zero) + self.layout.hsl_2_label.setMaximumWidth(zero) + self.layout.hsl_3_label.setMinimumWidth(zero) + self.layout.hsl_3_label.setMaximumWidth(zero) + self.layout.hsl_1_value.setMinimumWidth(zero) + self.layout.hsl_1_value.setMaximumWidth(zero) + self.layout.hsl_2_value.setMinimumWidth(zero) + self.layout.hsl_2_value.setMaximumWidth(zero) + self.layout.hsl_3_value.setMinimumWidth(zero) + self.layout.hsl_3_value.setMaximumWidth(zero) + # HCY + self.layout.hcy_1_label.setMinimumWidth(zero) + self.layout.hcy_1_label.setMaximumWidth(zero) + self.layout.hcy_2_label.setMinimumWidth(zero) + self.layout.hcy_2_label.setMaximumWidth(zero) + self.layout.hcy_3_label.setMinimumWidth(zero) + self.layout.hcy_3_label.setMaximumWidth(zero) + self.layout.hcy_1_value.setMinimumWidth(zero) + self.layout.hcy_1_value.setMaximumWidth(zero) + self.layout.hcy_2_value.setMinimumWidth(zero) + self.layout.hcy_2_value.setMaximumWidth(zero) + self.layout.hcy_3_value.setMinimumWidth(zero) + self.layout.hcy_3_value.setMaximumWidth(zero) + # SEL + self.layout.sel_1_label.setMinimumWidth(zero) + self.layout.sel_1_label.setMaximumWidth(zero) + self.layout.sel_2_label.setMinimumWidth(zero) + self.layout.sel_2_label.setMaximumWidth(zero) + self.layout.sel_3_label.setMinimumWidth(zero) + self.layout.sel_3_label.setMaximumWidth(zero) + self.layout.sel_1_value.setMinimumWidth(zero) + self.layout.sel_1_value.setMaximumWidth(zero) + self.layout.sel_2_value.setMinimumWidth(zero) + self.layout.sel_2_value.setMaximumWidth(zero) + self.layout.sel_3_value.setMinimumWidth(zero) + self.layout.sel_3_value.setMaximumWidth(zero) + + # XYZ + self.layout.xyz_1_label.setMinimumWidth(zero) + self.layout.xyz_1_label.setMaximumWidth(zero) + self.layout.xyz_2_label.setMinimumWidth(zero) + self.layout.xyz_2_label.setMaximumWidth(zero) + self.layout.xyz_3_label.setMinimumWidth(zero) + self.layout.xyz_3_label.setMaximumWidth(zero) + self.layout.xyz_1_value.setMinimumWidth(zero) + self.layout.xyz_1_value.setMaximumWidth(zero) + self.layout.xyz_2_value.setMinimumWidth(zero) + self.layout.xyz_2_value.setMaximumWidth(zero) + self.layout.xyz_3_value.setMinimumWidth(zero) + self.layout.xyz_3_value.setMaximumWidth(zero) + # XYY + self.layout.xyy_1_label.setMinimumWidth(zero) + self.layout.xyy_1_label.setMaximumWidth(zero) + self.layout.xyy_2_label.setMinimumWidth(zero) + self.layout.xyy_2_label.setMaximumWidth(zero) + self.layout.xyy_3_label.setMinimumWidth(zero) + self.layout.xyy_3_label.setMaximumWidth(zero) + self.layout.xyy_1_value.setMinimumWidth(zero) + self.layout.xyy_1_value.setMaximumWidth(zero) + self.layout.xyy_2_value.setMinimumWidth(zero) + self.layout.xyy_2_value.setMaximumWidth(zero) + self.layout.xyy_3_value.setMinimumWidth(zero) + self.layout.xyy_3_value.setMaximumWidth(zero) + # LUV + self.layout.luv_1_label.setMinimumWidth(zero) + self.layout.luv_1_label.setMaximumWidth(zero) + self.layout.luv_2_label.setMinimumWidth(zero) + self.layout.luv_2_label.setMaximumWidth(zero) + self.layout.luv_3_label.setMinimumWidth(zero) + self.layout.luv_3_label.setMaximumWidth(zero) + self.layout.luv_1_value.setMinimumWidth(zero) + self.layout.luv_1_value.setMaximumWidth(zero) + self.layout.luv_2_value.setMinimumWidth(zero) + self.layout.luv_2_value.setMaximumWidth(zero) + self.layout.luv_3_value.setMinimumWidth(zero) + self.layout.luv_3_value.setMaximumWidth(zero) + # HLAB + self.layout.hlab_1_label.setMinimumWidth(zero) + self.layout.hlab_1_label.setMaximumWidth(zero) + self.layout.hlab_2_label.setMinimumWidth(zero) + self.layout.hlab_2_label.setMaximumWidth(zero) + self.layout.hlab_3_label.setMinimumWidth(zero) + self.layout.hlab_3_label.setMaximumWidth(zero) + self.layout.hlab_1_value.setMinimumWidth(zero) + self.layout.hlab_1_value.setMaximumWidth(zero) + self.layout.hlab_2_value.setMinimumWidth(zero) + self.layout.hlab_2_value.setMaximumWidth(zero) + self.layout.hlab_3_value.setMinimumWidth(zero) + self.layout.hlab_3_value.setMaximumWidth(zero) + # LAB + self.layout.lab_1_label.setMinimumWidth(zero) + self.layout.lab_1_label.setMaximumWidth(zero) + self.layout.lab_2_label.setMinimumWidth(zero) + self.layout.lab_2_label.setMaximumWidth(zero) + self.layout.lab_3_label.setMinimumWidth(zero) + self.layout.lab_3_label.setMaximumWidth(zero) + self.layout.lab_1_value.setMinimumWidth(zero) + self.layout.lab_1_value.setMaximumWidth(zero) + self.layout.lab_2_value.setMinimumWidth(zero) + self.layout.lab_2_value.setMaximumWidth(zero) + self.layout.lab_3_value.setMinimumWidth(zero) + self.layout.lab_3_value.setMaximumWidth(zero) + # LCH + self.layout.lch_1_label.setMinimumWidth(zero) + self.layout.lch_1_label.setMaximumWidth(zero) + self.layout.lch_2_label.setMinimumWidth(zero) + self.layout.lch_2_label.setMaximumWidth(zero) + self.layout.lch_3_label.setMinimumWidth(zero) + self.layout.lch_3_label.setMaximumWidth(zero) + self.layout.lch_1_value.setMinimumWidth(zero) + self.layout.lch_1_value.setMaximumWidth(zero) + self.layout.lch_2_value.setMinimumWidth(zero) + self.layout.lch_2_value.setMaximumWidth(zero) + self.layout.lch_3_value.setMinimumWidth(zero) + self.layout.lch_3_value.setMaximumWidth(zero) + self.Adjust_Spacing() + self.Ratio_Channels() + self.menu_update = 5 + def Menu_Display_Hex(self): + val = self.dialog.display_hex.isChecked() + if val == True: + self.layout.hex_string.setMinimumWidth(self.ui_40) + self.layout.hex_string.setMaximumWidth(self.ui_100) + else: + self.layout.hex_string.setMinimumWidth(zero) + self.layout.hex_string.setMaximumWidth(zero) + self.Adjust_Spacing() + self.Ratio_Channels() + self.menu_update = 5 + def Menu_HEX_Copy(self): + self.hex_copy = self.dialog.hex_copy_paste.isChecked() + def Menu_Hue_Shine(self): + self.hue_shine = self.dialog.hue_shine.isChecked() + self.Pigment_Display() + self.Pigment_Sync() + def Menu_Cursor(self): + self.cursor = self.dialog.cursor.isChecked() + if self.cursor == True: + # Select the type of cursor + self.CHANNEL_Setup("LINE") + # self.CHANNEL_Setup("DIAMOND_2") # urzeye + else: + self.CHANNEL_Setup("DIAMOND_1") + def Adjust_Spacing(self): + # Read UI settings for Load + self.chan = self.dialog.cha.isChecked() + + self.chan_aaa = self.dialog.aaa.isChecked() + self.chan_rgb = self.dialog.rgb.isChecked() + self.chan_cmy = self.dialog.cmy.isChecked() + self.chan_cmyk = self.dialog.cmyk.isChecked() + self.chan_ryb = self.dialog.ryb.isChecked() + self.chan_yuv = self.dialog.yuv.isChecked() + self.chan_kkk = self.dialog.kkk.isChecked() + + self.chan_ard = self.dialog.ard.isChecked() + self.chan_hsv = self.dialog.hsv.isChecked() + self.chan_hsl = self.dialog.hsl.isChecked() + self.chan_hcy = self.dialog.hcy.isChecked() + self.chan_sel = self.dialog.sel.isChecked() + + self.chan_xyz = self.dialog.xyz.isChecked() + self.chan_xyy = self.dialog.xyy.isChecked() + self.chan_luv = self.dialog.luv.isChecked() + self.chan_hlab = self.dialog.hlab.isChecked() + self.chan_lab = self.dialog.lab.isChecked() + self.chan_lch = self.dialog.lch.isChecked() + + # Adjust Spacing for the Channels + chan_true = (self.chan_aaa == True + or self.chan_rgb == True + or self.chan_cmy == True + or self.chan_cmyk == True + or self.chan_ryb == True + or self.chan_yuv == True + or self.chan_kkk == True + or self.chan_ard == True + or self.chan_hsv == True + or self.chan_hsl == True + or self.chan_hcy == True + or self.chan_sel == True + or self.chan_xyz == True + or self.chan_xyy == True + or self.chan_luv == True + or self.chan_hlab == True + or self.chan_lab == True + or self.chan_lch == True) + chan_false = (self.chan_aaa == False + and self.chan_rgb == False + and self.chan_cmy == False + and self.chan_cmyk == False + and self.chan_ryb == False + and self.chan_yuv == False + and self.chan_kkk == False + and self.chan_ard == False + and self.chan_hsv == False + and self.chan_hsl == False + and self.chan_hcy == False + and self.chan_sel == False + and self.chan_xyz == False + and self.chan_xyy == False + and self.chan_luv == False + and self.chan_hlab == False + and self.chan_lab == False + and self.chan_lch == False) + + # Compensate Absence of Panel with vertical_spacer + if self.dialog.pan.isChecked() == False: + self.layout.vertical_spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + else: + self.layout.vertical_spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + + # Double check Spacing errors with PaintEvents + self.menu_update = 5 + def CHANNEL_Setup(self, set): + self.aaa_1_slider.Setup("AAA1", "4", set) + self.rgb_1_slider.Setup("RGB1", "4", set) + self.rgb_2_slider.Setup("RGB2", "4", set) + self.rgb_3_slider.Setup("RGB3", "4", set) + self.cmy_1_slider.Setup("CMY1", "4", set) + self.cmy_2_slider.Setup("CMY2", "4", set) + self.cmy_3_slider.Setup("CMY3", "4", set) + self.cmyk_1_slider.Setup("CMYK1", "4", set) + self.cmyk_2_slider.Setup("CMYK2", "4", set) + self.cmyk_3_slider.Setup("CMYK3", "4", set) + self.cmyk_4_slider.Setup("CMYK4", "4", set) + self.ryb_1_slider.Setup("RYB1", "4", set) + self.ryb_2_slider.Setup("RYB2", "4", set) + self.ryb_3_slider.Setup("RYB3", "4", set) + self.yuv_1_slider.Setup("YUV1", "4", set) + self.yuv_2_slider.Setup("YUV2", "4", set) + self.yuv_3_slider.Setup("YUV3", "4", set) + self.kkk_1_slider.Setup("KKK1", "4", set) + self.ard_1_slider.Setup("HUE", "HUE", set) + self.ard_2_slider.Setup("ARD2", "4", set) + self.ard_3_slider.Setup("ARD3", "6", set) + self.hsv_1_slider.Setup("HUE", "HUE", set) + self.hsv_2_slider.Setup("HSV2", "4", set) + self.hsv_3_slider.Setup("HSV3", "4", set) + self.hsl_1_slider.Setup("HUE", "HUE", set) + self.hsl_2_slider.Setup("HSL2", "4", set) + self.hsl_3_slider.Setup("HSL3", "4", set) + self.hcy_1_slider.Setup("HUE", "HUE", set) + self.hcy_2_slider.Setup("HCY2", "4", set) + self.hcy_3_slider.Setup("HCY3", "4", set) + self.xyz_1_slider.Setup("XYZ1", "4", set) + self.xyz_2_slider.Setup("XYZ2", "4", set) + self.xyz_3_slider.Setup("XYZ3", "4", set) + self.xyy_1_slider.Setup("XYY1", "4", set) + self.xyy_2_slider.Setup("XYY2", "4", set) + self.xyy_3_slider.Setup("XYY3", "4", set) + self.luv_1_slider.Setup("LUV1", "4", set) + self.luv_2_slider.Setup("LUV2", "4", set) + self.luv_3_slider.Setup("LUV3", "4", set) + self.hlab_1_slider.Setup("HLAB1", "4", set) + self.hlab_2_slider.Setup("HLAB2", "4", set) + self.hlab_3_slider.Setup("HLAB3", "4", set) + self.lab_1_slider.Setup("LAB1", "4", set) + self.lab_2_slider.Setup("LAB2", "4", set) + self.lab_3_slider.Setup("LAB3", "4", set) + self.lch_1_slider.Setup("LCH1", "4", set) + self.lch_2_slider.Setup("LCH2", "4", set) + self.lch_3_slider.Setup("LCH3", "4", set) + self.update() + # Color Spaces + def Menu_AAA(self): + font = self.dialog.aaa.font() + if (self.chan == True and self.dialog.aaa.isChecked()): + font.setBold(True) + self.chan_aaa = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_aaa = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + self.layout.aaa_1_label.setMinimumHeight(mini) + self.layout.aaa_1_label.setMaximumHeight(maxi) + self.layout.aaa_1_slider.setMinimumHeight(mini) + self.layout.aaa_1_slider.setMaximumHeight(maxi) + self.layout.aaa_1_value.setMinimumHeight(mini) + self.layout.aaa_1_value.setMaximumHeight(maxi) + self.layout.aaa_1_tick.setMinimumHeight(tick) + self.layout.aaa_1_tick.setMaximumHeight(tick) + self.layout.channels_aaa.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_aaa.setVerticalSpacing(vert) + self.dialog.aaa.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_RGB(self): + font = self.dialog.rgb.font() + if (self.chan == True and self.dialog.rgb.isChecked()): + font.setBold(True) + self.chan_rgb = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_rgb = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.rgb_1_label.setMinimumHeight(mini) + self.layout.rgb_1_label.setMaximumHeight(maxi) + self.layout.rgb_1_slider.setMinimumHeight(mini) + self.layout.rgb_1_slider.setMaximumHeight(maxi) + self.layout.rgb_1_value.setMinimumHeight(mini) + self.layout.rgb_1_value.setMaximumHeight(maxi) + self.layout.rgb_1_tick.setMinimumHeight(tick) + self.layout.rgb_1_tick.setMaximumHeight(tick) + # 2 + self.layout.rgb_2_label.setMinimumHeight(mini) + self.layout.rgb_2_label.setMaximumHeight(maxi) + self.layout.rgb_2_slider.setMinimumHeight(mini) + self.layout.rgb_2_slider.setMaximumHeight(maxi) + self.layout.rgb_2_value.setMinimumHeight(mini) + self.layout.rgb_2_value.setMaximumHeight(maxi) + self.layout.rgb_2_tick.setMinimumHeight(tick) + self.layout.rgb_2_tick.setMaximumHeight(tick) + # 3 + self.layout.rgb_3_label.setMinimumHeight(mini) + self.layout.rgb_3_label.setMaximumHeight(maxi) + self.layout.rgb_3_slider.setMinimumHeight(mini) + self.layout.rgb_3_slider.setMaximumHeight(maxi) + self.layout.rgb_3_value.setMinimumHeight(mini) + self.layout.rgb_3_value.setMaximumHeight(maxi) + self.layout.rgb_3_tick.setMinimumHeight(tick) + self.layout.rgb_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_rgb.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_rgb.setVerticalSpacing(vert) + # menu + self.dialog.rgb.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_CMY(self): + font = self.dialog.cmy.font() + if (self.chan == True and self.dialog.cmy.isChecked()): + font.setBold(True) + self.chan_cmy = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_cmy = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.cmy_1_label.setMinimumHeight(mini) + self.layout.cmy_1_label.setMaximumHeight(maxi) + self.layout.cmy_1_slider.setMinimumHeight(mini) + self.layout.cmy_1_slider.setMaximumHeight(maxi) + self.layout.cmy_1_value.setMinimumHeight(mini) + self.layout.cmy_1_value.setMaximumHeight(maxi) + self.layout.cmy_1_tick.setMinimumHeight(tick) + self.layout.cmy_1_tick.setMaximumHeight(tick) + # 2 + self.layout.cmy_2_label.setMinimumHeight(mini) + self.layout.cmy_2_label.setMaximumHeight(maxi) + self.layout.cmy_2_slider.setMinimumHeight(mini) + self.layout.cmy_2_slider.setMaximumHeight(maxi) + self.layout.cmy_2_value.setMinimumHeight(mini) + self.layout.cmy_2_value.setMaximumHeight(maxi) + self.layout.cmy_2_tick.setMinimumHeight(tick) + self.layout.cmy_2_tick.setMaximumHeight(tick) + # 3 + self.layout.cmy_3_label.setMinimumHeight(mini) + self.layout.cmy_3_label.setMaximumHeight(maxi) + self.layout.cmy_3_slider.setMinimumHeight(mini) + self.layout.cmy_3_slider.setMaximumHeight(maxi) + self.layout.cmy_3_value.setMinimumHeight(mini) + self.layout.cmy_3_value.setMaximumHeight(maxi) + self.layout.cmy_3_tick.setMinimumHeight(tick) + self.layout.cmy_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_cmy.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_cmy.setVerticalSpacing(vert) + # menu + self.dialog.cmy.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_CMYK(self): + font = self.dialog.cmyk.font() + if (self.chan == True and self.dialog.cmyk.isChecked()): + font.setBold(True) + self.chan_cmyk = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_cmyk = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.cmyk_1_label.setMinimumHeight(mini) + self.layout.cmyk_1_label.setMaximumHeight(maxi) + self.layout.cmyk_1_slider.setMinimumHeight(mini) + self.layout.cmyk_1_slider.setMaximumHeight(maxi) + self.layout.cmyk_1_value.setMinimumHeight(mini) + self.layout.cmyk_1_value.setMaximumHeight(maxi) + self.layout.cmyk_1_tick.setMinimumHeight(tick) + self.layout.cmyk_1_tick.setMaximumHeight(tick) + # 2 + self.layout.cmyk_2_label.setMinimumHeight(mini) + self.layout.cmyk_2_label.setMaximumHeight(maxi) + self.layout.cmyk_2_slider.setMinimumHeight(mini) + self.layout.cmyk_2_slider.setMaximumHeight(maxi) + self.layout.cmyk_2_value.setMinimumHeight(mini) + self.layout.cmyk_2_value.setMaximumHeight(maxi) + self.layout.cmyk_2_tick.setMinimumHeight(tick) + self.layout.cmyk_2_tick.setMaximumHeight(tick) + # 3 + self.layout.cmyk_3_label.setMinimumHeight(mini) + self.layout.cmyk_3_label.setMaximumHeight(maxi) + self.layout.cmyk_3_slider.setMinimumHeight(mini) + self.layout.cmyk_3_slider.setMaximumHeight(maxi) + self.layout.cmyk_3_value.setMinimumHeight(mini) + self.layout.cmyk_3_value.setMaximumHeight(maxi) + self.layout.cmyk_3_tick.setMinimumHeight(tick) + self.layout.cmyk_3_tick.setMaximumHeight(tick) + # 4 + self.layout.cmyk_4_label.setMinimumHeight(mini) + self.layout.cmyk_4_label.setMaximumHeight(maxi) + self.layout.cmyk_4_slider.setMinimumHeight(mini) + self.layout.cmyk_4_slider.setMaximumHeight(maxi) + self.layout.cmyk_4_value.setMinimumHeight(mini) + self.layout.cmyk_4_value.setMaximumHeight(maxi) + self.layout.cmyk_4_tick.setMinimumHeight(tick) + self.layout.cmyk_4_tick.setMaximumHeight(tick) + self.layout.cmyk_4_lock.setMinimumHeight(mini) + self.layout.cmyk_4_lock.setMaximumHeight(maxi) + # layout + self.layout.channels_cmyk.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_cmyk.setVerticalSpacing(vert) + # menu + self.dialog.cmyk.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_RYB(self): + font = self.dialog.ryb.font() + if (self.chan == True and self.dialog.ryb.isChecked()): + font.setBold(True) + self.chan_ryb = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_ryb = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.ryb_1_label.setMinimumHeight(mini) + self.layout.ryb_1_label.setMaximumHeight(maxi) + self.layout.ryb_1_slider.setMinimumHeight(mini) + self.layout.ryb_1_slider.setMaximumHeight(maxi) + self.layout.ryb_1_value.setMinimumHeight(mini) + self.layout.ryb_1_value.setMaximumHeight(maxi) + self.layout.ryb_1_tick.setMinimumHeight(tick) + self.layout.ryb_1_tick.setMaximumHeight(tick) + # 2 + self.layout.ryb_2_label.setMinimumHeight(mini) + self.layout.ryb_2_label.setMaximumHeight(maxi) + self.layout.ryb_2_slider.setMinimumHeight(mini) + self.layout.ryb_2_slider.setMaximumHeight(maxi) + self.layout.ryb_2_value.setMinimumHeight(mini) + self.layout.ryb_2_value.setMaximumHeight(maxi) + self.layout.ryb_2_tick.setMinimumHeight(tick) + self.layout.ryb_2_tick.setMaximumHeight(tick) + # 3 + self.layout.ryb_3_label.setMinimumHeight(mini) + self.layout.ryb_3_label.setMaximumHeight(maxi) + self.layout.ryb_3_slider.setMinimumHeight(mini) + self.layout.ryb_3_slider.setMaximumHeight(maxi) + self.layout.ryb_3_value.setMinimumHeight(mini) + self.layout.ryb_3_value.setMaximumHeight(maxi) + self.layout.ryb_3_tick.setMinimumHeight(tick) + self.layout.ryb_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_ryb.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_ryb.setVerticalSpacing(vert) + # menu + self.dialog.ryb.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_YUV(self): + font = self.dialog.yuv.font() + if (self.chan == True and self.dialog.yuv.isChecked()): + font.setBold(True) + self.chan_yuv = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_yuv = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.yuv_1_label.setMinimumHeight(mini) + self.layout.yuv_1_label.setMaximumHeight(maxi) + self.layout.yuv_1_slider.setMinimumHeight(mini) + self.layout.yuv_1_slider.setMaximumHeight(maxi) + self.layout.yuv_1_value.setMinimumHeight(mini) + self.layout.yuv_1_value.setMaximumHeight(maxi) + self.layout.yuv_1_tick.setMinimumHeight(tick) + self.layout.yuv_1_tick.setMaximumHeight(tick) + # 2 + self.layout.yuv_2_label.setMinimumHeight(mini) + self.layout.yuv_2_label.setMaximumHeight(maxi) + self.layout.yuv_2_slider.setMinimumHeight(mini) + self.layout.yuv_2_slider.setMaximumHeight(maxi) + self.layout.yuv_2_value.setMinimumHeight(mini) + self.layout.yuv_2_value.setMaximumHeight(maxi) + self.layout.yuv_2_tick.setMinimumHeight(tick) + self.layout.yuv_2_tick.setMaximumHeight(tick) + # 3 + self.layout.yuv_3_label.setMinimumHeight(mini) + self.layout.yuv_3_label.setMaximumHeight(maxi) + self.layout.yuv_3_slider.setMinimumHeight(mini) + self.layout.yuv_3_slider.setMaximumHeight(maxi) + self.layout.yuv_3_value.setMinimumHeight(mini) + self.layout.yuv_3_value.setMaximumHeight(maxi) + self.layout.yuv_3_tick.setMinimumHeight(tick) + self.layout.yuv_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_yuv.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_yuv.setVerticalSpacing(vert) + # menu + self.dialog.yuv.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_KKK(self): + font = self.dialog.kkk.font() + if (self.chan == True and self.dialog.kkk.isChecked()): + font.setBold(True) + self.chan_kkk = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_kkk = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.kkk_1_label.setMinimumHeight(mini) + self.layout.kkk_1_label.setMaximumHeight(maxi) + self.layout.kkk_1_slider.setMinimumHeight(mini) + self.layout.kkk_1_slider.setMaximumHeight(maxi) + self.layout.kkk_1_value.setMinimumHeight(mini) + self.layout.kkk_1_value.setMaximumHeight(maxi) + self.layout.kkk_1_tick.setMinimumHeight(tick) + self.layout.kkk_1_tick.setMaximumHeight(tick) + self.layout.kkk_1_lock.setMinimumHeight(mini) + self.layout.kkk_1_lock.setMaximumHeight(maxi) + # layout + self.layout.channels_kkk.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_kkk.setVerticalSpacing(vert) + # menu + self.dialog.kkk.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_ARD(self): + font = self.dialog.ard.font() + if (self.chan == True and self.dialog.ard.isChecked()): + font.setBold(True) + self.chan_ard = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_ard = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.ard_1_label.setMinimumHeight(mini) + self.layout.ard_1_label.setMaximumHeight(maxi) + self.layout.ard_1_slider.setMinimumHeight(mini) + self.layout.ard_1_slider.setMaximumHeight(maxi) + self.layout.ard_1_value.setMinimumHeight(mini) + self.layout.ard_1_value.setMaximumHeight(maxi) + self.layout.ard_1_tick.setMinimumHeight(tick) + self.layout.ard_1_tick.setMaximumHeight(tick) + self.layout.ard_1_lock.setMinimumHeight(mini) + self.layout.ard_1_lock.setMaximumHeight(maxi) + # 2 + self.layout.ard_2_label.setMinimumHeight(mini) + self.layout.ard_2_label.setMaximumHeight(maxi) + self.layout.ard_2_slider.setMinimumHeight(mini) + self.layout.ard_2_slider.setMaximumHeight(maxi) + self.layout.ard_2_value.setMinimumHeight(mini) + self.layout.ard_2_value.setMaximumHeight(maxi) + self.layout.ard_2_tick.setMinimumHeight(tick) + self.layout.ard_2_tick.setMaximumHeight(tick) + # 3 + self.layout.ard_3_label.setMinimumHeight(mini) + self.layout.ard_3_label.setMaximumHeight(maxi) + self.layout.ard_3_slider.setMinimumHeight(mini) + self.layout.ard_3_slider.setMaximumHeight(maxi) + self.layout.ard_3_value.setMinimumHeight(mini) + self.layout.ard_3_value.setMaximumHeight(maxi) + self.layout.ard_3_tick.setMinimumHeight(tick) + self.layout.ard_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_ard.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_ard.setVerticalSpacing(vert) + # menu + self.dialog.ard.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_HSV(self): + font = self.dialog.hsv.font() + if (self.chan == True and self.dialog.hsv.isChecked()): + font.setBold(True) + self.chan_hsv = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_hsv = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.hsv_1_label.setMinimumHeight(mini) + self.layout.hsv_1_label.setMaximumHeight(maxi) + self.layout.hsv_1_slider.setMinimumHeight(mini) + self.layout.hsv_1_slider.setMaximumHeight(maxi) + self.layout.hsv_1_value.setMinimumHeight(mini) + self.layout.hsv_1_value.setMaximumHeight(maxi) + self.layout.hsv_1_tick.setMinimumHeight(tick) + self.layout.hsv_1_tick.setMaximumHeight(tick) + # 2 + self.layout.hsv_2_label.setMinimumHeight(mini) + self.layout.hsv_2_label.setMaximumHeight(maxi) + self.layout.hsv_2_slider.setMinimumHeight(mini) + self.layout.hsv_2_slider.setMaximumHeight(maxi) + self.layout.hsv_2_value.setMinimumHeight(mini) + self.layout.hsv_2_value.setMaximumHeight(maxi) + self.layout.hsv_2_tick.setMinimumHeight(tick) + self.layout.hsv_2_tick.setMaximumHeight(tick) + # 3 + self.layout.hsv_3_label.setMinimumHeight(mini) + self.layout.hsv_3_label.setMaximumHeight(maxi) + self.layout.hsv_3_slider.setMinimumHeight(mini) + self.layout.hsv_3_slider.setMaximumHeight(maxi) + self.layout.hsv_3_value.setMinimumHeight(mini) + self.layout.hsv_3_value.setMaximumHeight(maxi) + self.layout.hsv_3_tick.setMinimumHeight(tick) + self.layout.hsv_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_hsv.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_hsv.setVerticalSpacing(vert) + # menu + self.dialog.hsv.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + self.panel_hsv.update() + except: + pass + def Menu_HSL(self): + font = self.dialog.hsl.font() + if (self.chan == True and self.dialog.hsl.isChecked()): + font.setBold(True) + self.chan_hsl = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_hsl = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.hsl_1_label.setMinimumHeight(mini) + self.layout.hsl_1_label.setMaximumHeight(maxi) + self.layout.hsl_1_slider.setMinimumHeight(mini) + self.layout.hsl_1_slider.setMaximumHeight(maxi) + self.layout.hsl_1_value.setMinimumHeight(mini) + self.layout.hsl_1_value.setMaximumHeight(maxi) + self.layout.hsl_1_tick.setMinimumHeight(tick) + self.layout.hsl_1_tick.setMaximumHeight(tick) + # 2 + self.layout.hsl_2_label.setMinimumHeight(mini) + self.layout.hsl_2_label.setMaximumHeight(maxi) + self.layout.hsl_2_slider.setMinimumHeight(mini) + self.layout.hsl_2_slider.setMaximumHeight(maxi) + self.layout.hsl_2_value.setMinimumHeight(mini) + self.layout.hsl_2_value.setMaximumHeight(maxi) + self.layout.hsl_2_tick.setMinimumHeight(tick) + self.layout.hsl_2_tick.setMaximumHeight(tick) + # 3 + self.layout.hsl_3_label.setMinimumHeight(mini) + self.layout.hsl_3_label.setMaximumHeight(maxi) + self.layout.hsl_3_slider.setMinimumHeight(mini) + self.layout.hsl_3_slider.setMaximumHeight(maxi) + self.layout.hsl_3_value.setMinimumHeight(mini) + self.layout.hsl_3_value.setMaximumHeight(maxi) + self.layout.hsl_3_tick.setMinimumHeight(tick) + self.layout.hsl_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_hsl.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_hsl.setVerticalSpacing(vert) + # menu + self.dialog.hsl.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_HCY(self): + font = self.dialog.hcy.font() + if (self.chan == True and self.dialog.hcy.isChecked()): + font.setBold(True) + self.chan_hcy = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_hcy = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.hcy_1_label.setMinimumHeight(mini) + self.layout.hcy_1_label.setMaximumHeight(maxi) + self.layout.hcy_1_slider.setMinimumHeight(mini) + self.layout.hcy_1_slider.setMaximumHeight(maxi) + self.layout.hcy_1_value.setMinimumHeight(mini) + self.layout.hcy_1_value.setMaximumHeight(maxi) + self.layout.hcy_1_tick.setMinimumHeight(tick) + self.layout.hcy_1_tick.setMaximumHeight(tick) + # 2 + self.layout.hcy_2_label.setMinimumHeight(mini) + self.layout.hcy_2_label.setMaximumHeight(maxi) + self.layout.hcy_2_slider.setMinimumHeight(mini) + self.layout.hcy_2_slider.setMaximumHeight(maxi) + self.layout.hcy_2_value.setMinimumHeight(mini) + self.layout.hcy_2_value.setMaximumHeight(maxi) + self.layout.hcy_2_tick.setMinimumHeight(tick) + self.layout.hcy_2_tick.setMaximumHeight(tick) + # 3 + self.layout.hcy_3_label.setMinimumHeight(mini) + self.layout.hcy_3_label.setMaximumHeight(maxi) + self.layout.hcy_3_slider.setMinimumHeight(mini) + self.layout.hcy_3_slider.setMaximumHeight(maxi) + self.layout.hcy_3_value.setMinimumHeight(mini) + self.layout.hcy_3_value.setMaximumHeight(maxi) + self.layout.hcy_3_tick.setMinimumHeight(tick) + self.layout.hcy_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_hcy.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_hcy.setVerticalSpacing(vert) + # menu + self.dialog.hcy.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_SEL(self): + font = self.dialog.sel.font() + if (self.chan == True and self.dialog.sel.isChecked()): + font.setBold(True) + self.chan_sel = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_sel = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.sel_1_label.setMinimumHeight(mini) + self.layout.sel_1_label.setMaximumHeight(maxi) + self.layout.sel_1_slider.setMinimumHeight(mini) + self.layout.sel_1_slider.setMaximumHeight(maxi) + self.layout.sel_1_value.setMinimumHeight(mini) + self.layout.sel_1_value.setMaximumHeight(maxi) + self.layout.sel_1_tick.setMinimumHeight(tick) + self.layout.sel_1_tick.setMaximumHeight(tick) + # 2 + self.layout.sel_2_label.setMinimumHeight(mini) + self.layout.sel_2_label.setMaximumHeight(maxi) + self.layout.sel_2_slider.setMinimumHeight(mini) + self.layout.sel_2_slider.setMaximumHeight(maxi) + self.layout.sel_2_value.setMinimumHeight(mini) + self.layout.sel_2_value.setMaximumHeight(maxi) + self.layout.sel_2_tick.setMinimumHeight(tick) + self.layout.sel_2_tick.setMaximumHeight(tick) + # 3 + self.layout.sel_3_label.setMinimumHeight(mini) + self.layout.sel_3_label.setMaximumHeight(maxi) + self.layout.sel_3_slider.setMinimumHeight(mini) + self.layout.sel_3_slider.setMaximumHeight(maxi) + self.layout.sel_3_value.setMinimumHeight(mini) + self.layout.sel_3_value.setMaximumHeight(maxi) + self.layout.sel_3_tick.setMinimumHeight(tick) + self.layout.sel_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_sel.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_sel.setVerticalSpacing(vert) + # menu + self.dialog.sel.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_XYZ(self): + font = self.dialog.xyz.font() + if (self.chan == True and self.dialog.xyz.isChecked()): + font.setBold(True) + self.chan_xyz = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_xyz = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.xyz_1_label.setMinimumHeight(mini) + self.layout.xyz_1_label.setMaximumHeight(maxi) + self.layout.xyz_1_slider.setMinimumHeight(mini) + self.layout.xyz_1_slider.setMaximumHeight(maxi) + self.layout.xyz_1_value.setMinimumHeight(mini) + self.layout.xyz_1_value.setMaximumHeight(maxi) + self.layout.xyz_1_tick.setMinimumHeight(tick) + self.layout.xyz_1_tick.setMaximumHeight(tick) + # 2 + self.layout.xyz_2_label.setMinimumHeight(mini) + self.layout.xyz_2_label.setMaximumHeight(maxi) + self.layout.xyz_2_slider.setMinimumHeight(mini) + self.layout.xyz_2_slider.setMaximumHeight(maxi) + self.layout.xyz_2_value.setMinimumHeight(mini) + self.layout.xyz_2_value.setMaximumHeight(maxi) + self.layout.xyz_2_tick.setMinimumHeight(tick) + self.layout.xyz_2_tick.setMaximumHeight(tick) + # 3 + self.layout.xyz_3_label.setMinimumHeight(mini) + self.layout.xyz_3_label.setMaximumHeight(maxi) + self.layout.xyz_3_slider.setMinimumHeight(mini) + self.layout.xyz_3_slider.setMaximumHeight(maxi) + self.layout.xyz_3_value.setMinimumHeight(mini) + self.layout.xyz_3_value.setMaximumHeight(maxi) + self.layout.xyz_3_tick.setMinimumHeight(tick) + self.layout.xyz_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_xyz.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_xyz.setVerticalSpacing(vert) + # menu + self.dialog.xyz.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_XYY(self): + font = self.dialog.xyy.font() + if (self.chan == True and self.dialog.xyy.isChecked()): + font.setBold(True) + self.chan_xyy = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_xyy = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.xyy_1_label.setMinimumHeight(mini) + self.layout.xyy_1_label.setMaximumHeight(maxi) + self.layout.xyy_1_slider.setMinimumHeight(mini) + self.layout.xyy_1_slider.setMaximumHeight(maxi) + self.layout.xyy_1_value.setMinimumHeight(mini) + self.layout.xyy_1_value.setMaximumHeight(maxi) + self.layout.xyy_1_tick.setMinimumHeight(tick) + self.layout.xyy_1_tick.setMaximumHeight(tick) + # 2 + self.layout.xyy_2_label.setMinimumHeight(mini) + self.layout.xyy_2_label.setMaximumHeight(maxi) + self.layout.xyy_2_slider.setMinimumHeight(mini) + self.layout.xyy_2_slider.setMaximumHeight(maxi) + self.layout.xyy_2_value.setMinimumHeight(mini) + self.layout.xyy_2_value.setMaximumHeight(maxi) + self.layout.xyy_2_tick.setMinimumHeight(tick) + self.layout.xyy_2_tick.setMaximumHeight(tick) + # 3 + self.layout.xyy_3_label.setMinimumHeight(mini) + self.layout.xyy_3_label.setMaximumHeight(maxi) + self.layout.xyy_3_slider.setMinimumHeight(mini) + self.layout.xyy_3_slider.setMaximumHeight(maxi) + self.layout.xyy_3_value.setMinimumHeight(mini) + self.layout.xyy_3_value.setMaximumHeight(maxi) + self.layout.xyy_3_tick.setMinimumHeight(tick) + self.layout.xyy_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_xyy.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_xyy.setVerticalSpacing(vert) + # menu + self.dialog.xyy.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_LUV(self): + font = self.dialog.luv.font() + if (self.chan == True and self.dialog.luv.isChecked()): + font.setBold(True) + self.chan_luv = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_luv = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.luv_1_label.setMinimumHeight(mini) + self.layout.luv_1_label.setMaximumHeight(maxi) + self.layout.luv_1_slider.setMinimumHeight(mini) + self.layout.luv_1_slider.setMaximumHeight(maxi) + self.layout.luv_1_value.setMinimumHeight(mini) + self.layout.luv_1_value.setMaximumHeight(maxi) + self.layout.luv_1_tick.setMinimumHeight(tick) + self.layout.luv_1_tick.setMaximumHeight(tick) + # 2 + self.layout.luv_2_label.setMinimumHeight(mini) + self.layout.luv_2_label.setMaximumHeight(maxi) + self.layout.luv_2_slider.setMinimumHeight(mini) + self.layout.luv_2_slider.setMaximumHeight(maxi) + self.layout.luv_2_value.setMinimumHeight(mini) + self.layout.luv_2_value.setMaximumHeight(maxi) + self.layout.luv_2_tick.setMinimumHeight(tick) + self.layout.luv_2_tick.setMaximumHeight(tick) + # 3 + self.layout.luv_3_label.setMinimumHeight(mini) + self.layout.luv_3_label.setMaximumHeight(maxi) + self.layout.luv_3_slider.setMinimumHeight(mini) + self.layout.luv_3_slider.setMaximumHeight(maxi) + self.layout.luv_3_value.setMinimumHeight(mini) + self.layout.luv_3_value.setMaximumHeight(maxi) + self.layout.luv_3_tick.setMinimumHeight(tick) + self.layout.luv_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_luv.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_luv.setVerticalSpacing(vert) + # menu + self.dialog.luv.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_HLAB(self): + font = self.dialog.hlab.font() + if (self.chan == True and self.dialog.hlab.isChecked()): + font.setBold(True) + self.chan_hlab = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_hlab = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.hlab_1_label.setMinimumHeight(mini) + self.layout.hlab_1_label.setMaximumHeight(maxi) + self.layout.hlab_1_slider.setMinimumHeight(mini) + self.layout.hlab_1_slider.setMaximumHeight(maxi) + self.layout.hlab_1_value.setMinimumHeight(mini) + self.layout.hlab_1_value.setMaximumHeight(maxi) + self.layout.hlab_1_tick.setMinimumHeight(tick) + self.layout.hlab_1_tick.setMaximumHeight(tick) + # 2 + self.layout.hlab_2_label.setMinimumHeight(mini) + self.layout.hlab_2_label.setMaximumHeight(maxi) + self.layout.hlab_2_slider.setMinimumHeight(mini) + self.layout.hlab_2_slider.setMaximumHeight(maxi) + self.layout.hlab_2_value.setMinimumHeight(mini) + self.layout.hlab_2_value.setMaximumHeight(maxi) + self.layout.hlab_2_tick.setMinimumHeight(tick) + self.layout.hlab_2_tick.setMaximumHeight(tick) + # 3 + self.layout.hlab_3_label.setMinimumHeight(mini) + self.layout.hlab_3_label.setMaximumHeight(maxi) + self.layout.hlab_3_slider.setMinimumHeight(mini) + self.layout.hlab_3_slider.setMaximumHeight(maxi) + self.layout.hlab_3_value.setMinimumHeight(mini) + self.layout.hlab_3_value.setMaximumHeight(maxi) + self.layout.hlab_3_tick.setMinimumHeight(tick) + self.layout.hlab_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_hlab.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_hlab.setVerticalSpacing(vert) + # menu + self.dialog.hlab.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_LAB(self): + font = self.dialog.lab.font() + if (self.chan == True and self.dialog.lab.isChecked()): + font.setBold(True) + self.chan_lab = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_lab = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.lab_1_label.setMinimumHeight(mini) + self.layout.lab_1_label.setMaximumHeight(maxi) + self.layout.lab_1_slider.setMinimumHeight(mini) + self.layout.lab_1_slider.setMaximumHeight(maxi) + self.layout.lab_1_value.setMinimumHeight(mini) + self.layout.lab_1_value.setMaximumHeight(maxi) + self.layout.lab_1_tick.setMinimumHeight(tick) + self.layout.lab_1_tick.setMaximumHeight(tick) + # 2 + self.layout.lab_2_label.setMinimumHeight(mini) + self.layout.lab_2_label.setMaximumHeight(maxi) + self.layout.lab_2_slider.setMinimumHeight(mini) + self.layout.lab_2_slider.setMaximumHeight(maxi) + self.layout.lab_2_value.setMinimumHeight(mini) + self.layout.lab_2_value.setMaximumHeight(maxi) + self.layout.lab_2_tick.setMinimumHeight(tick) + self.layout.lab_2_tick.setMaximumHeight(tick) + # 3 + self.layout.lab_3_label.setMinimumHeight(mini) + self.layout.lab_3_label.setMaximumHeight(maxi) + self.layout.lab_3_slider.setMinimumHeight(mini) + self.layout.lab_3_slider.setMaximumHeight(maxi) + self.layout.lab_3_value.setMinimumHeight(mini) + self.layout.lab_3_value.setMaximumHeight(maxi) + self.layout.lab_3_tick.setMinimumHeight(tick) + self.layout.lab_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_lab.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_lab.setVerticalSpacing(vert) + # menu + self.dialog.lab.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + def Menu_LCH(self): + font = self.dialog.lch.font() + if (self.chan == True and self.dialog.lch.isChecked()): + font.setBold(True) + self.chan_lch = True + mini = self.ui_10 + maxi = self.ui_20 + tick = unit + horz = zero + vert = unit + else: + font.setBold(False) + self.chan_lch = False + mini = zero + maxi = zero + tick = zero + horz = unit + vert = zero + # 1 + self.layout.lch_1_label.setMinimumHeight(mini) + self.layout.lch_1_label.setMaximumHeight(maxi) + self.layout.lch_1_slider.setMinimumHeight(mini) + self.layout.lch_1_slider.setMaximumHeight(maxi) + self.layout.lch_1_value.setMinimumHeight(mini) + self.layout.lch_1_value.setMaximumHeight(maxi) + self.layout.lch_1_tick.setMinimumHeight(tick) + self.layout.lch_1_tick.setMaximumHeight(tick) + # 2 + self.layout.lch_2_label.setMinimumHeight(mini) + self.layout.lch_2_label.setMaximumHeight(maxi) + self.layout.lch_2_slider.setMinimumHeight(mini) + self.layout.lch_2_slider.setMaximumHeight(maxi) + self.layout.lch_2_value.setMinimumHeight(mini) + self.layout.lch_2_value.setMaximumHeight(maxi) + self.layout.lch_2_tick.setMinimumHeight(tick) + self.layout.lch_2_tick.setMaximumHeight(tick) + # 3 + self.layout.lch_3_label.setMinimumHeight(mini) + self.layout.lch_3_label.setMaximumHeight(maxi) + self.layout.lch_3_slider.setMinimumHeight(mini) + self.layout.lch_3_slider.setMaximumHeight(maxi) + self.layout.lch_3_value.setMinimumHeight(mini) + self.layout.lch_3_value.setMaximumHeight(maxi) + self.layout.lch_3_tick.setMinimumHeight(tick) + self.layout.lch_3_tick.setMaximumHeight(tick) + # layout + self.layout.channels_lch.setContentsMargins(horz,vert,horz,vert) + self.layout.channels_lch.setVerticalSpacing(vert) + # menu + self.dialog.lch.setFont(font) + self.Adjust_Spacing() + try: + self.Pigment_Display() + except: + pass + + # Palette + def Menu_COR(self): + font = self.dialog.cor.font() + if self.dialog.cor.isChecked(): + font.setBold(True) + self.dialog.cor.setText("[PALETTE]") + self.layout.cor_00.setMinimumHeight(self.ui_50) + self.layout.cor_00.setMaximumHeight(self.ui_50) + self.layout.cor_01.setMinimumHeight(self.ui_50) + self.layout.cor_01.setMaximumHeight(self.ui_50) + self.layout.cor_02.setMinimumHeight(self.ui_50) + self.layout.cor_02.setMaximumHeight(self.ui_50) + self.layout.cor_03.setMinimumHeight(self.ui_50) + self.layout.cor_03.setMaximumHeight(self.ui_50) + self.layout.cor_04.setMinimumHeight(self.ui_50) + self.layout.cor_04.setMaximumHeight(self.ui_50) + self.layout.cor_05.setMinimumHeight(self.ui_50) + self.layout.cor_05.setMaximumHeight(self.ui_50) + self.layout.cor_06.setMinimumHeight(self.ui_50) + self.layout.cor_06.setMaximumHeight(self.ui_50) + self.layout.cor_07.setMinimumHeight(self.ui_50) + self.layout.cor_07.setMaximumHeight(self.ui_50) + self.layout.cor_08.setMinimumHeight(self.ui_50) + self.layout.cor_08.setMaximumHeight(self.ui_50) + self.layout.cor_09.setMinimumHeight(self.ui_50) + self.layout.cor_09.setMaximumHeight(self.ui_50) + self.layout.cor_10.setMinimumHeight(self.ui_50) + self.layout.cor_10.setMaximumHeight(self.ui_50) + self.layout.cores.setContentsMargins(zero, unit, zero, unit) + else: + font.setBold(False) + self.dialog.cor.setText("PALETTE") + self.layout.cor_00.setMinimumHeight(zero) + self.layout.cor_00.setMaximumHeight(zero) + self.layout.cor_01.setMinimumHeight(zero) + self.layout.cor_01.setMaximumHeight(zero) + self.layout.cor_02.setMinimumHeight(zero) + self.layout.cor_02.setMaximumHeight(zero) + self.layout.cor_03.setMinimumHeight(zero) + self.layout.cor_03.setMaximumHeight(zero) + self.layout.cor_04.setMinimumHeight(zero) + self.layout.cor_04.setMaximumHeight(zero) + self.layout.cor_05.setMinimumHeight(zero) + self.layout.cor_05.setMaximumHeight(zero) + self.layout.cor_06.setMinimumHeight(zero) + self.layout.cor_06.setMaximumHeight(zero) + self.layout.cor_07.setMinimumHeight(zero) + self.layout.cor_07.setMaximumHeight(zero) + self.layout.cor_08.setMinimumHeight(zero) + self.layout.cor_08.setMaximumHeight(zero) + self.layout.cor_09.setMinimumHeight(zero) + self.layout.cor_09.setMaximumHeight(zero) + self.layout.cor_10.setMinimumHeight(zero) + self.layout.cor_10.setMaximumHeight(zero) + self.layout.cores.setContentsMargins(zero, zero, zero, zero) + self.dialog.cor.setFont(font) + self.menu_update = 5 + + # Mixers + def Menu_MIX(self): + font = self.dialog.mix.font() + self.MIX_Shrink() + self.menu_mix = self.dialog.mix.isChecked() + self.menu_mix_index = self.dialog.mix_index.currentText() + # UI and Text + if self.menu_mix == False: + font.setBold(False) + self.dialog.mix.setText("MIXER") + else: + font.setBold(True) + self.dialog.mix.setText("[MIXER]") + # Scale up the correct Mixer + if (self.menu_mix == True and self.menu_mix_index == "TTS"): + self.layout.tts_l1.setMinimumHeight(self.ui_17) + self.layout.tts_l1.setMaximumHeight(self.ui_47) + self.layout.tint.setMinimumHeight(self.ui_15) + self.layout.tint.setMaximumHeight(self.ui_15) + self.layout.tone.setMinimumHeight(self.ui_15) + self.layout.tone.setMaximumHeight(self.ui_15) + self.layout.shade.setMinimumHeight(self.ui_15) + self.layout.shade.setMaximumHeight(self.ui_15) + self.layout.white.setMinimumHeight(self.ui_15) + self.layout.white.setMaximumHeight(self.ui_15) + self.layout.grey.setMinimumHeight(self.ui_15) + self.layout.grey.setMaximumHeight(self.ui_15) + self.layout.black.setMinimumHeight(self.ui_15) + self.layout.black.setMaximumHeight(self.ui_15) + self.layout.tint_tone_shade.setContentsMargins(zero, unit, zero, unit) + self.layout.tint_tone_shade.setVerticalSpacing(unit) + + if (self.menu_mix == True and self.menu_mix_index == "RGB"): + self.layout.rgb_l1.setMinimumHeight(self.ui_15) + self.layout.rgb_l1.setMaximumHeight(self.ui_15) + self.layout.rgb_l2.setMinimumHeight(self.ui_15) + self.layout.rgb_l2.setMaximumHeight(self.ui_15) + self.layout.rgb_l3.setMinimumHeight(self.ui_15) + self.layout.rgb_l3.setMaximumHeight(self.ui_15) + self.layout.rgb_r1.setMinimumHeight(self.ui_15) + self.layout.rgb_r1.setMaximumHeight(self.ui_15) + self.layout.rgb_r2.setMinimumHeight(self.ui_15) + self.layout.rgb_r2.setMaximumHeight(self.ui_15) + self.layout.rgb_r3.setMinimumHeight(self.ui_15) + self.layout.rgb_r3.setMaximumHeight(self.ui_15) + self.layout.rgb_g1.setMinimumHeight(self.ui_15) + self.layout.rgb_g1.setMaximumHeight(self.ui_15) + self.layout.rgb_g2.setMinimumHeight(self.ui_15) + self.layout.rgb_g2.setMaximumHeight(self.ui_15) + self.layout.rgb_g3.setMinimumHeight(self.ui_15) + self.layout.rgb_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_rgb.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_rgb.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "CMYK"): + self.layout.cmyk_l1.setMinimumHeight(self.ui_15) + self.layout.cmyk_l1.setMaximumHeight(self.ui_15) + self.layout.cmyk_l2.setMinimumHeight(self.ui_15) + self.layout.cmyk_l2.setMaximumHeight(self.ui_15) + self.layout.cmyk_l3.setMinimumHeight(self.ui_15) + self.layout.cmyk_l3.setMaximumHeight(self.ui_15) + self.layout.cmyk_r1.setMinimumHeight(self.ui_15) + self.layout.cmyk_r1.setMaximumHeight(self.ui_15) + self.layout.cmyk_r2.setMinimumHeight(self.ui_15) + self.layout.cmyk_r2.setMaximumHeight(self.ui_15) + self.layout.cmyk_r3.setMinimumHeight(self.ui_15) + self.layout.cmyk_r3.setMaximumHeight(self.ui_15) + self.layout.cmyk_g1.setMinimumHeight(self.ui_15) + self.layout.cmyk_g1.setMaximumHeight(self.ui_15) + self.layout.cmyk_g2.setMinimumHeight(self.ui_15) + self.layout.cmyk_g2.setMaximumHeight(self.ui_15) + self.layout.cmyk_g3.setMinimumHeight(self.ui_15) + self.layout.cmyk_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_cmyk.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_cmyk.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "RYB"): + self.layout.ryb_l1.setMinimumHeight(self.ui_15) + self.layout.ryb_l1.setMaximumHeight(self.ui_15) + self.layout.ryb_l2.setMinimumHeight(self.ui_15) + self.layout.ryb_l2.setMaximumHeight(self.ui_15) + self.layout.ryb_l3.setMinimumHeight(self.ui_15) + self.layout.ryb_l3.setMaximumHeight(self.ui_15) + self.layout.ryb_r1.setMinimumHeight(self.ui_15) + self.layout.ryb_r1.setMaximumHeight(self.ui_15) + self.layout.ryb_r2.setMinimumHeight(self.ui_15) + self.layout.ryb_r2.setMaximumHeight(self.ui_15) + self.layout.ryb_r3.setMinimumHeight(self.ui_15) + self.layout.ryb_r3.setMaximumHeight(self.ui_15) + self.layout.ryb_g1.setMinimumHeight(self.ui_15) + self.layout.ryb_g1.setMaximumHeight(self.ui_15) + self.layout.ryb_g2.setMinimumHeight(self.ui_15) + self.layout.ryb_g2.setMaximumHeight(self.ui_15) + self.layout.ryb_g3.setMinimumHeight(self.ui_15) + self.layout.ryb_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_ryb.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_ryb.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "YUV"): + self.layout.yuv_l1.setMinimumHeight(self.ui_15) + self.layout.yuv_l1.setMaximumHeight(self.ui_15) + self.layout.yuv_l2.setMinimumHeight(self.ui_15) + self.layout.yuv_l2.setMaximumHeight(self.ui_15) + self.layout.yuv_l3.setMinimumHeight(self.ui_15) + self.layout.yuv_l3.setMaximumHeight(self.ui_15) + self.layout.yuv_r1.setMinimumHeight(self.ui_15) + self.layout.yuv_r1.setMaximumHeight(self.ui_15) + self.layout.yuv_r2.setMinimumHeight(self.ui_15) + self.layout.yuv_r2.setMaximumHeight(self.ui_15) + self.layout.yuv_r3.setMinimumHeight(self.ui_15) + self.layout.yuv_r3.setMaximumHeight(self.ui_15) + self.layout.yuv_g1.setMinimumHeight(self.ui_15) + self.layout.yuv_g1.setMaximumHeight(self.ui_15) + self.layout.yuv_g2.setMinimumHeight(self.ui_15) + self.layout.yuv_g2.setMaximumHeight(self.ui_15) + self.layout.yuv_g3.setMinimumHeight(self.ui_15) + self.layout.yuv_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_yuv.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_yuv.setVerticalSpacing(unit) + + if (self.menu_mix == True and self.menu_mix_index == "ARD"): + self.layout.ard_l1.setMinimumHeight(self.ui_15) + self.layout.ard_l1.setMaximumHeight(self.ui_15) + self.layout.ard_l2.setMinimumHeight(self.ui_15) + self.layout.ard_l2.setMaximumHeight(self.ui_15) + self.layout.ard_l3.setMinimumHeight(self.ui_15) + self.layout.ard_l3.setMaximumHeight(self.ui_15) + self.layout.ard_r1.setMinimumHeight(self.ui_15) + self.layout.ard_r1.setMaximumHeight(self.ui_15) + self.layout.ard_r2.setMinimumHeight(self.ui_15) + self.layout.ard_r2.setMaximumHeight(self.ui_15) + self.layout.ard_r3.setMinimumHeight(self.ui_15) + self.layout.ard_r3.setMaximumHeight(self.ui_15) + self.layout.ard_g1.setMinimumHeight(self.ui_15) + self.layout.ard_g1.setMaximumHeight(self.ui_15) + self.layout.ard_g2.setMinimumHeight(self.ui_15) + self.layout.ard_g2.setMaximumHeight(self.ui_15) + self.layout.ard_g3.setMinimumHeight(self.ui_15) + self.layout.ard_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_ard.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_ard.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "HSV"): + self.layout.hsv_l1.setMinimumHeight(self.ui_15) + self.layout.hsv_l1.setMaximumHeight(self.ui_15) + self.layout.hsv_l2.setMinimumHeight(self.ui_15) + self.layout.hsv_l2.setMaximumHeight(self.ui_15) + self.layout.hsv_l3.setMinimumHeight(self.ui_15) + self.layout.hsv_l3.setMaximumHeight(self.ui_15) + self.layout.hsv_r1.setMinimumHeight(self.ui_15) + self.layout.hsv_r1.setMaximumHeight(self.ui_15) + self.layout.hsv_r2.setMinimumHeight(self.ui_15) + self.layout.hsv_r2.setMaximumHeight(self.ui_15) + self.layout.hsv_r3.setMinimumHeight(self.ui_15) + self.layout.hsv_r3.setMaximumHeight(self.ui_15) + self.layout.hsv_g1.setMinimumHeight(self.ui_15) + self.layout.hsv_g1.setMaximumHeight(self.ui_15) + self.layout.hsv_g2.setMinimumHeight(self.ui_15) + self.layout.hsv_g2.setMaximumHeight(self.ui_15) + self.layout.hsv_g3.setMinimumHeight(self.ui_15) + self.layout.hsv_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_hsv.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_hsv.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "HSL"): + self.layout.hsl_l1.setMinimumHeight(self.ui_15) + self.layout.hsl_l1.setMaximumHeight(self.ui_15) + self.layout.hsl_l2.setMinimumHeight(self.ui_15) + self.layout.hsl_l2.setMaximumHeight(self.ui_15) + self.layout.hsl_l3.setMinimumHeight(self.ui_15) + self.layout.hsl_l3.setMaximumHeight(self.ui_15) + self.layout.hsl_r1.setMinimumHeight(self.ui_15) + self.layout.hsl_r1.setMaximumHeight(self.ui_15) + self.layout.hsl_r2.setMinimumHeight(self.ui_15) + self.layout.hsl_r2.setMaximumHeight(self.ui_15) + self.layout.hsl_r3.setMinimumHeight(self.ui_15) + self.layout.hsl_r3.setMaximumHeight(self.ui_15) + self.layout.hsl_g1.setMinimumHeight(self.ui_15) + self.layout.hsl_g1.setMaximumHeight(self.ui_15) + self.layout.hsl_g2.setMinimumHeight(self.ui_15) + self.layout.hsl_g2.setMaximumHeight(self.ui_15) + self.layout.hsl_g3.setMinimumHeight(self.ui_15) + self.layout.hsl_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_hsl.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_hsl.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "HCY"): + self.layout.hcy_l1.setMinimumHeight(self.ui_15) + self.layout.hcy_l1.setMaximumHeight(self.ui_15) + self.layout.hcy_l2.setMinimumHeight(self.ui_15) + self.layout.hcy_l2.setMaximumHeight(self.ui_15) + self.layout.hcy_l3.setMinimumHeight(self.ui_15) + self.layout.hcy_l3.setMaximumHeight(self.ui_15) + self.layout.hcy_r1.setMinimumHeight(self.ui_15) + self.layout.hcy_r1.setMaximumHeight(self.ui_15) + self.layout.hcy_r2.setMinimumHeight(self.ui_15) + self.layout.hcy_r2.setMaximumHeight(self.ui_15) + self.layout.hcy_r3.setMinimumHeight(self.ui_15) + self.layout.hcy_r3.setMaximumHeight(self.ui_15) + self.layout.hcy_g1.setMinimumHeight(self.ui_15) + self.layout.hcy_g1.setMaximumHeight(self.ui_15) + self.layout.hcy_g2.setMinimumHeight(self.ui_15) + self.layout.hcy_g2.setMaximumHeight(self.ui_15) + self.layout.hcy_g3.setMinimumHeight(self.ui_15) + self.layout.hcy_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_hcy.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_hcy.setVerticalSpacing(unit) + + if (self.menu_mix == True and self.menu_mix_index == "XYZ"): + self.layout.xyz_l1.setMinimumHeight(self.ui_15) + self.layout.xyz_l1.setMaximumHeight(self.ui_15) + self.layout.xyz_l2.setMinimumHeight(self.ui_15) + self.layout.xyz_l2.setMaximumHeight(self.ui_15) + self.layout.xyz_l3.setMinimumHeight(self.ui_15) + self.layout.xyz_l3.setMaximumHeight(self.ui_15) + self.layout.xyz_r1.setMinimumHeight(self.ui_15) + self.layout.xyz_r1.setMaximumHeight(self.ui_15) + self.layout.xyz_r2.setMinimumHeight(self.ui_15) + self.layout.xyz_r2.setMaximumHeight(self.ui_15) + self.layout.xyz_r3.setMinimumHeight(self.ui_15) + self.layout.xyz_r3.setMaximumHeight(self.ui_15) + self.layout.xyz_g1.setMinimumHeight(self.ui_15) + self.layout.xyz_g1.setMaximumHeight(self.ui_15) + self.layout.xyz_g2.setMinimumHeight(self.ui_15) + self.layout.xyz_g2.setMaximumHeight(self.ui_15) + self.layout.xyz_g3.setMinimumHeight(self.ui_15) + self.layout.xyz_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_xyz.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_xyz.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "XYY"): + self.layout.xyy_l1.setMinimumHeight(self.ui_15) + self.layout.xyy_l1.setMaximumHeight(self.ui_15) + self.layout.xyy_l2.setMinimumHeight(self.ui_15) + self.layout.xyy_l2.setMaximumHeight(self.ui_15) + self.layout.xyy_l3.setMinimumHeight(self.ui_15) + self.layout.xyy_l3.setMaximumHeight(self.ui_15) + self.layout.xyy_r1.setMinimumHeight(self.ui_15) + self.layout.xyy_r1.setMaximumHeight(self.ui_15) + self.layout.xyy_r2.setMinimumHeight(self.ui_15) + self.layout.xyy_r2.setMaximumHeight(self.ui_15) + self.layout.xyy_r3.setMinimumHeight(self.ui_15) + self.layout.xyy_r3.setMaximumHeight(self.ui_15) + self.layout.xyy_g1.setMinimumHeight(self.ui_15) + self.layout.xyy_g1.setMaximumHeight(self.ui_15) + self.layout.xyy_g2.setMinimumHeight(self.ui_15) + self.layout.xyy_g2.setMaximumHeight(self.ui_15) + self.layout.xyy_g3.setMinimumHeight(self.ui_15) + self.layout.xyy_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_xyy.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_xyy.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "LUV"): + self.layout.luv_l1.setMinimumHeight(self.ui_15) + self.layout.luv_l1.setMaximumHeight(self.ui_15) + self.layout.luv_l2.setMinimumHeight(self.ui_15) + self.layout.luv_l2.setMaximumHeight(self.ui_15) + self.layout.luv_l3.setMinimumHeight(self.ui_15) + self.layout.luv_l3.setMaximumHeight(self.ui_15) + self.layout.luv_r1.setMinimumHeight(self.ui_15) + self.layout.luv_r1.setMaximumHeight(self.ui_15) + self.layout.luv_r2.setMinimumHeight(self.ui_15) + self.layout.luv_r2.setMaximumHeight(self.ui_15) + self.layout.luv_r3.setMinimumHeight(self.ui_15) + self.layout.luv_r3.setMaximumHeight(self.ui_15) + self.layout.luv_g1.setMinimumHeight(self.ui_15) + self.layout.luv_g1.setMaximumHeight(self.ui_15) + self.layout.luv_g2.setMinimumHeight(self.ui_15) + self.layout.luv_g2.setMaximumHeight(self.ui_15) + self.layout.luv_g3.setMinimumHeight(self.ui_15) + self.layout.luv_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_luv.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_luv.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "HLAB"): + self.layout.hlab_l1.setMinimumHeight(self.ui_15) + self.layout.hlab_l1.setMaximumHeight(self.ui_15) + self.layout.hlab_l2.setMinimumHeight(self.ui_15) + self.layout.hlab_l2.setMaximumHeight(self.ui_15) + self.layout.hlab_l3.setMinimumHeight(self.ui_15) + self.layout.hlab_l3.setMaximumHeight(self.ui_15) + self.layout.hlab_r1.setMinimumHeight(self.ui_15) + self.layout.hlab_r1.setMaximumHeight(self.ui_15) + self.layout.hlab_r2.setMinimumHeight(self.ui_15) + self.layout.hlab_r2.setMaximumHeight(self.ui_15) + self.layout.hlab_r3.setMinimumHeight(self.ui_15) + self.layout.hlab_r3.setMaximumHeight(self.ui_15) + self.layout.hlab_g1.setMinimumHeight(self.ui_15) + self.layout.hlab_g1.setMaximumHeight(self.ui_15) + self.layout.hlab_g2.setMinimumHeight(self.ui_15) + self.layout.hlab_g2.setMaximumHeight(self.ui_15) + self.layout.hlab_g3.setMinimumHeight(self.ui_15) + self.layout.hlab_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_hlab.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_hlab.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "LAB"): + self.layout.lab_l1.setMinimumHeight(self.ui_15) + self.layout.lab_l1.setMaximumHeight(self.ui_15) + self.layout.lab_l2.setMinimumHeight(self.ui_15) + self.layout.lab_l2.setMaximumHeight(self.ui_15) + self.layout.lab_l3.setMinimumHeight(self.ui_15) + self.layout.lab_l3.setMaximumHeight(self.ui_15) + self.layout.lab_r1.setMinimumHeight(self.ui_15) + self.layout.lab_r1.setMaximumHeight(self.ui_15) + self.layout.lab_r2.setMinimumHeight(self.ui_15) + self.layout.lab_r2.setMaximumHeight(self.ui_15) + self.layout.lab_r3.setMinimumHeight(self.ui_15) + self.layout.lab_r3.setMaximumHeight(self.ui_15) + self.layout.lab_g1.setMinimumHeight(self.ui_15) + self.layout.lab_g1.setMaximumHeight(self.ui_15) + self.layout.lab_g2.setMinimumHeight(self.ui_15) + self.layout.lab_g2.setMaximumHeight(self.ui_15) + self.layout.lab_g3.setMinimumHeight(self.ui_15) + self.layout.lab_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_lab.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_lab.setVerticalSpacing(unit) + if (self.menu_mix == True and self.menu_mix_index == "LCH"): + self.layout.lch_l1.setMinimumHeight(self.ui_15) + self.layout.lch_l1.setMaximumHeight(self.ui_15) + self.layout.lch_l2.setMinimumHeight(self.ui_15) + self.layout.lch_l2.setMaximumHeight(self.ui_15) + self.layout.lch_l3.setMinimumHeight(self.ui_15) + self.layout.lch_l3.setMaximumHeight(self.ui_15) + self.layout.lch_r1.setMinimumHeight(self.ui_15) + self.layout.lch_r1.setMaximumHeight(self.ui_15) + self.layout.lch_r2.setMinimumHeight(self.ui_15) + self.layout.lch_r2.setMaximumHeight(self.ui_15) + self.layout.lch_r3.setMinimumHeight(self.ui_15) + self.layout.lch_r3.setMaximumHeight(self.ui_15) + self.layout.lch_g1.setMinimumHeight(self.ui_15) + self.layout.lch_g1.setMaximumHeight(self.ui_15) + self.layout.lch_g2.setMinimumHeight(self.ui_15) + self.layout.lch_g2.setMaximumHeight(self.ui_15) + self.layout.lch_g3.setMinimumHeight(self.ui_15) + self.layout.lch_g3.setMaximumHeight(self.ui_15) + self.layout.mixer_lch.setContentsMargins(zero, unit, zero, unit) + self.layout.mixer_lch.setVerticalSpacing(unit) + + self.dialog.mix.setFont(font) + self.menu_update = 5 + self.Mixer_Display() + def MIX_Shrink(self): + # Mix TTS + self.layout.tts_l1.setMinimumHeight(zero) + self.layout.tts_l1.setMaximumHeight(zero) + self.layout.tint.setMinimumHeight(zero) + self.layout.tint.setMaximumHeight(zero) + self.layout.tone.setMinimumHeight(zero) + self.layout.tone.setMaximumHeight(zero) + self.layout.shade.setMinimumHeight(zero) + self.layout.shade.setMaximumHeight(zero) + self.layout.white.setMinimumHeight(zero) + self.layout.white.setMaximumHeight(zero) + self.layout.grey.setMinimumHeight(zero) + self.layout.grey.setMaximumHeight(zero) + self.layout.black.setMinimumHeight(zero) + self.layout.black.setMaximumHeight(zero) + self.layout.tint_tone_shade.setContentsMargins(zero, zero, zero, zero) + self.layout.tint_tone_shade.setVerticalSpacing(zero) + # Mix RGB + self.layout.rgb_l1.setMinimumHeight(zero) + self.layout.rgb_l1.setMaximumHeight(zero) + self.layout.rgb_l2.setMinimumHeight(zero) + self.layout.rgb_l2.setMaximumHeight(zero) + self.layout.rgb_l3.setMinimumHeight(zero) + self.layout.rgb_l3.setMaximumHeight(zero) + self.layout.rgb_r1.setMinimumHeight(zero) + self.layout.rgb_r1.setMaximumHeight(zero) + self.layout.rgb_r2.setMinimumHeight(zero) + self.layout.rgb_r2.setMaximumHeight(zero) + self.layout.rgb_r3.setMinimumHeight(zero) + self.layout.rgb_r3.setMaximumHeight(zero) + self.layout.rgb_g1.setMinimumHeight(zero) + self.layout.rgb_g1.setMaximumHeight(zero) + self.layout.rgb_g2.setMinimumHeight(zero) + self.layout.rgb_g2.setMaximumHeight(zero) + self.layout.rgb_g3.setMinimumHeight(zero) + self.layout.rgb_g3.setMaximumHeight(zero) + self.layout.mixer_rgb.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_rgb.setVerticalSpacing(zero) + # Mix CMYK + self.layout.cmyk_l1.setMinimumHeight(zero) + self.layout.cmyk_l1.setMaximumHeight(zero) + self.layout.cmyk_l2.setMinimumHeight(zero) + self.layout.cmyk_l2.setMaximumHeight(zero) + self.layout.cmyk_l3.setMinimumHeight(zero) + self.layout.cmyk_l3.setMaximumHeight(zero) + self.layout.cmyk_r1.setMinimumHeight(zero) + self.layout.cmyk_r1.setMaximumHeight(zero) + self.layout.cmyk_r2.setMinimumHeight(zero) + self.layout.cmyk_r2.setMaximumHeight(zero) + self.layout.cmyk_r3.setMinimumHeight(zero) + self.layout.cmyk_r3.setMaximumHeight(zero) + self.layout.cmyk_g1.setMinimumHeight(zero) + self.layout.cmyk_g1.setMaximumHeight(zero) + self.layout.cmyk_g2.setMinimumHeight(zero) + self.layout.cmyk_g2.setMaximumHeight(zero) + self.layout.cmyk_g3.setMinimumHeight(zero) + self.layout.cmyk_g3.setMaximumHeight(zero) + self.layout.mixer_cmyk.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_cmyk.setVerticalSpacing(zero) + # Mix RYB + self.layout.ryb_l1.setMinimumHeight(zero) + self.layout.ryb_l1.setMaximumHeight(zero) + self.layout.ryb_l2.setMinimumHeight(zero) + self.layout.ryb_l2.setMaximumHeight(zero) + self.layout.ryb_l3.setMinimumHeight(zero) + self.layout.ryb_l3.setMaximumHeight(zero) + self.layout.ryb_r1.setMinimumHeight(zero) + self.layout.ryb_r1.setMaximumHeight(zero) + self.layout.ryb_r2.setMinimumHeight(zero) + self.layout.ryb_r2.setMaximumHeight(zero) + self.layout.ryb_r3.setMinimumHeight(zero) + self.layout.ryb_r3.setMaximumHeight(zero) + self.layout.ryb_g1.setMinimumHeight(zero) + self.layout.ryb_g1.setMaximumHeight(zero) + self.layout.ryb_g2.setMinimumHeight(zero) + self.layout.ryb_g2.setMaximumHeight(zero) + self.layout.ryb_g3.setMinimumHeight(zero) + self.layout.ryb_g3.setMaximumHeight(zero) + self.layout.mixer_ryb.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_ryb.setVerticalSpacing(zero) + # Mix YUV + self.layout.yuv_l1.setMinimumHeight(zero) + self.layout.yuv_l1.setMaximumHeight(zero) + self.layout.yuv_l2.setMinimumHeight(zero) + self.layout.yuv_l2.setMaximumHeight(zero) + self.layout.yuv_l3.setMinimumHeight(zero) + self.layout.yuv_l3.setMaximumHeight(zero) + self.layout.yuv_r1.setMinimumHeight(zero) + self.layout.yuv_r1.setMaximumHeight(zero) + self.layout.yuv_r2.setMinimumHeight(zero) + self.layout.yuv_r2.setMaximumHeight(zero) + self.layout.yuv_r3.setMinimumHeight(zero) + self.layout.yuv_r3.setMaximumHeight(zero) + self.layout.yuv_g1.setMinimumHeight(zero) + self.layout.yuv_g1.setMaximumHeight(zero) + self.layout.yuv_g2.setMinimumHeight(zero) + self.layout.yuv_g2.setMaximumHeight(zero) + self.layout.yuv_g3.setMinimumHeight(zero) + self.layout.yuv_g3.setMaximumHeight(zero) + self.layout.mixer_yuv.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_yuv.setVerticalSpacing(zero) + + # Mix ARD + self.layout.ard_l1.setMinimumHeight(zero) + self.layout.ard_l1.setMaximumHeight(zero) + self.layout.ard_l2.setMinimumHeight(zero) + self.layout.ard_l2.setMaximumHeight(zero) + self.layout.ard_l3.setMinimumHeight(zero) + self.layout.ard_l3.setMaximumHeight(zero) + self.layout.ard_r1.setMinimumHeight(zero) + self.layout.ard_r1.setMaximumHeight(zero) + self.layout.ard_r2.setMinimumHeight(zero) + self.layout.ard_r2.setMaximumHeight(zero) + self.layout.ard_r3.setMinimumHeight(zero) + self.layout.ard_r3.setMaximumHeight(zero) + self.layout.ard_g1.setMinimumHeight(zero) + self.layout.ard_g1.setMaximumHeight(zero) + self.layout.ard_g2.setMinimumHeight(zero) + self.layout.ard_g2.setMaximumHeight(zero) + self.layout.ard_g3.setMinimumHeight(zero) + self.layout.ard_g3.setMaximumHeight(zero) + self.layout.mixer_ard.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_ard.setVerticalSpacing(zero) + # Mix HSV + self.layout.hsv_l1.setMinimumHeight(zero) + self.layout.hsv_l1.setMaximumHeight(zero) + self.layout.hsv_l2.setMinimumHeight(zero) + self.layout.hsv_l2.setMaximumHeight(zero) + self.layout.hsv_l3.setMinimumHeight(zero) + self.layout.hsv_l3.setMaximumHeight(zero) + self.layout.hsv_r1.setMinimumHeight(zero) + self.layout.hsv_r1.setMaximumHeight(zero) + self.layout.hsv_r2.setMinimumHeight(zero) + self.layout.hsv_r2.setMaximumHeight(zero) + self.layout.hsv_r3.setMinimumHeight(zero) + self.layout.hsv_r3.setMaximumHeight(zero) + self.layout.hsv_g1.setMinimumHeight(zero) + self.layout.hsv_g1.setMaximumHeight(zero) + self.layout.hsv_g2.setMinimumHeight(zero) + self.layout.hsv_g2.setMaximumHeight(zero) + self.layout.hsv_g3.setMinimumHeight(zero) + self.layout.hsv_g3.setMaximumHeight(zero) + self.layout.mixer_hsv.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_hsv.setVerticalSpacing(zero) + # Mix HSL + self.layout.hsl_l1.setMinimumHeight(zero) + self.layout.hsl_l1.setMaximumHeight(zero) + self.layout.hsl_l2.setMinimumHeight(zero) + self.layout.hsl_l2.setMaximumHeight(zero) + self.layout.hsl_l3.setMinimumHeight(zero) + self.layout.hsl_l3.setMaximumHeight(zero) + self.layout.hsl_r1.setMinimumHeight(zero) + self.layout.hsl_r1.setMaximumHeight(zero) + self.layout.hsl_r2.setMinimumHeight(zero) + self.layout.hsl_r2.setMaximumHeight(zero) + self.layout.hsl_r3.setMinimumHeight(zero) + self.layout.hsl_r3.setMaximumHeight(zero) + self.layout.hsl_g1.setMinimumHeight(zero) + self.layout.hsl_g1.setMaximumHeight(zero) + self.layout.hsl_g2.setMinimumHeight(zero) + self.layout.hsl_g2.setMaximumHeight(zero) + self.layout.hsl_g3.setMinimumHeight(zero) + self.layout.hsl_g3.setMaximumHeight(zero) + self.layout.mixer_hsl.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_hsl.setVerticalSpacing(zero) + # Mix HCY + self.layout.hcy_l1.setMinimumHeight(zero) + self.layout.hcy_l1.setMaximumHeight(zero) + self.layout.hcy_l2.setMinimumHeight(zero) + self.layout.hcy_l2.setMaximumHeight(zero) + self.layout.hcy_l3.setMinimumHeight(zero) + self.layout.hcy_l3.setMaximumHeight(zero) + self.layout.hcy_r1.setMinimumHeight(zero) + self.layout.hcy_r1.setMaximumHeight(zero) + self.layout.hcy_r2.setMinimumHeight(zero) + self.layout.hcy_r2.setMaximumHeight(zero) + self.layout.hcy_r3.setMinimumHeight(zero) + self.layout.hcy_r3.setMaximumHeight(zero) + self.layout.hcy_g1.setMinimumHeight(zero) + self.layout.hcy_g1.setMaximumHeight(zero) + self.layout.hcy_g2.setMinimumHeight(zero) + self.layout.hcy_g2.setMaximumHeight(zero) + self.layout.hcy_g3.setMinimumHeight(zero) + self.layout.hcy_g3.setMaximumHeight(zero) + self.layout.mixer_hcy.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_hcy.setVerticalSpacing(zero) + + # Mix XYZ + self.layout.xyz_l1.setMinimumHeight(zero) + self.layout.xyz_l1.setMaximumHeight(zero) + self.layout.xyz_l2.setMinimumHeight(zero) + self.layout.xyz_l2.setMaximumHeight(zero) + self.layout.xyz_l3.setMinimumHeight(zero) + self.layout.xyz_l3.setMaximumHeight(zero) + self.layout.xyz_r1.setMinimumHeight(zero) + self.layout.xyz_r1.setMaximumHeight(zero) + self.layout.xyz_r2.setMinimumHeight(zero) + self.layout.xyz_r2.setMaximumHeight(zero) + self.layout.xyz_r3.setMinimumHeight(zero) + self.layout.xyz_r3.setMaximumHeight(zero) + self.layout.xyz_g1.setMinimumHeight(zero) + self.layout.xyz_g1.setMaximumHeight(zero) + self.layout.xyz_g2.setMinimumHeight(zero) + self.layout.xyz_g2.setMaximumHeight(zero) + self.layout.xyz_g3.setMinimumHeight(zero) + self.layout.xyz_g3.setMaximumHeight(zero) + self.layout.mixer_xyz.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_xyz.setVerticalSpacing(zero) + # Mix XYY + self.layout.xyy_l1.setMinimumHeight(zero) + self.layout.xyy_l1.setMaximumHeight(zero) + self.layout.xyy_l2.setMinimumHeight(zero) + self.layout.xyy_l2.setMaximumHeight(zero) + self.layout.xyy_l3.setMinimumHeight(zero) + self.layout.xyy_l3.setMaximumHeight(zero) + self.layout.xyy_r1.setMinimumHeight(zero) + self.layout.xyy_r1.setMaximumHeight(zero) + self.layout.xyy_r2.setMinimumHeight(zero) + self.layout.xyy_r2.setMaximumHeight(zero) + self.layout.xyy_r3.setMinimumHeight(zero) + self.layout.xyy_r3.setMaximumHeight(zero) + self.layout.xyy_g1.setMinimumHeight(zero) + self.layout.xyy_g1.setMaximumHeight(zero) + self.layout.xyy_g2.setMinimumHeight(zero) + self.layout.xyy_g2.setMaximumHeight(zero) + self.layout.xyy_g3.setMinimumHeight(zero) + self.layout.xyy_g3.setMaximumHeight(zero) + self.layout.mixer_xyy.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_xyy.setVerticalSpacing(zero) + # Mix LUV + self.layout.luv_l1.setMinimumHeight(zero) + self.layout.luv_l1.setMaximumHeight(zero) + self.layout.luv_l2.setMinimumHeight(zero) + self.layout.luv_l2.setMaximumHeight(zero) + self.layout.luv_l3.setMinimumHeight(zero) + self.layout.luv_l3.setMaximumHeight(zero) + self.layout.luv_r1.setMinimumHeight(zero) + self.layout.luv_r1.setMaximumHeight(zero) + self.layout.luv_r2.setMinimumHeight(zero) + self.layout.luv_r2.setMaximumHeight(zero) + self.layout.luv_r3.setMinimumHeight(zero) + self.layout.luv_r3.setMaximumHeight(zero) + self.layout.luv_g1.setMinimumHeight(zero) + self.layout.luv_g1.setMaximumHeight(zero) + self.layout.luv_g2.setMinimumHeight(zero) + self.layout.luv_g2.setMaximumHeight(zero) + self.layout.luv_g3.setMinimumHeight(zero) + self.layout.luv_g3.setMaximumHeight(zero) + self.layout.mixer_luv.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_luv.setVerticalSpacing(zero) + # Mix HLAB + self.layout.hlab_l1.setMinimumHeight(zero) + self.layout.hlab_l1.setMaximumHeight(zero) + self.layout.hlab_l2.setMinimumHeight(zero) + self.layout.hlab_l2.setMaximumHeight(zero) + self.layout.hlab_l3.setMinimumHeight(zero) + self.layout.hlab_l3.setMaximumHeight(zero) + self.layout.hlab_r1.setMinimumHeight(zero) + self.layout.hlab_r1.setMaximumHeight(zero) + self.layout.hlab_r2.setMinimumHeight(zero) + self.layout.hlab_r2.setMaximumHeight(zero) + self.layout.hlab_r3.setMinimumHeight(zero) + self.layout.hlab_r3.setMaximumHeight(zero) + self.layout.hlab_g1.setMinimumHeight(zero) + self.layout.hlab_g1.setMaximumHeight(zero) + self.layout.hlab_g2.setMinimumHeight(zero) + self.layout.hlab_g2.setMaximumHeight(zero) + self.layout.hlab_g3.setMinimumHeight(zero) + self.layout.hlab_g3.setMaximumHeight(zero) + self.layout.mixer_hlab.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_hlab.setVerticalSpacing(zero) + # Mix LAB + self.layout.lab_l1.setMinimumHeight(zero) + self.layout.lab_l1.setMaximumHeight(zero) + self.layout.lab_l2.setMinimumHeight(zero) + self.layout.lab_l2.setMaximumHeight(zero) + self.layout.lab_l3.setMinimumHeight(zero) + self.layout.lab_l3.setMaximumHeight(zero) + self.layout.lab_r1.setMinimumHeight(zero) + self.layout.lab_r1.setMaximumHeight(zero) + self.layout.lab_r2.setMinimumHeight(zero) + self.layout.lab_r2.setMaximumHeight(zero) + self.layout.lab_r3.setMinimumHeight(zero) + self.layout.lab_r3.setMaximumHeight(zero) + self.layout.lab_g1.setMinimumHeight(zero) + self.layout.lab_g1.setMaximumHeight(zero) + self.layout.lab_g2.setMinimumHeight(zero) + self.layout.lab_g2.setMaximumHeight(zero) + self.layout.lab_g3.setMinimumHeight(zero) + self.layout.lab_g3.setMaximumHeight(zero) + self.layout.mixer_lab.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_lab.setVerticalSpacing(zero) + # Mix LCH + self.layout.lch_l1.setMinimumHeight(zero) + self.layout.lch_l1.setMaximumHeight(zero) + self.layout.lch_l2.setMinimumHeight(zero) + self.layout.lch_l2.setMaximumHeight(zero) + self.layout.lch_l3.setMinimumHeight(zero) + self.layout.lch_l3.setMaximumHeight(zero) + self.layout.lch_r1.setMinimumHeight(zero) + self.layout.lch_r1.setMaximumHeight(zero) + self.layout.lch_r2.setMinimumHeight(zero) + self.layout.lch_r2.setMaximumHeight(zero) + self.layout.lch_r3.setMinimumHeight(zero) + self.layout.lch_r3.setMaximumHeight(zero) + self.layout.lch_g1.setMinimumHeight(zero) + self.layout.lch_g1.setMaximumHeight(zero) + self.layout.lch_g2.setMinimumHeight(zero) + self.layout.lch_g2.setMaximumHeight(zero) + self.layout.lch_g3.setMinimumHeight(zero) + self.layout.lch_g3.setMaximumHeight(zero) + self.layout.mixer_lch.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_lch.setVerticalSpacing(zero) + + # History + def Menu_HISTORY(self): + font = self.dialog.his.font() + if self.dialog.his.isChecked(): + font.setBold(True) + self.dialog.his.setText("[HISTORY]") + self.layout.color_history.setMinimumHeight(self.ui_15) + self.layout.color_history.setMaximumHeight(self.ui_30) + self.layout.color_history_layout.setContentsMargins(zero, unit, zero, unit) + else: + font.setBold(False) + self.dialog.his.setText("HISTORY") + self.layout.color_history.setMinimumHeight(zero) + self.layout.color_history.setMaximumHeight(zero) + self.layout.color_history_layout.setContentsMargins(zero, zero, zero, zero) + self.dialog.his.setFont(font) + self.menu_update = 5 + try: + self.Pigment_Display() + except: + pass + + # Options Singular + def Menu_Luminosity(self): + luminosity = self.dialog.luminosity.currentText() + if luminosity == "ITU-R BT.601": + # Reference + self.luminosity = "601" + # Luma Coefficients + self.luma_r = 0.299 + self.luma_b = 0.114 + self.luma_g = 1 - self.luma_r - self.luma_b # 0.587 + self.luma_pr = 1.402 + self.luma_pb = 1.772 + # Update + self.aaa_1_slider.Update(self.aaa_1, self.channel_width) + self.aaa_1_slider.update() + if luminosity == "ITU-R BT.709": + # Reference + self.luminosity = "709" + # Luma Coefficients + self.luma_r = 0.2126 + self.luma_b = 0.0722 + self.luma_g = 1 - self.luma_r - self.luma_b # 0.7152 + self.luma_pr = 1.5748 + self.luma_pb = 1.8556 + # Update + self.aaa_1_slider.Update(self.aaa_1, self.channel_width) + self.aaa_1_slider.update() + if luminosity == "ITU-R BT.2020": + # Reference + self.luminosity = "2020" + # Luma Coefficients + self.luma_r = 0.2627 + self.luma_b = 0.0593 + self.luma_g = 1 - self.luma_r - self.luma_b # 0.678 + self.luma_pr = 0.4969 + self.luma_pb = 0.7910 + # Update + self.aaa_1_slider.Update(self.aaa_1, self.channel_width) + self.aaa_1_slider.update() + def Menu_XYZ_Conversion(self): + # from http://www.brucelindbloom.com/ + matrix = self.dialog.xyz_matrix.currentText() + iluma = self.dialog.xyz_illuminant.currentText() + # Conversion Matrix + if matrix == "sRGB": + if iluma == "D50": # i=0 + self.m_rgb_xyz = [ + [0.4360747, 0.3850649, 0.1430804], + [0.2225045, 0.7168786, 0.0606169], + [0.0139322, 0.0971045, 0.7141733] + ] + self.m_xyz_rgb = [ + [ 3.1338561, -1.6168667, -0.4906146], + [-0.9787684, 1.9161415, 0.0334540], + [ 0.0719453, -0.2289914, 1.4052427] + ] + if iluma == "D65": # i=1 + self.m_rgb_xyz = [ + [0.4124564, 0.3575761, 0.1804375], + [0.2126729, 0.7151522, 0.0721750], + [0.0193339, 0.1191920, 0.9503041] + ] + self.m_xyz_rgb = [ + [ 3.2404542, -1.5371385, -0.4985314], + [-0.9692660, 1.8760108, 0.0415560], + [ 0.0556434, -0.2040259, 1.0572252] + ] + + if matrix == "Adobe RGB": + if iluma == "D50": # i=2 + self.m_rgb_xyz = [ + [0.6097559, 0.2052401, 0.1492240], + [0.3111242, 0.6256560, 0.0632197], + [0.0194811, 0.0608902, 0.7448387] + ] + self.m_xyz_rgb = [ + [ 1.9624274, -0.6105343, -0.3413404], + [-0.9787684, 1.9161415, 0.0334540], + [ 0.0286869, -0.1406752, 1.3487655] + ] + if iluma == "D65": # i=3 + self.m_rgb_xyz = [ + [ 0.5767309, 0.1855540, 0.1881852], + [ 0.2973769, 0.6273491, 0.0752741], + [ 0.0270343, 0.0706872, 0.9911085] + ] + self.m_xyz_rgb = [ + [ 2.0413690, -0.5649464, -0.3446944], + [-0.9692660, 1.8760108, 0.0415560], + [ 0.0134474, -0.1183897, 1.0154096] + ] + if matrix == "Apple RGB": + if iluma == "D50": + self.m_rgb_xyz = [ + [0.4755678, 0.3396722, 0.1489800], + [0.2551812, 0.6725693, 0.0722496], + [0.0184697, 0.1133771, 0.6933632] + ] + self.m_xyz_rgb = [ + [ 2.8510695, -1.3605261, -0.4708281], + [-1.0927680, 2.0348871, 0.0227598], + [ 0.1027403, -0.2964984, 1.4510659] + ] + if iluma == "D65": + self.m_rgb_xyz = [ + [0.4497288, 0.3162486, 0.1844926], + [0.2446525, 0.6720283, 0.0833192], + [0.0251848, 0.1411824, 0.9224628] + ] + self.m_xyz_rgb = [ + [ 2.9515373, -1.2894116, -0.4738445], + [-1.0851093, 1.9908566, 0.0372026], + [ 0.0854934, -0.2694964, 1.0912975] + ] + if matrix == "Best RGB": + if iluma == "D50": + self.m_rgb_xyz = [ + [0.6326696, 0.2045558, 0.1269946], + [0.2284569, 0.7373523, 0.0341908], + [0.0000000, 0.0095142, 0.8156958] + ] + self.m_xyz_rgb = [ + [ 1.7552599, -0.4836786, -0.2530000], + [-0.5441336, 1.5068789, 0.0215528], + [ 0.0063467, -0.0175761, 1.2256959] + ] + else: + self.dialog.xyz_illuminant.setCurrentText("D50") + if matrix == "Beta RGB": + if iluma == "D50": + self.m_rgb_xyz = [ + [ 0.6712537, 0.1745834, 0.1183829], + [ 0.3032726, 0.6637861, 0.0329413], + [ 0.0000000, 0.0407010, 0.7845090] + ] + self.m_xyz_rgb = [ + [ 1.6832270, -0.4282363, -0.2360185], + [-0.7710229, 1.7065571, 0.0446900], + [ 0.0400013, -0.0885376, 1.2723640] + ] + else: + self.dialog.xyz_illuminant.setCurrentText("D50") + if matrix == "Bruce RGB": + if iluma == "D50": + self.m_rgb_xyz = [ + [ 0.4941816, 0.3204834, 0.1495550], + [ 0.2521531, 0.6844869, 0.0633600], + [ 0.0157886, 0.0629304, 0.7464909] + ] + self.m_xyz_rgb = [ + [ 2.6502856, -1.2014485, -0.4289936], + [-0.9787684, 1.9161415, 0.0334540], + [ 0.0264570, -0.1361227, 1.3458542] + ] + if iluma == "D65": + self.m_rgb_xyz = [ + [ 0.4674162, 0.2944512, 0.1886026], + [ 0.2410115, 0.6835475, 0.0754410], + [ 0.0219101, 0.0736128, 0.9933071] + ] + self.m_xyz_rgb = [ + [ 2.7454669, -1.1358136, -0.4350269], + [-0.9692660, 1.8760108, 0.0415560], + [ 0.0112723, -0.1139754, 1.0132541] + ] + # CIE RGB + if matrix == "ColorMatch RGB": + if iluma == "D50": + self.m_rgb_xyz = [ + [ 0.5093439, 0.3209071, 0.1339691], + [ 0.2748840, 0.6581315, 0.0669845], + [ 0.0242545, 0.1087821, 0.6921735] + ] + self.m_xyz_rgb = [ + [ 2.6422874, -1.2234270, -0.3930143], + [-1.1119763, 2.0590183, 0.0159614], + [ 0.0821699, -0.2807254, 1.4559877] + ] + else: + self.dialog.xyz_illuminant.setCurrentText("D50") + if matrix == "Don RGB 4": + if iluma == "D50": + self.m_rgb_xyz = [ + [ 0.6457711, 0.1933511, 0.1250978], + [ 0.2783496, 0.6879702, 0.0336802], + [ 0.0037113, 0.0179861, 0.8035125], + ] + self.m_xyz_rgb = [ + [ 1.7603902, -0.4881198, -0.2536126], + [-0.7126288, 1.6527432, 0.0416715], + [ 0.0078207, -0.0347411, 1.2447743], + ] + else: + self.dialog.xyz_illuminant.setCurrentText("D50") + if matrix == "ECI RGB": + if iluma == "D50": + self.m_rgb_xyz = [ + [ 0.6502043, 0.1780774, 0.1359384], + [ 0.3202499, 0.6020711, 0.0776791], + [ 0.0000000, 0.0678390, 0.7573710] + ] + self.m_xyz_rgb = [ + [ 1.7827618, -0.4969847, -0.2690101], + [-0.9593623, 1.9477962, -0.0275807], + [ 0.0859317, -0.1744674, 1.3228273] + ] + else: + self.dialog.xyz_illuminant.setCurrentText("D50") + if matrix == "Ekta Space PS5": + if iluma == "D50": + self.m_rgb_xyz = [ + [ 0.5938914, 0.2729801, 0.0973485], + [ 0.2606286, 0.7349465, 0.0044249], + [ 0.0000000, 0.0419969, 0.7832131] + ] + self.m_xyz_rgb = [ + [ 2.0043819, -0.7304844, -0.2450052], + [-0.7110285, 1.6202126, 0.0792227], + [ 0.0381263, -0.0868780, 1.2725438] + ] + else: + self.dialog.xyz_illuminant.setCurrentText("D50") + # NTSC RGB + if matrix == "PAL/SECAM RGB": + if iluma == "D50": + self.m_rgb_xyz = [ + [ 0.4552773, 0.3675500, 0.1413926], + [ 0.2323025, 0.7077956, 0.0599019], + [ 0.0145457, 0.1049154, 0.7057489] + ] + self.m_xyz_rgb = [ + [ 2.9603944, -1.4678519, -0.4685105], + [-0.9787684, 1.9161415, 0.0334540], + [ 0.0844874, -0.2545973, 1.4216174] + ] + if iluma == "D65": + self.m_rgb_xyz = [ + [ 0.4306190, 0.3415419, 0.1783091], + [ 0.2220379, 0.7066384, 0.0713236], + [ 0.0201853, 0.1295504, 0.9390944] + ] + self.m_xyz_rgb = [ + [ 3.0628971, -1.3931791, -0.4757517], + [-0.9692660, 1.8760108, 0.0415560], + [ 0.0678775, -0.2288548, 1.0693490] + ] + if matrix == "ProPhoto RGB": + if iluma == "D50": + self.m_rgb_xyz = [ + [0.7976749, 0.1351917, 0.0313534], + [0.2880402, 0.7118741, 0.0000857], + [0.0000000, 0.0000000, 0.8252100] + ] + self.m_xyz_rgb = [ + [ 1.3459433, -0.2556075, -0.0511118], + [-0.5445989, 1.5081673, 0.0205351], + [ 0.0000000, 0.0000000, 1.2118128] + ] + else: + self.dialog.xyz_illuminant.setCurrentText("D50") + if matrix == "SMPTE-C RGB": + if iluma == "D50": + self.m_rgb_xyz = [ + [ 0.4163290, 0.3931464, 0.1547446], + [ 0.2216999, 0.7032549, 0.0750452], + [ 0.0136576, 0.0913604, 0.7201920] + ] + self.m_xyz_rgb = [ + [ 3.3921940, -1.8264027, -0.5385522], + [-1.0770996, 2.0213975, 0.0207989], + [ 0.0723073, -0.2217902, 1.3960932] + ] + if iluma == "D65": + self.m_rgb_xyz = [ + [ 0.3935891, 0.3652497, 0.1916313], + [ 0.2124132, 0.7010437, 0.0865432], + [ 0.0187423, 0.1119313, 0.9581563] + ] + self.m_xyz_rgb = [ + [ 3.5053960, -1.7394894, -0.5439640], + [-1.0690722, 1.9778245, 0.0351722], + [ 0.0563200, -0.1970226, 1.0502026] + ] + if matrix == "Wide Gamut RGB": + if iluma == "D50": + self.m_rgb_xyz = [ + [ 0.7161046, 0.1009296, 0.1471858], + [ 0.2581874, 0.7249378, 0.0168748], + [ 0.0000000, 0.0517813, 0.7734287] + ] + self.m_xyz_rgb = [ + [ 1.4628067, -0.1840623, -0.2743606], + [-0.5217933, 1.4472381, 0.0677227], + [ 0.0349342, -0.0968930, 1.2884099] + ] + else: + self.dialog.xyz_illuminant.setCurrentText("D50") + + # Illuminants + if iluma == "D50": + self.ref_x = 0.96422 + self.ref_y = 1.00 + self.ref_z = 0.82521 + if iluma == "D65": + self.ref_x = 0.95047 + self.ref_y = 1.00 + self.ref_z = 1.08883 + self.update() + def Wheel_Space(self): + self.harmony_space = self.dialog.wheel_space.currentText() # Text + self.Harmony_Refresh() + self.Pigment_Display() + self.Ratio() + # Performance + def Menu_Release(self): + self.performance_release = self.dialog.release.isChecked() + def Menu_Inaccurate(self): + self.performance_inaccurate = self.dialog.inaccurate.isChecked() + self.Pigment_Sync() + self.Pigment_Display() + self.Mixer_Display() + + # Dockers + def Menu_FILL(self): + if ((self.canvas() is not None) and (self.canvas().view() is not None)): + self.fill = self.layout.fill.isChecked() + self.node = str(Krita.instance().activeDocument().activeNode().name()) + if self.fill == True: + Krita.instance().activeDocument().activeNode().setAlphaLocked(True) + self.layout.fill.setIcon(Krita.instance().icon('fillLayer')) + else: + Krita.instance().activeDocument().activeNode().setAlphaLocked(False) + self.layout.fill.setIcon(Krita.instance().icon('folder-documents')) + else: + self.node = None + self.layout.fill.setChecked(False) + self.layout.fill.setIcon(Krita.instance().icon('folder-documents')) + def Menu_SELECTION(self): + if self.layout.selection.isChecked() == True: + self.layout.selection.setIcon(Krita.instance().icon('local-selection-active')) + self.Selection_APPLY() + else: + self.layout.selection.setIcon(Krita.instance().icon('local-selection-inactive')) + Krita.instance().action('deselect').trigger() + def Menu_DOCKER(self): + self.dialog.show() + def Menu_COPYRIGHT(self): + self.copyright.show() + + # Start UP UI Shrink + def Menu_Shrink(self): + self.Menu_Display_Value() + self.Menu_Display_Hex() + self.Menu_Height_Zero() + self.Menu_CHANNEL() + + self.Menu_AAA() + self.Menu_RGB() + self.Menu_CMY() + self.Menu_CMYK() + self.Menu_RYB() + self.Menu_YUV() + self.Menu_KKK() + + self.Menu_ARD() + self.Menu_HSV() + self.Menu_HSL() + self.Menu_HCY() + self.Menu_SEL() + + self.Menu_XYZ() + self.Menu_XYY() + self.Menu_LUV() + self.Menu_HLAB() + self.Menu_LAB() + self.Menu_LCH() + def Menu_Height_Zero(self): + # HAR + self.layout.color_1.setMinimumHeight(self.ui_30) + self.layout.color_1.setMaximumHeight(self.ui_30) + self.layout.color_2.setMinimumHeight(self.ui_30) + self.layout.color_2.setMaximumHeight(self.ui_30) + self.layout.color_3.setMinimumHeight(self.ui_30) + self.layout.color_3.setMaximumHeight(self.ui_30) + self.layout.harmony_1.setMinimumHeight(zero) + self.layout.harmony_1.setMaximumHeight(zero) + self.layout.harmony_2.setMinimumHeight(zero) + self.layout.harmony_2.setMaximumHeight(zero) + self.layout.harmony_3.setMinimumHeight(zero) + self.layout.harmony_3.setMaximumHeight(zero) + self.layout.harmony_4.setMinimumHeight(zero) + self.layout.harmony_4.setMaximumHeight(zero) + self.layout.harmony_5.setMinimumHeight(zero) + self.layout.harmony_5.setMaximumHeight(zero) + self.layout.harmony_0.setMinimumHeight(zero) + self.layout.harmony_0.setMaximumHeight(zero) + self.layout.color_harmonys.setContentsMargins(zero, zero, zero, zero) + # PANEL + self.layout.panel_fgc.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_uvd.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_ard.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_hsv.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_hsl.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_hcy.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_hue.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.dialog.hue_secondary.setEnabled(False) + # DOT + self.layout.panel_dot_mix.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.dot_1.setMinimumHeight(zero) + self.layout.dot_1.setMaximumHeight(zero) + self.layout.dot_2.setMinimumHeight(zero) + self.layout.dot_2.setMaximumHeight(zero) + self.layout.dot_3.setMinimumHeight(zero) + self.layout.dot_3.setMaximumHeight(zero) + self.layout.dot_4.setMinimumHeight(zero) + self.layout.dot_4.setMaximumHeight(zero) + self.layout.dot_swap.setMinimumHeight(zero) + self.layout.dot_swap.setMaximumHeight(zero) + self.layout.panel_dot_colors.setContentsMargins(zero, zero, zero, zero) + self.layout.panel_dot_colors.setSpacing(0) + # OBJECT + self.layout.panel_obj_display.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + self.layout.panel_obj_colors.setContentsMargins(zero, zero, zero, zero) + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.layout.b1_live.setMinimumHeight(zero) + self.layout.b1_live.setMaximumHeight(zero) + self.layout.b1_color.setMinimumHeight(zero) + self.layout.b1_color.setMaximumHeight(zero) + self.layout.b1_alpha.setMinimumHeight(zero) + self.layout.b1_alpha.setMaximumHeight(zero) + self.layout.b2_live.setMinimumHeight(zero) + self.layout.b2_live.setMaximumHeight(zero) + self.layout.b2_color.setMinimumHeight(zero) + self.layout.b2_color.setMaximumHeight(zero) + self.layout.b2_alpha.setMinimumHeight(zero) + self.layout.b2_alpha.setMaximumHeight(zero) + self.layout.b3_live.setMinimumHeight(zero) + self.layout.b3_live.setMaximumHeight(zero) + self.layout.b3_color.setMinimumHeight(zero) + self.layout.b3_color.setMaximumHeight(zero) + self.layout.b3_alpha.setMinimumHeight(zero) + self.layout.b3_alpha.setMaximumHeight(zero) + self.layout.d1_live.setMinimumHeight(zero) + self.layout.d1_live.setMaximumHeight(zero) + self.layout.d1_color.setMinimumHeight(zero) + self.layout.d1_color.setMaximumHeight(zero) + self.layout.d1_alpha.setMinimumHeight(zero) + self.layout.d1_alpha.setMaximumHeight(zero) + self.layout.d2_live.setMinimumHeight(zero) + self.layout.d2_live.setMaximumHeight(zero) + self.layout.d2_color.setMinimumHeight(zero) + self.layout.d2_color.setMaximumHeight(zero) + self.layout.d2_alpha.setMinimumHeight(zero) + self.layout.d2_alpha.setMaximumHeight(zero) + self.layout.d3_live.setMinimumHeight(zero) + self.layout.d3_live.setMaximumHeight(zero) + self.layout.d3_color.setMinimumHeight(zero) + self.layout.d3_color.setMaximumHeight(zero) + self.layout.d3_alpha.setMinimumHeight(zero) + self.layout.d3_alpha.setMaximumHeight(zero) + self.layout.d4_live.setMinimumHeight(zero) + self.layout.d4_live.setMaximumHeight(zero) + self.layout.d4_color.setMinimumHeight(zero) + self.layout.d4_color.setMaximumHeight(zero) + self.layout.d4_alpha.setMinimumHeight(zero) + self.layout.d4_alpha.setMaximumHeight(zero) + self.layout.d5_live.setMinimumHeight(zero) + self.layout.d5_live.setMaximumHeight(zero) + self.layout.d5_color.setMinimumHeight(zero) + self.layout.d5_color.setMaximumHeight(zero) + self.layout.d5_alpha.setMinimumHeight(zero) + self.layout.d5_alpha.setMaximumHeight(zero) + self.layout.d6_live.setMinimumHeight(zero) + self.layout.d6_live.setMaximumHeight(zero) + self.layout.d6_color.setMinimumHeight(zero) + self.layout.d6_color.setMaximumHeight(zero) + self.layout.d6_alpha.setMinimumHeight(zero) + self.layout.d6_alpha.setMaximumHeight(zero) + self.layout.f1_live.setMinimumHeight(zero) + self.layout.f1_live.setMaximumHeight(zero) + self.layout.f1_color.setMinimumHeight(zero) + self.layout.f1_color.setMaximumHeight(zero) + self.layout.f1_alpha.setMinimumHeight(zero) + self.layout.f1_alpha.setMaximumHeight(zero) + self.layout.f2_live.setMinimumHeight(zero) + self.layout.f2_live.setMaximumHeight(zero) + self.layout.f2_color.setMinimumHeight(zero) + self.layout.f2_color.setMaximumHeight(zero) + self.layout.f2_alpha.setMinimumHeight(zero) + self.layout.f2_alpha.setMaximumHeight(zero) + self.layout.f3_live.setMinimumHeight(zero) + self.layout.f3_live.setMaximumHeight(zero) + self.layout.f3_color.setMinimumHeight(zero) + self.layout.f3_color.setMaximumHeight(zero) + self.layout.f3_alpha.setMinimumHeight(zero) + self.layout.f3_alpha.setMaximumHeight(zero) + # IMG + self.layout.panel_img.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) + # COR + self.layout.cor_00.setMinimumHeight(zero) + self.layout.cor_00.setMaximumHeight(zero) + self.layout.cor_01.setMinimumHeight(zero) + self.layout.cor_01.setMaximumHeight(zero) + self.layout.cor_02.setMinimumHeight(zero) + self.layout.cor_02.setMaximumHeight(zero) + self.layout.cor_03.setMinimumHeight(zero) + self.layout.cor_03.setMaximumHeight(zero) + self.layout.cor_04.setMinimumHeight(zero) + self.layout.cor_04.setMaximumHeight(zero) + self.layout.cor_05.setMinimumHeight(zero) + self.layout.cor_05.setMaximumHeight(zero) + self.layout.cor_06.setMinimumHeight(zero) + self.layout.cor_06.setMaximumHeight(zero) + self.layout.cor_07.setMinimumHeight(zero) + self.layout.cor_07.setMaximumHeight(zero) + self.layout.cor_08.setMinimumHeight(zero) + self.layout.cor_08.setMaximumHeight(zero) + self.layout.cor_09.setMinimumHeight(zero) + self.layout.cor_09.setMaximumHeight(zero) + self.layout.cor_10.setMinimumHeight(zero) + self.layout.cor_10.setMaximumHeight(zero) + self.layout.cores.setContentsMargins(zero, zero, zero, zero) + # TTS + self.layout.tts_l1.setMinimumHeight(zero) + self.layout.tts_l1.setMaximumHeight(zero) + self.layout.tint.setMinimumHeight(zero) + self.layout.tint.setMaximumHeight(zero) + self.layout.tone.setMinimumHeight(zero) + self.layout.tone.setMaximumHeight(zero) + self.layout.shade.setMinimumHeight(zero) + self.layout.shade.setMaximumHeight(zero) + self.layout.white.setMinimumHeight(zero) + self.layout.white.setMaximumHeight(zero) + self.layout.grey.setMinimumHeight(zero) + self.layout.grey.setMaximumHeight(zero) + self.layout.black.setMinimumHeight(zero) + self.layout.black.setMaximumHeight(zero) + self.layout.tint_tone_shade.setContentsMargins(zero, zero, zero, zero) + self.layout.tint_tone_shade.setVerticalSpacing(zero) + # Mix RGB + self.layout.rgb_l1.setMinimumHeight(zero) + self.layout.rgb_l1.setMaximumHeight(zero) + self.layout.rgb_l2.setMinimumHeight(zero) + self.layout.rgb_l2.setMaximumHeight(zero) + self.layout.rgb_l3.setMinimumHeight(zero) + self.layout.rgb_l3.setMaximumHeight(zero) + self.layout.rgb_r1.setMinimumHeight(zero) + self.layout.rgb_r1.setMaximumHeight(zero) + self.layout.rgb_r2.setMinimumHeight(zero) + self.layout.rgb_r2.setMaximumHeight(zero) + self.layout.rgb_r3.setMinimumHeight(zero) + self.layout.rgb_r3.setMaximumHeight(zero) + self.layout.rgb_g1.setMinimumHeight(zero) + self.layout.rgb_g1.setMaximumHeight(zero) + self.layout.rgb_g2.setMinimumHeight(zero) + self.layout.rgb_g2.setMaximumHeight(zero) + self.layout.rgb_g3.setMinimumHeight(zero) + self.layout.rgb_g3.setMaximumHeight(zero) + self.layout.mixer_rgb.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_rgb.setVerticalSpacing(zero) + # Mix CMYK + self.layout.cmyk_l1.setMinimumHeight(zero) + self.layout.cmyk_l1.setMaximumHeight(zero) + self.layout.cmyk_l2.setMinimumHeight(zero) + self.layout.cmyk_l2.setMaximumHeight(zero) + self.layout.cmyk_l3.setMinimumHeight(zero) + self.layout.cmyk_l3.setMaximumHeight(zero) + self.layout.cmyk_r1.setMinimumHeight(zero) + self.layout.cmyk_r1.setMaximumHeight(zero) + self.layout.cmyk_r2.setMinimumHeight(zero) + self.layout.cmyk_r2.setMaximumHeight(zero) + self.layout.cmyk_r3.setMinimumHeight(zero) + self.layout.cmyk_r3.setMaximumHeight(zero) + self.layout.cmyk_g1.setMinimumHeight(zero) + self.layout.cmyk_g1.setMaximumHeight(zero) + self.layout.cmyk_g2.setMinimumHeight(zero) + self.layout.cmyk_g2.setMaximumHeight(zero) + self.layout.cmyk_g3.setMinimumHeight(zero) + self.layout.cmyk_g3.setMaximumHeight(zero) + self.layout.mixer_cmyk.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_cmyk.setVerticalSpacing(zero) + # Mix RYB + self.layout.ryb_l1.setMinimumHeight(zero) + self.layout.ryb_l1.setMaximumHeight(zero) + self.layout.ryb_l2.setMinimumHeight(zero) + self.layout.ryb_l2.setMaximumHeight(zero) + self.layout.ryb_l3.setMinimumHeight(zero) + self.layout.ryb_l3.setMaximumHeight(zero) + self.layout.ryb_r1.setMinimumHeight(zero) + self.layout.ryb_r1.setMaximumHeight(zero) + self.layout.ryb_r2.setMinimumHeight(zero) + self.layout.ryb_r2.setMaximumHeight(zero) + self.layout.ryb_r3.setMinimumHeight(zero) + self.layout.ryb_r3.setMaximumHeight(zero) + self.layout.ryb_g1.setMinimumHeight(zero) + self.layout.ryb_g1.setMaximumHeight(zero) + self.layout.ryb_g2.setMinimumHeight(zero) + self.layout.ryb_g2.setMaximumHeight(zero) + self.layout.ryb_g3.setMinimumHeight(zero) + self.layout.ryb_g3.setMaximumHeight(zero) + self.layout.mixer_ryb.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_ryb.setVerticalSpacing(zero) + # Mix YUV + self.layout.yuv_l1.setMinimumHeight(zero) + self.layout.yuv_l1.setMaximumHeight(zero) + self.layout.yuv_l2.setMinimumHeight(zero) + self.layout.yuv_l2.setMaximumHeight(zero) + self.layout.yuv_l3.setMinimumHeight(zero) + self.layout.yuv_l3.setMaximumHeight(zero) + self.layout.yuv_r1.setMinimumHeight(zero) + self.layout.yuv_r1.setMaximumHeight(zero) + self.layout.yuv_r2.setMinimumHeight(zero) + self.layout.yuv_r2.setMaximumHeight(zero) + self.layout.yuv_r3.setMinimumHeight(zero) + self.layout.yuv_r3.setMaximumHeight(zero) + self.layout.yuv_g1.setMinimumHeight(zero) + self.layout.yuv_g1.setMaximumHeight(zero) + self.layout.yuv_g2.setMinimumHeight(zero) + self.layout.yuv_g2.setMaximumHeight(zero) + self.layout.yuv_g3.setMinimumHeight(zero) + self.layout.yuv_g3.setMaximumHeight(zero) + self.layout.mixer_yuv.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_yuv.setVerticalSpacing(zero) + + # Mix ARD + self.layout.ard_l1.setMinimumHeight(zero) + self.layout.ard_l1.setMaximumHeight(zero) + self.layout.ard_l2.setMinimumHeight(zero) + self.layout.ard_l2.setMaximumHeight(zero) + self.layout.ard_l3.setMinimumHeight(zero) + self.layout.ard_l3.setMaximumHeight(zero) + self.layout.ard_r1.setMinimumHeight(zero) + self.layout.ard_r1.setMaximumHeight(zero) + self.layout.ard_r2.setMinimumHeight(zero) + self.layout.ard_r2.setMaximumHeight(zero) + self.layout.ard_r3.setMinimumHeight(zero) + self.layout.ard_r3.setMaximumHeight(zero) + self.layout.ard_g1.setMinimumHeight(zero) + self.layout.ard_g1.setMaximumHeight(zero) + self.layout.ard_g2.setMinimumHeight(zero) + self.layout.ard_g2.setMaximumHeight(zero) + self.layout.ard_g3.setMinimumHeight(zero) + self.layout.ard_g3.setMaximumHeight(zero) + self.layout.mixer_ard.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_ard.setVerticalSpacing(zero) + # Mix HSV + self.layout.hsv_l1.setMinimumHeight(zero) + self.layout.hsv_l1.setMaximumHeight(zero) + self.layout.hsv_l2.setMinimumHeight(zero) + self.layout.hsv_l2.setMaximumHeight(zero) + self.layout.hsv_l3.setMinimumHeight(zero) + self.layout.hsv_l3.setMaximumHeight(zero) + self.layout.hsv_r1.setMinimumHeight(zero) + self.layout.hsv_r1.setMaximumHeight(zero) + self.layout.hsv_r2.setMinimumHeight(zero) + self.layout.hsv_r2.setMaximumHeight(zero) + self.layout.hsv_r3.setMinimumHeight(zero) + self.layout.hsv_r3.setMaximumHeight(zero) + self.layout.hsv_g1.setMinimumHeight(zero) + self.layout.hsv_g1.setMaximumHeight(zero) + self.layout.hsv_g2.setMinimumHeight(zero) + self.layout.hsv_g2.setMaximumHeight(zero) + self.layout.hsv_g3.setMinimumHeight(zero) + self.layout.hsv_g3.setMaximumHeight(zero) + self.layout.mixer_hsv.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_hsv.setVerticalSpacing(zero) + # Mix HSL + self.layout.hsl_l1.setMinimumHeight(zero) + self.layout.hsl_l1.setMaximumHeight(zero) + self.layout.hsl_l2.setMinimumHeight(zero) + self.layout.hsl_l2.setMaximumHeight(zero) + self.layout.hsl_l3.setMinimumHeight(zero) + self.layout.hsl_l3.setMaximumHeight(zero) + self.layout.hsl_r1.setMinimumHeight(zero) + self.layout.hsl_r1.setMaximumHeight(zero) + self.layout.hsl_r2.setMinimumHeight(zero) + self.layout.hsl_r2.setMaximumHeight(zero) + self.layout.hsl_r3.setMinimumHeight(zero) + self.layout.hsl_r3.setMaximumHeight(zero) + self.layout.hsl_g1.setMinimumHeight(zero) + self.layout.hsl_g1.setMaximumHeight(zero) + self.layout.hsl_g2.setMinimumHeight(zero) + self.layout.hsl_g2.setMaximumHeight(zero) + self.layout.hsl_g3.setMinimumHeight(zero) + self.layout.hsl_g3.setMaximumHeight(zero) + self.layout.mixer_hsl.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_hsl.setVerticalSpacing(zero) + # Mix HCY + self.layout.hcy_l1.setMinimumHeight(zero) + self.layout.hcy_l1.setMaximumHeight(zero) + self.layout.hcy_l2.setMinimumHeight(zero) + self.layout.hcy_l2.setMaximumHeight(zero) + self.layout.hcy_l3.setMinimumHeight(zero) + self.layout.hcy_l3.setMaximumHeight(zero) + self.layout.hcy_r1.setMinimumHeight(zero) + self.layout.hcy_r1.setMaximumHeight(zero) + self.layout.hcy_r2.setMinimumHeight(zero) + self.layout.hcy_r2.setMaximumHeight(zero) + self.layout.hcy_r3.setMinimumHeight(zero) + self.layout.hcy_r3.setMaximumHeight(zero) + self.layout.hcy_g1.setMinimumHeight(zero) + self.layout.hcy_g1.setMaximumHeight(zero) + self.layout.hcy_g2.setMinimumHeight(zero) + self.layout.hcy_g2.setMaximumHeight(zero) + self.layout.hcy_g3.setMinimumHeight(zero) + self.layout.hcy_g3.setMaximumHeight(zero) + self.layout.mixer_hcy.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_hcy.setVerticalSpacing(zero) + + # Mix XYZ + self.layout.xyz_l1.setMinimumHeight(zero) + self.layout.xyz_l1.setMaximumHeight(zero) + self.layout.xyz_l2.setMinimumHeight(zero) + self.layout.xyz_l2.setMaximumHeight(zero) + self.layout.xyz_l3.setMinimumHeight(zero) + self.layout.xyz_l3.setMaximumHeight(zero) + self.layout.xyz_r1.setMinimumHeight(zero) + self.layout.xyz_r1.setMaximumHeight(zero) + self.layout.xyz_r2.setMinimumHeight(zero) + self.layout.xyz_r2.setMaximumHeight(zero) + self.layout.xyz_r3.setMinimumHeight(zero) + self.layout.xyz_r3.setMaximumHeight(zero) + self.layout.xyz_g1.setMinimumHeight(zero) + self.layout.xyz_g1.setMaximumHeight(zero) + self.layout.xyz_g2.setMinimumHeight(zero) + self.layout.xyz_g2.setMaximumHeight(zero) + self.layout.xyz_g3.setMinimumHeight(zero) + self.layout.xyz_g3.setMaximumHeight(zero) + self.layout.mixer_xyz.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_xyz.setVerticalSpacing(zero) + # Mix XYY + self.layout.xyy_l1.setMinimumHeight(zero) + self.layout.xyy_l1.setMaximumHeight(zero) + self.layout.xyy_l2.setMinimumHeight(zero) + self.layout.xyy_l2.setMaximumHeight(zero) + self.layout.xyy_l3.setMinimumHeight(zero) + self.layout.xyy_l3.setMaximumHeight(zero) + self.layout.xyy_r1.setMinimumHeight(zero) + self.layout.xyy_r1.setMaximumHeight(zero) + self.layout.xyy_r2.setMinimumHeight(zero) + self.layout.xyy_r2.setMaximumHeight(zero) + self.layout.xyy_r3.setMinimumHeight(zero) + self.layout.xyy_r3.setMaximumHeight(zero) + self.layout.xyy_g1.setMinimumHeight(zero) + self.layout.xyy_g1.setMaximumHeight(zero) + self.layout.xyy_g2.setMinimumHeight(zero) + self.layout.xyy_g2.setMaximumHeight(zero) + self.layout.xyy_g3.setMinimumHeight(zero) + self.layout.xyy_g3.setMaximumHeight(zero) + self.layout.mixer_xyy.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_xyy.setVerticalSpacing(zero) + # Mix LUV + self.layout.luv_l1.setMinimumHeight(zero) + self.layout.luv_l1.setMaximumHeight(zero) + self.layout.luv_l2.setMinimumHeight(zero) + self.layout.luv_l2.setMaximumHeight(zero) + self.layout.luv_l3.setMinimumHeight(zero) + self.layout.luv_l3.setMaximumHeight(zero) + self.layout.luv_r1.setMinimumHeight(zero) + self.layout.luv_r1.setMaximumHeight(zero) + self.layout.luv_r2.setMinimumHeight(zero) + self.layout.luv_r2.setMaximumHeight(zero) + self.layout.luv_r3.setMinimumHeight(zero) + self.layout.luv_r3.setMaximumHeight(zero) + self.layout.luv_g1.setMinimumHeight(zero) + self.layout.luv_g1.setMaximumHeight(zero) + self.layout.luv_g2.setMinimumHeight(zero) + self.layout.luv_g2.setMaximumHeight(zero) + self.layout.luv_g3.setMinimumHeight(zero) + self.layout.luv_g3.setMaximumHeight(zero) + self.layout.mixer_luv.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_luv.setVerticalSpacing(zero) + # Mix HLAB + self.layout.hlab_l1.setMinimumHeight(zero) + self.layout.hlab_l1.setMaximumHeight(zero) + self.layout.hlab_l2.setMinimumHeight(zero) + self.layout.hlab_l2.setMaximumHeight(zero) + self.layout.hlab_l3.setMinimumHeight(zero) + self.layout.hlab_l3.setMaximumHeight(zero) + self.layout.hlab_r1.setMinimumHeight(zero) + self.layout.hlab_r1.setMaximumHeight(zero) + self.layout.hlab_r2.setMinimumHeight(zero) + self.layout.hlab_r2.setMaximumHeight(zero) + self.layout.hlab_r3.setMinimumHeight(zero) + self.layout.hlab_r3.setMaximumHeight(zero) + self.layout.hlab_g1.setMinimumHeight(zero) + self.layout.hlab_g1.setMaximumHeight(zero) + self.layout.hlab_g2.setMinimumHeight(zero) + self.layout.hlab_g2.setMaximumHeight(zero) + self.layout.hlab_g3.setMinimumHeight(zero) + self.layout.hlab_g3.setMaximumHeight(zero) + self.layout.mixer_hlab.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_hlab.setVerticalSpacing(zero) + # Mix LAB + self.layout.lab_l1.setMinimumHeight(zero) + self.layout.lab_l1.setMaximumHeight(zero) + self.layout.lab_l2.setMinimumHeight(zero) + self.layout.lab_l2.setMaximumHeight(zero) + self.layout.lab_l3.setMinimumHeight(zero) + self.layout.lab_l3.setMaximumHeight(zero) + self.layout.lab_r1.setMinimumHeight(zero) + self.layout.lab_r1.setMaximumHeight(zero) + self.layout.lab_r2.setMinimumHeight(zero) + self.layout.lab_r2.setMaximumHeight(zero) + self.layout.lab_r3.setMinimumHeight(zero) + self.layout.lab_r3.setMaximumHeight(zero) + self.layout.lab_g1.setMinimumHeight(zero) + self.layout.lab_g1.setMaximumHeight(zero) + self.layout.lab_g2.setMinimumHeight(zero) + self.layout.lab_g2.setMaximumHeight(zero) + self.layout.lab_g3.setMinimumHeight(zero) + self.layout.lab_g3.setMaximumHeight(zero) + self.layout.mixer_lab.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_lab.setVerticalSpacing(zero) + # Mix LCH + self.layout.lch_l1.setMinimumHeight(zero) + self.layout.lch_l1.setMaximumHeight(zero) + self.layout.lch_l2.setMinimumHeight(zero) + self.layout.lch_l2.setMaximumHeight(zero) + self.layout.lch_l3.setMinimumHeight(zero) + self.layout.lch_l3.setMaximumHeight(zero) + self.layout.lch_r1.setMinimumHeight(zero) + self.layout.lch_r1.setMaximumHeight(zero) + self.layout.lch_r2.setMinimumHeight(zero) + self.layout.lch_r2.setMaximumHeight(zero) + self.layout.lch_r3.setMinimumHeight(zero) + self.layout.lch_r3.setMaximumHeight(zero) + self.layout.lch_g1.setMinimumHeight(zero) + self.layout.lch_g1.setMaximumHeight(zero) + self.layout.lch_g2.setMinimumHeight(zero) + self.layout.lch_g2.setMaximumHeight(zero) + self.layout.lch_g3.setMinimumHeight(zero) + self.layout.lch_g3.setMaximumHeight(zero) + self.layout.mixer_lch.setContentsMargins(zero, zero, zero, zero) + self.layout.mixer_lch.setVerticalSpacing(zero) + + # History + self.layout.color_history.setMinimumHeight(zero) + self.layout.color_history.setMaximumHeight(zero) + self.layout.color_history_layout.setContentsMargins(zero, zero, zero, zero) + + #// + #\\ Conversions (range 0-1) ################################################ + # RGB Display of the given Color ########################################### + def convert(self, d_cm, d_cd, d_cp, src, val): + # Verification + if self.performance_inaccurate == False: # Accurate display of colors + # Source Color + if src == "AAA": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = [val[0]] + if d_cm == "RGBA": + rgb = [val[0], val[0], val[0]] + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( val[0], val[0], val[0] ) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( val[0], val[0], val[0] ) + if d_cm == "XYZA": + xyz = self.rgb_to_xyz( val[0], val[0], val[0] ) + if d_cm == "LABA": + lab = self.rgb_to_lab( val[0], val[0], val[0] ) + if src == "RGB": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa(val[0], val[1], val[2]) + if d_cm == "RGBA": + rgb = [val[0], val[1], val[2]] + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk(val[0], val[1], val[2]) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv(val[0], val[1], val[2]) + if d_cm == "XYZA": + xyz = self.rgb_to_xyz(val[0], val[1], val[2]) + if d_cm == "LABA": + lab = self.rgb_to_lab(val[0], val[1], val[2]) + if src == "CMY": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.cmy_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "RGBA": + rgb = self.cmy_to_rgb(val[0], val[1], val[2]) + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( *self.cmy_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( *self.cmy_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "XYZA": + xyz = self.rgb_to_xyz( *self.cmy_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "LABA": + lab = self.rgb_to_lab( *self.cmy_to_rgb(val[0], val[1], val[2]) ) + if src == "CMYK": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.cmyk_to_rgb(val[0], val[1], val[2], val[3]) ) + if d_cm == "RGBA": + rgb = self.cmyk_to_rgb(val[0], val[1], val[2], val[3]) + if d_cm == "CMYKA": + cmyk = [val[0], val[1], val[2], val[3]] + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( *self.cmyk_to_rgb(val[0], val[1], val[2], val[3]) ) + if d_cm == "XYZA": + xyz = self.rgb_to_xyz( *self.cmyk_to_rgb(val[0], val[1], val[2], val[3]) ) + if d_cm == "LABA": + lab = self.rgb_to_lab( *self.cmyk_to_rgb(val[0], val[1], val[2], val[3]) ) + if src == "RYB": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.ryb_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "RGBA": + rgb = self.ryb_to_rgb(val[0], val[1], val[2]) + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( *self.ryb_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( *self.ryb_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "XYZA": + xyz = self.rgb_to_xyz( *self.ryb_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "LABA": + lab = self.rgb_to_lab( *self.ryb_to_rgb(val[0], val[1], val[2]) ) + if src == "YUV": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.yuv_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "RGBA": + rgb = self.yuv_to_rgb(val[0], val[1], val[2]) + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( *self.yuv_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "YCbCrA": + yuv = [val[0], val[1], val[2]] + if d_cm == "XYZA": + xyz = self.rgb_to_xyz( *self.yuv_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "LABA": + lab = self.rgb_to_lab( *self.yuv_to_rgb(val[0], val[1], val[2]) ) + if src == "ARD": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.ard_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "RGBA": + rgb = self.ard_to_rgb(val[0], val[1], val[2]) + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( *self.ard_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( *self.ard_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "XYZA": + xyz = self.rgb_to_xyz( *self.ard_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "LABA": + lab = self.rgb_to_lab( *self.ard_to_rgb(val[0], val[1], val[2]) ) + if src == "HSV": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.hsv_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "RGBA": + rgb = self.hsv_to_rgb(val[0], val[1], val[2]) + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( *self.hsv_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( *self.hsv_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "XYZA": + xyz = self.rgb_to_xyz( *self.hsv_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "LABA": + lab = self.rgb_to_lab( *self.hsv_to_rgb(val[0], val[1], val[2]) ) + if src == "HSL": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.hsl_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "RGBA": + rgb = self.hsl_to_rgb(val[0], val[1], val[2]) + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( *self.hsl_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( *self.hsl_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "XYZA": + xyz = self.rgb_to_xyz( *self.hsl_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "LABA": + lab = self.rgb_to_lab( *self.hsl_to_rgb(val[0], val[1], val[2]) ) + if src == "HCY": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.hcy_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "RGBA": + rgb = self.hcy_to_rgb(val[0], val[1], val[2]) + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( *self.hcy_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( *self.hcy_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "XYZA": + xyz = self.rgb_to_xyz( *self.hcy_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "LABA": + lab = self.rgb_to_lab( *self.hcy_to_rgb(val[0], val[1], val[2]) ) + if src == "XYZ": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.xyz_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "RGBA": + rgb = self.xyz_to_rgb(val[0], val[1], val[2]) + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( *self.xyz_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( *self.xyz_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "XYZA": + xyz = [val[0], val[1], val[2]] + if d_cm == "LABA": + lab = self.xyz_to_lab(val[0], val[1], val[2]) + if src == "XYY": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.xyz_to_rgb( *self.xyy_to_xyz(val[0], val[1], val[2]) ) ) + if d_cm == "RGBA": + rgb = self.xyz_to_rgb( *self.xyy_to_xyz(val[0], val[1], val[2]) ) + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( *self.xyz_to_rgb( *self.xyy_to_xyz(val[0], val[1], val[2]) ) ) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( *self.xyz_to_rgb( *self.xyy_to_xyz(val[0], val[1], val[2]) ) ) + if d_cm == "XYZA": + xyz = self.xyy_to_xyz(val[0], val[1], val[2]) + if d_cm == "LABA": + lab = self.xyz_to_lab( *self.xyy_to_xyz(val[0], val[1], val[2]) ) + if src == "LAB": + if (d_cm == "A" or d_cm == "GRAYA"): + aaa = self.rgb_to_aaa( *self.lab_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "RGBA": + rgb = self.lab_to_rgb(val[0], val[1], val[2]) + if d_cm == "CMYKA": + cmyk = self.rgb_to_cmyk( *self.lab_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "YCbCrA": + yuv = self.rgb_to_yuv( *self.lab_to_rgb(val[0], val[1], val[2]) ) + if d_cm == "XYZA": + xyz = self.lab_to_xyz(val[0], val[1], val[2]) + if d_cm == "LABA": + lab = [val[0], val[1], val[2]] + # Apply Components to Document + if ((self.canvas() is not None) and (self.canvas().view() is not None)): + mc = ManagedColor(d_cm, d_cd, d_cp) + if (d_cm == "A" or d_cm == "GRAYA"): + mc.setComponents([aaa[0], 1.0]) + if d_cm == "RGBA": + if (d_cd == "U8" or d_cd == "U16"): + mc.setComponents([rgb[2], rgb[1], rgb[0], 1.0]) + if (d_cd == "F16" or d_cd == "F32"): + mc.setComponents([rgb[0], rgb[1], rgb[2], 1.0]) + if d_cm == "CMYKA": + mc.setComponents([cmyk[0], cmyk[1], cmyk[2], cmyk[3], 1.0]) + if d_cm == "YCbCrA": + mc.setComponents([yuv[0], yuv[1], yuv[2], 1.0]) + if d_cm == "XYZA": + mc.setComponents([xyz[0], xyz[1], xyz[2], 1.0]) + if d_cm == "LABA": + mc.setComponents([lab[0], lab[1], lab[2], 1.0]) + av = Krita.instance().activeWindow().activeView() + cfc = mc.colorForCanvas(av.canvas()) + r = cfc.redF() + g = cfc.greenF() + b = cfc.blueF() + else: + r = rgb[0] + g = rgb[1] + b = rgb[2] + else: # Inaccurate display of colors but faster + if src == "AAA": + r = val[0] + g = val[0] + b = val[0] + if src == "RGB": + r = val[0] + g = val[1] + b = val[2] + if src == "CMY": + rgb = self.cmy_to_rgb(val[0], val[1], val[2]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + if src == "CMYK": + rgb = self.cmyk_to_rgb(val[0], val[1], val[2], val[3]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + if src == "RYB": + rgb = self.ryb_to_rgb(val[0], val[1], val[2]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + if src == "YUV": + rgb = self.yuv_to_rgb(val[0], val[1], val[2]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + if src == "ARD": + rgb = self.ard_to_rgb(val[0], val[1], val[2]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + if src == "HSV": + rgb = self.hsv_to_rgb(val[0], val[1], val[2]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + if src == "HSL": + rgb = self.hsl_to_rgb(val[0], val[1], val[2]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + if src == "HCY": + rgb = self.hcy_to_rgb(val[0], val[1], val[2]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + if src == "XYZ": + rgb = self.xyz_to_rgb(val[0], val[1], val[2]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + if src == "XYY": + rgb = self.xyz_to_rgb( *self.xyy_to_xyz(val[0], val[1], val[2]) ) + r = rgb[0] + g = rgb[1] + b = rgb[2] + if src == "LAB": + rgb = self.lab_to_rgb(val[0], val[1], val[2]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + return [r, g, b] + + + # Gray Contrast ############################################################ + def gc(self, r, g, b): + value = self.rgb_to_aaa(r, g, b)[0] + if value <= 0.3: + gc = ( 1 - value ) + elif value >= 0.7: + gc = ( 1 - value ) + else: + gc = ( value - 0.3 ) + return gc + # AAA + def rgb_to_aaa(self, r, g, b): + aaa = (self.luma_r*r) + (self.luma_g*g) + (self.luma_b*b) + return [aaa] + # RGB + def srgb_to_lrgb(self, sr, sg, sb): + n = 0.055 + m = 12.92 + if sr > 0.04045: + lr = ( ( sr + n ) / ( 1 + n ) ) ** self.gamma_l + else: + lr = sr / m + if sg > 0.04045: + lg = ( ( sg + n ) / ( 1 + n ) ) ** self.gamma_l + else: + lg = sg / m + if sb > 0.04045: + lb = ( ( sb + n ) / ( 1 + n ) ) ** self.gamma_l + else: + lb = sb / m + return [lr, lg, lb] + def lrgb_to_srgb(self, lr, lg, lb): + n = 0.055 + m = 12.92 + if lr > 0.0031308: + sr = (( 1 + n ) * lr ** ( 1 / self.gamma_l )) - n + else: + sr = m * lr + if lg > 0.0031308: + sg = (( 1 + n ) * lg ** ( 1 / self.gamma_l )) - n + else: + sg = m * lg + if lb > 0.0031308: + sb = (( 1 + n ) * lb ** ( 1 / self.gamma_l )) - n + else: + sb = m * lb + return [sr, sg, sb] + # CMY + def rgb_to_cmy(self, r, g, b): + c = 1 - r + m = 1 - g + y = 1 - b + return [c, m, y] + def cmy_to_rgb(self, c, m, y): + r = 1 - c + g = 1 - m + b = 1 - y + return [r, g, b] + # CMYK + def rgb_to_cmyk(self, r, g, b): + q = max(r, g, b) + if q == 0: + if self.cmyk_lock == False: + c = 0 + m = 0 + y = 0 + k = 1 + if self.cmyk_lock == True: + c = 1 + m = 1 + y = 1 + k = self.cmyk_4 + else: + if self.cmyk_lock == False: + k = 1 - max(r, g, b) # Standard Transform + else: + k = self.cmyk_4 # Key is Locked + ik = 1 - k + if ik == 0 : + c = ( r - k ) / ( k ) + m = ( g - k ) / ( k ) + y = ( b - k ) / ( k ) + else: + c = ( 1 - r - k ) / ( 1 - k ) + m = ( 1 - g - k ) / ( 1 - k ) + y = ( 1 - b - k ) / ( 1 - k ) + return [c, m, y, k] + def cmyk_to_rgb(self, c, m, y, k): + r = ( 1 - c ) * ( 1 - k ) + g = ( 1 - m ) * ( 1 - k ) + b = ( 1 - y ) * ( 1 - k ) + return [r, g, b] + # RYB + def rgb_to_ryb(self, r, g, b): + red = r + green = g + blue = b + white = min(red, green, blue) + red -= white + green -= white + blue -= white + maxgreen = max(red, green, blue) + yellow = min(red, green) + red -= yellow + green -= yellow + if (blue > 0 and green > 0): + blue /= 2 + green /= 2 + yellow += green + blue += green + maxyellow = max(red, yellow, blue) + if maxyellow > 0: + N = maxgreen / maxyellow + red *= N + yellow *= N + blue *= N + red += white + yellow += white + blue += white + return [red, yellow, blue] + def ryb_to_rgb(self, r, y, b): + red = r + yellow = y + blue = b + white = min(red, yellow, blue) + red -= white + yellow -= white + blue -= white + maxyellow = max(red, yellow, blue) + green = min(yellow, blue) + yellow -= green + blue -= green + if (blue > 0 and green > 0): + blue *= 2 + green *= 2 + red += yellow + green += yellow + maxgreen = max(red, green, blue) + if maxgreen > 0: + N = maxyellow / maxgreen + red *= N + green *= N + blue *= N + red += white + green += white + blue += white + return [red, green, blue] + # RYB HUE Conversion + def hcmy_to_hryb(self, hcmy): + hcmy = self.Math_1D_Loop(hcmy) + for i in range(len(cmy_step)): + if hcmy == cmy_step[i]: + hryb = ryb_step[i] + for i in range(len(cmy_step)-1): + if (hcmy > cmy_step[i] and hcmy < cmy_step[i+1]): + var = (hcmy - cmy_step[i]) / (cmy_step[i+1] - cmy_step[i]) + hryb = ( ryb_step[i] + (ryb_step[i+1] - ryb_step[i]) * var ) + return hryb + def hryb_to_hcmy(self, hryb): + hcmy = self.Math_1D_Loop(hryb) + for i in range(len(ryb_step)): + if hryb == ryb_step[i]: + hcmy = cmy_step[i] + for i in range(len(ryb_step)-1): + if (hryb > ryb_step[i] and hryb < ryb_step[i+1]): + var = (hryb - ryb_step[i]) / (ryb_step[i+1] - ryb_step[i]) + hcmy = ( cmy_step[i] + (cmy_step[i+1] - cmy_step[i]) * var ) + return hcmy + # YUV + def rgb_to_yuv(self, r, g, b): + y = self.luma_r*r + self.luma_g*g + self.luma_b*b + pb = 0.5 + (0.5 * ((b - y) / (1 - self.luma_b))) # Chroma Blue - " 0.5 + " is the slider adjustment offset + pr = 0.5 + (0.5 * ((r - y) / (1 - self.luma_r))) # Chroma Red - " 0.5 + " is the slider adjustment offset + return [y, pb, pr] + def yuv_to_rgb(self, y, pb, pr): + pb = pb - 0.5 # slider adjustment offset + pr = pr - 0.5 # slider adjustment offset + r = self.luma_pr * pr + y + g = (-0.344136286201022) * pb + (-0.714136286201022) * pr + y + b = self.luma_pb * pb + y + if r <= 0: + r = 0 + if r >= 1: + r = 1 + if g <= 0: + g = 0 + if g >= 1: + g = 1 + if b <= 0: + b = 0 + if b >= 1: + b = 1 + return [r, g, b] + # KELVIN (not physical) + def kkk_to_rgb(self, k): + for i in range(len(kelvin_rgb)): + # detect list entry + if (k == kelvin_rgb[i][0] or (k > kelvin_rgb[i][0] and k < kelvin_rgb[i+1][0])): + # 1 value for that step + r = kelvin_rgb[i][1] / 255 + g = kelvin_rgb[i][2] / 255 + b = kelvin_rgb[i][3] / 255 + return [r, g, b] + + + # UVD ###################################################################### + def rgb_to_uvd(self, r, g, b): + # uv range from -1 to 1 (0.8 with mask) + # MatrixInverse * RGB + MatrixInv = [[-0.866025808, 0.866025808, -0.0000000000000000961481791], + [ 0.500000010, 0.499999990, -1.00000000], + [ 0.333333497, 0.333333503, 0.333333000]] + u = MatrixInv[0][0]*r + MatrixInv[0][1]*g + MatrixInv[0][2]*b + v = MatrixInv[1][0]*r + MatrixInv[1][1]*g + MatrixInv[1][2]*b + d = MatrixInv[2][0]*r + MatrixInv[2][1]*g + MatrixInv[2][2]*b + m = 0.0000001 + if (u > -m and u < m): + u = 0 + if (v > -m and v < m): + v = 0 + return [u, v, d] + def uvd_to_rgb(self, u, v, d): + # Matrix * UVD + Matrix = [[-0.57735, 0.333333, 1], + [ 0.57735, 0.333333, 1], + [-0.0000000113021, -0.666667, 1]] + r = Matrix[0][0]*u + Matrix[0][1]*v + Matrix[0][2]*d + g = Matrix[1][0]*u + Matrix[1][1]*v + Matrix[1][2]*d + b = Matrix[2][0]*u + Matrix[2][1]*v + Matrix[2][2]*d + # Correct out of Bound values + if r <= 0: + r = 0 + if r >= 1: + r = 1 + if g <= 0: + g = 0 + if g >= 1: + g = 1 + if b <= 0: + b = 0 + if b >= 1: + b = 1 + return [r, g, b] + def uvd_hexagon_origins(self, d): + # Values + w1 = 0.8660253882408142 + h1 = 0.5000000596046448 + h2 = 1 + diagonal = d * 3 + delta1 = diagonal + delta2 = diagonal - 1 + delta3 = diagonal - 2 + # Single Points + if diagonal <= 0.0: + self.O1 = [0, 0] + self.O2 = [0, 0] + self.O3 = [0, 0] + self.O4 = [0, 0] + self.O5 = [0, 0] + self.O6 = [0, 0] + elif (diagonal > 0.0 and diagonal <= 1.0): + self.O1 = [0 + 0, 0 - (h2*delta1)] # -1 exception to not be zero area + self.O2 = [0 + (w1*delta1), 0 + (h1*delta1)] + self.O3 = [0 + (w1*delta1), 0 + (h1*delta1)] + self.O4 = [0 - (w1*delta1), 0 + (h1*delta1)] + self.O5 = [0 - (w1*delta1), 0 + (h1*delta1)] + self.O6 = [0 + 0, 0 - (h2*delta1)] # -1 exception to not be zero area + elif (diagonal > 1.0 and diagonal < 2.0): + self.O1 = [ 0 + (w1*delta2), -h2 + (h1*delta2)] + self.O2 = [ w1 + 0, h1 - (h2*delta2)] + self.O3 = [ w1 - (w1*delta2), h1 + (h1*delta2)] + self.O4 = [-w1 + (w1*delta2), h1 + (h1*delta2)] + self.O5 = [-w1 + 0, h1 - (h2*delta2)] + self.O6 = [ 0 - (w1*delta2), -h2 + (h1*delta2)] + elif (diagonal >= 2.0 and diagonal < 3.0): + self.O1 = [ w1 - (w1*delta3), -h1 + (h1*delta3)] + self.O2 = [ w1 - (w1*delta3), -h1 + (h1*delta3)] + self.O3 = [ 0 + 0, h2 - (h2*delta3)] + self.O4 = [ 0 + 0, h2 - (h2*delta3)] + self.O5 = [-w1 + (w1*delta3), -h1 + (h1*delta3)] + self.O6 = [-w1 + (w1*delta3), -h1 + (h1*delta3)] + elif diagonal >= 3.0: + self.O1 = [0, 0] + self.O2 = [0, 0] + self.O3 = [0, 0] + self.O4 = [0, 0] + self.O5 = [0, 0] + self.O6 = [0, 0] + # Composed Points + self.OCC = [0, 0] + self.O12 = [self.O1[0] + ((self.O2[0] - self.O1[0]) / 2), self.O1[1] + ((self.O2[1] - self.O1[1]) / 2)] + self.O23 = [self.O2[0] + ((self.O3[0] - self.O2[0]) / 2), self.O2[1] + ((self.O3[1] - self.O2[1]) / 2)] + self.O34 = [self.O3[0] + ((self.O4[0] - self.O3[0]) / 2), self.O3[1] + ((self.O4[1] - self.O3[1]) / 2)] + self.O45 = [self.O4[0] + ((self.O5[0] - self.O4[0]) / 2), self.O4[1] + ((self.O5[1] - self.O4[1]) / 2)] + self.O56 = [self.O5[0] + ((self.O6[0] - self.O5[0]) / 2), self.O5[1] + ((self.O6[1] - self.O5[1]) / 2)] + self.O61 = [self.O6[0] + ((self.O1[0] - self.O6[0]) / 2), self.O6[1] + ((self.O1[1] - self.O6[1]) / 2)] + # Angle to Red Axis as Origin + self.REDAXIS = self.Math_2D_Points_Lines_Angle(10, 0, 0, 0, self.O45[0], self.O45[1]) + def uvd_to_ard(self, u, v, d): + # Update Origin Points + self.uvd_hexagon_origins(d) + # Correct UV values + u = round(u,15) + v = round(v,15) + # Angle + if (u == 0 and v == 0): + arc=0 + a=0 + else: + arc = self.Math_2D_Points_Lines_Angle(u,v, 0,0, self.O45[0],self.O45[1]) # range 0 to 360 + a = arc / 360 # range 0 to 1 + # User Value + user = self.Math_2D_Points_Distance(0, 0, u, v) + # Total Value + diagonal = d * 3 + if diagonal <= 0: + a = self.angle_live + total = 1 + elif (diagonal > 0 and diagonal <= 1): + # Angles according to O45(RED) as Origin + AR = 0 # RED + AG = self.Math_2D_Points_Lines_Angle(self.O23[0], self.O23[1], 0, 0, self.O45[0], self.O45[1]) # GREEN + AB = self.Math_2D_Points_Lines_Angle(self.O61[0], self.O61[1], 0, 0, self.O45[0], self.O45[1]) # BLUE + # Certain + if arc == AR: + total = self.Math_2D_Points_Distance(0, 0, self.O45[0], self.O45[1]) + elif arc == AG: + total = self.Math_2D_Points_Distance(0, 0, self.O23[0], self.O23[1]) + elif arc == AB: + total = self.Math_2D_Points_Distance(0, 0, self.O61[0], self.O61[1]) + # Intervals + elif (arc > AR and arc < AG): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O3[0], self.O3[1], self.O4[0], self.O4[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AG and arc < AB): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O1[0], self.O1[1], self.O2[0], self.O2[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AB or arc < AR): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O5[0], self.O5[1], self.O6[0], self.O6[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (diagonal > 1 and diagonal < 2): + # Angles according to O45(RED) as Origin + A1 = self.Math_2D_Points_Lines_Angle(self.O1[0], self.O1[1], 0, 0, self.O45[0], self.O45[1]) # O1 + A2 = self.Math_2D_Points_Lines_Angle(self.O2[0], self.O2[1], 0, 0, self.O45[0], self.O45[1]) # O2 + A3 = self.Math_2D_Points_Lines_Angle(self.O3[0], self.O3[1], 0, 0, self.O45[0], self.O45[1]) # O3 + A4 = self.Math_2D_Points_Lines_Angle(self.O4[0], self.O4[1], 0, 0, self.O45[0], self.O45[1]) # O4 + A5 = self.Math_2D_Points_Lines_Angle(self.O5[0], self.O5[1], 0, 0, self.O45[0], self.O45[1]) # O5 + A6 = self.Math_2D_Points_Lines_Angle(self.O6[0], self.O6[1], 0, 0, self.O45[0], self.O45[1]) # O6 + # Certain + if arc == A1: + total = self.Math_2D_Points_Distance(0, 0, self.O1[0], self.O1[1]) + elif arc == A2: + total = self.Math_2D_Points_Distance(0, 0, self.O2[0], self.O2[1]) + elif arc == A3: + total = self.Math_2D_Points_Distance(0, 0, self.O3[0], self.O3[1]) + elif arc == A4: + total = self.Math_2D_Points_Distance(0, 0, self.O4[0], self.O4[1]) + elif arc == A5: + total = self.Math_2D_Points_Distance(0, 0, self.O5[0], self.O5[1]) + elif arc == A6: + total = self.Math_2D_Points_Distance(0, 0, self.O6[0], self.O6[1]) + # Intervals + elif (arc > A4 and arc < A3): # 0 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O4[0], self.O4[1], self.O3[0], self.O3[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A3 and arc < A2): # 60 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O3[0], self.O3[1], self.O2[0], self.O2[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A2 and arc < A1): # 120 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O2[0], self.O2[1], self.O1[0], self.O1[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A1 and arc < A6): # 180 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O1[0], self.O1[1], self.O6[0], self.O6[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A6 and arc < A5): # 240 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O6[0], self.O6[1], self.O5[0], self.O5[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A5 or arc < A4): # 300 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O5[0], self.O5[1], self.O4[0], self.O4[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (diagonal >= 2 and diagonal < 3): + # Angles according to O45(RED) as Origin + AY = self.Math_2D_Points_Lines_Angle(self.O34[0], self.O34[1], 0, 0, self.O45[0], self.O45[1]) # YELLOW + AC = self.Math_2D_Points_Lines_Angle(self.O12[0], self.O12[1], 0, 0, self.O45[0], self.O45[1]) # CYAN + AM = self.Math_2D_Points_Lines_Angle(self.O56[0], self.O56[1], 0, 0, self.O45[0], self.O45[1]) # MAGENTA + # Certain + if arc == AY: + total = self.Math_2D_Points_Distance(0, 0, self.O34[0], self.O34[1]) + elif arc == AC: + total = self.Math_2D_Points_Distance(0, 0, self.O12[0], self.O12[1]) + elif arc == AM: + total = self.Math_2D_Points_Distance(0, 0, self.O56[0], self.O56[1]) + # Intervals + elif (arc > AY and arc < AC): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O2[0], self.O2[1], self.O3[0], self.O3[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AC and arc < AM): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O1[0], self.O1[1], self.O6[0], self.O6[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AM or arc < AY): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O4[0], self.O4[1], self.O5[0], self.O5[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif diagonal >= 3: + a = self.angle_live + total = 1 + # Percentual Value of the distance from the center to the outside + try: + ratio = user / total + except: + ratio = user + r = ratio + # Correct out of Bound values + if a <= 0: + a = 0 + if a >= 1: + a = 1 + if r <= 0: + r = 0 + if r >= 1: + r = 1 + if d <= 0: + d = 0 + if d >= 1: + d = 1 + return [a, r, d] + def ard_to_uvd(self, a, r, d): + # Update Origin Points + self.uvd_hexagon_origins(d) + # Angle according to normal zero axis +U right and counter clockwise + a360 = a * 360 + arc = a360 - self.REDAXIS + if a360 < self.REDAXIS: + arc = (360 - self.REDAXIS) + a360 + # Intersection Vector line Point + ucos = math.cos(math.radians(arc)) + vsin = -math.sin(math.radians(arc)) + # Diagonal Depth + diagonal = d * 3 + if diagonal <= 0: + total = 1 + elif (diagonal > 0 and diagonal <= 1): + # Angles according to +U(UVD) as Origin + AR = self.Math_2D_Points_Lines_Angle(self.O45[0], self.O45[1], 0, 0, 1, 0) # RED + AG = self.Math_2D_Points_Lines_Angle(self.O23[0], self.O23[1], 0, 0, 1, 0) # GREEN + AB = self.Math_2D_Points_Lines_Angle(self.O61[0], self.O61[1], 0, 0, 1, 0) # BLUE + # Certain + if arc == AR: # RED + total = self.Math_2D_Points_Distance(0, 0, self.O45[0], self.O45[1]) + elif arc == AG: # GREEN + total = self.Math_2D_Points_Distance(0, 0, self.O23[0], self.O23[1]) + elif arc == AB: # BLUE + total = self.Math_2D_Points_Distance(0, 0, self.O61[0], self.O61[1]) + # Intervals + elif (arc > AR and arc < AG): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O3[0], self.O3[1], self.O4[0], self.O4[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AG or arc < AB): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O1[0], self.O1[1], self.O2[0], self.O2[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AB and arc < AR): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O5[0], self.O5[1], self.O6[0], self.O6[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (diagonal > 1 and diagonal < 2): + # Angles according to +U(UVD) as Origin + A1 = self.Math_2D_Points_Lines_Angle(self.O1[0], self.O1[1], 0, 0, 1, 0) # P1 + A2 = self.Math_2D_Points_Lines_Angle(self.O2[0], self.O2[1], 0, 0, 1, 0) # P2 + A3 = self.Math_2D_Points_Lines_Angle(self.O3[0], self.O3[1], 0, 0, 1, 0) # P3 + A4 = self.Math_2D_Points_Lines_Angle(self.O4[0], self.O4[1], 0, 0, 1, 0) # P4 + A5 = self.Math_2D_Points_Lines_Angle(self.O5[0], self.O5[1], 0, 0, 1, 0) # P5 + A6 = self.Math_2D_Points_Lines_Angle(self.O6[0], self.O6[1], 0, 0, 1, 0) # P6 + # Certain + if arc == A1: + total = self.Math_2D_Points_Distance(0, 0, self.O1[0], self.O1[1]) + elif arc == A2: + total = self.Math_2D_Points_Distance(0, 0, self.O2[0], self.O2[1]) + elif arc == A3: + total = self.Math_2D_Points_Distance(0, 0, self.O3[0], self.O3[1]) + elif arc == A4: + total = self.Math_2D_Points_Distance(0, 0, self.O4[0], self.O4[1]) + elif arc == A5: + total = self.Math_2D_Points_Distance(0, 0, self.O5[0], self.O5[1]) + elif arc == A6: + total = self.Math_2D_Points_Distance(0, 0, self.O6[0], self.O6[1]) + # Intervals + elif (arc > A1 and arc < A6): # 180 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O1[0], self.O1[1], self.O6[0], self.O6[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A6 and arc < A5): # 240 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O6[0], self.O6[1], self.O5[0], self.O5[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A5 and arc < A4): # 300 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O5[0], self.O5[1], self.O4[0], self.O4[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A4 and arc < A3): # 0 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O4[0], self.O4[1], self.O3[0], self.O3[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + # Desambiguiation due to A2 crossing the Origin Axis + elif A2 < 180: + if (arc > A3 or arc < A2): # 60 OR + inter = list(self.Math_2D_Points_Lines_Intersection(self.O3[0], self.O3[1], self.O2[0], self.O2[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + if (arc > A2 and arc < A1): # 120 AND + inter = list(self.Math_2D_Points_Lines_Intersection(self.O2[0], self.O2[1], self.O1[0], self.O1[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif A2 > 180: + if (arc > A3 and arc < A2): # 60 AND + inter = list(self.Math_2D_Points_Lines_Intersection(self.O3[0], self.O3[1], self.O2[0], self.O2[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + if (arc > A2 or arc < A1): # 120 OR + inter = list(self.Math_2D_Points_Lines_Intersection(self.O2[0], self.O2[1], self.O1[0], self.O1[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (diagonal >= 2 and diagonal < 3): + # Angles according to +U(UVD) as Origin + AY = self.Math_2D_Points_Lines_Angle(self.O34[0], self.O34[1], 0, 0, 1, 0) # YELLOW + AC = self.Math_2D_Points_Lines_Angle(self.O12[0], self.O12[1], 0, 0, 1, 0) # CYAN + AM = self.Math_2D_Points_Lines_Angle(self.O56[0], self.O56[1], 0, 0, 1, 0) # MAGENTA + # Certain + if arc == AY: + total = self.Math_2D_Points_Distance(0, 0, self.O34[0], self.O34[1]) + elif arc == AC: + total = self.Math_2D_Points_Distance(0, 0, self.O12[0], self.O12[1]) + elif arc == AM: + total = self.Math_2D_Points_Distance(0, 0, self.O56[0], self.O56[1]) + # Intervals + elif (arc > AY or arc < AC): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O2[0], self.O2[1], self.O3[0], self.O3[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AC and arc < AM): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O1[0], self.O1[1], self.O6[0], self.O6[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AM and arc < AY): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O4[0], self.O4[1], self.O5[0], self.O5[1], 0, 0, ucos, vsin)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif diagonal >= 3: + total = 1 + # User Distance to Center + user = r * total + u = user * math.cos(math.radians(arc)) + v = user * -math.sin(math.radians(arc)) + # Correct UV for D extreme value + if (d==0 or d==1): + u = 0 + v = 0 + return [u, v, d] + # ARD + def rgb_to_ard(self, r, g, b): + uvd = self.rgb_to_uvd(r, g, b) + ard = self.uvd_to_ard(uvd[0], uvd[1], uvd[2]) + a = ard[0] + r = ard[1] + d = ard[2] + if r == 0: + a = self.angle_live + return [a, r, d] + def ard_to_rgb(self, a, r, d): + uvd = self.ard_to_uvd(a, r, d) + rgb = self.uvd_to_rgb(uvd[0], uvd[1], uvd[2]) + r = rgb[0] + g = rgb[1] + b = rgb[2] + return [r, g, b] + # HUE + def rgb_to_hue(self, r, g, b): + maxc = max(r, g, b) + minc = min(r, g, b) + if minc == maxc: + # return [0.0] + return [self.angle_live] + rc = (maxc-r) / (maxc-minc) + gc = (maxc-g) / (maxc-minc) + bc = (maxc-b) / (maxc-minc) + if r == maxc: + h = bc-gc + elif g == maxc: + h = 2.0 + rc - bc + else: + h = 4.0 + gc - rc + h = ( h / 6.0 ) % 1.0 + return [h] + def hue_to_rgb(self, h): + vh = h * 6 + if vh == 6 : + vh = 0 + vi = int( vh ) + v2 = 1 * ( 1 - 1 * ( vh - vi ) ) + v3 = 1 * ( 1 - 1 * ( 1 - ( vh - vi ) ) ) + if vi == 0 : + r = 1 + g = v3 + b = 0 + elif vi == 1 : + r = v2 + g = 1 + b = 0 + elif vi == 2 : + r = 0 + g = 1 + b = v3 + elif vi == 3 : + r = 0 + g = v2 + b = 1 + elif vi == 4 : + r = v3 + g = 0 + b = 1 + else: + r = 1 + g = 0 + b = v2 + return [r, g, b] + # HSI ???????????????????????????????????????????????????? + def rgb_to_hsi_old(self, r, g, b): + # In case Krita is in Linear Format + if self.d_cd != "U8": + lsl = self.lrgb_to_srgb(r, g, b) + r = lsl[0] + g = lsl[1] + b = lsl[2] + # sRGB to HSX + i = (r + g + b) / 3 + m = min(r,g,b) + s = 1 - (3/(r+g+b))*m + if g > b: + h = math.acos( ((r-g)+(r-b)) / ((r-g)**2+((r-b)(g-b)))**0.5 ) + else: + h = 360 - h + h = h / 360 + return [h, s, i] + def hsi_to_rgb_old(self, h, s, i): + # HSX to sRGB + hue = h * 6 + z = (1 - abs(math.fmod(hue, 2) - 1) ) * s + c = (3 * i * s) / (1 + z) + x = c * z + if (hue >= 0 and hue < 1): + r = c + g = x + b = 0 + elif (hue >= 1 and hue < 2): + r = x + g = c + b = 0 + elif (hue >= 2 and hue < 3): + r = 0 + g = c + b = x + elif (hue >= 3 and hue < 4): + r = 0 + g = x + b = c + elif (hue >= 4 and hue < 5): + r = x + g = 0 + b = c + elif (hue >= 5 and hue <= 6): + r = c + g = 0 + b = x + else: + r = 0 + g = 0 + b = 0 + m = i * ( 1 - s ) + r = r + m + g = g + m + b = b + m + # In case Krita is in Linear Format + if self.d_cd != "U8": + lsl = self.srgb_to_lrgb(r, g, b) + r = lsl[0] + g = lsl[1] + b = lsl[2] + return [r, g, b] + + def rgb_to_hsi(self, r, g, b): + return [h, s, i] + def hsi_to_rgb(self, h, s, i): + return [r, g, b] + + # HSV + def rgb_to_hsv(self, r, g, b): + # In case Krita is in Linear Format + if self.d_cd != "U8": + lsl = self.lrgb_to_srgb(r, g, b) + r = lsl[0] + g = lsl[1] + b = lsl[2] + # sRGB to HSX + v_min = min( r, g, b ) + v_max = max( r, g, b ) + d_max = v_max - v_min + v = v_max + if d_max == 0: + h = self.angle_live + s = 0 + else: + s = d_max / v_max + d_r = ( ( ( v_max - r ) / 6 ) + ( d_max / 2 ) ) / d_max + d_g = ( ( ( v_max - g ) / 6 ) + ( d_max / 2 ) ) / d_max + d_b = ( ( ( v_max - b ) / 6 ) + ( d_max / 2 ) ) / d_max + if r == v_max : + h = d_b - d_g + elif g == v_max : + h = ( 1 / 3 ) + d_r - d_b + elif b == v_max : + h = ( 2 / 3 ) + d_g - d_r + if h < 0 : + h += 1 + if h > 1 : + h -= 1 + return [h, s, v] + def hsv_to_rgb(self, h, s, v): + # HSX to sRGB + if s == 0: + r = v + g = v + b = v + else: + vh = h * 6 + if vh == 6 : + vh = 0 + vi = int( vh ) + v1 = v * ( 1 - s ) + v2 = v * ( 1 - s * ( vh - vi ) ) + v3 = v * ( 1 - s * ( 1 - ( vh - vi ) ) ) + if vi == 0 : + r = v + g = v3 + b = v1 + elif vi == 1 : + r = v2 + g = v + b = v1 + elif vi == 2 : + r = v1 + g = v + b = v3 + elif vi == 3 : + r = v1 + g = v2 + b = v + elif vi == 4 : + r = v3 + g = v1 + b = v + else: + r = v + g = v1 + b = v2 + # In case Krita is in Linear Format + if self.d_cd != "U8": + lsl = self.srgb_to_lrgb(r, g, b) + r = lsl[0] + g = lsl[1] + b = lsl[2] + return [r, g, b] + # HSL + def rgb_to_hsl(self, r, g, b): + # In case Krita is in Linear Format + if self.d_cd != "U8": + lsl = self.lrgb_to_srgb(r, g, b) + r = lsl[0] + g = lsl[1] + b = lsl[2] + # sRGB to HSX + v_min = min( r, g, b ) + v_max = max( r, g, b ) + d_max = v_max - v_min + l = ( v_max + v_min )/ 2 + if d_max == 0 : + h = self.angle_live + s = 0 + else: + if l < 0.5 : + s = d_max / ( v_max + v_min ) + else: + s = d_max / ( 2 - v_max - v_min ) + d_r = ( ( ( v_max - r ) / 6 ) + ( d_max / 2 ) ) / d_max + d_g = ( ( ( v_max - g ) / 6 ) + ( d_max / 2 ) ) / d_max + d_b = ( ( ( v_max - b ) / 6 ) + ( d_max / 2 ) ) / d_max + if r == v_max : + h = d_b - d_g + elif g == v_max: + h = ( 1 / 3 ) + d_r - d_b + elif b == v_max: + h = ( 2 / 3 ) + d_g - d_r + if h < 0: + h += 1 + if h > 1: + h -= 1 + return [h, s, l] + def hsl_to_rgb(self, h, s, l): + if s == 0 : + r = l + g = l + b = l + else: + if l < 0.5: + v2 = l * ( 1 + s ) + else: + v2 = ( l + s ) - ( s * l ) + v1 = 2 * l - v2 + r = self.hsl_chan( v1, v2, h + ( 1 / 3 ) ) + g = self.hsl_chan( v1, v2, h ) + b = self.hsl_chan( v1, v2, h - ( 1 / 3 ) ) + # In case Krita is in Linear Format + if self.d_cd != "U8": + lsl = self.srgb_to_lrgb(r, g, b) + r = lsl[0] + g = lsl[1] + b = lsl[2] + return [r, g, b] + def hsl_chan(self, v1, v2, vh): + if vh < 0 : + vh += 1 + if vh > 1 : + vh -= 1 + if ( 6 * vh ) < 1 : + return ( v1 + ( v2 - v1 ) * 6 * vh ) + if ( 2 * vh ) < 1 : + return ( v2 ) + if ( 3 * vh ) < 2 : + return ( v1 + ( v2 - v1 ) * ( ( 2 / 3 ) - vh ) * 6 ) + return ( v1 ) + # HSY (Krita version) + def rgb_to_hsy(self, r, g, b): + # In case Krita is NOT in Linear Format + if self.d_cd == "U8": + lsl = self.srgb_to_lrgb(r, g, b) + r = lsl[0] + g = lsl[1] + b = lsl[2] + # sRGB to HSX + minval = min(r, g, b) + maxval = max(r, g, b) + luma= (self.luma_r*r + self.luma_g*g + self.luma_b*b) + luma_a = luma + chroma = maxval-minval + max_sat = 0.5 + if chroma == 0: + hue = self.angle_live + sat = 0 + else: + if maxval == r: + if minval == b: + hue = (g-b)/chroma + else: + hue = (g-b)/chroma + 6.0 + elif maxval == g: + hue = (b-r)/chroma + 2.0 + elif maxval == b: + hue = (r-g)/chroma + 4.0 + hue /=6.0 + # segment = 0.166667 + segment = 1/6 + if (hue > 1.0 or hue < 0.0): + hue = math.fmod(hue, 1.0) + if (hue>=0.0 and hue=segment and hue<(2.0*segment)): + max_sat = (self.luma_g+self.luma_r) - self.luma_r*((hue-segment)*6) + elif (hue>=(2.0*segment) and hue<(3.0*segment)): + max_sat = self.luma_g + self.luma_b*((hue-2.0*segment)*6) + elif (hue>=(3.0*segment) and hue<(4.0*segment)): + max_sat = (self.luma_b+self.luma_g) - self.luma_g*((hue-3.0*segment)*6) + elif (hue>=(4.0*segment) and hue<(5.0*segment)): + max_sat = (self.luma_b) + self.luma_r*((hue-4.0*segment)*6) + elif (hue>=(5.0*segment) and hue<=1.0): + max_sat = (self.luma_r+self.luma_b) - self.luma_b*((hue-5.0*segment)*6) + else: + max_sat=0.5 + + if(max_sat>1.0 or max_sat<0.0): + max_sat = math.fmod(max_sat, 1.0) + if luma <= max_sat: + luma_a = (luma/max_sat)*0.5 + else: + luma_a = ((luma-max_sat)/(1-max_sat)*0.5)+0.5 + + if (chroma > 0.0): + sat = ((chroma/(2*luma_a)) if (luma <= max_sat) else (chroma/(2.0-(2*luma_a)))) + if sat<=0.0: + sat=0.0 + if luma<=0.0: + luma=0.0 + h=hue + s=sat + y=luma**(1/self.gamma_y) + return [h, s, y] + def hsy_to_rgb(self, h, s, y): + hue = 0.0 + sat = 0.0 + luma = 0.0 + if ( h > 1.0 or h < 0.0): + hue = math.fmod(h, 1.0) + else: + hue = h + if s < 0.0: + sat = 0.0 + else: + sat = s + if y < 0.0: + luma = 0.0 + else: + luma = y**(self.gamma_y) + # segment = 0.166667 + segment = 1/6 + r=0.0 + g=0.0 + b=0.0 + if (hue >= 0.0 and hue < segment): + max_sat = self.luma_r + ( self.luma_g*(hue*6) ) + if luma <= max_sat: + luma_a = (luma/max_sat)*0.5 + chroma=sat*2*luma_a + else: + luma_a = ((luma-max_sat)/(1-max_sat)*0.5)+0.5 + chroma=sat*(2-2*luma_a) + + fract = hue*6.0 + x = (1-abs(math.fmod(fract, 2)-1))*chroma + r = chroma + g=x + b=0 + m = luma-( (self.luma_r*r)+(self.luma_b*b)+(self.luma_g*g) ) + r += m + g += m + b += m + elif (hue >= (segment) and hue < (2.0*segment)): + max_sat = (self.luma_g+self.luma_r) - (self.luma_r*(hue-segment)*6) + + if luma= (2.0*segment) and hue < (3.0*segment)): + max_sat = self.luma_g + (self.luma_b*(hue-2.0*segment)*6) + if luma= (3.0*segment) and hue < (4.0*segment)): + max_sat = (self.luma_g+self.luma_b) - (self.luma_g*(hue-3.0*segment)*6) + if luma= (4.0*segment) and hue < (5*segment)): + max_sat = self.luma_b + (self.luma_r*((hue-4.0*segment)*6)) + if luma= (5.0*segment) and hue <= 1.0): + max_sat = (self.luma_b+self.luma_r) - (self.luma_b*(hue-5.0*segment)*6) + if (luma= y: + p = y + y*c*(1-tm)/tm + o = y + y*c*(th-tm)/tm + n = y - (y*c) + else: + p = y + (1-y)*c + o = y + (1-y)*c*(th-tm)/(1-tm) + n = y - (1-y)*c*tm/(1-tm) + # Back to RGB order + if h < 1: + r = p + g = o + b = n + elif h < 2: + r = o + g = p + b = n + elif h < 3: + r = n + g = p + b = o + elif h < 4: + r = n + g = o + b = p + elif h < 5: + r = o + g = n + b = p + else: + r = p + g = n + b = o + # In case Krita is NOT in Linear Format + if self.d_cd != "U8": # == vs != + lsl = self.lrgb_to_srgb(r, g, b) + r = lsl[0] + g = lsl[1] + b = lsl[2] + return [r, g, b] + + + # XYZ (sRGB) ############################################################### + def rgb_to_xyz(self, r, g, b): + lrgb = self.srgb_to_lrgb(r, g, b) + x = (lrgb[0] * self.m_rgb_xyz[0][0]) + (lrgb[1] * self.m_rgb_xyz[0][1]) + (lrgb[2] * self.m_rgb_xyz[0][2]) + y = (lrgb[0] * self.m_rgb_xyz[1][0]) + (lrgb[1] * self.m_rgb_xyz[1][1]) + (lrgb[2] * self.m_rgb_xyz[1][2]) + z = (lrgb[0] * self.m_rgb_xyz[2][0]) + (lrgb[1] * self.m_rgb_xyz[2][1]) + (lrgb[2] * self.m_rgb_xyz[2][2]) + return [x, y, z] + def xyz_to_rgb(self, x, y, z): + var_r = (x * self.m_xyz_rgb[0][0]) + (y * self.m_xyz_rgb[0][1]) + (z * self.m_xyz_rgb[0][2]) + var_g = (x * self.m_xyz_rgb[1][0]) + (y * self.m_xyz_rgb[1][1]) + (z * self.m_xyz_rgb[1][2]) + var_b = (x * self.m_xyz_rgb[2][0]) + (y * self.m_xyz_rgb[2][1]) + (z * self.m_xyz_rgb[2][2]) + srgb = self.lrgb_to_srgb(var_r, var_g, var_b) + r = self.Math_1D_Limit(srgb[0]) + g = self.Math_1D_Limit(srgb[1]) + b = self.Math_1D_Limit(srgb[2]) + return [r, g, b] + # XYY + def xyz_to_xyy(self, x, y, z): + if (x == 0 and y == 0 and z == 0): + x1 = 0.31272660439158345 + y2 = 0.3290231524027522 + y3 = y + else: + x1 = x / ( x + y + z ) + y2 = y / ( x + y + z ) + y3 = y + return [x1, y2, y3] + def xyy_to_xyz(self, x1, y2, y3): + if y2 == 0: + x = 0 + y = 0 + z = 0 + else: + x = ( x1 * y3 ) / y2 + y = y3 + z = (( 1 - x1 - y2) * y3) / y2 + return [x, y, z] + # LUV ??????????????????????????????????????????? REF + def xyz_to_luv_old(self, x, y, z): + try: + vu = ( 4 * x ) / ( x + ( 15 * y ) + ( 3 * z ) ) + vv = ( 9 * y ) / ( x + ( 15 * y ) + ( 3 * z ) ) + vy = y / 100 + if vy > 0.008856: + vy = vy ** ( 1/3 ) + else: + vy = ( 7.787 * vy ) + ( 16 / 116 ) + ru = ( 4 * self.ref_x ) / ( self.ref_x + ( 15 * self.ref_y ) + ( 3 * self.ref_z ) ) + rv = ( 9 * self.ref_y ) / ( self.ref_x + ( 15 * self.ref_y ) + ( 3 * self.ref_z ) ) + l = ( 116 * vy ) - 16 + u = 13 * l * ( vu - ru ) + v = 13 * l * ( vv - rv ) + except: + l = 0 + u = 0 + v = 0 + return [l, u, v] + def luv_to_xyz_old(self, l, u, v): + try: + vy = ( l + 16 ) /116 + if (vy**3) > 0.008856: + vy = vy**3 + else: + vy = ( vy - 16 / 116 ) / 7.787 + ru = ( 4 * self.ref_x ) / ( self.ref_x + ( 15 * self.ref_y ) + ( 3 * self.ref_z ) ) + rv = ( 9 * self.ref_y ) / ( self.ref_x + ( 15 * self.ref_y ) + ( 3 * self.ref_z ) ) + vu = u / ( 13 * l ) + ru + vv = v / ( 13 * l ) + rv + y = vy * 100 + x = - ( 9 * y * vu ) / ( ( vu - 4 ) * vv - vu * vv ) + z = ( 9 * y - ( 15 * vv * y ) - ( vv * x ) ) / ( 3 * vv ) + except: + x = 0 + y = 0 + z = 0 + return [x, y, z] + + def xyz_to_luv(self, x, y, z): + k = 903.3 + e = 0.008856 + + try: + yr = y / self.ref_y + + ud = (4*x) / ( x + (15*y) + (3*z) ) + vd = (9*x) / ( x + (15*y) + (3*z) ) + + udr = ( 4 * self.ref_x ) / ( self.ref_x + ( 15 * self.ref_y ) + ( 3 * self.ref_z ) ) + vdr = ( 9 * self.ref_y ) / ( self.ref_x + ( 15 * self.ref_y ) + ( 3 * self.ref_z ) ) + + if yr > e: + l = 116 * yr**(1/3) - 16 + else: + l = k * yr + u = 13 * l * (ud - udr) + v = 13 * l * (vd - vdr) + except: + l = 0 + u = 0 + v = 0 + + QtCore.qWarning(str(x)+" | "+str(y)+" | "+str(z)) + QtCore.qWarning(str(l)+" | "+str(u)+" | "+str(v)) + QtCore.qWarning("-------------------------------------------------------") + + return [l, u, v] + def luv_to_xyz(self, l, u, v): + k = 903.3 + e = 0.008856 + + try: + if l > (k*e): + y = (( l + 16 ) / 116 )**3 + else: + y = l / k + + uo = ( 4 * self.ref_x ) / ( self.ref_x + ( 15 * self.ref_y ) + ( 3 * self.ref_z ) ) + vo = ( 9 * self.ref_y ) / ( self.ref_x + ( 15 * self.ref_y ) + ( 3 * self.ref_z ) ) + + a = (1/3) * ((( 52 * l )/( u + (13*l*uo) )) - 1 ) + b = -5*y + c = -(1/3) + d = y * ( (( 39 * l )/( v + (13*l*vo) )) - 5 ) + + x = (d - b) / (a - c) + z = (x*a) + b + except: + x = 0 + y = 0 + z = 0 + + return [x, y, z] + + # Hunter LAB ???????????????????????????????????? REF + def xyz_to_hlab(self, x, y, z): + va = ( 175.0 / 198.04 ) * ( self.ref_y + self.ref_x ) + vb = ( 70.0 / 218.11 ) * ( self.ref_y + self.ref_z ) + hl = 100.0 * sqrt( Y / self.ref_y ) + ha = va * ( ( ( x / self.ref_x ) - ( y / self.ref_y ) ) / math.sqrt( y / self.ref_y ) ) + hb = vb * ( ( ( y / self.ref_y ) - ( z / self.ref_z ) ) / math.sqrt( y / self.ref_y ) ) + return [hl, ha, hb] + def hlab_to_xyz(self, hl, ha, hb): + va = ( 175.0 / 198.04 ) * ( self.ref_y + self.ref_x ) + vb = ( 70.0 / 218.11 ) * ( self.ref_y + self.ref_z ) + y = ( ( hl / self.ref_y ) ** 2 ) * 100.0 + x = ( ha / va * math.sqrt( y / self.ref_y ) + ( y / self.ref_y ) ) * self.ref_x + z = - ( hb / vb * math.sqrt( y / self.ref_y ) - ( y / self.ref_y ) ) * self.ref_z + return [x, y, z] + # LAB ??????????????????????????????????????????? REF + def xyz_to_lab(self, x, y, z): + k = 903.3 # Kappa + e = 0.008856 # Epsilon + x_r = x / self.ref_x + y_r = y / self.ref_y + z_r = z / self.ref_z + if x_r > e: + f_x = x_r ** ( 1/3 ) + else: + f_x = ( k * x_r + 16) / 116 + if y_r > e: + f_y = y_r ** ( 1/3 ) + else: + f_y = ( k * y_r + 16 ) / 116 + if z_r > e: + f_z = z_r ** ( 1/3 ) + else: + f_z = ( k * z_r + 16 ) / 116 + l = (( 116 * f_y ) - 16) + a = ( f_x - f_y ) # 500 * ( f_x - f_y ) + b = ( f_y - f_z ) # 200 * ( f_y - f_z ) + l = l / 100 + a = 0.5 + a + b = 0.5 + b + return [l, a, b] + def lab_to_xyz(self, l, a, b): + k = 903.3 # Kappa + e = 0.008856 # Epsilon + l = l * 100 + a = a - 0.5 + b = b - 0.5 + f_y = ( l + 16 ) / 116 + f_x = a + f_y # ( a / 500 ) + f_y + f_z = f_y - b # f_y - ( b / 200 ) + if (f_x**3) > e: + x_r = f_x**3 + else: + x_r = (( 116 * f_x ) - 16 ) / k + if l > (k*e): + y_r = (( l + 16 ) / 116 )**3 + else: + y_r = l / k + if (f_z**3) > e: + z_r = f_z**3 + else: + z_r = ((116 * f_z) - 16 ) / k + x = x_r * self.ref_x + y = y_r * self.ref_y + z = z_r * self.ref_z + return [x, y, z] + def rgb_to_lab(self, r, g, b): + xyz = self.rgb_to_xyz(r, g, b) + lab = self.xyz_to_lab(xyz[0], xyz[1], xyz[2]) + return [lab[0], lab[1], lab[2]] + def lab_to_rgb(self, l, a, b): + xyz = self.lab_to_xyz(l, a, b) + rgb = self.xyz_to_rgb(xyz[0], xyz[1], xyz[2]) + return [rgb[0], rgb[1], rgb[2]] + # LCH ??????????????????????????????????????????? + def lab_to_lch(self, l, a, b): + vh = math.atan( b, a ) + if vh > 0: + vh = ( vh / math.pi ) * 180 + else: + vh = 360 - ( abs( vh ) / math.pi ) * 180 + l = l + c = math.sqrt( a ** 2 + b ** 2 ) + h = vh + return [l, c, h] + def lch_to_lab(self, l, c, h): + l = l + a = math.cos( radians(h) ) * c + b = math.sin( radians(h) ) * c + return [l, a, b] + def xyz_to_lch(self, x, y, z): + lab = self.xyz_to_lab(x, y, z) + lch = self.lab_to_lch(lab[0], lab[1], lab[2]) + return [lch[0], lch[1], lch[2]] + def lch_to_xyz(self, l, c, h): + lab = self.lch_to_lab(x, y, z) + xyz = self.lab_to_xyz(lab[0], lab[1], lab[2]) + return [xyz[0], xyz[1], xyz[2]] + + + # Luminosity Locks + def luma_lock_ard(self, hi, si, xi): + # Lock Values + hl = self.luma_lock_value[0] + sl = self.luma_lock_value[1] + xl = self.luma_lock_value[2] + rl, gl, bl = self.ard_to_rgb(hl, sl, xl) + aaa_l = self.rgb_to_aaa(rl, gl, bl)[0] + # Input Values + ri, gi, bi = self.ard_to_rgb(hi, sl, xl) + aaa_i = self.rgb_to_aaa(ri, gi, bi)[0] + # Create the Perceptual Grey of the Input Color + dri = ri - aaa_i + dgi = gi - aaa_i + dbi = bi - aaa_i + # Shift the Color to the correct level of Perceptual Gray (First Solve) + r = aaa_l + dri + g = aaa_l + dgi + b = aaa_l + dbi + # Full Saturation State Descrimination + sat = self.rgb_to_ard(r, g, b)[1] + if sat >= 1: + # HSV variation with maximum saturation + rs, gs, bs = self.ard_to_rgb(hi, 1, xi) + aaa_s = self.rgb_to_aaa(rs, gs, bs)[0] + # Create the Perceptual Grey of the Saturated Color + drs = rs - aaa_s + dgs = gs - aaa_s + dbs = bs - aaa_s + # Shift the Color to the correct level of Perceptual Gray (Second Solve) + r = aaa_l + drs + g = aaa_l + dgs + b = aaa_l + dbs + # Correct Excess Values + if r<=0: + r=0 + if r>=1: + r=1 + if g<=0: + g=0 + if g>=1: + g=1 + if b<=0: + b=0 + if b>=1: + b=1 + # Return Color Vector + return [r, g, b] + def luma_lock_hsv(self, hi, si, xi): + # Lock Values + hl = self.luma_lock_value[0] + sl = self.luma_lock_value[1] + xl = self.luma_lock_value[2] + rl, gl, bl = self.hsv_to_rgb(hl, sl, xl) + aaa_l = self.rgb_to_aaa(rl, gl, bl)[0] + # Input Values + ri, gi, bi = self.hsv_to_rgb(hi, sl, xl) + aaa_i = self.rgb_to_aaa(ri, gi, bi)[0] + # Create the Perceptual Grey of the Input Color + dri = ri - aaa_i + dgi = gi - aaa_i + dbi = bi - aaa_i + # Shift the Color to the correct level of Perceptual Gray (First Solve) + r = aaa_l + dri + g = aaa_l + dgi + b = aaa_l + dbi + # Full Saturation State Descrimination + sat = self.rgb_to_hsv(r, g, b)[1] + if sat >= 1: + # HSV variation with maximum saturation + rs, gs, bs = self.hsv_to_rgb(hi, 1, xi) + aaa_s = self.rgb_to_aaa(rs, gs, bs)[0] + # Create the Perceptual Grey of the Saturated Color + drs = rs - aaa_s + dgs = gs - aaa_s + dbs = bs - aaa_s + # Shift the Color to the correct level of Perceptual Gray (Second Solve) + r = aaa_l + drs + g = aaa_l + dgs + b = aaa_l + dbs + # Correct Excess Values + if r<=0: + r=0 + if r>=1: + r=1 + if g<=0: + g=0 + if g>=1: + g=1 + if b<=0: + b=0 + if b>=1: + b=1 + # Return Color Vector + return [r, g, b] + def luma_lock_hsl(self, hi, si, xi): + # Lock Values + hl = self.luma_lock_value[0] + sl = self.luma_lock_value[1] + xl = self.luma_lock_value[2] + rl, gl, bl = self.hsl_to_rgb(hl, sl, xl) + aaa_l = self.rgb_to_aaa(rl, gl, bl)[0] + # Input Values + ri, gi, bi = self.hsl_to_rgb(hi, sl, xl) + aaa_i = self.rgb_to_aaa(ri, gi, bi)[0] + # Create the Perceptual Grey of the Input Color + dri = ri - aaa_i + dgi = gi - aaa_i + dbi = bi - aaa_i + # Shift the Color to the correct level of Perceptual Gray (First Solve) + r = aaa_l + dri + g = aaa_l + dgi + b = aaa_l + dbi + # Full Saturation State Descrimination + sat = self.rgb_to_hsl(r, g, b)[1] + if sat >= 1: + # HSL variation with maximum saturation + rs, gs, bs = self.hsl_to_rgb(hi, 1, xi) + aaa_s = self.rgb_to_aaa(rs, gs, bs)[0] + # Create the Perceptual Grey of the Saturated Color + drs = rs - aaa_s + dgs = gs - aaa_s + dbs = bs - aaa_s + # Shift the Color to the correct level of Perceptual Gray (Second Solve) + r = aaa_l + drs + g = aaa_l + dgs + b = aaa_l + dbs + # Correct Excess Values + if r<=0: + r=0 + if r>=1: + r=1 + if g<=0: + g=0 + if g>=1: + g=1 + if b<=0: + b=0 + if b>=1: + b=1 + # Return Color Vector + return [r, g, b] + def luma_lock_hcy(self, hi, si, xi): + # Lock Values + hl = self.luma_lock_value[0] + sl = self.luma_lock_value[1] + xl = self.luma_lock_value[2] + rl, gl, bl = self.hcy_to_rgb(hl, sl, xl) + aaa_l = self.rgb_to_aaa(rl, gl, bl)[0] + # Input Values + ri, gi, bi = self.hcy_to_rgb(hi, sl, xl) + aaa_i = self.rgb_to_aaa(ri, gi, bi)[0] + # Create the Perceptual Grey of the Input Color + dri = ri - aaa_i + dgi = gi - aaa_i + dbi = bi - aaa_i + # Shift the Color to the correct level of Perceptual Gray (First Solve) + r = aaa_l + dri + g = aaa_l + dgi + b = aaa_l + dbi + # Full Saturation State Descrimination + sat = self.rgb_to_hcy(r, g, b)[1] + if sat >= 1: + # HSL variation with maximum saturation + rs, gs, bs = self.hcy_to_rgb(hi, 1, xi) + aaa_s = self.rgb_to_aaa(rs, gs, bs)[0] + # Create the Perceptual Grey of the Saturated Color + drs = rs - aaa_s + dgs = gs - aaa_s + dbs = bs - aaa_s + # Shift the Color to the correct level of Perceptual Gray (Second Solve) + r = aaa_l + drs + g = aaa_l + dgs + b = aaa_l + dbs + # Correct Excess Values + if r<=0: + r=0 + if r>=1: + r=1 + if g<=0: + g=0 + if g>=1: + g=1 + if b<=0: + b=0 + if b>=1: + b=1 + # Return Color Vector + return [r, g, b] + + #// + #\\ Trignometry ############################################################ + def Math_1D_Limit(self, var): + if var <= 0: + var = 0 + if var >= 1: + var = 1 + return var + def Math_1D_Loop(self, var): + if var <= 0: + var += 1 + if var >= 1: + var -= 1 + return var + def Math_1D_Lerp(self, v0, v1, t): + return (v0+t*(v1-v0)) + def Math_2D_Points_Distance(self, x1, y1, x2, y2): + dd = math.sqrt( math.pow((x1-x2),2) + math.pow((y1-y2),2) ) + return dd + def Math_2D_Points_Lines_Intersection(self, x1, y1, x2, y2, x3, y3, x4, y4): + try: + xx = ((x2*y1-x1*y2)*(x4-x3)-(x4*y3-x3*y4)*(x2-x1)) / ((x2-x1)*(y4-y3)-(x4-x3)*(y2-y1)) + yy = ((x2*y1-x1*y2)*(y4-y3)-(x4*y3-x3*y4)*(y2-y1)) / ((x2-x1)*(y4-y3)-(x4-x3)*(y2-y1)) + except: + xx = 0 + yy = 0 + return xx, yy + def Math_2D_Points_Lines_Angle(self, x1, y1, x2, y2, x3, y3): + v1 = (x1-x2, y1-y2) + v2 = (x3-x2, y3-y2) + v1_theta = math.atan2(v1[1], v1[0]) + v2_theta = math.atan2(v2[1], v2[0]) + angle = (v2_theta - v1_theta) * (180.0 / math.pi) + if angle < 0: + angle += 360.0 + return angle + def Math_2D_Centroid_Triangle(self, a1, a2, b1, b2, c1, c2): + cx = (a1+b1+c1)/3 + cy = (a2+b2+c2)/3 + return [cx, cy] + def Math_2D_Centroid_Square(self, a1, a2, b1, b2, c1, c2, d1, d2): + cx = (a1+b1+c1+d1)/4 + cy = (a2+b2+c2+d2)/4 + return [cx, cy] + def Math_3D_Points_Distance(self, x1, y1, z1, x2, y2, z2): + d = math.sqrt((x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2) + return d + + #// + #\\ Krita & Pigment ######################################################## + def Krita_TIMER(self): + self.timer_state = self.layout.state.currentIndex() + try: + if self.timer_state == 0: # ON + self.Krita_2_Pigment() + self.timer.start() + if self.timer_state == 1: # P>K + self.timer.stop() + if self.timer_state == 2: # OFF + self.timer.stop() + except: + pass + + def Krita_2_Pigment(self): + # Check Theme + krita_value = QApplication.palette().color(QPalette.Window).value() + if self.krita_value != krita_value: + # Update System Variable + self.krita_value = krita_value + # Contrast Gray Calculation + self.krita_contrast = self.gc(krita_value/255, krita_value/255, krita_value/255) * 255 + # RGB Code of contrast Gray + self.gray_natural = self.HEX_6string(self.krita_value,self.krita_value,self.krita_value) + self.gray_contrast = self.HEX_6string(self.krita_contrast,self.krita_contrast,self.krita_contrast) + + # Check Color + if ((self.canvas() is not None) and (self.canvas().view() is not None)): + lock = (self.luma_lock == True or self.ard_lock == True or self.kkk_lock == True or self.harmony_slot != 0) + if (self.timer_state == 0 and lock == False): + try: # To avoid the window change error miss match + # Check Eraser Mode ON or OFF + kritaEraserAction = Krita.instance().action("erase_action") + # Current Krita Foreground Color + fg_color = Krita.instance().activeWindow().activeView().foregroundColor() + fg_comp_order = fg_color.componentsOrdered() + d_cm = fg_color.colorModel() + d_cd = fg_color.colorDepth() + d_cp = fg_color.colorProfile() + # Current Krita Background Color + bg_color = Krita.instance().activeWindow().activeView().backgroundColor() + bg_comp_order = bg_color.componentsOrdered() + # Current Active Document + ad = Krita.instance().activeDocument() + # Hold UVD D depth for autocorrect error + self.d_previous = self.uvd_3 + # Update Pigmento if Colors Differs + if (d_cm == "A" or d_cm == "GRAYA"): + # Foreground and Background Colors + kac1 = fg_comp_order[0] + kbc1 = bg_comp_order[0] + # Verify conditions to change Pigment + var1 = (kac1 < (math.floor(self.aaa_1 * k_AAA)) / k_AAA or kac1 > (math.ceil(self.aaa_1 * k_AAA)) / k_AAA) + if (var1 == True or (d_cm != self.d_cm)): + if not kritaEraserAction.isChecked(): + self.angle_live = 0 + self.Color_APPLY("AAA", kac1, 0, 0, 0) + self.Pigment_Release() + if (kbc1 != self.aaa_bg1 or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + self.Color_BG("AAA", kbc1, 0, 0, 0) + self.Pigment_Release() + if d_cm == "RGBA": + # Foreground and Background Colors (Krita is in RGB) + kac1 = fg_comp_order[0] # Red + kac2 = fg_comp_order[1] # Green + kac3 = fg_comp_order[2] # Blue + kbc1 = bg_comp_order[0] + kbc2 = bg_comp_order[1] + kbc3 = bg_comp_order[2] + # Verify conditions to change Pigment + var1 = (kac1 < (math.floor(self.rgb_1 * k_RGB)) / k_RGB or kac1 > (math.ceil(self.rgb_1 * k_RGB)) / k_RGB) + var2 = (kac2 < (math.floor(self.rgb_2 * k_RGB)) / k_RGB or kac2 > (math.ceil(self.rgb_2 * k_RGB)) / k_RGB) + var3 = (kac3 < (math.floor(self.rgb_3 * k_RGB)) / k_RGB or kac3 > (math.ceil(self.rgb_3 * k_RGB)) / k_RGB) + if (var1 == True or var2 == True or var3 == True or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + # Check if NOT a GreyScale to memorize HUE + if (kac1 != kac2 or kac2 != kac3 or kac3 != kac1): + self.Color_HUE("RGB", kac1, kac2, kac3, 0) + # Change Pigment + self.Color_APPLY("RGB", kac1, kac2, kac3, 0) + # # Clean Percentage Label Display + self.Pigment_Release() + if (kbc1 != self.rgb_bg1 or kbc2 != self.rgb_bg2 or kbc3 != self.rgb_bg3 or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + # Background Color + self.Color_BG("RGB", kbc1, kbc2, kbc3, 0) + # # Clean Percentage Label Display + self.Pigment_Release() + if d_cm == "CMYKA": + # Foreground and Background Colors + kac1 = fg_comp_order[0] + kac2 = fg_comp_order[1] + kac3 = fg_comp_order[2] + kac4 = fg_comp_order[3] + kbc1 = bg_comp_order[0] + kbc2 = bg_comp_order[1] + kbc3 = bg_comp_order[2] + kbc4 = bg_comp_order[3] + # Verify conditions to change Pigment + var1 = (kac1 < (math.floor(self.cmyk_1 * k_CMYK)) / k_CMYK or kac1 > (math.ceil(self.cmyk_1 * k_CMYK)) / k_CMYK) + var2 = (kac2 < (math.floor(self.cmyk_2 * k_CMYK)) / k_CMYK or kac2 > (math.ceil(self.cmyk_2 * k_CMYK)) / k_CMYK) + var3 = (kac3 < (math.floor(self.cmyk_3 * k_CMYK)) / k_CMYK or kac3 > (math.ceil(self.cmyk_3 * k_CMYK)) / k_CMYK) + var4 = (kac4 < (math.floor(self.cmyk_4 * k_CMYK)) / k_CMYK or kac4 > (math.ceil(self.cmyk_4 * k_CMYK)) / k_CMYK) + if (var1 == True or var2 == True or var3 == True or var4 == True or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + if (kac1 != kac2 or kac2 != kac3 or kac3 != kac1): + self.Color_HUE("CMYK", kac1, kac2, kac3, kac4) + self.Color_APPLY("CMYK", kac1, kac2, kac3, kac4) + self.Pigment_Release() + if (kbc1 != self.cmyk_bg1 or kbc2 != self.cmyk_bg2 or kbc3 != self.cmyk_bg3 or kbc4 != self.cmyk_bg4 or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + self.Color_BG("CMYK", kbc1, kbc2, kbc3, kbc4) + self.Pigment_Release() + if d_cm == "YCbCrA": + # Foreground and Background Colors + kac1 = fg_comp_order[0] + kac2 = fg_comp_order[1] + kac3 = fg_comp_order[2] + kbc1 = bg_comp_order[0] + kbc2 = bg_comp_order[1] + kbc3 = bg_comp_order[2] + # Verify conditions to change Pigment + var1 = (kac1 < (math.floor(self.yuv_1 * k_YYY)) / k_YYY or kac1 > (math.ceil(self.yuv_1 * k_YYY)) / k_YYY) + var2 = (kac2 < (math.floor(self.yuv_2 * k_UV)) / k_UV or kac2 > (math.ceil(self.yuv_2 * k_UV)) / k_UV) + var3 = (kac3 < (math.floor(self.yuv_3 * k_UV)) / k_UV or kac3 > (math.ceil(self.yuv_3 * k_UV)) / k_UV) + if (var1 == True or var2 == True or var3 == True or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + if (kac1 != kac2 or kac2 != kac3 or kac3 != kac1): + self.Color_HUE("YUV", kac1, kac2, kac3, 0) + self.Color_APPLY("YUV", kac1, kac2, kac3, 0) + self.Pigment_Release() + if (kbc1 != self.yuv_bg1 or kbc2 != self.yuv_bg2 or kbc3 != self.yuv_bg3 or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + self.Color_BG("YUV", kbc1, kbc2, kbc3, 0) + self.Pigment_Release() + if d_cm == "XYZA": + # Foreground and Background Colors + kac1 = fg_comp_order[0] + kac2 = fg_comp_order[1] + kac3 = fg_comp_order[2] + kbc1 = bg_comp_order[0] + kbc2 = bg_comp_order[1] + kbc3 = bg_comp_order[2] + # Verify conditions to change Pigment + var1 = (kac1 < (math.floor(self.xyz_1 * k_XYZ)) / k_XYZ or kac1 > (math.ceil(self.xyz_1 * k_XYZ)) / k_XYZ) + var2 = (kac2 < (math.floor(self.xyz_2 * k_XYZ)) / k_XYZ or kac2 > (math.ceil(self.xyz_2 * k_XYZ)) / k_XYZ) + var3 = (kac3 < (math.floor(self.xyz_3 * k_XYZ)) / k_XYZ or kac3 > (math.ceil(self.xyz_3 * k_XYZ)) / k_XYZ) + if (var1 == True or var2 == True or var3 == True or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + if (kac1 != kac2 or kac2 != kac3 or kac3 != kac1): + self.Color_HUE("XYZ", kac1, kac2, kac3, 0) + self.Color_APPLY("XYZ", kac1, kac2, kac3, 0) + self.Pigment_Release() + if (kbc1 != self.xyz_bg1 or kbc2 != self.xyz_bg2 or kbc3 != self.xyz_bg3 or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + self.Color_BG("XYZ", kbc1, kbc2, kbc3, 0) + self.Pigment_Release() + if d_cm == "LABA": + # Foreground and Background Colors + kac1 = fg_comp_order[0] + kac2 = fg_comp_order[1] + kac3 = fg_comp_order[2] + kbc1 = bg_comp_order[0] + kbc2 = bg_comp_order[1] + kbc3 = bg_comp_order[2] + # Verify conditions to change Pigment + var1 = (kac1 < (math.floor(self.lab_1 * k_LLL)) / k_LLL or kac1 > (math.ceil(self.lab_1 * k_LLL)) / k_LLL) + var2 = (kac2 < (math.floor(self.lab_2 * k_AB)) / k_AB or kac2 > (math.ceil(self.lab_2 * k_AB)) / k_AB) + var3 = (kac3 < (math.floor(self.lab_3 * k_AB)) / k_AB or kac3 > (math.ceil(self.lab_3 * k_AB)) / k_AB) + if (var1 == True or var2 == True or var3 == True or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + if (kac1 != kac2 or kac2 != kac3 or kac3 != kac1): + self.Color_HUE("LAB", kac1, kac2, kac3, 0) + self.Color_APPLY("LAB", kac1, kac2, kac3, 0) + self.Pigment_Release() + if (kbc1 != self.lab_bg1 or kbc2 != self.lab_bg2 or kbc3 != self.lab_bg3 or d_cm != self.d_cm): + if not kritaEraserAction.isChecked(): + self.Color_BG("LAB", kbc1, kbc2, kbc3, 0) + self.Pigment_Release() + # Consider for next Cycle Variations + if (self.d_cm != d_cm or self.d_cd != d_cd or self.d_cp != d_cp): + # Update Values + self.d_cm = d_cm + self.d_cd = d_cd + self.d_cp = d_cp + # Correct Display if Document format changes + self.Menu_Inaccurate() + if self.ad != ad: + # Update Values + self.ad = ad + # Load Anotations for that Document + self.Settings_Load_Annotations() + except: + self.Default_Document() + else: + self.Default_Document() + else: + self.Default_Document() + + # Fill Check (case active node changes) + if ((self.canvas() is not None) and (self.canvas().view() is not None)): + try: + node = str(Krita.instance().activeDocument().activeNode().name()) + if (self.node != node and self.node != None): + try: + Krita.instance().activeDocument().nodeByName(self.node).setAlphaLocked(False) + except: + Krita.instance().activeDocument().activeNode().setAlphaLocked(False) + self.node = node + self.layout.fill.setChecked(False) + except: + pass + else: + self.node = None + def Pigment_2_Krita(self, release): + # Operating System case sensitive Hold Color until the controler is Released for Linux Users + check_release = self.performance_release == False or (self.performance_release == True and release == True) + if check_release == True: + # Check if there is a valid Document Active + if ((self.canvas() is not None) and (self.canvas().view() is not None)): + if (self.timer_state == 0 or self.timer_state == 1): + # Document Check + self.d_cm = Krita.instance().activeDocument().colorModel() + self.d_cd = Krita.instance().activeDocument().colorDepth() + self.d_cp = Krita.instance().activeDocument().colorProfile() + # Check Eraser Mode ON or OFF + kritaEraserAction = Krita.instance().action("erase_action") + # Manage Colors (This nullifies the Eraser if it is ON) + fg_color = ManagedColor(self.d_cm, self.d_cd, self.d_cp) + bg_color = ManagedColor(self.d_cm, self.d_cd, self.d_cp) + # Alpha mask + if (self.d_cm == "A" or self.d_cm == "GRAYA"): # Gray with self.bg_alpha channel + # Active Color Considerations + if self.harmony_slot == 0: + if self.kkk_lock == False: + kac1 = self.aaa_1 + if self.kkk_lock == True: + kac1 = self.aaa_k1 + if self.harmony_slot == 1: + if self.kkk_lock == False: + har_1 = self.rgb_to_aaa(self.har_1[1], self.har_1[2], self.har_1[3]) + kac1 = har_1[0] + if self.kkk_lock == True: + har_1 = self.rgb_to_aaa(self.har_k1[0], self.har_k1[1], self.har_k1[2]) + kac1 = har_1[0] + if self.harmony_slot == 2: + if self.kkk_lock == False: + har_2 = self.rgb_to_aaa(self.har_2[1], self.har_2[2], self.har_2[3]) + kac1 = har_2[0] + if self.kkk_lock == True: + har_2 = self.rgb_to_aaa(self.har_k2[0], self.har_k2[1], self.har_k2[2]) + kac1 = har_2[0] + if self.harmony_slot == 3: + if self.kkk_lock == False: + har_3 = self.rgb_to_aaa(self.har_3[1], self.har_3[2], self.har_3[3]) + kac1 = har_3[0] + if self.kkk_lock == True: + har_3 = self.rgb_to_aaa(self.har_k3[0], self.har_k3[1], self.har_k3[2]) + kac1 = har_3[0] + if self.harmony_slot == 4: + if self.kkk_lock == False: + har_4 = self.rgb_to_aaa(self.har_4[1], self.har_4[2], self.har_4[3]) + kac1 = har_4[0] + if self.kkk_lock == True: + har_4 = self.rgb_to_aaa(self.har_k4[0], self.har_k4[1], self.har_k4[2]) + kac1 = har_4[0] + if self.harmony_slot == 5: + if self.kkk_lock == False: + har_5 = self.rgb_to_aaa(self.har_5[1], self.har_5[2], self.har_5[3]) + kac1 = har_5[0] + if self.kkk_lock == True: + har_5 = self.rgb_to_aaa(self.har_k5[0], self.har_k5[1], self.har_k5[2]) + kac1 = har_5[0] + # Secondary Color Considerations + kbc1 = self.aaa_bg1 + # Manage Colors with Context + fg_color.setComponents([kac1, 1.0]) + bg_color.setComponents([kbc1, 1.0]) + if (self.d_cm == "RGBA" or self.d_cm == None): # RGB with self.bg_alpha channel (The actual order of channels is most often BGR!) + # Active Color Considerations + if self.harmony_slot == 0: + if self.kkk_lock == False: + kac1 = self.rgb_1 + kac2 = self.rgb_2 + kac3 = self.rgb_3 + if self.kkk_lock == True: + kac1 = self.rgb_k1 + kac2 = self.rgb_k2 + kac3 = self.rgb_k3 + if self.harmony_slot == 1: + if self.kkk_lock == False: + kac1 = self.har_1[1] + kac2 = self.har_1[2] + kac3 = self.har_1[3] + if self.kkk_lock == True: + kac1 = self.har_1[1] * self.kkk_r + kac2 = self.har_1[2] * self.kkk_g + kac3 = self.har_1[3] * self.kkk_b + if self.harmony_slot == 2: + if self.kkk_lock == False: + kac1 = self.har_2[1] + kac2 = self.har_2[2] + kac3 = self.har_2[3] + if self.kkk_lock == True: + kac1 = self.har_2[1] * self.kkk_r + kac2 = self.har_2[2] * self.kkk_g + kac3 = self.har_2[3] * self.kkk_b + if self.harmony_slot == 3: + if self.kkk_lock == False: + kac1 = self.har_3[1] + kac2 = self.har_3[2] + kac3 = self.har_3[3] + if self.kkk_lock == True: + kac1 = self.har_3[1] * self.kkk_r + kac2 = self.har_3[2] * self.kkk_g + kac3 = self.har_3[3] * self.kkk_b + if self.harmony_slot == 4: + if self.kkk_lock == False: + kac1 = self.har_4[1] + kac2 = self.har_4[2] + kac3 = self.har_4[3] + if self.kkk_lock == True: + kac1 = self.har_4[1] * self.kkk_r + kac2 = self.har_4[2] * self.kkk_g + kac3 = self.har_4[3] * self.kkk_b + if self.harmony_slot == 5: + if self.kkk_lock == False: + kac1 = self.har_5[1] + kac2 = self.har_5[2] + kac3 = self.har_5[3] + if self.kkk_lock == True: + kac1 = self.har_5[1] * self.kkk_r + kac2 = self.har_5[2] * self.kkk_g + kac3 = self.har_5[3] * self.kkk_b + # Secondary Color Considerations + kbc1 = self.rgb_bg1 + kbc2 = self.rgb_bg2 + kbc3 = self.rgb_bg3 + # Manage Colors with Context FG + fg_comp = fg_color.components() + if (self.d_cd == "U8" or self.d_cd == "U16"): + fg_comp[0] = kac3 + fg_comp[1] = kac2 + fg_comp[2] = kac1 + fg_comp[3] = 1 + if (self.d_cd == "F16" or self.d_cd == "F32"): + fg_comp[0] = kac1 + fg_comp[1] = kac2 + fg_comp[2] = kac3 + fg_comp[3] = 1 + fg_color.setComponents(fg_comp) + fg_display = fg_color.colorForCanvas(Krita.instance().activeWindow().activeView().canvas()) + # Display Colors + if self.performance_inaccurate == True: + self.disp_1 = self.rgb_1 + self.disp_2 = self.rgb_2 + self.disp_3 = self.rgb_3 + else: + self.disp_1 = fg_display.redF() + self.disp_2 = fg_display.greenF() + self.disp_3 = fg_display.blueF() + # Manage Colors with Context BG + bg_comp = bg_color.components() + if (self.d_cd == "U8" or self.d_cd == "U16"): + bg_comp[0] = kbc3 + bg_comp[1] = kbc2 + bg_comp[2] = kbc1 + bg_comp[3] = 1 + if (self.d_cd == "F16" or self.d_cd == "F32"): + bg_comp[0] = kbc1 + bg_comp[1] = kbc2 + bg_comp[2] = kbc3 + bg_comp[3] = 1 + bg_color.setComponents(bg_comp) + bg_display = bg_color.colorForCanvas(Krita.instance().activeWindow().activeView().canvas()) + # Display Colors + if self.performance_inaccurate == True: + self.disp_bg1 = self.rgb_bg1 + self.disp_bg2 = self.rgb_bg2 + self.disp_bg3 = self.rgb_bg3 + else: + self.disp_bg1 = bg_display.redF() + self.disp_bg2 = bg_display.greenF() + self.disp_bg3 = bg_display.blueF() + if self.d_cm == "CMYKA": # CMYK with self.bg_alpha channel + # Active Color Considerations + if self.harmony_slot == 0: + if self.kkk_lock == False: + kac1 = self.cmyk_1 + kac2 = self.cmyk_2 + kac3 = self.cmyk_3 + kac4 = self.cmyk_4 + if self.kkk_lock == True: + kac1 = self.cmyk_k1 + kac2 = self.cmyk_k2 + kac3 = self.cmyk_k3 + kac4 = self.cmyk_k4 + if self.harmony_slot == 1: + if self.kkk_lock == False: + har_1 = self.rgb_to_cmyk(self.har_1[1], self.har_1[2], self.har_1[3]) + kac1 = har_1[0] + kac2 = har_1[1] + kac3 = har_1[2] + kac4 = har_1[3] + if self.kkk_lock == True: + har_1 = self.rgb_to_cmyk(self.har_k1[0], self.har_k1[1], self.har_k1[2]) + kac1 = har_1[0] + kac2 = har_1[1] + kac3 = har_1[2] + kac4 = har_1[3] + if self.harmony_slot == 2: + if self.kkk_lock == False: + har_2 = self.rgb_to_cmyk(self.har_2[1], self.har_2[2], self.har_2[3]) + kac1 = har_2[0] + kac2 = har_2[1] + kac3 = har_2[2] + kac4 = har_2[3] + if self.kkk_lock == True: + har_2 = self.rgb_to_cmyk(self.har_k2[0], self.har_k2[1], self.har_k2[2]) + kac1 = har_2[0] + kac2 = har_2[1] + kac3 = har_2[2] + kac4 = har_2[3] + if self.harmony_slot == 3: + if self.kkk_lock == False: + har_3 = self.rgb_to_cmyk(self.har_3[1], self.har_3[2], self.har_3[3]) + kac1 = har_3[0] + kac2 = har_3[1] + kac3 = har_3[2] + kac4 = har_3[3] + if self.kkk_lock == True: + har_3 = self.rgb_to_cmyk(self.har_k3[0], self.har_k3[1], self.har_k3[2]) + kac1 = har_3[0] + kac2 = har_3[1] + kac3 = har_3[2] + kac4 = har_3[3] + if self.harmony_slot == 4: + if self.kkk_lock == False: + har_4 = self.rgb_to_cmyk(self.har_4[1], self.har_4[2], self.har_4[3]) + kac1 = har_4[0] + kac2 = har_4[1] + kac3 = har_4[2] + kac4 = har_4[3] + if self.kkk_lock == True: + har_4 = self.rgb_to_cmyk(self.har_k4[0], self.har_k4[1], self.har_k4[2]) + kac1 = har_4[0] + kac2 = har_4[1] + kac3 = har_4[2] + kac4 = har_4[3] + if self.harmony_slot == 5: + if self.kkk_lock == False: + har_5 = self.rgb_to_cmyk(self.har_5[1], self.har_5[2], self.har_5[3]) + kac1 = har_5[0] + kac2 = har_5[1] + kac3 = har_5[2] + kac4 = har_5[3] + if self.kkk_lock == True: + har_5 = self.rgb_to_cmyk(self.har_k5[0], self.har_k5[1], self.har_k5[2]) + kac1 = har_5[0] + kac2 = har_5[1] + kac3 = har_5[2] + kac4 = har_5[3] + # Secondary Color Considerations + kbc1 = self.cmyk_bg1 + kbc2 = self.cmyk_bg2 + kbc3 = self.cmyk_bg3 + kbc4 = self.cmyk_bg4 + # Manage Colors with Context FG + fg_comp = fg_color.components() + fg_comp[0] = kac1 + fg_comp[1] = kac2 + fg_comp[2] = kac3 + fg_comp[3] = kac4 + fg_comp[4] = 1 + fg_color.setComponents(fg_comp) + fg_display = fg_color.colorForCanvas(Krita.instance().activeWindow().activeView().canvas()) + self.disp_1 = fg_display.redF() + self.disp_2 = fg_display.greenF() + self.disp_3 = fg_display.blueF() + # Manage Colors with Context BG + bg_comp = bg_color.components() + bg_comp[0] = kbc1 + bg_comp[1] = kbc2 + bg_comp[2] = kbc3 + bg_comp[3] = kbc4 + bg_comp[4] = 1 + bg_color.setComponents(bg_comp) + bg_display = bg_color.colorForCanvas(Krita.instance().activeWindow().activeView().canvas()) + self.disp_bg1 = bg_display.redF() + self.disp_bg2 = bg_display.greenF() + self.disp_bg3 = bg_display.blueF() + if self.d_cm == "YCbCrA": # YCbCr with self.bg_alpha channel + # Active Color Considerations + if self.harmony_slot == 0: + if self.kkk_lock == False: + kac1 = self.yuv_1 + kac2 = self.yuv_2 + kac3 = self.yuv_3 + if self.kkk_lock == True: + kac1 = self.yuv_k1 + kac2 = self.yuv_k2 + kac3 = self.yuv_k3 + if self.harmony_slot == 1: + if self.kkk_lock == False: + har_1 = self.rgb_to_yuv(self.har_1[1], self.har_1[2], self.har_1[3]) + kac1 = har_1[0] + kac2 = har_1[1] + kac3 = har_1[2] + if self.kkk_lock == True: + har_1 = self.rgb_to_yuv(self.har_k1[0], self.har_k1[1], self.har_k1[2]) + kac1 = har_1[0] + kac2 = har_1[1] + kac3 = har_1[2] + if self.harmony_slot == 2: + if self.kkk_lock == False: + har_2 = self.rgb_to_yuv(self.har_2[1], self.har_2[2], self.har_2[3]) + kac1 = har_2[0] + kac2 = har_2[1] + kac3 = har_2[2] + if self.kkk_lock == True: + har_2 = self.rgb_to_yuv(self.har_k2[0], self.har_k2[1], self.har_k2[2]) + kac1 = har_2[0] + kac2 = har_2[1] + kac3 = har_2[2] + if self.harmony_slot == 3: + if self.kkk_lock == False: + har_3 = self.rgb_to_yuv(self.har_3[1], self.har_3[2], self.har_3[3]) + kac1 = har_3[0] + kac2 = har_3[1] + kac3 = har_3[2] + if self.kkk_lock == True: + har_3 = self.rgb_to_yuv(self.har_k3[0], self.har_k3[1], self.har_k3[2]) + kac1 = har_3[0] + kac2 = har_3[1] + kac3 = har_3[2] + if self.harmony_slot == 4: + if self.kkk_lock == False: + har_4 = self.rgb_to_yuv(self.har_4[1], self.har_4[2], self.har_4[3]) + kac1 = har_4[0] + kac2 = har_4[1] + kac3 = har_4[2] + if self.kkk_lock == True: + har_4 = self.rgb_to_yuv(self.har_k4[0], self.har_k4[1], self.har_k4[2]) + kac1 = har_4[0] + kac2 = har_4[1] + kac3 = har_4[2] + if self.harmony_slot == 5: + if self.kkk_lock == False: + har_5 = self.rgb_to_yuv(self.har_5[1], self.har_5[2], self.har_5[3]) + kac1 = har_5[0] + kac2 = har_5[1] + kac3 = har_5[2] + if self.kkk_lock == True: + har_5 = self.rgb_to_yuv(self.har_k5[0], self.har_k5[1], self.har_k5[2]) + kac1 = har_5[0] + kac2 = har_5[1] + kac3 = har_5[2] + # Secondary Color Considerations + kbc1 = self.yuv_bg1 + kbc2 = self.yuv_bg2 + kbc3 = self.yuv_bg3 + # Manage Colors with Context FG + fg_comp = fg_color.components() + fg_comp[0] = kac1 + fg_comp[1] = kac2 + fg_comp[2] = kac3 + fg_comp[3] = 1 + fg_color.setComponents(fg_comp) + fg_display = fg_color.colorForCanvas(Krita.instance().activeWindow().activeView().canvas()) + self.disp_1 = fg_display.redF() + self.disp_2 = fg_display.greenF() + self.disp_3 = fg_display.blueF() + # Manage Colors with Context BG + bg_comp = bg_color.components() + bg_comp[0] = kbc1 + bg_comp[1] = kbc2 + bg_comp[2] = kbc3 + bg_comp[3] = 1 + bg_color.setComponents(bg_comp) + bg_display = bg_color.colorForCanvas(Krita.instance().activeWindow().activeView().canvas()) + self.disp_bg1 = bg_display.redF() + self.disp_bg2 = bg_display.greenF() + self.disp_bg3 = bg_display.blueF() + if self.d_cm == "XYZA": # XYZ with self.bg_alpha channel + # Active Color Considerations + if self.harmony_slot == 0: + if self.kkk_lock == False: + kac1 = self.xyz_1 + kac2 = self.xyz_2 + kac3 = self.xyz_3 + if self.kkk_lock == True: + kac1 = self.xyz_k1 + kac2 = self.xyz_k2 + kac3 = self.xyz_k3 + if self.harmony_slot == 1: + if self.kkk_lock == False: + har_1 = self.rgb_to_xyz(self.har_1[1], self.har_1[2], self.har_1[3]) + kac1 = har_1[0] + kac2 = har_1[1] + kac3 = har_1[2] + if self.kkk_lock == True: + har_1 = self.rgb_to_xyz(self.har_k1[0], self.har_k1[1], self.har_k1[2]) + kac1 = har_1[0] + kac2 = har_1[1] + kac3 = har_1[2] + if self.harmony_slot == 2: + if self.kkk_lock == False: + har_2 = self.rgb_to_xyz(self.har_2[1], self.har_2[2], self.har_2[3]) + kac1 = har_2[0] + kac2 = har_2[1] + kac3 = har_2[2] + if self.kkk_lock == True: + har_2 = self.rgb_to_xyz(self.har_k2[0], self.har_k2[1], self.har_k2[2]) + kac1 = har_2[0] + kac2 = har_2[1] + kac3 = har_2[2] + if self.harmony_slot == 3: + if self.kkk_lock == False: + har_3 = self.rgb_to_xyz(self.har_3[1], self.har_3[2], self.har_3[3]) + kac1 = har_3[0] + kac2 = har_3[1] + kac3 = har_3[2] + if self.kkk_lock == True: + har_3 = self.rgb_to_xyz(self.har_k3[0], self.har_k3[1], self.har_k3[2]) + kac1 = har_3[0] + kac2 = har_3[1] + kac3 = har_3[2] + if self.harmony_slot == 4: + if self.kkk_lock == False: + har_4 = self.rgb_to_xyz(self.har_4[1], self.har_4[2], self.har_4[3]) + kac1 = har_4[0] + kac2 = har_4[1] + kac3 = har_4[2] + if self.kkk_lock == True: + har_4 = self.rgb_to_xyz(self.har_k4[0], self.har_k4[1], self.har_k4[2]) + kac1 = har_4[0] + kac2 = har_4[1] + kac3 = har_4[2] + if self.harmony_slot == 5: + if self.kkk_lock == False: + har_5 = self.rgb_to_xyz(self.har_5[1], self.har_5[2], self.har_5[3]) + kac1 = har_5[0] + kac2 = har_5[1] + kac3 = har_5[2] + if self.kkk_lock == True: + har_5 = self.rgb_to_xyz(self.har_k5[0], self.har_k5[1], self.har_k5[2]) + kac1 = har_5[0] + kac2 = har_5[1] + kac3 = har_5[2] + # Secondary Color Considerations + kbc1 = self.xyz_bg1 + kbc2 = self.xyz_bg2 + kbc3 = self.xyz_bg3 + # Manage Colors with Context FG + fg_comp = fg_color.components() + fg_comp[0] = kac1 + fg_comp[1] = kac2 + fg_comp[2] = kac3 + fg_comp[3] = 1 + fg_color.setComponents(fg_comp) + fg_display = fg_color.colorForCanvas(Krita.instance().activeWindow().activeView().canvas()) + self.disp_1 = fg_display.redF() + self.disp_2 = fg_display.greenF() + self.disp_3 = fg_display.blueF() + # Manage Colors with Context BG + bg_comp = bg_color.components() + bg_comp[0] = kbc1 + bg_comp[1] = kbc2 + bg_comp[2] = kbc3 + bg_comp[3] = 1 + bg_color.setComponents(bg_comp) + bg_display = bg_color.colorForCanvas(Krita.instance().activeWindow().activeView().canvas()) + self.disp_bg1 = bg_display.redF() + self.disp_bg2 = bg_display.greenF() + self.disp_bg3 = bg_display.blueF() + if self.d_cm == "LABA": # LAB with self.bg_alpha channel + # Active Color Considerations + if self.harmony_slot == 0: + if self.kkk_lock == False: + kac1 = self.lab_1 + kac2 = self.lab_2 + kac3 = self.lab_3 + if self.kkk_lock == True: + kac1 = self.lab_k1 + kac2 = self.lab_k2 + kac3 = self.lab_k3 + if self.harmony_slot == 1: + if self.kkk_lock == False: + har_1 = self.rgb_to_lab(self.har_1[1], self.har_1[2], self.har_1[3]) + kac1 = har_1[0] + kac2 = har_1[1] + kac3 = har_1[2] + if self.kkk_lock == True: + har_1 = self.rgb_to_lab(self.har_k1[0], self.har_k1[1], self.har_k1[2]) + kac1 = har_1[0] + kac2 = har_1[1] + kac3 = har_1[2] + if self.harmony_slot == 2: + if self.kkk_lock == False: + har_2 = self.rgb_to_lab(self.har_2[1], self.har_2[2], self.har_2[3]) + kac1 = har_2[0] + kac2 = har_2[1] + kac3 = har_2[2] + if self.kkk_lock == True: + har_2 = self.rgb_to_lab(self.har_k2[0], self.har_k2[1], self.har_k2[2]) + kac1 = har_2[0] + kac2 = har_2[1] + kac3 = har_2[2] + if self.harmony_slot == 3: + if self.kkk_lock == False: + har_3 = self.rgb_to_lab(self.har_3[1], self.har_3[2], self.har_3[3]) + kac1 = har_3[0] + kac2 = har_3[1] + kac3 = har_3[2] + if self.kkk_lock == True: + har_3 = self.rgb_to_lab(self.har_k3[0], self.har_k3[1], self.har_k3[2]) + kac1 = har_3[0] + kac2 = har_3[1] + kac3 = har_3[2] + if self.harmony_slot == 4: + if self.kkk_lock == False: + har_4 = self.rgb_to_lab(self.har_4[1], self.har_4[2], self.har_4[3]) + kac1 = har_4[0] + kac2 = har_4[1] + kac3 = har_4[2] + if self.kkk_lock == True: + har_4 = self.rgb_to_lab(self.har_k4[0], self.har_k4[1], self.har_k4[2]) + kac1 = har_4[0] + kac2 = har_4[1] + kac3 = har_4[2] + if self.harmony_slot == 5: + if self.kkk_lock == False: + har_5 = self.rgb_to_lab(self.har_5[1], self.har_5[2], self.har_5[3]) + kac1 = har_5[0] + kac2 = har_5[1] + kac3 = har_5[2] + if self.kkk_lock == True: + har_5 = self.rgb_to_lab(self.har_k5[0], self.har_k5[1], self.har_k5[2]) + kac1 = har_5[0] + kac2 = har_5[1] + kac3 = har_5[2] + # Secondary Color Considerations + kbc1 = self.lab_bg1 + kbc2 = self.lab_bg2 + kbc3 = self.lab_bg3 + # Manage Colors with Context FG + fg_comp = fg_color.components() + fg_comp[0] = kac1 + fg_comp[1] = kac2 + fg_comp[2] = kac3 + fg_comp[3] = 1 + fg_color.setComponents(fg_comp) + fg_display = fg_color.colorForCanvas(Krita.instance().activeWindow().activeView().canvas()) + self.disp_1 = fg_display.redF() + self.disp_2 = fg_display.greenF() + self.disp_3 = fg_display.blueF() + # Manage Colors with Context BG + bg_comp = bg_color.components() + bg_comp[0] = kbc1 + bg_comp[1] = kbc2 + bg_comp[2] = kbc3 + bg_comp[3] = 1 + bg_color.setComponents(bg_comp) + bg_display = bg_color.colorForCanvas(Krita.instance().activeWindow().activeView().canvas()) + self.disp_bg1 = bg_display.redF() + self.disp_bg2 = bg_display.greenF() + self.disp_bg3 = bg_display.blueF() + # Apply Colors to Krita + Krita.instance().activeWindow().activeView().setForeGroundColor(fg_color) + Krita.instance().activeWindow().activeView().setBackGroundColor(bg_color) + # If Eraser was true, set it ON again + if kritaEraserAction.isChecked(): + kritaEraserAction.trigger() + # Fill with Foreground Color + if self.fill == True: + Krita.instance().action('fill_selection_foreground_color_opacity').trigger() + else: + self.Default_Display() + else: + self.Default_Display() + else: + self.Default_Display() + + def Default_Display(self): + if self.kkk_lock == True: + self.disp_1 = self.rgb_k1 + self.disp_2 = self.rgb_k2 + self.disp_3 = self.rgb_k3 + else: + self.disp_1 = self.rgb_1 + self.disp_2 = self.rgb_2 + self.disp_3 = self.rgb_3 + self.disp_bg1 = self.rgb_bg1 + self.disp_bg2 = self.rgb_bg2 + self.disp_bg3 = self.rgb_bg3 + def Default_Document(self): + self.d_cm = "RGBA" + self.d_cd = "U8" + self.d_cp = "sRGB-elle-V2-srgtrc.icc" + self.ad = None + + #// + #\\ Color Paths ############################################################ + # Color Functions + def Color_HUE(self, mode, val1, val2, val3, val4): + if mode == "AAA": + hue = self.rgb_to_hue(val1, val1, val1) + if mode == "RGB": + hue = self.rgb_to_hue(val1, val2, val3) + if mode == "CMY": + rgb = self.cmy_to_rgb(val1, val2, val3) + hue = self.rgb_to_hue(rgb[0], rgb[1], rgb[2]) + if mode == "CMYK": + rgb = self.cmyk_to_rgb(val1, val2, val3, val4) + hue = self.rgb_to_hue(rgb[0], rgb[1], rgb[2]) + if mode == "RYB": + rgb = self.ryb_to_rgb(val1, val2, val3) + hue = self.rgb_to_hue(rgb[0], rgb[1], rgb[2]) + if mode == "YUV": + rgb = self.yuv_to_rgb(val1, val2, val3) + hue = self.rgb_to_hue(rgb[0], rgb[1], rgb[2]) + if (mode == "ARD" or mode == "HSV" or mode == "HSL" or mode == "HCY"): + hue = [val1] + if mode == "XYZ": + rgb = self.xyz_to_rgb(val1, val2, val3) + hue = self.rgb_to_hue(rgb[0], rgb[1], rgb[2]) + if mode == "XYY": + xyz = self.xyy_to_xyz(val1, val2, val3) + rgb = self.xyz_to_rgb(xyz[0], xyz[1], xyz[2]) + hue = self.rgb_to_hue(rgb[0], rgb[1], rgb[2]) + if mode == "LAB": + rgb = self.lab_to_rgb(val1, val2, val3) + hue = self.rgb_to_hue(rgb[0], rgb[1], rgb[2]) + self.angle_live = hue[0] + def Color_APPLY(self, mode, val1, val2, val3, val4): + #\\ Convert to RGB+XYZ + if (mode == "AAA" or mode == "A" or mode == "GRAYA"): + aaa = [val1] + rgb = [aaa[0], aaa[0], aaa[0]] + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if (mode == "RGB" or mode == "RGBA" or mode == "LOAD"): + rgb = [val1, val2, val3] + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if mode == "CMY": + cmy = [val1, val2, val3] + rgb = self.cmy_to_rgb(cmy[0], cmy[1], cmy[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if (mode == "CMYK" or mode == "CMYKA"): + cmyk = [val1, val2, val3, val4] + rgb = self.cmyk_to_rgb(cmyk[0], cmyk[1], cmyk[2], cmyk[3]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if mode == "RYB": + ryb = [val1, val2, val3] + rgb = self.ryb_to_rgb(ryb[0], ryb[1], ryb[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if (mode == "YUV" or mode == "YCbCrA"): + yuv = [val1, val2, val3] + rgb = self.yuv_to_rgb(yuv[0], yuv[1], yuv[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if mode == "KKK": + self.kkk_0 = val1 + if self.kkk_lock == True: + kkk = self.kkk_to_rgb(self.kkk_0) + rgb = [self.rgb_1, self.rgb_2, self.rgb_3] + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + else: # self.kkk_lock == False + kkk = [1, 1, 1] + rgb = self.kkk_to_rgb(self.kkk_0) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + self.kkk_r = kkk[0] + self.kkk_g = kkk[1] + self.kkk_b = kkk[2] + + if mode == "UVD": + uvd = [val1, val2, val3] + rgb = self.uvd_to_rgb(uvd[0], uvd[1], uvd[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if mode == "ARD": + ard = [val1, val2, val3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + self.angle_live = val1 + if mode == "HSV": + hsv = [val1, val2, val3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + self.angle_live = val1 + if mode == "HSL": + hsl = [val1, val2, val3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + self.angle_live = val1 + if mode == "HCY": + hcy = [val1, val2, val3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + self.angle_live = val1 + + if (mode == "XYZ" or mode == "XYZA"): + xyz = [val1, val2, val3] + rgb = self.xyz_to_rgb(xyz[0], xyz[1], xyz[2]) + if mode == "XYY": + xyy = [val1, val2, val3] + xyz = self.xyy_to_xyz(xyy[0], xyy[1], xyy[2]) + rgb = self.xyz_to_rgb(xyz[0], xyz[1], xyz[2]) + if (mode == "LAB" or mode == "LABA"): + lab = [val1, val2, val3] + xyz = self.lab_to_xyz(lab[0], lab[1], lab[2]) + rgb = self.lab_to_rgb(lab[0], lab[1], lab[2]) + #// + #\\ Convert RGB+XYZ into Other + if mode != "AAA": + aaa = self.rgb_to_aaa(rgb[0], rgb[1], rgb[2]) + if (mode != "RGB" or mode != "LOAD"): + pass + if mode != "CMY": + cmy = self.rgb_to_cmy(rgb[0], rgb[1], rgb[2]) + if mode != "CMYK": + cmyk = self.rgb_to_cmyk(rgb[0], rgb[1], rgb[2]) + if mode != "RYB": + ryb = self.rgb_to_ryb(rgb[0], rgb[1], rgb[2]) + if (mode != "YUV" and mode != "YCbCrA"): + yuv = self.rgb_to_yuv(rgb[0], rgb[1], rgb[2]) + if mode != "KKK": + kkk = self.kkk_to_rgb(self.kkk_0) + self.kkk_r = kkk[0] + self.kkk_g = kkk[1] + self.kkk_b = kkk[2] + + if mode != "UVD": + uvd = self.rgb_to_uvd(rgb[0], rgb[1], rgb[2]) + if mode != "ARD": + conv = self.rgb_to_ard(rgb[0], rgb[1], rgb[2]) + if (mode == "HSV" or mode == "HSL" or mode == "HCY"): + ard = [conv[0], conv[1], conv[2]] + else: + ard = [self.angle_live, conv[1], conv[2]] + if mode != "HSV": + conv = self.rgb_to_hsv(rgb[0], rgb[1], rgb[2]) + if (mode == "ARD" or mode == "HSL" or mode == "HCY"): + hsv = [conv[0], conv[1], conv[2]] + else: + hsv = [self.angle_live, conv[1], conv[2]] + if mode != "HSL": + conv = self.rgb_to_hsl(rgb[0], rgb[1], rgb[2]) + if (mode == "ARD" or mode == "HSV" or mode == "HCY"): + hsl = [conv[0], conv[1], conv[2]] + else: + hsl = [self.angle_live, conv[1], conv[2]] + if mode != "HCY": + conv = self.rgb_to_hcy(rgb[0], rgb[1], rgb[2]) + if (mode == "ARD" or mode == "HSV" or mode == "HSL"): + hcy = [conv[0], conv[1], conv[2]] + else: + hcy = [self.angle_live, conv[1], conv[2]] + + if (mode != "XYZ" and mode != "XYZA"): + pass + if mode != "XYY": + xyy = self.xyz_to_xyy(xyz[0], xyz[1], xyz[2]) + if (mode != "LAB" and mode != "LABA"): + lab = self.xyz_to_lab(xyz[0], xyz[1], xyz[2]) + #// + #\\ Variables + # Alpha + self.aaa_1 = aaa[0] + # RGB + self.rgb_1 = rgb[0] + self.rgb_2 = rgb[1] + self.rgb_3 = rgb[2] + # CMY + self.cmy_1 = cmy[0] + self.cmy_2 = cmy[1] + self.cmy_3 = cmy[2] + # CMYK + self.cmyk_1 = cmyk[0] + self.cmyk_2 = cmyk[1] + self.cmyk_3 = cmyk[2] + self.cmyk_4 = cmyk[3] + # RYB + self.ryb_1 = ryb[0] + self.ryb_2 = ryb[1] + self.ryb_3 = ryb[2] + # YUV + self.yuv_1 = yuv[0] + self.yuv_2 = yuv[1] + self.yuv_3 = yuv[2] + + # UVD + self.uvd_1 = uvd[0] + self.uvd_2 = uvd[1] + self.uvd_3 = uvd[2] + # ARD + self.ard_1 = ard[0] + self.ard_2 = ard[1] + self.ard_3 = ard[2] + # Correct random D depth + condition = self.uvd_3 - self.d_previous + if (condition > -u_SVL and condition < u_SVL): + self.uvd_3 = self.d_previous + self.ard_3 = self.d_previous + # HSV + self.hsv_1 = hsv[0] + self.hsv_2 = hsv[1] + self.hsv_3 = hsv[2] + # HSL + self.hsl_1 = hsl[0] + self.hsl_2 = hsl[1] + self.hsl_3 = hsl[2] + # HCY + self.hcy_1 = hcy[0] + self.hcy_2 = hcy[1] + self.hcy_3 = hcy[2] + + # XYZ + self.xyz_1 = xyz[0] + self.xyz_2 = xyz[1] + self.xyz_3 = xyz[2] + # XYY + self.xyy_1 = xyy[0] + self.xyy_2 = xyy[1] + self.xyy_3 = xyy[2] + # LAB + self.lab_1 = lab[0] + self.lab_2 = lab[1] + self.lab_3 = lab[2] + + # RGB Kelvin + self.rgb_k1 = self.rgb_1 * self.kkk_r + self.rgb_k2 = self.rgb_2 * self.kkk_g + self.rgb_k3 = self.rgb_3 * self.kkk_b + # AAA Kelvin + aaak = self.rgb_to_aaa(self.rgb_k1, self.rgb_k2, self.rgb_k3) + self.aaa_k1 = aaak[0] + # CMYK Kelvin + cmykk = self.rgb_to_cmyk(self.rgb_k1, self.rgb_k2, self.rgb_k3) + self.cmyk_k1 = cmykk[0] + self.cmyk_k2 = cmykk[1] + self.cmyk_k3 = cmykk[2] + self.cmyk_k4 = cmykk[3] + # YUV Kelvin + yuvk = self.rgb_to_yuv(self.rgb_k1, self.rgb_k2, self.rgb_k3) + self.yuv_k1 = yuvk[0] + self.yuv_k2 = yuvk[1] + self.yuv_k3 = yuvk[2] + # XYZ Kelvin + xyzk = self.rgb_to_xyz(self.rgb_k1, self.rgb_k2, self.rgb_k3) + self.xyz_k1 = xyzk[0] + self.xyz_k2 = xyzk[1] + self.xyz_k3 = xyzk[2] + # LAB Kelvin + labk = self.rgb_to_lab(self.rgb_k1, self.rgb_k2, self.rgb_k3) + self.lab_k1 = labk[0] + self.lab_k2 = labk[1] + self.lab_k3 = labk[2] + + #// + #\\ Pigment Update Values + self.Signal_Block(True) + self.Color_Harmony_Delta() + self.Pigment_Sync() + self.Pigment_2_Krita(False) + self.Pigment_Display() + self.Mixer_Display() + #// + def Color_BG(self, mode, val1, val2, val3, val4): + #\\ Convert to RGB+XYZ + if (mode == "AAA" or mode == "A" or mode == "GRAYA"): + self.aaa_bg1 = val1 + rgb = [val1, val1, val1] + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if (mode == "RGB" or mode == "RGBA"): + self.rgb_bg1 = val1 + self.rgb_bg2 = val2 + self.rgb_bg3 = val3 + rgb = [val1, val2, val3] + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if (mode == "CMYK" or mode == "CMYKA"): + self.cmyk_bg1 = val1 + self.cmyk_bg2 = val2 + self.cmyk_bg3 = val3 + self.cmyk_bg4 = val4 + rgb = self.cmyk_to_rgb(val1, val2, val3, val4) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if (mode == "YUV" or mode == "YCbCrA"): + self.yuv_bg1 = val1 + self.yuv_bg2 = val2 + self.yuv_bg3 = val3 + rgb = self.yuv_to_rgb(val1, val2, val3) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if (mode == "XYZ" or mode == "XYZA"): + self.xyz_bg1 = val1 + self.xyz_bg2 = val2 + self.xyz_bg3 = val3 + xyz = [val1, val2, val3] + rgb = self.xyz_to_rgb(xyz[0], xyz[1], xyz[2]) + if (mode == "LAB" or mode == "LABA"): + self.lab_bg1 = val1 + self.lab_bg2 = val2 + self.lab_bg3 = val3 + xyz = self.lab_to_xyz(val1, val2, val3) + rgb = self.xyz_to_rgb(xyz[0], xyz[1], xyz[2]) + #// + #\\ Convert RGB+XYZ into Other + if (mode != "AAA" or mode == "A" or mode == "GRAYA"): + aaa = self.gc(rgb[0], rgb[1], rgb[2]) + self.aaa_bg1 = aaa + if (mode != "RGB" or mode == "RGBA"): + self.rgb_bg1 = rgb[0] + self.rgb_bg2 = rgb[1] + self.rgb_bg3 = rgb[2] + if (mode != "CMYK" or mode == "CMYKA"): + cmyk = self.rgb_to_cmyk(rgb[0], rgb[1], rgb[2]) + self.cmyk_bg1 = cmyk[0] + self.cmyk_bg2 = cmyk[1] + self.cmyk_bg3 = cmyk[2] + self.cmyk_bg4 = cmyk[3] + if (mode != "YUV" or mode == "YCbCrA"): + yuv = self.rgb_to_yuv(rgb[0], rgb[1], rgb[2]) + self.yuv_bg1 = yuv[0] + self.yuv_bg2 = yuv[1] + self.yuv_bg3 = yuv[2] + if (mode != "XYZ" or mode == "XYZA"): + self.xyz_bg1 = xyz[0] + self.xyz_bg2 = xyz[1] + self.xyz_bg3 = xyz[2] + if (mode != "LAB" or mode == "LABA"): + lab = self.xyz_to_lab(xyz[0], xyz[1], xyz[2]) + self.lab_bg1 = lab[0] + self.lab_bg2 = lab[1] + self.lab_bg3 = lab[2] + #// + #\\ Display + self.Pigment_Sync() + self.Pigment_2_Krita(False) + self.Pigment_Display() + #// + # Color Operations + def Color_CONVERT(self, space_in, input, space_out): + # Input + if space_in == "AAA": + rgb = [input[0], input[0], input[0]] + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if space_in == "RGB": + rgb = [input[0], input[1], input[2]] + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if space_in == "CMY": + rgb = self.cmy_to_rgb(input[0], input[1], input[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if space_in == "CMYK": + rgb = self.cmyk_to_rgb(input[0], input[1], input[2], input[3]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if space_in == "RYB": + rgb = self.ryb_to_rgb(input[0], input[1], input[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if space_in == "YUV": + rgb = self.yuv_to_rgb(input[0], input[1], input[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if space_in == "ARD": + rgb = self.ard_to_rgb(input[0], input[1], input[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if space_in == "HSV": + rgb = self.hsv_to_rgb(input[0], input[1], input[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if space_in == "HSL": + rgb = self.hsl_to_rgb(input[0], input[1], input[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if space_in == "HCY": + rgb = self.hcy_to_rgb(input[0], input[1], input[2]) + xyz = self.rgb_to_xyz(rgb[0], rgb[1], rgb[2]) + if space_in == "XYZ": + xyz = [input[0], input[1], input[2]] + rgb = self.xyz_to_rgb(xyz[0], xyz[1], xyz[2]) + if space_in == "XYY": + xyz = self.xyy_to_xyz(input[0], input[1], input[2]) + rgb = self.xyz_to_rgb(xyz[0], xyz[1], xyz[2]) + if space_in == "LAB": + xyz = self.lab_to_xyz(input[0], input[1], input[2]) + rgb = self.xyz_to_rgb(xyz[0], xyz[1], xyz[2]) + + # Output + if space_out == "AAA": + output = self.rgb_to_aaa(rgb[0], rgb[1], rgb[2]) + if space_out == "RGB": + output = rgb + if space_out == "CMY": + output = self.rgb_to_cmy(rgb[0], rgb[1], rgb[2]) + if space_out == "CMYK": + output = self.rgb_to_cmyk(rgb[0], rgb[1], rgb[2]) + if space_out == "RYB": + output = self.rgb_to_ryb(rgb[0], rgb[1], rgb[2]) + if space_out == "YUV": + output = self.rgb_to_yuv(rgb[0], rgb[1], rgb[2]) + if space_out == "ARD": + output = self.rgb_to_ard(rgb[0], rgb[1], rgb[2]) + if space_out == "HSV": + output = self.rgb_to_hsv(rgb[0], rgb[1], rgb[2]) + if space_out == "HSL": + output = self.rgb_to_hsl(rgb[0], rgb[1], rgb[2]) + if space_out == "HCY": + output = self.rgb_to_hcy(rgb[0], rgb[1], rgb[2]) + if space_out == "XYZ": + output = xyz + if space_out == "XYY": + output = self.xyz_to_xyy(xyz[0], xyz[1], xyz[2]) + if space_out == "LAB": + output = self.xyz_to_lab(xyz[0], xyz[1], xyz[2]) + + # Return Output + return output + def Color_INTERPOLATE(self, space, factor, cor1, cor2): + # Calculations + if space == "AAA": + # Deltas + d0 = cor2[0] - cor1[0] + # Linear Interpolation + a = cor1[0] + (d0 * factor) + # Output + output = [a] + elif space == "CMYK": + # Deltas + d0 = cor2[0] - cor1[0] + d1 = cor2[1] - cor1[1] + d2 = cor2[2] - cor1[2] + d3 = cor2[3] - cor1[3] + # Linear Interpolation + a = cor1[0] + (d0 * factor) + b = cor1[1] + (d1 * factor) + c = cor1[2] + (d2 * factor) + d = cor1[3] + (d3 * factor) + # Output + output = [a, b, c, d] + elif (space == "ARD" or space == "HSV" or space == "HSL" or space == "HCY"): + # Hue + cor1 = [cor1[0], cor1[1], cor1[2]] + cor2 = [cor2[0], cor2[1], cor2[2]] + cond1 = cor2[0] - cor1[0] + cond2 = (cor1[0] + 1) - cor2[0] + if cor1[0] <= cor2[0]: + cond1 = cor2[0] - cor1[0] + cond2 = (cor1[0] + 1) - cor2[0] + if cond1 <= cond2: + a = cor1[0] + (factor * cond1) + else: + a = cor1[0] - (factor * cond2) + else: + cond1 = cor1[0] - cor2[0] + cond2 = (cor2[0] + 1) - cor1[0] + if cond1 <= cond2: + a = cor1[0] - (factor * cond1) + else: + a = cor1[0] + (factor * cond2) + if a < 0: + a = a + 1 + if a > 1: + a = a - 1 + # Deltas + d1 = cor2[1] - cor1[1] + d2 = cor2[2] - cor1[2] + # Linear Interpolation + b = cor1[1] + (d1 * factor) + c = cor1[2] + (d2 * factor) + # Output + output = [a, b, c] + else: + # Deltas + d0 = cor2[0] - cor1[0] + d1 = cor2[1] - cor1[1] + d2 = cor2[2] - cor1[2] + # Linear Interpolation + a = cor1[0] + (d0 * factor) + b = cor1[1] + (d1 * factor) + c = cor1[2] + (d2 * factor) + # Output + output = [a, b, c] + # Return + return output + # Color Harmonies + def Color_Complementary(self, SIGNAL_COLOR_COMPLEMENTARY): + # Calculate the Angle + if self.wheel == "CMY": + self.angle_live = self.Math_1D_Loop(self.angle_live + 0.5) + if self.wheel == "RYB": + self.angle_live = self.hryb_to_hcmy(self.Math_1D_Loop(self.hcmy_to_hryb(self.angle_live) + 0.5)) + # Apply Color + if self.harmony_space == "ARD": + self.Color_APPLY("ARD", self.angle_live, self.ard_2, self.ard_3, 0) + if self.harmony_space == "HSV": + self.Color_APPLY("HSV", self.angle_live, self.hsv_2, self.hsv_3, 0) + if self.harmony_space == "HSL": + self.Color_APPLY("HSL", self.angle_live, self.hsl_2, self.hsl_3, 0) + if self.harmony_space == "HCY": + self.Color_APPLY("HCY", self.angle_live, self.hcy_2, self.hcy_3, 0) + self.History_List(self.rgb_1, self.rgb_2, self.rgb_3) + def Color_Harmony_Delta(self): + """ + Harmony Value = ["HSL", rgb_1, rgb_2, rgb_3, hsl_1, hsl_2, hsl_3] + """ + # Do Calculations in the active color wheel + if self.wheel == "CMY": + angulus = self.angle_live + if self.wheel == "RYB": + angulus = self.hcmy_to_hryb(self.angle_live) + + # Harmony Index + self.harmony_rule = self.dialog.har_rule.currentText() + if self.harmony_rule == "Monochromatic": + if self.harmony_slot == 1: # Rotating Node + # Shared Angle + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + # 1 + if self.harmony_space == "ARD": + self.har_1 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.har_1 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.har_1 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.har_1 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hcy_2, self.hcy_3] + # 2 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_3[5], self.har_3[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_3[5], self.har_3[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_3[5], self.har_3[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_3[5], self.har_3[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 2: # Rotating Node + # Shared Angle + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + # 1 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.harmony_space == "ARD": + self.har_2 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.har_2 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.har_2 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.har_2 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hcy_2, self.hcy_3] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_3[5], self.har_3[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_3[5], self.har_3[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_3[5], self.har_3[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_3[5], self.har_3[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 3: # Rotating Node Major + # Shared Angle + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + # 1 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + self.har_3 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.har_3 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.har_3 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.har_3 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hcy_2, self.hcy_3] + # 4 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 4: # Rotating Node + # Shared Angle + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + # 1 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_3[5], self.har_3[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_3[5], self.har_3[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_3[5], self.har_3[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_3[5], self.har_3[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.harmony_space == "ARD": + self.har_4 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.har_4 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.har_4 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.har_4 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hcy_2, self.hcy_3] + # 5 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 5: # Rotating Node + # Shared Angle + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + # 1 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_3[5], self.har_3[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_3[5], self.har_3[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_3[5], self.har_3[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_3[5], self.har_3[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.harmony_space == "ARD": + self.har_5 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.har_5 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.har_5 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.har_5 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hcy_2, self.hcy_3] + if self.harmony_rule == "Complemantary": + if self.harmony_slot == 1: # Rotating Node + # 1 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + self.har_1 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.har_1 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.har_1 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.har_1 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hcy_2, self.hcy_3] + # 2 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_3[5], self.har_3[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_3[5], self.har_3[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_3[5], self.har_3[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_3[5], self.har_3[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 2: # Rotating Node + # 1 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + self.har_2 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.har_2 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.har_2 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.har_2 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hcy_2, self.hcy_3] + # 3 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_3[5], self.har_3[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_3[5], self.har_3[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_3[5], self.har_3[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_3[5], self.har_3[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 3: # Rotating Node Major + # 1 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + self.har_3 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.har_3 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.har_3 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.har_3 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hcy_2, self.hcy_3] + # 4 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 4: # Rotating Node + # 1 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_3[5], self.har_3[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_3[5], self.har_3[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_3[5], self.har_3[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_3[5], self.har_3[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + self.har_4 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.har_4 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.har_4 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.har_4 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hcy_2, self.hcy_3] + # 5 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 5: # Rotating Node Major + # 1 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.wheel == "CMY": + angle = angulus + 0.5 + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_3[5], self.har_3[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_3[5], self.har_3[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_3[5], self.har_3[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_3[5], self.har_3[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + self.har_5 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.har_5 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.har_5 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.har_5 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angle, self.hcy_2, self.hcy_3] + if self.harmony_rule == "Analogous": + if self.harmony_slot == 1: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 / 2 + if delta1 > delta2: + self.harmony_delta = delta2 / 2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] - (2 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (2 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + (2 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (2 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 2: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 + if delta1 > delta2: + self.harmony_delta = delta2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] - (2 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (2 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + (2 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (2 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 3: # Rotating Node Major + # 1 + angle = angulus - (2*self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angle) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + angle = angulus - (1*self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angle) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.wheel == "CMY": + self.har_3 = ["ARD", self.rgb_1, self.rgb_2, self.rgb_3, angulus, self.ard_2, self.ard_3] + if self.wheel == "RYB": + ard = [self.hryb_to_hcmy(angulus), self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.wheel == "CMY": + self.har_3 = ["HSV", self.rgb_1, self.rgb_2, self.rgb_3, angulus, self.hsv_2, self.hsv_3] + if self.wheel == "RYB": + hsv = [self.hryb_to_hcmy(angulus), self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.wheel == "CMY": + self.har_3 = ["HSL", self.rgb_1, self.rgb_2, self.rgb_3, angulus, self.hsl_2, self.hsl_3] + if self.wheel == "RYB": + hsl = [self.hryb_to_hcmy(angulus), self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.wheel == "CMY": + self.har_3 = ["HCY", self.rgb_1, self.rgb_2, self.rgb_3, angulus, self.hcy_2, self.hcy_3] + if self.wheel == "RYB": + hcy = [self.hryb_to_hcmy(angulus), self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + #4 + angle = angulus + (1*self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angle) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + angle = angulus + (2*self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angle) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 4: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 + if delta1 > delta2: + self.harmony_delta = delta2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] - (2 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (2 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + (2 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (2 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 5: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 / 2 + if delta1 > delta2: + self.harmony_delta = delta2 / 2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] - (2 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (2 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + (2 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (2 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_rule == "Split Complemantary": + if self.harmony_slot == 1: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 + if delta1 > delta2: + self.harmony_delta = delta2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 2: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 + if delta1 > delta2: + self.harmony_delta = delta2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 3: # Rotating Node Major + # 1 + angle = self.Math_1D_Loop(angulus - (1*self.harmony_delta)) + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angle) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + angle = self.Math_1D_Loop(angulus - (1*self.harmony_delta)) + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angle) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + angle = self.Math_1D_Loop(angulus + (1*self.harmony_delta)) + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angle) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + angle = self.Math_1D_Loop(angulus + (1*self.harmony_delta)) + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angle) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 4: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 + if delta1 > delta2: + self.harmony_delta = delta2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 5: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 + if delta1 > delta2: + self.harmony_delta = delta2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + 1 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4] + 1) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_rule == "Double Split Complemantary": + if self.harmony_slot == 1: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 + if delta1 > delta2: + self.harmony_delta = delta2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] - 0.5 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - 0.5 + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + 0.5 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + 0.5 - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 2: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 + if delta1 > delta2: + self.harmony_delta = delta2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] + 0.5 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + 0.5 + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + 0.5 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + 0.5 - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 3: # Rotating Node Major + # 1 + if self.wheel == "CMY": + angle = angulus - (1*self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus - (1*self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = angulus + 0.5 + (1*self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + 0.5 + (1*self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + angle = angulus + if self.wheel == "RYB": + angle = self.hryb_to_hcmy(angulus) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = angulus - 0.5 - (1*self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus - 0.5 - (1*self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = angulus + (1*self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = angulus + (1*self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 4: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 + if delta1 > delta2: + self.harmony_delta = delta2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] - 0.5 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - 0.5 + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] - 0.5 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - 0.5 - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + if self.harmony_slot == 5: + # Delta + value1 = angulus # A + if self.wheel == "CMY": + value2 = self.har_3[4] # O + if self.wheel == "RYB": + value2 = self.hcmy_to_hryb(self.har_3[4]) # O + value3 = value1 + 1 + value4 = value2 + 1 + if value1 <= value2: + delta1 = value2 - value1 + delta2 = value3 - value2 + if value1 > value2: + delta1 = value1 - value2 + delta2 = value4 - value1 + if delta1 <= delta2: + self.harmony_delta = delta1 + if delta1 > delta2: + self.harmony_delta = delta2 + # 1 + if self.wheel == "CMY": + angle = self.har_3[4] - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_1[5], self.har_1[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_1 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_1[5], self.har_1[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_1 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_1[5], self.har_1[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_1 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_1[5], self.har_1[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_1 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 2 + if self.wheel == "CMY": + angle = self.har_3[4] - 0.5 + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) - 0.5 + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_2[5], self.har_2[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_2 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_2[5], self.har_2[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_2 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_2[5], self.har_2[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_2 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_2[5], self.har_2[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_2 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 3 + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + ard = [self.har_3[4], self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_3 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsv = [self.har_3[4], self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_3 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hsl = [self.har_3[4], self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_3 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [self.har_3[4], self.har_3[5], self.har_3[6]] + else: + hcy = [self.har_3[4], self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_3 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 4 + if self.wheel == "CMY": + angle = self.har_3[4] + 0.5 - (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + 0.5 - (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_4[5], self.har_4[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_4 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_4[5], self.har_4[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_4 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_4[5], self.har_4[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_4 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_4[5], self.har_4[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_4 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + # 5 + if self.wheel == "CMY": + angle = self.har_3[4] + (1 * self.harmony_delta) + angle = self.Math_1D_Loop(angle) + if self.wheel == "RYB": + angle = self.hcmy_to_hryb(self.har_3[4]) + (1 * self.harmony_delta) + angle = self.hryb_to_hcmy(self.Math_1D_Loop(angle)) + if self.harmony_space == "ARD": + if self.harmony_edit == True: + ard = [angle, self.har_5[5], self.har_5[6]] + else: + ard = [angle, self.ard_2, self.ard_3] + rgb = self.ard_to_rgb(ard[0], ard[1], ard[2]) + self.har_5 = ["ARD", rgb[0], rgb[1], rgb[2], ard[0], ard[1], ard[2]] + if self.harmony_space == "HSV": + if self.harmony_edit == True: + hsv = [angle, self.har_5[5], self.har_5[6]] + else: + hsv = [angle, self.hsv_2, self.hsv_3] + rgb = self.hsv_to_rgb(hsv[0], hsv[1], hsv[2]) + self.har_5 = ["HSV", rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]] + if self.harmony_space == "HSL": + if self.harmony_edit == True: + hsl = [angle, self.har_5[5], self.har_5[6]] + else: + hsl = [angle, self.hsl_2, self.hsl_3] + rgb = self.hsl_to_rgb(hsl[0], hsl[1], hsl[2]) + self.har_5 = ["HSL", rgb[0], rgb[1], rgb[2], hsl[0], hsl[1], hsl[2]] + if self.harmony_space == "HCY": + if self.harmony_edit == True: + hcy = [angle, self.har_5[5], self.har_5[6]] + else: + hcy = [angle, self.hcy_2, self.hcy_3] + rgb = self.hcy_to_rgb(hcy[0], hcy[1], hcy[2]) + self.har_5 = ["HCY", rgb[0], rgb[1], rgb[2], hcy[0], hcy[1], hcy[2]] + + # Harmony Influenced by Kalvin + self.har_k1 = [self.har_1[1] * self.kkk_r, self.har_1[2] * self.kkk_g, self.har_1[3] * self.kkk_b] + self.har_k2 = [self.har_2[1] * self.kkk_r, self.har_2[2] * self.kkk_g, self.har_2[3] * self.kkk_b] + self.har_k3 = [self.har_3[1] * self.kkk_r, self.har_3[2] * self.kkk_g, self.har_3[3] * self.kkk_b] + self.har_k4 = [self.har_4[1] * self.kkk_r, self.har_4[2] * self.kkk_g, self.har_4[3] * self.kkk_b] + self.har_k5 = [self.har_5[1] * self.kkk_r, self.har_5[2] * self.kkk_g, self.har_5[3] * self.kkk_b] + def Color_Harmony_Span(self, span): + # Span + self.harmony_span = span + # Do Calculations in the active color wheel + if self.wheel == "CMY": + angulus = self.angle_live + if self.wheel == "RYB": + angulus = self.hcmy_to_hryb(self.angle_live) + + # Harmony Index + self.harmony_rule = self.dialog.har_rule.currentText() + if self.harmony_rule == "Analogous": + if self.harmony_slot == 1: + pass + if self.harmony_slot == 2: + pass + if self.harmony_slot == 3: # Rotating Node Major + pass + if self.harmony_slot == 4: + pass + if self.harmony_slot == 5: + pass + # Support Funtions + def Swap_BG(self): + if ((self.canvas() is not None) and (self.canvas().view() is not None)): + Krita.instance().action('toggle_fg_bg').trigger() + self.Krita_2_Pigment() + else: + a = [self.rgb_1, self.rgb_2, self.rgb_3] + b = [self.rgb_bg1, self.rgb_bg2, self.rgb_bg3] + self.Color_HUE("RGB", b[0], b[1], b[2], 0) + self.Color_APPLY("RGB", b[0], b[1], b[2], 0) + self.Color_BG("RGB", a[0], a[1], a[2], 0) + self.Pigment_Display() + self.Pigment_Release() + def Clear_Focus(self): + # HEX + self.layout.hex_string.clearFocus() + # AAA + self.layout.aaa_1_value.clearFocus() + # RGB + self.layout.rgb_1_value.clearFocus() + self.layout.rgb_2_value.clearFocus() + self.layout.rgb_3_value.clearFocus() + # CMY + self.layout.cmy_1_value.clearFocus() + self.layout.cmy_2_value.clearFocus() + self.layout.cmy_3_value.clearFocus() + # CMYK + self.layout.cmyk_1_value.clearFocus() + self.layout.cmyk_2_value.clearFocus() + self.layout.cmyk_3_value.clearFocus() + self.layout.cmyk_4_value.clearFocus() + # RYB + self.layout.ryb_1_value.clearFocus() + self.layout.ryb_2_value.clearFocus() + self.layout.ryb_3_value.clearFocus() + # YUV + self.layout.yuv_1_value.clearFocus() + self.layout.yuv_2_value.clearFocus() + self.layout.yuv_3_value.clearFocus() + # KKK + self.layout.kkk_1_value.clearFocus() + + # ARD + self.layout.ard_1_value.clearFocus() + self.layout.ard_2_value.clearFocus() + self.layout.ard_3_value.clearFocus() + # HSV + self.layout.hsv_1_value.clearFocus() + self.layout.hsv_2_value.clearFocus() + self.layout.hsv_3_value.clearFocus() + # HSL + self.layout.hsl_1_value.clearFocus() + self.layout.hsl_2_value.clearFocus() + self.layout.hsl_3_value.clearFocus() + # HCY + self.layout.hcy_1_value.clearFocus() + self.layout.hcy_2_value.clearFocus() + self.layout.hcy_3_value.clearFocus() + + # XYZ + self.layout.xyz_1_value.clearFocus() + self.layout.xyz_2_value.clearFocus() + self.layout.xyz_3_value.clearFocus() + # XYY + self.layout.xyy_1_value.clearFocus() + self.layout.xyy_2_value.clearFocus() + self.layout.xyy_3_value.clearFocus() + # LUV + self.layout.luv_1_value.clearFocus() + self.layout.luv_2_value.clearFocus() + self.layout.luv_3_value.clearFocus() + # HLAB + self.layout.hlab_1_value.clearFocus() + self.layout.hlab_2_value.clearFocus() + self.layout.hlab_3_value.clearFocus() + # LAB + self.layout.lab_1_value.clearFocus() + self.layout.lab_2_value.clearFocus() + self.layout.lab_3_value.clearFocus() + # LCH + self.layout.lch_1_value.clearFocus() + self.layout.lch_2_value.clearFocus() + self.layout.lch_3_value.clearFocus() + + #// + #\\ Sync Channels ########################################################## + def Pigment_Sync(self): + # Adjust Channels + self.Ratio_Channels() + # Set Values + self.Signal_Send_Channels() + # Set Panels + self.Signal_Send_Panels() + + # Signals + def Signal_Block(self, boolean): + # AAA + self.layout.aaa_1_slider.blockSignals(boolean) + self.layout.aaa_1_value.blockSignals(boolean) + # RGB + self.layout.rgb_1_slider.blockSignals(boolean) + self.layout.rgb_2_slider.blockSignals(boolean) + self.layout.rgb_3_slider.blockSignals(boolean) + self.layout.rgb_1_value.blockSignals(boolean) + self.layout.rgb_2_value.blockSignals(boolean) + self.layout.rgb_3_value.blockSignals(boolean) + # CMY + self.layout.cmy_1_slider.blockSignals(boolean) + self.layout.cmy_2_slider.blockSignals(boolean) + self.layout.cmy_3_slider.blockSignals(boolean) + self.layout.cmy_1_value.blockSignals(boolean) + self.layout.cmy_2_value.blockSignals(boolean) + self.layout.cmy_3_value.blockSignals(boolean) + # CMYK + self.layout.cmyk_1_slider.blockSignals(boolean) + self.layout.cmyk_2_slider.blockSignals(boolean) + self.layout.cmyk_3_slider.blockSignals(boolean) + self.layout.cmyk_4_slider.blockSignals(boolean) + self.layout.cmyk_1_value.blockSignals(boolean) + self.layout.cmyk_2_value.blockSignals(boolean) + self.layout.cmyk_3_value.blockSignals(boolean) + self.layout.cmyk_4_value.blockSignals(boolean) + # RYB + self.layout.ryb_1_slider.blockSignals(boolean) + self.layout.ryb_2_slider.blockSignals(boolean) + self.layout.ryb_3_slider.blockSignals(boolean) + self.layout.ryb_1_value.blockSignals(boolean) + self.layout.ryb_2_value.blockSignals(boolean) + self.layout.ryb_3_value.blockSignals(boolean) + # YUV + self.layout.yuv_1_slider.blockSignals(boolean) + self.layout.yuv_2_slider.blockSignals(boolean) + self.layout.yuv_3_slider.blockSignals(boolean) + self.layout.yuv_1_value.blockSignals(boolean) + self.layout.yuv_2_value.blockSignals(boolean) + self.layout.yuv_3_value.blockSignals(boolean) + # KKK + self.layout.kkk_1_slider.blockSignals(boolean) + self.layout.kkk_1_value.blockSignals(boolean) + + # ARD + self.layout.ard_1_slider.blockSignals(boolean) + self.layout.ard_2_slider.blockSignals(boolean) + self.layout.ard_3_slider.blockSignals(boolean) + self.layout.ard_1_value.blockSignals(boolean) + self.layout.ard_2_value.blockSignals(boolean) + self.layout.ard_3_value.blockSignals(boolean) + # HSV + self.layout.hsv_1_slider.blockSignals(boolean) + self.layout.hsv_2_slider.blockSignals(boolean) + self.layout.hsv_3_slider.blockSignals(boolean) + self.layout.hsv_1_value.blockSignals(boolean) + self.layout.hsv_2_value.blockSignals(boolean) + self.layout.hsv_3_value.blockSignals(boolean) + # HSL + self.layout.hsl_1_slider.blockSignals(boolean) + self.layout.hsl_2_slider.blockSignals(boolean) + self.layout.hsl_3_slider.blockSignals(boolean) + self.layout.hsl_1_value.blockSignals(boolean) + self.layout.hsl_2_value.blockSignals(boolean) + self.layout.hsl_3_value.blockSignals(boolean) + # HCY + self.layout.hcy_1_slider.blockSignals(boolean) + self.layout.hcy_2_slider.blockSignals(boolean) + self.layout.hcy_3_slider.blockSignals(boolean) + self.layout.hcy_1_value.blockSignals(boolean) + self.layout.hcy_2_value.blockSignals(boolean) + self.layout.hcy_3_value.blockSignals(boolean) + + # XYZ + self.layout.xyz_1_slider.blockSignals(boolean) + self.layout.xyz_2_slider.blockSignals(boolean) + self.layout.xyz_3_slider.blockSignals(boolean) + self.layout.xyz_1_value.blockSignals(boolean) + self.layout.xyz_2_value.blockSignals(boolean) + self.layout.xyz_3_value.blockSignals(boolean) + # XYY + self.layout.xyy_1_slider.blockSignals(boolean) + self.layout.xyy_2_slider.blockSignals(boolean) + self.layout.xyy_3_slider.blockSignals(boolean) + self.layout.xyy_1_value.blockSignals(boolean) + self.layout.xyy_2_value.blockSignals(boolean) + self.layout.xyy_3_value.blockSignals(boolean) + # # LUV + # self.layout.luv_1_slider.blockSignals(boolean) + # self.layout.luv_2_slider.blockSignals(boolean) + # self.layout.luv_3_slider.blockSignals(boolean) + # self.layout.luv_1_value.blockSignals(boolean) + # self.layout.luv_2_value.blockSignals(boolean) + # self.layout.luv_3_value.blockSignals(boolean) + # # HLAB + # self.layout.hlab_1_slider.blockSignals(boolean) + # self.layout.hlab_2_slider.blockSignals(boolean) + # self.layout.hlab_3_slider.blockSignals(boolean) + # self.layout.hlab_1_value.blockSignals(boolean) + # self.layout.hlab_2_value.blockSignals(boolean) + # self.layout.hlab_3_value.blockSignals(boolean) + # LAB + self.layout.lab_1_slider.blockSignals(boolean) + self.layout.lab_2_slider.blockSignals(boolean) + self.layout.lab_3_slider.blockSignals(boolean) + self.layout.lab_1_value.blockSignals(boolean) + self.layout.lab_2_value.blockSignals(boolean) + self.layout.lab_3_value.blockSignals(boolean) + # # LCH + # self.layout.lch_1_slider.blockSignals(boolean) + # self.layout.lch_2_slider.blockSignals(boolean) + # self.layout.lch_3_slider.blockSignals(boolean) + # self.layout.lch_1_value.blockSignals(boolean) + # self.layout.lch_2_value.blockSignals(boolean) + # self.layout.lch_3_value.blockSignals(boolean) + def Signal_Send_Channels(self): + # AAA + self.aaa_1_slider.Update(self.aaa_1, self.channel_width) + self.layout.aaa_1_value.setValue(self.aaa_1 * k_AAA) + # RGB + self.rgb_1_slider.Update(self.rgb_1, self.channel_width) + self.rgb_2_slider.Update(self.rgb_2, self.channel_width) + self.rgb_3_slider.Update(self.rgb_3, self.channel_width) + self.layout.rgb_1_value.setValue(self.rgb_1 * k_RGB) + self.layout.rgb_2_value.setValue(self.rgb_2 * k_RGB) + self.layout.rgb_3_value.setValue(self.rgb_3 * k_RGB) + # CMY + self.cmy_1_slider.Update(self.cmy_1, self.channel_width) + self.cmy_2_slider.Update(self.cmy_2, self.channel_width) + self.cmy_3_slider.Update(self.cmy_3, self.channel_width) + self.layout.cmy_1_value.setValue(self.cmy_1 * k_CMY) + self.layout.cmy_2_value.setValue(self.cmy_2 * k_CMY) + self.layout.cmy_3_value.setValue(self.cmy_3 * k_CMY) + # CMYK + self.cmyk_1_slider.Update(self.cmyk_1, self.channel_width) + self.cmyk_2_slider.Update(self.cmyk_2, self.channel_width) + self.cmyk_3_slider.Update(self.cmyk_3, self.channel_width) + self.cmyk_4_slider.Update(self.cmyk_4, self.channel_width) + self.layout.cmyk_1_value.setValue(self.cmyk_1 * k_CMYK) + self.layout.cmyk_2_value.setValue(self.cmyk_2 * k_CMYK) + self.layout.cmyk_3_value.setValue(self.cmyk_3 * k_CMYK) + self.layout.cmyk_4_value.setValue(self.cmyk_4 * k_CMYK) + # RYB + self.ryb_1_slider.Update(self.ryb_1, self.channel_width) + self.ryb_2_slider.Update(self.ryb_2, self.channel_width) + self.ryb_3_slider.Update(self.ryb_3, self.channel_width) + self.layout.ryb_1_value.setValue(self.ryb_1 * k_RYB) + self.layout.ryb_2_value.setValue(self.ryb_2 * k_RYB) + self.layout.ryb_3_value.setValue(self.ryb_3 * k_RYB) + # YUV + self.yuv_1_slider.Update(self.yuv_1, self.channel_width) + self.yuv_2_slider.Update(self.yuv_2, self.channel_width) + self.yuv_3_slider.Update(self.yuv_3, self.channel_width) + self.layout.yuv_1_value.setValue(self.yuv_1 * k_YYY) + self.layout.yuv_2_value.setValue(self.yuv_2 * k_UV) + self.layout.yuv_3_value.setValue(self.yuv_3 * k_UV) + # KKK + self.kkk_1_slider.Update((self.kkk_0-k_KKKmin)/k_KKKdelta, self.channel_width) + self.layout.kkk_1_value.setValue(self.kkk_0) + + # ARD + self.ard_1_slider.Update(self.ard_1, self.channel_width) + self.ard_2_slider.Update(self.ard_2, self.channel_width) + self.ard_3_slider.Update(self.ard_3, self.channel_width) + self.layout.ard_1_value.setValue(self.ard_1 * k_HUE) + self.layout.ard_2_value.setValue(self.ard_2 * k_SVL) + self.layout.ard_3_value.setValue(self.ard_3 * k_SVL) + # HSV + self.hsv_1_slider.Update(self.hsv_1, self.channel_width) + self.hsv_2_slider.Update(self.hsv_2, self.channel_width) + self.hsv_3_slider.Update(self.hsv_3, self.channel_width) + self.layout.hsv_1_value.setValue(self.hsv_1 * k_HUE) + self.layout.hsv_2_value.setValue(self.hsv_2 * k_SVL) + self.layout.hsv_3_value.setValue(self.hsv_3 * k_SVL) + # HSL + self.hsl_1_slider.Update(self.hsl_1, self.channel_width) + self.hsl_2_slider.Update(self.hsl_2, self.channel_width) + self.hsl_3_slider.Update(self.hsl_3, self.channel_width) + self.layout.hsl_1_value.setValue(self.hsl_1 * k_HUE) + self.layout.hsl_2_value.setValue(self.hsl_2 * k_SVL) + self.layout.hsl_3_value.setValue(self.hsl_3 * k_SVL) + # HCY + self.hcy_1_slider.Update(self.hcy_1, self.channel_width) + self.hcy_2_slider.Update(self.hcy_2, self.channel_width) + self.hcy_3_slider.Update(self.hcy_3, self.channel_width) + self.layout.hcy_1_value.setValue(self.hcy_1 * k_HUE) + self.layout.hcy_2_value.setValue(self.hcy_2 * k_SVL) + self.layout.hcy_3_value.setValue(self.hcy_3 * k_SVL) + + # XYZ + self.xyz_1_slider.Update(self.xyz_1, self.channel_width) + self.xyz_2_slider.Update(self.xyz_2, self.channel_width) + self.xyz_3_slider.Update(self.xyz_3, self.channel_width) + self.layout.xyz_1_value.setValue(self.xyz_1 * k_XYZ) + self.layout.xyz_2_value.setValue(self.xyz_2 * k_XYZ) + self.layout.xyz_3_value.setValue(self.xyz_3 * k_XYZ) + # XYY + self.xyy_1_slider.Update(self.xyy_1, self.channel_width) + self.xyy_2_slider.Update(self.xyy_2, self.channel_width) + self.xyy_3_slider.Update(self.xyy_3, self.channel_width) + self.layout.xyy_1_value.setValue(self.xyy_1 * k_XYY) + self.layout.xyy_2_value.setValue(self.xyy_2 * k_XYY) + self.layout.xyy_3_value.setValue(self.xyy_3 * k_XYY) + # # LUV + # self.luv_1_slider.Update(self.luv_1, self.channel_width) + # self.luv_2_slider.Update(self.luv_2, self.channel_width) + # self.luv_3_slider.Update(self.luv_3, self.channel_width) + # self.layout.luv_1_value.setValue(self.luv_1 * k_LUV) + # self.layout.luv_2_value.setValue(self.luv_2 * k_LUV) + # self.layout.luv_3_value.setValue(self.luv_3 * k_LUV) + # # HLAB + # self.hlab_1_slider.Update(self.hlab_1, self.channel_width) + # self.hlab_2_slider.Update(self.hlab_2, self.channel_width) + # self.hlab_3_slider.Update(self.hlab_3, self.channel_width) + # self.layout.hlab_1_value.setValue(self.hlab_1 * k_HLAB) + # self.layout.hlab_2_value.setValue(self.hlab_2 * k_HLAB) + # self.layout.hlab_3_value.setValue(self.hlab_3 * k_HLAB) + # LAB + self.lab_1_slider.Update(self.lab_1, self.channel_width) + self.lab_2_slider.Update(self.lab_2, self.channel_width) + self.lab_3_slider.Update(self.lab_3, self.channel_width) + self.layout.lab_1_value.setValue(self.lab_1 * k_LLL) + self.layout.lab_2_value.setValue(self.lab_2 * k_AB) + self.layout.lab_3_value.setValue(self.lab_3 * k_AB) + # # LCH + # self.lch_1_slider.Update(self.lch_1, self.channel_width) + # self.lch_2_slider.Update(self.lch_2, self.channel_width) + # self.lch_3_slider.Update(self.lch_3, self.channel_width) + # self.layout.lch_1_value.setValue(self.lch_1 * k_LCH) + # self.layout.lch_2_value.setValue(self.lch_2 * k_LCH) + # self.layout.lch_3_value.setValue(self.lch_3 * k_LCH) + def Signal_Send_Panels(self): + if self.panel_active == "SWA": + self.Update_Panel_SWA() + self.panel_swa.update() + if self.panel_active == "RGB": + self.Update_Panel_UVD() + self.panel_uvd.update() + if self.panel_active == "YUV": + self.Update_Panel_YUV() + self.panel_yuv.update() + if self.panel_active == "ARD": + self.Update_Panel_ARD() + self.panel_ard.update() + if self.panel_active == "HSV": + self.Update_Panel_HSV() + self.panel_hsv.update() + if self.panel_active == "HSL": + self.Update_Panel_HSL() + self.panel_hsl.update() + if self.panel_active == "HCY": + self.Update_Panel_HCY() + self.panel_hcy.update() + if self.panel_active == "HUE": + self.Update_Panel_HUE() + # Update Main + self.panel_hue_circle.update() + # Update Secondary + if self.panel_secondary == "DOT": + pass + if self.panel_secondary == "TRIANGLE": + self.panel_triangle.update() + if self.panel_secondary == "SQUARE": + self.panel_square.update() + if self.panel_secondary == "DIAMOND": + self.panel_diamond.update() + if self.panel_active == "GAM": + self.Update_Panel_GAM_Circle() + self.Update_Panel_GAM_Polygon(self.P1_S1, self.P1_S3, self.P1_S4, self.P2_S1, self.P3_S3) + self.panel_gam_polygon.update() + if self.panel_active == "DOT": + self.Update_Panel_DOT() + self.panel_dots.update() + if self.panel_active == "OBJ": + self.Object_Live() + + #// + #\\ Updates ################################################################ + def Update_Color_Header_1(self): + self.color_1.Update_1( + self.HEX_6string(self.disp_1, self.disp_2, self.disp_3), + self.layout.color_1.width(), + self.ui_30) + def Update_Color_Header_2(self): + # Luma Lock + natural = self.HEX_6string(self.aaa_1, self.aaa_1, self.aaa_1) + gc = self.gc(self.aaa_1, self.aaa_1, self.aaa_1) + contrast = self.HEX_6string(gc, gc,gc) + # Update + self.color_2.Update_2( + self.HEX_6string(self.disp_1, self.disp_2, self.disp_3), + self.luma_lock, + natural, + contrast, + self.layout.color_2.width(), + self.ui_30) + def Update_Color_Header_3(self): + self.color_3.Update_1( + self.HEX_6string(self.disp_bg1, self.disp_bg2, self.disp_bg3), + self.ui_100, + self.ui_30) + # Harmony + def Update_Harmony_Colors(self): + self.harmony_1.Update(self.layout.harmony_1.width(), self.layout.harmony_1.height()) + self.harmony_2.Update(self.layout.harmony_2.width(), self.layout.harmony_2.height()) + self.harmony_3.Update(self.layout.harmony_3.width(), self.layout.harmony_3.height()) + self.harmony_4.Update(self.layout.harmony_4.width(), self.layout.harmony_4.height()) + self.harmony_5.Update(self.layout.harmony_5.width(), self.layout.harmony_5.height()) + def Update_Harmony_Span(self): + self.harmony_0.Update( + self.harmony_span, + self.gray_contrast, + self.layout.harmony_0.width(), + ) + # SWA Update + def Update_Panel_SWA(self): + self.panel_swa.Update_Panel( + self.cotd_1, + self.cotd_2, + self.cotd_3, + self.cotd_4, + self.cotd_5, + self.HEX_6string(self.cotd_1[0], self.cotd_1[1], self.cotd_1[2]), + self.HEX_6string(self.cotd_2[0], self.cotd_2[1], self.cotd_2[2]), + self.HEX_6string(self.cotd_3[0], self.cotd_3[1], self.cotd_3[2]), + self.HEX_6string(self.cotd_4[0], self.cotd_4[1], self.cotd_4[2]), + self.HEX_6string(self.cotd_5[0], self.cotd_5[1], self.cotd_5[2]), + self.layout.panel_swa.width(), + self.layout.panel_swa.height(), + ) + # UVD Update + def Update_Panel_UVD(self): + # UVD points of interest + self.Hexagon_Points_UVD() + # Update Panel + self.panel_uvd.Update_Panel( + self.uvd_1, self.uvd_2, self.uvd_3, + self.PCC, + self.P1, self.P2, self.P3, self.P4, self.P5, self.P6, + self.P12, self.P23, self.P34, self.P45, self.P56, self.P61, + self.uvd_width, self.uvd_height, + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom + ) + def Hexagon_Points_UVD(self): + # Calculate Original Points + self.uvd_hexagon_origins(self.uvd_3) + # Panel Dimensions + self.uvd_width = self.layout.panel_uvd.width() + self.uvd_height = self.layout.panel_uvd.height() + w2 = self.uvd_width * 0.5 + h2 = self.uvd_height * 0.5 + if w2 >= h2: + side = h2 + if h2 > w2: + side = w2 + # Single Points + self.P1 = [w2 + (self.O1[0] * side), h2 + (self.O1[1] * side)] + self.P2 = [w2 + (self.O2[0] * side), h2 + (self.O2[1] * side)] + self.P3 = [w2 + (self.O3[0] * side), h2 + (self.O3[1] * side)] + self.P4 = [w2 + (self.O4[0] * side), h2 + (self.O4[1] * side)] + self.P5 = [w2 + (self.O5[0] * side), h2 + (self.O5[1] * side)] + self.P6 = [w2 + (self.O6[0] * side), h2 + (self.O6[1] * side)] + # Composed Points + self.PCC = [w2 + (self.OCC[0] * side), h2 + (self.OCC[1] * side)] + self.P12 = [w2 + (self.O12[0] * side), h2 + (self.O12[1] * side)] + self.P23 = [w2 + (self.O23[0] * side), h2 + (self.O23[1] * side)] + self.P34 = [w2 + (self.O34[0] * side), h2 + (self.O34[1] * side)] + self.P45 = [w2 + (self.O45[0] * side), h2 + (self.O45[1] * side)] + self.P56 = [w2 + (self.O56[0] * side), h2 + (self.O56[1] * side)] + self.P61 = [w2 + (self.O61[0] * side), h2 + (self.O61[1] * side)] + # YUV Update + def Update_Panel_YUV(self): + # Panel Display + c1 = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.yuv_to_rgb(self.yuv_1, 0, 1)) + c2 = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.yuv_to_rgb(self.yuv_1, 0, 0.5)) + c3 = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.yuv_to_rgb(self.yuv_1, 0, 0)) + c4 = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.yuv_to_rgb(self.yuv_1, 1, 1)) + c5 = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.yuv_to_rgb(self.yuv_1, 1, 0.5)) + c6 = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.yuv_to_rgb(self.yuv_1, 1, 0)) + # Update + self.panel_yuv.Update_Panel( + [self.yuv_1, self.yuv_2, self.yuv_3], + + self.HEX_6string(c1[0], c1[1], c1[2]), + self.HEX_6string(c2[0], c2[1], c2[2]), + self.HEX_6string(c3[0], c3[1], c3[2]), + self.HEX_6string(c4[0], c4[1], c4[2]), + self.HEX_6string(c5[0], c5[1], c5[2]), + self.HEX_6string(c6[0], c6[1], c6[2]), + + self.layout.panel_yuv.width(), + self.layout.panel_yuv.height(), + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + # ARD Update + def Update_Panel_ARD(self): + if self.panel_active == "ARD": + # ARD points of intrest + self.Hexagon_Points_ARD() + # Update Panel + self.panel_ard.Update_Panel( + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hue_to_rgb(self.angle_live)), + self.ard_2, self.ard_3, + self.T1, self.T2, self.T3, self.cross, + self.ard_w, self.ard_h, + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom + ) + def Hexagon_Points_ARD(self): + # Mask + self.ard_w = self.layout.panel_ard.width() + self.ard_h = self.layout.panel_ard.height() + hue = self.ard_1*360 + if hue < 0: + value = 60 + if (hue >= 0 and hue < 60): + value = 60 + (hue-0) + if (hue >= 60 and hue < 120): + value = 120 - (hue-60) + if (hue >= 120 and hue < 180): + value = 60 + (hue-120) + if (hue >= 180 and hue < 240): + value = 120 - (hue-180) + if (hue >= 240 and hue < 300): + value = 60 + (hue-240) + if (hue >= 300 and hue < 360): + value = 120 - (hue-300) + if hue >= 360: + value = 60 + vertex = 1 - (round(value) / 180) + # Triangle + self.T1 = [0, 0] + self.T2 = [0 , 1] + self.T3 = [1, vertex] + # Intersection + ddd = 1 - self.ard_3 + if ddd < vertex: + self.cross = self.Math_2D_Points_Lines_Intersection(0,0,1,vertex, 0,ddd,1,ddd) + elif ddd > vertex: + self.cross = self.Math_2D_Points_Lines_Intersection(0,1,1,vertex, 0,ddd,1,ddd) + else: + self.cross = [1, ddd] + # Updates + def Update_Panel_HSV(self): + self.panel_hsv.Update_Panel( + [self.angle_live, self.hsv_2, self.hsv_3], + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hue_to_rgb(self.angle_live)), + + self.harmony_render, + self.harmony_edit, + self.rgb_to_hsv(self.har_1[1], self.har_1[2], self.har_1[3]), + self.rgb_to_hsv(self.har_2[1], self.har_2[2], self.har_2[3]), + self.rgb_to_hsv(self.har_3[1], self.har_3[2], self.har_3[3]), + self.rgb_to_hsv(self.har_4[1], self.har_4[2], self.har_4[3]), + self.rgb_to_hsv(self.har_5[1], self.har_5[2], self.har_5[3]), + + self.layout.panel_hsv.width(), + self.layout.panel_hsv.height(), + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + def Update_Panel_HSL(self): + self.panel_hsl.Update_Panel( + [self.angle_live, self.hsl_2, self.hsl_3], + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hue_to_rgb(self.angle_live)), + + self.harmony_render, + self.harmony_edit, + self.rgb_to_hsl(self.har_1[1], self.har_1[2], self.har_1[3]), + self.rgb_to_hsl(self.har_2[1], self.har_2[2], self.har_2[3]), + self.rgb_to_hsl(self.har_3[1], self.har_3[2], self.har_3[3]), + self.rgb_to_hsl(self.har_4[1], self.har_4[2], self.har_4[3]), + self.rgb_to_hsl(self.har_5[1], self.har_5[2], self.har_5[3]), + + self.layout.panel_hsl.width(), + self.layout.panel_hsl.height(), + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + def Update_Panel_HCY(self): + self.panel_hcy.Update_Panel( + [self.angle_live, self.hcy_2, self.hcy_3], + # self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hue_to_rgb(self.angle_live)), + # self.rgb_to_aaa(*self.hue_to_rgb(self.angle_live))[0], + + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 1.0)), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 0.9)), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 0.8)), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 0.7)), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 0.6)), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 0.5)), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 0.4)), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 0.3)), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 0.2)), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 0.1)), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.angle_live, 1, 0.0)), + + self.harmony_render, + self.harmony_edit, + # self.rgb_to_hcy(self.har_1[1], self.har_1[2], self.har_1[3]), + # self.rgb_to_hcy(self.har_2[1], self.har_2[2], self.har_2[3]), + # self.rgb_to_hcy(self.har_3[1], self.har_3[2], self.har_3[3]), + # self.rgb_to_hcy(self.har_4[1], self.har_4[2], self.har_4[3]), + # self.rgb_to_hcy(self.har_5[1], self.har_5[2], self.har_5[3]), + + self.layout.panel_hcy.width(), + self.layout.panel_hcy.height(), + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + + + ######################################################################## + # width = 100 + # height = 100 + # pixelData = "b'" + # for ih in range(height): + # for iw in range(width): + # rgb = self.hcy_to_rgb(self.angle_live, iw/width, (1-ih)/height) + # + # a = str(hex(int(rgb[0]*255)))[2:4].zfill(2) + # b = str(hex(int(rgb[1]*255)))[2:4].zfill(2) + # c = str(hex(int(rgb[2]*255)))[2:4].zfill(2) + # pixelData = pixelData + "\x" + a + "\x" + b + "\x" + c + + # q_image = QImage(pixelData, width, height, QImage.Format_RGBA8888) + # self.panel_hcy.Update_Panel() + + # pass + # HUE Update + def Update_Panel_HUE(self): + # Hue of Color + hue = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hue_to_rgb(self.angle_live)) + # Hue Circle Colors + if self.hue_shine == True: + red = [1, 0, 0] + mag = [1, 0, 1] + blu = [0, 0, 1] + cya = [0, 1, 1] + gre = [0, 1, 0] + yel = [1, 1, 0] + ora = [1, 0.5, 0] + else: + red = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [1, 0, 0]) + mag = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [1, 0, 1]) + blu = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [0, 0, 1]) + cya = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [0, 1, 1]) + gre = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [0, 1, 0]) + yel = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [1, 1, 0]) + ora = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [1, 0.5, 0]) + # Hex String Ample + hex = self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])) + # Angles + if self.wheel == "CMY": + angle_h0 = self.angle_live + angle_h1 = self.har_1[4] # hsl_1 + angle_h2 = self.har_2[4] # hsl_1 + angle_h3 = self.har_3[4] # hsl_1 + angle_h4 = self.har_4[4] # hsl_1 + angle_h5 = self.har_5[4] # hsl_1 + if self.wheel == "RYB": + angle_h0 = self.hcmy_to_hryb(self.angle_live) + angle_h1 = self.hcmy_to_hryb(self.har_1[4]) + angle_h2 = self.hcmy_to_hryb(self.har_2[4]) + angle_h3 = self.hcmy_to_hryb(self.har_3[4]) + angle_h4 = self.hcmy_to_hryb(self.har_4[4]) + angle_h5 = self.hcmy_to_hryb(self.har_5[4]) + # Update Regular + if self.panel_secondary == "DOT": + pass + if self.panel_secondary == "TRIANGLE": + self.panel_triangle.Update_Panel( + [self.angle_live, self.hsl_2, self.hsl_3], + [hue[0], hue[1], hue[2]], + + self.harmony_render, + self.harmony_edit, + self.rgb_to_hsl(self.har_1[1], self.har_1[2], self.har_1[3]), + self.rgb_to_hsl(self.har_2[1], self.har_2[2], self.har_2[3]), + self.rgb_to_hsl(self.har_3[1], self.har_3[2], self.har_3[3]), + self.rgb_to_hsl(self.har_4[1], self.har_4[2], self.har_4[3]), + self.rgb_to_hsl(self.har_5[1], self.har_5[2], self.har_5[3]), + + self.layout.panel_triangle.width(), + self.layout.panel_triangle.height(), + hex, + self.zoom) + if self.panel_secondary == "SQUARE": + self.panel_square.Update_Panel( + [self.angle_live, self.hsv_2, self.hsv_3], + [hue[0], hue[1], hue[2]], + + self.harmony_render, + self.harmony_edit, + self.rgb_to_hsv(self.har_1[1], self.har_1[2], self.har_1[3]), + self.rgb_to_hsv(self.har_2[1], self.har_2[2], self.har_2[3]), + self.rgb_to_hsv(self.har_3[1], self.har_3[2], self.har_3[3]), + self.rgb_to_hsv(self.har_4[1], self.har_4[2], self.har_4[3]), + self.rgb_to_hsv(self.har_5[1], self.har_5[2], self.har_5[3]), + + self.layout.panel_square.width(), + self.layout.panel_square.height(), + hex, + self.zoom) + if self.panel_secondary == "DIAMOND": + self.panel_diamond.Update_Panel( + [self.angle_live, self.hsl_2, self.hsl_3], + [hue[0], hue[1], hue[2]], + + self.harmony_render, + self.harmony_edit, + self.rgb_to_hsl(self.har_1[1], self.har_1[2], self.har_1[3]), + self.rgb_to_hsl(self.har_2[1], self.har_2[2], self.har_2[3]), + self.rgb_to_hsl(self.har_3[1], self.har_3[2], self.har_3[3]), + self.rgb_to_hsl(self.har_4[1], self.har_4[2], self.har_4[3]), + self.rgb_to_hsl(self.har_5[1], self.har_5[2], self.har_5[3]), + + self.layout.panel_diamond.width(), + self.layout.panel_diamond.height(), + hex, + self.zoom) + # Update Circle + if self.harmony_slot == 0: + self.panel_hue_circle.Update_Panel( + self.wheel, + self.harmony_render, + self.harmony_rule, + angle_h0, + [hue[0], hue[1], hue[2]], + self.layout.panel_hue_circle.width(), + self.layout.panel_hue_circle.height(), + self.gray_natural, + self.gray_contrast) + if self.harmony_slot != 0: + self.panel_hue_circle.Update_Harmony_1( + self.wheel, + self.harmony_render, + self.harmony_rule, + angle_h1, + [self.har_1[1], self.har_1[2], self.har_1[3]], # rgb_1, rgb_2, rgb_3 + self.layout.panel_hue_circle.width(), + self.layout.panel_hue_circle.height(), + self.gray_natural, + self.gray_contrast) + self.panel_hue_circle.Update_Harmony_2( + self.wheel, + self.harmony_render, + self.harmony_rule, + angle_h2, + [self.har_2[1], self.har_2[2], self.har_2[3]], + self.layout.panel_hue_circle.width(), + self.layout.panel_hue_circle.height(), + self.gray_natural, + self.gray_contrast) + self.panel_hue_circle.Update_Harmony_3( + self.wheel, + self.harmony_render, + self.harmony_rule, + angle_h3, + [self.har_3[1], self.har_3[2], self.har_3[3]], + self.layout.panel_hue_circle.width(), + self.layout.panel_hue_circle.height(), + self.gray_natural, + self.gray_contrast) + self.panel_hue_circle.Update_Harmony_4( + self.wheel, + self.harmony_render, + self.harmony_rule, + angle_h4, + [self.har_4[1], self.har_4[2], self.har_4[3]], + self.layout.panel_hue_circle.width(), + self.layout.panel_hue_circle.height(), + self.gray_natural, + self.gray_contrast) + self.panel_hue_circle.Update_Harmony_5( + self.wheel, + self.harmony_render, + self.harmony_rule, + angle_h5, + [self.har_5[1], self.har_5[2], self.har_5[3]], + self.layout.panel_hue_circle.width(), + self.layout.panel_hue_circle.height(), + self.gray_natural, + self.gray_contrast) + self.panel_hue_circle.Update_Ring(red, mag, blu, cya, gre, yel, ora) + # Gamut Update + def Update_Panel_GAM_Circle(self): + # Update Circle for Angle + self.panel_gam_circle.Update_Panel( + self.gamut_angle, + self.P1_S1, + self.P1_S3, + self.P1_S4, + self.P2_S1, + self.P3_S3, + self.layout.panel_gam_circle.width(), + self.layout.panel_gam_circle.height(), + self.gray_natural, + self.gray_contrast + ) + def Update_Panel_GAM_Polygon(self, P1_S1, P1_S3, P1_S4, P2_S1, P3_S3): + # Polygon List Build + panel_gam_polygon_width = self.layout.panel_gam_polygon.width() + panel_gam_polygon_height = self.layout.panel_gam_polygon.height() + # Update Circle of Colors and Polygon + if self.wheel == "CMY": + if self.gamut_space == "ARD": + self.panel_gam_polygon.Update_Panel( + self.angle_live, + self.ard_2, + self.wheel, + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(0/360, 0, self.ard_3) ), # Gray + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(0/360, 1, self.ard_3) ), # Red + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(10/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(20/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(30/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(40/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(50/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(60/360, 1, self.ard_3) ), # Yellow + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(70/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(80/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(90/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(100/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(110/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(120/360, 1, self.ard_3) ), # Green + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(130/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(140/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(150/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(160/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(170/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(180/360, 1, self.ard_3) ), # Cyan + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(190/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(200/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(210/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(220/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(230/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(240/360, 1, self.ard_3) ), # Blue + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(250/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(260/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(270/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(280/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(290/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(300/360, 1, self.ard_3) ), # Magenta + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(310/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(320/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(330/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(340/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(350/360, 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(360/360, 1, self.ard_3) ), # Red + self.gamut_shape, + P1_S1, + P1_S3, + P1_S4, + P2_S1, + P3_S3, + panel_gam_polygon_width, + panel_gam_polygon_height, + self.gray_natural, + self.gray_contrast, + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + if self.gamut_space == "HSV": + self.panel_gam_polygon.Update_Panel( + self.angle_live, + self.hsv_2, + self.wheel, + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(0/360, 0, self.hsv_3) ), # Gray + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(0/360, 1, self.hsv_3) ), # Red + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(10/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(20/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(30/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(40/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(50/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(60/360, 1, self.hsv_3) ), # Yellow + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(70/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(80/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(90/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(100/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(110/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(120/360, 1, self.hsv_3) ), # Green + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(130/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(140/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(150/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(160/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(170/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(180/360, 1, self.hsv_3) ), # Cyan + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(190/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(200/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(210/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(220/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(230/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(240/360, 1, self.hsv_3) ), # Blue + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(250/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(260/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(270/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(280/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(290/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(300/360, 1, self.hsv_3) ), # Magenta + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(310/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(320/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(330/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(340/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(350/360, 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(360/360, 1, self.hsv_3) ), # Red + self.gamut_shape, + P1_S1, + P1_S3, + P1_S4, + P2_S1, + P3_S3, + panel_gam_polygon_width, + panel_gam_polygon_height, + self.gray_natural, + self.gray_contrast, + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + if self.gamut_space == "HSL": + self.panel_gam_polygon.Update_Panel( + self.angle_live, + self.hsl_2, + self.wheel, + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(0/360, 0, self.hsl_3) ), # Gray + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(0/360, 1, self.hsl_3) ), # Red + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(10/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(20/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(30/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(40/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(50/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(60/360, 1, self.hsl_3) ), # Yellow + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(70/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(80/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(90/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(100/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(110/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(120/360, 1, self.hsl_3) ), # Green + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(130/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(140/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(150/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(160/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(170/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(180/360, 1, self.hsl_3) ), # Cyan + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(190/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(200/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(210/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(220/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(230/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(240/360, 1, self.hsl_3) ), # Blue + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(250/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(260/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(270/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(280/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(290/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(300/360, 1, self.hsl_3) ), # Magenta + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(310/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(320/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(330/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(340/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(350/360, 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(360/360, 1, self.hsl_3) ), # Red + self.gamut_shape, + P1_S1, + P1_S3, + P1_S4, + P2_S1, + P3_S3, + panel_gam_polygon_width, + panel_gam_polygon_height, + self.gray_natural, + self.gray_contrast, + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + if self.gamut_space == "HCY": + self.panel_gam_polygon.Update_Panel( + self.angle_live, + self.hcy_2, + self.wheel, + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(0/360, 0, self.hcy_3) ), # Gray + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(0/360, 1, self.hcy_3) ), # Red + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(10/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(20/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(30/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(40/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(50/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(60/360, 1, self.hcy_3) ), # Yellow + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(70/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(80/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(90/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(100/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(110/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(120/360, 1, self.hcy_3) ), # Green + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(130/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(140/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(150/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(160/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(170/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(180/360, 1, self.hcy_3) ), # Cyan + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(190/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(200/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(210/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(220/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(230/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(240/360, 1, self.hcy_3) ), # Blue + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(250/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(260/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(270/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(280/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(290/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(300/360, 1, self.hcy_3) ), # Magenta + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(310/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(320/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(330/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(340/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(350/360, 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(360/360, 1, self.hcy_3) ), # Red + self.gamut_shape, + P1_S1, + P1_S3, + P1_S4, + P2_S1, + P3_S3, + panel_gam_polygon_width, + panel_gam_polygon_height, + self.gray_natural, + self.gray_contrast, + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + if self.wheel == "RYB": + if self.gamut_space == "ARD": + self.panel_gam_polygon.Update_Panel( + self.hcmy_to_hryb(self.angle_live), + self.ard_2, + self.wheel, + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(0/360), 0, self.ard_3) ), # Gray + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(0/360), 1, self.ard_3) ), # Red + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(10/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(20/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(30/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(40/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(50/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(60/360), 1, self.ard_3) ), # Yellow + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(70/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(80/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(90/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(100/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(110/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(120/360), 1, self.ard_3) ), # Green + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(130/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(140/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(150/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(160/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(170/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(180/360), 1, self.ard_3) ), # Cyan + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(190/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(200/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(210/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(220/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(230/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(240/360), 1, self.ard_3) ), # Blue + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(250/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(260/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(270/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(280/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(290/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(300/360), 1, self.ard_3) ), # Magenta + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(310/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(320/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(330/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(340/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(350/360), 1, self.ard_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.ard_to_rgb(self.hryb_to_hcmy(360/360), 1, self.ard_3) ), # Red + self.gamut_shape, + P1_S1, + P1_S3, + P1_S4, + P2_S1, + P3_S3, + panel_gam_polygon_width, + panel_gam_polygon_height, + self.gray_natural, + self.gray_contrast, + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + if self.gamut_space == "HSV": + self.panel_gam_polygon.Update_Panel( + self.hcmy_to_hryb(self.angle_live), + self.hsv_2, + self.wheel, + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(0/360), 0, self.hsv_3) ), # Gray + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(0/360), 1, self.hsv_3) ), # Red + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(10/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(20/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(30/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(40/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(50/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(60/360), 1, self.hsv_3) ), # Yellow + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(70/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(80/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(90/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(100/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(110/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(120/360), 1, self.hsv_3) ), # Green + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(130/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(140/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(150/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(160/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(170/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(180/360), 1, self.hsv_3) ), # Cyan + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(190/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(200/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(210/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(220/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(230/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(240/360), 1, self.hsv_3) ), # Blue + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(250/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(260/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(270/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(280/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(290/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(300/360), 1, self.hsv_3) ), # Magenta + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(310/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(320/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(330/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(340/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(350/360), 1, self.hsv_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsv_to_rgb(self.hryb_to_hcmy(360/360), 1, self.hsv_3) ), # Red + self.gamut_shape, + P1_S1, + P1_S3, + P1_S4, + P2_S1, + P3_S3, + panel_gam_polygon_width, + panel_gam_polygon_height, + self.gray_natural, + self.gray_contrast, + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + if self.gamut_space == "HSL": + self.panel_gam_polygon.Update_Panel( + self.hcmy_to_hryb(self.angle_live), + self.hsl_2, + self.wheel, + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(0/360), 0, self.hsl_3) ), # Gray + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(0/360), 1, self.hsl_3) ), # Red + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(10/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(20/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(30/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(40/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(50/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(60/360), 1, self.hsl_3) ), # Yellow + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(70/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(80/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(90/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(100/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(110/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(120/360), 1, self.hsl_3) ), # Green + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(130/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(140/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(150/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(160/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(170/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(180/360), 1, self.hsl_3) ), # Cyan + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(190/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(200/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(210/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(220/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(230/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(240/360), 1, self.hsl_3) ), # Blue + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(250/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(260/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(270/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(280/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(290/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(300/360), 1, self.hsl_3) ), # Magenta + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(310/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(320/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(330/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(340/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(350/360), 1, self.hsl_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hsl_to_rgb(self.hryb_to_hcmy(360/360), 1, self.hsl_3) ), # Red + self.gamut_shape, + P1_S1, + P1_S3, + P1_S4, + P2_S1, + P3_S3, + panel_gam_polygon_width, + panel_gam_polygon_height, + self.gray_natural, + self.gray_contrast, + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + if self.gamut_space == "HCY": + self.panel_gam_polygon.Update_Panel( + self.hcmy_to_hryb(self.angle_live), + self.hcy_2, + self.wheel, + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(0/360), 0, self.hcy_3) ), # Gray + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(0/360), 1, self.hcy_3) ), # Red + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(10/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(20/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(30/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(40/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(50/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(60/360), 1, self.hcy_3) ), # Yellow + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(70/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(80/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(90/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(100/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(110/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(120/360), 1, self.hcy_3) ), # Green + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(130/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(140/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(150/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(160/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(170/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(180/360), 1, self.hcy_3) ), # Cyan + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(190/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(200/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(210/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(220/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(230/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(240/360), 1, self.hcy_3) ), # Blue + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(250/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(260/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(270/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(280/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(290/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(300/360), 1, self.hcy_3) ), # Magenta + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(310/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(320/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(330/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(340/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(350/360), 1, self.hcy_3) ), + self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", self.hcy_to_rgb(self.hryb_to_hcmy(360/360), 1, self.hcy_3) ), # Red + self.gamut_shape, + P1_S1, + P1_S3, + P1_S4, + P2_S1, + P3_S3, + panel_gam_polygon_width, + panel_gam_polygon_height, + self.gray_natural, + self.gray_contrast, + self.HEX_6string( *self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3])), + self.zoom) + # DOT Update + def Update_Panel_DOT(self): + # Create Empty Matrix to Fill after + colors = [] + for i in range(0, self.dot_dimension): + colors.append([[0,0,0]] * self.dot_dimension) + # Variables + dd1 = self.dot_dimension - 1 + dd5 = self.dot_dimension * 0.5 + dd2f = math.floor(dd5) + dd2c = math.ceil(dd5) + # Middle Line interpolation (1, 2) + mid = [] + for i in range(0, self.dot_dimension): + # Calculations + color_left = self.Color_CONVERT("RGB", [self.dot_1[1], self.dot_1[2], self.dot_1[3]], self.dot_interpolation) + color_right = self.Color_CONVERT("RGB", [self.dot_2[1], self.dot_2[2], self.dot_2[3]], self.dot_interpolation) + interpolation = self.Color_INTERPOLATE(self.dot_interpolation, i/dd1, color_left, color_right) + cor = self.Color_CONVERT(self.dot_interpolation, interpolation, "RGB") + # Apply Values + mid.append( [cor[0], cor[1], cor[2]] ) + colors[i][dd2f] = [cor[0], cor[1], cor[2]] + # Top Gradient + for i in range(0, self.dot_dimension): + for j in range(0, dd2c): + color_left = self.Color_CONVERT("RGB", [self.dot_3[1], self.dot_3[2], self.dot_3[3]], self.dot_interpolation) + color_right = self.Color_CONVERT("RGB", mid[i], self.dot_interpolation) + interpolation = self.Color_INTERPOLATE(self.dot_interpolation, j/dd2f, color_left, color_right) + cor = self.Color_CONVERT(self.dot_interpolation, interpolation, "RGB") + colors[i][j] = [cor[0], cor[1], cor[2]] + # Bottom Gradient + for i in range(0, self.dot_dimension): + for j in range(0, dd2c): + color_left = self.Color_CONVERT("RGB", mid[i], self.dot_interpolation) + color_right = self.Color_CONVERT("RGB", [self.dot_4[1], self.dot_4[2], self.dot_4[3]], self.dot_interpolation) + interpolation = self.Color_INTERPOLATE(self.dot_interpolation, j/dd2f, color_left, color_right) + cor = self.Color_CONVERT(self.dot_interpolation, interpolation, "RGB") + colors[i][dd2f+j] = [cor[0], cor[1], cor[2]] + + # Updated Values + self.panel_dots.Update_Panel( + colors, + self.layout.panel_dot_mix.width(), + self.layout.panel_dot_mix.height() + ) + # OBJ Update + def Update_Panel_OBJ(self): + self.obj_w = self.layout.panel_obj_display.width() + self.obj_h = self.layout.panel_obj_display.height() + self.panel_obj_display.Set_Cursor( + self.obj_location_x, + self.obj_location_y, + self.obj_w, + self.obj_h, + ) + self.panel_obj_display.Set_Path( + self.path_bg_1, + self.path_bg_2, + self.path_bg_3, + self.path_dif_1, + self.path_dif_2, + self.path_dif_3, + self.path_dif_4, + self.path_dif_5, + self.path_dif_6, + self.path_fg_1, + self.path_fg_2, + self.path_fg_3, + ) + self.panel_obj_display.Set_Colors( + self.bg_1[self.obj_index], + self.bg_2[self.obj_index], + self.bg_3[self.obj_index], + self.dif_1[self.obj_index], + self.dif_2[self.obj_index], + self.dif_3[self.obj_index], + self.dif_4[self.obj_index], + self.dif_5[self.obj_index], + self.dif_6[self.obj_index], + self.fg_1[self.obj_index], + self.fg_2[self.obj_index], + self.fg_3[self.obj_index], + ) + # IMG Panel + def Update_Panel_IMG(self): + # Panel + self.img_w = self.layout.panel_img.width() + self.img_h = self.layout.panel_img.height() + self.panel_img.Set_Cursor( + self.img_grayscale, + self.img_w, + self.img_h, + ) + + #// + #\\ Display ################################################################ + def Pigment_Display(self): + # Color Display + self.Update_Color_Header_1() + self.layout.color_1.update() + self.Update_Color_Header_3() + self.layout.color_3.update() + + # Foreground Color + if self.panel_active == "FGC": + if self.kkk_lock == True: + conv = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_k1, self.rgb_k2, self.rgb_k3]) + else: # self.kkk_lock == False + conv = self.convert( self.d_cm, self.d_cd, self.d_cp, "RGB", [self.rgb_1, self.rgb_2, self.rgb_3]) + foreground_color = str("QWidget { background-color: rgb(%f, %f, %f); }" % (conv[0]*255, conv[1]*255, conv[2]*255)) + self.layout.panel_fgc.setStyleSheet(foreground_color) + + # Harmony + if self.harmony_rule != 0: + self.layout.harmony_1.setStyleSheet(str("QWidget { background-color: rgb(%f, %f, %f); }" % (self.har_1[1]*255, self.har_1[2]*255, self.har_1[3]*255))) + self.layout.harmony_2.setStyleSheet(str("QWidget { background-color: rgb(%f, %f, %f); }" % (self.har_2[1]*255, self.har_2[2]*255, self.har_2[3]*255))) + self.layout.harmony_3.setStyleSheet(str("QWidget { background-color: rgb(%f, %f, %f); }" % (self.har_3[1]*255, self.har_3[2]*255, self.har_3[3]*255))) + self.layout.harmony_4.setStyleSheet(str("QWidget { background-color: rgb(%f, %f, %f); }" % (self.har_4[1]*255, self.har_4[2]*255, self.har_4[3]*255))) + self.layout.harmony_5.setStyleSheet(str("QWidget { background-color: rgb(%f, %f, %f); }" % (self.har_5[1]*255, self.har_5[2]*255, self.har_5[3]*255))) + self.layout.color_harmonys.setStyleSheet(str("QWidget { background-color: %s; }" % (self.gray_natural))) + + # Color Language + hex = str( self.Pigment_2_HEX() ) + self.layout.hex_string.setText(hex) + self.Color_Names(hex) + self.Color_Kelvin() + + # AAA + if self.chan_aaa == True: + aaa1_grade = self.Gradient_RGB([0, 0, 0], [1, 1, 1]) + self.aaa_1_slider.Colors(aaa1_grade) + self.aaa_1_slider.update() + # RGB + if self.chan_rgb == True: + rgb1_grade = self.Gradient_RGB([0, self.rgb_2, self.rgb_3], [1, self.rgb_2, self.rgb_3]) + rgb2_grade = self.Gradient_RGB([self.rgb_1, 0, self.rgb_3], [self.rgb_1, 1, self.rgb_3]) + rgb3_grade = self.Gradient_RGB([self.rgb_1, self.rgb_2, 0], [self.rgb_1, self.rgb_2, 1]) + self.rgb_1_slider.Colors(rgb1_grade) + self.rgb_2_slider.Colors(rgb2_grade) + self.rgb_3_slider.Colors(rgb3_grade) + self.rgb_1_slider.update() + self.rgb_2_slider.update() + self.rgb_3_slider.update() + # CMY + if self.chan_cmy == True: + cmy1_grade = self.Gradient_CMY([0, self.cmy_2, self.cmy_3], [1, self.cmy_2, self.cmy_3]) + cmy2_grade = self.Gradient_CMY([self.cmy_1, 0, self.cmy_3], [self.cmy_1, 1, self.cmy_3]) + cmy3_grade = self.Gradient_CMY([self.cmy_1, self.cmy_2, 0], [self.cmy_1, self.cmy_2, 1]) + self.cmy_1_slider.Colors(cmy1_grade) + self.cmy_2_slider.Colors(cmy2_grade) + self.cmy_3_slider.Colors(cmy3_grade) + self.cmy_1_slider.update() + self.cmy_2_slider.update() + self.cmy_3_slider.update() + # CMYK + if self.chan_cmyk == True: + cmyk1_grade = self.Gradient_CMYK([0, self.cmyk_2, self.cmyk_3, self.cmyk_4], [1, self.cmyk_2, self.cmyk_3, self.cmyk_4]) + cmyk2_grade = self.Gradient_CMYK([self.cmyk_1, 0, self.cmyk_3, self.cmyk_4], [self.cmyk_1, 1, self.cmyk_3, self.cmyk_4]) + cmyk3_grade = self.Gradient_CMYK([self.cmyk_1, self.cmyk_2, 0, self.cmyk_4], [self.cmyk_1, self.cmyk_2, 1, self.cmyk_4]) + cmyk4_grade = self.Gradient_CMYK([self.cmyk_1, self.cmyk_2, self.cmyk_3, 0], [self.cmyk_1, self.cmyk_2, self.cmyk_3, 1]) + self.cmyk_1_slider.Colors(cmyk1_grade) + self.cmyk_2_slider.Colors(cmyk2_grade) + self.cmyk_3_slider.Colors(cmyk3_grade) + self.cmyk_4_slider.Colors(cmyk4_grade) + self.cmyk_1_slider.update() + self.cmyk_2_slider.update() + self.cmyk_3_slider.update() + self.cmyk_4_slider.update() + # RYB + if self.chan_ryb == True: + ryb1_grade = self.Gradient_RYB([0, self.ryb_2, self.ryb_3], [1, self.ryb_2, self.ryb_3]) + ryb2_grade = self.Gradient_RYB([self.ryb_1, 0, self.ryb_3], [self.ryb_1, 1, self.ryb_3]) + ryb3_grade = self.Gradient_RYB([self.ryb_1, self.ryb_2, 0], [self.ryb_1, self.ryb_2, 1]) + self.ryb_1_slider.Colors(ryb1_grade) + self.ryb_2_slider.Colors(ryb2_grade) + self.ryb_3_slider.Colors(ryb3_grade) + self.ryb_1_slider.update() + self.ryb_2_slider.update() + self.ryb_3_slider.update() + # YUV + if self.chan_yuv == True: + yuv1_grade = self.Gradient_YUV([0, self.yuv_2, self.yuv_3], [1, self.yuv_2, self.yuv_3]) + yuv2_grade = self.Gradient_YUV([self.yuv_1, 0, self.yuv_3], [self.yuv_1, 1, self.yuv_3]) + yuv3_grade = self.Gradient_YUV([self.yuv_1, self.yuv_2, 0], [self.yuv_1, self.yuv_2, 1]) + self.yuv_1_slider.Colors(yuv1_grade) + self.yuv_2_slider.Colors(yuv2_grade) + self.yuv_3_slider.Colors(yuv3_grade) + self.yuv_1_slider.update() + self.yuv_2_slider.update() + self.yuv_3_slider.update() + # KKK + if self.chan_kkk == True: + if self.kkk_lock == False: + kkk1_grade = self.Gradient_KKK(1, 1, 1) + if self.kkk_lock == True: + kkk1_grade = self.Gradient_KKK(self.rgb_1, self.rgb_2, self.rgb_3) + self.kkk_1_slider.Colors(kkk1_grade) + self.kkk_1_slider.update() + + # ARD + if self.chan_ard == True: + if self.hue_shine == True: + ard_r = [1,0,0] + ard_y = [1,1,0] + ard_g = [0,1,0] + ard_c = [0,1,1] + ard_b = [0,0,1] + ard_m = [1,0,1] + ard_z = [1,0,0] + else: + src = "RGB" + ard_r = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.ard_to_rgb(0, self.ard_2, self.ard_3) ) + ard_y = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.ard_to_rgb(60/360, self.ard_2, self.ard_3) ) + ard_g = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.ard_to_rgb(120/360, self.ard_2, self.ard_3) ) + ard_c = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.ard_to_rgb(180/360, self.ard_2, self.ard_3) ) + ard_b = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.ard_to_rgb(240/360, self.ard_2, self.ard_3) ) + ard_m = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.ard_to_rgb(300/360, self.ard_2, self.ard_3) ) + ard_z = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.ard_to_rgb(360/360, self.ard_2, self.ard_3) ) + ard2_grade = self.Gradient_ARD([self.ard_1, 0, self.ard_3], [self.ard_1, 1, self.ard_3]) + ard3_grade = self.Gradient_ARD([self.ard_1, self.ard_2, 0], [self.ard_1, self.ard_2, 1]) + self.ard_1_slider.Hues(ard_r, ard_y, ard_g, ard_c, ard_b, ard_m, ard_z) + self.ard_2_slider.Colors(ard2_grade) + self.ard_3_slider.Colors(ard3_grade) + self.ard_1_slider.update() + self.ard_2_slider.update() + self.ard_3_slider.update() + # HSV + if self.chan_hsv == True: + if self.hue_shine == True: + hsv_r = [1,0,0] + hsv_y = [1,1,0] + hsv_g = [0,1,0] + hsv_c = [0,1,1] + hsv_b = [0,0,1] + hsv_m = [1,0,1] + hsv_z = [1,0,0] + else: + src = "RGB" + hsv_r = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsv_to_rgb(0, self.hsv_2, self.hsv_3) ) + hsv_y = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsv_to_rgb(60/360, self.hsv_2, self.hsv_3) ) + hsv_g = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsv_to_rgb(120/360, self.hsv_2, self.hsv_3) ) + hsv_c = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsv_to_rgb(180/360, self.hsv_2, self.hsv_3) ) + hsv_b = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsv_to_rgb(240/360, self.hsv_2, self.hsv_3) ) + hsv_m = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsv_to_rgb(300/360, self.hsv_2, self.hsv_3) ) + hsv_z = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsv_to_rgb(360/360, self.hsv_2, self.hsv_3) ) + hsv2_grade = self.Gradient_HSV([self.hsv_1, 0, self.hsv_3], [self.hsv_1, 1, self.hsv_3]) + hsv3_grade = self.Gradient_HSV([self.hsv_1, self.hsv_2, 0], [self.hsv_1, self.hsv_2, 1]) + self.hsv_1_slider.Hues(hsv_r, hsv_y, hsv_g, hsv_c, hsv_b, hsv_m, hsv_z) + self.hsv_2_slider.Colors(hsv2_grade) + self.hsv_3_slider.Colors(hsv3_grade) + self.hsv_1_slider.update() + self.hsv_2_slider.update() + self.hsv_3_slider.update() + # HSL + if self.chan_hsl == True: + if self.hue_shine == True: + hsl_r = [1,0,0] + hsl_y = [1,1,0] + hsl_g = [0,1,0] + hsl_c = [0,1,1] + hsl_b = [0,0,1] + hsl_m = [1,0,1] + hsl_z = [1,0,0] + else: + src = "RGB" + hsl_r = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsl_to_rgb(0, self.hsl_2, self.hsl_3) ) + hsl_y = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsl_to_rgb(60/360, self.hsl_2, self.hsl_3) ) + hsl_g = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsl_to_rgb(120/360, self.hsl_2, self.hsl_3) ) + hsl_c = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsl_to_rgb(180/360, self.hsl_2, self.hsl_3) ) + hsl_b = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsl_to_rgb(240/360, self.hsl_2, self.hsl_3) ) + hsl_m = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsl_to_rgb(300/360, self.hsl_2, self.hsl_3) ) + hsl_z = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hsl_to_rgb(360/360, self.hsl_2, self.hsl_3) ) + hsl2_grade = self.Gradient_HSL([self.hsl_1, 0, self.hsl_3], [self.hsl_1, 1, self.hsl_3]) + hsl3_grade = self.Gradient_HSL([self.hsl_1, self.hsl_2, 0], [self.hsl_1, self.hsl_2, 1]) + self.hsl_1_slider.Hues(hsl_r, hsl_y, hsl_g, hsl_c, hsl_b, hsl_m, hsl_z) + self.hsl_2_slider.Colors(hsl2_grade) + self.hsl_3_slider.Colors(hsl3_grade) + self.hsl_1_slider.update() + self.hsl_2_slider.update() + self.hsl_3_slider.update() + # HCY + if self.chan_hcy == True: + if self.hue_shine == True: + hcy_r = [1,0,0] + hcy_y = [1,1,0] + hcy_g = [0,1,0] + hcy_c = [0,1,1] + hcy_b = [0,0,1] + hcy_m = [1,0,1] + hcy_z = [1,0,0] + else: + src = "RGB" + hcy_r = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hcy_to_rgb(0, self.hcy_2, self.hcy_3) ) + hcy_y = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hcy_to_rgb(60/360, self.hcy_2, self.hcy_3) ) + hcy_g = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hcy_to_rgb(120/360, self.hcy_2, self.hcy_3) ) + hcy_c = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hcy_to_rgb(180/360, self.hcy_2, self.hcy_3) ) + hcy_b = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hcy_to_rgb(240/360, self.hcy_2, self.hcy_3) ) + hcy_m = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hcy_to_rgb(300/360, self.hcy_2, self.hcy_3) ) + hcy_z = self.convert(self.d_cm, self.d_cd, self.d_cp, src, self.hcy_to_rgb(360/360, self.hcy_2, self.hcy_3) ) + hcy2_grade = self.Gradient_HCY([self.hcy_1, 0, self.hcy_3], [self.hcy_1, 1, self.hcy_3]) + hcy3_grade = self.Gradient_HCY([self.hcy_1, self.hcy_2, 0], [self.hcy_1, self.hcy_2, 1]) + self.hcy_1_slider.Hues(hcy_r, hcy_y, hcy_g, hcy_c, hcy_b, hcy_m, hcy_z) + self.hcy_2_slider.Colors(hcy2_grade) + self.hcy_3_slider.Colors(hcy3_grade) + self.hcy_1_slider.update() + self.hcy_2_slider.update() + self.hcy_3_slider.update() + + # XYZ + if self.chan_xyz == True: + xyz1_grade = self.Gradient_XYZ([0, self.xyz_2, self.xyz_3], [1, self.xyz_2, self.xyz_3]) + xyz2_grade = self.Gradient_XYZ([self.xyz_1, 0, self.xyz_3], [self.xyz_1, 1, self.xyz_3]) + xyz3_grade = self.Gradient_XYZ([self.xyz_1, self.xyz_2, 0], [self.xyz_1, self.xyz_2, 1]) + self.xyz_1_slider.Colors(xyz1_grade) + self.xyz_2_slider.Colors(xyz2_grade) + self.xyz_3_slider.Colors(xyz3_grade) + self.xyz_1_slider.update() + self.xyz_2_slider.update() + self.xyz_3_slider.update() + # XYY + if self.chan_xyy == True: + xyy1_grade = self.Gradient_XYY([0, self.xyy_2, self.xyy_3], [1, self.xyy_2, self.xyy_3]) + xyy2_grade = self.Gradient_XYY([self.xyy_1, 0, self.xyy_3], [self.xyy_1, 1, self.xyy_3]) + xyy3_grade = self.Gradient_XYY([self.xyy_1, self.xyy_2, 0], [self.xyy_1, self.xyy_2, 1]) + self.xyy_1_slider.Colors(xyy1_grade) + self.xyy_2_slider.Colors(xyy2_grade) + self.xyy_3_slider.Colors(xyy3_grade) + self.xyy_1_slider.update() + self.xyy_2_slider.update() + self.xyy_3_slider.update() + # LAB + if self.chan_lab == True: + lab1_grade = self.Gradient_LAB([0, self.lab_2, self.lab_3], [1, self.lab_2, self.lab_3]) + lab2_grade = self.Gradient_LAB([self.lab_1, 0, self.lab_3], [self.lab_1, 1, self.lab_3]) + lab3_grade = self.Gradient_LAB([self.lab_1, self.lab_2, 0], [self.lab_1, self.lab_2, 1]) + self.lab_1_slider.Colors(lab1_grade) + self.lab_2_slider.Colors(lab2_grade) + self.lab_3_slider.Colors(lab3_grade) + self.lab_1_slider.update() + self.lab_2_slider.update() + self.lab_3_slider.update() + def Pigment_Release(self): + # Apply color for users with Realease ON + self.Pigment_2_Krita(True) + # Dusplay Release Color and Luma Lock + self.Update_Color_Header_2() + self.layout.color_2.update() + # Zoom Reset + self.zoom = 0 + # Color Language + hex = str(self.layout.hex_string.text()) + self.Color_Names(hex) + self.Color_Kelvin() + # ARD Lock + if self.ard_lock == True: + self.ard_lock_value = [self.uvd_1, self.uvd_2] + # Save the new HSX LOCK values + if (self.luma_lock == True and self.hsl_2 < 1): + self.AAA_1_Value_Lock() + # Gamut Verticies + self.P1_S1 = self.P1_S1_r + self.P1_S3 = self.P1_S3_r + self.P1_S4 = self.P1_S4_r + self.P2_S1 = self.P2_S1_r + self.P3_S3 = self.P3_S3_r + # Update the Widget + self.Ratio() + # Unblock Signals + self.Signal_Block(False) + # History + self.History_List(self.rgb_1, self.rgb_2, self.rgb_3) + # Label Clean + self.layout.label.setText("") + def Mixer_Display(self): + # Update Variables + self.menu_mix = self.dialog.mix.isChecked() + self.menu_mix_index = self.dialog.mix_index.currentText() + + # Mixer TTS + if (self.menu_mix == True and self.menu_mix_index == "TTS"): + if self.color_tts[0] == True: + input_tint = [self.color_tts[1], self.color_tts[2], self.color_tts[3]] + mix_tint = self.Gradient_RGB(input_tint, self.color_white) + mix_tone = self.Gradient_RGB(input_tint, self.gray_tts) + mix_shade = self.Gradient_RGB(input_tint, self.color_black) + self.mixer_tint.Colors(True, mix_tint) + self.mixer_tone.Colors(True, mix_tone) + self.mixer_shade.Colors(True, mix_shade) + self.mixer_tint.update() + self.mixer_tone.update() + self.mixer_shade.update() + else: + self.spacer_tint = 0 + self.spacer_tone = 0 + self.spacer_shade = 0 + self.mixer_tint.Colors(False, 0) + self.mixer_tone.Colors(False, 0) + self.mixer_shade.Colors(False, 0) + self.layout.tint.setStyleSheet(self.bg_alpha) + self.layout.tone.setStyleSheet(self.bg_alpha) + self.layout.shade.setStyleSheet(self.bg_alpha) + + # Mixer RGB + if (self.menu_mix == True and self.menu_mix_index == "RGB"): + if (self.color_rgb_l1[0] == True or self.color_rgb_r1[0] == True): + input_rgb_l1 = [self.color_rgb_l1[1], self.color_rgb_l1[2], self.color_rgb_l1[3]] + input_rgb_r1 = [self.color_rgb_r1[1], self.color_rgb_r1[2], self.color_rgb_r1[3]] + mix_rgb_g1 = self.Gradient_RGB(input_rgb_l1, input_rgb_r1) + self.mixer_rgb_g1.Colors(True, mix_rgb_g1) + self.mixer_rgb_g1.update() + else: + self.spacer_rgb_g1 = 0 + self.mixer_rgb_g1.Colors(False, 0) + self.mixer_rgb_g1.update() + if (self.color_rgb_l2[0] == True or self.color_rgb_r2[0] == True): + input_rgb_l2 = [self.color_rgb_l2[1], self.color_rgb_l2[2], self.color_rgb_l2[3]] + input_rgb_r2 = [self.color_rgb_r2[1], self.color_rgb_r2[2], self.color_rgb_r2[3]] + mix_rgb_g2 = self.Gradient_RGB(input_rgb_l2, input_rgb_r2) + self.mixer_rgb_g2.Colors(True, mix_rgb_g2) + self.mixer_rgb_g2.update() + else: + self.spacer_rgb_g2 = 0 + self.mixer_rgb_g2.Colors(False, 0) + self.mixer_rgb_g2.update() + if (self.color_rgb_l3[0] == True or self.color_rgb_r3[0] == True): + input_rgb_l3 = [self.color_rgb_l3[1], self.color_rgb_l3[2], self.color_rgb_l3[3]] + input_rgb_r3 = [self.color_rgb_r3[1], self.color_rgb_r3[2], self.color_rgb_r3[3]] + mix_rgb_g3 = self.Gradient_RGB(input_rgb_l3, input_rgb_r3) + self.mixer_rgb_g3.Colors(True, mix_rgb_g3) + self.mixer_rgb_g3.update() + else: + self.spacer_rgb_g3 = 0 + self.mixer_rgb_g3.Colors(False, 0) + self.mixer_rgb_g3.update() + else: + self.layout.rgb_g1.setStyleSheet(self.bg_alpha) + self.layout.rgb_g2.setStyleSheet(self.bg_alpha) + self.layout.rgb_g3.setStyleSheet(self.bg_alpha) + # Mixer CMYK + if (self.menu_mix == True and self.menu_mix_index == "CMYK"): + if (self.color_cmyk_l1[0] == True or self.color_cmyk_r1[0] == True): + input_cmyk_l1 = [self.color_cmyk_l1[1], self.color_cmyk_l1[2], self.color_cmyk_l1[3], self.color_cmyk_l1[4]] + input_cmyk_r1 = [self.color_cmyk_r1[1], self.color_cmyk_r1[2], self.color_cmyk_r1[3], self.color_cmyk_r1[4]] + mix_cmyk_g1 = self.Gradient_CMYK(input_cmyk_l1, input_cmyk_r1) + self.mixer_cmyk_g1.Colors(True, mix_cmyk_g1) + self.mixer_cmyk_g1.update() + else: + self.spacer_cmyk_g1 = 0 + self.mixer_cmyk_g1.Colors(False, 0) + self.mixer_cmyk_g1.update() + if (self.color_cmyk_l2[0] == True or self.color_cmyk_r2[0] == True): + input_cmyk_l2 = [self.color_cmyk_l2[1], self.color_cmyk_l2[2], self.color_cmyk_l2[3], self.color_cmyk_l2[4]] + input_cmyk_r2 = [self.color_cmyk_r2[1], self.color_cmyk_r2[2], self.color_cmyk_r2[3], self.color_cmyk_r2[4]] + mix_cmyk_g2 = self.Gradient_CMYK(input_cmyk_l2, input_cmyk_r2) + self.mixer_cmyk_g2.Colors(True, mix_cmyk_g2) + self.mixer_cmyk_g2.update() + else: + self.spacer_cmyk_g2 = 0 + self.mixer_cmyk_g2.Colors(False, 0) + self.mixer_cmyk_g2.update() + if (self.color_cmyk_l3[0] == True or self.color_cmyk_r3[0] == True): + input_cmyk_l3 = [self.color_cmyk_l3[1], self.color_cmyk_l3[2], self.color_cmyk_l3[3], self.color_cmyk_l3[4]] + input_cmyk_r3 = [self.color_cmyk_r3[1], self.color_cmyk_r3[2], self.color_cmyk_r3[3], self.color_cmyk_r3[4]] + mix_cmyk_g3 = self.Gradient_CMYK(input_cmyk_l3, input_cmyk_r3) + self.mixer_cmyk_g3.Colors(True, mix_cmyk_g3) + self.mixer_cmyk_g3.update() + else: + self.spacer_cmyk_g3 = 0 + self.mixer_cmyk_g3.Colors(False, 0) + self.mixer_cmyk_g3.update() + else: + self.layout.cmyk_g1.setStyleSheet(self.bg_alpha) + self.layout.cmyk_g2.setStyleSheet(self.bg_alpha) + self.layout.cmyk_g3.setStyleSheet(self.bg_alpha) + # Mixer RYB + if (self.menu_mix == True and self.menu_mix_index == "RYB"): + if (self.color_ryb_l1[0] == True or self.color_ryb_r1[0] == True): + input_ryb_l1 = [self.color_ryb_l1[1], self.color_ryb_l1[2], self.color_ryb_l1[3]] + input_ryb_r1 = [self.color_ryb_r1[1], self.color_ryb_r1[2], self.color_ryb_r1[3]] + mix_ryb_g1 = self.Gradient_RYB(input_ryb_l1, input_ryb_r1) + self.mixer_ryb_g1.Colors(True, mix_ryb_g1) + self.mixer_ryb_g1.update() + else: + self.spacer_ryb_g1 = 0 + self.mixer_ryb_g1.Colors(False, 0) + self.mixer_ryb_g1.update() + if (self.color_ryb_l2[0] == True or self.color_ryb_r2[0] == True): + input_ryb_l2 = [self.color_ryb_l2[1], self.color_ryb_l2[2], self.color_ryb_l2[3]] + input_ryb_r2 = [self.color_ryb_r2[1], self.color_ryb_r2[2], self.color_ryb_r2[3]] + mix_ryb_g2 = self.Gradient_RYB(input_ryb_l2, input_ryb_r2) + self.mixer_ryb_g2.Colors(True, mix_ryb_g2) + self.mixer_ryb_g2.update() + else: + self.spacer_ryb_g2 = 0 + self.mixer_ryb_g2.Colors(False, 0) + self.mixer_ryb_g2.update() + if (self.color_ryb_l3[0] == True or self.color_ryb_r3[0] == True): + input_ryb_l3 = [self.color_ryb_l3[1], self.color_ryb_l3[2], self.color_ryb_l3[3]] + input_ryb_r3 = [self.color_ryb_r3[1], self.color_ryb_r3[2], self.color_ryb_r3[3]] + mix_ryb_g3 = self.Gradient_RYB(input_ryb_l3, input_ryb_r3) + self.mixer_ryb_g3.Colors(True, mix_ryb_g3) + self.mixer_ryb_g3.update() + else: + self.spacer_ryb_g3 = 0 + self.mixer_ryb_g3.Colors(False, 0) + self.mixer_ryb_g3.update() + else: + self.layout.ryb_g1.setStyleSheet(self.bg_alpha) + self.layout.ryb_g2.setStyleSheet(self.bg_alpha) + self.layout.ryb_g3.setStyleSheet(self.bg_alpha) + # Mixer YUV + if (self.menu_mix == True and self.menu_mix_index == "YUV"): + if (self.color_yuv_l1[0] == True or self.color_yuv_r1[0] == True): + input_yuv_l1 = [self.color_yuv_l1[1], self.color_yuv_l1[2], self.color_yuv_l1[3]] + input_yuv_r1 = [self.color_yuv_r1[1], self.color_yuv_r1[2], self.color_yuv_r1[3]] + mix_yuv_g1 = self.Gradient_YUV(input_yuv_l1, input_yuv_r1) + self.mixer_yuv_g1.Colors(True, mix_yuv_g1) + self.mixer_yuv_g1.update() + else: + self.spacer_yuv_g1 = 0 + self.mixer_yuv_g1.Colors(False, 0) + self.mixer_yuv_g1.update() + if (self.color_yuv_l2[0] == True or self.color_yuv_r2[0] == True): + input_yuv_l2 = [self.color_yuv_l2[1], self.color_yuv_l2[2], self.color_yuv_l2[3]] + input_yuv_r2 = [self.color_yuv_r2[1], self.color_yuv_r2[2], self.color_yuv_r2[3]] + mix_yuv_g2 = self.Gradient_YUV(input_yuv_l2, input_yuv_r2) + self.mixer_yuv_g2.Colors(True, mix_yuv_g2) + self.mixer_yuv_g2.update() + else: + self.spacer_yuv_g2 = 0 + self.mixer_yuv_g2.Colors(False, 0) + self.mixer_yuv_g2.update() + if (self.color_yuv_l3[0] == True or self.color_yuv_r3[0] == True): + input_yuv_l3 = [self.color_yuv_l3[1], self.color_yuv_l3[2], self.color_yuv_l3[3]] + input_yuv_r3 = [self.color_yuv_r3[1], self.color_yuv_r3[2], self.color_yuv_r3[3]] + mix_yuv_g3 = self.Gradient_YUV(input_yuv_l3, input_yuv_r3) + self.mixer_yuv_g3.Colors(True, mix_yuv_g3) + self.mixer_yuv_g3.update() + else: + self.spacer_yuv_g3 = 0 + self.mixer_yuv_g3.Colors(False, 0) + self.mixer_yuv_g3.update() + else: + self.layout.yuv_g1.setStyleSheet(self.bg_alpha) + self.layout.yuv_g2.setStyleSheet(self.bg_alpha) + self.layout.yuv_g3.setStyleSheet(self.bg_alpha) + + # Mixer ARD + if (self.menu_mix == True and self.menu_mix_index == "ARD"): + if (self.color_ard_l1[0] == True or self.color_ard_r1[0] == True): + input_ard_l1 = [self.color_ard_l1[1], self.color_ard_l1[2], self.color_ard_l1[3]] + input_ard_r1 = [self.color_ard_r1[1], self.color_ard_r1[2], self.color_ard_r1[3]] + mix_ard_g1 = self.Gradient_Mix_ARD(input_ard_l1, input_ard_r1) + self.mixer_ard_g1.Colors(True, mix_ard_g1) + self.mixer_ard_g1.update() + else: + self.spacer_ard_g1 = 0 + self.mixer_ard_g1.Colors(False, 0) + self.mixer_ard_g1.update() + if (self.color_ard_l2[0] == True or self.color_ard_r2[0] == True): + input_ard_l2 = [self.color_ard_l2[1], self.color_ard_l2[2], self.color_ard_l2[3]] + input_ard_r2 = [self.color_ard_r2[1], self.color_ard_r2[2], self.color_ard_r2[3]] + mix_ard_g2 = self.Gradient_Mix_ARD(input_ard_l2, input_ard_r2) + self.mixer_ard_g2.Colors(True, mix_ard_g2) + self.mixer_ard_g2.update() + else: + self.spacer_ard_g2 = 0 + self.mixer_ard_g2.Colors(False, 0) + self.mixer_ard_g2.update() + if (self.color_ard_l3[0] == True or self.color_ard_r3[0] == True): + input_ard_l3 = [self.color_ard_l3[1], self.color_ard_l3[2], self.color_ard_l3[3]] + input_ard_r3 = [self.color_ard_r3[1], self.color_ard_r3[2], self.color_ard_r3[3]] + mix_ard_g3 = self.Gradient_Mix_ARD(input_ard_l3, input_ard_r3) + self.mixer_ard_g3.Colors(True, mix_ard_g3) + self.mixer_ard_g3.update() + else: + self.spacer_ard_g3 = 0 + self.mixer_ard_g3.Colors(False, 0) + self.mixer_ard_g3.update() + else: + self.layout.ard_g1.setStyleSheet(self.bg_alpha) + self.layout.ard_g2.setStyleSheet(self.bg_alpha) + self.layout.ard_g3.setStyleSheet(self.bg_alpha) + # Mixer HSV + if (self.menu_mix == True and self.menu_mix_index == "HSV"): + if (self.color_hsv_l1[0] == True or self.color_hsv_r1[0] == True): + input_hsv_l1 = [self.color_hsv_l1[1], self.color_hsv_l1[2], self.color_hsv_l1[3]] + input_hsv_r1 = [self.color_hsv_r1[1], self.color_hsv_r1[2], self.color_hsv_r1[3]] + mix_hsv_g1 = self.Gradient_Mix_HSV(input_hsv_l1, input_hsv_r1) + self.mixer_hsv_g1.Colors(True, mix_hsv_g1) + self.mixer_hsv_g1.update() + else: + self.spacer_hsv_g1 = 0 + self.mixer_hsv_g1.Colors(False, 0) + self.mixer_hsv_g1.update() + if (self.color_hsv_l2[0] == True or self.color_hsv_r2[0] == True): + input_hsv_l2 = [self.color_hsv_l2[1], self.color_hsv_l2[2], self.color_hsv_l2[3]] + input_hsv_r2 = [self.color_hsv_r2[1], self.color_hsv_r2[2], self.color_hsv_r2[3]] + mix_hsv_g2 = self.Gradient_Mix_HSV(input_hsv_l2, input_hsv_r2) + self.mixer_hsv_g2.Colors(True, mix_hsv_g2) + self.mixer_hsv_g2.update() + else: + self.spacer_hsv_g2 = 0 + self.mixer_hsv_g2.Colors(False, 0) + self.mixer_hsv_g2.update() + if (self.color_hsv_l3[0] == True or self.color_hsv_r3[0] == True): + input_hsv_l3 = [self.color_hsv_l3[1], self.color_hsv_l3[2], self.color_hsv_l3[3]] + input_hsv_r3 = [self.color_hsv_r3[1], self.color_hsv_r3[2], self.color_hsv_r3[3]] + mix_hsv_g3 = self.Gradient_Mix_HSV(input_hsv_l3, input_hsv_r3) + self.mixer_hsv_g3.Colors(True, mix_hsv_g3) + self.mixer_hsv_g3.update() + else: + self.spacer_hsv_g3 = 0 + self.mixer_hsv_g3.Colors(False, 0) + self.mixer_hsv_g3.update() + else: + self.layout.hsv_g1.setStyleSheet(self.bg_alpha) + self.layout.hsv_g2.setStyleSheet(self.bg_alpha) + self.layout.hsv_g3.setStyleSheet(self.bg_alpha) + # Mixer HSL + if (self.menu_mix == True and self.menu_mix_index == "HSL"): + if (self.color_hsl_l1[0] == True or self.color_hsl_r1[0] == True): + input_hsl_l1 = [self.color_hsl_l1[1], self.color_hsl_l1[2], self.color_hsl_l1[3]] + input_hsl_r1 = [self.color_hsl_r1[1], self.color_hsl_r1[2], self.color_hsl_r1[3]] + mix_hsl_g1 = self.Gradient_Mix_HSL(input_hsl_l1, input_hsl_r1) + self.mixer_hsl_g1.Colors(True, mix_hsl_g1) + self.mixer_hsl_g1.update() + else: + self.spacer_hsl_g1 = 0 + self.mixer_hsl_g1.Colors(False, 0) + self.mixer_hsl_g1.update() + if (self.color_hsl_l2[0] == True or self.color_hsl_r2[0] == True): + input_hsl_l2 = [self.color_hsl_l2[1], self.color_hsl_l2[2], self.color_hsl_l2[3]] + input_hsl_r2 = [self.color_hsl_r2[1], self.color_hsl_r2[2], self.color_hsl_r2[3]] + mix_hsl_g2 = self.Gradient_Mix_HSL(input_hsl_l2, input_hsl_r2) + self.mixer_hsl_g2.Colors(True, mix_hsl_g2) + self.mixer_hsl_g2.update() + else: + self.spacer_hsl_g2 = 0 + self.mixer_hsl_g2.Colors(False, 0) + self.mixer_hsl_g2.update() + if (self.color_hsl_l3[0] == True or self.color_hsl_r3[0] == True): + input_hsl_l3 = [self.color_hsl_l3[1], self.color_hsl_l3[2], self.color_hsl_l3[3]] + input_hsl_r3 = [self.color_hsl_r3[1], self.color_hsl_r3[2], self.color_hsl_r3[3]] + mix_hsl_g3 = self.Gradient_Mix_HSL(input_hsl_l3, input_hsl_r3) + self.mixer_hsl_g3.Colors(True, mix_hsl_g3) + self.mixer_hsl_g3.update() + else: + self.spacer_hsl_g3 = 0 + self.mixer_hsl_g3.Colors(False, 0) + self.mixer_hsl_g3.update() + else: + self.layout.hsl_g1.setStyleSheet(self.bg_alpha) + self.layout.hsl_g2.setStyleSheet(self.bg_alpha) + self.layout.hsl_g3.setStyleSheet(self.bg_alpha) + # Mixer HCY + if (self.menu_mix == True and self.menu_mix_index == "HCY"): + if (self.color_hcy_l1[0] == True or self.color_hcy_r1[0] == True): + input_hcy_l1 = [self.color_hcy_l1[1], self.color_hcy_l1[2], self.color_hcy_l1[3]] + input_hcy_r1 = [self.color_hcy_r1[1], self.color_hcy_r1[2], self.color_hcy_r1[3]] + mix_hcy_g1 = self.Gradient_Mix_HCY(input_hcy_l1, input_hcy_r1) + self.mixer_hcy_g1.Colors(True, mix_hcy_g1) + self.mixer_hcy_g1.update() + else: + self.spacer_hcy_g1 = 0 + self.mixer_hcy_g1.Colors(False, 0) + self.mixer_hcy_g1.update() + if (self.color_hcy_l2[0] == True or self.color_hcy_r2[0] == True): + input_hcy_l2 = [self.color_hcy_l2[1], self.color_hcy_l2[2], self.color_hcy_l2[3]] + input_hcy_r2 = [self.color_hcy_r2[1], self.color_hcy_r2[2], self.color_hcy_r2[3]] + mix_hcy_g2 = self.Gradient_Mix_HCY(input_hcy_l2, input_hcy_r2) + self.mixer_hcy_g2.Colors(True, mix_hcy_g2) + self.mixer_hcy_g2.update() + else: + self.spacer_hcy_g2 = 0 + self.mixer_hcy_g2.Colors(False, 0) + self.mixer_hcy_g2.update() + if (self.color_hcy_l3[0] == True or self.color_hcy_r3[0] == True): + input_hcy_l3 = [self.color_hcy_l3[1], self.color_hcy_l3[2], self.color_hcy_l3[3]] + input_hcy_r3 = [self.color_hcy_r3[1], self.color_hcy_r3[2], self.color_hcy_r3[3]] + mix_hcy_g3 = self.Gradient_Mix_HCY(input_hcy_l3, input_hcy_r3) + self.mixer_hcy_g3.Colors(True, mix_hcy_g3) + self.mixer_hcy_g3.update() + else: + self.spacer_hcy_g3 = 0 + self.mixer_hcy_g3.Colors(False, 0) + self.mixer_hcy_g3.update() + else: + self.layout.hcy_g1.setStyleSheet(self.bg_alpha) + self.layout.hcy_g2.setStyleSheet(self.bg_alpha) + self.layout.hcy_g3.setStyleSheet(self.bg_alpha) + + # Aspect Ratio + def Ratio(self): + # Redimension Channels Sliders + self.Ratio_Channels() + + # Redimension Frames to be Centered + self.Ratio_Box() + + # Relocate Panel Cursor due to Size Variation + self.panel_active = self.dialog.pan_index.currentText() + try: + if self.panel_active == "SWA": + self.Update_Panel_SWA() + if self.panel_active == "RGB": + self.Update_Panel_UVD() + if self.panel_active == "ARD": + self.Update_Panel_ARD() + if self.panel_active == "HSV": + self.Update_Panel_HSV() + if self.panel_active == "HSL": + self.Update_Panel_HSL() + if self.panel_active == "YUV": + self.Update_Panel_YUV() + if self.panel_active == "HUE": + self.Update_Panel_HUE() + if self.panel_active == "GAM": + self.Update_Panel_GAM_Circle() + self.Update_Panel_GAM_Polygon(self.P1_S1, self.P1_S3, self.P1_S4, self.P2_S1, self.P3_S3) + if self.panel_active == "DOT": + self.Update_Panel_DOT() + self.panel_dots.Location(self.dot_location_x, self.dot_location_y, self.layout.panel_dot_mix.width(), self.layout.panel_dot_mix.height()) + if self.panel_active == "OBJ": + self.Update_Panel_OBJ() + self.panel_obj_display.Location(self.obj_location_x, self.obj_location_y, self.layout.panel_obj_mix.width(), self.layout.panel_obj_mix.height()) + if self.panel_active == "IMG": + self.Update_Panel_IMG() + except: + pass + def Ratio_Channels(self): + # Channels + self.channel_width = self.layout.rgb_1_slider.width() + self.mixer_width = self.layout.rgb_g1.width() + # Harmony + try: + self.Update_Harmony_Colors() + self.Update_Harmony_Span() + except: + pass + # Relocate Channel Handle due to Size Variation + try: + if self.chan_aaa == True: + self.aaa_1_slider.Update(self.aaa_1, self.channel_width) + if self.chan_rgb == True: + self.rgb_1_slider.Update(self.rgb_1, self.channel_width) + self.rgb_2_slider.Update(self.rgb_2, self.channel_width) + self.rgb_3_slider.Update(self.rgb_3, self.channel_width) + if self.chan_cmy == True: + self.cmy_1_slider.Update(self.cmy_1, self.channel_width) + self.cmy_2_slider.Update(self.cmy_2, self.channel_width) + self.cmy_3_slider.Update(self.cmy_3, self.channel_width) + if self.chan_cmyk == True: + self.cmyk_1_slider.Update(self.cmyk_1, self.channel_width) + self.cmyk_2_slider.Update(self.cmyk_2, self.channel_width) + self.cmyk_3_slider.Update(self.cmyk_3, self.channel_width) + self.cmyk_4_slider.Update(self.cmyk_4, self.channel_width) + if self.chan_ryb == True: + self.ryb_1_slider.Update(self.ryb_1, self.channel_width) + self.ryb_2_slider.Update(self.ryb_2, self.channel_width) + self.ryb_3_slider.Update(self.ryb_3, self.channel_width) + if self.chan_yuv == True: + self.yuv_1_slider.Update(self.yuv_1, self.channel_width) + self.yuv_2_slider.Update(self.yuv_2, self.channel_width) + self.yuv_3_slider.Update(self.yuv_3, self.channel_width) + if self.chan_kkk == True: + self.kkk_1_slider.Update((self.kkk_0-k_KKKmin)/k_KKKdelta, self.channel_width) + + if self.chan_ard == True: + self.ard_1_slider.Update(self.ard_1, self.channel_width) + self.ard_2_slider.Update(self.ard_2, self.channel_width) + self.ard_3_slider.Update(self.ard_3, self.channel_width) + if self.chan_hsv == True: + self.hsv_1_slider.Update(self.hsv_1, self.channel_width) + self.hsv_2_slider.Update(self.hsv_2, self.channel_width) + self.hsv_3_slider.Update(self.hsv_3, self.channel_width) + if self.chan_hsl == True: + self.hsl_1_slider.Update(self.hsl_1, self.channel_width) + self.hsl_2_slider.Update(self.hsl_2, self.channel_width) + self.hsl_3_slider.Update(self.hsl_3, self.channel_width) + if self.chan_hcy == True: + self.hcy_1_slider.Update(self.hcy_1, self.channel_width) + self.hcy_2_slider.Update(self.hcy_2, self.channel_width) + self.hcy_3_slider.Update(self.hcy_3, self.channel_width) + + if self.chan_xyz == True: + self.xyz_1_slider.Update(self.xyz_1, self.channel_width) + self.xyz_2_slider.Update(self.xyz_2, self.channel_width) + self.xyz_3_slider.Update(self.xyz_3, self.channel_width) + if self.chan_xyy == True: + self.xyy_1_slider.Update(self.xyy_1, self.channel_width) + self.xyy_2_slider.Update(self.xyy_2, self.channel_width) + self.xyy_3_slider.Update(self.xyy_3, self.channel_width) + if self.chan_lab == True: + self.lab_1_slider.Update(self.lab_1, self.channel_width) + self.lab_2_slider.Update(self.lab_2, self.channel_width) + self.lab_3_slider.Update(self.lab_3, self.channel_width) + except: + pass + # Mixers + try: + # Relocate MIX Handles due to Size Variation + if self.menu_mix == True: + if self.menu_mix_index == "TTS": + self.mixer_tint.Update(self.spacer_tint, self.layout.tint.width()) + self.mixer_tone.Update(self.spacer_tone, self.layout.tone.width()) + self.mixer_shade.Update(self.spacer_shade, self.layout.shade.width()) + + if self.menu_mix_index == "RGB": + self.mixer_rgb_g1.Update(self.spacer_rgb_g1, self.mixer_width) + self.mixer_rgb_g2.Update(self.spacer_rgb_g2, self.mixer_width) + self.mixer_rgb_g3.Update(self.spacer_rgb_g3, self.mixer_width) + if self.menu_mix_index == "CMYK": + self.mixer_cmyk_g1.Update(self.spacer_cmyk_g1, self.mixer_width) + self.mixer_cmyk_g2.Update(self.spacer_cmyk_g2, self.mixer_width) + self.mixer_cmyk_g3.Update(self.spacer_cmyk_g3, self.mixer_width) + if self.menu_mix_index == "RYB": + self.mixer_ryb_g1.Update(self.spacer_ryb_g1, self.mixer_width) + self.mixer_ryb_g2.Update(self.spacer_ryb_g2, self.mixer_width) + self.mixer_ryb_g3.Update(self.spacer_ryb_g3, self.mixer_width) + if self.menu_mix_index == "YUV": + self.mixer_yuv_g1.Update(self.spacer_yuv_g1, self.mixer_width) + self.mixer_yuv_g2.Update(self.spacer_yuv_g2, self.mixer_width) + self.mixer_yuv_g3.Update(self.spacer_yuv_g3, self.mixer_width) + + if self.menu_mix_index == "ARD": + self.mixer_ard_g1.Update(self.spacer_ard_g1, self.mixer_width) + self.mixer_ard_g2.Update(self.spacer_ard_g2, self.mixer_width) + self.mixer_ard_g3.Update(self.spacer_ard_g3, self.mixer_width) + if self.menu_mix_index == "HSV": + self.mixer_hsv_g1.Update(self.spacer_hsv_g1, self.mixer_width) + self.mixer_hsv_g2.Update(self.spacer_hsv_g2, self.mixer_width) + self.mixer_hsv_g3.Update(self.spacer_hsv_g3, self.mixer_width) + if self.menu_mix_index == "HSL": + self.mixer_hsl_g1.Update(self.spacer_hsl_g1, self.mixer_width) + self.mixer_hsl_g2.Update(self.spacer_hsl_g2, self.mixer_width) + self.mixer_hsl_g3.Update(self.spacer_hsl_g3, self.mixer_width) + if self.menu_mix_index == "HCY": + self.mixer_hcy_g1.Update(self.spacer_hcy_g1, self.mixer_width) + self.mixer_hcy_g2.Update(self.spacer_hcy_g2, self.mixer_width) + self.mixer_hcy_g3.Update(self.spacer_hcy_g3, self.mixer_width) + + if self.menu_mix_index == "XYZ": + self.mixer_xyz_g1.Update(self.spacer_xyz_g1, self.mixer_width) + self.mixer_xyz_g2.Update(self.spacer_xyz_g2, self.mixer_width) + self.mixer_xyz_g3.Update(self.spacer_xyz_g3, self.mixer_width) + if self.menu_mix_index == "XYY": + self.mixer_xyy_g1.Update(self.spacer_xyy_g1, self.mixer_width) + self.mixer_xyy_g2.Update(self.spacer_xyy_g2, self.mixer_width) + self.mixer_xyy_g3.Update(self.spacer_xyy_g3, self.mixer_width) + if self.menu_mix_index == "LUV": + self.mixer_luv_g1.Update(self.spacer_luv_g1, self.mixer_width) + self.mixer_luv_g2.Update(self.spacer_luv_g2, self.mixer_width) + self.mixer_luv_g3.Update(self.spacer_luv_g3, self.mixer_width) + if self.menu_mix_index == "HLAB": + self.mixer_hlab_g1.Update(self.spacer_hlab_g1, self.mixer_width) + self.mixer_hlab_g2.Update(self.spacer_hlab_g2, self.mixer_width) + self.mixer_hlab_g3.Update(self.spacer_hlab_g3, self.mixer_width) + if self.menu_mix_index == "LAB": + self.mixer_lab_g1.Update(self.spacer_lab_g1, self.mixer_width) + self.mixer_lab_g2.Update(self.spacer_lab_g2, self.mixer_width) + self.mixer_lab_g3.Update(self.spacer_lab_g3, self.mixer_width) + if self.menu_mix_index == "LCH": + self.mixer_lch_g1.Update(self.spacer_lch_g1, self.mixer_width) + self.mixer_lch_g2.Update(self.spacer_lch_g2, self.mixer_width) + self.mixer_lch_g3.Update(self.spacer_lch_g3, self.mixer_width) + except: + pass + # Object + try: + self.b1_alpha.Update(self.bg_1[self.obj_index][4], self.layout.b1_alpha.width()) + self.b2_alpha.Update(self.bg_2[self.obj_index][4], self.layout.b2_alpha.width()) + self.b3_alpha.Update(self.bg_3[self.obj_index][4], self.layout.b3_alpha.width()) + self.d1_alpha.Update(self.dif_1[self.obj_index][4], self.layout.d1_alpha.width()) + self.d2_alpha.Update(self.dif_2[self.obj_index][4], self.layout.d2_alpha.width()) + self.d3_alpha.Update(self.dif_3[self.obj_index][4], self.layout.d3_alpha.width()) + self.d4_alpha.Update(self.dif_4[self.obj_index][4], self.layout.d4_alpha.width()) + self.d5_alpha.Update(self.dif_5[self.obj_index][4], self.layout.d5_alpha.width()) + self.d6_alpha.Update(self.dif_6[self.obj_index][4], self.layout.d6_alpha.width()) + self.f1_alpha.Update(self.fg_1[self.obj_index][4], self.layout.f1_alpha.width()) + self.f2_alpha.Update(self.fg_2[self.obj_index][4], self.layout.f2_alpha.width()) + self.f3_alpha.Update(self.fg_3[self.obj_index][4], self.layout.f3_alpha.width()) + self.layout.b1_alpha.update() + self.layout.b2_alpha.update() + self.layout.b3_alpha.update() + self.layout.d1_alpha.update() + self.layout.d2_alpha.update() + self.layout.d3_alpha.update() + self.layout.d4_alpha.update() + self.layout.d5_alpha.update() + self.layout.d6_alpha.update() + self.layout.f1_alpha.update() + self.layout.f2_alpha.update() + self.layout.f3_alpha.update() + except: + pass + def Ratio_Box(self): + # Panel Widget Alignment + if self.panel_active == "HUE": + # HUE Panel Ratio Adjust to maintain Square + hue_width = self.layout.panel_hue.width() + hue_height = self.layout.panel_hue.height() + if hue_width <= 0: + hue_width = 1 + if hue_height <= 0: + hue_height = 1 + if hue_width >= hue_height: + self.layout.panel_hue_box.setMaximumWidth(hue_height) + self.layout.panel_hue_box.setMaximumHeight(hue_height) + if hue_width < hue_height: + self.layout.panel_hue_box.setMaximumWidth(hue_width) + self.layout.panel_hue_box.setMaximumHeight(hue_width) + # Adjust Circle Geometry + self.layout.panel_hue_circle.setGeometry(0,0,self.layout.panel_hue_box.width(),self.layout.panel_hue_box.height()) + # Adjust Regular + self.panel_secondary = self.dialog.hue_secondary.currentText() + if self.panel_secondary == "DOT": + self.layout.panel_hue_regular_mask.setGeometry(0,0, 0,0) + if self.panel_secondary == "TRIANGLE": + # Adjust Regular Geometry + d1 = 0.28754 + d2 = 0.132 + d3 = 0.637388 + d4 = 0.735992 + panel_hue_box_width = self.layout.panel_hue_box.width() + panel_hue_box_height = self.layout.panel_hue_box.height() + self.layout.panel_hue_regular_mask.setGeometry( + panel_hue_box_width*d1, panel_hue_box_height*d2, + panel_hue_box_width*d3, panel_hue_box_height*d4) + # Adjust Regular Mask + panel_hue_regular_mask_width = self.layout.panel_hue_regular_mask.width() + panel_hue_regular_mask_height = self.layout.panel_hue_regular_mask.height() + region_polygon = QPolygon([ + QPoint(0, 0), + QPoint(0, panel_hue_regular_mask_height), + QPoint(panel_hue_regular_mask_width, panel_hue_regular_mask_height*0.5) + ]) + self.layout.panel_hue_regular_mask.setMask(QRegion(region_polygon)) + if self.panel_secondary == "SQUARE": + # Adjust Regular Geometry + d1 = 0.2 + d2 = 1 - (2*d1) + panel_hue_box_width = self.layout.panel_hue_box.width() + panel_hue_box_height = self.layout.panel_hue_box.height() + self.layout.panel_hue_regular_mask.setGeometry( + panel_hue_box_width*d1, panel_hue_box_height*d1, + panel_hue_box_width*d2, panel_hue_box_height*d2) + # Adjust Regular Mask + panel_hue_regular_mask_width = self.layout.panel_hue_regular_mask.width() + panel_hue_regular_mask_height = self.layout.panel_hue_regular_mask.height() + region_polygon = QPolygon([ + QPoint(0, 0), + QPoint(panel_hue_regular_mask_width, 0), + QPoint(panel_hue_regular_mask_width, panel_hue_regular_mask_height), + QPoint(0, panel_hue_regular_mask_height) + ]) + self.layout.panel_hue_regular_mask.setMask(QRegion(region_polygon)) + if self.panel_secondary == "DIAMOND": + # Adjust Regular Geometry + d1 = 0.075 + d2 = 1 - (2*d1) + panel_hue_box_width = self.layout.panel_hue_box.width() + panel_hue_box_height = self.layout.panel_hue_box.height() + self.layout.panel_hue_regular_mask.setGeometry( + panel_hue_box_width*d1, panel_hue_box_height*d1, + panel_hue_box_width*d2, panel_hue_box_height*d2) + # Adjust Regular Mask + panel_hue_regular_mask_width = self.layout.panel_hue_regular_mask.width() + panel_hue_regular_mask_height = self.layout.panel_hue_regular_mask.height() + region_polygon = QPolygon([ + QPoint(panel_hue_regular_mask_width*0.5, 0), + QPoint(panel_hue_regular_mask_width, panel_hue_regular_mask_height*0.5), + QPoint(panel_hue_regular_mask_width*0.5, panel_hue_regular_mask_height), + QPoint(0, panel_hue_regular_mask_height*0.5) + ]) + self.layout.panel_hue_regular_mask.setMask(QRegion(region_polygon)) + if self.panel_active == "GAM": + # GAM Panel Ratio Adjust to maintain Square + gam_width = self.layout.panel_gam.width() + gam_height = self.layout.panel_gam.height() + if gam_width <= 0: + gam_width = 1 + if gam_height <= 0: + gam_height = 1 + if gam_width >= gam_height: + circle = gam_height + if gam_width < gam_height: + circle = gam_width + self.layout.panel_gam_box.setMaximumWidth(circle) + self.layout.panel_gam_box.setMaximumHeight(circle) + # Adjust Circle Geometry + self.layout.panel_gam_circle.setGeometry(0,0,circle,circle) + g1 = 0.05 + g2 = 1 - (2*g1) + self.layout.panel_gam_polygon.setGeometry(circle*g1,circle*g1, circle*g2,circle*g2) + gp_w = self.layout.panel_gam_polygon.width() + gp_h = self.layout.panel_gam_polygon.height() + gamut_polygon = QRegion(0,0, gp_w,gp_h, QRegion.Ellipse) + self.layout.panel_gam_polygon.setMask(gamut_polygon) + if self.panel_active == "IMG": + self.Update_Panel_IMG() + def Ratio_Panel(self): + if self.panel_active == "SWA": + self.Update_Panel_SWA() + if self.panel_active == "RGB": + self.Update_Panel_UVD() + if self.panel_active == "YUV": + self.Update_Panel_YUV() + if self.panel_active == "ARD": + self.Update_Panel_ARD() + if self.panel_active == "HSV": + self.Update_Panel_HSV() + if self.panel_active == "HSL": + self.Update_Panel_HSL() + if self.panel_active == "HCY": + self.Update_Panel_HCY() + if self.panel_active == "HUE": + self.Update_Panel_HUE() + if self.panel_active == "GAM": + self.Update_Panel_GAM_Circle() + self.Update_Panel_GAM_Polygon(self.P1_S1_r, self.P1_S3_r, self.P1_S4_r, self.P2_S1_r, self.P3_S3_r) + if self.panel_active == "DOT": + self.Update_Panel_DOT() + if self.panel_active == "OBJ": + self.Update_Panel_OBJ() + if self.panel_active == "IMG": + self.Update_Panel_IMG() + # Language + def Color_Names(self, hex): + search = color_names.get(hex) + if search == None: + self.dialog.names_display.setText("") + else: + self.dialog.names_display.setText(str(search)) + def Color_Kelvin(self): + input = self.kkk_0 + for i in range(len(kelvin_illuminants)): + if (input == kelvin_illuminants[i][0] or (input > kelvin_illuminants[i][0] and input < kelvin_illuminants[i+1][0])): + self.dialog.kelvin_display.setText(kelvin_illuminants[i][1]) + + #// + #\\ Hex Codes ############################################################## + def Pigment_2_HEX(self): + if (self.d_cm == "A" or self.d_cm == "GRAYA"): + hex1 = str(hex(int(self.aaa_1 * hex_AAA)))[2:4].zfill(2) + pigment_hex = str("#"+hex1) + elif self.d_cm == "RGBA": + hex1 = str(hex(int(self.rgb_1 * hex_RGB)))[2:4].zfill(2) + hex2 = str(hex(int(self.rgb_2 * hex_RGB)))[2:4].zfill(2) + hex3 = str(hex(int(self.rgb_3 * hex_RGB)))[2:4].zfill(2) + pigment_hex = str("#"+hex1+hex2+hex3) + elif self.d_cm == "CMYKA": + hex1 = str(hex(int(self.cmyk_1 * hex_CMYK)))[2:4].zfill(2) + hex2 = str(hex(int(self.cmyk_2 * hex_CMYK)))[2:4].zfill(2) + hex3 = str(hex(int(self.cmyk_3 * hex_CMYK)))[2:4].zfill(2) + hex4 = str(hex(int(self.cmyk_4 * hex_CMYK)))[2:4].zfill(2) + pigment_hex = str("#"+hex1+hex2+hex3+hex4) + elif self.d_cm == "YCbCrA": + hex1 = str(hex(int(self.yuv_1 * hex_YYY)))[2:4].zfill(2) + hex2 = str(hex(int(self.yuv_2 * hex_UV)))[2:4].zfill(2) + hex3 = str(hex(int(self.yuv_3 * hex_UV)))[2:4].zfill(2) + pigment_hex = str("#"+hex1+hex2+hex3) + elif self.d_cm == "XYZA": + hex1 = str(hex(int(self.xyz_1 * hex_XYZ)))[2:4].zfill(2) + hex2 = str(hex(int(self.xyz_2 * hex_XYZ)))[2:4].zfill(2) + hex3 = str(hex(int(self.xyz_3 * hex_XYZ)))[2:4].zfill(2) + pigment_hex = str("#"+hex1+hex2+hex3) + elif self.d_cm == "LABA": + hex1 = str(hex(int(self.lab_1 * hex_LLL)))[2:4].zfill(2) + hex2 = str(hex(int(self.lab_2 * hex_AB)))[2:4].zfill(2) + hex3 = str(hex(int(self.lab_3 * hex_AB)))[2:4].zfill(2) + pigment_hex = str("#"+hex1+hex2+hex3) + return pigment_hex + def HEX_APPLY(self, hex): + # Parse Hex Code + hex1 = int(format(int(hex[1:3],16),'02d')) + hex2 = int(format(int(hex[3:5],16),'02d')) + hex3 = int(format(int(hex[5:7],16),'02d')) + # Apply to Pigment + rgb1 = hex1 / hex_RGB + rgb2 = hex2 / hex_RGB + rgb3 = hex3 / hex_RGB + self.Color_HUE("RGB", rgb1, rgb2, rgb3, 0) + self.Color_APPLY("RGB", rgb1, rgb2, rgb3, 0) + self.Pigment_Release() + def HEX_Code(self): + hex = self.layout.hex_string.text().lower() + try: + length = len(hex) + if (hex[0] == "#" and length == 3): + # Parse Hex Code + hex1 = int(format(int(hex[1:3],16),'02d')) + # Apply to Pigment + aaa1 = hex1 / hex_AAA + self.angle_live = 0 + self.Color_APPLY("AAA", aaa1, 0, 0, 0) + elif (hex[0] == "#" and length == 7): + # Parse Hex Code + hex1 = int(format(int(hex[1:3],16),'02d')) + hex2 = int(format(int(hex[3:5],16),'02d')) + hex3 = int(format(int(hex[5:7],16),'02d')) + # Apply to Pigment + rgb1 = hex1 / hex_RGB + rgb2 = hex2 / hex_RGB + rgb3 = hex3 / hex_RGB + self.Color_HUE("RGB", rgb1, rgb2, rgb3, 0) + self.Color_APPLY("RGB", rgb1, rgb2, rgb3, 0) + elif (hex[0] == "#" and length == 9): + # Parse Hex Code + hex1 = int(format(int(hex[1:3],16),'02d')) + hex2 = int(format(int(hex[3:5],16),'02d')) + hex3 = int(format(int(hex[5:7],16),'02d')) + hex4 = int(format(int(hex[7:9],16),'02d')) + # Apply to Pigment + cmyk1 = hex1 / hex_CMYK + cmyk2 = hex2 / hex_CMYK + cmyk3 = hex3 / hex_CMYK + cmyk4 = hex4 / hex_CMYK + self.Color_HUE("CMYK", cmyk1, cmyk2, cmyk3, cmyk4) + self.Color_APPLY("CMYK", cmyk1, cmyk2, cmyk3, cmyk4) + else: + self.layout.hex_string.setText("Error") + except: + self.layout.hex_string.setText("Error") + self.Pigment_Release() + def HEX_6string(self, red, green, blue): + # Transform into HEX + hex1 = str(hex(int(red * hex_RGB)))[2:4].zfill(2) + hex2 = str(hex(int(green * hex_RGB)))[2:4].zfill(2) + hex3 = str(hex(int(blue * hex_RGB)))[2:4].zfill(2) + pigment_hex = str("#"+hex1+hex2+hex3) + return pigment_hex + def HEX_Closest(self): + # Original HEX Point + hex_start = self.layout.hex_string.text().lower() + ps = self.HEX_Point(hex_start) + # Calculate Distances + lista = list(color_names) + index = [0,5] + for i in range(len(lista)): + pe = self.HEX_Point(lista[i]) + d = self.Math_3D_Points_Distance(ps[0], ps[1], ps[2], pe[0], pe[1], pe[2]) + if d < index[1]: + index = [i , d] + # Final Color + rgb = self.HEX_Point( lista[index[0]] ) + # Move Location to Closest Point + self.Color_HUE("RGB", rgb[0], rgb[1], rgb[2], 0) + self.Color_APPLY("RGB", rgb[0], rgb[1], rgb[2], 0) + self.Pigment_Release() + def HEX_Point(self, hex): + length = len(hex) + if (hex[0] == "#" and length == 3): + # Parse Hex Code + hex1 = int(format(int(hex[1:3],16),'02d')) + # Apply to Pigment + val1 = hex1 / hex_AAA + val2 = val1 + val3 = val1 + elif (hex[0] == "#" and length == 7): + # Parse Hex Code + hex1 = int(format(int(hex[1:3],16),'02d')) + hex2 = int(format(int(hex[3:5],16),'02d')) + hex3 = int(format(int(hex[5:7],16),'02d')) + # Apply to Pigment + val1 = hex1 / hex_RGB + val2 = hex2 / hex_RGB + val3 = hex3 / hex_RGB + elif (hex[0] == "#" and length == 9): + # Parse Hex Code + hex1 = int(format(int(hex[1:3],16),'02d')) + hex2 = int(format(int(hex[3:5],16),'02d')) + hex3 = int(format(int(hex[5:7],16),'02d')) + hex4 = int(format(int(hex[7:9],16),'02d')) + # Apply to Pigment + cmyk1 = hex1 / hex_CMYK + cmyk2 = hex2 / hex_CMYK + cmyk3 = hex3 / hex_CMYK + cmyk4 = hex4 / hex_CMYK + val1, val2, val3 = self.cmyk_to_rgb(cmyk1, cmyk2, cmyk3, cmyk4) + return [val1, val2, val3] + def HEX_Copy(self): + hc = QApplication.clipboard() + hc.clear() + hex = self.HEX_6string(self.rgb_1, self.rgb_2, self.rgb_3) + hc.setText(str(hex)) + def HEX_Paste(self): + hc = QApplication.clipboard() + hex = hc.text() + try: + if (hex[0] == "#" and len(hex) == 7): + self.HEX_APPLY(hex) + except: + pass + + #// + #\\ Channels Locks ######################################################### + def Pigment_AAA_1_Lock(self, SIGNAL_COLOR_LUMALOCK): + if self.luma_lock != True: + # Status + self.luma_lock = True + # Value Lock + self.AAA_1_Value_Lock() + else: + # Key Status + self.luma_lock = False + # Value Lock + self.luma_lock_value = [0, 0, 0] + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Pigment_Release() + def AAA_1_Value_Lock(self): + if self.panel_active == "ARD": + self.luma_lock_value = [self.ard_1, self.ard_2, self.ard_3] + if self.panel_active == "HSV": + self.luma_lock_value = [self.hsv_1, self.hsv_2, self.hsv_3] + if self.panel_active == "HSL": + self.luma_lock_value = [self.hsl_1, self.hsl_2, self.hsl_3] + if self.panel_active == "HUE": + if self.harmony_space == "ARD": + self.luma_lock_value = [self.ard_1, self.ard_2, self.ard_3] + if self.harmony_space == "HSV": + self.luma_lock_value = [self.hsv_1, self.hsv_2, self.hsv_3] + if self.harmony_space == "HSL": + self.luma_lock_value = [self.hsl_1, self.hsl_2, self.hsl_3] + if self.harmony_space == "HCY": + self.luma_lock_value = [self.hcy_1, self.hcy_2, self.hcy_3] + + def Pigment_CMYK_4_Lock(self): + if self.layout.cmyk_4_lock.isChecked(): + self.cmyk_lock = True + self.layout.cmyk_4_lock.setIcon(Krita.instance().icon('docker_lock_b')) + else: + self.cmyk_lock = False + self.layout.cmyk_4_lock.setIcon(Krita.instance().icon('docker_lock_a')) + self.Pigment_Release() + + def Pigment_KKK_1_Lock(self): + if self.layout.kkk_1_lock.isChecked(): + self.kkk_lock = True + self.layout.kkk_1_lock.setIcon(Krita.instance().icon('docker_lock_b')) + else: + self.kkk_lock = False + self.layout.kkk_1_lock.setIcon(Krita.instance().icon('docker_lock_a')) + self.Pigment_Display() + self.Pigment_Release() + + def Pigment_ARD_1_Lock(self): + if self.layout.ard_1_lock.isChecked(): + self.ard_lock = True + self.ard_lock_value = [self.uvd_1, self.uvd_2] + self.layout.ard_1_lock.setIcon(Krita.instance().icon('docker_lock_b')) + else: + self.ard_lock = False + self.ard_lock_value = [None, None] + self.layout.ard_1_lock.setIcon(Krita.instance().icon('docker_lock_a')) + self.Pigment_Release() + def ARD_1_Value_Lock_Ratio(self, a): + # UVD + u = self.uvd_1 + v = self.uvd_2 + d = self.uvd_3 + # Update Origin Points + self.uvd_hexagon_origins(d) + # Angle according to normal zero axis +U right and counter clockwise + arc = a * 360 + # Total Value + diagonal = d * 3 + if diagonal <= 0: + inter = [0,0] + inter = 0 + elif (diagonal > 0 and diagonal <= 1): + # Angles according to O45(RED) as Origin + AR = 0 # RED + AG = self.Math_2D_Points_Lines_Angle(self.O23[0], self.O23[1], 0, 0, self.O45[0], self.O45[1]) # GREEN + AB = self.Math_2D_Points_Lines_Angle(self.O61[0], self.O61[1], 0, 0, self.O45[0], self.O45[1]) # BLUE + # Certain + if arc == AR: + inter = [self.O45[0], self.O45[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O45[0], self.O45[1]) + elif arc == AG: + inter = [self.O23[0], self.O23[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O23[0], self.O23[1]) + elif arc == AB: + inter = [self.O61[0], self.O61[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O61[0], self.O61[1]) + # Intervals + elif (arc > AR and arc < AG): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O3[0], self.O3[1], self.O4[0], self.O4[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AG and arc < AB): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O1[0], self.O1[1], self.O2[0], self.O2[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AB or arc < AR): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O5[0], self.O5[1], self.O6[0], self.O6[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (diagonal > 1 and diagonal < 2): + # Angles according to O45(RED) as Origin + A1 = self.Math_2D_Points_Lines_Angle(self.O1[0], self.O1[1], 0, 0, self.O45[0], self.O45[1]) # O1 + A2 = self.Math_2D_Points_Lines_Angle(self.O2[0], self.O2[1], 0, 0, self.O45[0], self.O45[1]) # O2 + A3 = self.Math_2D_Points_Lines_Angle(self.O3[0], self.O3[1], 0, 0, self.O45[0], self.O45[1]) # O3 + A4 = self.Math_2D_Points_Lines_Angle(self.O4[0], self.O4[1], 0, 0, self.O45[0], self.O45[1]) # O4 + A5 = self.Math_2D_Points_Lines_Angle(self.O5[0], self.O5[1], 0, 0, self.O45[0], self.O45[1]) # O5 + A6 = self.Math_2D_Points_Lines_Angle(self.O6[0], self.O6[1], 0, 0, self.O45[0], self.O45[1]) # O6 + # Certain + if arc == A1: + inter = [self.O1[0], self.O1[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O1[0], self.O1[1]) + elif arc == A2: + inter = [self.O2[0], self.O2[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O2[0], self.O2[1]) + elif arc == A3: + inter = [self.O3[0], self.O3[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O3[0], self.O3[1]) + elif arc == A4: + inter = [self.O4[0], self.O4[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O4[0], self.O4[1]) + elif arc == A5: + inter = [self.O5[0], self.O5[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O5[0], self.O5[1]) + elif arc == A6: + inter = [self.O6[0], self.O6[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O6[0], self.O6[1]) + # Intervals + elif (arc > A4 and arc < A3): # 0 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O4[0], self.O4[1], self.O3[0], self.O3[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A3 and arc < A2): # 60 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O3[0], self.O3[1], self.O2[0], self.O2[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A2 and arc < A1): # 120 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O2[0], self.O2[1], self.O1[0], self.O1[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A1 and arc < A6): # 180 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O1[0], self.O1[1], self.O6[0], self.O6[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A6 and arc < A5): # 240 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O6[0], self.O6[1], self.O5[0], self.O5[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > A5 or arc < A4): # 300 + inter = list(self.Math_2D_Points_Lines_Intersection(self.O5[0], self.O5[1], self.O4[0], self.O4[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (diagonal >= 2 and diagonal < 3): + # Angles according to O45(RED) as Origin + AY = self.Math_2D_Points_Lines_Angle(self.O34[0], self.O34[1], 0, 0, self.O45[0], self.O45[1]) # YELLOW + AC = self.Math_2D_Points_Lines_Angle(self.O12[0], self.O12[1], 0, 0, self.O45[0], self.O45[1]) # CYAN + AM = self.Math_2D_Points_Lines_Angle(self.O56[0], self.O56[1], 0, 0, self.O45[0], self.O45[1]) # MAGENTA + # Certain + if arc == AY: + inter = [self.O34[0], self.O34[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O34[0], self.O34[1]) + elif arc == AC: + inter = [self.O12[0], self.O12[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O12[0], self.O12[1]) + elif arc == AM: + inter = [self.O56[0], self.O56[1]] + total = self.Math_2D_Points_Distance(0, 0, self.O56[0], self.O56[1]) + # Intervals + elif (arc > AY and arc < AC): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O2[0], self.O2[1], self.O3[0], self.O3[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AC and arc < AM): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O1[0], self.O1[1], self.O6[0], self.O6[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif (arc > AM or arc < AY): + inter = list(self.Math_2D_Points_Lines_Intersection(self.O4[0], self.O4[1], self.O5[0], self.O5[1], 0, 0, u, v)) + total = self.Math_2D_Points_Distance(0, 0, inter[0], inter[1]) + elif diagonal >= 3: + inter = [0,0] + total = 0 + # Absolute Ration with Limit + duv = self.Math_2D_Points_Distance(0,0, self.ard_lock_value[0], self.ard_lock_value[1]) + if duv > total: + duv = total + try: + ratio = duv / total + except: + ratio = duv + return ratio + + #// + #\\ Channels Half ########################################################## + def Pigment_AAA_1_Half(self): + self.aaa_1 = half + self.Color_APPLY("AAA", self.aaa_1, 0, 0, 0) + + def Pigment_RGB_1_Half(self): + self.rgb_1 = half + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + def Pigment_RGB_2_Half(self): + self.rgb_2 = half + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + def Pigment_RGB_3_Half(self): + self.rgb_3 = half + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + + def Pigment_CMY_1_Half(self): + self.cmy_1 = half + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + def Pigment_CMY_2_Half(self): + self.cmy_2 = half + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + def Pigment_CMY_3_Half(self): + self.cmy_3 = half + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + + def Pigment_CMYK_1_Half(self): + self.cmyk_1 = half + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + def Pigment_CMYK_2_Half(self): + self.cmyk_2 = half + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + def Pigment_CMYK_3_Half(self): + self.cmyk_3 = half + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + def Pigment_CMYK_4_Half(self): + self.cmyk_4 = half + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + + def Pigment_RYB_1_Half(self): + self.ryb_1 = half + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + def Pigment_RYB_2_Half(self): + self.ryb_2 = half + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + def Pigment_RYB_3_Half(self): + self.ryb_3 = half + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + + def Pigment_YUV_1_Half(self): + self.yuv_1 = half + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + def Pigment_YUV_2_Half(self): + self.yuv_2 = half + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + def Pigment_YUV_3_Half(self): + self.yuv_3 = half + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + + def Pigment_KKK_1_Half(self): + self.kkk_0 = k_KKKhalf + self.Color_APPLY("KKK", self.kkk_0, 0, 0, 0) + + + def Pigment_ARD_1_Half(self): + # Nearest Pure Color Pick + angle = self.ard_1 * 360 + if (angle >= 0 and angle <= 30): + angle = 0 + elif (angle > 30 and angle <= 90): + angle = 60 + elif (angle > 90 and angle <= 150): + angle = 120 + elif (angle > 150 and angle <= 210): + angle = 180 + elif (angle > 210 and angle <= 270): + angle = 240 + elif (angle > 270 and angle <= 330): + angle = 300 + elif (angle > 330 and angle <= 360): + angle = 360 + self.ard_1 = angle / 360 + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + def Pigment_ARD_2_Half(self): + self.ard_2 = half + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + def Pigment_ARD_3_Half(self): + # Nearest Pure Color Pick + diagonal = self.ard_3 * 360 + if (diagonal >= 0 and diagonal <= 30): + diagonal = 0 + elif (diagonal > 30 and diagonal <= 90): + diagonal = 60 + elif (diagonal > 90 and diagonal <= 150): + diagonal = 120 + elif (diagonal > 150 and diagonal <= 210): + diagonal = 180 + elif (diagonal > 210 and diagonal <= 270): + diagonal = 240 + elif (diagonal > 270 and diagonal <= 330): + diagonal = 300 + elif (diagonal > 330 and diagonal <= 360): + diagonal = 360 + self.ard_3 = diagonal / 360 + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + + def Pigment_HSV_1_Half(self): + # Nearest Pure Color Pick + hue = self.hsv_1 * 360 + if (hue >= 0 and hue <= 30): + hue = 0 + elif (hue > 30 and hue <= 90): + hue = 60 + elif (hue > 90 and hue <= 150): + hue = 120 + elif (hue > 150 and hue <= 210): + hue = 180 + elif (hue > 210 and hue <= 270): + hue = 240 + elif (hue > 270 and hue <= 330): + hue = 300 + elif (hue > 330 and hue <= 360): + hue = 360 + self.hsv_1 = hue / 360 + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + def Pigment_HSV_2_Half(self): + self.hsv_2 = half + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + def Pigment_HSV_3_Half(self): + self.hsv_3 = half + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + + def Pigment_HSL_1_Half(self): + # Nearest Pure Color Pick + hue = self.hsl_1 * 360 + if (hue >= 0 and hue <= 30): + hue = 0 + elif (hue > 30 and hue <= 90): + hue = 60 + elif (hue > 90 and hue <= 150): + hue = 120 + elif (hue > 150 and hue <= 210): + hue = 180 + elif (hue > 210 and hue <= 270): + hue = 240 + elif (hue > 270 and hue <= 330): + hue = 300 + elif (hue > 330 and hue <= 360): + hue = 360 + self.hsl_1 = hue / 360 + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + def Pigment_HSL_2_Half(self): + self.hsl_2 = half + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + def Pigment_HSL_3_Half(self): + self.hsl_3 = half + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + + def Pigment_HCY_1_Half(self): + # Nearest Pure Color Pick + hue = self.hcy_1 * 360 + if (hue >= 0 and hue <= 30): + hue = 0 + elif (hue > 30 and hue <= 90): + hue = 60 + elif (hue > 90 and hue <= 150): + hue = 120 + elif (hue > 150 and hue <= 210): + hue = 180 + elif (hue > 210 and hue <= 270): + hue = 240 + elif (hue > 270 and hue <= 330): + hue = 300 + elif (hue > 330 and hue <= 360): + hue = 360 + self.hcy_1 = hue / 360 + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + def Pigment_HCY_2_Half(self): + self.hcy_2 = half + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + def Pigment_HCY_3_Half(self): + self.hcy_3 = half + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + + + def Pigment_XYZ_1_Half(self): + self.xyz_1 = half + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + def Pigment_XYZ_2_Half(self): + self.xyz_2 = half + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + def Pigment_XYZ_3_Half(self): + self.xyz_3 = half + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + + def Pigment_XYY_1_Half(self): + self.xyy_1 = half + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + def Pigment_XYY_2_Half(self): + self.xyy_2 = half + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + def Pigment_XYY_3_Half(self): + self.xyy_3 = half + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + + def Pigment_LAB_1_Half(self): + self.lab_1 = half + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + def Pigment_LAB_2_Half(self): + self.lab_2 = half + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + def Pigment_LAB_3_Half(self): + self.lab_3 = half + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + + #// + #\\ Channels Minus ######################################################### + def Pigment_AAA_1_Minus(self): + self.aaa_1 = self.aaa_1 - u_RGB + if self.aaa_1 <= zero: + self.aaa_1 = zero + self.Color_APPLY("AAA", self.aaa_1, 0, 0, 0) + + def Pigment_RGB_1_Minus(self): + self.rgb_1 = self.rgb_1 - u_RGB + if self.rgb_1 <= zero: + self.rgb_1 = zero + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + def Pigment_RGB_2_Minus(self): + self.rgb_2 = self.rgb_2 - u_RGB + if self.rgb_2 <= zero: + self.rgb_2 = zero + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + def Pigment_RGB_3_Minus(self): + self.rgb_3 = self.rgb_3 - u_RGB + if self.rgb_3 <= zero: + self.rgb_3 = zero + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + + def Pigment_CMY_1_Minus(self): + self.cmy_1 = self.cmy_1 - u_CMY + if self.cmy_1 <= zero: + self.cmy_1 = zero + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + def Pigment_CMY_2_Minus(self): + self.cmy_2 = self.cmy_2 - u_CMY + if self.cmy_2 <= zero: + self.cmy_2 = zero + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + def Pigment_CMY_3_Minus(self): + self.cmy_3 = self.cmy_3 - u_CMY + if self.cmy_3 <= zero: + self.cmy_3 = zero + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + + def Pigment_CMYK_1_Minus(self): + self.cmyk_1 = self.cmyk_1 - u_CMYK + if self.cmyk_1 <= zero: + self.cmyk_1 = zero + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + def Pigment_CMYK_2_Minus(self): + self.cmyk_2 = self.cmyk_2 - u_CMYK + if self.cmyk_2 <= zero: + self.cmyk_2 = zero + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + def Pigment_CMYK_3_Minus(self): + self.cmyk_3 = self.cmyk_3 - u_CMYK + if self.cmyk_3 <= zero: + self.cmyk_3 = zero + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + def Pigment_CMYK_4_Minus(self): + self.cmyk_4 = self.cmyk_4 - u_CMYK + if self.cmyk_4 <= zero: + self.cmyk_4 = zero + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + + def Pigment_RYB_1_Minus(self): + self.ryb_1 = self.ryb_1 - u_RYB + if self.ryb_1 <= zero: + self.ryb_1 = zero + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + def Pigment_RYB_2_Minus(self): + self.ryb_2 = self.ryb_2 - u_RYB + if self.ryb_2 <= zero: + self.ryb_2 = zero + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + def Pigment_RYB_3_Minus(self): + self.ryb_3 = self.ryb_3 - u_RYB + if self.ryb_3 <= zero: + self.ryb_3 = zero + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + + def Pigment_YUV_1_Minus(self): + self.yuv_1 = self.yuv_1 - u_YYY + if self.yuv_1 <= zero: + self.yuv_1 = zero + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + def Pigment_YUV_2_Minus(self): + self.yuv_2 = self.yuv_2 - u_UV + if self.yuv_2 <= zero: + self.yuv_2 = zero + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + def Pigment_YUV_3_Minus(self): + self.yuv_3 = self.yuv_3 - u_UV + if self.yuv_3 <= zero: + self.yuv_3 = zero + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + + def Pigment_KKK_1_Minus(self): + self.kkk_0 = self.kkk_0 - k_KKKunit + if self.kkk_0 <= zero: + self.kkk_0 = zero + self.Color_APPLY("KKK", self.kkk_0, 0, 0, 0) + + + def Pigment_ARD_1_Minus(self): + self.ard_1 = self.ard_1 - u_HUE + if self.ard_1 < zero: + self.ard_1 = unit + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + def Pigment_ARD_2_Minus(self): + self.ard_2 = self.ard_2 - u_SVL + if self.ard_2 <= zero: + self.ard_2 = zero + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + def Pigment_ARD_3_Minus(self): + self.ard_3 = self.ard_3 - u_SVL + if self.ard_3 <= zero: + self.ard_3 = zero + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + + def Pigment_HSV_1_Minus(self): + self.hsv_1 = self.hsv_1 - u_HUE + if self.hsv_1 < zero: + self.hsv_1 = unit + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + def Pigment_HSV_2_Minus(self): + self.hsv_2 = self.hsv_2 - u_SVL + if self.hsv_2 <= zero: + self.hsv_2 = zero + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + def Pigment_HSV_3_Minus(self): + self.hsv_3 = self.hsv_3 - u_SVL + if self.hsv_3 <= zero: + self.hsv_3 = zero + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + + def Pigment_HSL_1_Minus(self): + self.hsl_1 = self.hsl_1 - u_HUE + if self.hsl_1 < zero: + self.hsl_1 = unit + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + def Pigment_HSL_2_Minus(self): + self.hsl_2 = self.hsl_2 - u_SVL + if self.hsl_2 <= zero: + self.hsl_2 = zero + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + def Pigment_HSL_3_Minus(self): + self.hsl_3 = self.hsl_3 - u_SVL + if self.hsl_3 <= zero: + self.hsl_3 = zero + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + + def Pigment_HCY_1_Minus(self): + self.hcy_1 = self.hcy_1 - u_HUE + if self.hcy_1 < zero: + self.hcy_1 = unit + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + def Pigment_HCY_2_Minus(self): + self.hcy_2 = self.hcy_2 - u_SVL + if self.hcy_2 <= zero: + self.hcy_2 = zero + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + def Pigment_HCY_3_Minus(self): + self.hcy_3 = self.hcy_3 - u_SVL + if self.hcy_3 <= zero: + self.hcy_3 = zero + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + + + def Pigment_XYZ_1_Minus(self): + self.xyz_1 = self.xyz_1 - u_XYZ + if self.xyz_1 <= zero: + self.xyz_1 = zero + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + def Pigment_XYZ_2_Minus(self): + self.xyz_2 = self.xyz_2 - u_XYZ + if self.xyz_2 <= zero: + self.xyz_2 = zero + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + def Pigment_XYZ_3_Minus(self): + self.xyz_3 = self.xyz_3 - u_XYZ + if self.xyz_3 <= zero: + self.xyz_3 = zero + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + + def Pigment_XYY_1_Minus(self): + self.xyy_1 = self.xyy_1 - u_XYY + if self.xyy_1 <= zero: + self.xyy_1 = zero + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + def Pigment_XYY_2_Minus(self): + self.xyy_2 = self.xyy_2 - u_XYY + if self.xyy_2 <= zero: + self.xyy_2 = zero + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + def Pigment_XYY_3_Minus(self): + self.xyy_3 = self.xyy_3 - u_XYY + if self.xyy_3 <= zero: + self.xyy_3 = zero + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + + def Pigment_LAB_1_Minus(self): + self.lab_1 = self.lab_1 - u_LLL + if self.lab_1 <= zero: + self.lab_1 = zero + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + def Pigment_LAB_2_Minus(self): + self.lab_2 = self.lab_2 - u_AB + if self.lab_2 <= zero: + self.lab_2 = zero + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + def Pigment_LAB_3_Minus(self): + self.lab_3 = self.lab_3 - u_AB + if self.lab_3 <= zero: + self.lab_3 = zero + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + + #// + #\\ Channels Plus ########################################################## + def Pigment_AAA_1_Plus(self): + self.aaa_1 = self.aaa_1 + u_AAA + if self.aaa_1 >= unit: + self.aaa_1 = unit + self.Color_APPLY("AAA", self.aaa_1, 0, 0, 0) + + def Pigment_RGB_1_Plus(self): + self.rgb_1 = self.rgb_1 + u_RGB + if self.rgb_1 >= unit: + self.rgb_1 = unit + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + def Pigment_RGB_2_Plus(self): + self.rgb_2 = self.rgb_2 + u_RGB + if self.rgb_2 >= unit: + self.rgb_2 = unit + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + def Pigment_RGB_3_Plus(self): + self.rgb_3 = self.rgb_3 + u_RGB + if self.rgb_3 >= unit: + self.rgb_3 = unit + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + + def Pigment_CMY_1_Plus(self): + self.cmy_1 = self.cmy_1 + u_CMY + if self.cmy_1 >= unit: + self.cmy_1 = unit + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + def Pigment_CMY_2_Plus(self): + self.cmy_2 = self.cmy_2 + u_CMY + if self.cmy_2 >= unit: + self.cmy_2 = unit + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + def Pigment_CMY_3_Plus(self): + self.cmy_3 = self.cmy_3 + u_CMY + if self.cmy_3 >= unit: + self.cmy_3 = unit + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + + def Pigment_CMYK_1_Plus(self): + self.cmyk_1 = self.cmyk_1 + u_CMYK + if self.cmyk_1 >= unit: + self.cmyk_1 = unit + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + def Pigment_CMYK_2_Plus(self): + self.cmyk_2 = self.cmyk_2 + u_CMYK + if self.cmyk_2 >= unit: + self.cmyk_2 = unit + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + def Pigment_CMYK_3_Plus(self): + self.cmyk_3 = self.cmyk_3 + u_CMYK + if self.cmyk_3 >= unit: + self.cmyk_3 = unit + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + def Pigment_CMYK_4_Plus(self): + self.cmyk_4 = self.cmyk_4 + u_CMYK + if self.cmyk_4 >= unit: + self.cmyk_4 = unit + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + + def Pigment_RYB_1_Plus(self): + self.ryb_1 = self.ryb_1 + u_RYB + if self.ryb_1 >= unit: + self.ryb_1 = unit + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + def Pigment_RYB_2_Plus(self): + self.ryb_2 = self.ryb_2 + u_RYB + if self.ryb_2 >= unit: + self.ryb_2 = unit + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + def Pigment_RYB_3_Plus(self): + self.ryb_3 = self.ryb_3 + u_RYB + if self.ryb_3 >= unit: + self.ryb_3 = unit + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + + def Pigment_YUV_1_Plus(self): + self.yuv_1 = self.yuv_1 + u_YYY + if self.yuv_1 >= unit: + self.yuv_1 = unit + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + def Pigment_YUV_2_Plus(self): + self.yuv_2 = self.yuv_2 + u_UV + if self.yuv_2 >= unit: + self.yuv_2 = unit + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + def Pigment_YUV_3_Plus(self): + self.yuv_3 = self.yuv_3 + u_UV + if self.yuv_3 >= unit: + self.yuv_3 = unit + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + + def Pigment_KKK_1_Plus(self): + self.kkk_0 = self.kkk_0 + k_KKKunit + if self.kkk_0 >= k_KKKmax: + self.kkk_0 = k_KKKmax + self.Color_APPLY("KKK", self.kkk_0, 0, 0, 0) + + + def Pigment_ARD_1_Plus(self): + self.ard_1 = self.ard_1 + u_HUE + if self.ard_1 > unit: + self.ard_1 = zero + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + def Pigment_ARD_2_Plus(self): + self.ard_2 = self.ard_2 + u_SVL + if self.ard_2 >= unit: + self.ard_2 = unit + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + def Pigment_ARD_3_Plus(self): + self.ard_3 = self.ard_3 + u_SVL + if self.ard_3 >= unit: + self.ard_3 = unit + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + + def Pigment_HSV_1_Plus(self): + self.hsv_1 = self.hsv_1 + u_HUE + if self.hsv_1 > unit: + self.hsv_1 = zero + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + def Pigment_HSV_2_Plus(self): + self.hsv_2 = self.hsv_2 + u_SVL + if self.hsv_2 >= unit: + self.hsv_2 = unit + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + def Pigment_HSV_3_Plus(self): + self.hsv_3 = self.hsv_3 + u_SVL + if self.hsv_3 >= unit: + self.hsv_3 = unit + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + + def Pigment_HSL_1_Plus(self): + self.hsl_1 = self.hsl_1 + u_HUE + if self.hsl_1 > unit: + self.hsl_1 = zero + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + def Pigment_HSL_2_Plus(self): + self.hsl_2 = self.hsl_2 + u_SVL + if self.hsl_2 >= unit: + self.hsl_2 = unit + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + def Pigment_HSL_3_Plus(self): + self.hsl_3 = self.hsl_3 + u_SVL + if self.hsl_3 >= unit: + self.hsl_3 = unit + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + + def Pigment_HCY_1_Plus(self): + self.hcy_1 = self.hcy_1 + u_HUE + if self.hcy_1 > unit: + self.hcy_1 = zero + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + def Pigment_HCY_2_Plus(self): + self.hcy_2 = self.hcy_2 + u_SVL + if self.hcy_2 >= unit: + self.hcy_2 = unit + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + def Pigment_HCY_3_Plus(self): + self.hcy_3 = self.hcy_3 + u_SVL + if self.hcy_3 >= unit: + self.hcy_3 = unit + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + + + def Pigment_XYZ_1_Plus(self): + self.xyz_1 = self.xyz_1 + u_XYZ + if self.xyz_1 >= unit: + self.xyz_1 = unit + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + def Pigment_XYZ_2_Plus(self): + self.xyz_2 = self.xyz_2 + u_XYZ + if self.xyz_2 >= unit: + self.xyz_2 = unit + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + def Pigment_XYZ_3_Plus(self): + self.xyz_3 = self.xyz_3 + u_XYZ + if self.xyz_3 >= unit: + self.xyz_3 = unit + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + + def Pigment_XYY_1_Plus(self): + self.xyy_1 = self.xyy_1 + u_XYY + if self.xyy_1 >= unit: + self.xyy_1 = unit + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + def Pigment_XYY_2_Plus(self): + self.xyy_2 = self.xyy_2 + u_XYY + if self.xyy_2 >= unit: + self.xyy_2 = unit + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + def Pigment_XYY_3_Plus(self): + self.xyy_3 = self.xyy_3 + u_XYY + if self.xyy_3 >= unit: + self.xyy_3 = unit + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + + def Pigment_LAB_1_Plus(self): + self.lab_1 = self.lab_1 + u_LLL + if self.lab_1 >= unit: + self.lab_1 = unit + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + def Pigment_LAB_2_Plus(self): + self.lab_2 = self.lab_2 + u_AB + if self.lab_2 >= unit: + self.lab_2 = unit + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + def Pigment_LAB_3_Plus(self): + self.lab_3 = self.lab_3 + u_AB + if self.lab_3 >= unit: + self.lab_3 = unit + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + + #// + #\\ Channels Slider Modify ################################################# + def Pigment_AAA_1_Slider_Modify(self, SIGNAL_VALUE): + self.aaa_1 = SIGNAL_VALUE + self.Color_APPLY("AAA", self.aaa_1, 0, 0, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + def Pigment_RGB_1_Slider_Modify(self, SIGNAL_VALUE): + self.rgb_1 = SIGNAL_VALUE + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_RGB_2_Slider_Modify(self, SIGNAL_VALUE): + self.rgb_2 = SIGNAL_VALUE + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_RGB_3_Slider_Modify(self, SIGNAL_VALUE): + self.rgb_3 = SIGNAL_VALUE + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + def Pigment_CMY_1_Slider_Modify(self, SIGNAL_VALUE): + self.cmy_1 = SIGNAL_VALUE + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_CMY_2_Slider_Modify(self, SIGNAL_VALUE): + self.cmy_2 = SIGNAL_VALUE + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_CMY_3_Slider_Modify(self, SIGNAL_VALUE): + self.cmy_3 = SIGNAL_VALUE + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + def Pigment_CMYK_1_Slider_Modify(self, SIGNAL_VALUE): + self.cmyk_1 = SIGNAL_VALUE + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_CMYK_2_Slider_Modify(self, SIGNAL_VALUE): + self.cmyk_2 = SIGNAL_VALUE + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_CMYK_3_Slider_Modify(self, SIGNAL_VALUE): + self.cmyk_3 = SIGNAL_VALUE + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_CMYK_4_Slider_Modify(self, SIGNAL_VALUE): + self.cmyk_4 = SIGNAL_VALUE + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + def Pigment_RYB_1_Slider_Modify(self, SIGNAL_VALUE): + self.ryb_1 = SIGNAL_VALUE + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_RYB_2_Slider_Modify(self, SIGNAL_VALUE): + self.ryb_2 = SIGNAL_VALUE + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_RYB_3_Slider_Modify(self, SIGNAL_VALUE): + self.ryb_3 = SIGNAL_VALUE + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + def Pigment_YUV_1_Slider_Modify(self, SIGNAL_VALUE): + self.yuv_1 = SIGNAL_VALUE + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_YUV_2_Slider_Modify(self, SIGNAL_VALUE): + self.yuv_2 = SIGNAL_VALUE + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.layout.label.setText(str(round(-50+SIGNAL_VALUE*100,2))+" %") + def Pigment_YUV_3_Slider_Modify(self, SIGNAL_VALUE): + self.yuv_3 = SIGNAL_VALUE + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.layout.label.setText(str(round(-50+SIGNAL_VALUE*100,2))+" %") + + def Pigment_KKK_1_Slider_Modify(self, SIGNAL_VALUE): + self.kkk_0 = int((SIGNAL_VALUE * k_KKKdelta) + k_KKKmin) + self.Color_APPLY("KKK", self.kkk_0, 0, 0, 0) + + + def Pigment_ARD_1_Slider_Modify(self, SIGNAL_VALUE): + self.ard_1 = SIGNAL_VALUE + if self.ard_lock == True: + self.ard_2 = self.ARD_1_Value_Lock_Ratio(SIGNAL_VALUE) + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*360,2))+" º") + def Pigment_ARD_2_Slider_Modify(self, SIGNAL_VALUE): + self.ard_2 = SIGNAL_VALUE + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_ARD_3_Slider_Modify(self, SIGNAL_VALUE): + self.ard_3 = SIGNAL_VALUE + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + def Pigment_HSV_1_Slider_Modify(self, SIGNAL_VALUE): + self.hsv_1 = SIGNAL_VALUE + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*360,2))+" º") + def Pigment_HSV_2_Slider_Modify(self, SIGNAL_VALUE): + self.hsv_2 = SIGNAL_VALUE + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_HSV_3_Slider_Modify(self, SIGNAL_VALUE): + self.hsv_3 = SIGNAL_VALUE + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + def Pigment_HSL_1_Slider_Modify(self, SIGNAL_VALUE): + self.hsl_1 = SIGNAL_VALUE + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*360,2))+" º") + def Pigment_HSL_2_Slider_Modify(self, SIGNAL_VALUE): + self.hsl_2 = SIGNAL_VALUE + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_HSL_3_Slider_Modify(self, SIGNAL_VALUE): + self.hsl_3 = SIGNAL_VALUE + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + def Pigment_HCY_1_Slider_Modify(self, SIGNAL_VALUE): + self.hcy_1 = SIGNAL_VALUE + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*360,2))+" º") + def Pigment_HCY_2_Slider_Modify(self, SIGNAL_VALUE): + self.hcy_2 = SIGNAL_VALUE + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_HCY_3_Slider_Modify(self, SIGNAL_VALUE): + self.hcy_3 = SIGNAL_VALUE + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + + def Pigment_XYZ_1_Slider_Modify(self, SIGNAL_VALUE): + self.xyz_1 = SIGNAL_VALUE + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_XYZ_2_Slider_Modify(self, SIGNAL_VALUE): + self.xyz_2 = SIGNAL_VALUE + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_XYZ_3_Slider_Modify(self, SIGNAL_VALUE): + self.xyz_3 = SIGNAL_VALUE + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + def Pigment_XYY_1_Slider_Modify(self, SIGNAL_VALUE): + self.xyy_1 = SIGNAL_VALUE + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_XYY_2_Slider_Modify(self, SIGNAL_VALUE): + self.xyy_2 = SIGNAL_VALUE + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_XYY_3_Slider_Modify(self, SIGNAL_VALUE): + self.xyy_3 = SIGNAL_VALUE + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + def Pigment_LAB_1_Slider_Modify(self, SIGNAL_VALUE): + self.lab_1 = SIGNAL_VALUE + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_LAB_2_Slider_Modify(self, SIGNAL_VALUE): + self.lab_2 = SIGNAL_VALUE + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + def Pigment_LAB_3_Slider_Modify(self, SIGNAL_VALUE): + self.lab_3 = SIGNAL_VALUE + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.layout.label.setText(str(round(SIGNAL_VALUE*100,2))+" %") + + #// + #\\ Channels Slider Release ################################################ + def Pigment_AAA_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_APPLY("AAA", self.aaa_1, 0, 0, 0) + self.Pigment_Release() + + def Pigment_RGB_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Pigment_Release() + def Pigment_RGB_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Pigment_Release() + def Pigment_RGB_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Pigment_Release() + + def Pigment_CMY_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Pigment_Release() + def Pigment_CMY_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Pigment_Release() + def Pigment_CMY_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Pigment_Release() + + def Pigment_CMYK_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Pigment_Release() + def Pigment_CMYK_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Pigment_Release() + def Pigment_CMYK_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Pigment_Release() + def Pigment_CMYK_4_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Pigment_Release() + + def Pigment_RYB_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Pigment_Release() + def Pigment_RYB_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Pigment_Release() + def Pigment_RYB_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Pigment_Release() + + def Pigment_YUV_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Pigment_Release() + def Pigment_YUV_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Pigment_Release() + def Pigment_YUV_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Pigment_Release() + + def Pigment_KKK_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_APPLY("KKK", self.kkk_0, 0, 0, 0) + self.Pigment_Release() + + + def Pigment_ARD_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Pigment_Release() + def Pigment_ARD_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Pigment_Release() + def Pigment_ARD_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Pigment_Release() + + def Pigment_HSV_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Pigment_Release() + def Pigment_HSV_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Pigment_Release() + def Pigment_HSV_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Pigment_Release() + + def Pigment_HSL_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Pigment_Release() + def Pigment_HSL_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Pigment_Release() + def Pigment_HSL_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Pigment_Release() + + def Pigment_HCY_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Pigment_Release() + def Pigment_HCY_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Pigment_Release() + def Pigment_HCY_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Pigment_Release() + + + def Pigment_XYZ_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Pigment_Release() + def Pigment_XYZ_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Pigment_Release() + def Pigment_XYZ_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Pigment_Release() + + def Pigment_XYY_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Pigment_Release() + def Pigment_XYY_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Pigment_Release() + def Pigment_XYY_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Pigment_Release() + + def Pigment_LAB_1_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Pigment_Release() + def Pigment_LAB_2_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Pigment_Release() + def Pigment_LAB_3_Slider_Release(self, SIGNAL_RELEASE): + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Pigment_Release() + + #// + #\\ Channels Values Modify ################################################# + def Pigment_AAA_1_Value_Modify(self): + self.aaa_1 = self.layout.aaa_1_value.value() / k_AAA + self.Color_APPLY("AAA", self.aaa_1, 0, 0, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.aaa_1*100,2))+" %") + + def Pigment_RGB_1_Value_Modify(self): + self.rgb_1 = self.layout.rgb_1_value.value() / k_RGB + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.rgb_1*100,2))+" %") + def Pigment_RGB_2_Value_Modify(self): + self.rgb_2 = self.layout.rgb_2_value.value() / k_RGB + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.rgb_2*100,2))+" %") + def Pigment_RGB_3_Value_Modify(self): + self.rgb_3 = self.layout.rgb_3_value.value() / k_RGB + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.rgb_3*100,2))+" %") + + def Pigment_CMY_1_Value_Modify(self): + self.cmy_1 = self.layout.cmy_1_value.value() / k_CMY + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.cmy_1*100,2))+" %") + def Pigment_CMY_2_Value_Modify(self): + self.cmy_2 = self.layout.cmy_2_value.value() / k_CMY + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.cmy_2*100,2))+" %") + def Pigment_CMY_3_Value_Modify(self): + self.cmy_3 = self.layout.cmy_3_value.value() / k_CMY + self.Color_HUE("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Color_APPLY("CMY", self.cmy_1, self.cmy_2, self.cmy_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.cmy_3*100,2))+" %") + + def Pigment_CMYK_1_Value_Modify(self): + self.cmyk_1 = self.layout.cmyk_1_value.value() / k_CMYK + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Pigment_Release() + self.layout.label.setText(str(round(self.cmyk_1*100,2))+" %") + def Pigment_CMYK_2_Value_Modify(self): + self.cmyk_2 = self.layout.cmyk_2_value.value() / k_CMYK + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Pigment_Release() + self.layout.label.setText(str(round(self.cmyk_2*100,2))+" %") + def Pigment_CMYK_3_Value_Modify(self): + self.cmyk_3 = self.layout.cmyk_3_value.value() / k_CMYK + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Pigment_Release() + self.layout.label.setText(str(round(self.cmyk_3*100,2))+" %") + def Pigment_CMYK_4_Value_Modify(self): + self.cmyk_4 = self.layout.cmyk_4_value.value() / k_CMYK + self.Color_HUE("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Color_APPLY("CMYK", self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4) + self.Pigment_Release() + self.layout.label.setText(str(round(self.cmyk_4*100,2))+" %") + + def Pigment_RYB_1_Value_Modify(self): + self.rgb_1 = self.layout.rgb_1_value.value() / k_RYB + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.rgb_1*100,2))+" %") + def Pigment_RYB_2_Value_Modify(self): + self.rgb_2 = self.layout.rgb_2_value.value() / k_RYB + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.rgb_2*100,2))+" %") + def Pigment_RYB_3_Value_Modify(self): + self.rgb_3 = self.layout.rgb_3_value.value() / k_RYB + self.Color_HUE("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Color_APPLY("RYB", self.ryb_1, self.ryb_2, self.ryb_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.rgb_3*100,2))+" %") + + def Pigment_YUV_1_Value_Modify(self): + self.yuv_1 = self.layout.yuv_1_value.value() / k_YYY + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.yuv_1*100,2))+" %") + def Pigment_YUV_2_Value_Modify(self): + self.yuv_2 = self.layout.yuv_2_value.value() / k_UV + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(-50+self.yuv_2*100,2))+" %") + def Pigment_YUV_3_Value_Modify(self): + self.yuv_3 = self.layout.yuv_3_value.value() / k_UV + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(-50+self.yuv_3*100,2))+" %") + + def Pigment_KKK_1_Value_Modify(self): + self.kkk_0 = self.layout.kkk_1_value.value() + # self.kkk_1_slider.Update((self.kkk_0 - k_KKKmin) / k_KKKdelta, self.channel_width) + self.Color_APPLY("KKK", self.kkk_0, 0, 0, 0) + self.Pigment_Release() + + + def Pigment_ARD_1_Value_Modify(self): + self.ard_1 = self.layout.ard_1_value.value() / k_HUE + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.ard_1*100,2))+" º") + def Pigment_ARD_2_Value_Modify(self): + self.ard_2 = self.layout.ard_2_value.value() / k_SVL + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.ard_2*100,2))+" %") + def Pigment_ARD_3_Value_Modify(self): + self.ard_3 = self.layout.ard_3_value.value() / k_SVL + self.Color_HUE("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.ard_3*100,2))+" %") + + def Pigment_HSV_1_Value_Modify(self): + self.hsv_1 = self.layout.hsv_1_value.value() / k_HUE + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.hsv_1*100,2))+" º") + def Pigment_HSV_2_Value_Modify(self): + self.hsv_2 = self.layout.hsv_2_value.value() / k_SVL + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.hsv_2*100,2))+" %") + def Pigment_HSV_3_Value_Modify(self): + self.hsv_3 = self.layout.hsv_3_value.value() / k_SVL + self.Color_HUE("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.hsv_3*100,2))+" %") + + def Pigment_HSL_1_Value_Modify(self): + self.hsl_1 = self.layout.hsl_1_value.value() / k_HUE + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.hsl_1*100,2))+" º") + def Pigment_HSL_2_Value_Modify(self): + self.hsl_2 = self.layout.hsl_2_value.value() / k_SVL + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.hsl_2*100,2))+" %") + def Pigment_HSL_3_Value_Modify(self): + self.hsl_3 = self.layout.hsl_3_value.value() / k_SVL + self.Color_HUE("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.hsl_3*100,2))+" %") + + def Pigment_HCY_1_Value_Modify(self): + self.hcy_1 = self.layout.hcy_1_value.value() / k_HUE + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.hcy_1*100,2))+" º") + def Pigment_HCY_2_Value_Modify(self): + self.hcy_2 = self.layout.hcy_2_value.value() / k_SVL + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.hcy_2*100,2))+" %") + def Pigment_HCY_3_Value_Modify(self): + self.hcy_3 = self.layout.hcy_3_value.value() / k_SVL + self.Color_HUE("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.hcy_3*100,2))+" %") + + + def Pigment_XYZ_1_Value_Modify(self): + self.xyz_1 = self.layout.xyz_1_value.value() / k_XYZ + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.xyz_1*100,2))+" %") + def Pigment_XYZ_2_Value_Modify(self): + self.xyz_2 = self.layout.xyz_2_value.value() / k_XYZ + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.xyz_2*100,2))+" %") + def Pigment_XYZ_3_Value_Modify(self): + self.xyz_3 = self.layout.xyz_3_value.value() / k_XYZ + self.Color_HUE("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Color_APPLY("XYZ", self.xyz_1, self.xyz_2, self.xyz_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.xyz_3*100,2))+" %") + + def Pigment_XYY_1_Value_Modify(self): + self.xyy_1 = self.layout.xyy_1_value.value() / k_XYY + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.xyy_1*100,2))+" %") + def Pigment_XYY_2_Value_Modify(self): + self.xyy_2 = self.layout.xyy_2_value.value() / k_XYY + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.xyy_2*100,2))+" %") + def Pigment_XYY_3_Value_Modify(self): + self.xyy_3 = self.layout.xyy_3_value.value() / k_XYY + self.Color_HUE("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Color_APPLY("XYY", self.xyy_1, self.xyy_2, self.xyy_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.xyy_3*100,2))+" %") + + def Pigment_LAB_1_Value_Modify(self): + self.lab_1 = self.layout.lab_1_value.value() / k_LLL + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.lab_1*100,2))+" %") + def Pigment_LAB_2_Value_Modify(self): + self.lab_2 = self.layout.lab_2_value.value() / k_AB + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.lab_2*100,2))+" %") + def Pigment_LAB_3_Value_Modify(self): + self.lab_3 = self.layout.lab_3_value.value() / k_AB + self.Color_HUE("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Color_APPLY("LAB", self.lab_1, self.lab_2, self.lab_3, 0) + self.Pigment_Release() + self.layout.label.setText(str(round(self.lab_3*100,2))+" %") + + #// + #\\ Channels Value Release ################################################# + def Pigment_AAA_1_Value_Release(self): + self.layout.aaa_1_value.clearFocus() + + def Pigment_RGB_1_Value_Release(self): + self.layout.rgb_1_value.clearFocus() + def Pigment_RGB_2_Value_Release(self): + self.layout.rgb_2_value.clearFocus() + def Pigment_RGB_3_Value_Release(self): + self.layout.rgb_3_value.clearFocus() + + def Pigment_CMY_1_Value_Release(self): + self.layout.cmy_1_value.clearFocus() + def Pigment_CMY_2_Value_Release(self): + self.layout.cmy_2_value.clearFocus() + def Pigment_CMY_3_Value_Release(self): + self.layout.cmy_3_value.clearFocus() + + def Pigment_CMYK_1_Value_Release(self): + self.layout.cmyk_1_value.clearFocus() + def Pigment_CMYK_2_Value_Release(self): + self.layout.cmyk_2_value.clearFocus() + def Pigment_CMYK_3_Value_Release(self): + self.layout.cmyk_3_value.clearFocus() + def Pigment_CMYK_4_Value_Release(self): + self.layout.cmyk_4_value.clearFocus() + + def Pigment_RYB_1_Value_Release(self): + self.layout.ryb_1_value.clearFocus() + def Pigment_RYB_2_Value_Release(self): + self.layout.ryb_2_value.clearFocus() + def Pigment_RYB_3_Value_Release(self): + self.layout.ryb_3_value.clearFocus() + + def Pigment_YUV_1_Value_Release(self): + self.layout.yuv_1_value.clearFocus() + def Pigment_YUV_2_Value_Release(self): + self.layout.yuv_2_value.clearFocus() + def Pigment_YUV_3_Value_Release(self): + self.layout.yuv_3_value.clearFocus() + + def Pigment_KKK_1_Value_Release(self): + self.layout.kkk_1_value.clearFocus() + + + def Pigment_ARD_1_Value_Release(self): + self.layout.ard_1_value.clearFocus() + def Pigment_ARD_2_Value_Release(self): + self.layout.ard_2_value.clearFocus() + def Pigment_ARD_3_Value_Release(self): + self.layout.ard_3_value.clearFocus() + + def Pigment_HSV_1_Value_Release(self): + self.layout.hsv_1_value.clearFocus() + def Pigment_HSV_2_Value_Release(self): + self.layout.hsv_2_value.clearFocus() + def Pigment_HSV_3_Value_Release(self): + self.layout.hsv_3_value.clearFocus() + + def Pigment_HSL_1_Value_Release(self): + self.layout.hsl_1_value.clearFocus() + def Pigment_HSL_2_Value_Release(self): + self.layout.hsl_2_value.clearFocus() + def Pigment_HSL_3_Value_Release(self): + self.layout.hsl_3_value.clearFocus() + + def Pigment_HCY_1_Value_Release(self): + self.layout.hcy_1_value.clearFocus() + def Pigment_HCY_2_Value_Release(self): + self.layout.hcy_2_value.clearFocus() + def Pigment_HCY_3_Value_Release(self): + self.layout.hcy_3_value.clearFocus() + + + def Pigment_XYZ_1_Value_Release(self): + self.layout.xyz_1_value.clearFocus() + def Pigment_XYZ_2_Value_Release(self): + self.layout.xyz_2_value.clearFocus() + def Pigment_XYZ_3_Value_Release(self): + self.layout.xyz_3_value.clearFocus() + + def Pigment_XYY_1_Value_Release(self): + self.layout.xyy_1_value.clearFocus() + def Pigment_XYY_2_Value_Release(self): + self.layout.xyy_2_value.clearFocus() + def Pigment_XYY_3_Value_Release(self): + self.layout.xyy_3_value.clearFocus() + + def Pigment_LAB_1_Value_Release(self): + self.layout.lab_1_value.clearFocus() + def Pigment_LAB_2_Value_Release(self): + self.layout.lab_2_value.clearFocus() + def Pigment_LAB_3_Value_Release(self): + self.layout.lab_3_value.clearFocus() + + #// + #\\ Palette ################################################################ + def Cor_00_APPLY(self, SIGNAL_CLICKS): + if self.cor_00[0] == True: + self.Color_HUE("RGB", self.cor_00[1], self.cor_00[2], self.cor_00[3], 0) + self.Color_APPLY("RGB", self.cor_00[1], self.cor_00[2], self.cor_00[3], 0) + self.Pigment_Release() + def Cor_00_SAVE(self, SIGNAL_CLICKS): + self.cor_00 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_00[1]*255, self.cor_00[2]*255, self.cor_00[3]*255)) + self.layout.cor_00.setStyleSheet(color) + def Cor_00_CLEAN(self, SIGNAL_CLICKS): + self.cor_00 = [False, 0, 0, 0] + self.layout.cor_00.setStyleSheet(self.bg_alpha) + + def Cor_01_APPLY(self, SIGNAL_CLICKS): + if self.cor_01[0] == True: + self.Color_HUE("RGB", self.cor_01[1], self.cor_01[2], self.cor_01[3], 0) + self.Color_APPLY("RGB", self.cor_01[1], self.cor_01[2], self.cor_01[3], 0) + self.Pigment_Release() + def Cor_01_SAVE(self, SIGNAL_CLICKS): + self.cor_01 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_01[1]*255, self.cor_01[2]*255, self.cor_01[3]*255)) + self.layout.cor_01.setStyleSheet(color) + def Cor_01_CLEAN(self, SIGNAL_CLICKS): + self.cor_01 = [False, 0, 0, 0] + self.layout.cor_01.setStyleSheet(self.bg_alpha) + + def Cor_02_APPLY(self, SIGNAL_CLICKS): + if self.cor_02[0] == True: + self.Color_HUE("RGB", self.cor_02[1], self.cor_02[2], self.cor_02[3], 0) + self.Color_APPLY("RGB", self.cor_02[1], self.cor_02[2], self.cor_02[3], 0) + self.Pigment_Release() + def Cor_02_SAVE(self, SIGNAL_CLICKS): + self.cor_02 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_02[1]*255, self.cor_02[2]*255, self.cor_02[3]*255)) + self.layout.cor_02.setStyleSheet(color) + def Cor_02_CLEAN(self, SIGNAL_CLICKS): + self.cor_02 = [False, 0, 0, 0] + self.layout.cor_02.setStyleSheet(self.bg_alpha) + + def Cor_03_APPLY(self, SIGNAL_CLICKS): + if self.cor_03[0] == True: + self.Color_HUE("RGB", self.cor_03[1], self.cor_03[2], self.cor_03[3], 0) + self.Color_APPLY("RGB", self.cor_03[1], self.cor_03[2], self.cor_03[3], 0) + self.Pigment_Release() + def Cor_03_SAVE(self, SIGNAL_CLICKS): + self.cor_03 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_03[1]*255, self.cor_03[2]*255, self.cor_03[3]*255)) + self.layout.cor_03.setStyleSheet(color) + def Cor_03_CLEAN(self, SIGNAL_CLICKS): + self.cor_03 = [False, 0, 0, 0] + self.layout.cor_03.setStyleSheet(self.bg_alpha) + + def Cor_04_APPLY(self, SIGNAL_CLICKS): + if self.cor_04[0] == True: + self.Color_HUE("RGB", self.cor_04[1], self.cor_04[2], self.cor_04[3], 0) + self.Color_APPLY("RGB", self.cor_04[1], self.cor_04[2], self.cor_04[3], 0) + self.Pigment_Release() + def Cor_04_SAVE(self, SIGNAL_CLICKS): + self.cor_04 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_04[1]*255, self.cor_04[2]*255, self.cor_04[3]*255)) + self.layout.cor_04.setStyleSheet(color) + def Cor_04_CLEAN(self, SIGNAL_CLICKS): + self.cor_04 = [False, 0, 0, 0] + self.layout.cor_04.setStyleSheet(self.bg_alpha) + + def Cor_05_APPLY(self, SIGNAL_CLICKS): + if self.cor_05[0] == True: + self.Color_HUE("RGB", self.cor_05[1], self.cor_05[2], self.cor_05[3], 0) + self.Color_APPLY("RGB", self.cor_05[1], self.cor_05[2], self.cor_05[3], 0) + self.Pigment_Release() + def Cor_05_SAVE(self, SIGNAL_CLICKS): + self.cor_05 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_05[1]*255, self.cor_05[2]*255, self.cor_05[3]*255)) + self.layout.cor_05.setStyleSheet(color) + def Cor_05_CLEAN(self, SIGNAL_CLICKS): + self.cor_05 = [False, 0, 0, 0] + self.layout.cor_05.setStyleSheet(self.bg_alpha) + + def Cor_06_APPLY(self, SIGNAL_CLICKS): + if self.cor_06[0] == True: + self.Color_HUE("RGB", self.cor_06[1], self.cor_06[2], self.cor_06[3], 0) + self.Color_APPLY("RGB", self.cor_06[1], self.cor_06[2], self.cor_06[3], 0) + self.Pigment_Release() + def Cor_06_SAVE(self, SIGNAL_CLICKS): + self.cor_06 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_06[1]*255, self.cor_06[2]*255, self.cor_06[3]*255)) + self.layout.cor_06.setStyleSheet(color) + def Cor_06_CLEAN(self, SIGNAL_CLICKS): + self.cor_06 = [False, 0, 0, 0] + self.layout.cor_06.setStyleSheet(self.bg_alpha) + + def Cor_07_APPLY(self, SIGNAL_CLICKS): + if self.cor_07[0] == True: + self.Color_HUE("RGB", self.cor_07[1], self.cor_07[2], self.cor_07[3], 0) + self.Color_APPLY("RGB", self.cor_07[1], self.cor_07[2], self.cor_07[3], 0) + self.Pigment_Release() + def Cor_07_SAVE(self, SIGNAL_CLICKS): + self.cor_07 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_07[1]*255, self.cor_07[2]*255, self.cor_07[3]*255)) + self.layout.cor_07.setStyleSheet(color) + def Cor_07_CLEAN(self, SIGNAL_CLICKS): + self.cor_07 = [False, 0, 0, 0] + self.layout.cor_07.setStyleSheet(self.bg_alpha) + + def Cor_08_APPLY(self, SIGNAL_CLICKS): + if self.cor_08[0] == True: + self.Color_HUE("RGB", self.cor_08[1], self.cor_08[2], self.cor_08[3], 0) + self.Color_APPLY("RGB", self.cor_08[1], self.cor_08[2], self.cor_08[3], 0) + self.Pigment_Release() + def Cor_08_SAVE(self, SIGNAL_CLICKS): + self.cor_08 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_08[1]*255, self.cor_08[2]*255, self.cor_08[3]*255)) + self.layout.cor_08.setStyleSheet(color) + def Cor_08_CLEAN(self, SIGNAL_CLICKS): + self.cor_08 = [False, 0, 0, 0] + self.layout.cor_08.setStyleSheet(self.bg_alpha) + + def Cor_09_APPLY(self, SIGNAL_CLICKS): + if self.cor_09[0] == True: + self.Color_HUE("RGB", self.cor_09[1], self.cor_09[2], self.cor_09[3], 0) + self.Color_APPLY("RGB", self.cor_09[1], self.cor_09[2], self.cor_09[3], 0) + self.Pigment_Release() + def Cor_09_SAVE(self, SIGNAL_CLICKS): + self.cor_09 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_09[1]*255, self.cor_09[2]*255, self.cor_09[3]*255)) + self.layout.cor_09.setStyleSheet(color) + def Cor_09_CLEAN(self, SIGNAL_CLICKS): + self.cor_09 = [False, 0, 0, 0] + self.layout.cor_09.setStyleSheet(self.bg_alpha) + + def Cor_10_APPLY(self, SIGNAL_CLICKS): + if self.cor_10[0] == True: + self.Color_HUE("RGB", self.cor_10[1], self.cor_10[2], self.cor_10[3], 0) + self.Color_APPLY("RGB", self.cor_10[1], self.cor_10[2], self.cor_10[3], 0) + self.Pigment_Release() + def Cor_10_SAVE(self, SIGNAL_CLICKS): + self.cor_10 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_10[1]*255, self.cor_10[2]*255, self.cor_10[3]*255)) + self.layout.cor_10.setStyleSheet(color) + def Cor_10_CLEAN(self, SIGNAL_CLICKS): + self.cor_10 = [False, 0, 0, 0] + self.layout.cor_10.setStyleSheet(self.bg_alpha) + + #// + #\\ Mixer Boxes ############################################################ + # TTS + def Mixer_TTS_APPLY(self, SIGNAL_APPLY): + if self.color_tts[0] == True: + self.Color_APPLY("RGB", self.color_tts[1], self.color_tts[2], self.color_tts[3], 0) + self.Pigment_Release() + def Mixer_TTS_SAVE(self, SIGNAL_SAVE): + # Color Math + self.color_tts = [True, self.rgb_1, self.rgb_2, self.rgb_3] + gray = self.rgb_to_aaa(self.rgb_1, self.rgb_2, self.rgb_3) + self.gray_tts = [gray[0], gray[0], gray[0]] + # Display + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ; " % (self.color_tts[1]*255, self.color_tts[2]*255, self.color_tts[3]*255)) + bg_gray_tts = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ; " % (self.gray_tts[0]*255, self.gray_tts[1]*255, self.gray_tts[2]*255)) + self.layout.tts_l1.setStyleSheet(color) + self.layout.white.setStyleSheet(self.bg_white) + self.layout.grey.setStyleSheet(bg_gray_tts) + self.layout.black.setStyleSheet(self.bg_black) + self.Mixer_Display() + def Mixer_TTS_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_tts = [False, 0, 0, 0] + self.gray_tts = self.color_grey + # Display + self.layout.tts_l1.setStyleSheet(self.bg_alpha) + self.layout.white.setStyleSheet(self.bg_alpha) + self.layout.grey.setStyleSheet(self.bg_alpha) + self.layout.black.setStyleSheet(self.bg_alpha) + self.layout.tint.setStyleSheet(self.bg_alpha) + self.layout.tone.setStyleSheet(self.bg_alpha) + self.layout.shade.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_tint = 0 + self.spacer_tone = 0 + self.spacer_shade = 0 + self.mixer_tint.Colors(False, 0) + self.mixer_tone.Colors(False, 0) + self.mixer_shade.Colors(False, 0) + + # RGB + def Mixer_RGB_L1_APPLY(self, SIGNAL_APPLY): + if self.color_rgb_l1[0] == True: + self.Color_APPLY("RGB", self.color_rgb_l1[1], self.color_rgb_l1[2], self.color_rgb_l1[3], 0) + self.Pigment_Release() + def Mixer_RGB_L1_SAVE(self, SIGNAL_SAVE): + # Color Math + self.color_rgb_l1 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + # Display + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_l1[1]*255, self.color_rgb_l1[2]*255, self.color_rgb_l1[3]*255)) + self.layout.rgb_l1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RGB_L1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_rgb_l1 = [False, 0, 0, 0] + # Display + self.layout.rgb_l1.setStyleSheet(self.bg_alpha) + self.layout.rgb_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_rgb_g1 = 0 + self.mixer_rgb_g1.Update(self.spacer_rgb_g1, self.mixer_width) + + def Mixer_RGB_R1_APPLY(self, SIGNAL_APPLY): + if self.color_rgb_r1[0] == True: + self.Color_APPLY("RGB", self.color_rgb_r1[1], self.color_rgb_r1[2], self.color_rgb_r1[3], 0) + self.Pigment_Release() + def Mixer_RGB_R1_SAVE(self, SIGNAL_SAVE): + # Color Math + self.color_rgb_r1 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + # Display + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_r1[1]*255, self.color_rgb_r1[2]*255, self.color_rgb_r1[3]*255)) + self.layout.rgb_r1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RGB_R1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_rgb_r1 = [False, 0, 0, 0] + # Display + self.layout.rgb_r1.setStyleSheet(self.bg_alpha) + self.layout.rgb_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_rgb_g1 = 0 + self.mixer_rgb_g1.Update(self.spacer_rgb_g1, self.mixer_width) + + def Mixer_RGB_L2_APPLY(self, SIGNAL_APPLY): + if self.color_rgb_l2[0] == True: + self.Color_APPLY("RGB", self.color_rgb_l2[1], self.color_rgb_l2[2], self.color_rgb_l2[3], 0) + self.Pigment_Release() + def Mixer_RGB_L2_SAVE(self, SIGNAL_SAVE): + # Color Math + self.color_rgb_l2 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + # Display + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_l2[1]*255, self.color_rgb_l2[2]*255, self.color_rgb_l2[3]*255)) + self.layout.rgb_l2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RGB_L2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_rgb_l2 = [False, 0, 0, 0] + # Display + self.layout.rgb_l2.setStyleSheet(self.bg_alpha) + self.layout.rgb_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_rgb_g2 = 0 + self.mixer_rgb_g2.Update(self.spacer_rgb_g2, self.mixer_width) + + def Mixer_RGB_R2_APPLY(self, SIGNAL_APPLY): + if self.color_rgb_r2[0] == True: + self.Color_APPLY("RGB", self.color_rgb_r2[1], self.color_rgb_r2[2], self.color_rgb_r2[3], 0) + self.Pigment_Release() + def Mixer_RGB_R2_SAVE(self, SIGNAL_SAVE): + # Color Math + self.color_rgb_r2 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + # Display + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_r2[1]*255, self.color_rgb_r2[2]*255, self.color_rgb_r2[3]*255)) + self.layout.rgb_r2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RGB_R2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_rgb_r2 = [False, 0, 0, 0] + # Display + self.layout.rgb_r2.setStyleSheet(self.bg_alpha) + self.layout.rgb_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_rgb_g2 = 0 + self.mixer_rgb_g2.Update(self.spacer_rgb_g2, self.mixer_width) + + def Mixer_RGB_L3_APPLY(self, SIGNAL_APPLY): + if self.color_rgb_l3[0] == True: + self.Color_APPLY("RGB", self.color_rgb_l3[1], self.color_rgb_l3[2], self.color_rgb_l3[3], 0) + self.Pigment_Release() + def Mixer_RGB_L3_SAVE(self, SIGNAL_SAVE): + # Color Math + self.color_rgb_l3 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + # Display + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_l3[1]*255, self.color_rgb_l3[2]*255, self.color_rgb_l3[3]*255)) + self.layout.rgb_l3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RGB_L3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_rgb_l3 = [False, 0, 0, 0] + # Display + self.layout.rgb_l3.setStyleSheet(self.bg_alpha) + self.layout.rgb_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_rgb_g3 = 0 + self.mixer_rgb_g3.Update(self.spacer_rgb_g3, self.mixer_width) + + def Mixer_RGB_R3_APPLY(self, SIGNAL_APPLY): + if self.color_rgb_r3[0] == True: + self.Color_APPLY("RGB", self.color_rgb_r3[1], self.color_rgb_r3[2], self.color_rgb_r3[3], 0) + self.Pigment_Release() + def Mixer_RGB_R3_SAVE(self, SIGNAL_SAVE): + # Color Math + self.color_rgb_r3 = [True, self.rgb_1, self.rgb_2, self.rgb_3] + # Display + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_r3[1]*255, self.color_rgb_r3[2]*255, self.color_rgb_r3[3]*255)) + self.layout.rgb_r3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RGB_R3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_rgb_r3 = [False, 0, 0, 0] + # Display + self.layout.rgb_r3.setStyleSheet(self.bg_alpha) + self.layout.rgb_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_rgb_g3 = 0 + self.mixer_rgb_g3.Update(self.spacer_rgb_g3, self.mixer_width) + + # ARD + def Mixer_ARD_L1_APPLY(self, SIGNAL_APPLY): + if self.color_ard_l1[0] == True: + self.Color_APPLY("ARD", self.color_ard_l1[1], self.color_ard_l1[2], self.color_ard_l1[3], 0) + self.Pigment_Release() + def Mixer_ARD_L1_SAVE(self, SIGNAL_SAVE): + # color + self.color_ard_l1 = [True, self.ard_1, self.ard_2, self.ard_3] + # Display + rgb = self.ard_to_rgb(self.color_ard_l1[1], self.color_ard_l1[2], self.color_ard_l1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ard_l1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_ARD_L1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ard_l1 = [False, 0, 0, 0, 0, 0, 0] + # Display + self.layout.ard_l1.setStyleSheet(self.bg_alpha) + self.layout.ard_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ard_g1 = 0 + self.mixer_ard_g1.Update(self.spacer_ard_g1, self.mixer_width) + + def Mixer_ARD_R1_APPLY(self, SIGNAL_APPLY): + if self.color_ard_r1[0] == True: + self.Color_APPLY("ARD", self.color_ard_r1[1], self.color_ard_r1[2], self.color_ard_r1[3], 0) + self.Pigment_Release() + def Mixer_ARD_R1_SAVE(self, SIGNAL_SAVE): + # color + self.color_ard_r1 = [True, self.ard_1, self.ard_2, self.ard_3] + # Display + rgb = self.ard_to_rgb(self.color_ard_r1[1], self.color_ard_r1[2], self.color_ard_r1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ard_r1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_ARD_R1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ard_r1 = [False, 0, 0, 0, 0, 0, 0] + # Display + self.layout.ard_r1.setStyleSheet(self.bg_alpha) + self.layout.ard_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ard_g1 = 0 + self.mixer_ard_g1.Update(self.spacer_ard_g1, self.mixer_width) + + def Mixer_ARD_L2_APPLY(self, SIGNAL_APPLY): + if self.color_ard_l2[0] == True: + self.Color_APPLY("ARD", self.color_ard_l2[1], self.color_ard_l2[2], self.color_ard_l2[3], 0) + self.Pigment_Release() + def Mixer_ARD_L2_SAVE(self, SIGNAL_SAVE): + # color + self.color_ard_l2 = [True, self.ard_1, self.ard_2, self.ard_3] + # Display + rgb = self.ard_to_rgb(self.color_ard_l2[1], self.color_ard_l2[2], self.color_ard_l2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ard_l2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_ARD_L2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ard_l2 = [False, 0, 0, 0, 0, 0, 0] + # Display + self.layout.ard_l2.setStyleSheet(self.bg_alpha) + self.layout.ard_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ard_g2 = 0 + self.mixer_ard_g2.Update(self.spacer_ard_g2, self.mixer_width) + + def Mixer_ARD_R2_APPLY(self, SIGNAL_APPLY): + if self.color_ard_r2[0] == True: + self.Color_APPLY("ARD", self.color_ard_r2[1], self.color_ard_r2[2], self.color_ard_r2[3], 0) + self.Pigment_Release() + def Mixer_ARD_R2_SAVE(self, SIGNAL_SAVE): + # color + self.color_ard_r2 = [True, self.ard_1, self.ard_2, self.ard_3] + # Display + rgb = self.ard_to_rgb(self.color_ard_r2[1], self.color_ard_r2[2], self.color_ard_r2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ard_r2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_ARD_R2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ard_r2 = [False, 0, 0, 0, 0, 0, 0] + # Display + self.layout.ard_r2.setStyleSheet(self.bg_alpha) + self.layout.ard_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ard_g2 = 0 + self.mixer_ard_g2.Update(self.spacer_ard_g2, self.mixer_width) + + def Mixer_ARD_L3_APPLY(self, SIGNAL_APPLY): + if self.color_ard_l3[0] == True: + self.Color_APPLY("ARD", self.color_ard_l3[1], self.color_ard_l3[2], self.color_ard_l3[3], 0) + self.Pigment_Release() + def Mixer_ARD_L3_SAVE(self, SIGNAL_SAVE): + # color + self.color_ard_l3 = [True, self.ard_1, self.ard_2, self.ard_3] + # Display + rgb = self.ard_to_rgb(self.color_ard_l3[1], self.color_ard_l3[2], self.color_ard_l3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ard_l3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_ARD_L3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ard_l3 = [False, 0, 0, 0, 0, 0, 0] + # Display + self.layout.ard_l3.setStyleSheet(self.bg_alpha) + self.layout.ard_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ard_g3 = 0 + self.mixer_ard_g3.Update(self.spacer_ard_g3, self.mixer_width) + + def Mixer_ARD_R3_APPLY(self, SIGNAL_APPLY): + if self.color_ard_r3[0] == True: + self.Color_APPLY("ARD", self.color_ard_r3[1], self.color_ard_r3[2], self.color_ard_r3[3], 0) + self.Pigment_Release() + def Mixer_ARD_R3_SAVE(self, SIGNAL_SAVE): + # color + self.color_ard_r3 = [True, self.ard_1, self.ard_2, self.ard_3] + # Display + rgb = self.ard_to_rgb(self.color_ard_r3[1], self.color_ard_r3[2], self.color_ard_r3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ard_r3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_ARD_R3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ard_r3 = [False, 0, 0, 0, 0, 0, 0] + # Display + self.layout.ard_r3.setStyleSheet(self.bg_alpha) + self.layout.ard_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ard_g3 = 0 + self.mixer_ard_g3.Update(self.spacer_ard_g3, self.mixer_width) + + # HSV + def Mixer_HSV_L1_APPLY(self, SIGNAL_APPLY): + if self.color_hsv_l1[0] == True: + self.Color_APPLY("HSV", self.color_hsv_l1[1], self.color_hsv_l1[2], self.color_hsv_l1[3], 0) + self.Pigment_Release() + def Mixer_HSV_L1_SAVE(self, SIGNAL_SAVE): + # color = [Bool, R, G, B, H, S, V] + self.color_hsv_l1 = [True, self.hsv_1, self.hsv_2, self.hsv_3] + # Display + rgb = self.hsv_to_rgb(self.color_hsv_l1[1], self.color_hsv_l1[2], self.color_hsv_l1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsv_l1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSV_L1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsv_l1 = [False, 0, 0, 0] + # Display + self.layout.hsv_l1.setStyleSheet(self.bg_alpha) + self.layout.hsv_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsv_g1 = 0 + self.mixer_hsv_g1.Update(self.spacer_hsv_g1, self.mixer_width) + + def Mixer_HSV_R1_APPLY(self, SIGNAL_APPLY): + if self.color_hsv_r1[0] == True: + self.Color_APPLY("HSV", self.color_hsv_r1[1], self.color_hsv_r1[2], self.color_hsv_r1[3], 0) + self.Pigment_Release() + def Mixer_HSV_R1_SAVE(self, SIGNAL_SAVE): + # color = [Bool, R, G, B, H, S, V] + self.color_hsv_r1 = [True, self.hsv_1, self.hsv_2, self.hsv_3] + # Display + rgb = self.hsv_to_rgb(self.color_hsv_r1[1], self.color_hsv_r1[2], self.color_hsv_r1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsv_r1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSV_R1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsv_r1 = [False, 0, 0, 0] + # Display + self.layout.hsv_r1.setStyleSheet(self.bg_alpha) + self.layout.hsv_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsv_g1 = 0 + self.mixer_hsv_g1.Update(self.spacer_hsv_g1, self.mixer_width) + + def Mixer_HSV_L2_APPLY(self, SIGNAL_APPLY): + if self.color_hsv_l2[0] == True: + self.Color_APPLY("HSV", self.color_hsv_l2[1], self.color_hsv_l2[2], self.color_hsv_l2[3], 0) + self.Pigment_Release() + def Mixer_HSV_L2_SAVE(self, SIGNAL_SAVE): + # color + self.color_hsv_l2 = [True, self.hsv_1, self.hsv_2, self.hsv_3] + # Display + rgb = self.hsv_to_rgb(self.color_hsv_l2[1], self.color_hsv_l2[2], self.color_hsv_l2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsv_l2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSV_L2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsv_l2 = [False, 0, 0, 0] + # Display + self.layout.hsv_l2.setStyleSheet(self.bg_alpha) + self.layout.hsv_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsv_g2 = 0 + self.mixer_hsv_g2.Update(self.spacer_hsv_g2, self.mixer_width) + + def Mixer_HSV_R2_APPLY(self, SIGNAL_APPLY): + if self.color_hsv_r2[0] == True: + self.Color_APPLY("HSV", self.color_hsv_r2[1], self.color_hsv_r2[2], self.color_hsv_r2[3], 0) + self.Pigment_Release() + def Mixer_HSV_R2_SAVE(self, SIGNAL_SAVE): + # color + self.color_hsv_r2 = [True, self.hsv_1, self.hsv_2, self.hsv_3] + # Display + rgb = self.hsv_to_rgb(self.color_hsv_r2[1], self.color_hsv_r2[2], self.color_hsv_r2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsv_r2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSV_R2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsv_r2 = [False, 0, 0, 0] + # Display + self.layout.hsv_r2.setStyleSheet(self.bg_alpha) + self.layout.hsv_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsv_g2 = 0 + self.mixer_hsv_g2.Update(self.spacer_hsv_g2, self.mixer_width) + + def Mixer_HSV_L3_APPLY(self, SIGNAL_APPLY): + if self.color_hsv_l3[0] == True: + self.Color_APPLY("HSV", self.color_hsv_l3[1], self.color_hsv_l3[2], self.color_hsv_l3[3], 0) + self.Pigment_Release() + def Mixer_HSV_L3_SAVE(self, SIGNAL_SAVE): + # color + self.color_hsv_l3 = [True, self.hsv_1, self.hsv_2, self.hsv_3] + # Display + rgb = self.hsv_to_rgb(self.color_hsv_l3[1], self.color_hsv_l3[2], self.color_hsv_l3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsv_l3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSV_L3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsv_l3 = [False, 0, 0, 0] + # Display + self.layout.hsv_l3.setStyleSheet(self.bg_alpha) + self.layout.hsv_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsv_g3 = 0 + self.mixer_hsv_g3.Update(self.spacer_hsv_g3, self.mixer_width) + + def Mixer_HSV_R3_APPLY(self, SIGNAL_APPLY): + if self.color_hsv_r3[0] == True: + self.Color_APPLY("HSV", self.color_hsv_r3[1], self.color_hsv_r3[2], self.color_hsv_r3[3], 0) + self.Pigment_Release() + def Mixer_HSV_R3_SAVE(self, SIGNAL_SAVE): + # color + self.color_hsv_r3 = [True, self.hsv_1, self.hsv_2, self.hsv_3] + # Display + rgb = self.hsv_to_rgb(self.color_hsv_r3[1], self.color_hsv_r3[2], self.color_hsv_r3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsv_r3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSV_R3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsv_r3 = [False, 0, 0, 0] + # Display + self.layout.hsv_r3.setStyleSheet(self.bg_alpha) + self.layout.hsv_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsv_g3 = 0 + self.mixer_hsv_g3.Update(self.spacer_hsv_g3, self.mixer_width) + + # HSL + def Mixer_HSL_L1_APPLY(self, SIGNAL_APPLY): + if self.color_hsl_l1[0] == True: + self.Color_APPLY("HSL", self.color_hsl_l1[1], self.color_hsl_l1[2], self.color_hsl_l1[3], 0) + self.Pigment_Release() + def Mixer_HSL_L1_SAVE(self, SIGNAL_SAVE): + # color + self.color_hsl_l1 = [True, self.hsl_1, self.hsl_2, self.hsl_3] + # Display + rgb = self.hsl_to_rgb(self.color_hsl_l1[1], self.color_hsl_l1[2], self.color_hsl_l1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsl_l1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSL_L1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsl_l1 = [False, 0, 0, 0] + # Display + self.layout.hsl_l1.setStyleSheet(self.bg_alpha) + self.layout.hsl_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsl_g1 = 0 + self.mixer_hsl_g1.Update(self.spacer_hsl_g1, self.mixer_width) + + def Mixer_HSL_R1_APPLY(self, SIGNAL_APPLY): + if self.color_hsl_r1[0] == True: + self.Color_APPLY("HSL", self.color_hsl_r1[1], self.color_hsl_r1[2], self.color_hsl_r1[3], 0) + self.Pigment_Release() + def Mixer_HSL_R1_SAVE(self, SIGNAL_SAVE): + # color + self.color_hsl_r1 = [True, self.hsl_1, self.hsl_2, self.hsl_3] + # Display + rgb = self.hsl_to_rgb(self.color_hsl_r1[1], self.color_hsl_r1[2], self.color_hsl_r1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsl_r1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSL_R1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsl_r1 = [False, 0, 0, 0] + # Display + self.layout.hsl_r1.setStyleSheet(self.bg_alpha) + self.layout.hsl_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsl_g1 = 0 + self.mixer_hsl_g1.Update(self.spacer_hsl_g1, self.mixer_width) + + def Mixer_HSL_L2_APPLY(self, SIGNAL_APPLY): + if self.color_hsl_l2[0] == True: + self.Color_APPLY("HSL", self.color_hsl_l2[1], self.color_hsl_l2[2], self.color_hsl_l2[3], 0) + self.Pigment_Release() + def Mixer_HSL_L2_SAVE(self, SIGNAL_SAVE): + # color + self.color_hsl_l2 = [True, self.hsl_1, self.hsl_2, self.hsl_3] + # Display + rgb = self.hsl_to_rgb(self.color_hsl_l2[1], self.color_hsl_l2[2], self.color_hsl_l2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsl_l2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSL_L2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsl_l2 = [False, 0, 0, 0] + # Display + self.layout.hsl_l2.setStyleSheet(self.bg_alpha) + self.layout.hsl_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsl_g2 = 0 + self.mixer_hsl_g2.Update(self.spacer_hsl_g2, self.mixer_width) + + def Mixer_HSL_R2_APPLY(self, SIGNAL_APPLY): + if self.color_hsl_r2[0] == True: + self.Color_APPLY("HSL", self.color_hsl_r2[1], self.color_hsl_r2[2], self.color_hsl_r2[3], 0) + self.Pigment_Release() + def Mixer_HSL_R2_SAVE(self, SIGNAL_SAVE): + # color + self.color_hsl_r2 = [True, self.hsl_1, self.hsl_2, self.hsl_3] + # Display + rgb = self.hsl_to_rgb(self.color_hsl_r2[1], self.color_hsl_r2[2], self.color_hsl_r2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsl_r2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSL_R2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsl_r2 = [False, 0, 0, 0] + # Display + self.layout.hsl_r2.setStyleSheet(self.bg_alpha) + self.layout.hsl_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsl_g2 = 0 + self.mixer_hsl_g2.Update(self.spacer_hsl_g2, self.mixer_width) + + def Mixer_HSL_L3_APPLY(self, SIGNAL_APPLY): + if self.color_hsl_l3[0] == True: + self.Color_APPLY("HSL", self.color_hsl_l3[1], self.color_hsl_l3[2], self.color_hsl_l3[3], 0) + self.Pigment_Release() + def Mixer_HSL_L3_SAVE(self, SIGNAL_SAVE): + # color + self.color_hsl_l3 = [True, self.hsl_1, self.hsl_2, self.hsl_3] + # Display + rgb = self.hsl_to_rgb(self.color_hsl_l3[1], self.color_hsl_l3[2], self.color_hsl_l3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsl_l3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSL_L3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsl_l3 = [False, 0, 0, 0] + # Display + self.layout.hsl_l3.setStyleSheet(self.bg_alpha) + self.layout.hsl_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsl_g3 = 0 + self.mixer_hsl_g3.Update(self.spacer_hsl_g3, self.mixer_width) + + def Mixer_HSL_R3_APPLY(self, SIGNAL_APPLY): + if self.color_hsl_r3[0] == True: + self.Color_APPLY("HSL", self.color_hsl_r3[1], self.color_hsl_r3[2], self.color_hsl_r3[3], 0) + self.Pigment_Release() + def Mixer_HSL_R3_SAVE(self, SIGNAL_SAVE): + # color + self.color_hsl_r3 = [True, self.hsl_1, self.hsl_2, self.hsl_3] + # Display + rgb = self.hsl_to_rgb(self.color_hsl_r3[1], self.color_hsl_r3[2], self.color_hsl_r3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hsl_r3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HSL_R3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hsl_r3 = [False, 0, 0, 0] + # Display + self.layout.hsl_r3.setStyleSheet(self.bg_alpha) + self.layout.hsl_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hsl_g3 = 0 + self.mixer_hsl_g3.Update(self.spacer_hsl_g3, self.mixer_width) + + # HCY + def Mixer_HCY_L1_APPLY(self, SIGNAL_APPLY): + if self.color_hcy_l1[0] == True: + self.Color_APPLY("HCY", self.color_hcy_l1[1], self.color_hcy_l1[2], self.color_hcy_l1[3], 0) + self.Pigment_Release() + def Mixer_HCY_L1_SAVE(self, SIGNAL_SAVE): + # color + self.color_hcy_l1 = [True, self.hcy_1, self.hcy_2, self.hcy_3] + # Display + rgb = self.hcy_to_rgb(self.color_hcy_l1[1], self.color_hcy_l1[2], self.color_hcy_l1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hcy_l1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HCY_L1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hcy_l1 = [False, 0, 0, 0] + # Display + self.layout.hcy_l1.setStyleSheet(self.bg_alpha) + self.layout.hcy_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hcy_g1 = 0 + self.mixer_hcy_g1.Update(self.spacer_hcy_g1, self.mixer_width) + + def Mixer_HCY_R1_APPLY(self, SIGNAL_APPLY): + if self.color_hcy_r1[0] == True: + self.Color_APPLY("HCY", self.color_hcy_r1[1], self.color_hcy_r1[2], self.color_hcy_r1[3], 0) + self.Pigment_Release() + def Mixer_HCY_R1_SAVE(self, SIGNAL_SAVE): + # color + self.color_hcy_r1 = [True, self.hcy_1, self.hcy_2, self.hcy_3] + # Display + rgb = self.hcy_to_rgb(self.color_hcy_r1[1], self.color_hcy_r1[2], self.color_hcy_r1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hcy_r1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HCY_R1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hcy_r1 = [False, 0, 0, 0] + # Display + self.layout.hcy_r1.setStyleSheet(self.bg_alpha) + self.layout.hcy_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hcy_g1 = 0 + self.mixer_hcy_g1.Update(self.spacer_hcy_g1, self.mixer_width) + + def Mixer_HCY_L2_APPLY(self, SIGNAL_APPLY): + if self.color_hcy_l2[0] == True: + self.Color_APPLY("HCY", self.color_hcy_l2[1], self.color_hcy_l2[2], self.color_hcy_l2[3], 0) + self.Pigment_Release() + def Mixer_HCY_L2_SAVE(self, SIGNAL_SAVE): + # color + self.color_hcy_l2 = [True, self.hcy_1, self.hcy_2, self.hcy_3] + # Display + rgb = self.hcy_to_rgb(self.color_hcy_l2[1], self.color_hcy_l2[2], self.color_hcy_l2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hcy_l2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HCY_L2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hcy_l2 = [False, 0, 0, 0] + # Display + self.layout.hcy_l2.setStyleSheet(self.bg_alpha) + self.layout.hcy_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hcy_g2 = 0 + self.mixer_hcy_g2.Update(self.spacer_hcy_g2, self.mixer_width) + + def Mixer_HCY_R2_APPLY(self, SIGNAL_APPLY): + if self.color_hcy_r2[0] == True: + self.Color_APPLY("HCY", self.color_hcy_r2[1], self.color_hcy_r2[2], self.color_hcy_r2[3], 0) + self.Pigment_Release() + def Mixer_HCY_R2_SAVE(self, SIGNAL_SAVE): + # color + self.color_hcy_r2 = [True, self.hcy_1, self.hcy_2, self.hcy_3] + # Display + rgb = self.hcy_to_rgb(self.color_hcy_r2[1], self.color_hcy_r2[2], self.color_hcy_r2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hcy_r2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HCY_R2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hcy_r2 = [False, 0, 0, 0] + # Display + self.layout.hcy_r2.setStyleSheet(self.bg_alpha) + self.layout.hcy_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hcy_g2 = 0 + self.mixer_hcy_g2.Update(self.spacer_hcy_g2, self.mixer_width) + + def Mixer_HCY_L3_APPLY(self, SIGNAL_APPLY): + if self.color_hcy_l3[0] == True: + self.Color_APPLY("HCY", self.color_hcy_l3[1], self.color_hcy_l3[2], self.color_hcy_l3[3], 0) + self.Pigment_Release() + def Mixer_HCY_L3_SAVE(self, SIGNAL_SAVE): + # color + self.color_hcy_l3 = [True, self.hcy_1, self.hcy_2, self.hcy_3] + # Display + rgb = self.hcy_to_rgb(self.color_hcy_l3[1], self.color_hcy_l3[2], self.color_hcy_l3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hcy_l3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HCY_L3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hcy_l3 = [False, 0, 0, 0] + # Display + self.layout.hcy_l3.setStyleSheet(self.bg_alpha) + self.layout.hcy_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hcy_g3 = 0 + self.mixer_hcy_g3.Update(self.spacer_hcy_g3, self.mixer_width) + + def Mixer_HCY_R3_APPLY(self, SIGNAL_APPLY): + if self.color_hcy_r3[0] == True: + self.Color_APPLY("HCY", self.color_hcy_r3[1], self.color_hcy_r3[2], self.color_hcy_r3[3], 0) + self.Pigment_Release() + def Mixer_HCY_R3_SAVE(self, SIGNAL_SAVE): + # color + self.color_hcy_r3 = [True, self.hcy_1, self.hcy_2, self.hcy_3] + # Display + rgb = self.hcy_to_rgb(self.color_hcy_r3[1], self.color_hcy_r3[2], self.color_hcy_r3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.hcy_r3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_HCY_R3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_hcy_r3 = [False, 0, 0, 0] + # Display + self.layout.hcy_r3.setStyleSheet(self.bg_alpha) + self.layout.hcy_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_hcy_g3 = 0 + self.mixer_hcy_g3.Update(self.spacer_hcy_g3, self.mixer_width) + + # YUV + def Mixer_YUV_L1_APPLY(self, SIGNAL_APPLY): + if self.color_yuv_l1[0] == True: + self.Color_APPLY("YUV", self.color_yuv_l1[1], self.color_yuv_l1[2], self.color_yuv_l1[3], 0) + self.Pigment_Release() + def Mixer_YUV_L1_SAVE(self, SIGNAL_SAVE): + # color + self.color_yuv_l1 = [True, self.yuv_1, self.yuv_2, self.yuv_3] + # Display + rgb = self.yuv_to_rgb(self.color_yuv_l1[1], self.color_yuv_l1[2], self.color_yuv_l1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.yuv_l1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_YUV_L1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_yuv_l1 = [False, 0, 0.5, 0.5] + # Display + self.layout.yuv_l1.setStyleSheet(self.bg_alpha) + self.layout.yuv_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_yuv_g1 = 0 + self.mixer_yuv_g1.Update(self.spacer_yuv_g1, self.mixer_width) + + def Mixer_YUV_R1_APPLY(self, SIGNAL_APPLY): + if self.color_yuv_r1[0] == True: + self.Color_APPLY("YUV", self.color_yuv_r1[1], self.color_yuv_r1[2], self.color_yuv_r1[3], 0) + self.Pigment_Release() + def Mixer_YUV_R1_SAVE(self, SIGNAL_SAVE): + # color + self.color_yuv_r1 = [True, self.yuv_1, self.yuv_2, self.yuv_3] + # Display + rgb = self.yuv_to_rgb(self.color_yuv_r1[1], self.color_yuv_r1[2], self.color_yuv_r1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.yuv_r1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_YUV_R1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_yuv_r1 = [False, 0, 0.5, 0.5] + # Display + self.layout.yuv_r1.setStyleSheet(self.bg_alpha) + self.layout.yuv_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_yuv_g1 = 0 + self.mixer_yuv_g1.Update(self.spacer_yuv_g1, self.mixer_width) + + def Mixer_YUV_L2_APPLY(self, SIGNAL_APPLY): + if self.color_yuv_l2[0] == True: + self.Color_APPLY("YUV", self.color_yuv_l2[1], self.color_yuv_l2[2], self.color_yuv_l2[3], 0) + self.Pigment_Release() + def Mixer_YUV_L2_SAVE(self, SIGNAL_SAVE): + # color + self.color_yuv_l2 = [True, self.yuv_1, self.yuv_2, self.yuv_3] + # Display + rgb = self.yuv_to_rgb(self.color_yuv_l2[1], self.color_yuv_l2[2], self.color_yuv_l2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.yuv_l2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_YUV_L2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_yuv_l2 = [False, 0, 0.5, 0.5] + # Display + self.layout.yuv_l2.setStyleSheet(self.bg_alpha) + self.layout.yuv_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_yuv_g2 = 0 + self.mixer_yuv_g2.Update(self.spacer_yuv_g2, self.mixer_width) + + def Mixer_YUV_R2_APPLY(self, SIGNAL_APPLY): + if self.color_yuv_r2[0] == True: + self.Color_APPLY("YUV", self.color_yuv_r2[1], self.color_yuv_r2[2], self.color_yuv_r2[3], 0) + self.Pigment_Release() + def Mixer_YUV_R2_SAVE(self, SIGNAL_SAVE): + # color + self.color_yuv_r2 = [True, self.yuv_1, self.yuv_2, self.yuv_3] + # Display + rgb = self.yuv_to_rgb(self.color_yuv_r2[1], self.color_yuv_r2[2], self.color_yuv_r2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.yuv_r2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_YUV_R2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_yuv_r2 = [False, 0, 0.5, 0.5] + # Display + self.layout.yuv_r2.setStyleSheet(self.bg_alpha) + self.layout.yuv_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_yuv_g2 = 0 + self.mixer_yuv_g2.Update(self.spacer_yuv_g2, self.mixer_width) + + def Mixer_YUV_L3_APPLY(self, SIGNAL_APPLY): + if self.color_yuv_l3[0] == True: + self.Color_APPLY("YUV", self.color_yuv_l3[1], self.color_yuv_l3[2], self.color_yuv_l3[3], 0) + self.Pigment_Release() + def Mixer_YUV_L3_SAVE(self, SIGNAL_SAVE): + # color + self.color_yuv_l3 = [True, self.yuv_1, self.yuv_2, self.yuv_3] + # Display + rgb = self.yuv_to_rgb(self.color_yuv_l3[1], self.color_yuv_l3[2], self.color_yuv_l3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.yuv_l3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_YUV_L3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_yuv_l3 = [False, 0, 0.5, 0.5] + # Display + self.layout.yuv_l3.setStyleSheet(self.bg_alpha) + self.layout.yuv_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_yuv_g3 = 0 + self.mixer_yuv_g3.Update(self.spacer_yuv_g3, self.mixer_width) + + def Mixer_YUV_R3_APPLY(self, SIGNAL_APPLY): + if self.color_yuv_r3[0] == True: + self.Color_APPLY("YUV", self.color_yuv_r3[1], self.color_yuv_r3[2], self.color_yuv_r3[3], 0) + self.Pigment_Release() + def Mixer_YUV_R3_SAVE(self, SIGNAL_SAVE): + # color + self.color_yuv_r3 = [True, self.yuv_1, self.yuv_2, self.yuv_3] + # Display + rgb = self.yuv_to_rgb(self.color_yuv_r3[1], self.color_yuv_r3[2], self.color_yuv_r3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.yuv_r3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_YUV_R3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_yuv_r3 = [False, 0, 0.5, 0.5] + # Display + self.layout.yuv_r3.setStyleSheet(self.bg_alpha) + self.layout.yuv_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_yuv_g3 = 0 + self.mixer_yuv_g3.Update(self.spacer_yuv_g3, self.mixer_width) + + # RYB + def Mixer_RYB_L1_APPLY(self, SIGNAL_APPLY): + if self.color_ryb_l1[0] == True: + self.Color_APPLY("RYB", self.color_ryb_l1[1], self.color_ryb_l1[2], self.color_ryb_l1[3], 0) + self.Pigment_Release() + def Mixer_RYB_L1_SAVE(self, SIGNAL_SAVE): + # color + self.color_ryb_l1 = [True, self.ryb_1, self.ryb_2, self.ryb_3] + # Display + rgb = self.ryb_to_rgb(self.color_ryb_l1[1], self.color_ryb_l1[2], self.color_ryb_l1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ryb_l1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RYB_L1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ryb_l1 = [False, 0, 0, 0] + # Display + self.layout.ryb_l1.setStyleSheet(self.bg_alpha) + self.layout.ryb_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ryb_g1 = 0 + self.mixer_ryb_g1.Update(self.spacer_ryb_g1, self.mixer_width) + + def Mixer_RYB_R1_APPLY(self, SIGNAL_APPLY): + if self.color_ryb_r1[0] == True: + self.Color_APPLY("RYB", self.color_ryb_r1[1], self.color_ryb_r1[2], self.color_ryb_r1[3], 0) + self.Pigment_Release() + def Mixer_RYB_R1_SAVE(self, SIGNAL_SAVE): + # color + self.color_ryb_r1 = [True, self.ryb_1, self.ryb_2, self.ryb_3] + # Display + rgb = self.ryb_to_rgb(self.color_ryb_r1[1], self.color_ryb_r1[2], self.color_ryb_r1[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ryb_r1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RYB_R1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ryb_r1 = [False, 0, 0, 0] + # Display + self.layout.ryb_r1.setStyleSheet(self.bg_alpha) + self.layout.ryb_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ryb_g1 = 0 + self.mixer_ryb_g1.Update(self.spacer_ryb_g1, self.mixer_width) + + def Mixer_RYB_L2_APPLY(self, SIGNAL_APPLY): + if self.color_ryb_l2[0] == True: + self.Color_APPLY("RYB", self.color_ryb_l2[1], self.color_ryb_l2[2], self.color_ryb_l2[3], 0) + self.Pigment_Release() + def Mixer_RYB_L2_SAVE(self, SIGNAL_SAVE): + # color + self.color_ryb_l2 = [True, self.ryb_1, self.ryb_2, self.ryb_3] + # Display + rgb = self.ryb_to_rgb(self.color_ryb_l2[1], self.color_ryb_l2[2], self.color_ryb_l2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ryb_l2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RYB_L2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ryb_l2 = [False, 0, 0, 0] + # Display + self.layout.ryb_l2.setStyleSheet(self.bg_alpha) + self.layout.ryb_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ryb_g2 = 0 + self.mixer_ryb_g2.Update(self.spacer_ryb_g2, self.mixer_width) + + def Mixer_RYB_R2_APPLY(self, SIGNAL_APPLY): + if self.color_ryb_r2[0] == True: + self.Color_APPLY("RYB", self.color_ryb_r2[1], self.color_ryb_r2[2], self.color_ryb_r2[3], 0) + self.Pigment_Release() + def Mixer_RYB_R2_SAVE(self, SIGNAL_SAVE): + # color + self.color_ryb_r2 = [True, self.ryb_1, self.ryb_2, self.ryb_3] + # Display + rgb = self.ryb_to_rgb(self.color_ryb_r2[1], self.color_ryb_r2[2], self.color_ryb_r2[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ryb_r2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RYB_R2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ryb_r2 = [False, 0, 0, 0] + # Display + self.layout.ryb_r2.setStyleSheet(self.bg_alpha) + self.layout.ryb_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ryb_g2 = 0 + self.mixer_ryb_g2.Update(self.spacer_ryb_g2, self.mixer_width) + + def Mixer_RYB_L3_APPLY(self, SIGNAL_APPLY): + if self.color_ryb_l3[0] == True: + self.Color_APPLY("RYB", self.color_ryb_l3[1], self.color_ryb_l3[2], self.color_ryb_l3[3], 0) + self.Pigment_Release() + def Mixer_RYB_L3_SAVE(self, SIGNAL_SAVE): + # color + self.color_ryb_l3 = [True, self.ryb_1, self.ryb_2, self.ryb_3] + # Display + rgb = self.ryb_to_rgb(self.color_ryb_l3[1], self.color_ryb_l3[2], self.color_ryb_l3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ryb_l3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RYB_L3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ryb_l3 = [False, 0, 0, 0] + # Display + self.layout.ryb_l3.setStyleSheet(self.bg_alpha) + self.layout.ryb_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ryb_g3 = 0 + self.mixer_ryb_g3.Update(self.spacer_ryb_g3, self.mixer_width) + + def Mixer_RYB_R3_APPLY(self, SIGNAL_APPLY): + if self.color_ryb_r3[0] == True: + self.Color_APPLY("RYB", self.color_ryb_r3[1], self.color_ryb_r3[2], self.color_ryb_r3[3], 0) + self.Pigment_Release() + def Mixer_RYB_R3_SAVE(self, SIGNAL_SAVE): + # color + self.color_ryb_r3 = [True, self.ryb_1, self.ryb_2, self.ryb_3] + # Display + rgb = self.ryb_to_rgb(self.color_ryb_r3[1], self.color_ryb_r3[2], self.color_ryb_r3[3]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.ryb_r3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_RYB_R3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_ryb_r3 = [False, 0, 0, 0] + # Display + self.layout.ryb_r3.setStyleSheet(self.bg_alpha) + self.layout.ryb_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_ryb_g3 = 0 + self.mixer_ryb_g3.Update(self.spacer_ryb_g3, self.mixer_width) + + # CMYK + def Mixer_CMYK_L1_APPLY(self, SIGNAL_APPLY): + if self.color_cmyk_l1[0] == True: + self.Color_APPLY("CMYK", self.color_cmyk_l1[1], self.color_cmyk_l1[2], self.color_cmyk_l1[3], self.color_cmyk_l1[4]) + self.Pigment_Release() + def Mixer_CMYK_L1_SAVE(self, SIGNAL_SAVE): + # color + self.color_cmyk_l1 = [True, self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4] + # Display + rgb = self.cmyk_to_rgb(self.color_cmyk_l1[1], self.color_cmyk_l1[2], self.color_cmyk_l1[3], self.color_cmyk_l1[4]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.cmyk_l1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_CMYK_L1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_cmyk_l1 = [False, 0, 0, 0, 1] + # Display + self.layout.cmyk_l1.setStyleSheet(self.bg_alpha) + self.layout.cmyk_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_cmyk_g1 = 0 + self.mixer_cmyk_g1.Update(self.spacer_cmyk_g1, self.mixer_width) + + def Mixer_CMYK_R1_APPLY(self, SIGNAL_APPLY): + if self.color_cmyk_r1[0] == True: + self.Color_APPLY("CMYK", self.color_cmyk_r1[1], self.color_cmyk_r1[2], self.color_cmyk_r1[3], self.color_cmyk_r1[4]) + self.Pigment_Release() + def Mixer_CMYK_R1_SAVE(self, SIGNAL_SAVE): + # color + self.color_cmyk_r1 = [True, self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4] + # Display + rgb = self.cmyk_to_rgb(self.color_cmyk_r1[1], self.color_cmyk_r1[2], self.color_cmyk_r1[3], self.color_cmyk_r1[4]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.cmyk_r1.setStyleSheet(color) + self.Mixer_Display() + def Mixer_CMYK_R1_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_cmyk_r1 = [False, 0, 0, 0, 1] + # Display + self.layout.cmyk_r1.setStyleSheet(self.bg_alpha) + self.layout.cmyk_g1.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_cmyk_g1 = 0 + self.mixer_cmyk_g1.Update(self.spacer_cmyk_g1, self.mixer_width) + + def Mixer_CMYK_L2_APPLY(self, SIGNAL_APPLY): + if self.color_cmyk_l2[0] == True: + self.Color_APPLY("CMYK", self.color_cmyk_l2[1], self.color_cmyk_l2[2], self.color_cmyk_l2[3], self.color_cmyk_l2[4]) + self.Pigment_Release() + def Mixer_CMYK_L2_SAVE(self, SIGNAL_SAVE): + # color + self.color_cmyk_l2 = [True, self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4] + # Display + rgb = self.cmyk_to_rgb(self.color_cmyk_l2[1], self.color_cmyk_l2[2], self.color_cmyk_l2[3], self.color_cmyk_l2[4]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.cmyk_l2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_CMYK_L2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_cmyk_l2 = [False, 0, 0, 0, 1] + # Display + self.layout.cmyk_l2.setStyleSheet(self.bg_alpha) + self.layout.cmyk_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_cmyk_g2 = 0 + self.mixer_cmyk_g2.Update(self.spacer_cmyk_g2, self.mixer_width) + + def Mixer_CMYK_R2_APPLY(self, SIGNAL_APPLY): + if self.color_cmyk_r2[0] == True: + self.Color_APPLY("CMYK", self.color_cmyk_r2[1], self.color_cmyk_r2[2], self.color_cmyk_r2[3], self.color_cmyk_r2[4]) + self.Pigment_Release() + def Mixer_CMYK_R2_SAVE(self, SIGNAL_SAVE): + # color + self.color_cmyk_r2 = [True, self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4] + # Display + rgb = self.cmyk_to_rgb(self.color_cmyk_r2[1], self.color_cmyk_r2[2], self.color_cmyk_r2[3], self.color_cmyk_r2[4]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.cmyk_r2.setStyleSheet(color) + self.Mixer_Display() + def Mixer_CMYK_R2_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_cmyk_r2 = [False, 0, 0, 0, 1] + # Display + self.layout.cmyk_r2.setStyleSheet(self.bg_alpha) + self.layout.cmyk_g2.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_cmyk_g2 = 0 + self.mixer_cmyk_g2.Update(self.spacer_cmyk_g2, self.mixer_width) + + def Mixer_CMYK_L3_APPLY(self, SIGNAL_APPLY): + if self.color_cmyk_l3[0] == True: + self.Color_APPLY("CMYK", self.color_cmyk_l3[1], self.color_cmyk_l3[2], self.color_cmyk_l3[3], self.color_cmyk_l3[4]) + self.Pigment_Release() + def Mixer_CMYK_L3_SAVE(self, SIGNAL_SAVE): + # color + self.color_cmyk_l3 = [True, self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4] + # Display + rgb = self.cmyk_to_rgb(self.color_cmyk_l3[1], self.color_cmyk_l3[2], self.color_cmyk_l3[3], self.color_cmyk_l3[4]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.cmyk_l3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_CMYK_L3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_cmyk_l3 = [False, 0, 0, 0, 1] + # Display + self.layout.cmyk_l3.setStyleSheet(self.bg_alpha) + self.layout.cmyk_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_cmyk_g3 = 0 + self.mixer_cmyk_g3.Update(self.spacer_cmyk_g3, self.mixer_width) + + def Mixer_CMYK_R3_APPLY(self, SIGNAL_APPLY): + if self.color_cmyk_r3[0] == True: + self.Color_APPLY("CMYK", self.color_cmyk_r3[1], self.color_cmyk_r3[2], self.color_cmyk_r3[3], self.color_cmyk_r3[4]) + self.Pigment_Release() + def Mixer_CMYK_R3_SAVE(self, SIGNAL_SAVE): + # color + self.color_cmyk_r3 = [True, self.cmyk_1, self.cmyk_2, self.cmyk_3, self.cmyk_4] + # Display + rgb = self.cmyk_to_rgb(self.color_cmyk_r3[1], self.color_cmyk_r3[2], self.color_cmyk_r3[3], self.color_cmyk_r3[4]) + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb[0]*255, rgb[1]*255, rgb[2]*255)) + self.layout.cmyk_r3.setStyleSheet(color) + self.Mixer_Display() + def Mixer_CMYK_R3_CLEAN(self, SIGNAL_CLEAN): + # Color Math + self.color_cmyk_r3 = [False, 0, 0, 0, 1] + # Display + self.layout.cmyk_r3.setStyleSheet(self.bg_alpha) + self.layout.cmyk_g3.setStyleSheet(self.bg_alpha) + self.Mixer_Display() + # Correct Values + self.spacer_cmyk_g3 = 0 + self.mixer_cmyk_g3.Update(self.spacer_cmyk_g3, self.mixer_width) + + #// + #\\ Mixer Gradient ######################################################### + def Mixer_Tint(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_tint = SIGNAL_MIXER_VALUE / (self.layout.tint.width()) + # Percentual Value added to Left Color Percentil + rgb1 = ((self.color_tts[1]) + (self.spacer_tint * (self.color_white[0] - self.color_tts[1]))) + rgb2 = ((self.color_tts[2]) + (self.spacer_tint * (self.color_white[1] - self.color_tts[2]))) + rgb3 = ((self.color_tts[3]) + (self.spacer_tint * (self.color_white[2] - self.color_tts[3]))) + # Send Values + self.Color_HUE("RGB", rgb1, rgb2, rgb3, 0) + self.Color_APPLY("RGB", rgb1, rgb2, rgb3, 0) + def Mixer_Tone(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_tone = SIGNAL_MIXER_VALUE / (self.layout.tone.width()) + # Percentual Value added to Left Color Percentil + rgb1 = ((self.color_tts[1]) + (self.spacer_tone * (self.gray_tts[0] - self.color_tts[1]))) + rgb2 = ((self.color_tts[2]) + (self.spacer_tone * (self.gray_tts[1] - self.color_tts[2]))) + rgb3 = ((self.color_tts[3]) + (self.spacer_tone * (self.gray_tts[2] - self.color_tts[3]))) + # Send Values + self.Color_HUE("RGB", rgb1, rgb2, rgb3, 0) + self.Color_APPLY("RGB", rgb1, rgb2, rgb3, 0) + def Mixer_Shade(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_shade = SIGNAL_MIXER_VALUE / (self.layout.shade.width()) + # Percentual Value added to Left Color Percentil + rgb1 = ((self.color_tts[1]) + (self.spacer_shade * (self.color_black[0] - self.color_tts[1]))) + rgb2 = ((self.color_tts[2]) + (self.spacer_shade * (self.color_black[1] - self.color_tts[2]))) + rgb3 = ((self.color_tts[3]) + (self.spacer_shade * (self.color_black[2] - self.color_tts[3]))) + # Send Values + self.Color_HUE("RGB", rgb1, rgb2, rgb3, 0) + self.Color_APPLY("RGB", rgb1, rgb2, rgb3, 0) + + def Mixer_RGB_G1(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_rgb_g1 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + rgb1 = (self.color_rgb_l1[1] + (self.spacer_rgb_g1 * (self.color_rgb_r1[1] - self.color_rgb_l1[1]))) + rgb2 = (self.color_rgb_l1[2] + (self.spacer_rgb_g1 * (self.color_rgb_r1[2] - self.color_rgb_l1[2]))) + rgb3 = (self.color_rgb_l1[3] + (self.spacer_rgb_g1 * (self.color_rgb_r1[3] - self.color_rgb_l1[3]))) + # Send Values + self.Color_HUE("RGB", rgb1, rgb2, rgb3, 0) + self.Color_APPLY("RGB", rgb1, rgb2, rgb3, 0) + def Mixer_RGB_G2(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_rgb_g2 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + rgb1 = (self.color_rgb_l2[1] + (self.spacer_rgb_g2 * (self.color_rgb_r2[1] - self.color_rgb_l2[1]))) + rgb2 = (self.color_rgb_l2[2] + (self.spacer_rgb_g2 * (self.color_rgb_r2[2] - self.color_rgb_l2[2]))) + rgb3 = (self.color_rgb_l2[3] + (self.spacer_rgb_g2 * (self.color_rgb_r2[3] - self.color_rgb_l2[3]))) + # Send Values + self.Color_HUE("RGB", rgb1, rgb2, rgb3, 0) + self.Color_APPLY("RGB", rgb1, rgb2, rgb3, 0) + def Mixer_RGB_G3(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_rgb_g3 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + rgb1 = (self.color_rgb_l3[1] + (self.spacer_rgb_g3 * (self.color_rgb_r3[1] - self.color_rgb_l3[1]))) + rgb2 = (self.color_rgb_l3[2] + (self.spacer_rgb_g3 * (self.color_rgb_r3[2] - self.color_rgb_l3[2]))) + rgb3 = (self.color_rgb_l3[3] + (self.spacer_rgb_g3 * (self.color_rgb_r3[3] - self.color_rgb_l3[3]))) + # Send Values + self.Color_HUE("RGB", rgb1, rgb2, rgb3, 0) + self.Color_APPLY("RGB", rgb1, rgb2, rgb3, 0) + + def Mixer_ARD_G1(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_ard_g1 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_ard_l1[1] <= self.color_ard_r1[1]: + # Conditions + cond1 = self.color_ard_r1[1] - self.color_ard_l1[1] + cond2 = (self.color_ard_l1[1] + 1) - self.color_ard_r1[1] + if cond1 <= cond2: + ang = self.color_ard_l1[1] + (self.spacer_ard_g1 * cond1) + else: + ang = self.color_ard_l1[1] - (self.spacer_ard_g1 * cond2) + else: + # Conditions + cond1 = self.color_ard_l1[1] - self.color_ard_r1[1] + cond2 = (self.color_ard_r1[1] + 1) - self.color_ard_l1[1] + if cond1 <= cond2: + ang = self.color_ard_l1[1] - (self.spacer_ard_g1 * cond1) + else: + ang = self.color_ard_l1[1] + (self.spacer_ard_g1 * cond2) + # Correct Excess + if ang < 0: + ang = ang + 1 + if ang > 1: + ang = ang - 1 + ard1 = ang + ard2 = (self.color_ard_l1[2] + (self.spacer_ard_g1 * (self.color_ard_r1[2] - self.color_ard_l1[2]))) + ard3 = (self.color_ard_l1[3] + (self.spacer_ard_g1 * (self.color_ard_r1[3] - self.color_ard_l1[3]))) + # Send Values + self.Color_APPLY("ARD", ard1, ard2, ard3, 0) + def Mixer_ARD_G2(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_ard_g2 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_ard_l2[1] <= self.color_ard_r2[1]: + # Conditions + cond1 = self.color_ard_r2[1] - self.color_ard_l2[1] + cond2 = (self.color_ard_l2[1] + 1) - self.color_ard_r2[1] + if cond1 <= cond2: + ang = self.color_ard_l2[1] + (self.spacer_ard_g2 * cond1) + else: + ang = self.color_ard_l2[1] - (self.spacer_ard_g2 * cond2) + else: + # Conditions + cond1 = self.color_ard_l2[1] - self.color_ard_r2[1] + cond2 = (self.color_ard_r2[1] + 1) - self.color_ard_l2[1] + if cond1 <= cond2: + ang = self.color_ard_l2[1] - (self.spacer_ard_g2 * cond1) + else: + ang = self.color_ard_l2[1] + (self.spacer_ard_g2 * cond2) + # Correct Excess + if ang < 0: + ang = ang + 1 + if ang > 1: + ang = ang - 1 + ard1 = ang + ard2 = (self.color_ard_l2[2] + (self.spacer_ard_g2 * (self.color_ard_r2[2] - self.color_ard_l2[2]))) + ard3 = (self.color_ard_l2[3] + (self.spacer_ard_g2 * (self.color_ard_r2[3] - self.color_ard_l2[3]))) + # Send Values + self.Color_APPLY("ARD", ard1, ard2, ard3, 0) + def Mixer_ARD_G3(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_ard_g3 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_ard_l3[1] <= self.color_ard_r3[1]: + # Conditions + cond1 = self.color_ard_r3[1] - self.color_ard_l3[1] + cond2 = (self.color_ard_l3[1] + 1) - self.color_ard_r3[1] + if cond1 <= cond2: + ang = self.color_ard_l3[1] + (self.spacer_ard_g3 * cond1) + else: + ang = self.color_ard_l3[1] - (self.spacer_ard_g3 * cond2) + else: + # Conditions + cond1 = self.color_ard_l3[1] - self.color_ard_r3[1] + cond2 = (self.color_ard_r3[1] + 1) - self.color_ard_l3[1] + if cond1 <= cond2: + ang = self.color_ard_l3[1] - (self.spacer_ard_g3 * cond1) + else: + ang = self.color_ard_l3[1] + (self.spacer_ard_g3 * cond2) + # Correct Excess + if ang < 0: + ang = ang + 1 + if ang > 1: + ang = ang - 1 + ard1 = ang + ard2 = (self.color_ard_l3[2] + (self.spacer_ard_g3 * (self.color_ard_r3[2] - self.color_ard_l3[2]))) + ard3 = (self.color_ard_l3[3] + (self.spacer_ard_g3 * (self.color_ard_r3[3] - self.color_ard_l3[3]))) + # Send Values + self.Color_APPLY("ARD", ard1, ard2, ard3, 0) + + def Mixer_HSV_G1(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_hsv_g1 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_hsv_l1[1] <= self.color_hsv_r1[1]: + # Conditions + cond1 = self.color_hsv_r1[1] - self.color_hsv_l1[1] + cond2 = (self.color_hsv_l1[1] + 1) - self.color_hsv_r1[1] + if cond1 <= cond2: + hue = self.color_hsv_l1[1] + (self.spacer_hsv_g1 * cond1) + else: + hue = self.color_hsv_l1[1] - (self.spacer_hsv_g1 * cond2) + else: + # Conditions + cond1 = self.color_hsv_l1[1] - self.color_hsv_r1[1] + cond2 = (self.color_hsv_r1[1] + 1) - self.color_hsv_l1[1] + if cond1 <= cond2: + hue = self.color_hsv_l1[1] - (self.spacer_hsv_g1 * cond1) + else: + hue = self.color_hsv_l1[1] + (self.spacer_hsv_g1 * cond2) + # Correct Excess + if hue < 0: + hue = hue + 1 + if hue > 1: + hue = hue - 1 + hsv1 = hue + hsv2 = (self.color_hsv_l1[2] + (self.spacer_hsv_g1 * (self.color_hsv_r1[2] - self.color_hsv_l1[2]))) + hsv3 = (self.color_hsv_l1[3] + (self.spacer_hsv_g1 * (self.color_hsv_r1[3] - self.color_hsv_l1[3]))) + # Send Values + self.Color_APPLY("HSV", hsv1, hsv2, hsv3, 0) + def Mixer_HSV_G2(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_hsv_g2 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_hsv_l2[1] <= self.color_hsv_r2[1]: + # Conditions + cond1 = self.color_hsv_r2[1] - self.color_hsv_l2[1] + cond2 = (self.color_hsv_l2[1] + 1) - self.color_hsv_r2[1] + if cond1 <= cond2: + hue = self.color_hsv_l2[1] + (self.spacer_hsv_g2 * cond1) + else: + hue = self.color_hsv_l2[1] - (self.spacer_hsv_g2 * cond2) + else: + # Conditions + cond1 = self.color_hsv_l2[1] - self.color_hsv_r2[1] + cond2 = (self.color_hsv_r2[1] + 1) - self.color_hsv_l2[1] + if cond1 <= cond2: + hue = self.color_hsv_l2[1] - (self.spacer_hsv_g2 * cond1) + else: + hue = self.color_hsv_l2[1] + (self.spacer_hsv_g2 * cond2) + # Correct Excess + if hue < 0: + hue = hue + 1 + if hue > 1: + hue = hue - 1 + hsv1 = hue + hsv2 = (self.color_hsv_l2[2] + (self.spacer_hsv_g2 * (self.color_hsv_r2[2] - self.color_hsv_l2[2]))) + hsv3 = (self.color_hsv_l2[3] + (self.spacer_hsv_g2 * (self.color_hsv_r2[3] - self.color_hsv_l2[3]))) + # Send Values + self.Color_APPLY("HSV", hsv1, hsv2, hsv3, 0) + def Mixer_HSV_G3(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_hsv_g3 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_hsv_l3[1] <= self.color_hsv_r3[1]: + # Conditions + cond1 = self.color_hsv_r3[1] - self.color_hsv_l3[1] + cond2 = (self.color_hsv_l3[1] + 1) - self.color_hsv_r3[1] + if cond1 <= cond2: + hue = self.color_hsv_l3[1] + (self.spacer_hsv_g3 * cond1) + else: + hue = self.color_hsv_l3[1] - (self.spacer_hsv_g3 * cond2) + else: + # Conditions + cond1 = self.color_hsv_l3[1] - self.color_hsv_r3[1] + cond2 = (self.color_hsv_r3[1] + 1) - self.color_hsv_l3[1] + if cond1 <= cond2: + hue = self.color_hsv_l3[1] - (self.spacer_hsv_g3 * cond1) + else: + hue = self.color_hsv_l3[1] + (self.spacer_hsv_g3 * cond2) + # Correct Excess + if hue < 0: + hue = hue + 1 + if hue > 1: + hue = hue - 1 + hsv1 = hue + hsv2 = (self.color_hsv_l3[2] + (self.spacer_hsv_g3 * (self.color_hsv_r3[2] - self.color_hsv_l3[2]))) + hsv3 = (self.color_hsv_l3[3] + (self.spacer_hsv_g3 * (self.color_hsv_r3[3] - self.color_hsv_l3[3]))) + # Send Values + self.Color_APPLY("HSV", hsv1, hsv2, hsv3, 0) + + def Mixer_HSL_G1(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_hsl_g1 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_hsl_l1[1] <= self.color_hsl_r1[1]: + # Conditions + cond1 = self.color_hsl_r1[1] - self.color_hsl_l1[1] + cond2 = (self.color_hsl_l1[1] + 1) - self.color_hsl_r1[1] + if cond1 <= cond2: + hue = self.color_hsl_l1[1] + (self.spacer_hsl_g1 * cond1) + else: + hue = self.color_hsl_l1[1] - (self.spacer_hsl_g1 * cond2) + else: + # Conditions + cond1 = self.color_hsl_l1[1] - self.color_hsl_r1[1] + cond2 = (self.color_hsl_r1[1] + 1) - self.color_hsl_l1[1] + if cond1 <= cond2: + hue = self.color_hsl_l1[1] - (self.spacer_hsl_g1 * cond1) + else: + hue = self.color_hsl_l1[1] + (self.spacer_hsl_g1 * cond2) + # Correct Excess + if hue < 0: + hue = hue + 1 + if hue > 1: + hue = hue - 1 + hsl1 = hue + hsl2 = (self.color_hsl_l1[2] + (self.spacer_hsl_g1 * (self.color_hsl_r1[2] - self.color_hsl_l1[2]))) + hsl3 = (self.color_hsl_l1[3] + (self.spacer_hsl_g1 * (self.color_hsl_r1[3] - self.color_hsl_l1[3]))) + # Send Values + self.Color_APPLY("HSL", hsl1, hsl2, hsl3, 0) + def Mixer_HSL_G2(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_hsl_g2 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_hsl_l2[1] <= self.color_hsl_r2[1]: + # Conditions + cond1 = self.color_hsl_r2[1] - self.color_hsl_l2[1] + cond2 = (self.color_hsl_l2[1] + 1) - self.color_hsl_r2[1] + if cond1 <= cond2: + hue = self.color_hsl_l2[1] + (self.spacer_hsl_g2 * cond1) + else: + hue = self.color_hsl_l2[1] - (self.spacer_hsl_g2 * cond2) + else: + # Conditions + cond1 = self.color_hsl_l2[1] - self.color_hsl_r2[1] + cond2 = (self.color_hsl_r2[1] + 1) - self.color_hsl_l2[1] + if cond1 <= cond2: + hue = self.color_hsl_l2[1] - (self.spacer_hsl_g2 * cond1) + else: + hue = self.color_hsl_l2[1] + (self.spacer_hsl_g2 * cond2) + # Correct Excess + if hue < 0: + hue = hue + 1 + if hue > 1: + hue = hue - 1 + hsl1 = hue + hsl2 = (self.color_hsl_l2[2] + (self.spacer_hsl_g2 * (self.color_hsl_r2[2] - self.color_hsl_l2[2]))) + hsl3 = (self.color_hsl_l2[3] + (self.spacer_hsl_g2 * (self.color_hsl_r2[3] - self.color_hsl_l2[3]))) + # Send Values + self.Color_APPLY("HSL", hsl1, hsl2, hsl3, 0) + def Mixer_HSL_G3(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_hsl_g3 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_hsl_l3[1] <= self.color_hsl_r3[1]: + # Conditions + cond1 = self.color_hsl_r3[1] - self.color_hsl_l3[1] + cond2 = (self.color_hsl_l3[1] + 1) - self.color_hsl_r3[1] + if cond1 <= cond2: + hue = self.color_hsl_l3[1] + (self.spacer_hsl_g3 * cond1) + else: + hue = self.color_hsl_l3[1] - (self.spacer_hsl_g3 * cond2) + else: + # Conditions + cond1 = self.color_hsl_l3[1] - self.color_hsl_r3[1] + cond2 = (self.color_hsl_r3[1] + 1) - self.color_hsl_l3[1] + if cond1 <= cond2: + hue = self.color_hsl_l3[1] - (self.spacer_hsl_g3 * cond1) + else: + hue = self.color_hsl_l3[1] + (self.spacer_hsl_g3 * cond2) + # Correct Excess + if hue < 0: + hue = hue + 1 + if hue > 1: + hue = hue - 1 + hsl1 = hue + hsl2 = (self.color_hsl_l3[2] + (self.spacer_hsl_g3 * (self.color_hsl_r3[2] - self.color_hsl_l3[2]))) + hsl3 = (self.color_hsl_l3[3] + (self.spacer_hsl_g3 * (self.color_hsl_r3[3] - self.color_hsl_l3[3]))) + # Send Values + self.Color_APPLY("HSL", hsl1, hsl2, hsl3, 0) + + def Mixer_HCY_G1(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_hcy_g1 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_hcy_l1[1] <= self.color_hcy_r1[1]: + # Conditions + cond1 = self.color_hcy_r1[1] - self.color_hcy_l1[1] + cond2 = (self.color_hcy_l1[1] + 1) - self.color_hcy_r1[1] + if cond1 <= cond2: + hue = self.color_hcy_l1[1] + (self.spacer_hcy_g1 * cond1) + else: + hue = self.color_hcy_l1[1] - (self.spacer_hcy_g1 * cond2) + else: + # Conditions + cond1 = self.color_hcy_l1[1] - self.color_hcy_r1[1] + cond2 = (self.color_hcy_r1[1] + 1) - self.color_hcy_l1[1] + if cond1 <= cond2: + hue = self.color_hcy_l1[1] - (self.spacer_hcy_g1 * cond1) + else: + hue = self.color_hcy_l1[1] + (self.spacer_hcy_g1 * cond2) + # Correct Excess + if hue < 0: + hue = hue + 1 + if hue > 1: + hue = hue - 1 + hcy1 = hue + hcy2 = (self.color_hcy_l1[2] + (self.spacer_hcy_g1 * (self.color_hcy_r1[2] - self.color_hcy_l1[2]))) + hcy3 = (self.color_hcy_l1[3] + (self.spacer_hcy_g1 * (self.color_hcy_r1[3] - self.color_hcy_l1[3]))) + # Send Values + self.Color_APPLY("HCY", hcy1, hcy2, hcy3, 0) + def Mixer_HCY_G2(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_hcy_g2 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_hcy_l2[1] <= self.color_hcy_r2[1]: + # Conditions + cond1 = self.color_hcy_r2[1] - self.color_hcy_l2[1] + cond2 = (self.color_hcy_l2[1] + 1) - self.color_hcy_r2[1] + if cond1 <= cond2: + hue = self.color_hcy_l2[1] + (self.spacer_hcy_g2 * cond1) + else: + hue = self.color_hcy_l2[1] - (self.spacer_hcy_g2 * cond2) + else: + # Conditions + cond1 = self.color_hcy_l2[1] - self.color_hcy_r2[1] + cond2 = (self.color_hcy_r2[1] + 1) - self.color_hcy_l2[1] + if cond1 <= cond2: + hue = self.color_hcy_l2[1] - (self.spacer_hcy_g2 * cond1) + else: + hue = self.color_hcy_l2[1] + (self.spacer_hcy_g2 * cond2) + # Correct Excess + if hue < 0: + hue = hue + 1 + if hue > 1: + hue = hue - 1 + hcy1 = hue + hcy2 = (self.color_hcy_l2[2] + (self.spacer_hcy_g2 * (self.color_hcy_r2[2] - self.color_hcy_l2[2]))) + hcy3 = (self.color_hcy_l2[3] + (self.spacer_hcy_g2 * (self.color_hcy_r2[3] - self.color_hcy_l2[3]))) + # Send Values + self.Color_APPLY("HCY", hcy1, hcy2, hcy3, 0) + def Mixer_HCY_G3(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_hcy_g3 = SIGNAL_MIXER_VALUE / (self.mixer_width) + if self.color_hcy_l3[1] <= self.color_hcy_r3[1]: + # Conditions + cond1 = self.color_hcy_r3[1] - self.color_hcy_l3[1] + cond2 = (self.color_hcy_l3[1] + 1) - self.color_hcy_r3[1] + if cond1 <= cond2: + hue = self.color_hcy_l3[1] + (self.spacer_hcy_g3 * cond1) + else: + hue = self.color_hcy_l3[1] - (self.spacer_hcy_g3 * cond2) + else: + # Conditions + cond1 = self.color_hcy_l3[1] - self.color_hcy_r3[1] + cond2 = (self.color_hcy_r3[1] + 1) - self.color_hcy_l3[1] + if cond1 <= cond2: + hue = self.color_hcy_l3[1] - (self.spacer_hcy_g3 * cond1) + else: + hue = self.color_hcy_l3[1] + (self.spacer_hcy_g3 * cond2) + # Correct Excess + if hue < 0: + hue = hue + 1 + if hue > 1: + hue = hue - 1 + hcy1 = hue + hcy2 = (self.color_hcy_l3[2] + (self.spacer_hcy_g3 * (self.color_hcy_r3[2] - self.color_hcy_l3[2]))) + hcy3 = (self.color_hcy_l3[3] + (self.spacer_hcy_g3 * (self.color_hcy_r3[3] - self.color_hcy_l3[3]))) + # Send Values + self.Color_APPLY("HCY", hcy1, hcy2, hcy3, 0) + + def Mixer_YUV_G1(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_yuv_g1 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + yuv1 = (self.color_yuv_l1[1] + (self.spacer_yuv_g1 * (self.color_yuv_r1[1] - self.color_yuv_l1[1]))) + yuv2 = (self.color_yuv_l1[2] + (self.spacer_yuv_g1 * (self.color_yuv_r1[2] - self.color_yuv_l1[2]))) + yuv3 = (self.color_yuv_l1[3] + (self.spacer_yuv_g1 * (self.color_yuv_r1[3] - self.color_yuv_l1[3]))) + # Send Values + self.Color_HUE("YUV", yuv1, yuv2, yuv3, 0) + self.Color_APPLY("YUV", yuv1, yuv2, yuv3, 0) + def Mixer_YUV_G2(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_yuv_g2 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + yuv1 = (self.color_yuv_l2[1] + (self.spacer_yuv_g2 * (self.color_yuv_r2[1] - self.color_yuv_l2[1]))) + yuv2 = (self.color_yuv_l2[2] + (self.spacer_yuv_g2 * (self.color_yuv_r2[2] - self.color_yuv_l2[2]))) + yuv3 = (self.color_yuv_l2[3] + (self.spacer_yuv_g2 * (self.color_yuv_r2[3] - self.color_yuv_l2[3]))) + # Send Values + self.Color_HUE("YUV", yuv1, yuv2, yuv3, 0) + self.Color_APPLY("YUV", yuv1, yuv2, yuv3, 0) + def Mixer_YUV_G3(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_yuv_g3 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + yuv1 = (self.color_yuv_l3[1] + (self.spacer_yuv_g3 * (self.color_yuv_r3[1] - self.color_yuv_l3[1]))) + yuv2 = (self.color_yuv_l3[2] + (self.spacer_yuv_g3 * (self.color_yuv_r3[2] - self.color_yuv_l3[2]))) + yuv3 = (self.color_yuv_l3[3] + (self.spacer_yuv_g3 * (self.color_yuv_r3[3] - self.color_yuv_l3[3]))) + # Send Values + self.Color_HUE("YUV", yuv1, yuv2, yuv3, 0) + self.Color_APPLY("YUV", yuv1, yuv2, yuv3, 0) + + def Mixer_RYB_G1(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_ryb_g1 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + ryb1 = (self.color_ryb_l1[1] + (self.spacer_ryb_g1 * (self.color_ryb_r1[1] - self.color_ryb_l1[1]))) + ryb2 = (self.color_ryb_l1[2] + (self.spacer_ryb_g1 * (self.color_ryb_r1[2] - self.color_ryb_l1[2]))) + ryb3 = (self.color_ryb_l1[3] + (self.spacer_ryb_g1 * (self.color_ryb_r1[3] - self.color_ryb_l1[3]))) + # Send Values + self.Color_HUE("RYB", ryb1, ryb2, ryb3, 0) + self.Color_APPLY("RYB", ryb1, ryb2, ryb3, 0) + def Mixer_RYB_G2(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_ryb_g2 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + ryb1 = (self.color_ryb_l2[1] + (self.spacer_ryb_g2 * (self.color_ryb_r2[1] - self.color_ryb_l2[1]))) + ryb2 = (self.color_ryb_l2[2] + (self.spacer_ryb_g2 * (self.color_ryb_r2[2] - self.color_ryb_l2[2]))) + ryb3 = (self.color_ryb_l2[3] + (self.spacer_ryb_g2 * (self.color_ryb_r2[3] - self.color_ryb_l2[3]))) + # Send Values + self.Color_HUE("RYB", ryb1, ryb2, ryb3, 0) + self.Color_APPLY("RYB", ryb1, ryb2, ryb3, 0) + def Mixer_RYB_G3(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_ryb_g3 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + ryb1 = (self.color_ryb_l3[1] + (self.spacer_ryb_g3 * (self.color_ryb_r3[1] - self.color_ryb_l3[1]))) + ryb2 = (self.color_ryb_l3[2] + (self.spacer_ryb_g3 * (self.color_ryb_r3[2] - self.color_ryb_l3[2]))) + ryb3 = (self.color_ryb_l3[3] + (self.spacer_ryb_g3 * (self.color_ryb_r3[3] - self.color_ryb_l3[3]))) + # Send Values + self.Color_HUE("RYB", ryb1, ryb2, ryb3, 0) + self.Color_APPLY("RYB", ryb1, ryb2, ryb3, 0) + + def Mixer_CMYK_G1(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_cmyk_g1 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + cmyk1 = (self.color_cmyk_l1[1] + (self.spacer_cmyk_g1 * (self.color_cmyk_r1[1] - self.color_cmyk_l1[1]))) + cmyk2 = (self.color_cmyk_l1[2] + (self.spacer_cmyk_g1 * (self.color_cmyk_r1[2] - self.color_cmyk_l1[2]))) + cmyk3 = (self.color_cmyk_l1[3] + (self.spacer_cmyk_g1 * (self.color_cmyk_r1[3] - self.color_cmyk_l1[3]))) + cmyk4 = (self.color_cmyk_l1[4] + (self.spacer_cmyk_g1 * (self.color_cmyk_r1[4] - self.color_cmyk_l1[4]))) + # Send Values + self.Color_HUE("CMYK", cmyk1, cmyk2, cmyk3, cmyk4) + self.Color_APPLY("CMYK", cmyk1, cmyk2, cmyk3, cmyk4) + def Mixer_CMYK_G2(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_cmyk_g2 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + cmyk1 = (self.color_cmyk_l2[1] + (self.spacer_cmyk_g2 * (self.color_cmyk_r2[1] - self.color_cmyk_l2[1]))) + cmyk2 = (self.color_cmyk_l2[2] + (self.spacer_cmyk_g2 * (self.color_cmyk_r2[2] - self.color_cmyk_l2[2]))) + cmyk3 = (self.color_cmyk_l2[3] + (self.spacer_cmyk_g2 * (self.color_cmyk_r2[3] - self.color_cmyk_l2[3]))) + cmyk4 = (self.color_cmyk_l2[4] + (self.spacer_cmyk_g2 * (self.color_cmyk_r2[4] - self.color_cmyk_l2[4]))) + # Send Values + self.Color_HUE("CMYK", cmyk1, cmyk2, cmyk3, cmyk4) + self.Color_APPLY("CMYK", cmyk1, cmyk2, cmyk3, cmyk4) + def Mixer_CMYK_G3(self, SIGNAL_MIXER_VALUE): + # Percentage Value + self.spacer_cmyk_g3 = SIGNAL_MIXER_VALUE / (self.mixer_width) + # Percentual Value added to Left Color Percentil + cmyk1 = (self.color_cmyk_l3[1] + (self.spacer_cmyk_g3 * (self.color_cmyk_r3[1] - self.color_cmyk_l3[1]))) + cmyk2 = (self.color_cmyk_l3[2] + (self.spacer_cmyk_g3 * (self.color_cmyk_r3[2] - self.color_cmyk_l3[2]))) + cmyk3 = (self.color_cmyk_l3[3] + (self.spacer_cmyk_g3 * (self.color_cmyk_r3[3] - self.color_cmyk_l3[3]))) + cmyk4 = (self.color_cmyk_l3[4] + (self.spacer_cmyk_g3 * (self.color_cmyk_r3[4] - self.color_cmyk_l3[4]))) + # Send Values + self.Color_HUE("CMYK", cmyk1, cmyk2, cmyk3, cmyk4) + self.Color_APPLY("CMYK", cmyk1, cmyk2, cmyk3, cmyk4) + + #// + #\\ Harmony ################################################################ + def Harmony_Refresh(self): + if self.harmony_slot == 1: + self.Harmony_1_Active(0) + if self.harmony_slot == 2: + self.Harmony_2_Active(0) + if self.harmony_slot == 3: + self.Harmony_3_Active(0) + if self.harmony_slot == 4: + self.Harmony_4_Active(0) + if self.harmony_slot == 5: + self.Harmony_5_Active(0) + def Harmony_1_Active(self, SIGNAL_ACTIVE): + self.harmony_menu = self.dialog.har.isChecked() + if self.harmony_menu == True: + self.harmony_slot = 1 + self.Harmony_Slots(self.harmony_slot) + else: + self.harmony_slot = 0 + self.Harmony_Slots(self.harmony_slot) + # Update Display + self.Ratio_Channels() + def Harmony_2_Active(self, SIGNAL_ACTIVE): + self.harmony_menu = self.dialog.har.isChecked() + if self.harmony_menu == True: + self.harmony_slot = 2 + self.Harmony_Slots(self.harmony_slot) + else: + self.harmony_slot = 0 + self.Harmony_Slots(self.harmony_slot) + # Update Display + self.Ratio_Channels() + def Harmony_3_Active(self, SIGNAL_ACTIVE): + self.harmony_menu = self.dialog.har.isChecked() + if self.harmony_menu == True: + self.harmony_slot = 3 + self.Harmony_Slots(self.harmony_slot) + else: + self.harmony_slot = 0 + self.Harmony_Slots(self.harmony_slot) + # Update Display + self.Ratio_Channels() + def Harmony_4_Active(self, SIGNAL_ACTIVE): + self.harmony_menu = self.dialog.har.isChecked() + if self.harmony_menu == True: + self.harmony_slot = 4 + self.Harmony_Slots(self.harmony_slot) + else: + self.harmony_slot = 0 + self.Harmony_Slots(self.harmony_slot) + # Update Display + self.Ratio_Channels() + def Harmony_5_Active(self, SIGNAL_ACTIVE): + self.harmony_menu = self.dialog.har.isChecked() + if self.harmony_menu == True: + self.harmony_slot = 5 + self.Harmony_Slots(self.harmony_slot) + else: + self.harmony_slot = 0 + self.Harmony_Slots(self.harmony_slot) + # Update Display + self.Ratio_Channels() + + def Harmony_Slots(self, slot): + self.Hexagon_Points_UVD() + if slot == 0: + self.harmony_1.Active(False) + self.harmony_2.Active(False) + self.harmony_3.Active(False) + self.harmony_4.Active(False) + self.harmony_5.Active(False) + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + if slot == 1: + self.harmony_1.Active(True) + self.harmony_2.Active(False) + self.harmony_3.Active(False) + self.harmony_4.Active(False) + self.harmony_5.Active(False) + self.Color_HUE("RGB", self.har_1[1], self.har_1[2], self.har_1[3], 0) + self.Color_APPLY("RGB", self.har_1[1], self.har_1[2], self.har_1[3], 0) + if slot == 2: + self.harmony_1.Active(False) + self.harmony_2.Active(True) + self.harmony_3.Active(False) + self.harmony_4.Active(False) + self.harmony_5.Active(False) + self.Color_HUE("RGB", self.har_2[1], self.har_2[2], self.har_2[3], 0) + self.Color_APPLY("RGB", self.har_2[1], self.har_2[2], self.har_2[3], 0) + if slot == 3: + self.harmony_1.Active(False) + self.harmony_2.Active(False) + self.harmony_3.Active(True) + self.harmony_4.Active(False) + self.harmony_5.Active(False) + self.Color_HUE("RGB", self.har_3[1], self.har_3[2], self.har_3[3], 0) + self.Color_APPLY("RGB", self.har_3[1], self.har_3[2], self.har_3[3], 0) + if slot == 4: + self.harmony_1.Active(False) + self.harmony_2.Active(False) + self.harmony_3.Active(False) + self.harmony_4.Active(True) + self.harmony_5.Active(False) + self.Color_HUE("RGB", self.har_4[1], self.har_4[2], self.har_4[3], 0) + self.Color_APPLY("RGB", self.har_4[1], self.har_4[2], self.har_4[3], 0) + if slot == 5: + self.harmony_1.Active(False) + self.harmony_2.Active(False) + self.harmony_3.Active(False) + self.harmony_4.Active(False) + self.harmony_5.Active(True) + self.Color_HUE("RGB", self.har_5[1], self.har_5[2], self.har_5[3], 0) + self.Color_APPLY("RGB", self.har_5[1], self.har_5[2], self.har_5[3], 0) + # Update Display + self.Pigment_Release() + self.Ratio_Channels() + + def Harmony_Span(self, SIGNAL_ACTIVE): + self.harmony_span = SIGNAL_ACTIVE + + + #// + #\\ DOT #################################################################### + def DOT_Interpolation(self): + self.dot_interpolation = self.dialog.dot_interpolation.currentText() + self.Update_Panel_DOT() + def DOT_Resolution(self): + string = self.dialog.dot_resolution.currentText().split() + self.dot_dimension = int(string[0]) + self.Update_Panel_DOT() + + def DOT_1_APPLY(self, SIGNAL_CLICKS): + if self.dot_1[0] == True: + self.Color_HUE("RGB", self.dot_1[1], self.dot_1[2], self.dot_1[3], 0) + self.Color_APPLY("RGB", self.dot_1[1], self.dot_1[2], self.dot_1[3], 0) + self.Pigment_Release() + def DOT_1_SAVE(self, SIGNAL_CLICKS): + self.dot_1 = [True, self.rgb_1, self.rgb_2, self.rgb_3, self.xyz_1, self.xyz_2, self.xyz_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_1[1]*255, self.dot_1[2]*255, self.dot_1[3]*255)) + self.layout.dot_1.setStyleSheet(color) + self.Update_Panel_DOT() + def DOT_1_CLEAN(self, SIGNAL_CLICKS): + self.dot_1 = [False, 0, 0, 0, 0, 0, 0] + self.layout.dot_1.setStyleSheet(self.bg_alpha) + self.Update_Panel_DOT() + + def DOT_2_APPLY(self, SIGNAL_CLICKS): + if self.dot_2[0] == True: + self.Color_HUE("RGB", self.dot_2[1], self.dot_2[2], self.dot_2[3], 0) + self.Color_APPLY("RGB", self.dot_2[1], self.dot_2[2], self.dot_2[3], 0) + self.Pigment_Release() + def DOT_2_SAVE(self, SIGNAL_CLICKS): + self.dot_2 = [True, self.rgb_1, self.rgb_2, self.rgb_3, self.xyz_1, self.xyz_2, self.xyz_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_2[1]*255, self.dot_2[2]*255, self.dot_2[3]*255)) + self.layout.dot_2.setStyleSheet(color) + self.Update_Panel_DOT() + def DOT_2_CLEAN(self, SIGNAL_CLICKS): + self.dot_2 = [False, 0, 0, 0, 0, 0, 0] + self.layout.dot_2.setStyleSheet(self.bg_alpha) + self.Update_Panel_DOT() + + def DOT_3_APPLY(self, SIGNAL_CLICKS): + if self.dot_3[0] == True: + self.Color_HUE("RGB", self.dot_3[1], self.dot_3[2], self.dot_3[3], 0) + self.Color_APPLY("RGB", self.dot_3[1], self.dot_3[2], self.dot_3[3], 0) + self.Pigment_Release() + def DOT_3_SAVE(self, SIGNAL_CLICKS): + self.dot_3 = [True, self.rgb_1, self.rgb_2, self.rgb_3, self.xyz_1, self.xyz_2, self.xyz_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_3[1]*255, self.dot_3[2]*255, self.dot_3[3]*255)) + self.layout.dot_3.setStyleSheet(color) + self.Update_Panel_DOT() + def DOT_3_CLEAN(self, SIGNAL_CLICKS): + self.dot_3 = [False, 0, 0, 0, 0, 0, 0] + self.layout.dot_3.setStyleSheet(self.bg_alpha) + self.Update_Panel_DOT() + + def DOT_4_APPLY(self, SIGNAL_CLICKS): + if self.dot_4[0] == True: + self.Color_HUE("RGB", self.dot_4[1], self.dot_4[2], self.dot_4[3], 0) + self.Color_APPLY("RGB", self.dot_4[1], self.dot_4[2], self.dot_4[3], 0) + self.Pigment_Release() + def DOT_4_SAVE(self, SIGNAL_CLICKS): + self.dot_4 = [True, self.rgb_1, self.rgb_2, self.rgb_3, self.xyz_1, self.xyz_2, self.xyz_3] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_4[1]*255, self.dot_4[2]*255, self.dot_4[3]*255)) + self.layout.dot_4.setStyleSheet(color) + self.Update_Panel_DOT() + def DOT_4_CLEAN(self, SIGNAL_CLICKS): + self.dot_4 = [False, 0, 0, 0, 0, 0, 0] + self.layout.dot_4.setStyleSheet(self.bg_alpha) + self.Update_Panel_DOT() + + def DOT_SWAP(self): + # transition variables to do the swap + a1 = self.dot_1 + a2 = self.dot_2 + b1 = self.dot_3 + b2 = self.dot_4 + # swap the variables + self.dot_1 = b1 + self.dot_2 = b2 + self.dot_3 = a1 + self.dot_4 = a2 + # Apply Colors + if self.dot_1[0] == True: + color_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_1[1]*255, self.dot_1[2]*255, self.dot_1[3]*255)) + self.layout.dot_1.setStyleSheet(color_1) + else: + self.layout.dot_1.setStyleSheet(self.bg_alpha) + if self.dot_2[0] == True: + color_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_2[1]*255, self.dot_2[2]*255, self.dot_2[3]*255)) + self.layout.dot_2.setStyleSheet(color_2) + else: + self.layout.dot_2.setStyleSheet(self.bg_alpha) + if self.dot_3[0] == True: + color_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_3[1]*255, self.dot_3[2]*255, self.dot_3[3]*255)) + self.layout.dot_3.setStyleSheet(color_3) + else: + self.layout.dot_3.setStyleSheet(self.bg_alpha) + if self.dot_4[0] == True: + color_4 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_4[1]*255, self.dot_4[2]*255, self.dot_4[3]*255)) + self.layout.dot_4.setStyleSheet(color_4) + else: + self.layout.dot_4.setStyleSheet(self.bg_alpha) + # Update Display + self.Update_Panel_DOT() + + #// + #\\ OBJ #################################################################### + def BG_1_LIVE(self): + if self.layout.b1_live.isChecked() == True: + self.BG_1_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.bg_1[self.obj_index][4]) + def BG_1_APPLY(self): + if self.bg_1[self.obj_index][0] == True: + self.Object_Color(self.bg_1[self.obj_index][1], self.bg_1[self.obj_index][2], self.bg_1[self.obj_index][3]) + self.Pigment_Release() + def BG_1_SAVE(self, val_1, val_2, val_3, val_4): + self.bg_1[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.bg_1[self.obj_index][1]*255, self.bg_1[self.obj_index][2]*255, self.bg_1[self.obj_index][3]*255, self.bg_1[self.obj_index][4]*255)) + self.layout.b1_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def BG_1_CLEAN(self): + self.bg_1[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.b1_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def BG_1_ALPHA(self, SIGNAL_VALUE): + self.bg_1[self.obj_index][4] = SIGNAL_VALUE + self.BG_1_SAVE(self.bg_1[self.obj_index][1], self.bg_1[self.obj_index][2], self.bg_1[self.obj_index][3], self.bg_1[self.obj_index][4]) + def BG_1_Exclusion(self): + # self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.bg_1[self.obj_index][1], self.bg_1[self.obj_index][2], self.bg_1[self.obj_index][3]) + + def BG_2_LIVE(self): + if self.layout.b2_live.isChecked() == True: + self.BG_2_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.bg_2[self.obj_index][4]) + def BG_2_APPLY(self): + if self.bg_2[self.obj_index][0] == True: + self.Object_Color(self.bg_2[self.obj_index][1], self.bg_2[self.obj_index][2], self.bg_2[self.obj_index][3]) + self.Pigment_Release() + def BG_2_SAVE(self, val_1, val_2, val_3, val_4): + self.bg_2[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.bg_2[self.obj_index][1]*255, self.bg_2[self.obj_index][2]*255, self.bg_2[self.obj_index][3]*255, self.bg_2[self.obj_index][4]*255)) + self.layout.b2_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def BG_2_CLEAN(self): + self.bg_2[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.b2_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def BG_2_ALPHA(self, SIGNAL_VALUE): + self.bg_2[self.obj_index][4] = SIGNAL_VALUE + self.BG_2_SAVE(self.bg_2[self.obj_index][1], self.bg_2[self.obj_index][2], self.bg_2[self.obj_index][3], self.bg_2[self.obj_index][4]) + def BG_2_Exclusion(self): + self.layout.b1_live.setChecked(0) + # self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.bg_2[self.obj_index][1], self.bg_2[self.obj_index][2], self.bg_2[self.obj_index][3]) + + def BG_3_LIVE(self): + if self.layout.b3_live.isChecked() == True: + self.BG_3_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.bg_3[self.obj_index][4]) + def BG_3_APPLY(self): + if self.bg_3[self.obj_index][0] == True: + self.Object_Color(self.bg_3[self.obj_index][1], self.bg_3[self.obj_index][2], self.bg_3[self.obj_index][3]) + self.Pigment_Release() + def BG_3_SAVE(self, val_1, val_2, val_3, val_4): + self.bg_3[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.bg_3[self.obj_index][1]*255, self.bg_3[self.obj_index][2]*255, self.bg_3[self.obj_index][3]*255, self.bg_3[self.obj_index][4]*255)) + self.layout.b3_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def BG_3_CLEAN(self): + self.bg_3[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.b3_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def BG_3_ALPHA(self, SIGNAL_VALUE): + self.bg_3[self.obj_index][4] = SIGNAL_VALUE + self.BG_3_SAVE(self.bg_3[self.obj_index][1], self.bg_3[self.obj_index][2], self.bg_3[self.obj_index][3], self.bg_3[self.obj_index][4]) + def BG_3_Exclusion(self): + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + # self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.bg_3[self.obj_index][1], self.bg_3[self.obj_index][2], self.bg_3[self.obj_index][3]) + + + def DIF_1_LIVE(self): + if self.layout.d1_live.isChecked() == True: + self.DIF_1_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_1[self.obj_index][4]) + def DIF_1_APPLY(self): + if self.dif_1[self.obj_index][0] == True: + self.Object_Color(self.dif_1[self.obj_index][1], self.dif_1[self.obj_index][2], self.dif_1[self.obj_index][3]) + self.Pigment_Release() + def DIF_1_SAVE(self, val_1, val_2, val_3, val_4): + self.dif_1[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_1[self.obj_index][1]*255, self.dif_1[self.obj_index][2]*255, self.dif_1[self.obj_index][3]*255, self.dif_1[self.obj_index][4]*255)) + self.layout.d1_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_1_CLEAN(self): + self.dif_1[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.d1_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_1_ALPHA(self, SIGNAL_VALUE): + self.dif_1[self.obj_index][4] = SIGNAL_VALUE + self.DIF_1_SAVE(self.dif_1[self.obj_index][1], self.dif_1[self.obj_index][2], self.dif_1[self.obj_index][3], self.dif_1[self.obj_index][4]) + def DIF_1_Exclusion(self): + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + # self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.dif_1[self.obj_index][1], self.dif_1[self.obj_index][2], self.dif_1[self.obj_index][3]) + + def DIF_2_LIVE(self): + if self.layout.d2_live.isChecked() == True: + self.DIF_2_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_2[self.obj_index][4]) + def DIF_2_APPLY(self): + if self.dif_2[self.obj_index][0] == True: + self.Object_Color(self.dif_2[self.obj_index][1], self.dif_2[self.obj_index][2], self.dif_2[self.obj_index][3]) + self.Pigment_Release() + def DIF_2_SAVE(self, val_1, val_2, val_3, val_4): + self.dif_2[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_2[self.obj_index][1]*255, self.dif_2[self.obj_index][2]*255, self.dif_2[self.obj_index][3]*255, self.dif_2[self.obj_index][4]*255)) + self.layout.d2_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_2_CLEAN(self): + self.dif_2[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.d2_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_2_ALPHA(self, SIGNAL_VALUE): + self.dif_2[self.obj_index][4] = SIGNAL_VALUE + self.DIF_2_SAVE(self.dif_2[self.obj_index][1], self.dif_2[self.obj_index][2], self.dif_2[self.obj_index][3], self.dif_2[self.obj_index][4]) + def DIF_2_Exclusion(self): + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + # self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.dif_2[self.obj_index][1], self.dif_2[self.obj_index][2], self.dif_2[self.obj_index][3]) + + def DIF_3_LIVE(self): + if self.layout.d3_live.isChecked() == True: + self.DIF_3_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_3[self.obj_index][4]) + def DIF_3_APPLY(self): + if self.dif_3[self.obj_index][0] == True: + self.Object_Color(self.dif_3[self.obj_index][1], self.dif_3[self.obj_index][2], self.dif_3[self.obj_index][3]) + self.Pigment_Release() + def DIF_3_SAVE(self, val_1, val_2, val_3, val_4): + self.dif_3[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_3[self.obj_index][1]*255, self.dif_3[self.obj_index][2]*255, self.dif_3[self.obj_index][3]*255, self.dif_3[self.obj_index][4]*255)) + self.layout.d3_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_3_CLEAN(self): + self.dif_3[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.d3_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_3_ALPHA(self, SIGNAL_VALUE): + self.dif_3[self.obj_index][4] = SIGNAL_VALUE + self.DIF_3_SAVE(self.dif_3[self.obj_index][1], self.dif_3[self.obj_index][2], self.dif_3[self.obj_index][3], self.dif_3[self.obj_index][4]) + def DIF_3_Exclusion(self): + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + # self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.dif_3[self.obj_index][1], self.dif_3[self.obj_index][2], self.dif_3[self.obj_index][3]) + + def DIF_4_LIVE(self): + if self.layout.d4_live.isChecked() == True: + self.DIF_4_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_4[self.obj_index][4]) + def DIF_4_APPLY(self): + if self.dif_4[self.obj_index][0] == True: + self.Object_Color(self.dif_4[self.obj_index][1], self.dif_4[self.obj_index][2], self.dif_4[self.obj_index][3]) + self.Pigment_Release() + def DIF_4_SAVE(self, val_1, val_2, val_3, val_4): + self.dif_4[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_4[self.obj_index][1]*255, self.dif_4[self.obj_index][2]*255, self.dif_4[self.obj_index][3]*255, self.dif_4[self.obj_index][4]*255)) + self.layout.d4_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_4_CLEAN(self): + self.dif_4[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.d4_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_4_ALPHA(self, SIGNAL_VALUE): + self.dif_4[self.obj_index][4] = SIGNAL_VALUE + self.DIF_4_SAVE(self.dif_4[self.obj_index][1], self.dif_4[self.obj_index][2], self.dif_4[self.obj_index][3], self.dif_4[self.obj_index][4]) + def DIF_4_Exclusion(self): + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + # self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.dif_4[self.obj_index][1], self.dif_4[self.obj_index][2], self.dif_4[self.obj_index][3]) + + def DIF_5_LIVE(self): + if self.layout.d5_live.isChecked() == True: + self.DIF_5_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_5[self.obj_index][4]) + def DIF_5_APPLY(self): + if self.dif_5[self.obj_index][0] == True: + self.Object_Color(self.dif_5[self.obj_index][1], self.dif_5[self.obj_index][2], self.dif_5[self.obj_index][3]) + self.Pigment_Release() + def DIF_5_SAVE(self, val_1, val_2, val_3, val_4): + self.dif_5[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_5[self.obj_index][1]*255, self.dif_5[self.obj_index][2]*255, self.dif_5[self.obj_index][3]*255, self.dif_5[self.obj_index][4]*255)) + self.layout.d5_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_5_CLEAN(self): + self.dif_5[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.d5_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_5_ALPHA(self, SIGNAL_VALUE): + self.dif_5[self.obj_index][4] = SIGNAL_VALUE + self.DIF_5_SAVE(self.dif_5[self.obj_index][1], self.dif_5[self.obj_index][2], self.dif_5[self.obj_index][3], self.dif_5[self.obj_index][4]) + def DIF_5_Exclusion(self): + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + # self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.dif_5[self.obj_index][1], self.dif_5[self.obj_index][2], self.dif_5[self.obj_index][3]) + + def DIF_6_LIVE(self): + if self.layout.d6_live.isChecked() == True: + self.DIF_6_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.dif_6[self.obj_index][4]) + def DIF_6_APPLY(self): + if self.dif_6[self.obj_index][0] == True: + self.Object_Color(self.dif_6[self.obj_index][1], self.dif_6[self.obj_index][2], self.dif_6[self.obj_index][3]) + self.Pigment_Release() + def DIF_6_SAVE(self, val_1, val_2, val_3, val_4): + self.dif_6[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_6[self.obj_index][1]*255, self.dif_6[self.obj_index][2]*255, self.dif_6[self.obj_index][3]*255, self.dif_6[self.obj_index][4]*255)) + self.layout.d6_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_6_CLEAN(self): + self.dif_6[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.d6_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def DIF_6_ALPHA(self, SIGNAL_VALUE): + self.dif_6[self.obj_index][4] = SIGNAL_VALUE + self.DIF_6_SAVE(self.dif_6[self.obj_index][1], self.dif_6[self.obj_index][2], self.dif_6[self.obj_index][3], self.dif_6[self.obj_index][4]) + def DIF_6_Exclusion(self): + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + # self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.dif_6[self.obj_index][1], self.dif_6[self.obj_index][2], self.dif_6[self.obj_index][3]) + + + def FG_1_LIVE(self): + if self.layout.f1_live.isChecked() == True: + self.FG_1_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.fg_1[self.obj_index][4]) + def FG_1_APPLY(self): + if self.fg_1[self.obj_index][0] == True: + self.Object_Color(self.fg_1[self.obj_index][1], self.fg_1[self.obj_index][2], self.fg_1[self.obj_index][3]) + self.Pigment_Release() + def FG_1_SAVE(self, val_1, val_2, val_3, val_4): + self.fg_1[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.fg_1[self.obj_index][1]*255, self.fg_1[self.obj_index][2]*255, self.fg_1[self.obj_index][3]*255, self.fg_1[self.obj_index][4]*255)) + self.layout.f1_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def FG_1_CLEAN(self): + self.fg_1[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.f1_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def FG_1_ALPHA(self, SIGNAL_VALUE): + self.fg_1[self.obj_index][4] = SIGNAL_VALUE + self.FG_1_SAVE(self.fg_1[self.obj_index][1], self.fg_1[self.obj_index][2], self.fg_1[self.obj_index][3], self.fg_1[self.obj_index][4]) + def FG_1_Exclusion(self): + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + # self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.fg_1[self.obj_index][1], self.fg_1[self.obj_index][2], self.fg_1[self.obj_index][3]) + + def FG_2_LIVE(self): + if self.layout.f2_live.isChecked() == True: + self.FG_2_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.fg_2[self.obj_index][4]) + def FG_2_APPLY(self): + if self.fg_2[self.obj_index][0] == True: + self.Object_Color(self.fg_2[self.obj_index][1], self.fg_2[self.obj_index][2], self.fg_2[self.obj_index][3]) + self.Pigment_Release() + def FG_2_SAVE(self, val_1, val_2, val_3, val_4): + self.fg_2[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.fg_2[self.obj_index][1]*255, self.fg_2[self.obj_index][2]*255, self.fg_2[self.obj_index][3]*255, self.fg_2[self.obj_index][4]*255)) + self.layout.f2_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def FG_2_CLEAN(self): + self.fg_2[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.f2_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def FG_2_ALPHA(self, SIGNAL_VALUE): + self.fg_2[self.obj_index][4] = SIGNAL_VALUE + self.FG_2_SAVE(self.fg_2[self.obj_index][1], self.fg_2[self.obj_index][2], self.fg_2[self.obj_index][3], self.fg_2[self.obj_index][4]) + def FG_2_Exclusion(self): + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + # self.layout.f2_live.setChecked(0) + self.layout.f3_live.setChecked(0) + self.Object_Color(self.fg_2[self.obj_index][1], self.fg_2[self.obj_index][2], self.fg_2[self.obj_index][3]) + + def FG_3_LIVE(self): + if self.layout.f3_live.isChecked() == True: + self.FG_3_SAVE(self.rgb_1, self.rgb_2, self.rgb_3, self.fg_3[self.obj_index][4]) + def FG_3_APPLY(self): + if self.fg_3[self.obj_index][0] == True: + self.Object_Color(self.fg_3[self.obj_index][1], self.fg_3[self.obj_index][2], self.fg_3[self.obj_index][3]) + self.Pigment_Release() + def FG_3_SAVE(self, val_1, val_2, val_3, val_4): + self.fg_3[self.obj_index] = [True, val_1, val_2, val_3, val_4] + color = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.fg_3[self.obj_index][1]*255, self.fg_3[self.obj_index][2]*255, self.fg_3[self.obj_index][3]*255, self.fg_3[self.obj_index][4]*255)) + self.layout.f3_color.setStyleSheet(color) + self.Update_Panel_OBJ() + self.Pigment_Release() + def FG_3_CLEAN(self): + self.fg_3[self.obj_index] = [False, 0, 0, 0, 0] + self.layout.f3_color.setStyleSheet(self.bg_alpha) + self.Update_Panel_OBJ() + self.Pigment_Release() + def FG_3_ALPHA(self, SIGNAL_VALUE): + self.fg_3[self.obj_index][4] = SIGNAL_VALUE + self.FG_3_SAVE(self.fg_3[self.obj_index][1], self.fg_3[self.obj_index][2], self.fg_3[self.obj_index][3], self.fg_3[self.obj_index][4]) + def FG_3_Exclusion(self): + self.layout.b1_live.setChecked(0) + self.layout.b2_live.setChecked(0) + self.layout.b3_live.setChecked(0) + self.layout.d1_live.setChecked(0) + self.layout.d2_live.setChecked(0) + self.layout.d3_live.setChecked(0) + self.layout.d4_live.setChecked(0) + self.layout.d5_live.setChecked(0) + self.layout.d6_live.setChecked(0) + self.layout.f1_live.setChecked(0) + self.layout.f2_live.setChecked(0) + # self.layout.f3_live.setChecked(0) + self.Object_Color(self.fg_3[self.obj_index][1], self.fg_3[self.obj_index][2], self.fg_3[self.obj_index][3]) + + def Object_Color(self, val1, val2, val3): + self.Color_HUE("RGB", val1, val2, val3, 0) + self.Color_APPLY("RGB", val1, val2, val3, 0) + def Object_Live(self): + self.BG_1_LIVE() + self.BG_2_LIVE() + self.BG_3_LIVE() + self.DIF_1_LIVE() + self.DIF_2_LIVE() + self.DIF_3_LIVE() + self.DIF_4_LIVE() + self.DIF_5_LIVE() + self.DIF_6_LIVE() + self.FG_1_LIVE() + self.FG_2_LIVE() + self.FG_3_LIVE() + def Object_Save(self): + self.BG_1_SAVE(self.bg_1[self.obj_index][1], self.bg_1[self.obj_index][2], self.bg_1[self.obj_index][3], self.bg_1[self.obj_index][4]) + self.BG_2_SAVE(self.bg_2[self.obj_index][1], self.bg_2[self.obj_index][2], self.bg_2[self.obj_index][3], self.bg_2[self.obj_index][4]) + self.BG_3_SAVE(self.bg_3[self.obj_index][1], self.bg_3[self.obj_index][2], self.bg_3[self.obj_index][3], self.bg_3[self.obj_index][4]) + self.DIF_1_SAVE(self.dif_1[self.obj_index][1], self.dif_1[self.obj_index][2], self.dif_1[self.obj_index][3], self.dif_1[self.obj_index][4]) + self.DIF_2_SAVE(self.dif_2[self.obj_index][1], self.dif_2[self.obj_index][2], self.dif_2[self.obj_index][3], self.dif_2[self.obj_index][4]) + self.DIF_3_SAVE(self.dif_3[self.obj_index][1], self.dif_3[self.obj_index][2], self.dif_3[self.obj_index][3], self.dif_3[self.obj_index][4]) + self.DIF_4_SAVE(self.dif_4[self.obj_index][1], self.dif_4[self.obj_index][2], self.dif_4[self.obj_index][3], self.dif_4[self.obj_index][4]) + self.DIF_5_SAVE(self.dif_5[self.obj_index][1], self.dif_5[self.obj_index][2], self.dif_5[self.obj_index][3], self.dif_5[self.obj_index][4]) + self.DIF_6_SAVE(self.dif_6[self.obj_index][1], self.dif_6[self.obj_index][2], self.dif_6[self.obj_index][3], self.dif_6[self.obj_index][4]) + self.FG_1_SAVE(self.fg_1[self.obj_index][1], self.fg_1[self.obj_index][2], self.fg_1[self.obj_index][3], self.fg_1[self.obj_index][4]) + self.FG_2_SAVE(self.fg_2[self.obj_index][1], self.fg_2[self.obj_index][2], self.fg_2[self.obj_index][3], self.fg_2[self.obj_index][4]) + self.FG_3_SAVE(self.fg_3[self.obj_index][1], self.fg_3[self.obj_index][2], self.fg_3[self.obj_index][3], self.fg_3[self.obj_index][4]) + def Object_SetDisplay(self): + color01 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.bg_1[self.obj_index][1]*255, self.bg_1[self.obj_index][2]*255, self.bg_1[self.obj_index][3]*255, self.bg_1[self.obj_index][4]*255)) + color02 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.bg_2[self.obj_index][1]*255, self.bg_2[self.obj_index][2]*255, self.bg_2[self.obj_index][3]*255, self.bg_2[self.obj_index][4]*255)) + color03 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.bg_3[self.obj_index][1]*255, self.bg_3[self.obj_index][2]*255, self.bg_3[self.obj_index][3]*255, self.bg_3[self.obj_index][4]*255)) + color04 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_1[self.obj_index][1]*255, self.dif_1[self.obj_index][2]*255, self.dif_1[self.obj_index][3]*255, self.dif_1[self.obj_index][4]*255)) + color05 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_2[self.obj_index][1]*255, self.dif_2[self.obj_index][2]*255, self.dif_2[self.obj_index][3]*255, self.dif_2[self.obj_index][4]*255)) + color06 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_3[self.obj_index][1]*255, self.dif_3[self.obj_index][2]*255, self.dif_3[self.obj_index][3]*255, self.dif_3[self.obj_index][4]*255)) + color07 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_4[self.obj_index][1]*255, self.dif_4[self.obj_index][2]*255, self.dif_4[self.obj_index][3]*255, self.dif_4[self.obj_index][4]*255)) + color08 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_5[self.obj_index][1]*255, self.dif_5[self.obj_index][2]*255, self.dif_5[self.obj_index][3]*255, self.dif_5[self.obj_index][4]*255)) + color09 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dif_6[self.obj_index][1]*255, self.dif_6[self.obj_index][2]*255, self.dif_6[self.obj_index][3]*255, self.dif_6[self.obj_index][4]*255)) + color10 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.fg_1[self.obj_index][1]*255, self.fg_1[self.obj_index][2]*255, self.fg_1[self.obj_index][3]*255, self.fg_1[self.obj_index][4]*255)) + color11 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.fg_2[self.obj_index][1]*255, self.fg_2[self.obj_index][2]*255, self.fg_2[self.obj_index][3]*255, self.fg_2[self.obj_index][4]*255)) + color12 = str("background-color: rgba(%f, %f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.fg_3[self.obj_index][1]*255, self.fg_3[self.obj_index][2]*255, self.fg_3[self.obj_index][3]*255, self.fg_3[self.obj_index][4]*255)) + self.layout.b1_color.setStyleSheet(color01) + self.layout.b2_color.setStyleSheet(color02) + self.layout.b3_color.setStyleSheet(color03) + self.layout.d1_color.setStyleSheet(color04) + self.layout.d2_color.setStyleSheet(color05) + self.layout.d3_color.setStyleSheet(color06) + self.layout.d4_color.setStyleSheet(color07) + self.layout.d5_color.setStyleSheet(color08) + self.layout.d6_color.setStyleSheet(color09) + self.layout.f1_color.setStyleSheet(color10) + self.layout.f2_color.setStyleSheet(color11) + self.layout.f3_color.setStyleSheet(color12) + + #// + #\\ IMG #################################################################### + def IMG_File(self): + path = QFileDialog.getOpenFileName(self, 'Open', '', 'All Files (*.*)') + if QImageReader(path[0]).canRead() == True: + self.img_state = "SAVE" + QImage(path[0]).save(self.img_save) + self.Update_Panel_IMG() + self.panel_img.Set_QImage(path[0]) + def IMG_APPLY(self, path): + self.Update_Panel_IMG() + if self.img_state == "SAVE": + self.panel_img.Set_QImage(path) + elif self.img_state == "DEFAULT": + self.panel_img.Set_Default(self.img_default) + def IMG_GrayScale(self): + self.img_grayscale = self.dialog.img_grayscale.isChecked() + self.Update_Panel_IMG() + self.panel_img.update() + + #// + #\\ History ################################################################ + def History_List(self, value1, value2, value3): + color = QColor(value1*k_RGB, value2*k_RGB, value3*k_RGB) + pixmap = QPixmap(15,30) + pixmap.fill(color) + item = QListWidgetItem() + item.setIcon(QIcon(pixmap)) + item.setBackground(QBrush(color)) + self.layout.color_history.insertItem(0, item) + + def History_APPLY(self): + current = self.layout.color_history.currentItem() + color = current.background().color() + red = color.red() / k_RGB + green = color.green() / k_RGB + blue = color.blue() / k_RGB + self.Color_HUE("RGB", red, green, blue, 0) + self.Color_APPLY("RGB", red, green, blue, 0) + def History_CLEAR(self): + self.layout.color_history.clear() + + #// + #\\ Key Shortcuts ########################################################## + def Menu_Key_1(self): + self.key_1 = self.dialog.key_1.currentText() + def Menu_Key_2(self): + self.key_2 = self.dialog.key_2.currentText() + def Menu_Key_3(self): + self.key_3 = self.dialog.key_3.currentText() + def Menu_Key_4(self): + self.key_4 = self.dialog.key_4.currentText() + + #// + #\\ Selection ############################################################## + def Selection_APPLY(self): + if ((self.canvas() is not None) and (self.canvas().view() is not None)): + doc = Krita.instance().activeDocument() + node = doc.activeNode() + selection = self.selectRGB(node, int(self.rgb_1*k_RGB), int(self.rgb_2*k_RGB), int(self.rgb_3*k_RGB), 255) + doc.setSelection(selection) + + def selectRGB(self, node, red, green, blue, selectionLevel): + pdata = node.projectionPixelData(node.bounds().left(), node.bounds().top(), node.bounds().width(), node.bounds().height()) + + bred = red.to_bytes(1, 'big') + bgreen = green.to_bytes(1, 'big') + bblue = blue.to_bytes(1, 'big') + + selectionPixels = [0]*(node.bounds().width()*node.bounds().height()) + + offset=0 + for index in range(len(selectionPixels)): + if (pdata[offset] == bblue and pdata[offset+1] == bgreen and pdata[offset+2] == bred): + selectionPixels[index] = min(selectionLevel, int.from_bytes(pdata[offset+3], 'big')) + offset+=4 + + returned = Selection() + returned.setPixelData(QByteArray(bytes(selectionPixels)), node.bounds().left(), node.bounds().top(), node.bounds().width(), node.bounds().height()) + + return returned + + #// + #\\ Module Signals ######################################################### + def Signal_Apply_RGB(self, SIGNAL_APPLY): + self.rgb_1 = SIGNAL_APPLY[0] + self.rgb_2 = SIGNAL_APPLY[1] + self.rgb_3 = SIGNAL_APPLY[2] + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Pigment_Release() + + def Signal_UVD(self, SIGNAL_UVD_VALUE): + if SIGNAL_UVD_VALUE[0] == "UV": + self.uvd_1 = round(SIGNAL_UVD_VALUE[1]*k_UVD, 2) / k_UVD + self.uvd_2 = round(SIGNAL_UVD_VALUE[2]*k_UVD, 2) / k_UVD + if SIGNAL_UVD_VALUE[0] == "D": + factor = 100 + self.uvd_3 = self.uvd_3 + (SIGNAL_UVD_VALUE[3]/factor) + self.uvd_3 = self.Math_1D_Limit(self.uvd_3) + hue = self.uvd_to_ard(self.uvd_1, self.uvd_2, self.uvd_3) + self.angle_live = hue[0] + self.Color_APPLY("UVD", self.uvd_1, self.uvd_2, self.uvd_3, 0) + self.layout.label.setText("") + + def Signal_YUV(self, SIGNAL_YUV_VALUE): + if SIGNAL_YUV_VALUE[0] == "Y": + factor = 100 + self.yuv_1 = round(self.yuv_1 + (SIGNAL_YUV_VALUE[1]/factor), 2) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + if SIGNAL_YUV_VALUE[0] == "UV": + self.yuv_2 = round(SIGNAL_YUV_VALUE[2]*k_UV, 2) / k_UV + self.yuv_3 = round(SIGNAL_YUV_VALUE[3]*k_UV, 2) / k_UV + self.Color_HUE("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.Color_APPLY("YUV", self.yuv_1, self.yuv_2, self.yuv_3, 0) + self.layout.label.setText("") + + def Signal_ARD(self, SIGNAL_ARD_VALUE): + if SIGNAL_ARD_VALUE[0] == "A": + factor = 100 + if self.wheel == "CMY": + hue = self.ard_1 + (SIGNAL_ARD_VALUE[1]/factor) + if self.wheel == "RYB": + hue = self.hcmy_to_hryb(self.ard_1) + (SIGNAL_ARD_VALUE[1]/factor) + if hue <= 0: + hue += 1 + if hue >= 1: + hue -= 1 + if self.wheel == "CMY": + self.angle_live = self.ard_1 = hue + if self.wheel == "RYB": + self.angle_live = self.ard_1 = self.hryb_to_hcmy(hue) + if self.luma_lock == True: + ll = self.luma_lock_ard(self.ard_1, self.ard_2, self.ard_3) + self.Color_APPLY("RGB", ll[0], ll[1], ll[2], 0) + else: + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + if SIGNAL_ARD_VALUE[0] == "RD": + self.ard_2 = round(SIGNAL_ARD_VALUE[2]*k_SVL, 2) / k_SVL + self.ard_3 = round(SIGNAL_ARD_VALUE[3]*k_SVL, 2) / k_SVL + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + self.layout.label.setText("") + + def Signal_HSV_4(self, SIGNAL_HSV_4_VALUE): # Solo e Hue + if SIGNAL_HSV_4_VALUE[0] == "H": + factor = 100 + if self.wheel == "CMY": + hue = self.hsv_1 + (SIGNAL_HSV_4_VALUE[1]/factor) + if self.wheel == "RYB": + hue = self.hcmy_to_hryb(self.hsv_1) + (SIGNAL_HSV_4_VALUE[1]/factor) + if hue <= 0: + hue += 1 + if hue >= 1: + hue -= 1 + if self.wheel == "CMY": + self.angle_live = self.hsv_1 = hue + if self.wheel == "RYB": + self.angle_live = self.hsv_1 = self.hryb_to_hcmy(hue) + if self.luma_lock == True: + ll = self.luma_lock_hsv(self.hsv_1, self.hsv_2, self.hsv_3) + self.Color_APPLY("RGB", ll[0], ll[1], ll[2], 0) + else: + self.Color_APPLY("HSV", self.angle_live, self.hsv_2, self.hsv_3, 0) + if SIGNAL_HSV_4_VALUE[0] == "SV": + self.hsv_2 = round(SIGNAL_HSV_4_VALUE[2]*k_SVL, 2) / k_SVL + self.hsv_3 = round(SIGNAL_HSV_4_VALUE[3]*k_SVL, 2) / k_SVL + self.Color_APPLY("HSV", self.angle_live, self.hsv_2, self.hsv_3, 0) + self.layout.label.setText("") + + def Signal_HSL_3(self, SIGNAL_HSL_3_VALUE): # Hue Triangle + if SIGNAL_HSL_3_VALUE[0] == "H": + factor = 100 + if self.wheel == "CMY": + hue = self.hsl_1 + (SIGNAL_HSL_3_VALUE[1]/factor) + if self.wheel == "RYB": + hue = self.hcmy_to_hryb(self.hsl_1) + (SIGNAL_HSL_3_VALUE[1]/factor) + if hue <= 0: + hue += 1 + if hue >= 1: + hue -= 1 + if self.wheel == "CMY": + self.angle_live = self.hsl_1 = hue + if self.wheel == "RYB": + self.angle_live = self.hsl_1 = self.hryb_to_hcmy(hue) + if self.luma_lock == True: + ll = self.luma_lock_hsl(self.hsl_1, self.hsl_2, self.hsl_3) + self.Color_APPLY("RGB", ll[0], ll[1], ll[2], 0) + else: + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + if SIGNAL_HSL_3_VALUE[0] == "SL": + self.hsl_2 = round(SIGNAL_HSL_3_VALUE[2]*k_SVL, 2) / k_SVL + self.hsl_3 = round(SIGNAL_HSL_3_VALUE[3]*k_SVL, 2) / k_SVL + self.Color_APPLY("HSL", self.angle_live, self.hsl_2, self.hsl_3, 0) + self.layout.label.setText("") + def Signal_HSL_4(self, SIGNAL_HSL_4_VALUE): # Solo + if SIGNAL_HSL_4_VALUE[0] == "H": + factor = 100 + if self.wheel == "CMY": + hue = self.hsl_1 + (SIGNAL_HSL_4_VALUE[1]/factor) + if self.wheel == "RYB": + hue = self.hcmy_to_hryb(self.hsl_1) + (SIGNAL_HSL_4_VALUE[1]/factor) + if hue <= 0: + hue += 1 + if hue >= 1: + hue -= 1 + if self.wheel == "CMY": + self.angle_live = self.hsl_1 = hue + if self.wheel == "RYB": + self.angle_live = self.hsl_1 = self.hryb_to_hcmy(hue) + if self.luma_lock == True: + ll = self.luma_lock_hsl(self.hsl_1, self.hsl_2, self.hsl_3) + self.Color_APPLY("RGB", ll[0], ll[1], ll[2], 0) + else: + self.Color_APPLY("HSL", self.angle_live, self.hsl_2, self.hsl_3, 0) + if SIGNAL_HSL_4_VALUE[0] == "SL": + self.hsl_2 = round(SIGNAL_HSL_4_VALUE[2]*k_SVL, 2) / k_SVL + self.hsl_3 = round(SIGNAL_HSL_4_VALUE[3]*k_SVL, 2) / k_SVL + self.Color_APPLY("HSL", self.angle_live, self.hsl_2, self.hsl_3, 0) + self.layout.label.setText("") + def Signal_HSL_4D(self, SIGNAL_HSL_4D_VALUE): # Hue Diamond + if SIGNAL_HSL_4D_VALUE[0] == "H": + factor = 100 + if self.wheel == "CMY": + hue = self.hsl_1 + (SIGNAL_HSL_4D_VALUE[1]/factor) + if self.wheel == "RYB": + hue = self.hcmy_to_hryb(self.hsl_1) + (SIGNAL_HSL_4D_VALUE[1]/factor) + if hue <= 0: + hue += 1 + if hue >= 1: + hue -= 1 + if self.wheel == "CMY": + self.angle_live = self.hsl_1 = hue + if self.wheel == "RYB": + self.angle_live = self.hsl_1 = self.hryb_to_hcmy(hue) + if self.luma_lock == True: + ll = self.luma_lock_hsl(self.hsl_1, self.hsl_2, self.hsl_3) + self.Color_APPLY("RGB", ll[0], ll[1], ll[2], 0) + else: + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + if SIGNAL_HSL_4D_VALUE[0] == "SL": + self.hsl_2 = round(SIGNAL_HSL_4D_VALUE[2]*k_SVL, 2) / k_SVL + self.hsl_3 = round(SIGNAL_HSL_4D_VALUE[3]*k_SVL, 2) / k_SVL + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + self.layout.label.setText("") + + def Signal_HCY_4(self, SIGNAL_HCY_4_VALUE): # Solo e Hue + if SIGNAL_HCY_4_VALUE[0] == "H": + factor = 100 + if self.wheel == "CMY": + hue = self.hcy_1 + (SIGNAL_HCY_4_VALUE[1]/factor) + if self.wheel == "RYB": + hue = self.hcmy_to_hryb(self.hcy_1) + (SIGNAL_HCY_4_VALUE[1]/factor) + if hue <= 0: + hue += 1 + if hue >= 1: + hue -= 1 + if self.wheel == "CMY": + self.angle_live = self.hcy_1 = hue + if self.wheel == "RYB": + self.angle_live = self.hcy_1 = self.hryb_to_hcmy(hue) + if self.luma_lock == True: + ll = self.luma_lock_hcy(self.hcy_1, self.hcy_2, self.hcy_3) + self.Color_APPLY("RGB", ll[0], ll[1], ll[2], 0) + else: + self.Color_APPLY("HCY", self.angle_live, self.hcy_2, self.hcy_3, 0) + if SIGNAL_HCY_4_VALUE[0] == "CY": + self.hcy_2 = round(SIGNAL_HCY_4_VALUE[2]*k_SVL, 2) / k_SVL + self.hcy_3 = round(SIGNAL_HCY_4_VALUE[3]*k_SVL, 2) / k_SVL + self.Color_APPLY("HCY", self.angle_live, self.hcy_2, self.hcy_3, 0) + self.layout.label.setText("") + + def Signal_HUE_Circle(self, SIGNAL_HUE_C_VALUE): + if self.harmony_space == "ARD": + if self.wheel == "CMY": + self.angle_live = self.ard_1 = SIGNAL_HUE_C_VALUE[0] + if self.wheel == "RYB": + self.angle_live = self.ard_1 = self.hryb_to_hcmy(SIGNAL_HUE_C_VALUE[0]) + if self.luma_lock == True: + ll = self.luma_lock_ard(self.ard_1, self.ard_2, self.ard_3) + self.Color_APPLY("RGB", ll[0], ll[1], ll[2], 0) + else: + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + if self.harmony_space == "HSV": + if self.wheel == "CMY": + self.angle_live = self.hsv_1 = SIGNAL_HUE_C_VALUE[0] + if self.wheel == "RYB": + self.angle_live = self.hsv_1 = self.hryb_to_hcmy(SIGNAL_HUE_C_VALUE[0]) + if self.luma_lock == True: + ll = self.luma_lock_hsv(self.hsv_1, self.hsv_2, self.hsv_3) + self.Color_APPLY("RGB", ll[0], ll[1], ll[2], 0) + else: + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + if self.harmony_space == "HSL": + if self.wheel == "CMY": + self.angle_live = self.hsl_1 = SIGNAL_HUE_C_VALUE[0] + if self.wheel == "RYB": + self.angle_live = self.hsl_1 = self.hryb_to_hcmy(SIGNAL_HUE_C_VALUE[0]) + if self.luma_lock == True: + ll = self.luma_lock_hsl(self.hsl_1, self.hsl_2, self.hsl_3) + self.Color_APPLY("RGB", ll[0], ll[1], ll[2], 0) + else: + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + if self.harmony_space == "HCY": + if self.wheel == "CMY": + self.angle_live = self.hcy_1 = SIGNAL_HUE_C_VALUE[0] + if self.wheel == "RYB": + self.angle_live = self.hcy_1 = self.hryb_to_hcmy(SIGNAL_HUE_C_VALUE[0]) + if self.luma_lock == True: + ll = self.luma_lock_hcy(self.hcy_1, self.hcy_2, self.hcy_3) + self.Color_APPLY("RGB", ll[0], ll[1], ll[2], 0) + else: + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.layout.label.setText("") + def Signal_HUE_Active(self, SIGNAL_HUE_C_HARMONY_ACTIVE): + self.harmony_slot = int(SIGNAL_HUE_C_HARMONY_ACTIVE) + if self.harmony_slot == 1: + self.harmony_1.Active(True) + self.harmony_2.Active(False) + self.harmony_3.Active(False) + self.harmony_4.Active(False) + self.harmony_5.Active(False) + self.Color_HUE("RGB", self.har_1[1], self.har_1[2], self.har_1[3], 0) + self.Color_APPLY("RGB", self.har_1[1], self.har_1[2], self.har_1[3], 0) + self.Pigment_Release() + if self.harmony_slot == 2: + self.harmony_1.Active(False) + self.harmony_2.Active(True) + self.harmony_3.Active(False) + self.harmony_4.Active(False) + self.harmony_5.Active(False) + self.Color_HUE("RGB", self.har_2[1], self.har_2[2], self.har_2[3], 0) + self.Color_APPLY("RGB", self.har_2[1], self.har_2[2], self.har_2[3], 0) + self.Pigment_Release() + if self.harmony_slot == 3: + self.harmony_1.Active(False) + self.harmony_2.Active(False) + self.harmony_3.Active(True) + self.harmony_4.Active(False) + self.harmony_5.Active(False) + self.Color_HUE("RGB", self.har_3[1], self.har_3[2], self.har_3[3], 0) + self.Color_APPLY("RGB", self.har_3[1], self.har_3[2], self.har_3[3], 0) + self.Pigment_Release() + if self.harmony_slot == 4: + self.harmony_1.Active(False) + self.harmony_2.Active(False) + self.harmony_3.Active(False) + self.harmony_4.Active(True) + self.harmony_5.Active(False) + self.Color_HUE("RGB", self.har_4[1], self.har_4[2], self.har_4[3], 0) + self.Color_APPLY("RGB", self.har_4[1], self.har_4[2], self.har_4[3], 0) + self.Pigment_Release() + if self.harmony_slot == 5: + self.harmony_1.Active(False) + self.harmony_2.Active(False) + self.harmony_3.Active(False) + self.harmony_4.Active(False) + self.harmony_5.Active(True) + self.Color_HUE("RGB", self.har_5[1], self.har_5[2], self.har_5[3], 0) + self.Color_APPLY("RGB", self.har_5[1], self.har_5[2], self.har_5[3], 0) + self.Pigment_Release() + # Update Display + self.Ratio_Channels() + + def Signal_GAM_Circle(self, SIGNAL_GAM_C_VALUE): + self.gamut_angle = SIGNAL_GAM_C_VALUE[0] + self.P1_S1_r = SIGNAL_GAM_C_VALUE[1] + self.P1_S3_r = SIGNAL_GAM_C_VALUE[2] + self.P1_S4_r = SIGNAL_GAM_C_VALUE[3] + self.P2_S1_r = SIGNAL_GAM_C_VALUE[4] + self.P3_S3_r = SIGNAL_GAM_C_VALUE[5] + # Update Rotation + self.Update_Panel_GAM_Circle() + self.Update_Panel_GAM_Polygon(self.P1_S1_r, self.P1_S3_r, self.P1_S4_r, self.P2_S1_r, self.P3_S3_r) + self.layout.panel_gam.update() + self.layout.label.setText("") + def Signal_GAM_Points(self, SIGNAL_GAM_P_POINTS): + if SIGNAL_GAM_P_POINTS[0] == "None": + pass + if SIGNAL_GAM_P_POINTS[0] == "P1_S1": + if SIGNAL_GAM_P_POINTS[1] == 1: + self.P1_S1[0] = SIGNAL_GAM_P_POINTS[2] + self.P1_S1[1] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 2: + self.P1_S1[2] = SIGNAL_GAM_P_POINTS[2] + self.P1_S1[3] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 3: + self.P1_S1[4] = SIGNAL_GAM_P_POINTS[2] + self.P1_S1[5] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 4: + self.P1_S1[6] = SIGNAL_GAM_P_POINTS[2] + self.P1_S1[7] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[0] == "P1_S3": + if SIGNAL_GAM_P_POINTS[1] == 1: + self.P1_S3[0] = SIGNAL_GAM_P_POINTS[2] + self.P1_S3[1] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 2: + self.P1_S3[2] = SIGNAL_GAM_P_POINTS[2] + self.P1_S3[3] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 3: + self.P1_S3[4] = SIGNAL_GAM_P_POINTS[2] + self.P1_S3[5] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[0] == "P1_S4": + if SIGNAL_GAM_P_POINTS[1] == 1: + self.P1_S4[0] = SIGNAL_GAM_P_POINTS[2] + self.P1_S4[1] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 2: + self.P1_S4[2] = SIGNAL_GAM_P_POINTS[2] + self.P1_S4[3] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 3: + self.P1_S4[4] = SIGNAL_GAM_P_POINTS[2] + self.P1_S4[5] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 4: + self.P1_S4[6] = SIGNAL_GAM_P_POINTS[2] + self.P1_S4[7] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[0] == "P2_S1": + if SIGNAL_GAM_P_POINTS[1] == 1: + self.P2_S1[0] = SIGNAL_GAM_P_POINTS[2] + self.P2_S1[1] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 2: + self.P2_S1[2] = SIGNAL_GAM_P_POINTS[2] + self.P2_S1[3] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 3: + self.P2_S1[4] = SIGNAL_GAM_P_POINTS[2] + self.P2_S1[5] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 4: + self.P2_S1[6] = SIGNAL_GAM_P_POINTS[2] + self.P2_S1[7] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 5: + self.P2_S1[8] = SIGNAL_GAM_P_POINTS[2] + self.P2_S1[9] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 6: + self.P2_S1[10] = SIGNAL_GAM_P_POINTS[2] + self.P2_S1[11] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 7: + self.P2_S1[12] = SIGNAL_GAM_P_POINTS[2] + self.P2_S1[13] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 8: + self.P2_S1[14] = SIGNAL_GAM_P_POINTS[2] + self.P2_S1[15] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[0] == "P3_S3": + if SIGNAL_GAM_P_POINTS[1] == 1: + self.P3_S3[0] = SIGNAL_GAM_P_POINTS[2] + self.P3_S3[1] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 2: + self.P3_S3[2] = SIGNAL_GAM_P_POINTS[2] + self.P3_S3[3] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 3: + self.P3_S3[4] = SIGNAL_GAM_P_POINTS[2] + self.P3_S3[5] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 4: + self.P3_S3[6] = SIGNAL_GAM_P_POINTS[2] + self.P3_S3[7] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 5: + self.P3_S3[8] = SIGNAL_GAM_P_POINTS[2] + self.P3_S3[9] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 6: + self.P3_S3[10] = SIGNAL_GAM_P_POINTS[2] + self.P3_S3[11] = SIGNAL_GAM_P_POINTS[3] + if SIGNAL_GAM_P_POINTS[1] == 7: + self.P3_S3[12] = SIGNAL_GAM_P_POINTS[2] + self.P3_S3[13] = SIGNAL_GAM_P_POINTS[3] + self.Update_Panel_GAM_Circle() + self.Update_Panel_GAM_Polygon(self.P1_S1_r, self.P1_S3_r, self.P1_S4_r, self.P2_S1_r, self.P3_S3_r) + self.layout.label.setText("") + def Signal_GAM_Polygon(self, SIGNAL_GAM_P_VALUE): + if SIGNAL_GAM_P_VALUE[0] == "12": + if self.gamut_space == "ARD": + if self.wheel == "CMY": + hue = self.Math_1D_Loop(SIGNAL_GAM_P_VALUE[1]) + self.angle_live = self.ard_1 = hue + self.ard_2 = SIGNAL_GAM_P_VALUE[2] + if self.wheel == "RYB": + hue = self.Math_1D_Loop(self.hryb_to_hcmy(SIGNAL_GAM_P_VALUE[1])) + self.angle_live = self.ard_1 = hue + self.ard_2 = SIGNAL_GAM_P_VALUE[2] + self.Color_APPLY("ARD", self.angle_live, self.ard_2, self.ard_3, 0) + if self.gamut_space == "HSV": + if self.wheel == "CMY": + hue = self.Math_1D_Loop(SIGNAL_GAM_P_VALUE[1]) + self.angle_live = self.hsv_1 = hue + self.hsv_2 = SIGNAL_GAM_P_VALUE[2] + if self.wheel == "RYB": + hue = self.Math_1D_Loop(self.hryb_to_hcmy(SIGNAL_GAM_P_VALUE[1])) + self.angle_live = self.hsv_1 = hue + self.hsv_2 = SIGNAL_GAM_P_VALUE[2] + self.Color_APPLY("HSV", self.angle_live, self.hsv_2, self.hsv_3, 0) + if self.gamut_space == "HSL": + if self.wheel == "CMY": + hue = self.Math_1D_Loop(SIGNAL_GAM_P_VALUE[1]) + self.angle_live = self.hsl_1 = hue + self.hsl_2 = SIGNAL_GAM_P_VALUE[2] + if self.wheel == "RYB": + hue = self.Math_1D_Loop(self.hryb_to_hcmy(SIGNAL_GAM_P_VALUE[1])) + self.angle_live = self.hsl_1 = hue + self.hsl_2 = SIGNAL_GAM_P_VALUE[2] + self.Color_APPLY("HSL", self.angle_live, self.hsl_2, self.hsl_3, 0) + if self.gamut_space == "HCY": + if self.wheel == "CMY": + hue = self.Math_1D_Loop(SIGNAL_GAM_P_VALUE[1]) + self.angle_live = self.hcy_1 = hue + self.hcy_2 = SIGNAL_GAM_P_VALUE[2] + if self.wheel == "RYB": + hue = self.Math_1D_Loop(self.hryb_to_hcmy(SIGNAL_GAM_P_VALUE[1])) + self.angle_live = self.hcy_1 = hue + self.hcy_2 = SIGNAL_GAM_P_VALUE[2] + self.Color_APPLY("HCY", self.angle_live, self.hcy_2, self.hcy_3, 0) + if SIGNAL_GAM_P_VALUE[0] == "3": + factor = 100 + if self.gamut_space == "ARD": + self.ard_3 = self.ard_3 + (SIGNAL_GAM_P_VALUE[3]/factor) + self.ard_3 = self.Math_1D_Limit(self.ard_3) + self.Color_APPLY("ARD", self.ard_1, self.ard_2, self.ard_3, 0) + if self.gamut_space == "HSV": + self.hsv_3 = self.hsv_3 + (SIGNAL_GAM_P_VALUE[3]/factor) + self.hsv_3 = self.Math_1D_Limit(self.hsv_3) + self.Color_APPLY("HSV", self.hsv_1, self.hsv_2, self.hsv_3, 0) + if self.gamut_space == "HSL": + self.hsl_3 = self.hsl_3 + (SIGNAL_GAM_P_VALUE[3]/factor) + self.hsl_3 = self.Math_1D_Limit(self.hsl_3) + self.Color_APPLY("HSL", self.hsl_1, self.hsl_2, self.hsl_3, 0) + if self.gamut_space == "HCY": + self.hcy_3 = self.hcy_3 + (SIGNAL_GAM_P_VALUE[3]/factor) + self.hcy_3 = self.Math_1D_Limit(self.hcy_3) + self.Color_APPLY("HCY", self.hcy_1, self.hcy_2, self.hcy_3, 0) + self.layout.label.setText("") + + def Signal_DOT_Color(self, SIGNAL_DOT_COLOR): + # Geometry + width = self.layout.panel_dot_mix.width() + height = self.layout.panel_dot_mix.height() + pixmap = self.layout.panel_dot_mix.grab(QRect(QPoint(0, 0), QPoint(width, height))) + image = pixmap.toImage() + scaled = image.scaled(QSize(width, height)) + color = scaled.pixelColor(SIGNAL_DOT_COLOR[0], SIGNAL_DOT_COLOR[1]) + # Apply Color Values + if (color.red() != 0 and color.green() != 0 and color.blue() != 0): + self.rgb_1 = color.red()/255 + self.rgb_2 = color.green()/255 + self.rgb_3 = color.blue()/255 + # Apply Colors + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.layout.label.setText("") + def Signal_DOT_Cursor(self, SIGNAL_DOT_CURSOR): + self.dot_location_x = SIGNAL_DOT_CURSOR[0] + self.dot_location_y = SIGNAL_DOT_CURSOR[1] + + def Signal_OBJ_Color(self, SIGNAL_OBJ_COLOR): + # Geometry + pixmap = self.layout.panel_obj_display.grab(QRect(QPoint(0, 0), QPoint(self.obj_w, self.obj_h))) + image = pixmap.toImage() + color = image.pixelColor(SIGNAL_OBJ_COLOR[0], SIGNAL_OBJ_COLOR[1]) + # Apply Color Values + self.rgb_1 = color.red()/255 + self.rgb_2 = color.green()/255 + self.rgb_3 = color.blue()/255 + # Apply Colors + self.angle_live = self.rgb_to_hue(self.rgb_1, self.rgb_2, self.rgb_3)[0] + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.layout.label.setText("") + def Signal_OBJ_Cursor(self, SIGNAL_OBJ_CURSOR): + self.obj_location_x = SIGNAL_OBJ_CURSOR[0] + self.obj_location_y = SIGNAL_OBJ_CURSOR[1] + + def Signal_IMG_State(self, SIGNAL_IMG_STATE): + self.img_state = SIGNAL_IMG_STATE + def Signal_IMG_Color(self, SIGNAL_IMG_COLOR): + # Geometry + pixmap = self.layout.panel_img.grab(QRect(QPoint(0, 0), QPoint(self.img_w, self.img_h))) + image = pixmap.toImage() + color = image.pixelColor(SIGNAL_IMG_COLOR[0], SIGNAL_IMG_COLOR[1]) + # Apply Color Values + self.rgb_1 = color.red()/255 + self.rgb_2 = color.green()/255 + self.rgb_3 = color.blue()/255 + # Apply Colors + self.angle_live = self.rgb_to_hue(self.rgb_1, self.rgb_2, self.rgb_3)[0] + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.layout.label.setText("") + def Signal_Scan_Value(self, SIGNAL_SCAN_VAL): + self.layout.scan_progress.setValue(SIGNAL_SCAN_VAL) + def Pigment_Scan_Maximum(self, SIGNAL_SCAN_MAX): + self.layout.scan_progress.setMaximum(SIGNAL_SCAN_MAX) + + def Signal_Panel_Zoom(self, SIGNAL_ZOOM): + self.zoom = SIGNAL_ZOOM + + def Signal_Extension_COR(self, SIGNAL_COR): + if SIGNAL_COR == 0: + self.Cor_00_APPLY(0) + if SIGNAL_COR == 1: + self.Cor_01_APPLY(0) + if SIGNAL_COR == 2: + self.Cor_02_APPLY(0) + if SIGNAL_COR == 3: + self.Cor_03_APPLY(0) + if SIGNAL_COR == 4: + self.Cor_04_APPLY(0) + if SIGNAL_COR == 5: + self.Cor_05_APPLY(0) + if SIGNAL_COR == 6: + self.Cor_06_APPLY(0) + if SIGNAL_COR == 7: + self.Cor_07_APPLY(0) + if SIGNAL_COR == 8: + self.Cor_08_APPLY(0) + if SIGNAL_COR == 9: + self.Cor_09_APPLY(0) + if SIGNAL_COR == 10: + self.Cor_10_APPLY(0) + def Signal_Extension_KEY(self, SIGNAL_KEY): + if SIGNAL_KEY == "K1 Minus": + # None + if self.key_1 == "KEY 1": + pass + # AAA + if self.key_1 == "A 1": + self.Pigment_AAA_1_Minus() + # RGB + if self.key_1 == "RGB 1": + self.Pigment_RGB_1_Minus() + if self.key_1 == "RGB 2": + self.Pigment_RGB_2_Minus() + if self.key_1 == "RGB 3": + self.Pigment_RGB_3_Minus() + # CMY + if self.key_1 == "CMY 1": + self.Pigment_CMY_1_Minus() + if self.key_1 == "CMY 2": + self.Pigment_CMY_2_Minus() + if self.key_1 == "CMY 3": + self.Pigment_CMY_3_Minus() + # CMYK + if self.key_1 == "CMYK 1": + self.Pigment_CMYK_1_Minus() + if self.key_1 == "CMYK 2": + self.Pigment_CMYK_2_Minus() + if self.key_1 == "CMYK 3": + self.Pigment_CMYK_3_Minus() + if self.key_1 == "CMYK 4": + self.Pigment_CMYK_4_Minus() + # RYB + if self.key_1 == "RYB 1": + self.Pigment_RYB_1_Minus() + if self.key_1 == "RYB 2": + self.Pigment_RYB_2_Minus() + if self.key_1 == "RYB 3": + self.Pigment_RYB_3_Minus() + # YUV + if self.key_1 == "YUV 1": + self.Pigment_YUV_1_Minus() + if self.key_1 == "YUV 2": + self.Pigment_YUV_2_Minus() + if self.key_1 == "YUV 3": + self.Pigment_YUV_3_Minus() + # KKK + if self.key_1 == "K 1": + self.Pigment_KKK_1_Minus() + + # ARD + if self.key_1 == "ARD 1": + self.Pigment_ARD_1_Minus() + if self.key_1 == "ARD 2": + self.Pigment_ARD_2_Minus() + if self.key_1 == "ARD 3": + self.Pigment_ARD_3_Minus() + # HSV + if self.key_1 == "HSV 1": + self.Pigment_HSV_1_Minus() + if self.key_1 == "HSV 2": + self.Pigment_HSV_2_Minus() + if self.key_1 == "HSV 3": + self.Pigment_HSV_3_Minus() + # HSL + if self.key_1 == "HSL 1": + self.Pigment_HSL_1_Minus() + if self.key_1 == "HSL 2": + self.Pigment_HSL_2_Minus() + if self.key_1 == "HSL 3": + self.Pigment_HSL_3_Minus() + # HCY + if self.key_1 == "HCY 1": + self.Pigment_HCY_1_Minus() + if self.key_1 == "HCY 2": + self.Pigment_HCY_2_Minus() + if self.key_1 == "HCY 3": + self.Pigment_HCY_3_Minus() + + # XYZ + if self.key_1 == "XYZ 1": + self.Pigment_XYZ_1_Minus() + if self.key_1 == "XYZ 2": + self.Pigment_XYZ_2_Minus() + if self.key_1 == "XYZ 3": + self.Pigment_XYZ_3_Minus() + # XYY + if self.key_1 == "XYY 1": + self.Pigment_XYY_1_Minus() + if self.key_1 == "XYY 2": + self.Pigment_XYY_2_Minus() + if self.key_1 == "XYY 3": + self.Pigment_XYY_3_Minus() + # LUV + if self.key_1 == "LUV 1": + self.Pigment_LUV_1_Minus() + if self.key_1 == "LUV 2": + self.Pigment_LUV_2_Minus() + if self.key_1 == "LUV 3": + self.Pigment_LUV_3_Minus() + # HLAB + if self.key_1 == "HLAB 1": + self.Pigment_HLAB_1_Minus() + if self.key_1 == "HLAB 2": + self.Pigment_HLAB_2_Minus() + if self.key_1 == "HLAB 3": + self.Pigment_HLAB_3_Minus() + # LAB + if self.key_1 == "LAB 1": + self.Pigment_LAB_1_Minus() + if self.key_1 == "LAB 2": + self.Pigment_LAB_2_Minus() + if self.key_1 == "LAB 3": + self.Pigment_LAB_3_Minus() + # LCH + if self.key_1 == "LCH 1": + self.Pigment_LCH_1_Minus() + if self.key_1 == "LCH 2": + self.Pigment_LCH_2_Minus() + if self.key_1 == "LCH 3": + self.Pigment_LCH_3_Minus() + if SIGNAL_KEY == "K1 Plus": + # None + if self.key_1 == "KEY 1": + pass + # AAA + if self.key_1 == "A 1": + self.Pigment_AAA_1_Plus() + # RGB + if self.key_1 == "RGB 1": + self.Pigment_RGB_1_Plus() + if self.key_1 == "RGB 2": + self.Pigment_RGB_2_Plus() + if self.key_1 == "RGB 3": + self.Pigment_RGB_3_Plus() + # CMY + if self.key_1 == "CMY 1": + self.Pigment_CMY_1_Plus() + if self.key_1 == "CMY 2": + self.Pigment_CMY_2_Plus() + if self.key_1 == "CMY 3": + self.Pigment_CMY_3_Plus() + # CMYK + if self.key_1 == "CMYK 1": + self.Pigment_CMYK_1_Plus() + if self.key_1 == "CMYK 2": + self.Pigment_CMYK_2_Plus() + if self.key_1 == "CMYK 3": + self.Pigment_CMYK_3_Plus() + if self.key_1 == "CMYK 4": + self.Pigment_CMYK_4_Plus() + # RYB + if self.key_1 == "RYB 1": + self.Pigment_RYB_1_Plus() + if self.key_1 == "RYB 2": + self.Pigment_RYB_2_Plus() + if self.key_1 == "RYB 3": + self.Pigment_RYB_3_Plus() + # YUV + if self.key_1 == "YUV 1": + self.Pigment_YUV_1_Plus() + if self.key_1 == "YUV 2": + self.Pigment_YUV_2_Plus() + if self.key_1 == "YUV 3": + self.Pigment_YUV_3_Plus() + # KKK + if self.key_1 == "K 1": + self.Pigment_KKK_1_Plus() + + # ARD + if self.key_1 == "ARD 1": + self.Pigment_ARD_1_Plus() + if self.key_1 == "ARD 2": + self.Pigment_ARD_2_Plus() + if self.key_1 == "ARD 3": + self.Pigment_ARD_3_Plus() + # HSV + if self.key_1 == "HSV 1": + self.Pigment_HSV_1_Plus() + if self.key_1 == "HSV 2": + self.Pigment_HSV_2_Plus() + if self.key_1 == "HSV 3": + self.Pigment_HSV_3_Plus() + # HSL + if self.key_1 == "HSL 1": + self.Pigment_HSL_1_Plus() + if self.key_1 == "HSL 2": + self.Pigment_HSL_2_Plus() + if self.key_1 == "HSL 3": + self.Pigment_HSL_3_Plus() + # HCY + if self.key_1 == "HCY 1": + self.Pigment_HCY_1_Plus() + if self.key_1 == "HCY 2": + self.Pigment_HCY_2_Plus() + if self.key_1 == "HCY 3": + self.Pigment_HCY_3_Plus() + + # XYZ + if self.key_1 == "XYZ 1": + self.Pigment_XYZ_1_Plus() + if self.key_1 == "XYZ 2": + self.Pigment_XYZ_2_Plus() + if self.key_1 == "XYZ 3": + self.Pigment_XYZ_3_Plus() + # XYY + if self.key_1 == "XYY 1": + self.Pigment_XYY_1_Plus() + if self.key_1 == "XYY 2": + self.Pigment_XYY_2_Plus() + if self.key_1 == "XYY 3": + self.Pigment_XYY_3_Plus() + # LUV + if self.key_1 == "LUV 1": + self.Pigment_LUV_1_Plus() + if self.key_1 == "LUV 2": + self.Pigment_LUV_2_Plus() + if self.key_1 == "LUV 3": + self.Pigment_LUV_3_Plus() + # HLAB + if self.key_1 == "HLAB 1": + self.Pigment_HLAB_1_Plus() + if self.key_1 == "HLAB 2": + self.Pigment_HLAB_2_Plus() + if self.key_1 == "HLAB 3": + self.Pigment_HLAB_3_Plus() + # LAB + if self.key_1 == "LAB 1": + self.Pigment_LAB_1_Plus() + if self.key_1 == "LAB 2": + self.Pigment_LAB_2_Plus() + if self.key_1 == "LAB 3": + self.Pigment_LAB_3_Plus() + # LCH + if self.key_1 == "LCH 1": + self.Pigment_LCH_1_Plus() + if self.key_1 == "LCH 2": + self.Pigment_LCH_2_Plus() + if self.key_1 == "LCH 3": + self.Pigment_LCH_3_Plus() + + if SIGNAL_KEY == "K2 Minus": + # None + if self.key_2 == "KEY 2": + pass + # AAA + if self.key_2 == "A 1": + self.Pigment_AAA_1_Minus() + # RGB + if self.key_2 == "RGB 1": + self.Pigment_RGB_1_Minus() + if self.key_2 == "RGB 2": + self.Pigment_RGB_2_Minus() + if self.key_2 == "RGB 3": + self.Pigment_RGB_3_Minus() + # CMY + if self.key_2 == "CMY 1": + self.Pigment_CMY_1_Minus() + if self.key_2 == "CMY 2": + self.Pigment_CMY_2_Minus() + if self.key_2 == "CMY 3": + self.Pigment_CMY_3_Minus() + # CMYK + if self.key_2 == "CMYK 1": + self.Pigment_CMYK_1_Minus() + if self.key_2 == "CMYK 2": + self.Pigment_CMYK_2_Minus() + if self.key_2 == "CMYK 3": + self.Pigment_CMYK_3_Minus() + if self.key_2 == "CMYK 4": + self.Pigment_CMYK_4_Minus() + # RYB + if self.key_2 == "RYB 1": + self.Pigment_RYB_1_Minus() + if self.key_2 == "RYB 2": + self.Pigment_RYB_2_Minus() + if self.key_2 == "RYB 3": + self.Pigment_RYB_3_Minus() + # YUV + if self.key_2 == "YUV 1": + self.Pigment_YUV_1_Minus() + if self.key_2 == "YUV 2": + self.Pigment_YUV_2_Minus() + if self.key_2 == "YUV 3": + self.Pigment_YUV_3_Minus() + # KKK + if self.key_2 == "K 1": + self.Pigment_KKK_1_Minus() + + # ARD + if self.key_2 == "ARD 1": + self.Pigment_ARD_1_Minus() + if self.key_2 == "ARD 2": + self.Pigment_ARD_2_Minus() + if self.key_2 == "ARD 3": + self.Pigment_ARD_3_Minus() + # HSV + if self.key_2 == "HSV 1": + self.Pigment_HSV_1_Minus() + if self.key_2 == "HSV 2": + self.Pigment_HSV_2_Minus() + if self.key_2 == "HSV 3": + self.Pigment_HSV_3_Minus() + # HSL + if self.key_2 == "HSL 1": + self.Pigment_HSL_1_Minus() + if self.key_2 == "HSL 2": + self.Pigment_HSL_2_Minus() + if self.key_2 == "HSL 3": + self.Pigment_HSL_3_Minus() + # HCY + if self.key_2 == "HCY 1": + self.Pigment_HCY_1_Minus() + if self.key_2 == "HCY 2": + self.Pigment_HCY_2_Minus() + if self.key_2 == "HCY 3": + self.Pigment_HCY_3_Minus() + + # XYZ + if self.key_2 == "XYZ 1": + self.Pigment_XYZ_1_Minus() + if self.key_2 == "XYZ 2": + self.Pigment_XYZ_2_Minus() + if self.key_2 == "XYZ 3": + self.Pigment_XYZ_3_Minus() + # XYY + if self.key_2 == "XYY 1": + self.Pigment_XYY_1_Minus() + if self.key_2 == "XYY 2": + self.Pigment_XYY_2_Minus() + if self.key_2 == "XYY 3": + self.Pigment_XYY_3_Minus() + # LUV + if self.key_2 == "LUV 1": + self.Pigment_LUV_1_Minus() + if self.key_2 == "LUV 2": + self.Pigment_LUV_2_Minus() + if self.key_2 == "LUV 3": + self.Pigment_LUV_3_Minus() + # HLAB + if self.key_2 == "HLAB 1": + self.Pigment_HLAB_1_Minus() + if self.key_2 == "HLAB 2": + self.Pigment_HLAB_2_Minus() + if self.key_2 == "HLAB 3": + self.Pigment_HLAB_3_Minus() + # LAB + if self.key_2 == "LAB 1": + self.Pigment_LAB_1_Minus() + if self.key_2 == "LAB 2": + self.Pigment_LAB_2_Minus() + if self.key_2 == "LAB 3": + self.Pigment_LAB_3_Minus() + # LCH + if self.key_2 == "LCH 1": + self.Pigment_LCH_1_Minus() + if self.key_2 == "LCH 2": + self.Pigment_LCH_2_Minus() + if self.key_2 == "LCH 3": + self.Pigment_LCH_3_Minus() + if SIGNAL_KEY == "K2 Plus": + # None + if self.key_2 == "KEY 2": + pass + # AAA + if self.key_2 == "A 1": + self.Pigment_AAA_1_Plus() + # RGB + if self.key_2 == "RGB 1": + self.Pigment_RGB_1_Plus() + if self.key_2 == "RGB 2": + self.Pigment_RGB_2_Plus() + if self.key_2 == "RGB 3": + self.Pigment_RGB_3_Plus() + # CMY + if self.key_2 == "CMY 1": + self.Pigment_CMY_1_Plus() + if self.key_2 == "CMY 2": + self.Pigment_CMY_2_Plus() + if self.key_2 == "CMY 3": + self.Pigment_CMY_3_Plus() + # CMYK + if self.key_2 == "CMYK 1": + self.Pigment_CMYK_1_Plus() + if self.key_2 == "CMYK 2": + self.Pigment_CMYK_2_Plus() + if self.key_2 == "CMYK 3": + self.Pigment_CMYK_3_Plus() + if self.key_2 == "CMYK 4": + self.Pigment_CMYK_4_Plus() + # RYB + if self.key_2 == "RYB 1": + self.Pigment_RYB_1_Plus() + if self.key_2 == "RYB 2": + self.Pigment_RYB_2_Plus() + if self.key_2 == "RYB 3": + self.Pigment_RYB_3_Plus() + # YUV + if self.key_2 == "YUV 1": + self.Pigment_YUV_1_Plus() + if self.key_2 == "YUV 2": + self.Pigment_YUV_2_Plus() + if self.key_2 == "YUV 3": + self.Pigment_YUV_3_Plus() + # KKK + if self.key_2 == "K 1": + self.Pigment_KKK_1_Plus() + + # ARD + if self.key_2 == "ARD 1": + self.Pigment_ARD_1_Plus() + if self.key_2 == "ARD 2": + self.Pigment_ARD_2_Plus() + if self.key_2 == "ARD 3": + self.Pigment_ARD_3_Plus() + # HSV + if self.key_2 == "HSV 1": + self.Pigment_HSV_1_Plus() + if self.key_2 == "HSV 2": + self.Pigment_HSV_2_Plus() + if self.key_2 == "HSV 3": + self.Pigment_HSV_3_Plus() + # HSL + if self.key_2 == "HSL 1": + self.Pigment_HSL_1_Plus() + if self.key_2 == "HSL 2": + self.Pigment_HSL_2_Plus() + if self.key_2 == "HSL 3": + self.Pigment_HSL_3_Plus() + # HCY + if self.key_2 == "HCY 1": + self.Pigment_HCY_1_Plus() + if self.key_2 == "HCY 2": + self.Pigment_HCY_2_Plus() + if self.key_2 == "HCY 3": + self.Pigment_HCY_3_Plus() + + # XYZ + if self.key_2 == "XYZ 1": + self.Pigment_XYZ_1_Plus() + if self.key_2 == "XYZ 2": + self.Pigment_XYZ_2_Plus() + if self.key_2 == "XYZ 3": + self.Pigment_XYZ_3_Plus() + # XYY + if self.key_2 == "XYY 1": + self.Pigment_XYY_1_Plus() + if self.key_2 == "XYY 2": + self.Pigment_XYY_2_Plus() + if self.key_2 == "XYY 3": + self.Pigment_XYY_3_Plus() + # LUV + if self.key_2 == "LUV 1": + self.Pigment_LUV_1_Plus() + if self.key_2 == "LUV 2": + self.Pigment_LUV_2_Plus() + if self.key_2 == "LUV 3": + self.Pigment_LUV_3_Plus() + # HLAB + if self.key_2 == "HLAB 1": + self.Pigment_HLAB_1_Plus() + if self.key_2 == "HLAB 2": + self.Pigment_HLAB_2_Plus() + if self.key_2 == "HLAB 3": + self.Pigment_HLAB_3_Plus() + # LAB + if self.key_2 == "LAB 1": + self.Pigment_LAB_1_Plus() + if self.key_2 == "LAB 2": + self.Pigment_LAB_2_Plus() + if self.key_2 == "LAB 3": + self.Pigment_LAB_3_Plus() + # LCH + if self.key_2 == "LCH 1": + self.Pigment_LCH_1_Plus() + if self.key_2 == "LCH 2": + self.Pigment_LCH_2_Plus() + if self.key_2 == "LCH 3": + self.Pigment_LCH_3_Plus() + + if SIGNAL_KEY == "K3 Minus": + # None + if self.key_3 == "KEY 3": + pass + # AAA + if self.key_3 == "A 1": + self.Pigment_AAA_1_Minus() + # RGB + if self.key_3 == "RGB 1": + self.Pigment_RGB_1_Minus() + if self.key_3 == "RGB 2": + self.Pigment_RGB_2_Minus() + if self.key_3 == "RGB 3": + self.Pigment_RGB_3_Minus() + # CMY + if self.key_3 == "CMY 1": + self.Pigment_CMY_1_Minus() + if self.key_3 == "CMY 2": + self.Pigment_CMY_2_Minus() + if self.key_3 == "CMY 3": + self.Pigment_CMY_3_Minus() + # CMYK + if self.key_3 == "CMYK 1": + self.Pigment_CMYK_1_Minus() + if self.key_3 == "CMYK 2": + self.Pigment_CMYK_2_Minus() + if self.key_3 == "CMYK 3": + self.Pigment_CMYK_3_Minus() + if self.key_3 == "CMYK 4": + self.Pigment_CMYK_4_Minus() + # RYB + if self.key_3 == "RYB 1": + self.Pigment_RYB_1_Minus() + if self.key_3 == "RYB 2": + self.Pigment_RYB_2_Minus() + if self.key_3 == "RYB 3": + self.Pigment_RYB_3_Minus() + # YUV + if self.key_3 == "YUV 1": + self.Pigment_YUV_1_Minus() + if self.key_3 == "YUV 2": + self.Pigment_YUV_2_Minus() + if self.key_3 == "YUV 3": + self.Pigment_YUV_3_Minus() + # KKK + if self.key_3 == "K 1": + self.Pigment_KKK_1_Minus() + + # ARD + if self.key_3 == "ARD 1": + self.Pigment_ARD_1_Minus() + if self.key_3 == "ARD 2": + self.Pigment_ARD_2_Minus() + if self.key_3 == "ARD 3": + self.Pigment_ARD_3_Minus() + # HSV + if self.key_3 == "HSV 1": + self.Pigment_HSV_1_Minus() + if self.key_3 == "HSV 2": + self.Pigment_HSV_2_Minus() + if self.key_3 == "HSV 3": + self.Pigment_HSV_3_Minus() + # HSL + if self.key_3 == "HSL 1": + self.Pigment_HSL_1_Minus() + if self.key_3 == "HSL 2": + self.Pigment_HSL_2_Minus() + if self.key_3 == "HSL 3": + self.Pigment_HSL_3_Minus() + # HCY + if self.key_3 == "HCY 1": + self.Pigment_HCY_1_Minus() + if self.key_3 == "HCY 2": + self.Pigment_HCY_2_Minus() + if self.key_3 == "HCY 3": + self.Pigment_HCY_3_Minus() + + # XYZ + if self.key_3 == "XYZ 1": + self.Pigment_XYZ_1_Minus() + if self.key_3 == "XYZ 2": + self.Pigment_XYZ_2_Minus() + if self.key_3 == "XYZ 3": + self.Pigment_XYZ_3_Minus() + # XYY + if self.key_3 == "XYY 1": + self.Pigment_XYY_1_Minus() + if self.key_3 == "XYY 2": + self.Pigment_XYY_2_Minus() + if self.key_3 == "XYY 3": + self.Pigment_XYY_3_Minus() + # LUV + if self.key_3 == "LUV 1": + self.Pigment_LUV_1_Minus() + if self.key_3 == "LUV 2": + self.Pigment_LUV_2_Minus() + if self.key_3 == "LUV 3": + self.Pigment_LUV_3_Minus() + # HLAB + if self.key_3 == "HLAB 1": + self.Pigment_HLAB_1_Minus() + if self.key_3 == "HLAB 2": + self.Pigment_HLAB_2_Minus() + if self.key_3 == "HLAB 3": + self.Pigment_HLAB_3_Minus() + # LAB + if self.key_3 == "LAB 1": + self.Pigment_LAB_1_Minus() + if self.key_3 == "LAB 2": + self.Pigment_LAB_2_Minus() + if self.key_3 == "LAB 3": + self.Pigment_LAB_3_Minus() + # LCH + if self.key_3 == "LCH 1": + self.Pigment_LCH_1_Minus() + if self.key_3 == "LCH 2": + self.Pigment_LCH_2_Minus() + if self.key_3 == "LCH 3": + self.Pigment_LCH_3_Minus() + if SIGNAL_KEY == "K3 Plus": + # None + if self.key_3 == "KEY 3": + pass + # AAA + if self.key_3 == "A 1": + self.Pigment_AAA_1_Plus() + # RGB + if self.key_3 == "RGB 1": + self.Pigment_RGB_1_Plus() + if self.key_3 == "RGB 2": + self.Pigment_RGB_2_Plus() + if self.key_3 == "RGB 3": + self.Pigment_RGB_3_Plus() + # CMY + if self.key_3 == "CMY 1": + self.Pigment_CMY_1_Plus() + if self.key_3 == "CMY 2": + self.Pigment_CMY_2_Plus() + if self.key_3 == "CMY 3": + self.Pigment_CMY_3_Plus() + # CMYK + if self.key_3 == "CMYK 1": + self.Pigment_CMYK_1_Plus() + if self.key_3 == "CMYK 2": + self.Pigment_CMYK_2_Plus() + if self.key_3 == "CMYK 3": + self.Pigment_CMYK_3_Plus() + if self.key_3 == "CMYK 4": + self.Pigment_CMYK_4_Plus() + # RYB + if self.key_3 == "RYB 1": + self.Pigment_RYB_1_Plus() + if self.key_3 == "RYB 2": + self.Pigment_RYB_2_Plus() + if self.key_3 == "RYB 3": + self.Pigment_RYB_3_Plus() + # YUV + if self.key_3 == "YUV 1": + self.Pigment_YUV_1_Plus() + if self.key_3 == "YUV 2": + self.Pigment_YUV_2_Plus() + if self.key_3 == "YUV 3": + self.Pigment_YUV_3_Plus() + # KKK + if self.key_3 == "K 1": + self.Pigment_KKK_1_Plus() + + # ARD + if self.key_3 == "ARD 1": + self.Pigment_ARD_1_Plus() + if self.key_3 == "ARD 2": + self.Pigment_ARD_2_Plus() + if self.key_3 == "ARD 3": + self.Pigment_ARD_3_Plus() + # HSV + if self.key_3 == "HSV 1": + self.Pigment_HSV_1_Plus() + if self.key_3 == "HSV 2": + self.Pigment_HSV_2_Plus() + if self.key_3 == "HSV 3": + self.Pigment_HSV_3_Plus() + # HSL + if self.key_3 == "HSL 1": + self.Pigment_HSL_1_Plus() + if self.key_3 == "HSL 2": + self.Pigment_HSL_2_Plus() + if self.key_3 == "HSL 3": + self.Pigment_HSL_3_Plus() + # HCY + if self.key_3 == "HCY 1": + self.Pigment_HCY_1_Plus() + if self.key_3 == "HCY 2": + self.Pigment_HCY_2_Plus() + if self.key_3 == "HCY 3": + self.Pigment_HCY_3_Plus() + + # XYZ + if self.key_3 == "XYZ 1": + self.Pigment_XYZ_1_Plus() + if self.key_3 == "XYZ 2": + self.Pigment_XYZ_2_Plus() + if self.key_3 == "XYZ 3": + self.Pigment_XYZ_3_Plus() + # XYY + if self.key_3 == "XYY 1": + self.Pigment_XYY_1_Plus() + if self.key_3 == "XYY 2": + self.Pigment_XYY_2_Plus() + if self.key_3 == "XYY 3": + self.Pigment_XYY_3_Plus() + # LUV + if self.key_3 == "LUV 1": + self.Pigment_LUV_1_Plus() + if self.key_3 == "LUV 2": + self.Pigment_LUV_2_Plus() + if self.key_3 == "LUV 3": + self.Pigment_LUV_3_Plus() + # HLAB + if self.key_3 == "HLAB 1": + self.Pigment_HLAB_1_Plus() + if self.key_3 == "HLAB 2": + self.Pigment_HLAB_2_Plus() + if self.key_3 == "HLAB 3": + self.Pigment_HLAB_3_Plus() + # LAB + if self.key_3 == "LAB 1": + self.Pigment_LAB_1_Plus() + if self.key_3 == "LAB 2": + self.Pigment_LAB_2_Plus() + if self.key_3 == "LAB 3": + self.Pigment_LAB_3_Plus() + # LCH + if self.key_3 == "LCH 1": + self.Pigment_LCH_1_Plus() + if self.key_3 == "LCH 2": + self.Pigment_LCH_2_Plus() + if self.key_3 == "LCH 3": + self.Pigment_LCH_3_Plus() + + if SIGNAL_KEY == "K4 Minus": + # None + if self.key_4 == "KEY 4": + pass + # AAA + if self.key_4 == "A 1": + self.Pigment_AAA_1_Minus() + # RGB + if self.key_4 == "RGB 1": + self.Pigment_RGB_1_Minus() + if self.key_4 == "RGB 2": + self.Pigment_RGB_2_Minus() + if self.key_4 == "RGB 3": + self.Pigment_RGB_3_Minus() + # CMY + if self.key_4 == "CMY 1": + self.Pigment_CMY_1_Minus() + if self.key_4 == "CMY 2": + self.Pigment_CMY_2_Minus() + if self.key_4 == "CMY 3": + self.Pigment_CMY_3_Minus() + # CMYK + if self.key_4 == "CMYK 1": + self.Pigment_CMYK_1_Minus() + if self.key_4 == "CMYK 2": + self.Pigment_CMYK_2_Minus() + if self.key_4 == "CMYK 3": + self.Pigment_CMYK_3_Minus() + if self.key_4 == "CMYK 4": + self.Pigment_CMYK_4_Minus() + # RYB + if self.key_4 == "RYB 1": + self.Pigment_RYB_1_Minus() + if self.key_4 == "RYB 2": + self.Pigment_RYB_2_Minus() + if self.key_4 == "RYB 3": + self.Pigment_RYB_3_Minus() + # YUV + if self.key_4 == "YUV 1": + self.Pigment_YUV_1_Minus() + if self.key_4 == "YUV 2": + self.Pigment_YUV_2_Minus() + if self.key_4 == "YUV 3": + self.Pigment_YUV_3_Minus() + # KKK + if self.key_4 == "K 1": + self.Pigment_KKK_1_Minus() + + # ARD + if self.key_4 == "ARD 1": + self.Pigment_ARD_1_Minus() + if self.key_4 == "ARD 2": + self.Pigment_ARD_2_Minus() + if self.key_4 == "ARD 3": + self.Pigment_ARD_3_Minus() + # HSV + if self.key_4 == "HSV 1": + self.Pigment_HSV_1_Minus() + if self.key_4 == "HSV 2": + self.Pigment_HSV_2_Minus() + if self.key_4 == "HSV 3": + self.Pigment_HSV_3_Minus() + # HSL + if self.key_4 == "HSL 1": + self.Pigment_HSL_1_Minus() + if self.key_4 == "HSL 2": + self.Pigment_HSL_2_Minus() + if self.key_4 == "HSL 3": + self.Pigment_HSL_3_Minus() + # HCY + if self.key_4 == "HCY 1": + self.Pigment_HCY_1_Minus() + if self.key_4 == "HCY 2": + self.Pigment_HCY_2_Minus() + if self.key_4 == "HCY 3": + self.Pigment_HCY_3_Minus() + + # XYZ + if self.key_4 == "XYZ 1": + self.Pigment_XYZ_1_Minus() + if self.key_4 == "XYZ 2": + self.Pigment_XYZ_2_Minus() + if self.key_4 == "XYZ 3": + self.Pigment_XYZ_3_Minus() + # XYY + if self.key_4 == "XYY 1": + self.Pigment_XYY_1_Minus() + if self.key_4 == "XYY 2": + self.Pigment_XYY_2_Minus() + if self.key_4 == "XYY 3": + self.Pigment_XYY_3_Minus() + # LUV + if self.key_4 == "LUV 1": + self.Pigment_LUV_1_Minus() + if self.key_4 == "LUV 2": + self.Pigment_LUV_2_Minus() + if self.key_4 == "LUV 3": + self.Pigment_LUV_3_Minus() + # HLAB + if self.key_4 == "HLAB 1": + self.Pigment_HLAB_1_Minus() + if self.key_4 == "HLAB 2": + self.Pigment_HLAB_2_Minus() + if self.key_4 == "HLAB 3": + self.Pigment_HLAB_3_Minus() + # LAB + if self.key_4 == "LAB 1": + self.Pigment_LAB_1_Minus() + if self.key_4 == "LAB 2": + self.Pigment_LAB_2_Minus() + if self.key_4 == "LAB 3": + self.Pigment_LAB_3_Minus() + # LCH + if self.key_4 == "LCH 1": + self.Pigment_LCH_1_Minus() + if self.key_4 == "LCH 2": + self.Pigment_LCH_2_Minus() + if self.key_4 == "LCH 3": + self.Pigment_LCH_3_Minus() + if SIGNAL_KEY == "K4 Plus": + # None + if self.key_4 == "KEY 4": + pass + # AAA + if self.key_4 == "A 1": + self.Pigment_AAA_1_Plus() + # RGB + if self.key_4 == "RGB 1": + self.Pigment_RGB_1_Plus() + if self.key_4 == "RGB 2": + self.Pigment_RGB_2_Plus() + if self.key_4 == "RGB 3": + self.Pigment_RGB_3_Plus() + # CMY + if self.key_4 == "CMY 1": + self.Pigment_CMY_1_Plus() + if self.key_4 == "CMY 2": + self.Pigment_CMY_2_Plus() + if self.key_4 == "CMY 3": + self.Pigment_CMY_3_Plus() + # CMYK + if self.key_4 == "CMYK 1": + self.Pigment_CMYK_1_Plus() + if self.key_4 == "CMYK 2": + self.Pigment_CMYK_2_Plus() + if self.key_4 == "CMYK 3": + self.Pigment_CMYK_3_Plus() + if self.key_4 == "CMYK 4": + self.Pigment_CMYK_4_Plus() + # RYB + if self.key_4 == "RYB 1": + self.Pigment_RYB_1_Plus() + if self.key_4 == "RYB 2": + self.Pigment_RYB_2_Plus() + if self.key_4 == "RYB 3": + self.Pigment_RYB_3_Plus() + # YUV + if self.key_4 == "YUV 1": + self.Pigment_YUV_1_Plus() + if self.key_4 == "YUV 2": + self.Pigment_YUV_2_Plus() + if self.key_4 == "YUV 3": + self.Pigment_YUV_3_Plus() + # KKK + if self.key_4 == "K 1": + self.Pigment_KKK_1_Plus() + + # ARD + if self.key_4 == "ARD 1": + self.Pigment_ARD_1_Plus() + if self.key_4 == "ARD 2": + self.Pigment_ARD_2_Plus() + if self.key_4 == "ARD 3": + self.Pigment_ARD_3_Plus() + # HSV + if self.key_4 == "HSV 1": + self.Pigment_HSV_1_Plus() + if self.key_4 == "HSV 2": + self.Pigment_HSV_2_Plus() + if self.key_4 == "HSV 3": + self.Pigment_HSV_3_Plus() + # HSL + if self.key_4 == "HSL 1": + self.Pigment_HSL_1_Plus() + if self.key_4 == "HSL 2": + self.Pigment_HSL_2_Plus() + if self.key_4 == "HSL 3": + self.Pigment_HSL_3_Plus() + # HCY + if self.key_4 == "HCY 1": + self.Pigment_HCY_1_Plus() + if self.key_4 == "HCY 2": + self.Pigment_HCY_2_Plus() + if self.key_4 == "HCY 3": + self.Pigment_HCY_3_Plus() + + # XYZ + if self.key_4 == "XYZ 1": + self.Pigment_XYZ_1_Plus() + if self.key_4 == "XYZ 2": + self.Pigment_XYZ_2_Plus() + if self.key_4 == "XYZ 3": + self.Pigment_XYZ_3_Plus() + # XYY + if self.key_4 == "XYY 1": + self.Pigment_XYY_1_Plus() + if self.key_4 == "XYY 2": + self.Pigment_XYY_2_Plus() + if self.key_4 == "XYY 3": + self.Pigment_XYY_3_Plus() + # LUV + if self.key_4 == "LUV 1": + self.Pigment_LUV_1_Plus() + if self.key_4 == "LUV 2": + self.Pigment_LUV_2_Plus() + if self.key_4 == "LUV 3": + self.Pigment_LUV_3_Plus() + # HLAB + if self.key_4 == "HLAB 1": + self.Pigment_HLAB_1_Plus() + if self.key_4 == "HLAB 2": + self.Pigment_HLAB_2_Plus() + if self.key_4 == "HLAB 3": + self.Pigment_HLAB_3_Plus() + # LAB + if self.key_4 == "LAB 1": + self.Pigment_LAB_1_Plus() + if self.key_4 == "LAB 2": + self.Pigment_LAB_2_Plus() + if self.key_4 == "LAB 3": + self.Pigment_LAB_3_Plus() + # LCH + if self.key_4 == "LCH 1": + self.Pigment_LCH_1_Plus() + if self.key_4 == "LCH 2": + self.Pigment_LCH_2_Plus() + if self.key_4 == "LCH 3": + self.Pigment_LCH_3_Plus() + def Signal_Extension_LOK(self, SIGNAL_LOK): + if SIGNAL_LOK == "CMYK": + if self.layout.cmyk_4_lock.isChecked(): + self.layout.cmyk_4_lock.setChecked(False) + else: + self.layout.cmyk_4_lock.setChecked(True) + if SIGNAL_LOK == "KKK": + if self.layout.kkk_1_lock.isChecked(): + self.layout.kkk_1_lock.setChecked(False) + else: + self.layout.kkk_1_lock.setChecked(True) + if SIGNAL_LOK == "ARD": + if self.layout.ard_1_lock.isChecked(): + self.layout.ard_1_lock.setChecked(False) + else: + self.layout.ard_1_lock.setChecked(True) + + #// + #\\ Style ################################################################## + def Percentage(self, count): + if count == "P4L": + percentage_style_sheet = str( + "background-color: qlineargradient(spread:pad, \n"+ + "x1:0, y1:0, \n"+ + "x2:1, y2:0, \n"+ + "stop:0.000 rgba(255, 255, 255, 255), \n"+ + "stop:0.003 rgba(255, 255, 255, 255), \n"+ + "stop:0.004 rgba(0, 0, 0, 0), \n"+ + "stop:0.248 rgba(0, 0, 0, 0), \n"+ + "stop:0.249 rgba(255, 255, 255, 255), \n"+ + "stop:0.251 rgba(255, 255, 255, 255), \n"+ + "stop:0.252 rgba(0, 0, 0, 0), \n"+ + "stop:0.498 rgba(0, 0, 0, 0), \n"+ + "stop:0.499 rgba(255, 255, 255, 255), \n"+ + "stop:0.501 rgba(255, 255, 255, 255), \n"+ + "stop:0.502 rgba(0, 0, 0, 0), \n"+ + "stop:0.748 rgba(0, 0, 0, 0), \n"+ + "stop:0.749 rgba(255, 255, 255, 255), \n"+ + "stop:0.751 rgba(255, 255, 255, 255), \n"+ + "stop:0.752 rgba(0, 0, 0, 0), \n"+ + "stop:0.996 rgba(0, 0, 0, 0), \n"+ + "stop:0.997 rgba(255, 255, 255, 255), \n"+ + "stop:1.000 rgba(255, 255, 255, 255));" + ) + if count == "P6L": + percentage_style_sheet = str( + "background-color: qlineargradient(spread:pad, \n"+ + "x1:0, y1:0, \n"+ + "x2:1, y2:0, \n"+ + "stop:0.000 rgba(255, 255, 255, 255), \n"+ + "stop:0.003 rgba(255, 255, 255, 255), \n"+ + "stop:0.004 rgba(0, 0, 0, 0), \n"+ + "stop:0.164 rgba(0, 0, 0, 0), \n"+ + "stop:0.165 rgba(255, 255, 255, 255), \n"+ + "stop:0.167 rgba(255, 255, 255, 255), \n"+ + "stop:0.168 rgba(0, 0, 0, 0), \n"+ + "stop:0.331 rgba(0, 0, 0, 0), \n"+ + "stop:0.332 rgba(255, 255, 255, 255), \n"+ + "stop:0.334 rgba(255, 255, 255, 255), \n"+ + "stop:0.335 rgba(0, 0, 0, 0), \n"+ + "stop:0.498 rgba(0, 0, 0, 0), \n"+ + "stop:0.499 rgba(255, 255, 255, 255), \n"+ + "stop:0.501 rgba(255, 255, 255, 255), \n"+ + "stop:0.502 rgba(0, 0, 0, 0), \n"+ + "stop:0.664 rgba(0, 0, 0, 0), \n"+ + "stop:0.665 rgba(255, 255, 255, 255), \n"+ + "stop:0.667 rgba(255, 255, 255, 255), \n"+ + "stop:0.668 rgba(0, 0, 0, 0), \n"+ + "stop:0.831 rgba(0, 0, 0, 0), \n"+ + "stop:0.832 rgba(255, 255, 255, 255), \n"+ + "stop:0.834 rgba(255, 255, 255, 255), \n"+ + "stop:0.835 rgba(0, 0, 0, 0), \n"+ + "stop:0.996 rgba(0, 0, 0, 0), \n"+ + "stop:0.997 rgba(255, 255, 255, 255), \n"+ + "stop:1.000 rgba(255, 255, 255, 255));" + ) + if count == "P10A": + percentage_style_sheet = str( + "background-color: qlineargradient(spread:pad, \n"+ + "x1:0, y1:0, \n"+ + "x2:1, y2:0, \n"+ + "stop:0.000 rgba(255, 255, 255, 255), \n"+ + "stop:0.003 rgba(255, 255, 255, 255), \n"+ + "stop:0.004 rgba(0, 0, 0, 0), \n"+ + "stop:0.097 rgba(0, 0, 0, 0), \n"+ + "stop:0.098 rgba(255, 255, 255, 255), \n"+ + "stop:0.100 rgba(255, 255, 255, 255), \n"+ + "stop:0.102 rgba(0, 0, 0, 0), \n"+ + "stop:0.197 rgba(0, 0, 0, 0), \n"+ + "stop:0.199 rgba(255, 255, 255, 255), \n"+ + "stop:0.200 rgba(255, 255, 255, 255), \n"+ + "stop:0.202 rgba(0, 0, 0, 0), \n"+ + "stop:0.297 rgba(0, 0, 0, 0), \n"+ + "stop:0.299 rgba(255, 255, 255, 255), \n"+ + "stop:0.300 rgba(255, 255, 255, 255), \n"+ + "stop:0.302 rgba(0, 0, 0, 0), \n"+ + "stop:0.397 rgba(0, 0, 0, 0), \n"+ + "stop:0.399 rgba(255, 255, 255, 255), \n"+ + "stop:0.400 rgba(255, 255, 255, 255), \n"+ + "stop:0.402 rgba(0, 0, 0, 0), \n"+ + "stop:0.497 rgba(0, 0, 0, 0), \n"+ + "stop:0.499 rgba(255, 255, 255, 255), \n"+ + "stop:0.500 rgba(255, 255, 255, 255), \n"+ + "stop:0.502 rgba(0, 0, 0, 0), \n"+ + "stop:0.597 rgba(0, 0, 0, 0), \n"+ + "stop:0.599 rgba(255, 255, 255, 255), \n"+ + "stop:0.600 rgba(255, 255, 255, 255), \n"+ + "stop:0.602 rgba(0, 0, 0, 0), \n"+ + "stop:0.697 rgba(0, 0, 0, 0), \n"+ + "stop:0.699 rgba(255, 255, 255, 255), \n"+ + "stop:0.700 rgba(255, 255, 255, 255), \n"+ + "stop:0.702 rgba(0, 0, 0, 0), \n"+ + "stop:0.797 rgba(0, 0, 0, 0), \n"+ + "stop:0.799 rgba(255, 255, 255, 255), \n"+ + "stop:0.800 rgba(255, 255, 255, 255), \n"+ + "stop:0.802 rgba(0, 0, 0, 0), \n"+ + "stop:0.897 rgba(0, 0, 0, 0), \n"+ + "stop:0.899 rgba(255, 255, 255, 255), \n"+ + "stop:0.900 rgba(255, 255, 255, 255), \n"+ + "stop:0.902 rgba(0, 0, 0, 0), \n"+ + "stop:0.996 rgba(0, 0, 0, 0), \n"+ + "stop:0.997 rgba(255, 255, 255, 255), \n"+ + "stop:1.000 rgba(255, 255, 255, 255));" + ) + if count == "P10B": + percentage_style_sheet = str( + "background-color: qlineargradient(spread:pad, \n"+ + "x1:0, y1:0, \n"+ + "x2:1, y2:0, \n"+ + "stop:0.000 rgba(0, 0, 0, 50), \n"+ + "stop:0.099 rgba(0, 0, 0, 50), \n"+ + "stop:0.100 rgba(0, 0, 0, 0), \n"+ + "stop:0.199 rgba(0, 0, 0, 0), \n"+ + "stop:0.200 rgba(0, 0, 0, 50), \n"+ + "stop:0.299 rgba(0, 0, 0, 50), \n"+ + "stop:0.300 rgba(0, 0, 0, 0), \n"+ + "stop:0.399 rgba(0, 0, 0, 0), \n"+ + "stop:0.400 rgba(0, 0, 0, 50), \n"+ + "stop:0.499 rgba(0, 0, 0, 50), \n"+ + "stop:0.500 rgba(0, 0, 0, 0), \n"+ + "stop:0.599 rgba(0, 0, 0, 0), \n"+ + "stop:0.600 rgba(0, 0, 0, 50), \n"+ + "stop:0.699 rgba(0, 0, 0, 50), \n"+ + "stop:0.700 rgba(0, 0, 0, 0), \n"+ + "stop:0.799 rgba(0, 0, 0, 0), \n"+ + "stop:0.800 rgba(0, 0, 0, 50), \n"+ + "stop:0.899 rgba(0, 0, 0, 50), \n"+ + "stop:0.900 rgba(0, 0, 0, 0), \n"+ + "stop:0.999 rgba(0, 0, 0, 0), \n"+ + "stop:1.000 rgba(0, 0, 0, 50));" + ) + if count == "P3B": + percentage_style_sheet = str( + "background-color: qlineargradient(spread:pad, \n"+ + "x1:0, y1:0, \n"+ + "x2:0, y2:1, \n"+ + "stop:0.000 rgba(0, 0, 0, 50), \n"+ + "stop:0.332 rgba(0, 0, 0, 50), \n"+ + "stop:0.333 rgba(0, 0, 0, 0), \n"+ + "stop:0.666 rgba(0, 0, 0, 0), \n"+ + "stop:0.667 rgba(0, 0, 0, 50), \n"+ + "stop:1.000 rgba(0, 0, 0, 50));" + ) + return percentage_style_sheet + + # Slider Gradients + def Gradient_RGB(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "RGB" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_CMY(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "CMY" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_CMYK(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2], left[3]] + right = [right[0], right[1], right[2], right[3]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + l4 = round(left[3],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + r4 = round(right[3],3) + # Difference + n = 20 + dc = (r1 - l1) / n + dm = (r2 - l2) / n + dy = (r3 - l3) / n + dk = (r4 - l4) / n + # Output + s00 = [l1, l2, l3, l4] + s05 = [l1 + (dc * 1), l2 + (dm * 1), l3 + (dy * 1), l4 + (dk * 1)] + s10 = [l1 + (dc * 2), l2 + (dm * 2), l3 + (dy * 2), l4 + (dk * 2)] + s15 = [l1 + (dc * 3), l2 + (dm * 3), l3 + (dy * 3), l4 + (dk * 3)] + s20 = [l1 + (dc * 4), l2 + (dm * 4), l3 + (dy * 4), l4 + (dk * 4)] + s25 = [l1 + (dc * 5), l2 + (dm * 5), l3 + (dy * 5), l4 + (dk * 5)] + s30 = [l1 + (dc * 6), l2 + (dm * 6), l3 + (dy * 6), l4 + (dk * 6)] + s35 = [l1 + (dc * 7), l2 + (dm * 7), l3 + (dy * 7), l4 + (dk * 7)] + s40 = [l1 + (dc * 8), l2 + (dm * 8), l3 + (dy * 8), l4 + (dk * 8)] + s45 = [l1 + (dc * 9), l2 + (dm * 9), l3 + (dy * 9), l4 + (dk * 9)] + s50 = [l1 + (dc * 10), l2 + (dm * 10), l3 + (dy * 10), l4 + (dk * 10)] + s55 = [l1 + (dc * 11), l2 + (dm * 11), l3 + (dy * 11), l4 + (dk * 11)] + s60 = [l1 + (dc * 12), l2 + (dm * 12), l3 + (dy * 12), l4 + (dk * 12)] + s65 = [l1 + (dc * 13), l2 + (dm * 13), l3 + (dy * 13), l4 + (dk * 13)] + s70 = [l1 + (dc * 14), l2 + (dm * 14), l3 + (dy * 14), l4 + (dk * 14)] + s75 = [l1 + (dc * 15), l2 + (dm * 15), l3 + (dy * 15), l4 + (dk * 15)] + s80 = [l1 + (dc * 16), l2 + (dm * 16), l3 + (dy * 16), l4 + (dk * 16)] + s85 = [l1 + (dc * 17), l2 + (dm * 17), l3 + (dy * 17), l4 + (dk * 17)] + s90 = [l1 + (dc * 18), l2 + (dm * 18), l3 + (dy * 18), l4 + (dk * 18)] + s95 = [l1 + (dc * 19), l2 + (dm * 19), l3 + (dy * 19), l4 + (dk * 19)] + sAA = [r1, r2, r3, r4] + # Convert to Document Display + src = "CMYK" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_RYB(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "RYB" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_YUV(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "YUV" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_KKK(self, red, green, blue): + # Difference + n = 20 + dk = k_KKKdelta / n + # Output + s00 = self.kkk_to_rgb(k_KKKmin) + s05 = self.kkk_to_rgb(k_KKKmin + dk * 1) + s10 = self.kkk_to_rgb(k_KKKmin + dk * 2) + s15 = self.kkk_to_rgb(k_KKKmin + dk * 3) + s20 = self.kkk_to_rgb(k_KKKmin + dk * 4) + s25 = self.kkk_to_rgb(k_KKKmin + dk * 5) + s30 = self.kkk_to_rgb(k_KKKmin + dk * 6) + s35 = self.kkk_to_rgb(k_KKKmin + dk * 7) + s40 = self.kkk_to_rgb(k_KKKmin + dk * 8) + s45 = self.kkk_to_rgb(k_KKKmin + dk * 9) + s50 = self.kkk_to_rgb(k_KKKmin + dk * 10) + s55 = self.kkk_to_rgb(k_KKKmin + dk * 11) + s60 = self.kkk_to_rgb(k_KKKmin + dk * 12) + s65 = self.kkk_to_rgb(k_KKKmin + dk * 13) + s70 = self.kkk_to_rgb(k_KKKmin + dk * 14) + s75 = self.kkk_to_rgb(k_KKKmin + dk * 15) + s80 = self.kkk_to_rgb(k_KKKmin + dk * 16) + s85 = self.kkk_to_rgb(k_KKKmin + dk * 17) + s90 = self.kkk_to_rgb(k_KKKmin + dk * 18) + s95 = self.kkk_to_rgb(k_KKKmin + dk * 19) + sAA = self.kkk_to_rgb(k_KKKmin + dk * 20) + # When Lock is active + if self.kkk_lock == True: + s00 = [s00[0] * self.rgb_1, s00[1] * self.rgb_2, s00[2] * self.rgb_3] + s05 = [s05[0] * self.rgb_1, s05[1] * self.rgb_2, s05[2] * self.rgb_3] + s10 = [s10[0] * self.rgb_1, s10[1] * self.rgb_2, s10[2] * self.rgb_3] + s15 = [s15[0] * self.rgb_1, s15[1] * self.rgb_2, s15[2] * self.rgb_3] + s20 = [s20[0] * self.rgb_1, s20[1] * self.rgb_2, s20[2] * self.rgb_3] + s25 = [s25[0] * self.rgb_1, s25[1] * self.rgb_2, s25[2] * self.rgb_3] + s30 = [s30[0] * self.rgb_1, s30[1] * self.rgb_2, s30[2] * self.rgb_3] + s35 = [s35[0] * self.rgb_1, s35[1] * self.rgb_2, s35[2] * self.rgb_3] + s40 = [s40[0] * self.rgb_1, s40[1] * self.rgb_2, s40[2] * self.rgb_3] + s45 = [s45[0] * self.rgb_1, s45[1] * self.rgb_2, s45[2] * self.rgb_3] + s50 = [s50[0] * self.rgb_1, s50[1] * self.rgb_2, s50[2] * self.rgb_3] + s55 = [s55[0] * self.rgb_1, s55[1] * self.rgb_2, s55[2] * self.rgb_3] + s60 = [s60[0] * self.rgb_1, s60[1] * self.rgb_2, s60[2] * self.rgb_3] + s65 = [s65[0] * self.rgb_1, s65[1] * self.rgb_2, s65[2] * self.rgb_3] + s70 = [s70[0] * self.rgb_1, s70[1] * self.rgb_2, s70[2] * self.rgb_3] + s75 = [s75[0] * self.rgb_1, s75[1] * self.rgb_2, s75[2] * self.rgb_3] + s80 = [s80[0] * self.rgb_1, s80[1] * self.rgb_2, s80[2] * self.rgb_3] + s85 = [s85[0] * self.rgb_1, s85[1] * self.rgb_2, s85[2] * self.rgb_3] + s90 = [s90[0] * self.rgb_1, s90[1] * self.rgb_2, s90[2] * self.rgb_3] + s95 = [s95[0] * self.rgb_1, s95[1] * self.rgb_2, s95[2] * self.rgb_3] + sAA = [sAA[0] * self.rgb_1, sAA[1] * self.rgb_2, sAA[2] * self.rgb_3] + # Convert to Document Display + src = "RGB" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + + def Gradient_ARD(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "ARD" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_HSV(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "HSV" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_HSL(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "HSL" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_HCY(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "HCY" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + + def Gradient_XYZ(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "XYZ" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_XYY(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "XYY" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_LAB(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Convert Left + l1 = round(left[0],3) + l2 = round(left[1],3) + l3 = round(left[2],3) + # Convert Right + r1 = round(right[0],3) + r2 = round(right[1],3) + r3 = round(right[2],3) + # Difference + n = 20 + dr = (r1 - l1) / n + dg = (r2 - l2) / n + db = (r3 - l3) / n + # Output + s00 = [l1, l2, l3] + s05 = [l1 + (dr * 1), l2 + (dg * 1), l3 + (db * 1)] + s10 = [l1 + (dr * 2), l2 + (dg * 2), l3 + (db * 2)] + s15 = [l1 + (dr * 3), l2 + (dg * 3), l3 + (db * 3)] + s20 = [l1 + (dr * 4), l2 + (dg * 4), l3 + (db * 4)] + s25 = [l1 + (dr * 5), l2 + (dg * 5), l3 + (db * 5)] + s30 = [l1 + (dr * 6), l2 + (dg * 6), l3 + (db * 6)] + s35 = [l1 + (dr * 7), l2 + (dg * 7), l3 + (db * 7)] + s40 = [l1 + (dr * 8), l2 + (dg * 8), l3 + (db * 8)] + s45 = [l1 + (dr * 9), l2 + (dg * 9), l3 + (db * 9)] + s50 = [l1 + (dr * 10), l2 + (dg * 10), l3 + (db * 10)] + s55 = [l1 + (dr * 11), l2 + (dg * 11), l3 + (db * 11)] + s60 = [l1 + (dr * 12), l2 + (dg * 12), l3 + (db * 12)] + s65 = [l1 + (dr * 13), l2 + (dg * 13), l3 + (db * 13)] + s70 = [l1 + (dr * 14), l2 + (dg * 14), l3 + (db * 14)] + s75 = [l1 + (dr * 15), l2 + (dg * 15), l3 + (db * 15)] + s80 = [l1 + (dr * 16), l2 + (dg * 16), l3 + (db * 16)] + s85 = [l1 + (dr * 17), l2 + (dg * 17), l3 + (db * 17)] + s90 = [l1 + (dr * 18), l2 + (dg * 18), l3 + (db * 18)] + s95 = [l1 + (dr * 19), l2 + (dg * 19), l3 + (db * 19)] + sAA = [r1, r2, r3] + # Convert to Document Display + src = "LAB" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + + # Mixer Gradients + def Gradient_Mix_ARD(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Difference + n = 20 + d = 1 / n + # Interpolation + s00 = self.ard_to_rgb(left[0], left[1], left[2]) + s05 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 1, left, right)) + s10 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 2, left, right)) + s15 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 3, left, right)) + s20 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 4, left, right)) + s25 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 5, left, right)) + s30 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 6, left, right)) + s35 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 7, left, right)) + s40 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 8, left, right)) + s45 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 9, left, right)) + s50 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 10, left, right)) + s55 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 11, left, right)) + s60 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 12, left, right)) + s65 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 13, left, right)) + s70 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 14, left, right)) + s75 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 15, left, right)) + s80 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 16, left, right)) + s85 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 17, left, right)) + s90 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 18, left, right)) + s95 = self.ard_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 19, left, right)) + sAA = self.ard_to_rgb(right[0], right[1], right[2]) + # Convert to Document Display + src = "RGB" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_Mix_HSV(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Difference + n = 20 + d = 1 / n + # Interpolation + s00 = self.hsv_to_rgb(left[0], left[1], left[2]) + s05 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 1, left, right)) + s10 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 2, left, right)) + s15 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 3, left, right)) + s20 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 4, left, right)) + s25 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 5, left, right)) + s30 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 6, left, right)) + s35 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 7, left, right)) + s40 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 8, left, right)) + s45 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 9, left, right)) + s50 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 10, left, right)) + s55 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 11, left, right)) + s60 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 12, left, right)) + s65 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 13, left, right)) + s70 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 14, left, right)) + s75 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 15, left, right)) + s80 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 16, left, right)) + s85 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 17, left, right)) + s90 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 18, left, right)) + s95 = self.hsv_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 19, left, right)) + sAA = self.hsv_to_rgb(right[0], right[1], right[2]) + # Convert to Document Display + src = "RGB" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_Mix_HSL(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Difference + n = 20 + d = 1 / n + # Interpolation + s00 = self.hsl_to_rgb(left[0], left[1], left[2]) + s05 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 1, left, right)) + s10 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 2, left, right)) + s15 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 3, left, right)) + s20 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 4, left, right)) + s25 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 5, left, right)) + s30 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 6, left, right)) + s35 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 7, left, right)) + s40 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 8, left, right)) + s45 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 9, left, right)) + s50 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 10, left, right)) + s55 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 11, left, right)) + s60 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 12, left, right)) + s65 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 13, left, right)) + s70 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 14, left, right)) + s75 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 15, left, right)) + s80 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 16, left, right)) + s85 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 17, left, right)) + s90 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 18, left, right)) + s95 = self.hsl_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 19, left, right)) + sAA = self.hsl_to_rgb(right[0], right[1], right[2]) + # Convert to Document Display + src = "RGB" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + def Gradient_Mix_HCY(self, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Difference + n = 20 + d = 1 / n + # Interpolation + s00 = self.hcy_to_rgb(left[0], left[1], left[2]) + s05 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 1, left, right)) + s10 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 2, left, right)) + s15 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 3, left, right)) + s20 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 4, left, right)) + s25 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 5, left, right)) + s30 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 6, left, right)) + s35 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 7, left, right)) + s40 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 8, left, right)) + s45 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 9, left, right)) + s50 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 10, left, right)) + s55 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 11, left, right)) + s60 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 12, left, right)) + s65 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 13, left, right)) + s70 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 14, left, right)) + s75 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 15, left, right)) + s80 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 16, left, right)) + s85 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 17, left, right)) + s90 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 18, left, right)) + s95 = self.hcy_to_rgb(*self.Mixer_Hue_Linear_Interpolation(d * 19, left, right)) + sAA = self.hcy_to_rgb(right[0], right[1], right[2]) + # Convert to Document Display + src = "RGB" + s00 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s00 ) + s05 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s05 ) + s10 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s10 ) + s15 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s15 ) + s20 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s20 ) + s25 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s25 ) + s30 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s30 ) + s35 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s35 ) + s40 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s40 ) + s45 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s45 ) + s50 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s50 ) + s55 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s55 ) + s60 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s60 ) + s65 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s65 ) + s70 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s70 ) + s75 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s75 ) + s80 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s80 ) + s85 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s85 ) + s90 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s90 ) + s95 = self.convert(self.d_cm, self.d_cd, self.d_cp, src, s95 ) + sAA = self.convert(self.d_cm, self.d_cd, self.d_cp, src, sAA ) + # Return + return [s00, s05, s10, s15, s20, s25, s30, s35, s40, s45, s50, s55, s60, s65, s70, s75, s80, s85, s90, s95, sAA] + # Mixer Hue Linear Interpolation + def Mixer_Hue_Linear_Interpolation(self, factor, left, right): + """ Input: 0-1 """ + # Colors + left = [left[0], left[1], left[2]] + right = [right[0], right[1], right[2]] + # Conditions + cond1 = right[0] - left[0] + cond2 = (left[0] + 1) - right[0] + cond3 = right[1] - left[1] + cond4 = right[2] - left[2] + # Angle Calculations + if left[0] <= right[0]: + # Conditions + cond1 = right[0] - left[0] + cond2 = (left[0] + 1) - right[0] + if cond1 <= cond2: + a = left[0] + (factor * cond1) + else: + a = left[0] - (factor * cond2) + else: + # Conditions + cond1 = left[0] - right[0] + cond2 = (right[0] + 1) - left[0] + if cond1 <= cond2: + a = left[0] - (factor * cond1) + else: + a = left[0] + (factor * cond2) + # Correct Excess + if a < 0: + a = a + 1 + if a > 1: + a = a - 1 + value1 = a + value2 = (left[1] + (factor * cond3)) + value3 = (left[2] + (factor * cond4)) + # Return + return value1, value2, value3 + + # Icons + def Icon_Corner(self, hex): + string = str( + " \n" + + " \n" + + " \n" + + " \n" + + " " + ) + array = bytearray(string, encoding='utf-8') + return array + def Icon_Left(self, hex): + string = str( + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " " + ) + array = bytearray(string, encoding='utf-8') + return array + def Icon_Right(self, hex): + string = str( + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " " + ) + array = bytearray(string, encoding='utf-8') + return array + def Icon_Lock(self, hex): + string = str( + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + "" + ) + array = bytearray(string, encoding='utf-8') + return array + + #// + #\\ Widget Events ########################################################## + # Docker Events + def showEvent(self, event): + # Layout loads as vertical Size Policy Ignore for correct loading purposes and after the loadding is done I can set it up to the correct Size policy so it works well after, This happens after the init function has ended + self.window.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred) + # Colors + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Pigment_Display() + self.Mixer_Display() + self.Ratio() + # Start Timer when the Docker is Present + if check_timer >= 1: + self.timer.start() + def enterEvent(self, event): + # Check Krita/Clipboard Once before editing Pigmento + if self.hex_copy == True: + self.HEX_Paste() + else: + self.Krita_2_Pigment() + # Confirm Panel + self.Ratio() + # Stop Asking Krita the Current Color + if check_timer >= 1: + self.timer.stop() + def leaveEvent(self, event): + # Pigment + self.Pigment_2_Krita(True) + # Clear Values cursor focus + self.Signal_Block(True) + self.Clear_Focus() + self.Signal_Block(False) + # Hex Copy + if self.hex_copy == True: + self.HEX_Copy() + # Start Asking Krita the Current Color + if check_timer >= 1: + self.timer.start() + # Save Settings + self.Default_Save() + def resizeEvent(self, event): + # Maintian Ratio + self.Ratio() + def closeEvent(self, event): + # Stop QTimer + if check_timer >= 1: + self.timer.stop() + # Save Settings + self.Default_Save() + + # Paint Events + def paintEvent(self, event): + # Luma Lock Button Update + self.Update_Color_Header_1() + self.Update_Color_Header_2() + + if self.menu_update > 0: + # Update Channels on Widget Recalling + self.Ratio_Channels() + # Update Frames on Widget Recalling + self.Ratio_Box() + # Updates Painter on PANEL Widget Recalling + self.Ratio_Panel() + + # One Less Double Check + self.menu_update -= 1 + else: + self.menu_update = 0 + + # Return Paint event to Regain Docker Title + return super().paintEvent(event) + + #// + #\\ Settings ############################################################### + def Version_Settings(self): + self.Default_Boot() + try: + version = self.Settings_Load_Version() + if pigment_o_version == version: + self.Settings_Load_Misc() + self.Settings_Load_ActiveColor() + self.Settings_Load_UI() + except: + QtCore.qWarning("Pigment.O - Load Error - Wrong Version") + + def Default_Boot(self): + # First To Load + #\\ Document ########################################################### + self.d_cm = "RGBA" + self.d_cd = "U8" + self.d_cp = "sRGB-elle-V2-srgtrc.icc" + + #// + #\\ Locks ############################################################## + self.performance_release = False + self.luma_lock = False # AAA / BW channel + self.luma_lock_value = [0, 0, 0] # AAA / BW hsx value to bind too while doing variation + self.ard_lock = False # ARD Radius constant Channel + self.ard_lock_value = [None, None] + self.cmyk_lock = False # CMYK channel + self.kkk_lock = False # KELVIN channel + + #// + #\\ Harmony ############################################################ + self.harmony_menu = False + self.harmony_status = 0 + self.harmony_slot = 0 + self.harmony_render = "COLOR" + self.harmony_rule = "Analogous" + self.harmony_space = "HSV" + self.harmony_edit = False + self.harmony_delta = 30 + self.harmony_span = 120 + self.har_1 = ["HSL", 0,0,0, 0,0,0] + self.har_2 = ["HSL", 0,0,0, 0,0,0] + self.har_3 = ["HSL", 0,0,0, 0,0,0] + self.har_4 = ["HSL", 0,0,0, 0,0,0] + self.har_5 = ["HSL", 0,0,0, 0,0,0] + self.layout.harmony_1.setStyleSheet(str("QWidget { background-color: rgb(%f, %f, %f);}" % (self.har_1[1]*255, self.har_1[2]*255, self.har_1[3]*255))) + self.layout.harmony_2.setStyleSheet(str("QWidget { background-color: rgb(%f, %f, %f);}" % (self.har_2[1]*255, self.har_2[2]*255, self.har_2[3]*255))) + self.layout.harmony_3.setStyleSheet(str("QWidget { background-color: rgb(%f, %f, %f);}" % (self.har_3[1]*255, self.har_3[2]*255, self.har_3[3]*255))) + self.layout.harmony_4.setStyleSheet(str("QWidget { background-color: rgb(%f, %f, %f);}" % (self.har_4[1]*255, self.har_4[2]*255, self.har_4[3]*255))) + self.layout.harmony_5.setStyleSheet(str("QWidget { background-color: rgb(%f, %f, %f);}" % (self.har_5[1]*255, self.har_5[2]*255, self.har_5[3]*255))) + + #// + #\\ Panel ############################################################## + self.panel_active = "HSV" + self.zoom = 0 + + #// + #\\ Panel HUE ########################################################## + self.panel_secondary = "DOT" + + #// + #\\ Panel GAM ########################################################## + self.gamut_space = "ARD" + self.gamut_shape = "None" + self.gamut_initial = 0 + self.gamut_angle = 0 + + # Memory + self.P1_S1 = [ + 0.5,0.1, + 0.9,0.5, + 0.5,0.9, + 0.1,0.5] + self.P1_S3 = [ + 0.5,0.1, + 0.84641,0.7, + 0.15359,0.7] + self.P1_S4 = [ + 0.5,0.1, + 0.9,0.5, + 0.5,0.9, + 0.1,0.5] + self.P2_S1 = [ + # Circle 1 + 0.5,0.1, + 0.675,0.275, + 0.5,0.45, + 0.325,0.275, + # Circle 2 + 0.5,0.55, + 0.675,0.725, + 0.5,0.9, + 0.325,0.725] + self.P3_S3 = [ + # Center + 0.5,0.5, + # Hexagon + 0.5,0.15359, + 0.8,0.32679, + 0.8,0.67321, + 0.5,0.84641, + 0.2,0.67321, + 0.2,0.32679] + # Rotation + self.P1_S1_r = [ + 0.5,0.1, + 0.9,0.5, + 0.5,0.9, + 0.1,0.5] + self.P1_S3_r = [ + 0.5,0.1, + 0.84641,0.7, + 0.15359,0.7] + self.P1_S4_r = [ + 0.5,0.1, + 0.9,0.5, + 0.5,0.9, + 0.1,0.5] + self.P2_S1_r = [ + # Circle 1 + 0.5,0.1, + 0.675,0.275, + 0.5,0.45, + 0.325,0.275, + # Circle 2 + 0.5,0.55, + 0.675,0.725, + 0.5,0.9, + 0.325,0.725] + self.P3_S3_r = [ + # Center + 0.5,0.5, + # Hexagon + 0.5,0.15359, + 0.8,0.32679, + 0.8,0.67321, + 0.5,0.84641, + 0.2,0.67321, + 0.2,0.32679] + #// + #\\ Panel DOT ########################################################## + self.dot_interpolation = "RGB" + self.dot_dimension = 11 + self.dot_location_x = 0 + self.dot_location_y = 0 + self.dot_1 = [True, 183/255, 46/255, 53/255, 53.93/255, 31.32/255, 11.79/255] # Cadmium Red (sRGB) + self.dot_2 = [True, 237/255, 181/255, 37/255, 140.22/255, 132.81/255, 17.82/255] # Yellow Ochre (sRGB) + self.dot_3 = [True, 237/255, 240/255, 236/255, 210.34/255, 220.31/255, 177.34/255] # Titanium White (sRGB) + self.dot_4 = [True, 41/255, 36/255, 33/255, 4.75/255, 4.72/255, 3.29/255] # IvoryBlack (sRGB) + color1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_1[1]*255, self.dot_1[2]*255, self.dot_1[3]*255)) + color2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_2[1]*255, self.dot_2[2]*255, self.dot_2[3]*255)) + color3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_3[1]*255, self.dot_3[2]*255, self.dot_3[3]*255)) + color4 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_4[1]*255, self.dot_4[2]*255, self.dot_4[3]*255)) + self.layout.dot_1.setStyleSheet(color1) + self.layout.dot_2.setStyleSheet(color2) + self.layout.dot_3.setStyleSheet(color3) + self.layout.dot_4.setStyleSheet(color4) + + #// + #\\ Panel OBJ ########################################################## + # Index Display + self.obj_index = 0 + self.obj_text = "SPHERE" + # Cursor Variables + self.obj_location_x = 0 + self.obj_location_y = 0 + # Panel Variables + self.obj_w = 0 + self.obj_h = 0 + # Object Color Sets + self.bg_1 = [ + [False, 0.5, 0.5, 0.5, 0], + [True, 0, 0, 0, 1]] + self.bg_2 = [ + [True, 0, 0, 0, 1], + [True, 0, 0, 0, 1]] + self.bg_3 = [ + [True, 0, 0, 0, 1], + [True, 0, 0, 0, 1]] + self.dif_1 = [ + [True, 35/255, 20/255, 2/255, 1], + [True, 0, 0, 0, 1]] + self.dif_2 = [ + [True, 84/255, 55/255, 19/255, 1], + [True, 0, 0, 0, 1]] + self.dif_3 = [ + [True, 254/255, 159/255, 14/255, 1], + [True, 0, 0, 0, 1]] + self.dif_4 = [ + [True, 255/255, 202/255, 50/255, 1], + [True, 0, 0, 0, 1]] + self.dif_5 = [ + [False, 0, 0, 0, 0], + [True, 0, 0, 0, 1]] + self.dif_6 = [ + [False, 0, 0, 0, 0], + [True, 0, 0, 0, 1]] + self.fg_1 = [ + [True, 0, 0, 0, 1], + [True, 0, 0, 0, 1]] + self.fg_2 = [ + [True, 255/255, 255/255, 150/255, 1], + [True, 0, 0, 0, 1]] + self.fg_3 = [ + [True, 1, 1, 1, 1], + [True, 0, 0, 0, 1]] + # First Object to Load + self.path_bg_1 = str(self.dir_name + "/OBJECT/SPHERE/bg_1.png") + self.path_bg_2 = str(self.dir_name + "/OBJECT/SPHERE/bg_2.png") + self.path_bg_3 = str(self.dir_name + "/OBJECT/SPHERE/bg_3.png") + self.path_dif_1 = str(self.dir_name + "/OBJECT/SPHERE/dif_1.png") + self.path_dif_2 = str(self.dir_name + "/OBJECT/SPHERE/dif_2.png") + self.path_dif_3 = str(self.dir_name + "/OBJECT/SPHERE/dif_3.png") + self.path_dif_4 = str(self.dir_name + "/OBJECT/SPHERE/dif_4.png") + self.path_dif_5 = str(self.dir_name + "/OBJECT/SPHERE/dif_5.png") + self.path_dif_6 = str(self.dir_name + "/OBJECT/SPHERE/dif_6.png") + self.path_fg_1 = str(self.dir_name + "/OBJECT/SPHERE/fg_1.png") + self.path_fg_2 = str(self.dir_name + "/OBJECT/SPHERE/fg_2.png") + self.path_fg_3 = str(self.dir_name + "/OBJECT/SPHERE/fg_3.png") + + #// + #\\ Panel IMG ########################################################## + # Default Image Path + self.img_state = "DEFAULT" + self.img_default = os.path.normpath( self.dir_name + "/IMAGE/default.png" ) + self.img_save = os.path.normpath( self.dir_name + "/IMAGE/save.png" ) + self.img_grayscale = False + # Panel + self.img_w = 1 + self.img_h = 1 + + #// + #\\ Channels ########################################################### + self.chan = True + self.hex_copy = False + self.hue_shine = False + + #// + #\\ COR ################################################################ + self.cor_00 = [False, 0, 0, 0] + self.cor_01 = [False, 0, 0, 0] + self.cor_02 = [False, 0, 0, 0] + self.cor_03 = [False, 0, 0, 0] + self.cor_04 = [False, 0, 0, 0] + self.cor_05 = [False, 0, 0, 0] + self.cor_06 = [False, 0, 0, 0] + self.cor_07 = [False, 0, 0, 0] + self.cor_08 = [False, 0, 0, 0] + self.cor_09 = [False, 0, 0, 0] + self.cor_10 = [False, 0, 0, 0] + self.layout.cor_00.setStyleSheet(self.bg_alpha) + self.layout.cor_01.setStyleSheet(self.bg_alpha) + self.layout.cor_02.setStyleSheet(self.bg_alpha) + self.layout.cor_03.setStyleSheet(self.bg_alpha) + self.layout.cor_04.setStyleSheet(self.bg_alpha) + self.layout.cor_05.setStyleSheet(self.bg_alpha) + self.layout.cor_06.setStyleSheet(self.bg_alpha) + self.layout.cor_07.setStyleSheet(self.bg_alpha) + self.layout.cor_08.setStyleSheet(self.bg_alpha) + self.layout.cor_09.setStyleSheet(self.bg_alpha) + self.layout.cor_10.setStyleSheet(self.bg_alpha) + + #// + #\\ Mixer TTS ########################################################## + self.color_tts = [False, 0, 0, 0] + self.gray_tts = self.color_grey + self.spacer_tint = 0 + self.spacer_tone = 0 + self.spacer_shade = 0 + + #// + #\\ Mixer TTS ########################################################## + # Default Load + self.color_tts = [False, 0, 0, 0] + self.gray_tts = self.color_grey + self.layout.tts_l1.setStyleSheet(self.bg_alpha) + self.layout.white.setStyleSheet(self.bg_alpha) + self.layout.grey.setStyleSheet(self.bg_alpha) + self.layout.black.setStyleSheet(self.bg_alpha) + # Correct Values + self.spacer_tint = 0 + self.spacer_tone = 0 + self.spacer_shade = 0 + self.mixer_tint.Update(self.spacer_tint, self.layout.tint.width()) + self.mixer_tone.Update(self.spacer_tone, self.layout.tone.width()) + self.mixer_shade.Update(self.spacer_shade, self.layout.shade.width()) + + #// + #\\ Mixer RGB ########################################################## + # Mixer RGB 1 + self.color_rgb_l1 = [False, 0, 0, 0] + self.color_rgb_r1 = [False, 0, 0, 0] + self.layout.rgb_l1.setStyleSheet(self.bg_alpha) + self.layout.rgb_r1.setStyleSheet(self.bg_alpha) + self.spacer_rgb_g1 = 0 + self.mixer_rgb_g1.Update(self.spacer_rgb_g1, self.mixer_width) + # Mixer RGB 2 + self.color_rgb_l2 = [False, 0, 0, 0] + self.color_rgb_r2 = [False, 0, 0, 0] + self.layout.rgb_l2.setStyleSheet(self.bg_alpha) + self.layout.rgb_r2.setStyleSheet(self.bg_alpha) + self.spacer_rgb_g2 = 0 + self.mixer_rgb_g2.Update(self.spacer_rgb_g2, self.mixer_width) + # Mixer RGB 3 + self.color_rgb_l3 = [False, 0, 0, 0] + self.color_rgb_r3 = [False, 0, 0, 0] + self.layout.rgb_l3.setStyleSheet(self.bg_alpha) + self.layout.rgb_r3.setStyleSheet(self.bg_alpha) + self.spacer_rgb_g3 = 0 + self.mixer_rgb_g3.Update(self.spacer_rgb_g3, self.mixer_width) + + #// + #\\ Mixer CMYK ######################################################### + # Mixer CMYK 1 + self.color_cmyk_l1 = [False, 0, 0, 0, 1] + self.color_cmyk_r1 = [False, 0, 0, 0, 1] + self.layout.cmyk_l1.setStyleSheet(self.bg_alpha) + self.layout.cmyk_r1.setStyleSheet(self.bg_alpha) + self.spacer_cmyk_g1 = 0 + self.mixer_cmyk_g1.Update(self.spacer_cmyk_g1, self.mixer_width) + # Mixer CMYK 2 + self.color_cmyk_l2 = [False, 0, 0, 0, 1] + self.color_cmyk_r2 = [False, 0, 0, 0, 1] + self.layout.cmyk_l2.setStyleSheet(self.bg_alpha) + self.layout.cmyk_r2.setStyleSheet(self.bg_alpha) + self.spacer_cmyk_g2 = 0 + self.mixer_cmyk_g2.Update(self.spacer_cmyk_g2, self.mixer_width) + # Mixer CMYK 3 + self.color_cmyk_l3 = [False, 0, 0, 0, 1] + self.color_cmyk_r3 = [False, 0, 0, 0, 1] + self.layout.cmyk_l3.setStyleSheet(self.bg_alpha) + self.layout.cmyk_r3.setStyleSheet(self.bg_alpha) + self.spacer_cmyk_g3 = 0 + self.mixer_cmyk_g3.Update(self.spacer_cmyk_g3, self.mixer_width) + + #// + #\\ Mixer RYB ########################################################## + # Mixer RYB 1 + self.color_ryb_l1 = [False, 0, 0, 0] + self.color_ryb_r1 = [False, 0, 0, 0] + self.layout.ryb_l1.setStyleSheet(self.bg_alpha) + self.layout.ryb_r1.setStyleSheet(self.bg_alpha) + self.spacer_ryb_g1 = 0 + self.mixer_ryb_g1.Update(self.spacer_ryb_g1, self.mixer_width) + # Mixer RYB 2 + self.color_ryb_l2 = [False, 0, 0, 0] + self.color_ryb_r2 = [False, 0, 0, 0] + self.layout.ryb_l2.setStyleSheet(self.bg_alpha) + self.layout.ryb_r2.setStyleSheet(self.bg_alpha) + self.spacer_ryb_g2 = 0 + self.mixer_ryb_g2.Update(self.spacer_ryb_g2, self.mixer_width) + # Mixer RYB 3 + self.color_ryb_l3 = [False, 0, 0, 0] + self.color_ryb_r3 = [False, 0, 0, 0] + self.layout.ryb_l3.setStyleSheet(self.bg_alpha) + self.layout.ryb_r3.setStyleSheet(self.bg_alpha) + self.spacer_ryb_g3 = 0 + self.mixer_ryb_g3.Update(self.spacer_ryb_g3, self.mixer_width) + + #// + #\\ Mixer YUV ########################################################## + # Mixer YUV 1 + self.color_yuv_l1 = [False, 0, 0.5, 0.5] + self.color_yuv_r1 = [False, 0, 0.5, 0.5] + self.layout.yuv_l1.setStyleSheet(self.bg_alpha) + self.layout.yuv_r1.setStyleSheet(self.bg_alpha) + self.spacer_yuv_g1 = 0 + self.mixer_yuv_g1.Update(self.spacer_yuv_g1, self.mixer_width) + # Mixer YUV 2 + self.color_yuv_l2 = [False, 0, 0.5, 0.5] + self.color_yuv_r2 = [False, 0, 0.5, 0.5] + self.layout.yuv_l2.setStyleSheet(self.bg_alpha) + self.layout.yuv_r2.setStyleSheet(self.bg_alpha) + self.spacer_yuv_g2 = 0 + self.mixer_yuv_g2.Update(self.spacer_yuv_g2, self.mixer_width) + # Mixer YUV 3 + self.color_yuv_l3 = [False, 0, 0.5, 0.5] + self.color_yuv_r3 = [False, 0, 0.5, 0.5] + self.layout.yuv_l3.setStyleSheet(self.bg_alpha) + self.layout.yuv_r3.setStyleSheet(self.bg_alpha) + self.spacer_yuv_g3 = 0 + self.mixer_yuv_g3.Update(self.spacer_yuv_g3, self.mixer_width) + + #// + #\\ Mixer ARD ########################################################## + # Mixer ARD 1 + self.color_ard_l1 = [False, 0, 0, 0] + self.color_ard_r1 = [False, 0, 0, 0] + self.layout.ard_l1.setStyleSheet(self.bg_alpha) + self.layout.ard_r1.setStyleSheet(self.bg_alpha) + self.spacer_ard_g1 = 0 + self.mixer_ard_g1.Update(self.spacer_ard_g1, self.mixer_width) + # Mixer ARD 2 + self.color_ard_l2 = [False, 0, 0, 0] + self.color_ard_r2 = [False, 0, 0, 0] + self.layout.ard_l2.setStyleSheet(self.bg_alpha) + self.layout.ard_r2.setStyleSheet(self.bg_alpha) + self.spacer_ard_g2 = 0 + self.mixer_ard_g2.Update(self.spacer_ard_g2, self.mixer_width) + # Mixer ARD 3 + self.color_ard_l3 = [False, 0, 0, 0] + self.color_ard_r3 = [False, 0, 0, 0] + self.layout.ard_l3.setStyleSheet(self.bg_alpha) + self.layout.ard_r3.setStyleSheet(self.bg_alpha) + self.spacer_ard_g3 = 0 + self.mixer_ard_g3.Update(self.spacer_ard_g3, self.mixer_width) + + #// + #\\ Mixer HSV ########################################################## + # Mixer HSV 1 + self.color_hsv_l1 = [False, 0, 0, 0] + self.color_hsv_r1 = [False, 0, 0, 0] + self.layout.hsv_l1.setStyleSheet(self.bg_alpha) + self.layout.hsv_r1.setStyleSheet(self.bg_alpha) + self.spacer_hsv_g1 = 0 + self.mixer_hsv_g1.Update(self.spacer_hsv_g1, self.mixer_width) + # Mixer HSV 2 + self.color_hsv_l2 = [False, 0, 0, 0] + self.color_hsv_r2 = [False, 0, 0, 0] + self.layout.hsv_l2.setStyleSheet(self.bg_alpha) + self.layout.hsv_r2.setStyleSheet(self.bg_alpha) + self.spacer_hsv_g2 = 0 + self.mixer_hsv_g2.Update(self.spacer_hsv_g2, self.mixer_width) + # Mixer HSV 3 + self.color_hsv_l3 = [False, 0, 0, 0] + self.color_hsv_r3 = [False, 0, 0, 0] + self.layout.hsv_l3.setStyleSheet(self.bg_alpha) + self.layout.hsv_r3.setStyleSheet(self.bg_alpha) + self.spacer_hsv_g3 = 0 + self.mixer_hsv_g3.Update(self.spacer_hsv_g3, self.mixer_width) + + #// + #\\ Mixer HSL ########################################################## + # Mixer HSL 1 + self.color_hsl_l1 = [False, 0, 0, 0] + self.color_hsl_r1 = [False, 0, 0, 0] + self.layout.hsl_l1.setStyleSheet(self.bg_alpha) + self.layout.hsl_r1.setStyleSheet(self.bg_alpha) + self.spacer_hsl_g1 = 0 + self.mixer_hsl_g1.Update(self.spacer_hsl_g1, self.mixer_width) + # Mixer HSL 2 + self.color_hsl_l2 = [False, 0, 0, 0] + self.color_hsl_r2 = [False, 0, 0, 0] + self.layout.hsl_l2.setStyleSheet(self.bg_alpha) + self.layout.hsl_r2.setStyleSheet(self.bg_alpha) + self.spacer_hsl_g2 = 0 + self.mixer_hsl_g2.Update(self.spacer_hsl_g2, self.mixer_width) + # Mixer HSL 3 + self.color_hsl_l3 = [False, 0, 0, 0] + self.color_hsl_r3 = [False, 0, 0, 0] + self.layout.hsl_l3.setStyleSheet(self.bg_alpha) + self.layout.hsl_r3.setStyleSheet(self.bg_alpha) + self.spacer_hsl_g3 = 0 + self.mixer_hsl_g3.Update(self.spacer_hsl_g3, self.mixer_width) + + #// + #\\ Mixer HCY ########################################################## + # Mixer HCY 1 + self.color_hcy_l1 = [False, 0, 0, 0] + self.color_hcy_r1 = [False, 0, 0, 0] + self.layout.hcy_l1.setStyleSheet(self.bg_alpha) + self.layout.hcy_r1.setStyleSheet(self.bg_alpha) + self.spacer_hcy_g1 = 0 + self.mixer_hcy_g1.Update(self.spacer_hcy_g1, self.mixer_width) + # Mixer HCY 2 + self.color_hcy_l2 = [False, 0, 0, 0] + self.color_hcy_r2 = [False, 0, 0, 0] + self.layout.hcy_l2.setStyleSheet(self.bg_alpha) + self.layout.hcy_r2.setStyleSheet(self.bg_alpha) + self.spacer_hcy_g2 = 0 + self.mixer_hcy_g2.Update(self.spacer_hcy_g2, self.mixer_width) + # Mixer HCY 3 + self.color_hcy_l3 = [False, 0, 0, 0] + self.color_hcy_r3 = [False, 0, 0, 0] + self.layout.hcy_l3.setStyleSheet(self.bg_alpha) + self.layout.hcy_r3.setStyleSheet(self.bg_alpha) + self.spacer_hcy_g3 = 0 + self.mixer_hcy_g3.Update(self.spacer_hcy_g3, self.mixer_width) + + #// + #\\ Mixer Gradient Display ############################################# + self.Mixer_Display() + + #// + #\\ Mode ############################################################### + self.wheel = "CMY" + self.luminosity = "709" + self.Menu_XYZ_Conversion() + + #// + #\\ Key Shortcuts ###################################################### + self.key_1 = "KEY 1" + self.key_2 = "KEY 2" + self.key_3 = "KEY 3" + self.key_4 = "KEY 4" + + #// + # Last To Load + #\\ Performance ######################################################## + self.performance_release = False + self.performance_inaccurate = False + + #// + #\\ Active Color ####################################################### + # Foreground Colors + self.rgb_1 = 0 + self.rgb_2 = 0 + self.rgb_3 = 0 + self.rgb_k1 = 0 + self.rgb_k2 = 0 + self.rgb_k3 = 0 + self.xyz_1 = 0 + self.xyz_2 = 0 + self.xyz_3 = 0 + self.angle_live = 0 + self.angle_ryb = 0 + self.uvd_1 = 0 + self.uvd_2 = 0 + self.uvd_3 = 0 + self.d_previous = 0 + self.kkk_0 = 6500 + self.kkk_r = 255/255 + self.kkk_g = 249/255 + self.kkk_b = 253/255 + # Background Colors + self.aaa_bg1 = 0 + self.rgb_bg1 = 0 + self.rgb_bg2 = 0 + self.rgb_bg3 = 0 + self.cmyk_bg1 = 0 + self.cmyk_bg2 = 0 + self.cmyk_bg3 = 0 + self.cmyk_bg4 = 0 + self.yuv_bg1 = 0 + self.yuv_bg2 = 0 + self.yuv_bg3 = 0 + self.xyz_bg1 = 0 + self.xyz_bg2 = 0 + self.xyz_bg3 = 0 + self.lab_bg1 = 0 + self.lab_bg2 = 0 + self.lab_bg3 = 0 + # Display + self.disp_1 = 0 + self.disp_2 = 0 + self.disp_3 = 0 + self.disp_bg1 = 0 + self.disp_bg2 = 0 + self.disp_bg3 = 0 + # Apply Active Color + self.Hexagon_Points_UVD() + self.Color_HUE("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Color_APPLY("RGB", self.rgb_1, self.rgb_2, self.rgb_3, 0) + self.Pigment_Release() + + #// + #\\ User Interface ##################################################### + # D1 + self.dialog.har.setChecked(False) + self.dialog.pan.setChecked(True) + self.dialog.cha.setChecked(True) + self.dialog.cor.setChecked(False) + self.dialog.mix.setChecked(False) + self.dialog.his.setChecked(False) + # D2 + self.dialog.har_rule.setCurrentIndex(2) + self.dialog.har_edit.setChecked(False) + self.dialog.pan_index.setCurrentIndex(3) + self.dialog.hue_secondary.setCurrentIndex(0) + self.dialog.gam_space.setCurrentIndex(0) + self.dialog.gam_shape.setCurrentIndex(0) + # self.dialog.gam_reset.setChecked(0) + self.dialog.dot_interpolation.setCurrentIndex(0) + self.dialog.dot_resolution.setCurrentIndex(4) + self.dialog.dot_set.setChecked(False) + self.dialog.obj_index.setCurrentIndex(0) + self.dialog.obj_set.setChecked(False) + # self.dialog.img_file.setChecked(False) + self.dialog.img_grayscale.setChecked(False) + # D3 + self.dialog.aaa.setChecked(False) + self.dialog.rgb.setChecked(False) + self.dialog.cmy.setChecked(False) + self.dialog.cmyk.setChecked(False) + self.dialog.ryb.setChecked(False) + self.dialog.yuv.setChecked(False) + self.dialog.kkk.setChecked(False) + # D3 + self.dialog.ard.setChecked(False) + self.dialog.hsv.setChecked(True) + self.dialog.hsl.setChecked(False) + self.dialog.hcy.setChecked(False) + # D3 + self.dialog.xyz.setChecked(False) + self.dialog.xyy.setChecked(False) + self.dialog.luv.setChecked(False) + self.dialog.hlab.setChecked(False) + self.dialog.lab.setChecked(False) + self.dialog.lch.setChecked(False) + # D4 + self.dialog.display_values.setChecked(False) + self.dialog.display_hex.setChecked(False) + self.dialog.hex_copy_paste.setChecked(False) + self.dialog.hue_shine.setChecked(False) + self.dialog.cursor.setChecked(False) + # D5 + self.dialog.mix_index.setCurrentIndex(0) + # self.dialog.history_clear.setChecked(False) + # D6 + self.dialog.wheel_index.setCurrentIndex(0) + self.dialog.wheel_space.setCurrentIndex(0) + self.dialog.luminosity.setCurrentIndex(1) + self.dialog.xyz_matrix.setCurrentIndex(0) + self.dialog.xyz_illuminant.setCurrentIndex(1) + self.dialog.key_1.setCurrentIndex(0) + self.dialog.key_2.setCurrentIndex(0) + self.dialog.key_3.setCurrentIndex(0) + self.dialog.key_4.setCurrentIndex(0) + # D7 + # self.dialog.names_closest.setChecked(False) + # D8 + self.dialog.release.setChecked(False) + self.dialog.inaccurate.setChecked(False) + + #// + def Default_Save(self): + self.Settings_Save_Misc() + self.Settings_Save_ActiveColor() + self.Settings_Save_UI() + self.Settings_Save_Version() + self.Settings_Save_Annotations() + + def Settings_Load_Version(self): + try: + version = Krita.instance().readSetting("Pigment.O", "version", "") + except: + version = False + return version + def Settings_Save_Version(self): + Krita.instance().writeSetting("Pigment.O", "version", str(pigment_o_version)) + + def Settings_Load_Misc(self): + #\\ Panel GAM ########################################################## + try: + gam_p1s1_string = Krita.instance().readSetting("Pigment.O", "gam_p1s1", "") + gam_p1s3_string = Krita.instance().readSetting("Pigment.O", "gam_p1s3", "") + gam_p1s4_string = Krita.instance().readSetting("Pigment.O", "gam_p1s4", "") + gam_p2s1_string = Krita.instance().readSetting("Pigment.O", "gam_p2s1", "") + gam_p3s3_string = Krita.instance().readSetting("Pigment.O", "gam_p3s3", "") + p1s1s = gam_p1s1_string.split(",") + p1s3s = gam_p1s3_string.split(",") + p1s4s = gam_p1s4_string.split(",") + p2s1s = gam_p2s1_string.split(",") + p3s3s = gam_p3s3_string.split(",") + # Update Variables + self.P1_S1 = self.P1_S1_r = [ + eval(p1s1s[0]), eval(p1s1s[1]), + eval(p1s1s[2]), eval(p1s1s[3]), + eval(p1s1s[4]), eval(p1s1s[5]), + eval(p1s1s[6]), eval(p1s1s[7]), + ] + self.P1_S3 = self.P1_S3_r = [ + eval(p1s3s[0]), eval(p1s3s[1]), + eval(p1s3s[2]), eval(p1s3s[3]), + eval(p1s3s[4]), eval(p1s3s[5]), + ] + self.P1_S4 = self.P1_S4_r = [ + eval(p1s4s[0]), eval(p1s4s[1]), + eval(p1s4s[2]), eval(p1s4s[3]), + eval(p1s4s[4]), eval(p1s4s[5]), + eval(p1s4s[6]), eval(p1s4s[7]), + ] + self.P2_S1 = self.P2_S1_r = [ + eval(p2s1s[0]), eval(p2s1s[1]), + eval(p2s1s[2]), eval(p2s1s[3]), + eval(p2s1s[4]), eval(p2s1s[5]), + eval(p2s1s[6]), eval(p2s1s[7]), + eval(p2s1s[8]), eval(p2s1s[9]), + eval(p2s1s[10]), eval(p2s1s[11]), + eval(p2s1s[12]), eval(p2s1s[13]), + eval(p2s1s[14]), eval(p2s1s[15]), + ] + self.P3_S3 = self.P3_S3_r = [ + eval(p3s3s[0]), eval(p3s3s[1]), + eval(p3s3s[2]), eval(p3s3s[3]), + eval(p3s3s[4]), eval(p3s3s[5]), + eval(p3s3s[6]), eval(p3s3s[7]), + eval(p3s3s[8]), eval(p3s3s[9]), + eval(p3s3s[10]), eval(p3s3s[11]), + eval(p3s3s[12]), eval(p3s3s[13]), + ] + # Update widget with Variables + self.Update_Panel_GAM_Polygon(self.P1_S1, self.P1_S3, self.P1_S4, self.P2_S1, self.P3_S3) + except: + QtCore.qWarning("Pigment.O - Load Error - Panel GAM") + #// + #\\ Panel DOT ########################################################## + try: + dot_01_string = Krita.instance().readSetting("Pigment.O", "dot_01", "") + dot_02_string = Krita.instance().readSetting("Pigment.O", "dot_02", "") + dot_03_string = Krita.instance().readSetting("Pigment.O", "dot_03", "") + dot_04_string = Krita.instance().readSetting("Pigment.O", "dot_04", "") + dot_01_split = dot_01_string.split(",") + dot_02_split = dot_02_string.split(",") + dot_03_split = dot_03_string.split(",") + dot_04_split = dot_04_string.split(",") + check1 = eval(dot_01_split[0]) + check2 = eval(dot_02_split[0]) + check3 = eval(dot_03_split[0]) + check4 = eval(dot_04_split[0]) + if (check1 == True or check2 == True or check3 == True or check4 == True): + if check1 == True: + self.dot_1 = [True, float(dot_01_split[1]), float(dot_01_split[2]), float(dot_01_split[3]), float(dot_01_split[4]), float(dot_01_split[5]), float(dot_01_split[6])] + color1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_1[1]*255, self.dot_1[2]*255, self.dot_1[3]*255)) + self.layout.dot_1.setStyleSheet(color1) + else: + self.dot_1 = [False, 0, 0, 0, 0, 0, 0] + self.layout.dot_1.setStyleSheet(self.bg_alpha) + if check2 == True: + self.dot_2 = [True, float(dot_02_split[1]), float(dot_02_split[2]), float(dot_02_split[3]), float(dot_02_split[4]), float(dot_02_split[5]), float(dot_02_split[6])] + color2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_2[1]*255, self.dot_2[2]*255, self.dot_2[3]*255)) + self.layout.dot_2.setStyleSheet(color2) + else: + self.dot_2 = [False, 0, 0, 0, 0, 0, 0] + self.layout.dot_2.setStyleSheet(self.bg_alpha) + if check3 == True: + self.dot_3 = [True, float(dot_03_split[1]), float(dot_03_split[2]), float(dot_03_split[3]), float(dot_03_split[4]), float(dot_03_split[5]), float(dot_03_split[6])] + color3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_3[1]*255, self.dot_3[2]*255, self.dot_3[3]*255)) + self.layout.dot_3.setStyleSheet(color3) + else: + self.dot_3 = [False, 0, 0, 0, 0, 0, 0] + self.layout.dot_3.setStyleSheet(self.bg_alpha) + if check4 == True: + self.dot_4 = [True, float(dot_04_split[1]), float(dot_04_split[2]), float(dot_04_split[3]), float(dot_04_split[4]), float(dot_04_split[5]), float(dot_04_split[6])] + color4 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.dot_4[1]*255, self.dot_4[2]*255, self.dot_4[3]*255)) + self.layout.dot_4.setStyleSheet(color4) + else: + self.dot_4 = [False, 0, 0, 0, 0, 0, 0] + self.layout.dot_4.setStyleSheet(self.bg_alpha) + except: + QtCore.qWarning("Pigment.O - Load Error - Panel DOT") + + #// + #\\ Panel OBJ ########################################################## + try: + # Load from File + object_00_string = Krita.instance().readSetting("Pigment.O", "obj_00", "") + object_01_string = Krita.instance().readSetting("Pigment.O", "obj_01", "") + obj00s = object_00_string.split(",") + obj01s = object_01_string.split(",") + # Assign Variables + self.bg_1 = [ + [eval(obj00s[0]), eval(obj00s[1]), eval(obj00s[2]), eval(obj00s[3]), eval(obj00s[4])], + [eval(obj01s[0]), eval(obj01s[1]), eval(obj01s[2]), eval(obj01s[3]), eval(obj01s[4])]] + self.bg_2 = [ + [eval(obj00s[5]), eval(obj00s[6]), eval(obj00s[7]), eval(obj00s[8]), eval(obj00s[9])], + [eval(obj01s[5]), eval(obj01s[6]), eval(obj01s[7]), eval(obj01s[8]), eval(obj01s[9])]] + self.bg_3 = [ + [eval(obj00s[10]), eval(obj00s[11]), eval(obj00s[12]), eval(obj00s[13]), eval(obj00s[14])], + [eval(obj01s[10]), eval(obj01s[11]), eval(obj01s[12]), eval(obj01s[13]), eval(obj01s[14])]] + self.dif_1 = [ + [eval(obj00s[15]), eval(obj00s[16]), eval(obj00s[17]), eval(obj00s[18]), eval(obj00s[19])], + [eval(obj01s[15]), eval(obj01s[16]), eval(obj01s[17]), eval(obj01s[18]), eval(obj01s[19])]] + self.dif_2 = [ + [eval(obj00s[20]), eval(obj00s[21]), eval(obj00s[22]), eval(obj00s[23]), eval(obj00s[24])], + [eval(obj01s[20]), eval(obj01s[21]), eval(obj01s[22]), eval(obj01s[23]), eval(obj01s[24])]] + self.dif_3 = [ + [eval(obj00s[25]), eval(obj00s[26]), eval(obj00s[27]), eval(obj00s[28]), eval(obj00s[29])], + [eval(obj01s[25]), eval(obj01s[26]), eval(obj01s[27]), eval(obj01s[28]), eval(obj01s[29])]] + self.dif_4 = [ + [eval(obj00s[30]), eval(obj00s[31]), eval(obj00s[32]), eval(obj00s[33]), eval(obj00s[34])], + [eval(obj01s[30]), eval(obj01s[31]), eval(obj01s[32]), eval(obj01s[33]), eval(obj01s[34])]] + self.dif_5 = [ + [eval(obj00s[35]), eval(obj00s[36]), eval(obj00s[37]), eval(obj00s[38]), eval(obj00s[39])], + [eval(obj01s[35]), eval(obj01s[36]), eval(obj01s[37]), eval(obj01s[38]), eval(obj01s[39])]] + self.dif_6 = [ + [eval(obj00s[40]), eval(obj00s[41]), eval(obj00s[42]), eval(obj00s[43]), eval(obj00s[44])], + [eval(obj01s[40]), eval(obj01s[41]), eval(obj01s[42]), eval(obj01s[43]), eval(obj01s[44])]] + self.fg_1 = [ + [eval(obj00s[45]), eval(obj00s[46]), eval(obj00s[47]), eval(obj00s[48]), eval(obj00s[49])], + [eval(obj01s[45]), eval(obj01s[46]), eval(obj01s[47]), eval(obj01s[48]), eval(obj01s[49])]] + self.fg_2 = [ + [eval(obj00s[50]), eval(obj00s[51]), eval(obj00s[52]), eval(obj00s[53]), eval(obj00s[54])], + [eval(obj01s[50]), eval(obj01s[51]), eval(obj01s[52]), eval(obj01s[53]), eval(obj01s[54])]] + self.fg_3 = [ + [eval(obj00s[55]), eval(obj00s[56]), eval(obj00s[57]), eval(obj00s[58]), eval(obj00s[59])], + [eval(obj01s[55]), eval(obj01s[56]), eval(obj01s[57]), eval(obj01s[58]), eval(obj01s[59])]] + # Verify to RESET Colors + if ( + self.bg_1[0][0] == False and + self.bg_2[0][0] == False and + self.bg_3[0][0] == False and + self.dif_1[0][0] == False and + self.dif_2[0][0] == False and + self.dif_3[0][0] == False and + self.dif_4[0][0] == False and + self.dif_5[0][0] == False and + self.dif_6[0][0] == False and + self.fg_1[0][0] == False and + self.fg_2[0][0] == False and + self.fg_3[0][0] == False): + self.bg_1[0] = [False, 0.5, 0.5, 0.5, 0] + self.bg_2[0] = [True, 0, 0, 0, 1] + self.bg_3[0] = [True, 0, 0, 0, 1] + self.dif_1[0] = [True, 35/255, 20/255, 2/255, 1] + self.dif_2[0] = [True, 84/255, 55/255, 19/255, 1] + self.dif_3[0] = [True, 254/255, 159/255, 14/255, 1] + self.dif_4[0] = [True, 255/255, 202/255, 50/255, 1] + self.dif_5[0] = [False, 0, 0, 0, 0] + self.dif_6[0] = [False, 0, 0, 0, 0] + self.fg_1[0] = [True, 0, 0, 0, 1] + self.fg_2[0] = [True, 255/255, 255/255, 150/255, 1] + self.fg_3[0] = [True, 1, 1, 1, 1] + if ( + self.bg_1[1][0] == False and + self.bg_2[1][0] == False and + self.bg_3[1][0] == False and + self.dif_1[1][0] == False and + self.dif_2[1][0] == False and + self.dif_3[1][0] == False and + self.dif_4[1][0] == False and + self.dif_5[1][0] == False and + self.dif_6[1][0] == False and + self.fg_1[1][0] == False and + self.fg_2[1][0] == False and + self.fg_3[1][0] == False): + self.bg_1[1] = [True, 0, 0, 0, 1] + self.bg_2[1] = [True, 0, 0, 0, 1] + self.bg_3[1] = [True, 0, 0, 0, 1] + self.dif_1[1] = [True, 0, 0, 0, 1] + self.dif_2[1] = [True, 0, 0, 0, 1] + self.dif_3[1] = [True, 0, 0, 0, 1] + self.dif_4[1] = [True, 0, 0, 0, 1] + self.dif_5[1] = [True, 0, 0, 0, 1] + self.dif_6[1] = [True, 0, 0, 0, 1] + self.fg_1[1] = [True, 0, 0, 0, 1] + self.fg_2[1] = [True, 0, 0, 0, 1] + self.fg_3[1] = [True, 0, 0, 0, 1] + # Update + self.Object_SetDisplay() + self.Update_Panel_OBJ() + except: + QtCore.qWarning("Pigment.O - Load Error - Panel OBJ") + #// + #\\ Panel IMG ########################################################## + try: + self.img_state = str(Krita.instance().readSetting("Pigment.O", "img_state", "")) + if (self.img_state == "SAVE" and QImageReader(self.img_save).canRead() == True): + self.IMG_APPLY(self.img_save) + else: + self.img_state = "DEFAULT" + self.IMG_APPLY(self.img_default) + + except: + QtCore.qWarning("Pigment.O - Load Error - Panel IMG") + #// + #\\ COR ################################################################ + try: + cor_00_string = Krita.instance().readSetting("Pigment.O", "cor_00", "") + cor_01_string = Krita.instance().readSetting("Pigment.O", "cor_01", "") + cor_02_string = Krita.instance().readSetting("Pigment.O", "cor_02", "") + cor_03_string = Krita.instance().readSetting("Pigment.O", "cor_03", "") + cor_04_string = Krita.instance().readSetting("Pigment.O", "cor_04", "") + cor_05_string = Krita.instance().readSetting("Pigment.O", "cor_05", "") + cor_06_string = Krita.instance().readSetting("Pigment.O", "cor_06", "") + cor_07_string = Krita.instance().readSetting("Pigment.O", "cor_07", "") + cor_08_string = Krita.instance().readSetting("Pigment.O", "cor_08", "") + cor_09_string = Krita.instance().readSetting("Pigment.O", "cor_09", "") + cor_10_string = Krita.instance().readSetting("Pigment.O", "cor_10", "") + cor_00_split = cor_00_string.split(",") + cor_01_split = cor_01_string.split(",") + cor_02_split = cor_02_string.split(",") + cor_03_split = cor_03_string.split(",") + cor_04_split = cor_04_string.split(",") + cor_05_split = cor_05_string.split(",") + cor_06_split = cor_06_string.split(",") + cor_07_split = cor_07_string.split(",") + cor_08_split = cor_08_string.split(",") + cor_09_split = cor_09_string.split(",") + cor_10_split = cor_10_string.split(",") + if eval(cor_00_split[0]) == True: + self.cor_00 = [True, float(cor_00_split[1]), float(cor_00_split[2]), float(cor_00_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_00[1]*255, self.cor_00[2]*255, self.cor_00[3]*255)) + self.layout.cor_00.setStyleSheet(color) + if eval(cor_01_split[0]) == True: + self.cor_01 = [True, float(cor_01_split[1]), float(cor_01_split[2]), float(cor_01_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_01[1]*255, self.cor_01[2]*255, self.cor_01[3]*255)) + self.layout.cor_01.setStyleSheet(color) + if eval(cor_02_split[0]) == True: + self.cor_02 = [True, float(cor_02_split[1]), float(cor_02_split[2]), float(cor_02_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_02[1]*255, self.cor_02[2]*255, self.cor_02[3]*255)) + self.layout.cor_02.setStyleSheet(color) + if eval(cor_03_split[0]) == True: + self.cor_03 = [True, float(cor_03_split[1]), float(cor_03_split[2]), float(cor_03_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_03[1]*255, self.cor_03[2]*255, self.cor_03[3]*255)) + self.layout.cor_03.setStyleSheet(color) + if eval(cor_04_split[0]) == True: + self.cor_04 = [True, float(cor_04_split[1]), float(cor_04_split[2]), float(cor_04_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_04[1]*255, self.cor_04[2]*255, self.cor_04[3]*255)) + self.layout.cor_04.setStyleSheet(color) + if eval(cor_05_split[0]) == True: + self.cor_05 = [True, float(cor_05_split[1]), float(cor_05_split[2]), float(cor_05_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_05[1]*255, self.cor_05[2]*255, self.cor_05[3]*255)) + self.layout.cor_05.setStyleSheet(color) + if eval(cor_06_split[0]) == True: + self.cor_06 = [True, float(cor_06_split[1]), float(cor_06_split[2]), float(cor_06_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_06[1]*255, self.cor_06[2]*255, self.cor_06[3]*255)) + self.layout.cor_06.setStyleSheet(color) + if eval(cor_07_split[0]) == True: + self.cor_07 = [True, float(cor_07_split[1]), float(cor_07_split[2]), float(cor_07_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_07[1]*255, self.cor_07[2]*255, self.cor_07[3]*255)) + self.layout.cor_07.setStyleSheet(color) + if eval(cor_08_split[0]) == True: + self.cor_08 = [True, float(cor_08_split[1]), float(cor_08_split[2]), float(cor_08_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_08[1]*255, self.cor_08[2]*255, self.cor_08[3]*255)) + self.layout.cor_08.setStyleSheet(color) + if eval(cor_09_split[0]) == True: + self.cor_09 = [True, float(cor_09_split[1]), float(cor_09_split[2]), float(cor_09_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_09[1]*255, self.cor_09[2]*255, self.cor_09[3]*255)) + self.layout.cor_09.setStyleSheet(color) + if eval(cor_10_split[0]) == True: + self.cor_10 = [True, float(cor_10_split[1]), float(cor_10_split[2]), float(cor_10_split[3])] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.cor_10[1]*255, self.cor_10[2]*255, self.cor_10[3]*255)) + self.layout.cor_10.setStyleSheet(color) + except: + QtCore.qWarning("Pigment.O - Load Error - COR Palette") + + #// + #\\ Mixer TTS ########################################################## + try: + mixer_tts_string = Krita.instance().readSetting("Pigment.O", "mix_TTS", "") + mixer_tts_split = mixer_tts_string.split(",") + if eval(mixer_tts_split[0]) == True: + self.color_tts = [True, float(mixer_tts_split[1]), float(mixer_tts_split[2]), float(mixer_tts_split[3])] + gray = self.rgb_to_aaa(self.color_tts[1], self.color_tts[2], self.color_tts[3]) + self.gray_tts = [gray[0], gray[0], gray[0]] + color = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_tts[1]*255, self.color_tts[2]*255, self.color_tts[3]*255)) + bg_gray_tts = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ; " % (self.gray_tts[0]*255, self.gray_tts[1]*255, self.gray_tts[2]*255)) + self.layout.tts_l1.setStyleSheet(color) + self.layout.white.setStyleSheet(self.bg_white) + self.layout.grey.setStyleSheet(bg_gray_tts) + self.layout.black.setStyleSheet(self.bg_black) + except: + QtCore.qWarning("Pigment.O - Load Error - Mixer TTS") + #// + #\\ Mixer RGB ########################################################## + try: + # Mixer RGB 1 + mixer_rgb_1_string = Krita.instance().readSetting("Pigment.O", "mix_RGB_1", "") + mixer_rgb_1_split = mixer_rgb_1_string.split(",") + mixer_rgb_1_left = eval(mixer_rgb_1_split[0]) + mixer_rgb_1_right = eval(mixer_rgb_1_split[4]) + if (mixer_rgb_1_left == True and mixer_rgb_1_right == True): + # Gradient + self.color_rgb_l1 = [True, float(mixer_rgb_1_split[1]), float(mixer_rgb_1_split[2]), float(mixer_rgb_1_split[3])] + self.color_rgb_r1 = [True, float(mixer_rgb_1_split[5]), float(mixer_rgb_1_split[6]), float(mixer_rgb_1_split[7])] + color_rgb_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_l1[1]*255, self.color_rgb_l1[2]*255, self.color_rgb_l1[3]*255)) + color_rgb_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_r1[1]*255, self.color_rgb_r1[2]*255, self.color_rgb_r1[3]*255)) + self.layout.rgb_l1.setStyleSheet(color_rgb_left_1) + self.layout.rgb_r1.setStyleSheet(color_rgb_right_1) + elif (mixer_rgb_1_left == True and mixer_rgb_1_right != True): + # Color Left + self.color_rgb_l1 = [True, float(mixer_rgb_1_split[1]), float(mixer_rgb_1_split[2]), float(mixer_rgb_1_split[3])] + self.color_rgb_r1 = [False, 0, 0, 0] + color_rgb_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_l1[1]*255, self.color_rgb_l1[2]*255, self.color_rgb_l1[3]*255)) + self.layout.rgb_l1.setStyleSheet(color_rgb_left_1) + self.layout.rgb_r1.setStyleSheet(self.bg_alpha) + elif (mixer_rgb_1_left != True and mixer_rgb_1_right == True): + # Color Right + self.color_rgb_l1 = [False, 0, 0, 0] + self.color_rgb_r1 = [True, float(mixer_rgb_1_split[5]), float(mixer_rgb_1_split[6]), float(mixer_rgb_1_split[7])] + color_rgb_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_r1[1]*255, self.color_rgb_r1[2]*255, self.color_rgb_r1[3]*255)) + self.layout.rgb_l1.setStyleSheet(self.bg_alpha) + self.layout.rgb_r1.setStyleSheet(color_rgb_right_1) + # Mixer RGB 2 + mixer_rgb_2_string = Krita.instance().readSetting("Pigment.O", "mix_RGB_2", "") + mixer_rgb_2_split = mixer_rgb_2_string.split(",") + mixer_rgb_2_left = eval(mixer_rgb_2_split[0]) + mixer_rgb_2_right = eval(mixer_rgb_2_split[4]) + if (mixer_rgb_2_left == True and mixer_rgb_2_right == True): + # Gradient + self.color_rgb_l2 = [True, float(mixer_rgb_2_split[1]), float(mixer_rgb_2_split[2]), float(mixer_rgb_2_split[3])] + self.color_rgb_r2 = [True, float(mixer_rgb_2_split[5]), float(mixer_rgb_2_split[6]), float(mixer_rgb_2_split[7])] + color_rgb_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_l2[1]*255, self.color_rgb_l2[2]*255, self.color_rgb_l2[3]*255)) + color_rgb_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_r2[1]*255, self.color_rgb_r2[2]*255, self.color_rgb_r2[3]*255)) + self.layout.rgb_l2.setStyleSheet(color_rgb_left_2) + self.layout.rgb_r2.setStyleSheet(color_rgb_right_2) + elif (mixer_rgb_2_left == True and mixer_rgb_2_right != True): + # Color Left + self.color_rgb_l2 = [True, float(mixer_rgb_2_split[1]), float(mixer_rgb_2_split[2]), float(mixer_rgb_2_split[3])] + self.color_rgb_r2 = [False, 0, 0, 0] + color_rgb_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_l2[1]*255, self.color_rgb_l2[2]*255, self.color_rgb_l2[3]*255)) + self.layout.rgb_l2.setStyleSheet(color_rgb_left_2) + self.layout.rgb_r2.setStyleSheet(self.bg_alpha) + elif (mixer_rgb_2_left != True and mixer_rgb_2_right == True): + # Color Right + self.color_rgb_l2 = [False, 0, 0, 0] + self.color_rgb_r2 = [True, float(mixer_rgb_2_split[5]), float(mixer_rgb_2_split[6]), float(mixer_rgb_2_split[7])] + color_rgb_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_r2[1]*255, self.color_rgb_r2[2]*255, self.color_rgb_r2[3]*255)) + self.layout.rgb_l2.setStyleSheet(self.bg_alpha) + self.layout.rgb_r2.setStyleSheet(color_rgb_right_2) + # Mixer RGB 3 + mixer_rgb_3_string = Krita.instance().readSetting("Pigment.O", "mix_RGB_3", "") + mixer_rgb_3_split = mixer_rgb_3_string.split(",") + mixer_rgb_3_left = eval(mixer_rgb_3_split[0]) + mixer_rgb_3_right = eval(mixer_rgb_3_split[4]) + if (mixer_rgb_3_left == True and mixer_rgb_3_right == True): + # Gradient + self.color_rgb_l3 = [True, float(mixer_rgb_3_split[1]), float(mixer_rgb_3_split[2]), float(mixer_rgb_3_split[3])] + self.color_rgb_r3 = [True, float(mixer_rgb_3_split[5]), float(mixer_rgb_3_split[6]), float(mixer_rgb_3_split[7])] + color_rgb_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_l3[1]*255, self.color_rgb_l3[2]*255, self.color_rgb_l3[3]*255)) + color_rgb_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_r3[1]*255, self.color_rgb_r3[2]*255, self.color_rgb_r3[3]*255)) + self.layout.rgb_l3.setStyleSheet(color_rgb_left_3) + self.layout.rgb_r3.setStyleSheet(color_rgb_right_3) + elif (mixer_rgb_3_left == True and mixer_rgb_3_right != True): + # Color Left + self.color_rgb_l3 = [True, float(mixer_rgb_3_split[1]), float(mixer_rgb_3_split[2]), float(mixer_rgb_3_split[3])] + self.color_rgb_r3 = [False, 0, 0, 0] + color_rgb_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_l3[1]*255, self.color_rgb_l3[2]*255, self.color_rgb_l3[3]*255)) + self.layout.rgb_l3.setStyleSheet(color_rgb_left_3) + self.layout.rgb_r3.setStyleSheet(self.bg_alpha) + elif (mixer_rgb_3_left != True and mixer_rgb_3_right == True): + # Color Right + self.color_rgb_l3 = [False, 0, 0, 0] + self.color_rgb_r3 = [True, float(mixer_rgb_3_split[5]), float(mixer_rgb_3_split[6]), float(mixer_rgb_3_split[7])] + color_rgb_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (self.color_rgb_r3[1]*255, self.color_rgb_r3[2]*255, self.color_rgb_r3[3]*255)) + self.layout.rgb_l3.setStyleSheet(self.bg_alpha) + self.layout.rgb_r3.setStyleSheet(color_rgb_right_3) + except: + QtCore.qWarning("Pigment.O - Load Error - Mixer RGB") + #// + #\\ Mixer CMYK ######################################################### + try: + # Mixer CMYK 1 + mixer_cmyk_1_string = Krita.instance().readSetting("Pigment.O", "mix_CMYK_1", "") + mixer_cmyk_1_split = mixer_cmyk_1_string.split(",") + mixer_cmyk_1_left = eval(mixer_cmyk_1_split[0]) + mixer_cmyk_1_right = eval(mixer_cmyk_1_split[5]) + if (mixer_cmyk_1_left == True and mixer_cmyk_1_right == True): + # Gradient + self.color_cmyk_l1 = [True, float(mixer_cmyk_1_split[1]), float(mixer_cmyk_1_split[2]), float(mixer_cmyk_1_split[3]), float(mixer_cmyk_1_split[4])] + self.color_cmyk_r1 = [True, float(mixer_cmyk_1_split[6]), float(mixer_cmyk_1_split[7]), float(mixer_cmyk_1_split[8]), float(mixer_cmyk_1_split[9])] + rgb_cmyk_l1 = self.cmyk_to_rgb(self.color_cmyk_l1[1], self.color_cmyk_l1[2], self.color_cmyk_l1[3], self.color_cmyk_l1[4]) + rgb_cmyk_r1 = self.cmyk_to_rgb(self.color_cmyk_r1[1], self.color_cmyk_r1[2], self.color_cmyk_r1[3], self.color_cmyk_r1[4]) + color_cmyk_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_l1[0]*255, rgb_cmyk_l1[1]*255, rgb_cmyk_l1[2]*255)) + color_cmyk_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_r1[0]*255, rgb_cmyk_r1[1]*255, rgb_cmyk_r1[2]*255)) + self.layout.cmyk_l1.setStyleSheet(color_cmyk_left_1) + self.layout.cmyk_r1.setStyleSheet(color_cmyk_right_1) + elif (mixer_cmyk_1_left == True and mixer_cmyk_1_right != True): + # Color Left + self.color_cmyk_l1 = [True, float(mixer_cmyk_1_split[1]), float(mixer_cmyk_1_split[2]), float(mixer_cmyk_1_split[3]), float(mixer_cmyk_1_split[4])] + self.color_cmyk_r1 = [False, 0, 0, 0, 1] + rgb_cmyk_l1 = self.cmyk_to_rgb(self.color_cmyk_l1[1], self.color_cmyk_l1[2], self.color_cmyk_l1[3], self.color_cmyk_l1[4]) + color_cmyk_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_l1[0]*255, rgb_cmyk_l1[1]*255, rgb_cmyk_l1[2]*255)) + self.layout.cmyk_l1.setStyleSheet(color_cmyk_left_1) + self.layout.cmyk_r1.setStyleSheet(self.bg_alpha) + elif (mixer_cmyk_1_left != True and mixer_cmyk_1_right == True): + # Color Right + self.color_cmyk_l1 = [False, 0, 0, 0, 1] + self.color_cmyk_r1 = [True, float(mixer_cmyk_1_split[6]), float(mixer_cmyk_1_split[7]), float(mixer_cmyk_1_split[8]), float(mixer_cmyk_1_split[9])] + rgb_cmyk_r1 = self.cmyk_to_rgb(self.color_cmyk_r1[1], self.color_cmyk_r1[2], self.color_cmyk_r1[3], self.color_cmyk_r1[4]) + color_cmyk_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_r1[0]*255, rgb_cmyk_r1[1]*255, rgb_cmyk_r1[2]*255)) + self.layout.cmyk_l1.setStyleSheet(self.bg_alpha) + self.layout.cmyk_r1.setStyleSheet(color_cmyk_right_1) + # Mixer CMYK 2 + mixer_cmyk_2_string = Krita.instance().readSetting("Pigment.O", "mix_CMYK_2", "") + mixer_cmyk_2_split = mixer_cmyk_2_string.split(",") + mixer_cmyk_2_left = eval(mixer_cmyk_2_split[0]) + mixer_cmyk_2_right = eval(mixer_cmyk_2_split[5]) + if (mixer_cmyk_2_left == True and mixer_cmyk_2_right == True): + # Gradient + self.color_cmyk_l2 = [True, float(mixer_cmyk_2_split[1]), float(mixer_cmyk_2_split[2]), float(mixer_cmyk_2_split[3]), float(mixer_cmyk_2_split[4])] + self.color_cmyk_r2 = [True, float(mixer_cmyk_2_split[6]), float(mixer_cmyk_2_split[7]), float(mixer_cmyk_2_split[8]), float(mixer_cmyk_2_split[9])] + rgb_cmyk_l2 = self.cmyk_to_rgb(self.color_cmyk_l2[1], self.color_cmyk_l2[2], self.color_cmyk_l2[3], self.color_cmyk_l2[4]) + rgb_cmyk_r2 = self.cmyk_to_rgb(self.color_cmyk_r2[1], self.color_cmyk_r2[2], self.color_cmyk_r2[3], self.color_cmyk_r2[4]) + color_cmyk_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_l2[0]*255, rgb_cmyk_l2[1]*255, rgb_cmyk_l2[2]*255)) + color_cmyk_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_r2[0]*255, rgb_cmyk_r2[1]*255, rgb_cmyk_r2[2]*255)) + self.layout.cmyk_l2.setStyleSheet(color_cmyk_left_2) + self.layout.cmyk_r2.setStyleSheet(color_cmyk_right_2) + elif (mixer_cmyk_2_left == True and mixer_cmyk_2_right != True): + # Color Left + self.color_cmyk_l2 = [True, float(mixer_cmyk_2_split[1]), float(mixer_cmyk_2_split[2]), float(mixer_cmyk_2_split[3]), float(mixer_cmyk_2_split[4])] + self.color_cmyk_r2 = [False, 0, 0, 0, 1] + rgb_cmyk_l2 = self.cmyk_to_rgb(self.color_cmyk_l2[1], self.color_cmyk_l2[2], self.color_cmyk_l2[3], self.color_cmyk_l2[4]) + color_cmyk_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_l2[0]*255, rgb_cmyk_l2[1]*255, rgb_cmyk_l2[2]*255)) + self.layout.cmyk_l2.setStyleSheet(color_cmyk_left_2) + self.layout.cmyk_r2.setStyleSheet(self.bg_alpha) + elif (mixer_cmyk_2_left != True and mixer_cmyk_2_right == True): + # Color Right + self.color_cmyk_l2 = [False, 0, 0, 0, 1] + self.color_cmyk_r2 = [True, float(mixer_cmyk_2_split[6]), float(mixer_cmyk_2_split[7]), float(mixer_cmyk_2_split[8]), float(mixer_cmyk_2_split[9])] + rgb_cmyk_r2 = self.cmyk_to_rgb(self.color_cmyk_r2[1], self.color_cmyk_r2[2], self.color_cmyk_r2[3], self.color_cmyk_r2[4]) + color_cmyk_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_r2[0]*255, rgb_cmyk_r2[1]*255, rgb_cmyk_r2[2]*255)) + self.layout.cmyk_l2.setStyleSheet(self.bg_alpha) + self.layout.cmyk_r2.setStyleSheet(color_cmyk_right_2) + # Mixer CMYK 3 + mixer_cmyk_3_string = Krita.instance().readSetting("Pigment.O", "mix_CMYK_3", "") + mixer_cmyk_3_split = mixer_cmyk_3_string.split(",") + mixer_cmyk_3_left = eval(mixer_cmyk_3_split[0]) + mixer_cmyk_3_right = eval(mixer_cmyk_3_split[5]) + if (mixer_cmyk_3_left == True and mixer_cmyk_3_right == True): + # Gradient + self.color_cmyk_l3 = [True, float(mixer_cmyk_3_split[1]), float(mixer_cmyk_3_split[2]), float(mixer_cmyk_3_split[3]), float(mixer_cmyk_3_split[4])] + self.color_cmyk_r3 = [True, float(mixer_cmyk_3_split[6]), float(mixer_cmyk_3_split[7]), float(mixer_cmyk_3_split[8]), float(mixer_cmyk_3_split[9])] + rgb_cmyk_l3 = self.cmyk_to_rgb(self.color_cmyk_l3[1], self.color_cmyk_l3[2], self.color_cmyk_l3[3], self.color_cmyk_l3[4]) + rgb_cmyk_r3 = self.cmyk_to_rgb(self.color_cmyk_r3[1], self.color_cmyk_r3[2], self.color_cmyk_r3[3], self.color_cmyk_r3[4]) + color_cmyk_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_l3[0]*255, rgb_cmyk_l3[1]*255, rgb_cmyk_l3[2]*255)) + color_cmyk_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_r3[0]*255, rgb_cmyk_r3[1]*255, rgb_cmyk_r3[2]*255)) + self.layout.cmyk_l3.setStyleSheet(color_cmyk_left_3) + self.layout.cmyk_r3.setStyleSheet(color_cmyk_right_3) + elif (mixer_cmyk_3_left == True and mixer_cmyk_3_right != True): + # Color Left + self.color_cmyk_l3 = [True, float(mixer_cmyk_3_split[1]), float(mixer_cmyk_3_split[2]), float(mixer_cmyk_3_split[3]), float(mixer_cmyk_3_split[4])] + self.color_cmyk_r3 = [False, 0, 0, 0, 1] + rgb_cmyk_l3 = self.cmyk_to_rgb(self.color_cmyk_l3[1], self.color_cmyk_l3[2], self.color_cmyk_l3[3], self.color_cmyk_l3[4]) + color_cmyk_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_l3[0]*255, rgb_cmyk_l3[1]*255, rgb_cmyk_l3[2]*255)) + self.layout.cmyk_l3.setStyleSheet(color_cmyk_left_3) + self.layout.cmyk_r3.setStyleSheet(self.bg_alpha) + elif (mixer_cmyk_3_left != True and mixer_cmyk_3_right == True): + # Color Right + self.color_cmyk_l3 = [False, 0, 0, 0, 1] + self.color_cmyk_r3 = [True, float(mixer_cmyk_3_split[6]), float(mixer_cmyk_3_split[7]), float(mixer_cmyk_3_split[8]), float(mixer_cmyk_3_split[9])] + rgb_cmyk_r3 = self.cmyk_to_rgb(self.color_cmyk_r3[1], self.color_cmyk_r3[2], self.color_cmyk_r3[3], self.color_cmyk_r3[4]) + color_cmyk_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_cmyk_r3[0]*255, rgb_cmyk_r3[1]*255, rgb_cmyk_r3[2]*255)) + self.layout.cmyk_l3.setStyleSheet(self.bg_alpha) + self.layout.cmyk_r3.setStyleSheet(color_cmyk_right_3) + except: + QtCore.qWarning("Pigment.O - Load Error - Mixer CMYK") + #// + #\\ Mixer RYB ########################################################## + try: + # Mixer RYB 1 + mixer_ryb_1_string = Krita.instance().readSetting("Pigment.O", "mix_RYB_1", "") + mixer_ryb_1_split = mixer_ryb_1_string.split(",") + mixer_ryb_1_left = eval(mixer_ryb_1_split[0]) + mixer_ryb_1_right = eval(mixer_ryb_1_split[4]) + if (mixer_ryb_1_left == True and mixer_ryb_1_right == True): + # Gradient + self.color_ryb_l1 = [True, float(mixer_ryb_1_split[1]), float(mixer_ryb_1_split[2]), float(mixer_ryb_1_split[3])] + self.color_ryb_r1 = [True, float(mixer_ryb_1_split[5]), float(mixer_ryb_1_split[6]), float(mixer_ryb_1_split[7])] + rgb_ryb_l1 = self.ryb_to_rgb(self.color_ryb_l1[1], self.color_ryb_l1[2], self.color_ryb_l1[3]) + rgb_ryb_r1 = self.ryb_to_rgb(self.color_ryb_r1[1], self.color_ryb_r1[2], self.color_ryb_r1[3]) + color_ryb_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_l1[0]*255, rgb_ryb_l1[1]*255, rgb_ryb_l1[2]*255)) + color_ryb_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_r1[0]*255, rgb_ryb_r1[1]*255, rgb_ryb_r1[2]*255)) + self.layout.ryb_l1.setStyleSheet(color_ryb_left_1) + self.layout.ryb_r1.setStyleSheet(color_ryb_right_1) + elif (mixer_ryb_1_left == True and mixer_ryb_1_right != True): + # Color Left + self.color_ryb_l1 = [True, float(mixer_ryb_1_split[1]), float(mixer_ryb_1_split[2]), float(mixer_ryb_1_split[3])] + self.color_ryb_r1 = [False, 0, 0, 0] + rgb_ryb_l1 = self.ryb_to_rgb(self.color_ryb_l1[1], self.color_ryb_l1[2], self.color_ryb_l1[3]) + color_ryb_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_l1[0]*255, rgb_ryb_l1[1]*255, rgb_ryb_l1[2]*255)) + self.layout.ryb_l1.setStyleSheet(color_ryb_left_1) + self.layout.ryb_r1.setStyleSheet(self.bg_alpha) + elif (mixer_ryb_1_left != True and mixer_ryb_1_right == True): + # Color Right + self.color_ryb_l1 = [False, 0, 0, 0] + self.color_ryb_r1 = [True, float(mixer_ryb_1_split[5]), float(mixer_ryb_1_split[6]), float(mixer_ryb_1_split[7])] + rgb_ryb_r1 = self.ryb_to_rgb(self.color_ryb_r1[1], self.color_ryb_r1[2], self.color_ryb_r1[3]) + color_ryb_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_r1[0]*255, rgb_ryb_r1[1]*255, rgb_ryb_r1[2]*255)) + self.layout.ryb_l1.setStyleSheet(self.bg_alpha) + self.layout.ryb_r1.setStyleSheet(color_ryb_right_1) + # Mixer RYB 2 + mixer_ryb_2_string = Krita.instance().readSetting("Pigment.O", "mix_RYB_2", "") + mixer_ryb_2_split = mixer_ryb_2_string.split(",") + mixer_ryb_2_left = eval(mixer_ryb_2_split[0]) + mixer_ryb_2_right = eval(mixer_ryb_2_split[4]) + if (mixer_ryb_2_left == True and mixer_ryb_2_right == True): + # Gradient + self.color_ryb_l2 = [True, float(mixer_ryb_2_split[1]), float(mixer_ryb_2_split[2]), float(mixer_ryb_2_split[3])] + self.color_ryb_r2 = [True, float(mixer_ryb_2_split[5]), float(mixer_ryb_2_split[6]), float(mixer_ryb_2_split[7])] + rgb_ryb_l2 = self.ryb_to_rgb(self.color_ryb_l2[1], self.color_ryb_l2[2], self.color_ryb_l2[3]) + rgb_ryb_r2 = self.ryb_to_rgb(self.color_ryb_r2[1], self.color_ryb_r2[2], self.color_ryb_r2[3]) + color_ryb_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_l2[0]*255, rgb_ryb_l2[1]*255, rgb_ryb_l2[2]*255)) + color_ryb_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_r2[0]*255, rgb_ryb_r2[1]*255, rgb_ryb_r2[2]*255)) + self.layout.ryb_l2.setStyleSheet(color_ryb_left_2) + self.layout.ryb_r2.setStyleSheet(color_ryb_right_2) + elif (mixer_ryb_2_left == True and mixer_ryb_2_right != True): + # Color Left + self.color_ryb_l2 = [True, float(mixer_ryb_2_split[1]), float(mixer_ryb_2_split[2]), float(mixer_ryb_2_split[3])] + self.color_ryb_r2 = [False, 0, 0, 0] + rgb_ryb_l2 = self.ryb_to_rgb(self.color_ryb_l2[1], self.color_ryb_l2[2], self.color_ryb_l2[3]) + color_ryb_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_l2[0]*255, rgb_ryb_l2[1]*255, rgb_ryb_l2[2]*255)) + self.layout.ryb_l2.setStyleSheet(color_ryb_left_2) + self.layout.ryb_r2.setStyleSheet(self.bg_alpha) + elif (mixer_ryb_2_left != True and mixer_ryb_2_right == True): + # Color Right + self.color_ryb_l2 = [False, 0, 0, 0] + self.color_ryb_r2 = [True, float(mixer_ryb_2_split[5]), float(mixer_ryb_2_split[6]), float(mixer_ryb_2_split[7])] + rgb_ryb_r2 = self.ryb_to_rgb(self.color_ryb_r2[1], self.color_ryb_r2[2], self.color_ryb_r2[3]) + color_ryb_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_r2[0]*255, rgb_ryb_r2[1]*255, rgb_ryb_r2[2]*255)) + self.layout.ryb_l2.setStyleSheet(self.bg_alpha) + self.layout.ryb_r2.setStyleSheet(color_ryb_right_2) + # Mixer RYB 3 + mixer_ryb_3_string = Krita.instance().readSetting("Pigment.O", "mix_RYB_3", "") + mixer_ryb_3_split = mixer_ryb_3_string.split(",") + mixer_ryb_3_left = eval(mixer_ryb_3_split[0]) + mixer_ryb_3_right = eval(mixer_ryb_3_split[4]) + if (mixer_ryb_3_left == True and mixer_ryb_3_right == True): + # Gradient + self.color_ryb_l3 = [True, float(mixer_ryb_3_split[1]), float(mixer_ryb_3_split[2]), float(mixer_ryb_3_split[3])] + self.color_ryb_r3 = [True, float(mixer_ryb_3_split[5]), float(mixer_ryb_3_split[6]), float(mixer_ryb_3_split[7])] + rgb_ryb_l3 = self.ryb_to_rgb(self.color_ryb_l3[1], self.color_ryb_l3[2], self.color_ryb_l3[3]) + rgb_ryb_r3 = self.ryb_to_rgb(self.color_ryb_r3[1], self.color_ryb_r3[2], self.color_ryb_r3[3]) + color_ryb_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_l3[0]*255, rgb_ryb_l3[1]*255, rgb_ryb_l3[2]*255)) + color_ryb_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_r3[0]*255, rgb_ryb_r3[1]*255, rgb_ryb_r3[2]*255)) + self.layout.ryb_l3.setStyleSheet(color_ryb_left_3) + self.layout.ryb_r3.setStyleSheet(color_ryb_right_3) + elif (mixer_ryb_3_left == True and mixer_ryb_3_right != True): + # Color Left + self.color_ryb_l3 = [True, float(mixer_ryb_3_split[1]), float(mixer_ryb_3_split[2]), float(mixer_ryb_3_split[3])] + self.color_ryb_r3 = [False, 0, 0, 0] + rgb_ryb_l3 = self.ryb_to_rgb(self.color_ryb_l3[1], self.color_ryb_l3[2], self.color_ryb_l3[3]) + color_ryb_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_l3[0]*255, rgb_ryb_l3[1]*255, rgb_ryb_l3[2]*255)) + self.layout.ryb_l3.setStyleSheet(color_ryb_left_3) + self.layout.ryb_r3.setStyleSheet(self.bg_alpha) + elif (mixer_ryb_3_left != True and mixer_ryb_3_right == True): + # Color Right + self.color_ryb_l3 = [False, 0, 0, 0] + self.color_ryb_r3 = [True, float(mixer_ryb_3_split[5]), float(mixer_ryb_3_split[6]), float(mixer_ryb_3_split[7])] + rgb_ryb_r3 = self.ryb_to_rgb(self.color_ryb_r3[1], self.color_ryb_r3[2], self.color_ryb_r3[3]) + color_ryb_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ryb_r3[0]*255, rgb_ryb_r3[1]*255, rgb_ryb_r3[2]*255)) + self.layout.ryb_l3.setStyleSheet(self.bg_alpha) + self.layout.ryb_r3.setStyleSheet(color_ryb_right_3) + except: + QtCore.qWarning("Pigment.O - Load Error - Mixer RYB") + #// + #\\ Mixer YUV ########################################################## + try: + # Mixer YUV 1 + mixer_yuv_1_string = Krita.instance().readSetting("Pigment.O", "mix_YUV_1", "") + mixer_yuv_1_split = mixer_yuv_1_string.split(",") + mixer_yuv_1_left = eval(mixer_yuv_1_split[0]) + mixer_yuv_1_right = eval(mixer_yuv_1_split[4]) + if (mixer_yuv_1_left == True and mixer_yuv_1_right == True): + # Gradient + self.color_yuv_l1 = [True, float(mixer_yuv_1_split[1]), float(mixer_yuv_1_split[2]), float(mixer_yuv_1_split[3])] + self.color_yuv_r1 = [True, float(mixer_yuv_1_split[5]), float(mixer_yuv_1_split[6]), float(mixer_yuv_1_split[7])] + rgb_yuv_l1 = self.yuv_to_rgb(self.color_yuv_l1[1], self.color_yuv_l1[2], self.color_yuv_l1[3]) + rgb_yuv_r1 = self.yuv_to_rgb(self.color_yuv_r1[1], self.color_yuv_r1[2], self.color_yuv_r1[3]) + color_yuv_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_l1[0]*255, rgb_yuv_l1[1]*255, rgb_yuv_l1[2]*255)) + color_yuv_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_r1[0]*255, rgb_yuv_r1[1]*255, rgb_yuv_r1[2]*255)) + self.layout.yuv_l1.setStyleSheet(color_yuv_left_1) + self.layout.yuv_r1.setStyleSheet(color_yuv_right_1) + elif (mixer_yuv_1_left == True and mixer_yuv_1_right != True): + # Color Left + self.color_yuv_l1 = [True, float(mixer_yuv_1_split[1]), float(mixer_yuv_1_split[2]), float(mixer_yuv_1_split[3])] + self.color_yuv_r1 = [False, 0, 0.5, 0.5] + rgb_yuv_l1 = self.yuv_to_rgb(self.color_yuv_l1[1], self.color_yuv_l1[2], self.color_yuv_l1[3]) + color_yuv_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_l1[0]*255, rgb_yuv_l1[1]*255, rgb_yuv_l1[2]*255)) + self.layout.yuv_l1.setStyleSheet(color_yuv_left_1) + self.layout.yuv_r1.setStyleSheet(self.bg_alpha) + elif (mixer_yuv_1_left != True and mixer_yuv_1_right == True): + # Color Right + self.color_yuv_l1 = [False, 0, 0.5, 0.5] + self.color_yuv_r1 = [True, float(mixer_yuv_1_split[5]), float(mixer_yuv_1_split[6]), float(mixer_yuv_1_split[7])] + rgb_yuv_r1 = self.yuv_to_rgb(self.color_yuv_r1[1], self.color_yuv_r1[2], self.color_yuv_r1[3]) + color_yuv_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_r1[0]*255, rgb_yuv_r1[1]*255, rgb_yuv_r1[2]*255)) + self.layout.yuv_l1.setStyleSheet(self.bg_alpha) + self.layout.yuv_r1.setStyleSheet(color_yuv_right_1) + # Mixer YUV 2 + mixer_yuv_2_string = Krita.instance().readSetting("Pigment.O", "mix_YUV_2", "") + mixer_yuv_2_split = mixer_yuv_2_string.split(",") + mixer_yuv_2_left = eval(mixer_yuv_2_split[0]) + mixer_yuv_2_right = eval(mixer_yuv_2_split[4]) + if (mixer_yuv_2_left == True and mixer_yuv_2_right == True): + # Gradient + self.color_yuv_l2 = [True, float(mixer_yuv_2_split[1]), float(mixer_yuv_2_split[2]), float(mixer_yuv_2_split[3])] + self.color_yuv_r2 = [True, float(mixer_yuv_2_split[5]), float(mixer_yuv_2_split[6]), float(mixer_yuv_2_split[7])] + rgb_yuv_l2 = self.yuv_to_rgb(self.color_yuv_l2[1], self.color_yuv_l2[2], self.color_yuv_l2[3]) + rgb_yuv_r2 = self.yuv_to_rgb(self.color_yuv_r2[1], self.color_yuv_r2[2], self.color_yuv_r2[3]) + color_yuv_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_l2[0]*255, rgb_yuv_l2[1]*255, rgb_yuv_l2[2]*255)) + color_yuv_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_r2[0]*255, rgb_yuv_r2[1]*255, rgb_yuv_r2[2]*255)) + self.layout.yuv_l2.setStyleSheet(color_yuv_left_2) + self.layout.yuv_r2.setStyleSheet(color_yuv_right_2) + elif (mixer_yuv_2_left == True and mixer_yuv_2_right != True): + # Color Left + self.color_yuv_l2 = [True, float(mixer_yuv_2_split[1]), float(mixer_yuv_2_split[2]), float(mixer_yuv_2_split[3])] + self.color_yuv_r2 = [False, 0, 0.5, 0.5] + rgb_yuv_l2 = self.yuv_to_rgb(self.color_yuv_l2[1], self.color_yuv_l2[2], self.color_yuv_l2[3]) + color_yuv_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_l2[0]*255, rgb_yuv_l2[1]*255, rgb_yuv_l2[2]*255)) + self.layout.yuv_l2.setStyleSheet(color_yuv_left_2) + self.layout.yuv_r2.setStyleSheet(self.bg_alpha) + elif (mixer_yuv_2_left != True and mixer_yuv_2_right == True): + # Color Right + self.color_yuv_l2 = [False, 0, 0.5, 0.5] + self.color_yuv_r2 = [True, float(mixer_yuv_2_split[5]), float(mixer_yuv_2_split[6]), float(mixer_yuv_2_split[7])] + rgb_yuv_r2 = self.yuv_to_rgb(self.color_yuv_r2[1], self.color_yuv_r2[2], self.color_yuv_r2[3]) + color_yuv_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_r2[0]*255, rgb_yuv_r2[1]*255, rgb_yuv_r2[2]*255)) + self.layout.yuv_l2.setStyleSheet(self.bg_alpha) + self.layout.yuv_r2.setStyleSheet(color_yuv_right_2) + # Mixer YUV 3 + mixer_yuv_3_string = Krita.instance().readSetting("Pigment.O", "mix_YUV_3", "") + mixer_yuv_3_split = mixer_yuv_3_string.split(",") + mixer_yuv_3_left = eval(mixer_yuv_3_split[0]) + mixer_yuv_3_right = eval(mixer_yuv_3_split[4]) + if (mixer_yuv_3_left == True and mixer_yuv_3_right == True): + # Gradient + self.color_yuv_l3 = [True, float(mixer_yuv_3_split[1]), float(mixer_yuv_3_split[2]), float(mixer_yuv_3_split[3])] + self.color_yuv_r3 = [True, float(mixer_yuv_3_split[5]), float(mixer_yuv_3_split[6]), float(mixer_yuv_3_split[7])] + rgb_yuv_l3 = self.yuv_to_rgb(self.color_yuv_l3[1], self.color_yuv_l3[2], self.color_yuv_l3[3]) + rgb_yuv_r3 = self.yuv_to_rgb(self.color_yuv_r3[1], self.color_yuv_r3[2], self.color_yuv_r3[3]) + color_yuv_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_l3[0]*255, rgb_yuv_l3[1]*255, rgb_yuv_l3[2]*255)) + color_yuv_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_r3[0]*255, rgb_yuv_r3[1]*255, rgb_yuv_r3[2]*255)) + self.layout.yuv_l3.setStyleSheet(color_yuv_left_3) + self.layout.yuv_r3.setStyleSheet(color_yuv_right_3) + elif (mixer_yuv_3_left == True and mixer_yuv_3_right != True): + # Color Left + self.color_yuv_l3 = [True, float(mixer_yuv_3_split[1]), float(mixer_yuv_3_split[2]), float(mixer_yuv_3_split[3])] + self.color_yuv_r3 = [False, 0, 0.5, 0.5] + rgb_yuv_l3 = self.yuv_to_rgb(self.color_yuv_l3[1], self.color_yuv_l3[2], self.color_yuv_l3[3]) + color_yuv_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_l3[0]*255, rgb_yuv_l3[1]*255, rgb_yuv_l3[2]*255)) + self.layout.yuv_l3.setStyleSheet(color_yuv_left_3) + self.layout.yuv_r3.setStyleSheet(self.bg_alpha) + elif (mixer_yuv_3_left != True and mixer_yuv_3_right == True): + # Color Right + self.color_yuv_l3 = [False, 0, 0.5, 0.5] + self.color_yuv_r3 = [True, float(mixer_yuv_3_split[5]), float(mixer_yuv_3_split[6]), float(mixer_yuv_3_split[7])] + rgb_yuv_r3 = self.yuv_to_rgb(self.color_yuv_r3[1], self.color_yuv_r3[2], self.color_yuv_r3[3]) + color_yuv_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_yuv_r3[0]*255, rgb_yuv_r3[1]*255, rgb_yuv_r3[2]*255)) + self.layout.yuv_l3.setStyleSheet(self.bg_alpha) + self.layout.yuv_r3.setStyleSheet(color_yuv_right_3) + except: + QtCore.qWarning("Pigment.O - Load Error - Mixer YUV") + #// + #\\ Mixer ARD ########################################################## + try: + # Mixer ARD 1 + mixer_ard_1_string = Krita.instance().readSetting("Pigment.O", "mix_ARD_1", "") + mixer_ard_1_split = mixer_ard_1_string.split(",") + mixer_ard_1_left = eval(mixer_ard_1_split[0]) + mixer_ard_1_right = eval(mixer_ard_1_split[4]) + if (mixer_ard_1_left == True and mixer_ard_1_right == True): + # Gradient + self.color_ard_l1 = [True, float(mixer_ard_1_split[1]), float(mixer_ard_1_split[2]), float(mixer_ard_1_split[3])] + self.color_ard_r1 = [True, float(mixer_ard_1_split[5]), float(mixer_ard_1_split[6]), float(mixer_ard_1_split[7])] + rgb_ard_l1 = self.ard_to_rgb(self.color_ard_l1[1], self.color_ard_l1[2], self.color_ard_l1[3]) + rgb_ard_r1 = self.ard_to_rgb(self.color_ard_r1[1], self.color_ard_r1[2], self.color_ard_r1[3]) + color_ard_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_l1[0]*255, rgb_ard_l1[1]*255, rgb_ard_l1[2]*255)) + color_ard_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_r1[0]*255, rgb_ard_r1[1]*255, rgb_ard_r1[2]*255)) + self.layout.ard_l1.setStyleSheet(color_ard_left_1) + self.layout.ard_r1.setStyleSheet(color_ard_right_1) + elif (mixer_ard_1_left == True and mixer_ard_1_right != True): + # Color Left + self.color_ard_l1 = [True, float(mixer_ard_1_split[1]), float(mixer_ard_1_split[2]), float(mixer_ard_1_split[3])] + self.color_ard_r1 = [False, 0, 0, 0] + rgb_ard_l1 = self.ard_to_rgb(self.color_ard_l1[1], self.color_ard_l1[2], self.color_ard_l1[3]) + color_ard_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_l1[0]*255, rgb_ard_l1[1]*255, rgb_ard_l1[2]*255)) + self.layout.ard_l1.setStyleSheet(color_ard_left_1) + self.layout.ard_r1.setStyleSheet(self.bg_alpha) + elif (mixer_ard_1_left != True and mixer_ard_1_right == True): + # Color Right + self.color_ard_l1 = [False, 0, 0, 0] + self.color_ard_r1 = [True, float(mixer_ard_1_split[5]), float(mixer_ard_1_split[6]), float(mixer_ard_1_split[7])] + rgb_ard_r1 = self.ard_to_rgb(self.color_ard_r1[1], self.color_ard_r1[2], self.color_ard_r1[3]) + color_ard_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_r1[0]*255, rgb_ard_r1[1]*255, rgb_ard_r1[2]*255)) + self.layout.ard_l1.setStyleSheet(self.bg_alpha) + self.layout.ard_r1.setStyleSheet(color_ard_right_1) + # Mixer ARD 2 + mixer_ard_2_string = Krita.instance().readSetting("Pigment.O", "mix_ARD_2", "") + mixer_ard_2_split = mixer_ard_2_string.split(",") + mixer_ard_2_left = eval(mixer_ard_2_split[0]) + mixer_ard_2_right = eval(mixer_ard_2_split[4]) + if (mixer_ard_2_left == True and mixer_ard_2_right == True): + # Gradient + self.color_ard_l2 = [True, float(mixer_ard_2_split[1]), float(mixer_ard_2_split[2]), float(mixer_ard_2_split[3])] + self.color_ard_r2 = [True, float(mixer_ard_2_split[5]), float(mixer_ard_2_split[6]), float(mixer_ard_2_split[7])] + rgb_ard_l2 = self.ard_to_rgb(self.color_ard_l2[1], self.color_ard_l2[2], self.color_ard_l2[3]) + rgb_ard_r2 = self.ard_to_rgb(self.color_ard_r2[1], self.color_ard_r2[2], self.color_ard_r2[3]) + color_ard_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_l2[0]*255, rgb_ard_l2[1]*255, rgb_ard_l2[2]*255)) + color_ard_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_r2[0]*255, rgb_ard_r2[1]*255, rgb_ard_r2[2]*255)) + self.layout.ard_l2.setStyleSheet(color_ard_left_2) + self.layout.ard_r2.setStyleSheet(color_ard_right_2) + elif (mixer_ard_2_left == True and mixer_ard_2_right != True): + # Color Left + self.color_ard_l2 = [True, float(mixer_ard_2_split[1]), float(mixer_ard_2_split[2]), float(mixer_ard_2_split[3])] + self.color_ard_r2 = [False, 0, 0, 0] + rgb_ard_l2 = self.ard_to_rgb(self.color_ard_l2[1], self.color_ard_l2[2], self.color_ard_l2[3]) + color_ard_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_l2[0]*255, rgb_ard_l2[1]*255, rgb_ard_l2[2]*255)) + self.layout.ard_l2.setStyleSheet(color_ard_left_2) + self.layout.ard_r2.setStyleSheet(self.bg_alpha) + elif (mixer_ard_2_left != True and mixer_ard_2_right == True): + # Color Right + self.color_ard_l2 = [False, 0, 0, 0] + self.color_ard_r2 = [True, float(mixer_ard_2_split[5]), float(mixer_ard_2_split[6]), float(mixer_ard_2_split[7])] + rgb_ard_r2 = self.ard_to_rgb(self.color_ard_r2[1], self.color_ard_r2[2], self.color_ard_r2[3]) + color_ard_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_r2[0]*255, rgb_ard_r2[1]*255, rgb_ard_r2[2]*255)) + self.layout.ard_l2.setStyleSheet(self.bg_alpha) + self.layout.ard_r2.setStyleSheet(color_ard_right_2) + # Mixer ARD 3 + mixer_ard_3_string = Krita.instance().readSetting("Pigment.O", "mix_ARD_3", "") + mixer_ard_3_split = mixer_ard_3_string.split(",") + mixer_ard_3_left = eval(mixer_ard_3_split[0]) + mixer_ard_3_right = eval(mixer_ard_3_split[4]) + if (mixer_ard_3_left == True and mixer_ard_3_right == True): + # Gradient + self.color_ard_l3 = [True, float(mixer_ard_3_split[1]), float(mixer_ard_3_split[2]), float(mixer_ard_3_split[3])] + self.color_ard_r3 = [True, float(mixer_ard_3_split[5]), float(mixer_ard_3_split[6]), float(mixer_ard_3_split[7])] + rgb_ard_l3 = self.ard_to_rgb(self.color_ard_l3[1], self.color_ard_l3[2], self.color_ard_l3[3]) + rgb_ard_r3 = self.ard_to_rgb(self.color_ard_r3[1], self.color_ard_r3[2], self.color_ard_r3[3]) + color_ard_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_l3[0]*255, rgb_ard_l3[1]*255, rgb_ard_l3[2]*255)) + color_ard_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_r3[0]*255, rgb_ard_r3[1]*255, rgb_ard_r3[2]*255)) + self.layout.ard_l3.setStyleSheet(color_ard_left_3) + self.layout.ard_r3.setStyleSheet(color_ard_right_3) + elif (mixer_ard_3_left == True and mixer_ard_3_right != True): + # Color Left + self.color_ard_l3 = [True, float(mixer_ard_3_split[1]), float(mixer_ard_3_split[2]), float(mixer_ard_3_split[3])] + self.color_ard_r3 = [False, 0, 0, 0] + rgb_ard_l3 = self.ard_to_rgb(self.color_ard_l3[1], self.color_ard_l3[2], self.color_ard_l3[3]) + color_ard_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_l3[0]*255, rgb_ard_l3[1]*255, rgb_ard_l3[2]*255)) + self.layout.ard_l3.setStyleSheet(color_ard_left_3) + self.layout.ard_r3.setStyleSheet(self.bg_alpha) + elif (mixer_ard_3_left != True and mixer_ard_3_right == True): + # Color Right + self.color_ard_l3 = [False, 0, 0, 0] + self.color_ard_r3 = [True, float(mixer_ard_3_split[5]), float(mixer_ard_3_split[6]), float(mixer_ard_3_split[7])] + rgb_ard_r3 = self.ard_to_rgb(self.color_ard_r3[1], self.color_ard_r3[2], self.color_ard_r3[3]) + color_ard_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_ard_r3[0]*255, rgb_ard_r3[1]*255, rgb_ard_r3[2]*255)) + self.layout.ard_l3.setStyleSheet(self.bg_alpha) + self.layout.ard_r3.setStyleSheet(color_ard_right_3) + except: + QtCore.qWarning("Pigment.O - Load Error - Mixer ARD") + #// + #\\ Mixer HSV ########################################################## + try: + # Mixer HSV 1 + mixer_hsv_1_string = Krita.instance().readSetting("Pigment.O", "mix_HSV_1", "") + mixer_hsv_1_split = mixer_hsv_1_string.split(",") + mixer_hsv_1_left = eval(mixer_hsv_1_split[0]) + mixer_hsv_1_right = eval(mixer_hsv_1_split[4]) + if (mixer_hsv_1_left == True and mixer_hsv_1_right == True): + # Gradient + self.color_hsv_l1 = [True, float(mixer_hsv_1_split[1]), float(mixer_hsv_1_split[2]), float(mixer_hsv_1_split[3])] + self.color_hsv_r1 = [True, float(mixer_hsv_1_split[5]), float(mixer_hsv_1_split[6]), float(mixer_hsv_1_split[7])] + rgb_hsv_l1 = self.hsv_to_rgb(self.color_hsv_l1[1], self.color_hsv_l1[2], self.color_hsv_l1[3]) + rgb_hsv_r1 = self.hsv_to_rgb(self.color_hsv_r1[1], self.color_hsv_r1[2], self.color_hsv_r1[3]) + color_hsv_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_l1[0]*255, rgb_hsv_l1[1]*255, rgb_hsv_l1[2]*255)) + color_hsv_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_r1[0]*255, rgb_hsv_r1[1]*255, rgb_hsv_r1[2]*255)) + self.layout.hsv_l1.setStyleSheet(color_hsv_left_1) + self.layout.hsv_r1.setStyleSheet(color_hsv_right_1) + elif (mixer_hsv_1_left == True and mixer_hsv_1_right != True): + # Color Left + self.color_hsv_l1 = [True, float(mixer_hsv_1_split[1]), float(mixer_hsv_1_split[2]), float(mixer_hsv_1_split[3])] + self.color_hsv_r1 = [False, 0, 0, 0] + rgb_hsv_l1 = self.hsv_to_rgb(self.color_hsv_l1[1], self.color_hsv_l1[2], self.color_hsv_l1[3]) + color_hsv_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_l1[0]*255, rgb_hsv_l1[1]*255, rgb_hsv_l1[2]*255)) + self.layout.hsv_l1.setStyleSheet(color_hsv_left_1) + self.layout.hsv_r1.setStyleSheet(self.bg_alpha) + elif (mixer_hsv_1_left != True and mixer_hsv_1_right == True): + # Color Right + self.color_hsv_l1 = [False, 0, 0, 0] + self.color_hsv_r1 = [True, float(mixer_hsv_1_split[5]), float(mixer_hsv_1_split[6]), float(mixer_hsv_1_split[7])] + rgb_hsv_r1 = self.hsv_to_rgb(self.color_hsv_r1[1], self.color_hsv_r1[2], self.color_hsv_r1[3]) + color_hsv_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_r1[0]*255, rgb_hsv_r1[1]*255, rgb_hsv_r1[2]*255)) + self.layout.hsv_l1.setStyleSheet(self.bg_alpha) + self.layout.hsv_r1.setStyleSheet(color_hsv_right_1) + # Mixer HSV 2 + mixer_hsv_2_string = Krita.instance().readSetting("Pigment.O", "mix_HSV_2", "") + mixer_hsv_2_split = mixer_hsv_2_string.split(",") + mixer_hsv_2_left = eval(mixer_hsv_2_split[0]) + mixer_hsv_2_right = eval(mixer_hsv_2_split[4]) + if (mixer_hsv_2_left == True and mixer_hsv_2_right == True): + # Gradient + self.color_hsv_l2 = [True, float(mixer_hsv_2_split[1]), float(mixer_hsv_2_split[2]), float(mixer_hsv_2_split[3])] + self.color_hsv_r2 = [True, float(mixer_hsv_2_split[5]), float(mixer_hsv_2_split[6]), float(mixer_hsv_2_split[7])] + rgb_hsv_l2 = self.hsv_to_rgb(self.color_hsv_l2[1], self.color_hsv_l2[2], self.color_hsv_l2[3]) + rgb_hsv_r2 = self.hsv_to_rgb(self.color_hsv_r2[1], self.color_hsv_r2[2], self.color_hsv_r2[3]) + color_hsv_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_l2[0]*255, rgb_hsv_l2[1]*255, rgb_hsv_l2[2]*255)) + color_hsv_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_r2[0]*255, rgb_hsv_r2[1]*255, rgb_hsv_r2[2]*255)) + self.layout.hsv_l2.setStyleSheet(color_hsv_left_2) + self.layout.hsv_r2.setStyleSheet(color_hsv_right_2) + elif (mixer_hsv_2_left == True and mixer_hsv_2_right != True): + # Color Left + self.color_hsv_l2 = [True, float(mixer_hsv_2_split[1]), float(mixer_hsv_2_split[2]), float(mixer_hsv_2_split[3])] + self.color_hsv_r2 = [False, 0, 0, 0] + rgb_hsv_l2 = self.hsv_to_rgb(self.color_hsv_l2[1], self.color_hsv_l2[2], self.color_hsv_l2[3]) + color_hsv_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_l2[0]*255, rgb_hsv_l2[1]*255, rgb_hsv_l2[2]*255)) + self.layout.hsv_l2.setStyleSheet(color_hsv_left_2) + self.layout.hsv_r2.setStyleSheet(self.bg_alpha) + elif (mixer_hsv_2_left != True and mixer_hsv_2_right == True): + # Color Right + self.color_hsv_l2 = [False, 0, 0, 0] + self.color_hsv_r2 = [True, float(mixer_hsv_2_split[5]), float(mixer_hsv_2_split[6]), float(mixer_hsv_2_split[7])] + rgb_hsv_r2 = self.hsv_to_rgb(self.color_hsv_r2[1], self.color_hsv_r2[2], self.color_hsv_r2[3]) + color_hsv_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_r2[0]*255, rgb_hsv_r2[1]*255, rgb_hsv_r2[2]*255)) + self.layout.hsv_l2.setStyleSheet(self.bg_alpha) + self.layout.hsv_r2.setStyleSheet(color_hsv_right_2) + # Mixer HSV 3 + mixer_hsv_3_string = Krita.instance().readSetting("Pigment.O", "mix_HSV_3", "") + mixer_hsv_3_split = mixer_hsv_3_string.split(",") + mixer_hsv_3_left = eval(mixer_hsv_3_split[0]) + mixer_hsv_3_right = eval(mixer_hsv_3_split[4]) + if (mixer_hsv_3_left == True and mixer_hsv_3_right == True): + # Gradient + self.color_hsv_l3 = [True, float(mixer_hsv_3_split[1]), float(mixer_hsv_3_split[2]), float(mixer_hsv_3_split[3])] + self.color_hsv_r3 = [True, float(mixer_hsv_3_split[5]), float(mixer_hsv_3_split[6]), float(mixer_hsv_3_split[7])] + rgb_hsv_l3 = self.hsv_to_rgb(self.color_hsv_l3[1], self.color_hsv_l3[2], self.color_hsv_l3[3]) + rgb_hsv_r3 = self.hsv_to_rgb(self.color_hsv_r3[1], self.color_hsv_r3[2], self.color_hsv_r3[3]) + color_hsv_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_l3[0]*255, rgb_hsv_l3[1]*255, rgb_hsv_l3[2]*255)) + color_hsv_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_r3[0]*255, rgb_hsv_r3[1]*255, rgb_hsv_r3[2]*255)) + self.layout.hsv_l3.setStyleSheet(color_hsv_left_3) + self.layout.hsv_r3.setStyleSheet(color_hsv_right_3) + elif (mixer_hsv_3_left == True and mixer_hsv_3_right != True): + # Color Left + self.color_hsv_l3 = [True, float(mixer_hsv_3_split[1]), float(mixer_hsv_3_split[2]), float(mixer_hsv_3_split[3])] + self.color_hsv_r3 = [False, 0, 0, 0] + rgb_hsv_l3 = self.hsv_to_rgb(self.color_hsv_l3[1], self.color_hsv_l3[2], self.color_hsv_l3[3]) + color_hsv_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_l3[0]*255, rgb_hsv_l3[1]*255, rgb_hsv_l3[2]*255)) + self.layout.hsv_l3.setStyleSheet(color_hsv_left_3) + self.layout.hsv_r3.setStyleSheet(self.bg_alpha) + elif (mixer_hsv_3_left != True and mixer_hsv_3_right == True): + # Color Right + self.color_hsv_l3 = [False, 0, 0, 0] + self.color_hsv_r3 = [True, float(mixer_hsv_3_split[5]), float(mixer_hsv_3_split[6]), float(mixer_hsv_3_split[7])] + rgb_hsv_r3 = self.hsv_to_rgb(self.color_hsv_r3[1], self.color_hsv_r3[2], self.color_hsv_r3[3]) + color_hsv_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsv_r3[0]*255, rgb_hsv_r3[1]*255, rgb_hsv_r3[2]*255)) + self.layout.hsv_l3.setStyleSheet(self.bg_alpha) + self.layout.hsv_r3.setStyleSheet(color_hsv_right_3) + except: + QtCore.qWarning("Pigment.O - Load Error - Mixer HSV") + #// + #\\ Mixer HSL ########################################################## + try: + # Mixer HSL 1 + mixer_hsl_1_string = Krita.instance().readSetting("Pigment.O", "mix_HSL_1", "") + mixer_hsl_1_split = mixer_hsl_1_string.split(",") + mixer_hsl_1_left = eval(mixer_hsl_1_split[0]) + mixer_hsl_1_right = eval(mixer_hsl_1_split[4]) + if (mixer_hsl_1_left == True and mixer_hsl_1_right == True): + # Gradient + self.color_hsl_l1 = [True, float(mixer_hsl_1_split[1]), float(mixer_hsl_1_split[2]), float(mixer_hsl_1_split[3])] + self.color_hsl_r1 = [True, float(mixer_hsl_1_split[5]), float(mixer_hsl_1_split[6]), float(mixer_hsl_1_split[7])] + rgb_hsl_l1 = self.hsl_to_rgb(self.color_hsl_l1[1], self.color_hsl_l1[2], self.color_hsl_l1[3]) + rgb_hsl_r1 = self.hsl_to_rgb(self.color_hsl_r1[1], self.color_hsl_r1[2], self.color_hsl_r1[3]) + color_hsl_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_l1[0]*255, rgb_hsl_l1[1]*255, rgb_hsl_l1[2]*255)) + color_hsl_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_r1[0]*255, rgb_hsl_r1[1]*255, rgb_hsl_r1[2]*255)) + self.layout.hsl_l1.setStyleSheet(color_hsl_left_1) + self.layout.hsl_r1.setStyleSheet(color_hsl_right_1) + elif (mixer_hsl_1_left == True and mixer_hsl_1_right != True): + # Color Left + self.color_hsl_l1 = [True, float(mixer_hsl_1_split[1]), float(mixer_hsl_1_split[2]), float(mixer_hsl_1_split[3])] + self.color_hsl_r1 = [False, 0, 0, 0] + rgb_hsl_l1 = self.hsl_to_rgb(self.color_hsl_l1[1], self.color_hsl_l1[2], self.color_hsl_l1[3]) + color_hsl_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_l1[0]*255, rgb_hsl_l1[1]*255, rgb_hsl_l1[2]*255)) + self.layout.hsl_l1.setStyleSheet(color_hsl_left_1) + self.layout.hsl_r1.setStyleSheet(self.bg_alpha) + elif (mixer_hsl_1_left != True and mixer_hsl_1_right == True): + # Color Right + self.color_hsl_l1 = [False, 0, 0, 0] + self.color_hsl_r1 = [True, float(mixer_hsl_1_split[5]), float(mixer_hsl_1_split[6]), float(mixer_hsl_1_split[7])] + rgb_hsl_r1 = self.hsl_to_rgb(self.color_hsl_r1[1], self.color_hsl_r1[2], self.color_hsl_r1[3]) + color_hsl_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_r1[0]*255, rgb_hsl_r1[1]*255, rgb_hsl_r1[2]*255)) + self.layout.hsl_l1.setStyleSheet(self.bg_alpha) + self.layout.hsl_r1.setStyleSheet(color_hsl_right_1) + # Mixer HSL 2 + mixer_hsl_2_string = Krita.instance().readSetting("Pigment.O", "mix_HSL_2", "") + mixer_hsl_2_split = mixer_hsl_2_string.split(",") + mixer_hsl_2_left = eval(mixer_hsl_2_split[0]) + mixer_hsl_2_right = eval(mixer_hsl_2_split[4]) + if (mixer_hsl_2_left == True and mixer_hsl_2_right == True): + # Gradient + self.color_hsl_l2 = [True, float(mixer_hsl_2_split[1]), float(mixer_hsl_2_split[2]), float(mixer_hsl_2_split[3])] + self.color_hsl_r2 = [True, float(mixer_hsl_2_split[5]), float(mixer_hsl_2_split[6]), float(mixer_hsl_2_split[7])] + rgb_hsl_l2 = self.hsl_to_rgb(self.color_hsl_l2[1], self.color_hsl_l2[2], self.color_hsl_l2[3]) + rgb_hsl_r2 = self.hsl_to_rgb(self.color_hsl_r2[1], self.color_hsl_r2[2], self.color_hsl_r2[3]) + color_hsl_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_l2[0]*255, rgb_hsl_l2[1]*255, rgb_hsl_l2[2]*255)) + color_hsl_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_r2[0]*255, rgb_hsl_r2[1]*255, rgb_hsl_r2[2]*255)) + self.layout.hsl_l2.setStyleSheet(color_hsl_left_2) + self.layout.hsl_r2.setStyleSheet(color_hsl_right_2) + elif (mixer_hsl_2_left == True and mixer_hsl_2_right != True): + # Color Left + self.color_hsl_l2 = [True, float(mixer_hsl_2_split[1]), float(mixer_hsl_2_split[2]), float(mixer_hsl_2_split[3])] + self.color_hsl_r2 = [False, 0, 0, 0] + rgb_hsl_l2 = self.hsl_to_rgb(self.color_hsl_l2[1], self.color_hsl_l2[2], self.color_hsl_l2[3]) + color_hsl_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_l2[0]*255, rgb_hsl_l2[1]*255, rgb_hsl_l2[2]*255)) + self.layout.hsl_l2.setStyleSheet(color_hsl_left_2) + self.layout.hsl_r2.setStyleSheet(self.bg_alpha) + elif (mixer_hsl_2_left != True and mixer_hsl_2_right == True): + # Color Right + self.color_hsl_l2 = [False, 0, 0, 0] + self.color_hsl_r2 = [True, float(mixer_hsl_2_split[5]), float(mixer_hsl_2_split[6]), float(mixer_hsl_2_split[7])] + rgb_hsl_r2 = self.hsl_to_rgb(self.color_hsl_r2[1], self.color_hsl_r2[2], self.color_hsl_r2[3]) + color_hsl_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_r2[0]*255, rgb_hsl_r2[1]*255, rgb_hsl_r2[2]*255)) + self.layout.hsl_l2.setStyleSheet(self.bg_alpha) + self.layout.hsl_r2.setStyleSheet(color_hsl_right_2) + # Mixer HSL 3 + mixer_hsl_3_string = Krita.instance().readSetting("Pigment.O", "mix_HSL_3", "") + mixer_hsl_3_split = mixer_hsl_3_string.split(",") + mixer_hsl_3_left = eval(mixer_hsl_3_split[0]) + mixer_hsl_3_right = eval(mixer_hsl_3_split[4]) + if (mixer_hsl_3_left == True and mixer_hsl_3_right == True): + # Gradient + self.color_hsl_l3 = [True, float(mixer_hsl_3_split[1]), float(mixer_hsl_3_split[2]), float(mixer_hsl_3_split[3])] + self.color_hsl_r3 = [True, float(mixer_hsl_3_split[5]), float(mixer_hsl_3_split[6]), float(mixer_hsl_3_split[7])] + rgb_hsl_l3 = self.hsl_to_rgb(self.color_hsl_l3[1], self.color_hsl_l3[2], self.color_hsl_l3[3]) + rgb_hsl_r3 = self.hsl_to_rgb(self.color_hsl_r3[1], self.color_hsl_r3[2], self.color_hsl_r3[3]) + color_hsl_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_l3[0]*255, rgb_hsl_l3[1]*255, rgb_hsl_l3[2]*255)) + color_hsl_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_r3[0]*255, rgb_hsl_r3[1]*255, rgb_hsl_r3[2]*255)) + self.layout.hsl_l3.setStyleSheet(color_hsl_left_3) + self.layout.hsl_r3.setStyleSheet(color_hsl_right_3) + elif (mixer_hsl_3_left == True and mixer_hsl_3_right != True): + # Color Left + self.color_hsl_l3 = [True, float(mixer_hsl_3_split[1]), float(mixer_hsl_3_split[2]), float(mixer_hsl_3_split[3])] + self.color_hsl_r3 = [False, 0, 0, 0] + rgb_hsl_l3 = self.hsl_to_rgb(self.color_hsl_l3[1], self.color_hsl_l3[2], self.color_hsl_l3[3]) + color_hsl_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_l3[0]*255, rgb_hsl_l3[1]*255, rgb_hsl_l3[2]*255)) + self.layout.hsl_l3.setStyleSheet(color_hsl_left_3) + self.layout.hsl_r3.setStyleSheet(self.bg_alpha) + elif (mixer_hsl_3_left != True and mixer_hsl_3_right == True): + # Color Right + self.color_hsl_l3 = [False, 0, 0, 0] + self.color_hsl_r3 = [True, float(mixer_hsl_3_split[5]), float(mixer_hsl_3_split[6]), float(mixer_hsl_3_split[7])] + rgb_hsl_r3 = self.hsl_to_rgb(self.color_hsl_r3[1], self.color_hsl_r3[2], self.color_hsl_r3[3]) + color_hsl_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hsl_r3[0]*255, rgb_hsl_r3[1]*255, rgb_hsl_r3[2]*255)) + self.layout.hsl_l3.setStyleSheet(self.bg_alpha) + self.layout.hsl_r3.setStyleSheet(color_hsl_right_3) + except: + QtCore.qWarning("Pigment.O - Load Error - Mixer HSL") + #// + #\\ Mixer HCY ########################################################## + try: + # Mixer HCY 1 + mixer_hcy_1_string = Krita.instance().readSetting("Pigment.O", "mix_HCY_1", "") + mixer_hcy_1_split = mixer_hcy_1_string.split(",") + mixer_hcy_1_left = eval(mixer_hcy_1_split[0]) + mixer_hcy_1_right = eval(mixer_hcy_1_split[4]) + if (mixer_hcy_1_left == True and mixer_hcy_1_right == True): + # Gradient + self.color_hcy_l1 = [True, float(mixer_hcy_1_split[1]), float(mixer_hcy_1_split[2]), float(mixer_hcy_1_split[3])] + self.color_hcy_r1 = [True, float(mixer_hcy_1_split[5]), float(mixer_hcy_1_split[6]), float(mixer_hcy_1_split[7])] + rgb_hcy_l1 = self.hcy_to_rgb(self.color_hcy_l1[1], self.color_hcy_l1[2], self.color_hcy_l1[3]) + rgb_hcy_r1 = self.hcy_to_rgb(self.color_hcy_r1[1], self.color_hcy_r1[2], self.color_hcy_r1[3]) + color_hcy_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_l1[0]*255, rgb_hcy_l1[1]*255, rgb_hcy_l1[2]*255)) + color_hcy_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_r1[0]*255, rgb_hcy_r1[1]*255, rgb_hcy_r1[2]*255)) + self.layout.hcy_l1.setStyleSheet(color_hcy_left_1) + self.layout.hcy_r1.setStyleSheet(color_hcy_right_1) + elif (mixer_hcy_1_left == True and mixer_hcy_1_right != True): + # Color Left + self.color_hcy_l1 = [True, float(mixer_hcy_1_split[1]), float(mixer_hcy_1_split[2]), float(mixer_hcy_1_split[3])] + self.color_hcy_r1 = [False, 0, 0, 0] + rgb_hcy_l1 = self.hcy_to_rgb(self.color_hcy_l1[1], self.color_hcy_l1[2], self.color_hcy_l1[3]) + color_hcy_left_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_l1[0]*255, rgb_hcy_l1[1]*255, rgb_hcy_l1[2]*255)) + self.layout.hcy_l1.setStyleSheet(color_hcy_left_1) + self.layout.hcy_r1.setStyleSheet(self.bg_alpha) + elif (mixer_hcy_1_left != True and mixer_hcy_1_right == True): + # Color Right + self.color_hcy_l1 = [False, 0, 0, 0] + self.color_hcy_r1 = [True, float(mixer_hcy_1_split[5]), float(mixer_hcy_1_split[6]), float(mixer_hcy_1_split[7])] + rgb_hcy_r1 = self.hcy_to_rgb(self.color_hcy_r1[1], self.color_hcy_r1[2], self.color_hcy_r1[3]) + color_hcy_right_1 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_r1[0]*255, rgb_hcy_r1[1]*255, rgb_hcy_r1[2]*255)) + self.layout.hcy_l1.setStyleSheet(self.bg_alpha) + self.layout.hcy_r1.setStyleSheet(color_hcy_right_1) + # Mixer HCY 2 + mixer_hcy_2_string = Krita.instance().readSetting("Pigment.O", "mix_HCY_2", "") + mixer_hcy_2_split = mixer_hcy_2_string.split(",") + mixer_hcy_2_left = eval(mixer_hcy_2_split[0]) + mixer_hcy_2_right = eval(mixer_hcy_2_split[4]) + if (mixer_hcy_2_left == True and mixer_hcy_2_right == True): + # Gradient + self.color_hcy_l2 = [True, float(mixer_hcy_2_split[1]), float(mixer_hcy_2_split[2]), float(mixer_hcy_2_split[3])] + self.color_hcy_r2 = [True, float(mixer_hcy_2_split[5]), float(mixer_hcy_2_split[6]), float(mixer_hcy_2_split[7])] + rgb_hcy_l2 = self.hcy_to_rgb(self.color_hcy_l2[1], self.color_hcy_l2[2], self.color_hcy_l2[3]) + rgb_hcy_r2 = self.hcy_to_rgb(self.color_hcy_r2[1], self.color_hcy_r2[2], self.color_hcy_r2[3]) + color_hcy_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_l2[0]*255, rgb_hcy_l2[1]*255, rgb_hcy_l2[2]*255)) + color_hcy_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_r2[0]*255, rgb_hcy_r2[1]*255, rgb_hcy_r2[2]*255)) + self.layout.hcy_l2.setStyleSheet(color_hcy_left_2) + self.layout.hcy_r2.setStyleSheet(color_hcy_right_2) + elif (mixer_hcy_2_left == True and mixer_hcy_2_right != True): + # Color Left + self.color_hcy_l2 = [True, float(mixer_hcy_2_split[1]), float(mixer_hcy_2_split[2]), float(mixer_hcy_2_split[3])] + self.color_hcy_r2 = [False, 0, 0, 0] + rgb_hcy_l2 = self.hcy_to_rgb(self.color_hcy_l2[1], self.color_hcy_l2[2], self.color_hcy_l2[3]) + color_hcy_left_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_l2[0]*255, rgb_hcy_l2[1]*255, rgb_hcy_l2[2]*255)) + self.layout.hcy_l2.setStyleSheet(color_hcy_left_2) + self.layout.hcy_r2.setStyleSheet(self.bg_alpha) + elif (mixer_hcy_2_left != True and mixer_hcy_2_right == True): + # Color Right + self.color_hcy_l2 = [False, 0, 0, 0] + self.color_hcy_r2 = [True, float(mixer_hcy_2_split[5]), float(mixer_hcy_2_split[6]), float(mixer_hcy_2_split[7])] + rgb_hcy_r2 = self.hcy_to_rgb(self.color_hcy_r2[1], self.color_hcy_r2[2], self.color_hcy_r2[3]) + color_hcy_right_2 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_r2[0]*255, rgb_hcy_r2[1]*255, rgb_hcy_r2[2]*255)) + self.layout.hcy_l2.setStyleSheet(self.bg_alpha) + self.layout.hcy_r2.setStyleSheet(color_hcy_right_2) + # Mixer HCY 3 + mixer_hcy_3_string = Krita.instance().readSetting("Pigment.O", "mix_HCY_3", "") + mixer_hcy_3_split = mixer_hcy_3_string.split(",") + mixer_hcy_3_left = eval(mixer_hcy_3_split[0]) + mixer_hcy_3_right = eval(mixer_hcy_3_split[4]) + if (mixer_hcy_3_left == True and mixer_hcy_3_right == True): + # Gradient + self.color_hcy_l3 = [True, float(mixer_hcy_3_split[1]), float(mixer_hcy_3_split[2]), float(mixer_hcy_3_split[3])] + self.color_hcy_r3 = [True, float(mixer_hcy_3_split[5]), float(mixer_hcy_3_split[6]), float(mixer_hcy_3_split[7])] + rgb_hcy_l3 = self.hcy_to_rgb(self.color_hcy_l3[1], self.color_hcy_l3[2], self.color_hcy_l3[3]) + rgb_hcy_r3 = self.hcy_to_rgb(self.color_hcy_r3[1], self.color_hcy_r3[2], self.color_hcy_r3[3]) + color_hcy_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_l3[0]*255, rgb_hcy_l3[1]*255, rgb_hcy_l3[2]*255)) + color_hcy_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_r3[0]*255, rgb_hcy_r3[1]*255, rgb_hcy_r3[2]*255)) + self.layout.hcy_l3.setStyleSheet(color_hcy_left_3) + self.layout.hcy_r3.setStyleSheet(color_hcy_right_3) + elif (mixer_hcy_3_left == True and mixer_hcy_3_right != True): + # Color Left + self.color_hcy_l3 = [True, float(mixer_hcy_3_split[1]), float(mixer_hcy_3_split[2]), float(mixer_hcy_3_split[3])] + self.color_hcy_r3 = [False, 0, 0, 0] + rgb_hcy_l3 = self.hcy_to_rgb(self.color_hcy_l3[1], self.color_hcy_l3[2], self.color_hcy_l3[3]) + color_hcy_left_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_l3[0]*255, rgb_hcy_l3[1]*255, rgb_hcy_l3[2]*255)) + self.layout.hcy_l3.setStyleSheet(color_hcy_left_3) + self.layout.hcy_r3.setStyleSheet(self.bg_alpha) + elif (mixer_hcy_3_left != True and mixer_hcy_3_right == True): + # Color Right + self.color_hcy_l3 = [False, 0, 0, 0] + self.color_hcy_r3 = [True, float(mixer_hcy_3_split[5]), float(mixer_hcy_3_split[6]), float(mixer_hcy_3_split[7])] + rgb_hcy_r3 = self.hcy_to_rgb(self.color_hcy_r3[1], self.color_hcy_r3[2], self.color_hcy_r3[3]) + color_hcy_right_3 = str("background-color: rgb(%f, %f, %f); border: 1px solid rgba(56, 56, 56, 255) ;" % (rgb_hcy_r3[0]*255, rgb_hcy_r3[1]*255, rgb_hcy_r3[2]*255)) + self.layout.hcy_l3.setStyleSheet(self.bg_alpha) + self.layout.hcy_r3.setStyleSheet(color_hcy_right_3) + except: + QtCore.qWarning("Pigment.O - Load Error - Mixer HCY") + #// + #\\ Mixer Gradient Display ############################################# + self.Mixer_Display() + + #// + def Settings_Save_Misc(self): + #\\ Panel GAM ########################################################## + gam_list_p1s1 = ( + str(self.P1_S1[0]), str(self.P1_S1[1]), + str(self.P1_S1[2]), str(self.P1_S1[3]), + str(self.P1_S1[4]), str(self.P1_S1[5]), + str(self.P1_S1[6]), str(self.P1_S1[7]), + ) + gam_list_p1s3 = ( + str(self.P1_S3[0]), str(self.P1_S3[1]), + str(self.P1_S3[2]), str(self.P1_S3[3]), + str(self.P1_S3[4]), str(self.P1_S3[5]), + ) + gam_list_p1s4 = ( + str(self.P1_S4[0]), str(self.P1_S4[1]), + str(self.P1_S4[2]), str(self.P1_S4[3]), + str(self.P1_S4[4]), str(self.P1_S4[5]), + str(self.P1_S4[6]), str(self.P1_S4[7]), + ) + gam_list_p2s1 = ( + str(self.P2_S1[0]), str(self.P2_S1[1]), + str(self.P2_S1[2]), str(self.P2_S1[3]), + str(self.P2_S1[4]), str(self.P2_S1[5]), + str(self.P2_S1[6]), str(self.P2_S1[7]), + str(self.P2_S1[8]), str(self.P2_S1[9]), + str(self.P2_S1[10]), str(self.P2_S1[11]), + str(self.P2_S1[12]), str(self.P2_S1[13]), + str(self.P2_S1[14]), str(self.P2_S1[15]), + ) + gam_list_p3s3 = ( + str(self.P3_S3[0]), str(self.P3_S3[1]), + str(self.P3_S3[2]), str(self.P3_S3[3]), + str(self.P3_S3[4]), str(self.P3_S3[5]), + str(self.P3_S3[6]), str(self.P3_S3[7]), + str(self.P3_S3[8]), str(self.P3_S3[9]), + str(self.P3_S3[10]), str(self.P3_S3[11]), + str(self.P3_S3[12]), str(self.P3_S3[13]), + ) + gam_string_p1s1 = ','.join(gam_list_p1s1) + gam_string_p1s3 = ','.join(gam_list_p1s3) + gam_string_p1s4 = ','.join(gam_list_p1s4) + gam_string_p2s1 = ','.join(gam_list_p2s1) + gam_string_p3s3 = ','.join(gam_list_p3s3) + Krita.instance().writeSetting("Pigment.O", "gam_p1s1", gam_string_p1s1) + Krita.instance().writeSetting("Pigment.O", "gam_p1s3", gam_string_p1s3) + Krita.instance().writeSetting("Pigment.O", "gam_p1s4", gam_string_p1s4) + Krita.instance().writeSetting("Pigment.O", "gam_p2s1", gam_string_p2s1) + Krita.instance().writeSetting("Pigment.O", "gam_p3s3", gam_string_p3s3) + #// + #\\ Panel DOT ########################################################## + dot_list_01 = ( str(self.dot_1[0]), str(self.dot_1[1]), str(self.dot_1[2]), str(self.dot_1[3]), str(self.dot_1[4]), str(self.dot_1[5]), str(self.dot_1[6]) ) + dot_list_02 = ( str(self.dot_2[0]), str(self.dot_2[1]), str(self.dot_2[2]), str(self.dot_2[3]), str(self.dot_2[4]), str(self.dot_2[5]), str(self.dot_2[6]) ) + dot_list_03 = ( str(self.dot_3[0]), str(self.dot_3[1]), str(self.dot_3[2]), str(self.dot_3[3]), str(self.dot_3[4]), str(self.dot_3[5]), str(self.dot_3[6]) ) + dot_list_04 = ( str(self.dot_4[0]), str(self.dot_4[1]), str(self.dot_4[2]), str(self.dot_4[3]), str(self.dot_4[4]), str(self.dot_4[5]), str(self.dot_4[6]) ) + dot_string_01 = ','.join(dot_list_01) + dot_string_02 = ','.join(dot_list_02) + dot_string_03 = ','.join(dot_list_03) + dot_string_04 = ','.join(dot_list_04) + Krita.instance().writeSetting("Pigment.O", "dot_01", dot_string_01) + Krita.instance().writeSetting("Pigment.O", "dot_02", dot_string_02) + Krita.instance().writeSetting("Pigment.O", "dot_03", dot_string_03) + Krita.instance().writeSetting("Pigment.O", "dot_04", dot_string_04) + #// + #\\ Panel OBJ ########################################################## + object_00_list = ( + str(self.bg_1[0][0]), str(self.bg_1[0][1]), str(self.bg_1[0][2]), str(self.bg_1[0][3]), str(self.bg_1[0][4]), + str(self.bg_2[0][0]), str(self.bg_2[0][1]), str(self.bg_2[0][2]), str(self.bg_2[0][3]), str(self.bg_2[0][4]), + str(self.bg_3[0][0]), str(self.bg_3[0][1]), str(self.bg_3[0][2]), str(self.bg_3[0][3]), str(self.bg_3[0][4]), + str(self.dif_1[0][0]), str(self.dif_1[0][1]), str(self.dif_1[0][2]), str(self.dif_1[0][3]), str(self.dif_1[0][4]), + str(self.dif_2[0][0]), str(self.dif_2[0][1]), str(self.dif_2[0][2]), str(self.dif_2[0][3]), str(self.dif_2[0][4]), + str(self.dif_3[0][0]), str(self.dif_3[0][1]), str(self.dif_3[0][2]), str(self.dif_3[0][3]), str(self.dif_3[0][4]), + str(self.dif_4[0][0]), str(self.dif_4[0][1]), str(self.dif_4[0][2]), str(self.dif_4[0][3]), str(self.dif_4[0][4]), + str(self.dif_5[0][0]), str(self.dif_5[0][1]), str(self.dif_5[0][2]), str(self.dif_5[0][3]), str(self.dif_5[0][4]), + str(self.dif_6[0][0]), str(self.dif_6[0][1]), str(self.dif_6[0][2]), str(self.dif_6[0][3]), str(self.dif_6[0][4]), + str(self.fg_1[0][0]), str(self.fg_1[0][1]), str(self.fg_1[0][2]), str(self.fg_1[0][3]), str(self.fg_1[0][4]), + str(self.fg_2[0][0]), str(self.fg_2[0][1]), str(self.fg_2[0][2]), str(self.fg_2[0][3]), str(self.fg_2[0][4]), + str(self.fg_3[0][0]), str(self.fg_3[0][1]), str(self.fg_3[0][2]), str(self.fg_3[0][3]), str(self.fg_3[0][4]), + ) + object_00_string = ','.join(object_00_list) + Krita.instance().writeSetting("Pigment.O", "obj_00", object_00_string) + + object_01_list = ( + str(self.bg_1[1][0]), str(self.bg_1[1][1]), str(self.bg_1[1][2]), str(self.bg_1[1][3]), str(self.bg_1[1][4]), + str(self.bg_2[1][0]), str(self.bg_2[1][1]), str(self.bg_2[1][2]), str(self.bg_2[1][3]), str(self.bg_2[1][4]), + str(self.bg_3[1][0]), str(self.bg_3[1][1]), str(self.bg_3[1][2]), str(self.bg_3[1][3]), str(self.bg_3[1][4]), + str(self.dif_1[1][0]), str(self.dif_1[1][1]), str(self.dif_1[1][2]), str(self.dif_1[1][3]), str(self.dif_1[1][4]), + str(self.dif_2[1][0]), str(self.dif_2[1][1]), str(self.dif_2[1][2]), str(self.dif_2[1][3]), str(self.dif_2[1][4]), + str(self.dif_3[1][0]), str(self.dif_3[1][1]), str(self.dif_3[1][2]), str(self.dif_3[1][3]), str(self.dif_3[1][4]), + str(self.dif_4[1][0]), str(self.dif_4[1][1]), str(self.dif_4[1][2]), str(self.dif_4[1][3]), str(self.dif_4[1][4]), + str(self.dif_5[1][0]), str(self.dif_5[1][1]), str(self.dif_5[1][2]), str(self.dif_5[1][3]), str(self.dif_5[1][4]), + str(self.dif_6[1][0]), str(self.dif_6[1][1]), str(self.dif_6[1][2]), str(self.dif_6[1][3]), str(self.dif_6[1][4]), + str(self.fg_1[1][0]), str(self.fg_1[1][1]), str(self.fg_1[1][2]), str(self.fg_1[1][3]), str(self.fg_1[1][4]), + str(self.fg_2[1][0]), str(self.fg_2[1][1]), str(self.fg_2[1][2]), str(self.fg_2[1][3]), str(self.fg_2[1][4]), + str(self.fg_3[1][0]), str(self.fg_3[1][1]), str(self.fg_3[1][2]), str(self.fg_3[1][3]), str(self.fg_3[1][4]), + ) + object_01_string = ','.join(object_01_list) + Krita.instance().writeSetting("Pigment.O", "obj_01", object_01_string) + #// + #\\ Panel IMG ########################################################## + Krita.instance().writeSetting("Pigment.O", "img_state", self.img_state) + + #// + #\\ COR ################################################################ + cor_00_list = (str(self.cor_00[0]), str(self.cor_00[1]), str(self.cor_00[2]), str(self.cor_00[3])) + cor_01_list = (str(self.cor_01[0]), str(self.cor_01[1]), str(self.cor_01[2]), str(self.cor_01[3])) + cor_02_list = (str(self.cor_02[0]), str(self.cor_02[1]), str(self.cor_02[2]), str(self.cor_02[3])) + cor_03_list = (str(self.cor_03[0]), str(self.cor_03[1]), str(self.cor_03[2]), str(self.cor_03[3])) + cor_04_list = (str(self.cor_04[0]), str(self.cor_04[1]), str(self.cor_04[2]), str(self.cor_04[3])) + cor_05_list = (str(self.cor_05[0]), str(self.cor_05[1]), str(self.cor_05[2]), str(self.cor_05[3])) + cor_06_list = (str(self.cor_06[0]), str(self.cor_06[1]), str(self.cor_06[2]), str(self.cor_06[3])) + cor_07_list = (str(self.cor_07[0]), str(self.cor_07[1]), str(self.cor_07[2]), str(self.cor_07[3])) + cor_08_list = (str(self.cor_08[0]), str(self.cor_08[1]), str(self.cor_08[2]), str(self.cor_08[3])) + cor_09_list = (str(self.cor_09[0]), str(self.cor_09[1]), str(self.cor_09[2]), str(self.cor_09[3])) + cor_10_list = (str(self.cor_10[0]), str(self.cor_10[1]), str(self.cor_10[2]), str(self.cor_10[3])) + cor_00_string = ','.join(cor_00_list) + cor_01_string = ','.join(cor_01_list) + cor_02_string = ','.join(cor_02_list) + cor_03_string = ','.join(cor_03_list) + cor_04_string = ','.join(cor_04_list) + cor_05_string = ','.join(cor_05_list) + cor_06_string = ','.join(cor_06_list) + cor_07_string = ','.join(cor_07_list) + cor_08_string = ','.join(cor_08_list) + cor_09_string = ','.join(cor_09_list) + cor_10_string = ','.join(cor_10_list) + Krita.instance().writeSetting("Pigment.O", "cor_00", cor_00_string) + Krita.instance().writeSetting("Pigment.O", "cor_01", cor_01_string) + Krita.instance().writeSetting("Pigment.O", "cor_02", cor_02_string) + Krita.instance().writeSetting("Pigment.O", "cor_03", cor_03_string) + Krita.instance().writeSetting("Pigment.O", "cor_04", cor_04_string) + Krita.instance().writeSetting("Pigment.O", "cor_05", cor_05_string) + Krita.instance().writeSetting("Pigment.O", "cor_06", cor_06_string) + Krita.instance().writeSetting("Pigment.O", "cor_07", cor_07_string) + Krita.instance().writeSetting("Pigment.O", "cor_08", cor_08_string) + Krita.instance().writeSetting("Pigment.O", "cor_09", cor_09_string) + Krita.instance().writeSetting("Pigment.O", "cor_10", cor_10_string) + #// + #\\ Mixer ############################################################## + mixer_list_tts = (str(self.color_tts[0]), str(self.color_tts[1]), str(self.color_tts[2]), str(self.color_tts[3])) + mixer_list_rgb_1 = (str(self.color_rgb_l1[0]), str(self.color_rgb_l1[1]), str(self.color_rgb_l1[2]), str(self.color_rgb_l1[3]), str(self.color_rgb_r1[0]), str(self.color_rgb_r1[1]), str(self.color_rgb_r1[2]), str(self.color_rgb_r1[3])) + mixer_list_rgb_2 = (str(self.color_rgb_l2[0]), str(self.color_rgb_l2[1]), str(self.color_rgb_l2[2]), str(self.color_rgb_l2[3]), str(self.color_rgb_r2[0]), str(self.color_rgb_r2[1]), str(self.color_rgb_r2[2]), str(self.color_rgb_r2[3])) + mixer_list_rgb_3 = (str(self.color_rgb_l3[0]), str(self.color_rgb_l3[1]), str(self.color_rgb_l3[2]), str(self.color_rgb_l3[3]), str(self.color_rgb_r3[0]), str(self.color_rgb_r3[1]), str(self.color_rgb_r3[2]), str(self.color_rgb_r3[3])) + mixer_list_cmyk_1 = (str(self.color_cmyk_l1[0]), str(self.color_cmyk_l1[1]), str(self.color_cmyk_l1[2]), str(self.color_cmyk_l1[3]), str(self.color_cmyk_l1[4]), str(self.color_cmyk_r1[0]), str(self.color_cmyk_r1[1]), str(self.color_cmyk_r1[2]), str(self.color_cmyk_r1[3]), str(self.color_cmyk_r1[4])) + mixer_list_cmyk_2 = (str(self.color_cmyk_l2[0]), str(self.color_cmyk_l2[1]), str(self.color_cmyk_l2[2]), str(self.color_cmyk_l2[3]), str(self.color_cmyk_l2[4]), str(self.color_cmyk_r2[0]), str(self.color_cmyk_r2[1]), str(self.color_cmyk_r2[2]), str(self.color_cmyk_r2[3]), str(self.color_cmyk_r2[4])) + mixer_list_cmyk_3 = (str(self.color_cmyk_l3[0]), str(self.color_cmyk_l3[1]), str(self.color_cmyk_l3[2]), str(self.color_cmyk_l3[3]), str(self.color_cmyk_l3[4]), str(self.color_cmyk_r3[0]), str(self.color_cmyk_r3[1]), str(self.color_cmyk_r3[2]), str(self.color_cmyk_r3[3]), str(self.color_cmyk_r3[4])) + mixer_list_ryb_1 = (str(self.color_ryb_l1[0]), str(self.color_ryb_l1[1]), str(self.color_ryb_l1[2]), str(self.color_ryb_l1[3]), str(self.color_ryb_r1[0]), str(self.color_ryb_r1[1]), str(self.color_ryb_r1[2]), str(self.color_ryb_r1[3])) + mixer_list_ryb_2 = (str(self.color_ryb_l2[0]), str(self.color_ryb_l2[1]), str(self.color_ryb_l2[2]), str(self.color_ryb_l2[3]), str(self.color_ryb_r2[0]), str(self.color_ryb_r2[1]), str(self.color_ryb_r2[2]), str(self.color_ryb_r2[3])) + mixer_list_ryb_3 = (str(self.color_ryb_l3[0]), str(self.color_ryb_l3[1]), str(self.color_ryb_l3[2]), str(self.color_ryb_l3[3]), str(self.color_ryb_r3[0]), str(self.color_ryb_r3[1]), str(self.color_ryb_r3[2]), str(self.color_ryb_r3[3])) + mixer_list_yuv_1 = (str(self.color_yuv_l1[0]), str(self.color_yuv_l1[1]), str(self.color_yuv_l1[2]), str(self.color_yuv_l1[3]), str(self.color_yuv_r1[0]), str(self.color_yuv_r1[1]), str(self.color_yuv_r1[2]), str(self.color_yuv_r1[3])) + mixer_list_yuv_2 = (str(self.color_yuv_l2[0]), str(self.color_yuv_l2[1]), str(self.color_yuv_l2[2]), str(self.color_yuv_l2[3]), str(self.color_yuv_r2[0]), str(self.color_yuv_r2[1]), str(self.color_yuv_r2[2]), str(self.color_yuv_r2[3])) + mixer_list_yuv_3 = (str(self.color_yuv_l3[0]), str(self.color_yuv_l3[1]), str(self.color_yuv_l3[2]), str(self.color_yuv_l3[3]), str(self.color_yuv_r3[0]), str(self.color_yuv_r3[1]), str(self.color_yuv_r3[2]), str(self.color_yuv_r3[3])) + mixer_list_ard_1 = (str(self.color_ard_l1[0]), str(self.color_ard_l1[1]), str(self.color_ard_l1[2]), str(self.color_ard_l1[3]), str(self.color_ard_r1[0]), str(self.color_ard_r1[1]), str(self.color_ard_r1[2]), str(self.color_ard_r1[3])) + mixer_list_ard_2 = (str(self.color_ard_l2[0]), str(self.color_ard_l2[1]), str(self.color_ard_l2[2]), str(self.color_ard_l2[3]), str(self.color_ard_r2[0]), str(self.color_ard_r2[1]), str(self.color_ard_r2[2]), str(self.color_ard_r2[3])) + mixer_list_ard_3 = (str(self.color_ard_l3[0]), str(self.color_ard_l3[1]), str(self.color_ard_l3[2]), str(self.color_ard_l3[3]), str(self.color_ard_r3[0]), str(self.color_ard_r3[1]), str(self.color_ard_r3[2]), str(self.color_ard_r3[3])) + mixer_list_hsv_1 = (str(self.color_hsv_l1[0]), str(self.color_hsv_l1[1]), str(self.color_hsv_l1[2]), str(self.color_hsv_l1[3]), str(self.color_hsv_r1[0]), str(self.color_hsv_r1[1]), str(self.color_hsv_r1[2]), str(self.color_hsv_r1[3])) + mixer_list_hsv_2 = (str(self.color_hsv_l2[0]), str(self.color_hsv_l2[1]), str(self.color_hsv_l2[2]), str(self.color_hsv_l2[3]), str(self.color_hsv_r2[0]), str(self.color_hsv_r2[1]), str(self.color_hsv_r2[2]), str(self.color_hsv_r2[3])) + mixer_list_hsv_3 = (str(self.color_hsv_l3[0]), str(self.color_hsv_l3[1]), str(self.color_hsv_l3[2]), str(self.color_hsv_l3[3]), str(self.color_hsv_r3[0]), str(self.color_hsv_r3[1]), str(self.color_hsv_r3[2]), str(self.color_hsv_r3[3])) + mixer_list_hsl_1 = (str(self.color_hsl_l1[0]), str(self.color_hsl_l1[1]), str(self.color_hsl_l1[2]), str(self.color_hsl_l1[3]), str(self.color_hsl_r1[0]), str(self.color_hsl_r1[1]), str(self.color_hsl_r1[2]), str(self.color_hsl_r1[3])) + mixer_list_hsl_2 = (str(self.color_hsl_l2[0]), str(self.color_hsl_l2[1]), str(self.color_hsl_l2[2]), str(self.color_hsl_l2[3]), str(self.color_hsl_r2[0]), str(self.color_hsl_r2[1]), str(self.color_hsl_r2[2]), str(self.color_hsl_r2[3])) + mixer_list_hsl_3 = (str(self.color_hsl_l3[0]), str(self.color_hsl_l3[1]), str(self.color_hsl_l3[2]), str(self.color_hsl_l3[3]), str(self.color_hsl_r3[0]), str(self.color_hsl_r3[1]), str(self.color_hsl_r3[2]), str(self.color_hsl_r3[3])) + mixer_list_hcy_1 = (str(self.color_hcy_l1[0]), str(self.color_hcy_l1[1]), str(self.color_hcy_l1[2]), str(self.color_hcy_l1[3]), str(self.color_hcy_r1[0]), str(self.color_hcy_r1[1]), str(self.color_hcy_r1[2]), str(self.color_hcy_r1[3])) + mixer_list_hcy_2 = (str(self.color_hcy_l2[0]), str(self.color_hcy_l2[1]), str(self.color_hcy_l2[2]), str(self.color_hcy_l2[3]), str(self.color_hcy_r2[0]), str(self.color_hcy_r2[1]), str(self.color_hcy_r2[2]), str(self.color_hcy_r2[3])) + mixer_list_hcy_3 = (str(self.color_hcy_l3[0]), str(self.color_hcy_l3[1]), str(self.color_hcy_l3[2]), str(self.color_hcy_l3[3]), str(self.color_hcy_r3[0]), str(self.color_hcy_r3[1]), str(self.color_hcy_r3[2]), str(self.color_hcy_r3[3])) + + mixer_string_tts = ','.join(mixer_list_tts) + mixer_string_rgb_1 = ','.join(mixer_list_rgb_1) + mixer_string_rgb_2 = ','.join(mixer_list_rgb_2) + mixer_string_rgb_3 = ','.join(mixer_list_rgb_3) + mixer_string_cmyk_1 = ','.join(mixer_list_cmyk_1) + mixer_string_cmyk_2 = ','.join(mixer_list_cmyk_2) + mixer_string_cmyk_3 = ','.join(mixer_list_cmyk_3) + mixer_string_ryb_1 = ','.join(mixer_list_ryb_1) + mixer_string_ryb_2 = ','.join(mixer_list_ryb_2) + mixer_string_ryb_3 = ','.join(mixer_list_ryb_3) + mixer_string_yuv_1 = ','.join(mixer_list_yuv_1) + mixer_string_yuv_2 = ','.join(mixer_list_yuv_2) + mixer_string_yuv_3 = ','.join(mixer_list_yuv_3) + mixer_string_ard_1 = ','.join(mixer_list_ard_1) + mixer_string_ard_2 = ','.join(mixer_list_ard_2) + mixer_string_ard_3 = ','.join(mixer_list_ard_3) + mixer_string_hsv_1 = ','.join(mixer_list_hsv_1) + mixer_string_hsv_2 = ','.join(mixer_list_hsv_2) + mixer_string_hsv_3 = ','.join(mixer_list_hsv_3) + mixer_string_hsl_1 = ','.join(mixer_list_hsl_1) + mixer_string_hsl_2 = ','.join(mixer_list_hsl_2) + mixer_string_hsl_3 = ','.join(mixer_list_hsl_3) + mixer_string_hcy_1 = ','.join(mixer_list_hcy_1) + mixer_string_hcy_2 = ','.join(mixer_list_hcy_2) + mixer_string_hcy_3 = ','.join(mixer_list_hcy_3) + + Krita.instance().writeSetting("Pigment.O", "mix_TTS", mixer_string_tts) + Krita.instance().writeSetting("Pigment.O", "mix_RGB_1", mixer_string_rgb_1) + Krita.instance().writeSetting("Pigment.O", "mix_RGB_2", mixer_string_rgb_2) + Krita.instance().writeSetting("Pigment.O", "mix_RGB_3", mixer_string_rgb_3) + Krita.instance().writeSetting("Pigment.O", "mix_CMYK_1", mixer_string_cmyk_1) + Krita.instance().writeSetting("Pigment.O", "mix_CMYK_2", mixer_string_cmyk_2) + Krita.instance().writeSetting("Pigment.O", "mix_CMYK_3", mixer_string_cmyk_3) + Krita.instance().writeSetting("Pigment.O", "mix_RYB_1", mixer_string_ryb_1) + Krita.instance().writeSetting("Pigment.O", "mix_RYB_2", mixer_string_ryb_2) + Krita.instance().writeSetting("Pigment.O", "mix_RYB_3", mixer_string_ryb_3) + Krita.instance().writeSetting("Pigment.O", "mix_YUV_1", mixer_string_yuv_1) + Krita.instance().writeSetting("Pigment.O", "mix_YUV_2", mixer_string_yuv_2) + Krita.instance().writeSetting("Pigment.O", "mix_YUV_3", mixer_string_yuv_3) + Krita.instance().writeSetting("Pigment.O", "mix_ARD_1", mixer_string_ard_1) + Krita.instance().writeSetting("Pigment.O", "mix_ARD_2", mixer_string_ard_2) + Krita.instance().writeSetting("Pigment.O", "mix_ARD_3", mixer_string_ard_3) + Krita.instance().writeSetting("Pigment.O", "mix_HSV_1", mixer_string_hsv_1) + Krita.instance().writeSetting("Pigment.O", "mix_HSV_2", mixer_string_hsv_2) + Krita.instance().writeSetting("Pigment.O", "mix_HSV_3", mixer_string_hsv_3) + Krita.instance().writeSetting("Pigment.O", "mix_HSL_1", mixer_string_hsl_1) + Krita.instance().writeSetting("Pigment.O", "mix_HSL_2", mixer_string_hsl_2) + Krita.instance().writeSetting("Pigment.O", "mix_HSL_3", mixer_string_hsl_3) + Krita.instance().writeSetting("Pigment.O", "mix_HCY_1", mixer_string_hcy_1) + Krita.instance().writeSetting("Pigment.O", "mix_HCY_2", mixer_string_hcy_2) + Krita.instance().writeSetting("Pigment.O", "mix_HCY_3", mixer_string_hcy_3) + + #// + + def Settings_Load_ActiveColor(self): + # Active Color + try: + # Active Color + active_color_string = Krita.instance().readSetting("Pigment.O", "active_color", "") + active_color_split = active_color_string.split(",") + self.rgb_1 = float(active_color_split[0]) + self.rgb_2 = float(active_color_split[1]) + self.rgb_3 = float(active_color_split[2]) + self.angle_live = float(active_color_split[3]) + self.angle_ryb = float(active_color_split[4]) + self.uvd_1 = float(active_color_split[5]) + self.uvd_2 = float(active_color_split[6]) + self.uvd_3 = float(active_color_split[7]) + self.d_previous = float(active_color_split[8]) + self.kkk_0 = float(active_color_split[9]) + self.kkk_r = float(active_color_split[10]) + self.kkk_g = float(active_color_split[11]) + self.kkk_b = float(active_color_split[12]) + self.rgb_bg1 = float(active_color_split[13]) + self.rgb_bg2 = float(active_color_split[14]) + self.rgb_bg3 = float(active_color_split[15]) + except: + QtCore.qWarning("Pigment.O - Load Error - Active Color") + # Harmony + try: + # Active Harmony Read + har_00_string = Krita.instance().readSetting("Pigment.O", "har_00", "") + har_01_string = Krita.instance().readSetting("Pigment.O", "har_01", "") + har_02_string = Krita.instance().readSetting("Pigment.O", "har_02", "") + har_03_string = Krita.instance().readSetting("Pigment.O", "har_03", "") + har_04_string = Krita.instance().readSetting("Pigment.O", "har_04", "") + har_05_string = Krita.instance().readSetting("Pigment.O", "har_05", "") + # Active Harmony Split + har_00_split = har_00_string.split(",") + har_01_split = har_01_string.split(",") + har_02_split = har_02_string.split(",") + har_03_split = har_03_string.split(",") + har_04_split = har_04_string.split(",") + har_05_split = har_05_string.split(",") + # Active Harmony Variables + self.wheel = str(har_00_split[0]) + self.harmony_menu = bool(har_00_split[1]) + self.harmony_slot = int(har_00_split[2]) + self.harmony_rule = str(har_00_split[3]) + self.harmony_space = str(har_00_split[4]) + self.harmony_status = int(har_00_split[5]) + self.harmony_delta = float(har_00_split[6]) + self.har_1 = [har_01_split[0], eval(har_01_split[1]),eval(har_01_split[2]),eval(har_01_split[3]), eval(har_01_split[4]),eval(har_01_split[5]),eval(har_01_split[6])] + self.har_2 = [har_02_split[0], eval(har_02_split[1]),eval(har_02_split[2]),eval(har_02_split[3]), eval(har_02_split[4]),eval(har_02_split[5]),eval(har_02_split[6])] + self.har_3 = [har_03_split[0], eval(har_03_split[1]),eval(har_03_split[2]),eval(har_03_split[3]), eval(har_03_split[4]),eval(har_03_split[5]),eval(har_03_split[6])] + self.har_4 = [har_04_split[0], eval(har_04_split[1]),eval(har_04_split[2]),eval(har_04_split[3]), eval(har_04_split[4]),eval(har_04_split[5]),eval(har_04_split[6])] + self.har_5 = [har_05_split[0], eval(har_05_split[1]),eval(har_05_split[2]),eval(har_05_split[3]), eval(har_05_split[4]),eval(har_05_split[5]),eval(har_05_split[6])] + except: + QtCore.qWarning("Pigment.O - Load Error - Harmony Colors") + + # Apply Color/Harmony Colors + self.Harmony_Slots(self.harmony_slot) + # Harmony Display GUI if active + if self.panel_active == "HUE": + self.Update_Panel_HUE() + def Settings_Save_ActiveColor(self): + # Active Color + try: + active_color_list = ( + str(self.rgb_1), + str(self.rgb_2), + str(self.rgb_3), + str(self.angle_live), + str(self.angle_ryb), + str(self.uvd_1), + str(self.uvd_2), + str(self.uvd_3), + str(self.d_previous), + str(self.kkk_0), + str(self.kkk_r), + str(self.kkk_g), + str(self.kkk_b), + str(self.rgb_bg1), + str(self.rgb_bg2), + str(self.rgb_bg3), + ) + active_color_string = ','.join(active_color_list) + Krita.instance().writeSetting("Pigment.O", "active_color", active_color_string) + except: + QtCore.qWarning("Save Error - Active Color") + # Harmony + try: + har_list_00 = ( + str(self.wheel), + str(self.harmony_menu), + str(self.harmony_slot), + str(self.harmony_rule), + str(self.harmony_space), + str(self.harmony_status), + str(self.harmony_delta), + ) + har_list_01 = (str(self.har_1[0]), str(self.har_1[1]), str(self.har_1[2]), str(self.har_1[3]), str(self.har_1[4]), str(self.har_1[5]), str(self.har_1[6])) + har_list_02 = (str(self.har_2[0]), str(self.har_2[1]), str(self.har_2[2]), str(self.har_2[3]), str(self.har_2[4]), str(self.har_2[5]), str(self.har_2[6])) + har_list_03 = (str(self.har_3[0]), str(self.har_3[1]), str(self.har_3[2]), str(self.har_3[3]), str(self.har_3[4]), str(self.har_3[5]), str(self.har_3[6])) + har_list_04 = (str(self.har_4[0]), str(self.har_4[1]), str(self.har_4[2]), str(self.har_4[3]), str(self.har_4[4]), str(self.har_4[5]), str(self.har_4[6])) + har_list_05 = (str(self.har_5[0]), str(self.har_5[1]), str(self.har_5[2]), str(self.har_5[3]), str(self.har_5[4]), str(self.har_5[5]), str(self.har_5[6])) + har_string_00 = ','.join(har_list_00) + har_string_01 = ','.join(har_list_01) + har_string_02 = ','.join(har_list_02) + har_string_03 = ','.join(har_list_03) + har_string_04 = ','.join(har_list_04) + har_string_05 = ','.join(har_list_05) + Krita.instance().writeSetting("Pigment.O", "har_00", har_string_00) + Krita.instance().writeSetting("Pigment.O", "har_01", har_string_01) + Krita.instance().writeSetting("Pigment.O", "har_02", har_string_02) + Krita.instance().writeSetting("Pigment.O", "har_03", har_string_03) + Krita.instance().writeSetting("Pigment.O", "har_04", har_string_04) + Krita.instance().writeSetting("Pigment.O", "har_05", har_string_05) + except: + QtCore.qWarning("Save Error - Active Harmony") + + def Settings_Load_UI(self): + try: + # D1 + self.dialog.har.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_har", "")) ) + self.dialog.pan.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_pan", "")) ) + self.dialog.cha.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_cha", "")) ) + self.dialog.cor.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_cor", "")) ) + self.dialog.mix.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_mix", "")) ) + self.dialog.his.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_his", "")) ) + # D2 + self.dialog.har_rule.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_har_rule", "")) ) + self.dialog.har_edit.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_har_edit", "")) ) + self.dialog.pan_index.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_pan_index", "")) ) + self.dialog.hue_secondary.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_hue_secondary", "")) ) + self.dialog.gam_space.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_gam_space", "")) ) + self.dialog.gam_shape.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_gam_shape", "")) ) + self.dialog.dot_interpolation.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_dot_interpolation", "")) ) + self.dialog.dot_resolution.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_dot_resolution", "")) ) + self.dialog.dot_set.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_dot_set", "")) ) + self.dialog.obj_index.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_obj_index", "")) ) + self.dialog.obj_set.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_obj_set", "")) ) + self.dialog.img_grayscale.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_img_grayscale", "")) ) + # D3 + self.dialog.aaa.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_aaa", "")) ) + self.dialog.rgb.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_rgb", "")) ) + self.dialog.cmy.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_cmy", "")) ) + self.dialog.cmyk.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_cmyk", "")) ) + self.dialog.ryb.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_ryb", "")) ) + self.dialog.yuv.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_yuv", "")) ) + self.dialog.kkk.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_kkk", "")) ) + self.dialog.ard.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_ard", "")) ) + self.dialog.hsv.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_hsv", "")) ) + self.dialog.hsl.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_hsl", "")) ) + self.dialog.hcy.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_hcy", "")) ) + self.dialog.sel.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_sel", "")) ) + self.dialog.xyz.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_xyz", "")) ) + self.dialog.xyy.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_xyy", "")) ) + self.dialog.luv.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_luv", "")) ) + self.dialog.hlab.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_hlab", "")) ) + self.dialog.lab.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_lab", "")) ) + self.dialog.lch.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_lch", "")) ) + # D4 + self.dialog.display_values.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_display_values", "")) ) + self.dialog.display_hex.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_display_hex", "")) ) + self.dialog.hex_copy_paste.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_hex_copy_paste", "")) ) + self.dialog.hue_shine.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_hue_shine", "")) ) + self.dialog.cursor.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_cursor", "")) ) + # D5 + self.dialog.mix_index.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_mix_index", "")) ) + # D6 + self.dialog.wheel_index.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_wheel_index", "")) ) + self.dialog.wheel_space.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_wheel_space", "")) ) + self.dialog.luminosity.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_luminosity", "")) ) + self.dialog.xyz_matrix.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_xyz_matrix", "")) ) + self.dialog.xyz_illuminant.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_xyz_illuminant", "")) ) + self.dialog.key_1.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_key_1", "")) ) + self.dialog.key_2.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_key_2", "")) ) + self.dialog.key_3.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_key_3", "")) ) + self.dialog.key_4.setCurrentIndex( eval(Krita.instance().readSetting("Pigment.O", "ui_key_4", "")) ) + # D8 + self.dialog.release.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_release", "")) ) + self.dialog.inaccurate.setChecked( eval(Krita.instance().readSetting("Pigment.O", "ui_inaccurate", "")) ) + except: + QtCore.qWarning("Pigment.O - Load Error - UI") + def Settings_Save_UI(self): + # D1 + Krita.instance().writeSetting("Pigment.O", "ui_har", str(self.dialog.har.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_pan", str(self.dialog.pan.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_cha", str(self.dialog.cha.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_cor", str(self.dialog.cor.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_mix", str(self.dialog.mix.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_his", str(self.dialog.his.isChecked()) ) + # D2 + Krita.instance().writeSetting("Pigment.O", "ui_har_rule", str(self.dialog.har_rule.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_har_edit", str(self.dialog.har_edit.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_pan_index", str(self.dialog.pan_index.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_hue_secondary", str(self.dialog.hue_secondary.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_gam_space", str(self.dialog.gam_space.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_gam_shape", str(self.dialog.gam_shape.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_dot_interpolation", str(self.dialog.dot_interpolation.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_dot_resolution", str(self.dialog.dot_resolution.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_dot_set", str(self.dialog.dot_set.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_obj_index", str(self.dialog.obj_index.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_obj_set", str(self.dialog.obj_set.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_img_grayscale", str(self.dialog.img_grayscale.isChecked()) ) + # D3 + Krita.instance().writeSetting("Pigment.O", "ui_aaa", str(self.dialog.aaa.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_rgb", str(self.dialog.rgb.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_cmy", str(self.dialog.cmy.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_cmyk", str(self.dialog.cmyk.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_ryb", str(self.dialog.ryb.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_yuv", str(self.dialog.yuv.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_kkk", str(self.dialog.kkk.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_ard", str(self.dialog.ard.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_hsv", str(self.dialog.hsv.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_hsl", str(self.dialog.hsl.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_hcy", str(self.dialog.hcy.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_sel", str(self.dialog.sel.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_xyz", str(self.dialog.xyz.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_xyy", str(self.dialog.xyy.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_luv", str(self.dialog.luv.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_hlab", str(self.dialog.hlab.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_lab", str(self.dialog.lab.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_lch", str(self.dialog.lch.isChecked()) ) + # D4 + Krita.instance().writeSetting("Pigment.O", "ui_display_values", str(self.dialog.display_values.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_display_hex", str(self.dialog.display_hex.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_hex_copy_paste", str(self.dialog.hex_copy_paste.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_hue_shine", str(self.dialog.hue_shine.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_cursor", str(self.dialog.cursor.isChecked()) ) + # D5 + Krita.instance().writeSetting("Pigment.O", "ui_mix_index", str(self.dialog.mix_index.currentIndex()) ) + # D6 + Krita.instance().writeSetting("Pigment.O", "ui_wheel_index", str(self.dialog.wheel_index.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_wheel_space", str(self.dialog.wheel_space.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_luminosity", str(self.dialog.luminosity.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_xyz_matrix", str(self.dialog.xyz_matrix.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_xyz_illuminant", str(self.dialog.xyz_illuminant.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_key_1", str(self.dialog.key_1.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_key_2", str(self.dialog.key_2.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_key_3", str(self.dialog.key_3.currentIndex()) ) + Krita.instance().writeSetting("Pigment.O", "ui_key_4", str(self.dialog.key_4.currentIndex()) ) + # D8 + Krita.instance().writeSetting("Pigment.O", "ui_release", str(self.dialog.release.isChecked()) ) + Krita.instance().writeSetting("Pigment.O", "ui_inaccurate", str(self.dialog.inaccurate.isChecked()) ) + + def Settings_Load_Annotations(self): + if ((self.canvas() is not None) and (self.canvas().view() is not None)): + try: + # Active Document annotations + notes_string = str(self.ad.annotation("pigment_o_annotations")) + # Remove excess words + words_remove = [ + "gam_p1s1=[", + "gam_p1s3=[", + "gam_p1s4=[", + "gam_p2s1=[", + "gam_p3s3=[", + "]", + " ", + "b", + "'", + "\\n", + ] + for word in words_remove: + notes_string = notes_string.replace(word, "") + # Split values + notes_split = notes_string.split(",") + # Variables Placement + self.P1_S1 = self.P1_S1_r = [eval(notes_split[0]), eval(notes_split[1]), eval(notes_split[2]), eval(notes_split[3]), eval(notes_split[4]), eval(notes_split[5]), eval(notes_split[6]), eval(notes_split[7])] + self.P1_S3 = self.P1_S3_r = [eval(notes_split[8]), eval(notes_split[9]), eval(notes_split[10]), eval(notes_split[11]), eval(notes_split[12]), eval(notes_split[13])] + self.P1_S4 = self.P1_S4_r = [eval(notes_split[14]), eval(notes_split[15]), eval(notes_split[16]), eval(notes_split[17]), eval(notes_split[18]), eval(notes_split[19]), eval(notes_split[20]), eval(notes_split[21])] + self.P2_S1 = self.P2_S1_r = [eval(notes_split[22]), eval(notes_split[23]), eval(notes_split[24]), eval(notes_split[25]), eval(notes_split[26]), eval(notes_split[27]), eval(notes_split[28]), eval(notes_split[29]), eval(notes_split[30]), eval(notes_split[31]), eval(notes_split[32]), eval(notes_split[33]), eval(notes_split[34]), eval(notes_split[35]), eval(notes_split[36]), eval(notes_split[37])] + self.P3_S3 = self.P3_S3_r = [eval(notes_split[38]), eval(notes_split[39]), eval(notes_split[40]), eval(notes_split[41]), eval(notes_split[42]), eval(notes_split[43]), eval(notes_split[44]), eval(notes_split[45]), eval(notes_split[46]), eval(notes_split[47]), eval(notes_split[48]), eval(notes_split[49]), eval(notes_split[50]), eval(notes_split[51])] + # Update widget with Variables + self.Update_Panel_GAM_Polygon(self.P1_S1, self.P1_S3, self.P1_S4, self.P2_S1, self.P3_S3) + self.layout.panel_gam_polygon.update() + except: + pass + def Settings_Save_Annotations(self): + if ((self.canvas() is not None) and (self.canvas().view() is not None)): + try: + # Data to be Saved + data = ( + "gam_p1s1="+str(self.P1_S1)+", \n"+ + "gam_p1s3="+str(self.P1_S3)+", \n"+ + "gam_p1s4="+str(self.P1_S4)+", \n"+ + "gam_p2s1="+str(self.P2_S1)+", \n"+ + "gam_p3s3="+str(self.P3_S3) + ) + # Save to active Document + self.ad.setAnnotation('pigment_o_annotations', "pigmento annotations", QByteArray(data.encode())) + except: + pass + + #// + #\\ Change the Canvas ###################################################### + def canvasChanged(self, canvas): + pass + + #// + #\\ Notes ################################################################## + """ + # Label Message + self.layout.label.setText("message") + + # Pop Up Message + QMessageBox.information(QWidget(), i18n("Warnning"), i18n("message")) + + # Log Viewer Message + QtCore.qDebug("message") + QtCore.qWarning("message") + QtCore.qCritical("message") + + + To Do: + - swatch panel. generates and generates from a set. + - Fix HCY panel. create matrix 255x255 to create a small gradient image and then you can just scale it up to the correct size + - Panel HCY display and HUE+HCY + - OKhsv and OKhsl. needs alot of research. + - import image into IMG to create a GAM pixel mask + - color range selection + + Objectives: + - Harmony Span + - IMG analyze image. GAM mask. Palette creation. + - SWA everything. Generate from color space. Color of the day. generate from input. + - Select Color Range + + Bugs: + - Lab formula misses by one point + - HCY in 16+ bits acts wobbly on the HUE + + """ + #// diff --git a/pigment_o/pigment_o_manual.html b/pigment_o/pigment_o_manual.html new file mode 100644 index 0000000..4fa4746 --- /dev/null +++ b/pigment_o/pigment_o_manual.html @@ -0,0 +1,208 @@ + + + + + +
+ +

COLOR

+
Active Color : Left slot displays color. Shift or Ctrl plus LMB for Luminosity Lock. Alt plus LMB for Complemantary color, affected by wheel colors space. Always color accurate.
+
Previous Color : Right slot displays color. Shift or Ctrl plus LMB for Luminosity Lock and will display control Tone Gray. Alt plus LMB for Complemantary color, affected by wheel colors space. Always color accurate.
+
Background Color : Upmost left slot and is hidden. Hover over the Active or Previous color to display the Background Color. Press to swap foreground and background colors. Always color accurate.
+
Harmony Colors : Bottom slots. Press to activate Harmony color from the five color stack display according to the active rule.
+
+ +

HARMONY

+
Mode : Display a set of five colors following color theory rules. Harmony colors can be selected under the active color display. Select from the rule list for Monochromatic, Complemantary, Analogous, Split Complemantary and Double Split Complemantary rules. Panel HUE is able to display and select Harmony colors dynamically. The 3rd color in the stack is the main color and is represented by a straight line, while the other colors revolve around it and are represented by a dashed line. While in Harmony mode Pigment.O will suspend Krita active color checks.
+
Edit : Allows for all colors in the harmony stack to perserve their own independant Saturation and Ligthtness values. While inactive these values are shared accross the entire set. Edit mode can be seen as a line between 5 points in sone Panels.
+
+ +

PANELS

+
Grafical user interface (GUI) to display and pick your color with a click within a given color space.
+
Panel - FGC : Displays only the Foreground Color. Can display the 5 color Harmony set. Can display lock Temperature Influence.
+
Panel - RGB : Pick in RGB color space. Use R, G and B axis to select. Use modifier key to shift D and modify the polygon cut to the RGB cube.
+
Panel - ARD : Pick in ARD color space. Use R and D axis to select. Use modifier key to shift A and modify the polygon cut to the RGB cube. Can use Liminosity Lock.
+
Panel - HSV : Pick in HSV color space. Use S and V axis to select. Use modifier key to shift H. Can display Harmony set when in Edit mode. Can use Liminosity Lock.
+
Panel - HSL : Pick in HSL color space. Use S and L axis to select. Use modifier key to shift H. Can display Harmony set when in Edit mode. Can use Liminosity Lock.
+
Panel - HUE : Pick in HSV/HSL color space. Use H polar axis to select. Pick secondary display from DOT(none), TRIANGLE(hsl), SQUARE(hsv) and DIAMOND(hsl) to shift SV or SL. Main and secondary panels can display Harmony colors according to the active rule. Can use Liminosity Lock.
+
Panel - GAM : Pick in ARD/HSV/HSL/HCY color space. Use A polar axis and R axis to select. Pick a Mask from None, Circle, Triangle, Square, 2 Circles amd 3 Pies. Use modifier key to adjust the Mask or rotate it. Reset option cleans all Mask modifications to default values.
+
Panel - DOT : Pick in RGB color space. Select color space for the linear interpolation method. Adjust DOT size matrix by selecting the number dots. Set two pairs of driving colors to generate interpolation swatches. Press the middle button to swap the interpolation order. Default color set by Anders Zorn limited skin palette, composed by Cadmium Red, Yellow Ochre, Ivory Black and Titanium White. Cleanning all colors will reset to default colors.
+
Panel - OBJ : Pick in RGB color space. Create a image where colors are seperated by layers and store it in the appropriate file location of the plugin. 12 Layers are organized by BG(under all with 3 layers), DIF(middle and with 6 layers) and FG(top and with 3 layers). Each layer is filled with a driving color and alpha diferenciated by Object. Cleanning all colors will reset to default colors. Pick color from the final rendered image. SPHERE is default object and USER is a empty slot to be filled by the user reason why it is all black and empty. More objects can be added in if entries are coded in.
+
Panel - IMG : Pick in RGB color space. Select the path to a image file in your system by selecting PATH (to browse it on a system explorer) or by dragging and droping the file into the panel and will accept cropped images. Pressing "GRAYSCALE" converts the image display into grayscale. Click on the image to pick any color. Right cleanning the panel will open the context menu. Context menu allows Frame(everything is in frame), Adjust(Shift+Ctrl+Alt=Reset, Ctrl+Alt=Zoom and Shift+Alt=Pan) and Clean(cleans image).
+
+

Panel Operators

+
RMB : Zoom on the currently active color.
+
(SHIFT_CTRL_ALT)+LMB+(Left_Right) : Cumulative 3rd axis shift to the left or right.
+
+

Object Layers Oganization

+
Diffuse 1-6 : Object 6 Diffuse layers.
+
BackGround 1-3 : Object 3 BackGround layers. Shadow and Ambient Occlusion (ground).
+
ForeGround 1-3 : Object 3 ForeGround layers. Ambient Occlusion (object) and Specularity.
+
+ +

CHANNELS

+
Channels : Slider and Value display of a given color space. Value option displays the values when required. Hue option iluminates the Hues to maximum brightness.
+
A : Activate BW color space. BW = Black White. Sends Monochromatic value to other channels. When recieving from other channels it displays a weighted value considering the colors mixed and the active luminosity rule. A can be locked by using the luminosity lock.
+
RGB : Activate RGB color space. RGB = Red Green Blue.
+
CMY : Activate CMY color space. CMY = Cyan Magenta Yellow.
+
CMYK : Activate CMYK color space. CMYK = Cyan Magenta Yellow Key. Key can be locked to maintain mix.
+
RYB : Activate RYB color space. RYB = Red Yellow Blue.
+
YUV : Activate YUV color space. YUV = Luma Blue-Yellow Red-Green.
+
K : Activate K color space. K = Kelvin Temperature. Kelvin can be locked as a weighted value temperature to the current active color or act independant and send it's own RGB value.
+ +
ARD : Activate ARD color space. ARD = Angle Ratio Diagonal. Similar if not identical to HSI.
+
HSV : Activate HSV color space. HSV = Hue Saturation Value.
+
HSL : Activate HSL color space. HSL = Hue Saturation Lightness.
+
HCY : Activate HCY color space. HCY = Hue Chroma Luma. Similar if not identical to HSY.
+ +
XYZ : Activate XYZ color space. XYZ = X Y Z. Converting XYZ to RGB will limit values out of RGB range.
+
XYY : Activate XYY color space. XYY = X Y Y.
+
LAB* : Activate LAB* color space. LAB* = Lightness A(green–red) B(blue–yellow).
+
+ +

Channel Others

+
VALUES : Display of the label and numerical values of the channels.
+
HEX CODE : Display of the HEX value of the color within document color space. Default is RGB.
+
HEX CP : Activate to copy and paste HEX codes quickly by just hovering in(paste) and out(copy) of the main widget area. Hex codes must be in the format #123456 or will be ignored.
+
HUE SHINE : Display of hue channels to always be the most lit.
+
CURSOR : Toggle display of the channels cursors between Diamonds into Lines.
+
+ +

Channel Operators

+
Hex : Hex color code of the Selected Color.
+
Slider : Move Slider to select amount. Slider has Modifier Key operators.
+
Slider+Shift+LMB : Middle Value or nearest Pure Hue.
+
Slider+CTRL+LMB : Pin to nearest percetual value (delta=10%) or purest hue (delta=60º).
+
Slider+ALT+LMB (left side) : Minus one point on the Channel.
+
Slider+ALT+LMB (right side) : Plus one point on the Channel.
+
Slider+RMB : Activate Panel Zoom.
+
Value : Numerical value of the Channel. Requires activation from the menu.
+
Value+Arrow(Up/Dn) : Minus or Plus one point on the channel depending on the direction.
+
Value+Key(PgUp/PgDn) : Minus or Plus 10 point on the channel depending on the direction.
+
+ +

PALETTE

+
Save active color into 11 available slots. Colors inside the slots can be applyed quickly with the shortcut action "P. Color ##" for the slot of the respective number, counting from left(0) to right(10).
+
+ +

MIXER

+
Select 1 or 2 costum colors to calculate the interpolation between colors. TTS mixer can adjust the amount of Tint, Tone(Luma) and Shade in RGB space. Other mixers use 2 colors custom colors to interpolate using the respective color spaces: RGB, CMYK, RYB, YUV, ARD, HSV, HSL and HCY.
+
+ +

HISTORY

+
Color changes within Krita are detected and saved into a history buffer that can be reselected.
+
+ +

WHEEL

+
Spacing : Toggle between HUE_CMY(standard) and HUE_RYB(artistic) color wheels. Affects the display in HUE and GAM panels.
+
Color Space : Toggle between HSV, HSL and HCY color spaces for the wheels hue.
+
+ +

LUMA

+
Luma : Toggle between "ITU-R BT.601", "ITU-R BT.709" and "ITU-R BT.2020" presets. Affects all gray calculations.
+
+ +

XYZ-RGB

+
XYZ RGB Matrix : Conversions between XYZ and RGB are affected by the type of RGB color space used. Select the desired RGB color space for a correct conversion. By default "sRGB" will be choosen.
+
Illuminant : Conversions between XYZ and RGB are affected by the illuminant factor present. Available options are D50(print) and D65(monitors). By default D65 will be choosen.
+
+ +

KEYS

+
KEY 1 : Select the color space channel for the shortcut action "P. Key 1 Minus" and "P. Key 1 Plus".
+
KEY 2 : Select the color space channel for the shortcut action "P. Key 2 Minus" and "P. Key 2 Plus".
+
KEY 3 : Select the color space channel for the shortcut action "P. Key 3 Minus" and "P. Key 3 Plus".
+
KEY 4 : Select the color space channel for the shortcut action "P. Key 4 Minus" and "P. Key 4 Plus".
+
+ +

NAMES

+
Closest : Click to select the closest color with a name within the RGB color space.
+
Display : When active if the selected color has a name it will be displayed on the label. Uses the name entries of the list in the names file. More names can be added to the list as desired by editing the pigmento_o_names.py file.
+
+ +

KELVIN

+
Display : Adjusting the color temperature channel (Kelvin) will display the corresponding code and conditions for the adjustment.
+
+ +

PERFORMANCE

+
Release : Limits color input into Krita, to only when you mouse release. Changes will not be seen in real time inside Krita when editing.
+
Inaccurate : Limits color display accuracy to the most basic form of RGB 8-bit. This will bypass the extra step of asking Krita what is the correct display values of a given color considering the document. However this will not affect the Header as it interacts independantly.
+
+ +

Sync Switch

+
ON : Send color to Krita Enable. Check color of Krita Enable.
+
P>K : Send color to Krita Enable. Check color of Krita Disable.
+
OFF : Send color to Krita Disable. Check color of Krita Disable.
+
+ +

Fill Switch

+
Fill : Toggle to Alpha lock a layer and then auto fill it with a new active color. Unchecking "Fill" will unlock the layer. Selecting another layer will disable "Fill" automaticly. When "Performance > Release" is active the fill action will only be applyed when the mouse button is released. Use with caution as it overloads the undo history.
+
+ +

Color Select Switch

+
Select : Toggle on to create a red area selection over the image using the current active color as the target.
+
+ +

Settings Dialog

+
Lines : Displays the available settings.
+
+ +

Click Controls

+
Neutral + (LMBx2) to Apply current settings.
+
Shift + (LMBx1) to Apply current settings.
+
Ctrl + (LMBx1) to Save current settings.
+
Alt + (LMBx1) to Clean settings.
+
+

Update Events

+
Time Check : Every pulse there will be a Krita color check.
+
Mouse Enter : Entering the widget area will update itself and stops the timer pulse.
+
Mouse Leave : Leaving the widget area starts the timer pulse.
+
Memory : Last session Settings wil be retainned in memory until change or deletion. Settings are saved when Krita is closing.
+
+ +

[Frequently Asked Questions]

+
Why does Pigment.O not even boot?
+
For Linux users your probably missing the "PyQt5-SVG" module on your system.
+
The "Load Previous Session Settings" can cause a index missmatch on certain cases, for that case you need to head to the "kritarc" file and delete Pigment.O's indexes for a default state load.
+
+
Why using any Slider or Panel causes a huge Slowdown?
+
The most noticiable culprit for this situation is Linux's version of PyQt5 on how it handles Signals.
+
If your in this situation I recommend changing Pigment.O to "Sync > P>K" (so it only sends signals and not check Krita) and or activating "Performance > Release" (so it does not flood Krita with inputs).
+
+
Why does Krita periodicly lags out every second with Pigment.O active?
+
The cause of that is Pigment.O's periodic pulse to check any color changes within Krita. If your in this situation change the switch to "P>K" or any other Performance option that is most suited for your case.
+
Also you can adjust this delta time pulse to be faster(low values) or slower(high values) or disabled(anything less than 1) by changing the "check_timer" variable inside the pigment_o_docker.py file. 1000ms = 1second.
+
+
Why does Pigment.O change Color values right after I choose one?
+
This behaviour is certainly odd but ensures stability within Pigment.O's cyle, since it operates in multiple color spaces at the same time.
+
+
I will explain 2 cases where this happens in 8 bit depth scenario where it happens often:
+
1) Imagine your in RGB and you set the value 120.50 in the Red channel. This value does not really exist persay but exists within, since RGB works in integer values so what you acctually apply is the value 120 since that color ranges from 120.00 up too 120.99. After the color you choose is placed in Krita, Pigment.O checks the color that is currently active in Krita with it's periodical check and it reads 120, since 120.00 is different than 120.50 it adjusts itself to the current color changing the selected value.
+
2) The other case is when your working in another color space like HSV or HSL. What happens is similar but with a extra step. Imagine you set the HSV Color of (120,120,120), that is immediatley converted into RGB and applied to Krita, most conversions if not all will output a float value so what is applied is the integer value that contains it. For that reason after the check the RGB channels will round out all decimal values to zero and your HSV color will be set to corresponding color of (120,123.25,120).
+
+
Thus concluding that even though the value changes, it changes to the correct values of the color you choose in its containing color space and for the case of HSV and HSL they are containned by RGB.
+
It may feel weird but knowing why it does it, should improve confidence on it's behaviour.
+
+
Why can't I work with percentual values?
+
Well you acctually can, Pigment.O is acctually Agnostic over color scaling. However these values are not adjustable to ensure best case scenario by default for all users.
+
+
What is that talk about Pigment.O being Agnostic?
+
Pigment.O is independant of any color scale on all color spaces.
+
Noticiable cases of need:
+
- Wanting to work in percentual values, from 0 to 100.
+
- HSV and HSL is a case where the color scale is wrong but works better as it is given. Normaly HSV/HSL is (360,100,100) unlike what is used (360,255,255) but the fact is that you loose more colors during conversions if you use the Standard.
+
- 16 bit integer color depth is a case where color ranges from 0 to 65535. Pigment.O is by default set to work on 8 bit so you need to change it if you want to work on higher bit depths.
+
- 16 and 32 bit float color depth is a case where it ranges from 0 to 1. This range is how Pigment.O works internally and then it is scalled up, but this range should not be used due to some widgets behaviour that mess up decimal values by rounding them out and so a 0 to 100 range should be used instead.
+
To use this hidden feature go to the pigment_o_docker.py file and you can change the variables k_AAA, k_RGB, k_HUE, k_SVL, k_CMYK and others as needed.
+
This however will not affect the HEX color conversion unless by explicity changing the variables hexAAA, hexRGB, hexCMYK however this is not recommended and is marked as such with the comment "# DO NOT TOUCH !" as it is a convention to communicate colors on the web and inbetween applications.
+
+
Can I change/add my own Objects?
+
Yes you can.
+
Go to the "OBJECT" folder inside the Pigment.O instalation folder and edit/replace the maps inside the USER folder.
+
The Maps are seperated in 3 categories: Diffuse(D), BackGround(BG) and ForeGround(FG).
+
Diffuse is the object itself, which ranges from D1(lowest) to D6(topmost) layers.
+
BackGround are the effects behind the Object such as BackGround, Shadow and AO(ground), which ranges from BG1(lowest) to BG3(topmost) layers. All BackGround Layers are Under all other layer sets.
+
ForeGround are the effects over/above the Object such as AO(object) and Specularity(Tint and Direct), which ranges from FG1(lowest) to FG3(topmost) layers. All ForeGround Layers are Above all other layer sets.
+
Also if you make a good mask for a material or other send me word and I can consider it to be added.
+ + +