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.
+
+
+