added color harmony extension
This commit is contained in:
parent
8386b76eda
commit
3abb77ea77
1
extensions/fablabchemnitz/color_harmony/.gitignore
vendored
Normal file
1
extensions/fablabchemnitz/color_harmony/.gitignore
vendored
Normal file
@ -0,0 +1 @@
|
|||||||
|
*__pycache__*
|
||||||
87
extensions/fablabchemnitz/color_harmony/color_harmony.inx
Normal file
87
extensions/fablabchemnitz/color_harmony/color_harmony.inx
Normal file
@ -0,0 +1,87 @@
|
|||||||
|
<?xml version="1.0" encoding="UTF-8"?>
|
||||||
|
<inkscape-extension xmlns="http://www.inkscape.org/namespace/inkscape/extension">
|
||||||
|
<name>Color Harmony</name>
|
||||||
|
<id>fablabchemnitz.de.color_harmony</id>
|
||||||
|
<param name="tab" type="notebook">
|
||||||
|
<page name="render" gui-text="Create Color Harmony">
|
||||||
|
<label>Select an object that is filled with the color that you want to use as a base for your palette.</label>
|
||||||
|
<param name="harmony" type="optiongroup" appearance="combo" gui-text="Color Harmony:" gui-description="The asterisk means that the Angle modificator parameter can be used to change the outcome.">
|
||||||
|
<option value="just_opposite">Just opposite</option>
|
||||||
|
<option value="split_complementary">Split complementary *</option>
|
||||||
|
<option value="three">Three colors</option>
|
||||||
|
<option value="four">Four colors</option>
|
||||||
|
<option value="rectangle">Rectangle *</option>
|
||||||
|
<option value="five">Five colors *</option>
|
||||||
|
<option value="similar_3">Three similar colors *</option>
|
||||||
|
<option value="similar_5">Five similar colors *</option>
|
||||||
|
<option value="similar_and_opposite">Similar and opposite *</option>
|
||||||
|
<option value="from_raster">From selected raster image</option>
|
||||||
|
</param>
|
||||||
|
<param name="factor" type="int" min="1" max="100" gui-text="Angle modificator *" appearance="full" gui-description="Factor for determining the angle on the color circle for some of the harmonies (those that are marked with an asterisk)">50</param>
|
||||||
|
<param name="sort" type="optiongroup" appearance="combo" gui-text="Sort by:">
|
||||||
|
<option value="by_hue">Hue, 0-360°</option>
|
||||||
|
<option value="hue_contiguous">Hue, start from largest gap</option>
|
||||||
|
<option value="by_saturation">Saturation</option>
|
||||||
|
<option value="by_value">Value</option>
|
||||||
|
</param>
|
||||||
|
<label appearance="header">Add shades</label>
|
||||||
|
<hbox>
|
||||||
|
<vbox>
|
||||||
|
<param type="bool" name="cooler" gui-text="Cooler">false</param>
|
||||||
|
<param type="bool" name="warmer" gui-text="Warmer">false</param>
|
||||||
|
<param type="bool" name="saturation" gui-text="Saturation">false</param>
|
||||||
|
</vbox>
|
||||||
|
<vbox>
|
||||||
|
<param type="bool" name="value" gui-text="Value">false</param>
|
||||||
|
<param type="bool" name="chroma" gui-text="Chroma">false</param>
|
||||||
|
<param type="bool" name="luma" gui-text="Luma">false</param>
|
||||||
|
</vbox>
|
||||||
|
<vbox>
|
||||||
|
<param type="bool" name="hue" gui-text="Hue">false</param>
|
||||||
|
<param type="bool" name="hue_luma" gui-text="Hue / Luma">false</param>
|
||||||
|
<param type="bool" name="luma_plus_chroma" gui-text="Luma plus Chroma">false</param>
|
||||||
|
</vbox>
|
||||||
|
<vbox>
|
||||||
|
<param type="bool" name="luma_minus_chroma" gui-text="Luma minus Chroma">false</param>
|
||||||
|
</vbox>
|
||||||
|
</hbox>
|
||||||
|
<param name="step_width" type="float" min="0" max="1" gui-text="Shading step width:">0.1</param>
|
||||||
|
<label appearance="header">Size</label>
|
||||||
|
<param name="size" type="int" min="0" max="10000" gui-text="Size:">10</param>
|
||||||
|
<param name="unit" type="optiongroup" appearance="combo" gui-text="Units:">
|
||||||
|
<option value="mm">mm</option>
|
||||||
|
<option value="cm">cm</option>
|
||||||
|
<option value="in">in</option>
|
||||||
|
<option value="px">px</option>
|
||||||
|
<option value="pt">pt</option>
|
||||||
|
<option value="pc">pc</option>
|
||||||
|
</param>
|
||||||
|
<param name="delete_existing" type="boolean" gui-text="Remove old palettes">true</param>
|
||||||
|
</page>
|
||||||
|
<page name="save" gui-text="Save as Palette File">
|
||||||
|
<label>Save all selected palettes to a (single) palette file</label>
|
||||||
|
<param name="palette_format" type="optiongroup" appearance="combo" gui-text="Palette file format:">
|
||||||
|
<option value="gimp">Gimp Palette (.gpl)</option>
|
||||||
|
<option value="krita">Krita Palette (.kpl)</option>
|
||||||
|
<option value="scribus">Scribus Palette (.xml)</option>
|
||||||
|
</param>
|
||||||
|
<param type="path" name="palette_folder" gui-text="Folder to save palette file:" mode="folder" />
|
||||||
|
<param name="palette_name" type="string" gui-text="Palette name">My Palette</param>
|
||||||
|
</page>
|
||||||
|
<page name="colorize" gui-text="Magic Colors">
|
||||||
|
<label>Press "Apply" to colorize the selection with the rendered palette.</label>
|
||||||
|
</page>
|
||||||
|
</param>
|
||||||
|
<effect needs-live-preview="true">
|
||||||
|
<object-type>all</object-type>
|
||||||
|
<menu-tip>Generate color harmonies and save as palette file</menu-tip>
|
||||||
|
<effects-menu>
|
||||||
|
<submenu name="FabLab Chemnitz">
|
||||||
|
<submenu name="Various"/>
|
||||||
|
</submenu>
|
||||||
|
</effects-menu>
|
||||||
|
</effect>
|
||||||
|
<script>
|
||||||
|
<command location="inx" interpreter="python">color_harmony.py</command>
|
||||||
|
</script>
|
||||||
|
</inkscape-extension>
|
||||||
318
extensions/fablabchemnitz/color_harmony/color_harmony.py
Normal file
318
extensions/fablabchemnitz/color_harmony/color_harmony.py
Normal file
@ -0,0 +1,318 @@
|
|||||||
|
#!/usr/bin/env python3
|
||||||
|
|
||||||
|
# Color Harmony - Inkscape extension to generate
|
||||||
|
# palettes of colors that go well together
|
||||||
|
#
|
||||||
|
# Version 0.2 "golem"
|
||||||
|
#
|
||||||
|
# Copyright (C) 2009-2018 Ilya Portnov <portnov84@rambler.ru>
|
||||||
|
# (original 'palette-editor' tool, version 0.0.7)
|
||||||
|
# 2020 Maren Hachmann (extension-ification)
|
||||||
|
#
|
||||||
|
# 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 2 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, write to the Free Software Foundation, Inc.,
|
||||||
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||||
|
|
||||||
|
|
||||||
|
"""
|
||||||
|
This extension allows you to automatically add guides to your Inkscape documents.
|
||||||
|
"""
|
||||||
|
|
||||||
|
#from math import sqrt
|
||||||
|
#import types
|
||||||
|
import inkex
|
||||||
|
from inkex import Group, Rectangle
|
||||||
|
from inkex.colors import is_color
|
||||||
|
from color_harmony.colorplus import ColorPlus
|
||||||
|
from color_harmony.harmonies import *
|
||||||
|
from color_harmony.shades import *
|
||||||
|
|
||||||
|
|
||||||
|
class ColorHarmony(inkex.EffectExtension):
|
||||||
|
"""Generate palettes of colors that go well together"""
|
||||||
|
|
||||||
|
color = ''
|
||||||
|
|
||||||
|
def add_arguments(self, pars):
|
||||||
|
# General options
|
||||||
|
pars.add_argument('--tab', default='render', help='Extension functionality to use') # options: render, save, colorize
|
||||||
|
|
||||||
|
# Render tab options
|
||||||
|
pars.add_argument('--harmony', default="five", help='Color harmony to generate, options: from_raster, just_opposite, split_complementary, three, four, rectangle, five, similar_3, similar_5, similar_and_opposite')
|
||||||
|
pars.add_argument('--sort', default="by_hue", help="Method to sort the palette by, options: by_hue, by_saturation, by_value, hue_contiguous")
|
||||||
|
pars.add_argument('--factor', default=50, type=int, help="Factor to affect the result, between 1 and 100. Default is 50. This modifies the angle between the resulting colors on the color wheel.")
|
||||||
|
pars.add_argument('--size', default=10, help="Size of the generated palette squares")
|
||||||
|
pars.add_argument('--unit', default='mm', help='Units') # options: mm, cm, in, px, pt, pc
|
||||||
|
pars.add_argument('--delete_existing', type=inkex.Boolean, help='Delete existing palettes before generating a new one')
|
||||||
|
|
||||||
|
# Shading: cooler, warmer, saturation, value, chroma, luma, hue, hue_luma, luma_plus_chroma, luma_minus_chroma
|
||||||
|
pars.add_argument( '--cooler', type=inkex.Boolean, help='Add shades with cooler color temperature')
|
||||||
|
pars.add_argument( '--warmer', type=inkex.Boolean, help='Add shades with warmer color temperature')
|
||||||
|
pars.add_argument( '--saturation', type=inkex.Boolean, help='Add shades with saturation steps')
|
||||||
|
pars.add_argument( '--value', type=inkex.Boolean, help='Add shades with value steps')
|
||||||
|
pars.add_argument( '--chroma', type=inkex.Boolean, help='Add shades with chroma steps')
|
||||||
|
pars.add_argument( '--luma', type=inkex.Boolean, help='Add shades with luma steps')
|
||||||
|
pars.add_argument( '--hue', type=inkex.Boolean, help='Add shades with hue steps')
|
||||||
|
pars.add_argument( '--hue_luma', type=inkex.Boolean, help='Add shades with hue and luma steps')
|
||||||
|
pars.add_argument( '--luma_plus_chroma', type=inkex.Boolean, help='Add shades with luma plus chroma steps')
|
||||||
|
pars.add_argument( '--luma_minus_chroma', type=inkex.Boolean, help='Add shades with luma minus chroma steps')
|
||||||
|
pars.add_argument('--step_width', type=float, default=0.1, help='Shader step width') # TODO: find out what range this can take on, and adjust min, max, default in inx
|
||||||
|
|
||||||
|
# Save tab options
|
||||||
|
pars.add_argument('--palette_format', default='gimp', help='Palette file format')
|
||||||
|
# options: gimp, krita, scribus
|
||||||
|
pars.add_argument('--palette_folder', help="Folder to save the palette file in")
|
||||||
|
pars.add_argument('--palette_name', help="Name of the palette")
|
||||||
|
|
||||||
|
# Colorize tab options
|
||||||
|
# no options currently
|
||||||
|
|
||||||
|
|
||||||
|
def effect(self):
|
||||||
|
|
||||||
|
if self.options.tab == "render":
|
||||||
|
|
||||||
|
if len(self.svg.selected) == 1:
|
||||||
|
for obj_id, obj in self.svg.selected.items():
|
||||||
|
fill = obj.style.get("fill")
|
||||||
|
if is_color(fill):
|
||||||
|
if self.options.delete_existing:
|
||||||
|
self.delete_existing_palettes()
|
||||||
|
self.color = ColorPlus(fill)
|
||||||
|
self.options.factor = self.options.factor/100
|
||||||
|
colors = self.create_harmony()
|
||||||
|
shades = self.create_shades(colors)
|
||||||
|
palettes = [colors] + shades
|
||||||
|
|
||||||
|
for i in range(len(palettes)):
|
||||||
|
self.render_palette(palettes[i], i)
|
||||||
|
else:
|
||||||
|
raise inkex.AbortExtension(
|
||||||
|
"Please select an object with a plain fill color.")
|
||||||
|
else:
|
||||||
|
raise inkex.AbortExtension(
|
||||||
|
"Please select one object.")
|
||||||
|
elif self.options.tab == "save":
|
||||||
|
palettes = self.get_palettes_in_doc()
|
||||||
|
if len(palettes) >= 1:
|
||||||
|
self.save_palette(palettes[0])
|
||||||
|
else:
|
||||||
|
raise inkex.AbortExtension(
|
||||||
|
"There is no rendered palette in the document. Please render a palette using the first tab of the dialog before you try to save it.")
|
||||||
|
elif self.options.tab == "colorize":
|
||||||
|
if len(self.svg.selected) > 0:
|
||||||
|
self.colorize()
|
||||||
|
else:
|
||||||
|
raise inkex.AbortExtension(
|
||||||
|
"Please select an object to colorize!")
|
||||||
|
|
||||||
|
|
||||||
|
# METHODS FOR EACH TAB
|
||||||
|
# --------------------
|
||||||
|
|
||||||
|
# Render tab
|
||||||
|
# ==========
|
||||||
|
def create_harmony(self):
|
||||||
|
|
||||||
|
harmony_functions = {
|
||||||
|
"from_raster": self.palette_from_raster, # not implemented yet
|
||||||
|
"just_opposite": self.opposite,
|
||||||
|
"split_complementary": self.splitcomplementary,
|
||||||
|
"three": self.nhues3,
|
||||||
|
"four": self.nhues4,
|
||||||
|
"rectangle": self.rectangle,
|
||||||
|
"five": self.fivecolors,
|
||||||
|
"similar_3": self.similar_3,
|
||||||
|
"similar_5": self.similar_5,
|
||||||
|
"similar_and_opposite": self.similaropposite,
|
||||||
|
}
|
||||||
|
|
||||||
|
# use appropriate function for the selected tab
|
||||||
|
colors = harmony_functions[self.options.harmony](self.color)
|
||||||
|
colors = self.sort_colors(colors)
|
||||||
|
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def render_palette(self, colors, shift):
|
||||||
|
size = self.svg.unittouu(str(self.options.size)+self.options.unit)
|
||||||
|
top = 0 + shift * size
|
||||||
|
left = 0
|
||||||
|
|
||||||
|
layer = self.svg.get_current_layer() if self.svg.get_current_layer() is not None else self.document.getroot()
|
||||||
|
|
||||||
|
group_attribs = {inkex.addNS('label', 'inkscape'): "Palette ({harmony}, {color}) ".format(color=self.color, harmony=self.options.harmony)}
|
||||||
|
palette_group = Group(**group_attribs)
|
||||||
|
|
||||||
|
for color in colors:
|
||||||
|
palette_field = Rectangle(x=str(left),
|
||||||
|
y=str(top),
|
||||||
|
width=str(size),
|
||||||
|
height=str(size))
|
||||||
|
palette_field.style = {'fill': color}
|
||||||
|
palette_group.add(palette_field)
|
||||||
|
left += size
|
||||||
|
|
||||||
|
palette_group.transform.add_translate(0, self.svg.height + size)
|
||||||
|
|
||||||
|
layer.add(palette_group)
|
||||||
|
|
||||||
|
def palette_from_raster(self, color):
|
||||||
|
# TODO: implement
|
||||||
|
return []
|
||||||
|
|
||||||
|
def opposite(self, color):
|
||||||
|
colors = opposite(color)
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def splitcomplementary(self, color):
|
||||||
|
colors = splitcomplementary(color, self.options.factor)
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def nhues3(self, color):
|
||||||
|
colors = nHues(color, 3)
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def nhues4(self, color):
|
||||||
|
colors = nHues(color, 4)
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def rectangle(self, color):
|
||||||
|
colors = rectangle(color, self.options.factor)
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def fivecolors(self, color):
|
||||||
|
colors = fiveColors(color, self.options.factor)
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def similar_3(self, color):
|
||||||
|
colors = similar(color, 3, self.options.factor)
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def similar_5(self, color):
|
||||||
|
colors = similar(color, 5, self.options.factor)
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def similaropposite(self, color):
|
||||||
|
colors = similarAndOpposite(color, self.options.factor)
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def create_shades(self, colors):
|
||||||
|
shades = []
|
||||||
|
shading_options = {
|
||||||
|
"cooler": cooler,
|
||||||
|
"warmer": warmer,
|
||||||
|
"saturation": saturation,
|
||||||
|
"value": value,
|
||||||
|
"chroma": chroma,
|
||||||
|
"luma": luma,
|
||||||
|
"hue": hue,
|
||||||
|
"hue_luma": hue_luma,
|
||||||
|
"luma_plus_chroma": luma_plus_chroma,
|
||||||
|
"luma_minus_chroma": luma_minus_chroma,
|
||||||
|
}
|
||||||
|
|
||||||
|
for option, function in shading_options.items():
|
||||||
|
if vars(self.options)[option] == True:
|
||||||
|
# shades are created per color,
|
||||||
|
# but we want to get one palette per shading step
|
||||||
|
shaded_colors = []
|
||||||
|
for i in range(len(colors)):
|
||||||
|
shaded_colors.append(function(colors[i], self.options.step_width))
|
||||||
|
|
||||||
|
pals = [list(a) for a in zip(*shaded_colors)]
|
||||||
|
|
||||||
|
shades += pals
|
||||||
|
return shades
|
||||||
|
|
||||||
|
def delete_existing_palettes(self):
|
||||||
|
"""Delete all palettes in the document"""
|
||||||
|
|
||||||
|
for palette in self.get_palettes_in_doc():
|
||||||
|
palette.delete()
|
||||||
|
|
||||||
|
# Save tab
|
||||||
|
# ========
|
||||||
|
def save_palette(self, palette):
|
||||||
|
# TODO: implement
|
||||||
|
# if not hasattr(self.palette, 'name'):
|
||||||
|
# if type(file_w) in [str, unicode]:
|
||||||
|
# self.palette.name = basename(file_w)
|
||||||
|
# else:
|
||||||
|
# self.palette.name='Colors'
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
# Colorize tab
|
||||||
|
# ============
|
||||||
|
|
||||||
|
def colorize(self):
|
||||||
|
# TODO: implement
|
||||||
|
pass
|
||||||
|
|
||||||
|
# HELPER FUNCTIONS
|
||||||
|
# ----------------
|
||||||
|
|
||||||
|
def get_palettes_in_doc(self):
|
||||||
|
palettes = []
|
||||||
|
for group in self.svg.findall('.//svg:g'):
|
||||||
|
if group.get('inkscape:label').startswith('Palette ('):
|
||||||
|
palettes.append(group)
|
||||||
|
return palettes
|
||||||
|
|
||||||
|
def sort_colors(self, colors):
|
||||||
|
if self.options.sort == "by_hue":
|
||||||
|
colors.sort(key=lambda color: color.to_hsv()[0])
|
||||||
|
elif self.options.sort == "by_saturation":
|
||||||
|
colors.sort(key=lambda color: color.to_hsv()[1])
|
||||||
|
elif self.options.sort == "by_value":
|
||||||
|
colors.sort(key=lambda color: color.to_hsv()[2])
|
||||||
|
# this option looks nicer when the palette colors are similar red tones
|
||||||
|
# some of which have a hue close to 0
|
||||||
|
# and some of which have a hue close to 1
|
||||||
|
elif self.options.sort == "hue_contiguous":
|
||||||
|
# sort by hue first
|
||||||
|
colors.sort(key=lambda color: color.to_hsv()[0])
|
||||||
|
# now find out if the hues are maybe clustered around the 0 - 1 boundary
|
||||||
|
hues = [color.to_hsv()[0] for color in colors]
|
||||||
|
start_hue = 0
|
||||||
|
end_hue = 0
|
||||||
|
max_dist = 0
|
||||||
|
for i in range(len(colors)-1):
|
||||||
|
h1 = hues[i]
|
||||||
|
h2 = hues[i+1]
|
||||||
|
cur_dist = h2-h1
|
||||||
|
if cur_dist > max_dist and self.no_colors_in_between(h1, h2, hues):
|
||||||
|
max_dist = cur_dist
|
||||||
|
start_hue = h2
|
||||||
|
for i in range(len(colors)):
|
||||||
|
sorting_hue = hues[i] - start_hue
|
||||||
|
if sorting_hue > 1:
|
||||||
|
sorting_hue -=1
|
||||||
|
elif sorting_hue < 0:
|
||||||
|
sorting_hue += 1
|
||||||
|
hues[i] = sorting_hue
|
||||||
|
sorted_colors = [color for hue, color in sorted(zip(hues,colors))]
|
||||||
|
colors = sorted_colors
|
||||||
|
else:
|
||||||
|
raise inkex.AbortExtension(
|
||||||
|
"Please select one of the following sorting options: by_hue, by_saturation, by_value.")
|
||||||
|
return colors
|
||||||
|
|
||||||
|
def no_colors_in_between(self, hue1, hue2, hues):
|
||||||
|
for hue in hues:
|
||||||
|
if hue > hue1 and hue < hue2:
|
||||||
|
return False
|
||||||
|
return True
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
ColorHarmony().run()
|
||||||
@ -0,0 +1 @@
|
|||||||
|
# empty
|
||||||
@ -0,0 +1,260 @@
|
|||||||
|
#!/usr/bin/env python
|
||||||
|
# coding=utf-8
|
||||||
|
#
|
||||||
|
# Copyright (C) 2009-2018 Ilya Portnov <portnov84@rambler.ru>
|
||||||
|
# (original 'palette-editor' tool, version 0.0.7)
|
||||||
|
# 2020 Maren Hachmann (extension-ification)
|
||||||
|
#
|
||||||
|
# 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 2 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, write to the Free Software Foundation, Inc.,
|
||||||
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||||
|
|
||||||
|
|
||||||
|
from math import cos, acos, sqrt, pi
|
||||||
|
import colorsys
|
||||||
|
from inkex.colors import Color
|
||||||
|
|
||||||
|
_HCY_RED_LUMA = 0.299
|
||||||
|
_HCY_GREEN_LUMA = 0.587
|
||||||
|
_HCY_BLUE_LUMA = 0.114
|
||||||
|
|
||||||
|
class ColorPlus(Color):
|
||||||
|
|
||||||
|
#HCYwts = 0.299, 0.587, 0.114
|
||||||
|
|
||||||
|
## HCY colour space.
|
||||||
|
#
|
||||||
|
# Copy&Paste from https://raw.githubusercontent.com/mypaint/mypaint/master/gui/colors/uicolor.py
|
||||||
|
# Copyright (C) 2012-2013 by Andrew Chadwick <andrewc-git@piffle.org>
|
||||||
|
#
|
||||||
|
|
||||||
|
# Frequently referred to as HSY, Hue/Chroma/Luma, HsY, HSI etc. It can be
|
||||||
|
# thought of as a cylindrical remapping of the YCbCr solid: the "C" term is the
|
||||||
|
# proportion of the maximum permissible chroma within the RGB gamut at a given
|
||||||
|
# hue and luma. Planes of constant Y are equiluminant.
|
||||||
|
#
|
||||||
|
# ref https://code.google.com/p/colour-space-viewer/
|
||||||
|
# ref git://anongit.kde.org/kdelibs in kdeui/colors/kcolorspaces.cpp
|
||||||
|
# ref http://blog.publicfields.net/2011/12/rgb-hue-saturation-luma.html
|
||||||
|
# ref Joblove G.H., Greenberg D., Color spaces for computer graphics.
|
||||||
|
# ref http://www.cs.rit.edu/~ncs/color/t_convert.html
|
||||||
|
# ref http://en.literateprograms.org/RGB_to_HSV_color_space_conversion_(C)
|
||||||
|
# ref http://lodev.org/cgtutor/color.html
|
||||||
|
# ref Levkowitz H., Herman G.T., "GLHS: a generalized lightness, hue, and
|
||||||
|
# saturation color model"
|
||||||
|
|
||||||
|
# For consistency, use the same weights that the Color and Luminosity layer
|
||||||
|
# blend modes use, as also used by brushlib's Colorize brush blend mode. We
|
||||||
|
# follow http://www.w3.org/TR/compositing/ here. BT.601 YCbCr has a nearly
|
||||||
|
# identical definition of luma.
|
||||||
|
|
||||||
|
def __init__(self, color=None, space='rgb'):
|
||||||
|
super().__init__(color)
|
||||||
|
|
||||||
|
def to_hcy(self):
|
||||||
|
"""RGB → HCY: R,G,B,H,C,Y ∈ [0, 1]
|
||||||
|
|
||||||
|
:param rgb: Color expressed as an additive RGB triple.
|
||||||
|
:type rgb: tuple (r, g, b) where 0≤r≤1, 0≤g≤1, 0≤b≤1.
|
||||||
|
:rtype: tuple (h, c, y) where 0≤h<1, but 0≤c≤2 and 0≤y≤1.
|
||||||
|
|
||||||
|
"""
|
||||||
|
r, g, b = self.to_floats()
|
||||||
|
|
||||||
|
# Luma is just a weighted sum of the three components.
|
||||||
|
y = _HCY_RED_LUMA*r + _HCY_GREEN_LUMA*g + _HCY_BLUE_LUMA*b
|
||||||
|
|
||||||
|
# Hue. First pick a sector based on the greatest RGB component, then add
|
||||||
|
# the scaled difference of the other two RGB components.
|
||||||
|
p = max(r, g, b)
|
||||||
|
n = min(r, g, b)
|
||||||
|
d = p - n # An absolute measure of chroma: only used for scaling.
|
||||||
|
if n == p:
|
||||||
|
h = 0.0
|
||||||
|
elif p == r:
|
||||||
|
h = (g - b)/d
|
||||||
|
if h < 0:
|
||||||
|
h += 6.0
|
||||||
|
elif p == g:
|
||||||
|
h = ((b - r)/d) + 2.0
|
||||||
|
else: # p==b
|
||||||
|
h = ((r - g)/d) + 4.0
|
||||||
|
h /= 6.0
|
||||||
|
|
||||||
|
# Chroma, relative to the RGB gamut envelope.
|
||||||
|
if r == g == b:
|
||||||
|
# Avoid a division by zero for the achromatic case.
|
||||||
|
c = 0.0
|
||||||
|
else:
|
||||||
|
# For the derivation, see the GLHS paper.
|
||||||
|
c = max((y-n)/y, (p-y)/(1-y))
|
||||||
|
return h, c, y
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def from_hcy(h, c, y):
|
||||||
|
"""HCY → RGB: R,G,B,H,C,Y ∈ [0, 1]
|
||||||
|
|
||||||
|
:param hcy: Color expressed as a Hue/relative-Chroma/Luma triple.
|
||||||
|
:type hcy: tuple (h, c, y) where 0≤h<1, but 0≤c≤2 and 0≤y≤1.
|
||||||
|
:rtype: ColorPlus object.
|
||||||
|
|
||||||
|
>>> n = 32
|
||||||
|
>>> diffs = [sum( [abs(c1-c2) for c1, c2 in
|
||||||
|
... zip( HCY_to_RGB(RGB_to_HCY([r/n, g/n, b/n])),
|
||||||
|
... [r/n, g/n, b/n] ) ] )
|
||||||
|
... for r in range(int(n+1))
|
||||||
|
... for g in range(int(n+1))
|
||||||
|
... for b in range(int(n+1))]
|
||||||
|
>>> sum(diffs) < n*1e-6
|
||||||
|
True
|
||||||
|
|
||||||
|
"""
|
||||||
|
|
||||||
|
if c == 0:
|
||||||
|
return y, y, y
|
||||||
|
|
||||||
|
h %= 1.0
|
||||||
|
h *= 6.0
|
||||||
|
if h < 1:
|
||||||
|
#implies (p==r and h==(g-b)/d and g>=b)
|
||||||
|
th = h
|
||||||
|
tm = _HCY_RED_LUMA + _HCY_GREEN_LUMA * th
|
||||||
|
elif h < 2:
|
||||||
|
#implies (p==g and h==((b-r)/d)+2.0 and b<r)
|
||||||
|
th = 2.0 - h
|
||||||
|
tm = _HCY_GREEN_LUMA + _HCY_RED_LUMA * th
|
||||||
|
elif h < 3:
|
||||||
|
#implies (p==g and h==((b-r)/d)+2.0 and b>=g)
|
||||||
|
th = h - 2.0
|
||||||
|
tm = _HCY_GREEN_LUMA + _HCY_BLUE_LUMA * th
|
||||||
|
elif h < 4:
|
||||||
|
#implies (p==b and h==((r-g)/d)+4.0 and r<g)
|
||||||
|
th = 4.0 - h
|
||||||
|
tm = _HCY_BLUE_LUMA + _HCY_GREEN_LUMA * th
|
||||||
|
elif h < 5:
|
||||||
|
#implies (p==b and h==((r-g)/d)+4.0 and r>=g)
|
||||||
|
th = h - 4.0
|
||||||
|
tm = _HCY_BLUE_LUMA + _HCY_RED_LUMA * th
|
||||||
|
else:
|
||||||
|
#implies (p==r and h==(g-b)/d and g<b)
|
||||||
|
th = 6.0 - h
|
||||||
|
tm = _HCY_RED_LUMA + _HCY_BLUE_LUMA * th
|
||||||
|
|
||||||
|
# Calculate the RGB components in sorted order
|
||||||
|
if tm >= 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, g, b = p, o, n
|
||||||
|
elif h < 2: r, g, b = o, p, n
|
||||||
|
elif h < 3: r, g, b = n, p, o
|
||||||
|
elif h < 4: r, g, b = n, o, p
|
||||||
|
elif h < 5: r, g, b = o, n, p
|
||||||
|
else: r, g, b = p, n, o
|
||||||
|
|
||||||
|
return ColorPlus([255*r, 255*g, 255*b])
|
||||||
|
|
||||||
|
def to_hsv(self):
|
||||||
|
r, g, b = self.to_floats()
|
||||||
|
eps = 0.001
|
||||||
|
if abs(max(r,g,b)) < eps:
|
||||||
|
return (0,0,0)
|
||||||
|
return colorsys.rgb_to_hsv(r, g, b)
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def from_hsv(h, s, v):
|
||||||
|
r, g, b = colorsys.hsv_to_rgb(h, s, v)
|
||||||
|
return ColorPlus([255*r, 255*g, 255*b])
|
||||||
|
|
||||||
|
# TODO: everything below is not updated yet, maybe not really needed
|
||||||
|
def hex(self):
|
||||||
|
r,g,b = self.getRGB()
|
||||||
|
return "#{:02x}{:02x}{:02x}".format(r,g,b)
|
||||||
|
|
||||||
|
def getRgbString(self):
|
||||||
|
r,g,b = self.getRGB()
|
||||||
|
return "rgb({}, {}, {})".format(r,g,b)
|
||||||
|
|
||||||
|
def getHsvString(self):
|
||||||
|
h,s,v = self.getHSV()
|
||||||
|
return "hsv({}, {}, {})".format(h,s,v)
|
||||||
|
|
||||||
|
def invert(self):
|
||||||
|
r, g, b = self._rgb
|
||||||
|
return Color(255-r, 255-g, 255-b)
|
||||||
|
|
||||||
|
def darker(clr, q):
|
||||||
|
h,s,v = clr.getHSV()
|
||||||
|
v = clip(v-q)
|
||||||
|
return hsv(h,s,v)
|
||||||
|
|
||||||
|
def lighter(clr, q):
|
||||||
|
h,s,v = clr.getHSV()
|
||||||
|
v = clip(v+q)
|
||||||
|
return hsv(h,s,v)
|
||||||
|
|
||||||
|
def saturate(clr, q):
|
||||||
|
h,s,v = clr.getHSV()
|
||||||
|
s = clip(s+q)
|
||||||
|
return hsv(h,s,v)
|
||||||
|
|
||||||
|
def desaturate(clr, q):
|
||||||
|
h,s,v = clr.getHSV()
|
||||||
|
s = clip(s-q)
|
||||||
|
return hsv(h,s,v)
|
||||||
|
|
||||||
|
def increment_hue(clr, q):
|
||||||
|
h,s,v = clr.getHSV()
|
||||||
|
h += q
|
||||||
|
if h > 1.0:
|
||||||
|
h -= 1.0
|
||||||
|
if h < 1.0:
|
||||||
|
h += 1.0
|
||||||
|
return hsv(h,s,v)
|
||||||
|
|
||||||
|
def contrast(clr, q):
|
||||||
|
h,s,v = clr.getHSV()
|
||||||
|
v = (v - 0.5)*(1.0 + q) + 0.5
|
||||||
|
v = clip(v)
|
||||||
|
return hsv(h,s,v)
|
||||||
|
|
||||||
|
def linear(x, y, q):
|
||||||
|
return (1.-q)*x + q*y
|
||||||
|
|
||||||
|
def linear3(v1, v2, q):
|
||||||
|
x1, y1, z1 = v1
|
||||||
|
x2, y2, z2 = v2
|
||||||
|
return (linear(x1, x2, q), linear(y1, y2, q), linear(z1, z2, q))
|
||||||
|
|
||||||
|
def circular(h1, h2, q, circle=1.0):
|
||||||
|
#print("Src hues: "+ str((h1, h2)))
|
||||||
|
d = h2 - h1
|
||||||
|
if h1 > h2:
|
||||||
|
h1, h2 = h2, h1
|
||||||
|
d = -d
|
||||||
|
q = 1.0 - q
|
||||||
|
if d > circle/2.0:
|
||||||
|
h1 = h1 + circle
|
||||||
|
h = linear(h1, h2, q)
|
||||||
|
else:
|
||||||
|
h = h1 + q*d
|
||||||
|
if h >= circle:
|
||||||
|
h -= circle
|
||||||
|
#print("Hue: "+str(h))
|
||||||
|
return h
|
||||||
139
extensions/fablabchemnitz/color_harmony/color_harmony/export.py
Normal file
139
extensions/fablabchemnitz/color_harmony/color_harmony/export.py
Normal file
@ -0,0 +1,139 @@
|
|||||||
|
#!/usr/bin/env python
|
||||||
|
# coding=utf-8
|
||||||
|
#
|
||||||
|
# Copyright (C) 2009-2018 Ilya Portnov <portnov84@rambler.ru>
|
||||||
|
# (original 'palette-editor' tool, version 0.0.7)
|
||||||
|
# 2020 Maren Hachmann (extension-ification)
|
||||||
|
#
|
||||||
|
# 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 2 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, write to the Free Software Foundation, Inc.,
|
||||||
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||||
|
|
||||||
|
|
||||||
|
from os.path import join, basename
|
||||||
|
from lxml import etree as ET
|
||||||
|
from zipfile import ZipFile, ZIP_DEFLATED
|
||||||
|
|
||||||
|
|
||||||
|
class PaletteFile(object)
|
||||||
|
|
||||||
|
def __init__(self, name, colors, filename, folder):
|
||||||
|
self.colors = colors
|
||||||
|
if name != "":
|
||||||
|
self.name = name
|
||||||
|
else:
|
||||||
|
self.name = "Palette"
|
||||||
|
self.folder = folder
|
||||||
|
|
||||||
|
def save(self, format):
|
||||||
|
FORMATS = {'gimp': [build_gpl, 'gpl'],
|
||||||
|
'scribus': [build_scribus_xml, 'xml'],
|
||||||
|
'krita': [build_kpl, 'kpl'],
|
||||||
|
'css': [build_css, 'css'],
|
||||||
|
'android_xml': [build_android_xml, 'xml'],
|
||||||
|
}
|
||||||
|
|
||||||
|
if os.path.exists(self.folder):
|
||||||
|
# save with given file name
|
||||||
|
pass
|
||||||
|
|
||||||
|
def build_gpl(self):
|
||||||
|
# TODO: fix
|
||||||
|
palette_string = (u"Name: {}\n".format(self.palette.name).encode('utf-8'))
|
||||||
|
if hasattr(self.palette, 'ncols') and self.palette.ncols:
|
||||||
|
palette_string += 'Columns: %s\n' % self.palette.ncols
|
||||||
|
for key,value in self.palette.meta.items():
|
||||||
|
if key != "Name":
|
||||||
|
palette_string += u"# {}: {}\n".format(key, value).encode('utf-8')
|
||||||
|
palette_string += '#\n'
|
||||||
|
for row in self.palette.slots:
|
||||||
|
for slot in row:
|
||||||
|
n = slot.name
|
||||||
|
r, g, b = slot.color.getRGB()
|
||||||
|
s = '%d %d %d %s\n' % (r, g, b, n)
|
||||||
|
palette_string += s
|
||||||
|
for key,value in slot.color.meta.items():
|
||||||
|
if key != "Name":
|
||||||
|
palette_string += u"# {}: {}\n".format(key, value).encode('utf-8')
|
||||||
|
return palette_string
|
||||||
|
|
||||||
|
def build_kpl(self):
|
||||||
|
# TODO: fix (and don't save it here, only build)
|
||||||
|
with ZipFile(file_w, 'w', ZIP_DEFLATED) as zf:
|
||||||
|
zf.writestr("mimetype", MIMETYPE)
|
||||||
|
|
||||||
|
xml = ET.Element("Colorset")
|
||||||
|
xml.attrib['version'] = '1.0'
|
||||||
|
xml.attrib['columns'] = str(self.palette.ncols)
|
||||||
|
xml.attrib['name'] = self.palette.name
|
||||||
|
xml.attrib['comment'] = self.palette.meta.get("Comment", "Generated by Palette Editor")
|
||||||
|
|
||||||
|
for i,row in enumerate(self.palette.slots):
|
||||||
|
for j,slot in enumerate(row):
|
||||||
|
color = slot.color
|
||||||
|
name = color.name
|
||||||
|
default_name = "Swatch-{}-{}".format(i,j)
|
||||||
|
if not name:
|
||||||
|
name = default_name
|
||||||
|
|
||||||
|
elem = ET.SubElement(xml, "ColorSetEntry")
|
||||||
|
elem.attrib['spot'] = color.meta.get("Spot", "false")
|
||||||
|
elem.attrib['id'] = default_name
|
||||||
|
elem.attrib['name'] = name
|
||||||
|
elem.attrib['bitdepth'] = 'U8'
|
||||||
|
|
||||||
|
r,g,b = color.getRGB1()
|
||||||
|
srgb = ET.SubElement(elem, "sRGB")
|
||||||
|
srgb.attrib['r'] = str(r)
|
||||||
|
srgb.attrib['g'] = str(g)
|
||||||
|
srgb.attrib['b'] = str(b)
|
||||||
|
|
||||||
|
tree = ET.ElementTree(xml)
|
||||||
|
tree_str = ET.tostring(tree, encoding='utf-8', pretty_print=True, xml_declaration=False)
|
||||||
|
|
||||||
|
zf.writestr("colorset.xml", tree_str)
|
||||||
|
|
||||||
|
def build_scribus_xml(self):
|
||||||
|
# TODO: fix, and don't save here
|
||||||
|
xml = ET.Element("SCRIBUSCOLORS", NAME=name)
|
||||||
|
|
||||||
|
for i,row in enumerate(self.palette.getColors()):
|
||||||
|
for j,color in enumerate(row):
|
||||||
|
name = color.name
|
||||||
|
if not name:
|
||||||
|
name = "Swatch-{}-{}".format(i,j)
|
||||||
|
elem = ET.SubElement(xml, "COLOR", NAME=name, RGB=color.hex())
|
||||||
|
if "Spot" in color.meta:
|
||||||
|
elem.attrib["Spot"] = color.meta["Spot"]
|
||||||
|
if "Register" in color.meta:
|
||||||
|
elem.attrib["Register"] = color.meta["Register"]
|
||||||
|
|
||||||
|
ET.ElementTree(xml).write(file_w, encoding="utf-8", pretty_print=True, xml_declaration=True)
|
||||||
|
|
||||||
|
def build_android_xml(self):
|
||||||
|
# https://stackoverflow.com/questions/3769762/web-colors-in-an-android-color-xml-resource-file
|
||||||
|
palette_string = ''
|
||||||
|
# TODO: implement
|
||||||
|
return palette_string
|
||||||
|
|
||||||
|
def build_css(self):
|
||||||
|
palette_string = ''
|
||||||
|
|
||||||
|
# TODO: fix
|
||||||
|
for i, row in enumerate(self.palette.slots):
|
||||||
|
for j, slot in enumerate(row):
|
||||||
|
hex = slot.color.hex()
|
||||||
|
s = ".color-{}-{}{} {{ color: {} }};\n".format(i,j, user, hex)
|
||||||
|
palette_string += s
|
||||||
|
|
||||||
|
return palette_string
|
||||||
@ -0,0 +1,104 @@
|
|||||||
|
#!/usr/bin/env python
|
||||||
|
# coding=utf-8
|
||||||
|
#
|
||||||
|
# Copyright (C) 2009-2018 Ilya Portnov <portnov84@rambler.ru>
|
||||||
|
# (original 'palette-editor' tool, version 0.0.7)
|
||||||
|
# 2020 Maren Hachmann (extension-ification)
|
||||||
|
#
|
||||||
|
# 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 2 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, write to the Free Software Foundation, Inc.,
|
||||||
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||||
|
|
||||||
|
from math import sqrt, sin, cos
|
||||||
|
from color_harmony.colorplus import ColorPlus
|
||||||
|
from color_harmony.utils import seq, circle_hue
|
||||||
|
|
||||||
|
|
||||||
|
# Each of these functions takes one ColorPlus object
|
||||||
|
# and returns a list of ColorPlus objects:
|
||||||
|
__all__ = ['opposite', 'splitcomplementary', 'similar', 'similarAndOpposite', 'rectangle', 'nHues', 'fiveColors']
|
||||||
|
|
||||||
|
# Harmony functions
|
||||||
|
# 180° rotation
|
||||||
|
def opposite(color):
|
||||||
|
h, s, v = color.to_hsv()
|
||||||
|
h = h + 0.5
|
||||||
|
if h > 1.0:
|
||||||
|
h -= 1.0
|
||||||
|
return [color, ColorPlus.from_hsv(h, s, v)]
|
||||||
|
|
||||||
|
# default value 0.5 corresponds to +-36° deviation from opposite, max. useful value: 89°, min. useful value: 1°
|
||||||
|
def splitcomplementary(color, parameter=0.5):
|
||||||
|
h, s, v = color.to_hsv()
|
||||||
|
h += (1.0 - 0.4*parameter)/2.0
|
||||||
|
if h > 1.0:
|
||||||
|
h -= 1.0
|
||||||
|
c1 = ColorPlus.from_hsv(h,s,v)
|
||||||
|
h += 0.4*parameter
|
||||||
|
if h > 1.0:
|
||||||
|
h -= 1.0
|
||||||
|
c2 = ColorPlus.from_hsv(h,s,v)
|
||||||
|
return [color, c1, c2]
|
||||||
|
|
||||||
|
# default value 0.5 corresponds to 36° per step, max. useful value: 360°/n , min. useful value: 1°
|
||||||
|
def similar(color, n, parameter=0.5):
|
||||||
|
h, s, v = color.to_hsv()
|
||||||
|
step = 0.2 * parameter
|
||||||
|
hmin = h - (n // 2) * step
|
||||||
|
hmax = h + (n // 2) * step
|
||||||
|
return [ColorPlus.from_hsv(dh % 1.0, s, v) for dh in seq(hmin, hmax, step)]
|
||||||
|
|
||||||
|
# default value 0.5 corresponds to 36° deviation from original, max. useful value: 178°, min. useful value: 1°
|
||||||
|
def similarAndOpposite(color, parameter=0.5):
|
||||||
|
h, c, y = color.to_hcy()
|
||||||
|
h1 = h + 0.2 * parameter
|
||||||
|
if h1 > 1.0:
|
||||||
|
h1 -= 1.0
|
||||||
|
h2 = h - 0.2 * parameter
|
||||||
|
if h2 < 0.0:
|
||||||
|
h2 += 1.0
|
||||||
|
h3 = h + 0.5
|
||||||
|
if h3 > 1.0:
|
||||||
|
h3 -= 1.0
|
||||||
|
return [ColorPlus.from_hcy(h1,c,y),
|
||||||
|
color,
|
||||||
|
ColorPlus.from_hcy(h2,c,y),
|
||||||
|
ColorPlus.from_hcy(h3,c,y)]
|
||||||
|
|
||||||
|
# default value 0.5 corresponds to 36° deviation from original, max. useful angle 180°, min. useful angle 1°
|
||||||
|
def rectangle(color, parameter=0.5):
|
||||||
|
h, c, y = color.to_hcy()
|
||||||
|
h1 = (h + 0.2 * parameter) % 1.0
|
||||||
|
h2 = (h1 + 0.5) % 1.0
|
||||||
|
h3 = (h + 0.5) % 1.0
|
||||||
|
return [color,
|
||||||
|
ColorPlus.from_hcy(h1,c,y),
|
||||||
|
ColorPlus.from_hcy(h2,c,y),
|
||||||
|
ColorPlus.from_hcy(h3,c,y)]
|
||||||
|
|
||||||
|
# returns n colors that are placed on the hue circle in steps of 360°/n
|
||||||
|
def nHues(color, n):
|
||||||
|
h, s, v = color.to_hsv()
|
||||||
|
return [color] + [ColorPlus.from_hsv(circle_hue(i, n, h), s, v) for i in range(1, n)]
|
||||||
|
|
||||||
|
# parameter determines +/- deviation from a the hues +/-120° away, default value 0.5 corresponds to 2.16°, max. possible angle 4.32°
|
||||||
|
def fiveColors(color, parameter=0.5):
|
||||||
|
h0, s, v = color.to_hsv()
|
||||||
|
h1s = (h0 + 1.0/3.0) % 1.0
|
||||||
|
h2s = (h1s + 1.0/3.0) % 1.0
|
||||||
|
delta = 0.06 * parameter
|
||||||
|
h1 = (h1s - delta) % 1.0
|
||||||
|
h2 = (h1s + delta) % 1.0
|
||||||
|
h3 = (h2s - delta) % 1.0
|
||||||
|
h4 = (h2s + delta) % 1.0
|
||||||
|
return [color] + [ColorPlus.from_hsv(h,s,v) for h in [h1,h2,h3,h4]]
|
||||||
@ -0,0 +1 @@
|
|||||||
|
# empty
|
||||||
@ -0,0 +1,117 @@
|
|||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color.spaces import *
|
||||||
|
|
||||||
|
def find_min(idx, occupied, d):
|
||||||
|
best_i = None
|
||||||
|
best_y = None
|
||||||
|
best_clr = None
|
||||||
|
for i, clr in d.iteritems():
|
||||||
|
if i in occupied:
|
||||||
|
continue
|
||||||
|
y = clr[idx]
|
||||||
|
if best_y is None or y < best_y:
|
||||||
|
best_i = i
|
||||||
|
best_y = y
|
||||||
|
best_clr = clr
|
||||||
|
if best_y is not None:
|
||||||
|
return best_i
|
||||||
|
for i, clr in d.iteritems():
|
||||||
|
y = clr[idx]
|
||||||
|
if best_y is None or y < best_y:
|
||||||
|
best_i = i
|
||||||
|
best_y = y
|
||||||
|
best_clr = clr
|
||||||
|
assert best_i is not None
|
||||||
|
return best_i
|
||||||
|
|
||||||
|
def find_max(idx, occupied, d):
|
||||||
|
best_i = None
|
||||||
|
best_y = None
|
||||||
|
best_clr = None
|
||||||
|
for i, clr in d.iteritems():
|
||||||
|
if i in occupied:
|
||||||
|
continue
|
||||||
|
y = clr[idx]
|
||||||
|
if best_y is None or y > best_y:
|
||||||
|
best_i = i
|
||||||
|
best_y = y
|
||||||
|
best_clr = clr
|
||||||
|
if best_y is not None:
|
||||||
|
return best_i
|
||||||
|
for i, clr in d.iteritems():
|
||||||
|
y = clr[idx]
|
||||||
|
if best_y is None or y > best_y:
|
||||||
|
best_i = i
|
||||||
|
best_y = y
|
||||||
|
best_clr = clr
|
||||||
|
assert best_i is not None
|
||||||
|
return best_i
|
||||||
|
|
||||||
|
def match_colors(colors1, colors2):
|
||||||
|
hsvs1 = dict(enumerate([c.getHCY() for c in colors1 if c is not None]))
|
||||||
|
hsvs2 = dict(enumerate([c.getHCY() for c in colors2 if c is not None]))
|
||||||
|
occupied = []
|
||||||
|
result = {}
|
||||||
|
while len(hsvs1.keys()) > 0:
|
||||||
|
# Darkest of SVG colors
|
||||||
|
darkest1_i = find_min(2, [], hsvs1)
|
||||||
|
# Darkest of palette colors
|
||||||
|
darkest2_i = find_min(2, occupied, hsvs2)
|
||||||
|
hsvs1.pop(darkest1_i)
|
||||||
|
occupied.append(darkest2_i)
|
||||||
|
result[darkest1_i] = darkest2_i
|
||||||
|
if not hsvs1:
|
||||||
|
break
|
||||||
|
|
||||||
|
# Lightest of SVG colors
|
||||||
|
lightest1_i = find_max(2, [], hsvs1)
|
||||||
|
# Lightest of palette colors
|
||||||
|
lightest2_i = find_max(2, occupied, hsvs2)
|
||||||
|
hsvs1.pop(lightest1_i)
|
||||||
|
occupied.append(lightest2_i)
|
||||||
|
result[lightest1_i] = lightest2_i
|
||||||
|
if not hsvs1:
|
||||||
|
break
|
||||||
|
|
||||||
|
# Less saturated of SVG colors
|
||||||
|
grayest1_i = find_min(1, [], hsvs1)
|
||||||
|
# Less saturated of palette colors
|
||||||
|
grayest2_i = find_min(1, occupied, hsvs2)
|
||||||
|
hsvs1.pop(grayest1_i)
|
||||||
|
occupied.append(grayest2_i)
|
||||||
|
result[grayest1_i] = grayest2_i
|
||||||
|
if not hsvs1:
|
||||||
|
break
|
||||||
|
|
||||||
|
# Most saturated of SVG colors
|
||||||
|
saturated1_i = find_max(1, [], hsvs1)
|
||||||
|
# Most saturated of palette colors
|
||||||
|
saturated2_i = find_max(1, occupied, hsvs2)
|
||||||
|
hsvs1.pop(saturated1_i)
|
||||||
|
occupied.append(saturated2_i)
|
||||||
|
result[saturated1_i] = saturated2_i
|
||||||
|
if not hsvs1:
|
||||||
|
break
|
||||||
|
|
||||||
|
redest1_i = find_min(0, [], hsvs1)
|
||||||
|
redest2_i = find_min(0, occupied, hsvs2)
|
||||||
|
hsvs1.pop(redest1_i)
|
||||||
|
occupied.append(redest2_i)
|
||||||
|
result[redest1_i] = redest2_i
|
||||||
|
if not hsvs1:
|
||||||
|
break
|
||||||
|
|
||||||
|
bluest1_i = find_max(0, [], hsvs1)
|
||||||
|
bluest2_i = find_max(0, occupied, hsvs2)
|
||||||
|
hsvs1.pop(bluest1_i)
|
||||||
|
occupied.append(bluest2_i)
|
||||||
|
result[bluest1_i] = bluest2_i
|
||||||
|
|
||||||
|
clrs = []
|
||||||
|
for i in range(len(result.keys())):
|
||||||
|
j = result[i]
|
||||||
|
clrs.append(colors2[j])
|
||||||
|
return clrs
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,96 @@
|
|||||||
|
|
||||||
|
import re
|
||||||
|
from lxml import etree
|
||||||
|
|
||||||
|
from color import colors
|
||||||
|
|
||||||
|
SVG_NS="http://www.w3.org/2000/svg"
|
||||||
|
|
||||||
|
color_re = re.compile("#[0-9a-fA-F]+")
|
||||||
|
|
||||||
|
def walk(processor, element):
|
||||||
|
for child in element.iter():
|
||||||
|
processor(child)
|
||||||
|
|
||||||
|
class Collector(object):
|
||||||
|
def __init__(self):
|
||||||
|
self.colors = {}
|
||||||
|
self.n = 0
|
||||||
|
|
||||||
|
def _parse(self, string):
|
||||||
|
xs = string.split(";")
|
||||||
|
single = len(xs) == 1
|
||||||
|
|
||||||
|
result = {}
|
||||||
|
for x in xs:
|
||||||
|
ts = x.split(":")
|
||||||
|
if len(ts) < 2:
|
||||||
|
if single:
|
||||||
|
return None
|
||||||
|
else:
|
||||||
|
continue
|
||||||
|
key, value = ts[0], ts[1]
|
||||||
|
result[key] = value
|
||||||
|
return result
|
||||||
|
|
||||||
|
def _merge(self, attr):
|
||||||
|
if type(attr) == str:
|
||||||
|
return attr
|
||||||
|
result = ""
|
||||||
|
for key in attr:
|
||||||
|
value = attr[key]
|
||||||
|
result += key + ":" + value + ";"
|
||||||
|
return result
|
||||||
|
|
||||||
|
def _is_color(self, val):
|
||||||
|
return color_re.match(val) is not None
|
||||||
|
|
||||||
|
def _remember_color(self, color):
|
||||||
|
if color not in self.colors:
|
||||||
|
self.colors[color] = self.n
|
||||||
|
self.n += 1
|
||||||
|
n = self.colors[color]
|
||||||
|
return "${color%s}" % n
|
||||||
|
|
||||||
|
def _process_attr(self, value):
|
||||||
|
d = self._parse(value)
|
||||||
|
if d is None:
|
||||||
|
if self._is_color(value):
|
||||||
|
return self._remember_color(value)
|
||||||
|
else:
|
||||||
|
return value
|
||||||
|
elif type(d) == dict:
|
||||||
|
for attr in ['fill', 'stroke', 'stop-color']:
|
||||||
|
if (attr in d) and self._is_color(d[attr]):
|
||||||
|
color = d[attr]
|
||||||
|
d[attr] = self._remember_color(color)
|
||||||
|
return self._merge(d)
|
||||||
|
else:
|
||||||
|
if self._is_color(value):
|
||||||
|
return self._remember_color(value)
|
||||||
|
else:
|
||||||
|
return value
|
||||||
|
|
||||||
|
def process(self, element):
|
||||||
|
for attr in ['fill', 'stroke', 'style', 'pagecolor', 'bordercolor']:
|
||||||
|
if attr in element.attrib:
|
||||||
|
value = element.get(attr)
|
||||||
|
element.set(attr, self._process_attr(value))
|
||||||
|
|
||||||
|
def result(self):
|
||||||
|
return self.colors
|
||||||
|
|
||||||
|
def read_template(filename):
|
||||||
|
xml = etree.parse(filename)
|
||||||
|
collector = Collector()
|
||||||
|
walk(collector.process, xml.getroot())
|
||||||
|
svg = etree.tostring(xml, encoding='utf-8', xml_declaration=True, pretty_print=True)
|
||||||
|
#open("last_template.svg",'w').write(svg)
|
||||||
|
color_dict = collector.result()
|
||||||
|
colors_inv = dict((v,k) for k, v in color_dict.iteritems())
|
||||||
|
svg_colors = []
|
||||||
|
for key in range(len(colors_inv.keys())):
|
||||||
|
clr = colors_inv[key]
|
||||||
|
svg_colors.append( colors.fromHex(clr) )
|
||||||
|
return svg_colors, svg
|
||||||
|
|
||||||
@ -0,0 +1,135 @@
|
|||||||
|
|
||||||
|
from string import Template
|
||||||
|
from PyQt4 import QtGui, QtSvg, QtCore
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color.spaces import *
|
||||||
|
import svg, transform, matching
|
||||||
|
|
||||||
|
class SvgTemplateWidget(QtSvg.QSvgWidget):
|
||||||
|
template_loaded = QtCore.pyqtSignal()
|
||||||
|
colors_matched = QtCore.pyqtSignal()
|
||||||
|
file_dropped = QtCore.pyqtSignal(unicode)
|
||||||
|
|
||||||
|
def __init__(self, *args):
|
||||||
|
QtSvg.QSvgWidget.__init__(self, *args)
|
||||||
|
self.setAcceptDrops(True)
|
||||||
|
self._colors = [Color(i*10,i*10,i*10) for i in range(20)]
|
||||||
|
self._template = None
|
||||||
|
self._template_filename = None
|
||||||
|
self._svg = None
|
||||||
|
self._need_render = True
|
||||||
|
self._svg_colors = None
|
||||||
|
self._dst_colors = None
|
||||||
|
self._last_size = None
|
||||||
|
|
||||||
|
def sizeHint(self):
|
||||||
|
if self.renderer().isValid():
|
||||||
|
return self.renderer().defaultSize()
|
||||||
|
elif self._last_size:
|
||||||
|
return self._last_size
|
||||||
|
else:
|
||||||
|
return QtCore.QSize(300,300)
|
||||||
|
|
||||||
|
|
||||||
|
def dragEnterEvent(self, event):
|
||||||
|
if event.mimeData().hasUrls():
|
||||||
|
event.acceptProposedAction()
|
||||||
|
|
||||||
|
def dropEvent(self, event):
|
||||||
|
if event.mimeData().hasUrls():
|
||||||
|
urls = event.mimeData().urls()
|
||||||
|
path = unicode( urls[0].path() )
|
||||||
|
self.file_dropped.emit(path)
|
||||||
|
|
||||||
|
def _get_color(self, i):
|
||||||
|
if i < len(self._colors):
|
||||||
|
return self._colors[i]
|
||||||
|
else:
|
||||||
|
return Color(i*10, i*10, i*10)
|
||||||
|
|
||||||
|
def _update(self):
|
||||||
|
arr = QtCore.QByteArray.fromRawData(self.get_svg())
|
||||||
|
print("Data loaded: {} bytes".format(arr.length()))
|
||||||
|
self.load(arr)
|
||||||
|
if self.renderer().isValid():
|
||||||
|
self._last_size = self.renderer().defaultSize()
|
||||||
|
self.update()
|
||||||
|
|
||||||
|
def _get_image(self):
|
||||||
|
w,h = self.size().width(), self.size().height()
|
||||||
|
image = QtGui.QImage(w, h, QtGui.QImage.Format_ARGB32_Premultiplied)
|
||||||
|
image.fill(0)
|
||||||
|
qp = QtGui.QPainter()
|
||||||
|
qp.begin(image)
|
||||||
|
self.renderer().render(qp, QtCore.QRectF(0.0, 0.0, w, h))
|
||||||
|
qp.end()
|
||||||
|
return image
|
||||||
|
|
||||||
|
def loadTemplate(self, filename):
|
||||||
|
self._template_filename = filename
|
||||||
|
self._svg_colors, self._template = svg.read_template(filename)
|
||||||
|
print("Source SVG colors:")
|
||||||
|
for c in self._svg_colors:
|
||||||
|
print str(c)
|
||||||
|
print("Template loaded: {}: {} bytes".format(filename, len(self._template)))
|
||||||
|
self._need_render = True
|
||||||
|
self._update()
|
||||||
|
self.template_loaded.emit()
|
||||||
|
|
||||||
|
def set_color(self, idx, color):
|
||||||
|
self._colors[idx] = color
|
||||||
|
self._need_render = True
|
||||||
|
self._update()
|
||||||
|
|
||||||
|
def setColors(self, dst_colors, space=HCY):
|
||||||
|
if not dst_colors:
|
||||||
|
return
|
||||||
|
print("Matching colors in space: {}".format(space))
|
||||||
|
self._dst_colors = dst_colors
|
||||||
|
self._colors = transform.match_colors(space, self._svg_colors, dst_colors)
|
||||||
|
#self._colors = matching.match_colors(self._svg_colors, dst_colors)
|
||||||
|
self._need_render = True
|
||||||
|
self._update()
|
||||||
|
self.colors_matched.emit()
|
||||||
|
|
||||||
|
def resetColors(self):
|
||||||
|
self.load(self._template_filename)
|
||||||
|
self.repaint()
|
||||||
|
|
||||||
|
def get_svg_colors(self):
|
||||||
|
return self._svg_colors
|
||||||
|
|
||||||
|
def get_dst_colors(self):
|
||||||
|
return self._colors
|
||||||
|
|
||||||
|
def get_svg(self):
|
||||||
|
if self._svg is not None and not self._need_render:
|
||||||
|
return self._svg
|
||||||
|
else:
|
||||||
|
self._svg = self._render()
|
||||||
|
self._need_render = False
|
||||||
|
return self._svg
|
||||||
|
|
||||||
|
def _render(self):
|
||||||
|
#d = dict([("color"+str(i), color.hex() if color is not None else Color(255,255,255)) for i, color in enumerate(self._colors)])
|
||||||
|
d = ColorDict(self._colors)
|
||||||
|
#self._image = self._get_image()
|
||||||
|
return Template(self._template).substitute(d)
|
||||||
|
|
||||||
|
class ColorDict(object):
|
||||||
|
def __init__(self, colors):
|
||||||
|
self._colors = colors
|
||||||
|
|
||||||
|
def __getitem__(self, key):
|
||||||
|
if key.startswith("color"):
|
||||||
|
n = int( key[5:] )
|
||||||
|
if n < len(self._colors):
|
||||||
|
return self._colors[n].hex()
|
||||||
|
else:
|
||||||
|
return "#ffffff"
|
||||||
|
else:
|
||||||
|
raise KeyError(key)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,243 @@
|
|||||||
|
#!/usr/bin/python
|
||||||
|
|
||||||
|
# -*- coding: utf-8 -*-
|
||||||
|
|
||||||
|
# -y11+a13*x13+a12*x12+a11*x11+b1
|
||||||
|
# -y12+a23*x13+a22*x12+a21*x11+b2
|
||||||
|
# -y13+a33*x13+a32*x12+a31*x11+b3
|
||||||
|
# -y21+a13*x23+a12*x22+a11*x21+b1
|
||||||
|
# -y22+a23*x23+a22*x22+a21*x21+b2
|
||||||
|
# -y23+a33*x23+a32*x22+a31*x21+b3
|
||||||
|
# -y31+a13*x33+a12*x32+a11*x31+b1
|
||||||
|
# -y32+a23*x33+a22*x32+a21*x31+b2
|
||||||
|
# -y33+a33*x33+a32*x32+a31*x31+b3
|
||||||
|
# -y41+a13*x43+a12*x42+a11*x41+b1
|
||||||
|
# -y42+a23*x43+a22*x42+a21*x41+b2
|
||||||
|
# -y43+a33*x43+a32*x42+a31*x41+b3
|
||||||
|
|
||||||
|
from math import sqrt
|
||||||
|
import itertools
|
||||||
|
import numpy as np
|
||||||
|
from numpy.linalg import solve, det
|
||||||
|
from numpy.linalg.linalg import LinAlgError
|
||||||
|
from copy import deepcopy as copy
|
||||||
|
from PyQt4 import QtGui
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color.spaces import *
|
||||||
|
|
||||||
|
def get_A(x):
|
||||||
|
return np.array([[x[0][0], x[0][1], x[0][2], 0, 0, 0, 0, 0, 0, 1, 0, 0],
|
||||||
|
[0, 0, 0, x[0][0], x[0][1], x[0][2], 0, 0, 0, 0, 1, 0],
|
||||||
|
[0, 0, 0, 0, 0, 0, x[0][0], x[0][1], x[0][2], 0, 0, 1],
|
||||||
|
[x[1][0], x[1][1], x[1][2], 0, 0, 0, 0, 0, 0, 1, 0, 0],
|
||||||
|
[0, 0, 0, x[1][0], x[1][1], x[1][2], 0, 0, 0, 0, 1, 0],
|
||||||
|
[0, 0, 0, 0, 0, 0, x[1][0], x[1][1], x[1][2], 0, 0, 1],
|
||||||
|
[x[2][0], x[2][1], x[2][2], 0, 0, 0, 0, 0, 0, 1, 0, 0],
|
||||||
|
[0, 0, 0, x[2][0], x[2][1], x[2][2], 0, 0, 0, 0, 1, 0],
|
||||||
|
[0, 0, 0, 0, 0, 0, x[2][0], x[2][1], x[2][2], 0, 0, 1],
|
||||||
|
[x[3][0], x[3][1], x[3][2], 0, 0, 0, 0, 0, 0, 1, 0, 0],
|
||||||
|
[0, 0, 0, x[3][0], x[3][1], x[3][2], 0, 0, 0, 0, 1, 0],
|
||||||
|
[0, 0, 0, 0, 0, 0, x[3][0], x[3][1], x[3][2], 0, 0, 1] ])
|
||||||
|
|
||||||
|
def get_B(y):
|
||||||
|
return np.array([[y[0][0]], [y[0][1]], [y[0][2]],
|
||||||
|
[y[1][0]], [y[1][1]], [y[1][2]],
|
||||||
|
[y[2][0]], [y[2][1]], [y[2][2]],
|
||||||
|
[y[3][0]], [y[3][1]], [y[3][2]] ])
|
||||||
|
|
||||||
|
def color_row(space, color):
|
||||||
|
x1,x2,x3 = space.getCoords(color)
|
||||||
|
return np.array([x1,x2,x3])
|
||||||
|
|
||||||
|
def color_column(space, color):
|
||||||
|
x1,x2,x3 = space.getCoords(color)
|
||||||
|
return np.array([[x1],[x2],[x3]])
|
||||||
|
|
||||||
|
def colors_array(space, *colors):
|
||||||
|
return np.array([color_row(space, c) for c in colors])
|
||||||
|
|
||||||
|
def find_transform_colors(space, cx1, cx2, cx3, cx4, cy1, cy2, cy3, cy4):
|
||||||
|
x = colors_array(space, cx1, cx2, cx3, cx4)
|
||||||
|
y = colors_array(space, cy1, cy2, cy3, cy4)
|
||||||
|
return find_transform(x,y)
|
||||||
|
|
||||||
|
def find_transform(x, y):
|
||||||
|
#print("X:\n"+str(x))
|
||||||
|
#print("Y:\n"+str(y))
|
||||||
|
m = solve(get_A(x), get_B(y))
|
||||||
|
a = np.array([[m[0][0], m[1][0], m[2][0]],
|
||||||
|
[m[3][0], m[4][0], m[5][0]],
|
||||||
|
[m[6][0], m[7][0], m[8][0]]])
|
||||||
|
b = np.array([[m[9][0]], [m[10][0]], [m[11][0]]])
|
||||||
|
return (a, b)
|
||||||
|
|
||||||
|
def transform_colors(space, a, b, cx):
|
||||||
|
x = color_column(space, cx)
|
||||||
|
y = a.dot(x) + b
|
||||||
|
#print("X: " + str(x))
|
||||||
|
#print("Y: " + str(y))
|
||||||
|
return space.fromCoords(y[0][0], y[1][0], y[2][0])
|
||||||
|
|
||||||
|
def transform(a, b, x):
|
||||||
|
#print(type(x))
|
||||||
|
return a.dot(x[:,None]) + b
|
||||||
|
|
||||||
|
def rhoC(space, color1, color2):
|
||||||
|
x1,y1,z1 = space.getCoords(color1)
|
||||||
|
x2,y2,z2 = space.getCoords(color2)
|
||||||
|
return sqrt((x1-x2)**2 + (y1-y2)**2 + (z1-z2)**2)
|
||||||
|
|
||||||
|
def rho(c1, c2):
|
||||||
|
x1,y1,z1 = c1[0], c1[1], c1[2]
|
||||||
|
x2,y2,z2 = c2[0], c2[1], c2[2]
|
||||||
|
return sqrt((x1-x2)**2 + (y1-y2)**2 + (z1-z2)**2)
|
||||||
|
|
||||||
|
def get_center(points):
|
||||||
|
zero = np.array([0,0,0])
|
||||||
|
return sum(points, zero) / float(len(points))
|
||||||
|
|
||||||
|
def get_center_color(space, colors):
|
||||||
|
zero = np.array([0,0,0])
|
||||||
|
points = [space.getCoords(c) for c in colors]
|
||||||
|
center = sum(points, zero) / float(len(points))
|
||||||
|
c1,c2,c3 = center[0], center[1], center[2]
|
||||||
|
return space.fromCoords((c1,c2,c3))
|
||||||
|
|
||||||
|
def get_nearest(x, occupied, points):
|
||||||
|
min_rho = None
|
||||||
|
min_p = None
|
||||||
|
for p in points:
|
||||||
|
if any([(p == o).all() for o in occupied]):
|
||||||
|
continue
|
||||||
|
r = rho(x,p)
|
||||||
|
if min_rho is None or r < min_rho:
|
||||||
|
min_rho = r
|
||||||
|
min_p = p
|
||||||
|
if min_p is not None:
|
||||||
|
occupied.append(min_p)
|
||||||
|
#print("Now occupied : " + str(x))
|
||||||
|
return min_p
|
||||||
|
#print("Was occupied : " + str(x))
|
||||||
|
for p in points:
|
||||||
|
r = rho(x,p)
|
||||||
|
if min_rho is None or r < min_rho:
|
||||||
|
min_rho = r
|
||||||
|
min_p = p
|
||||||
|
return min_p
|
||||||
|
|
||||||
|
def get_nearest_color(space, occupied, cx, colors):
|
||||||
|
points = [space.getCoords(c) for c in colors]
|
||||||
|
cy = get_nearest(space.getCoords(cx), occupied, points)
|
||||||
|
return space.fromCoords((cy[0], cy[1], cy[2]))
|
||||||
|
|
||||||
|
def exclude(lst, x):
|
||||||
|
return [p for p in lst if not (p == x).all()]
|
||||||
|
|
||||||
|
def get_farest(points):
|
||||||
|
#center = get_center(points)
|
||||||
|
#print(str(center))
|
||||||
|
points_ = copy(points)
|
||||||
|
darkest = min(points_, key = lambda p: p[2])
|
||||||
|
points_ = exclude(points_, darkest)
|
||||||
|
lightest = max(points_, key = lambda p: p[2])
|
||||||
|
points_ = exclude(points_, lightest)
|
||||||
|
grayest = min(points_, key = lambda p: p[1])
|
||||||
|
points_ = exclude(points_, grayest)
|
||||||
|
most_saturated = max(points_, key = lambda p: p[1])
|
||||||
|
return [darkest, lightest, grayest, most_saturated]
|
||||||
|
#srt = sorted(points, key = lambda c: -rho(center, c))
|
||||||
|
#return srt[:4]
|
||||||
|
|
||||||
|
def get_farest_colors(space, colors):
|
||||||
|
points = [space.getCoords(c) for c in colors]
|
||||||
|
farest = get_farest(points)
|
||||||
|
return [space.fromCoords(c) for c in farest]
|
||||||
|
|
||||||
|
def match_colors_(space, colors1, colors2):
|
||||||
|
try:
|
||||||
|
points1 = [color_row(space, c) for c in colors1 if c is not None]
|
||||||
|
points2 = [color_row(space, c) for c in colors2 if c is not None]
|
||||||
|
farest1 = get_farest(points1)
|
||||||
|
farest2 = get_farest(points2)
|
||||||
|
a, b = find_transform(farest1, farest2)
|
||||||
|
#print("A:\n" + str(a))
|
||||||
|
#print("B:\n" + str(b))
|
||||||
|
print("Matching colors:")
|
||||||
|
for p1, p2 in zip(farest1, farest2):
|
||||||
|
print(" {} -> {}".format(p1,p2))
|
||||||
|
transformed = [transform(a, b, x) for x in points1]
|
||||||
|
occupied = []
|
||||||
|
matched = []
|
||||||
|
for x in transformed:
|
||||||
|
y = get_nearest(x, occupied, points2)
|
||||||
|
matched.append(y)
|
||||||
|
return [space.fromCoords(x) for x in matched]
|
||||||
|
except LinAlgError as e:
|
||||||
|
print e
|
||||||
|
return colors1
|
||||||
|
|
||||||
|
def match_colors(space, colors1, colors2):
|
||||||
|
points1 = [color_row(space, c) for c in colors1 if c is not None]
|
||||||
|
points2 = [color_row(space, c) for c in colors2 if c is not None]
|
||||||
|
c1 = get_center(points1)
|
||||||
|
c2 = get_center(points2)
|
||||||
|
#print c1, c2
|
||||||
|
print("Centers difference: {}".format(c2-c1))
|
||||||
|
szs1 = np.vstack([abs(c1-p) for p in points1]).max(axis=0)
|
||||||
|
szs2 = np.vstack([abs(c2-p) for p in points2]).max(axis=0)
|
||||||
|
if (szs1 == 0).any():
|
||||||
|
zoom = np.array([1,1,1])
|
||||||
|
else:
|
||||||
|
zoom = szs2 / szs1
|
||||||
|
print("Scale by axes: {}".format(zoom))
|
||||||
|
transformed = [(p-c1)*zoom + c2 for p in points1]
|
||||||
|
occupied = []
|
||||||
|
matched = []
|
||||||
|
deltas = []
|
||||||
|
for x in transformed:
|
||||||
|
y = get_nearest(x, occupied, points2)
|
||||||
|
matched.append(y)
|
||||||
|
deltas.append(abs(y-x))
|
||||||
|
delta = np.vstack(deltas).max(axis=0)
|
||||||
|
print("Maximum deltas from affine transformed to source colors: {}".format(delta))
|
||||||
|
return [space.fromCoords(x) for x in matched]
|
||||||
|
|
||||||
|
def find_simple_transform(space, colors1, colors2):
|
||||||
|
points1 = [color_row(space, c) for c in colors1 if c is not None]
|
||||||
|
points2 = [color_row(space, c) for c in colors2 if c is not None]
|
||||||
|
c1 = get_center(points1)
|
||||||
|
c2 = get_center(points2)
|
||||||
|
#transfer = c2 - c1
|
||||||
|
szs1 = max([abs(c1-p) for p in points1])
|
||||||
|
szs2 = max([abs(c2-p) for p in points2])
|
||||||
|
if (szs1 == 0).any():
|
||||||
|
zoom = np.array([1,1,1])
|
||||||
|
else:
|
||||||
|
zoom = szs2 / szs1
|
||||||
|
return (c1, c2, zoom)
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
|
||||||
|
x1 = Color(0,0,0)
|
||||||
|
x2 = Color(0,10,0)
|
||||||
|
x3 = Color(0,0,20)
|
||||||
|
x4 = Color(20,0,10)
|
||||||
|
x5 = Color(10,10,10)
|
||||||
|
x6 = Color(0,20,0)
|
||||||
|
x7 = Color(0,0,40)
|
||||||
|
x8 = Color(40,0,20)
|
||||||
|
|
||||||
|
y1 = Color(0,0,0)
|
||||||
|
y2 = Color(0,10,0)
|
||||||
|
y3 = Color(0,0,20)
|
||||||
|
y4 = Color(20,0,10)
|
||||||
|
y5 = Color(10,10,10)
|
||||||
|
y6 = Color(0,20,0)
|
||||||
|
y7 = Color(0,0,40)
|
||||||
|
y8 = Color(40,0,20)
|
||||||
|
|
||||||
|
res = match_colors(RGB, [x1,x2,x3,x4,x5,x6,x7,x8], [y1,y2,y3,y4,y5,y6,y7,y8])
|
||||||
|
print([c.getRGB() for c in res])
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,17 @@
|
|||||||
|
def load_palette(filename, mixer=None, options=None):
|
||||||
|
if mixer is None:
|
||||||
|
mixer = mixers.MixerRGB
|
||||||
|
loader = detect_storage(filename)
|
||||||
|
if loader is None:
|
||||||
|
return None
|
||||||
|
palette = loader().load(mixer, filename, options)
|
||||||
|
return palette
|
||||||
|
|
||||||
|
def save_palette(palette, path, formatname=None):
|
||||||
|
if formatname is not None:
|
||||||
|
loader = get_storage_by_name(formatname)
|
||||||
|
else:
|
||||||
|
loader = detect_storage(path, save=True)
|
||||||
|
if loader is None:
|
||||||
|
raise RuntimeError("Unknown file type!")
|
||||||
|
loader(palette).save(path)
|
||||||
@ -0,0 +1,352 @@
|
|||||||
|
|
||||||
|
from os.path import join, basename
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color import mixers
|
||||||
|
from models.meta import Meta
|
||||||
|
|
||||||
|
NONE = 0
|
||||||
|
USER_DEFINED = 1
|
||||||
|
VERTICALLY_GENERATED = 2
|
||||||
|
HORIZONTALLY_GENERATED = 3
|
||||||
|
DEFAULT_GROUP_SIZE = 7
|
||||||
|
MAX_COLS = 10
|
||||||
|
|
||||||
|
class Slot(object):
|
||||||
|
def __init__(self, color=None, name=None, user_defined=False):
|
||||||
|
self._color = color
|
||||||
|
self._mode = NONE
|
||||||
|
self._user_defined = user_defined
|
||||||
|
self._src_slot1 = None
|
||||||
|
self._src_row1 = None
|
||||||
|
self._src_col1 = None
|
||||||
|
self._src_slot2 = None
|
||||||
|
self._src_row2 = None
|
||||||
|
self._src_col2 = None
|
||||||
|
if name:
|
||||||
|
self.name = name
|
||||||
|
|
||||||
|
def get_name(self):
|
||||||
|
if self._color:
|
||||||
|
return self._color.name
|
||||||
|
else:
|
||||||
|
return None
|
||||||
|
|
||||||
|
def set_name(self, name):
|
||||||
|
if self._color:
|
||||||
|
self._color.name = name
|
||||||
|
|
||||||
|
name = property(get_name, set_name)
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
return "<Slot mode={}>".format(self._mode)
|
||||||
|
|
||||||
|
def getColor(self):
|
||||||
|
if self._color is None:
|
||||||
|
return Color(1,1,1)
|
||||||
|
else:
|
||||||
|
return self._color
|
||||||
|
|
||||||
|
def setColor(self, color):
|
||||||
|
self._color = color
|
||||||
|
|
||||||
|
color = property(getColor, setColor)
|
||||||
|
|
||||||
|
def getMode(self):
|
||||||
|
if self._user_defined:
|
||||||
|
return USER_DEFINED
|
||||||
|
else:
|
||||||
|
return self._mode
|
||||||
|
|
||||||
|
def setMode(self, mode):
|
||||||
|
self._mode = mode
|
||||||
|
if mode == USER_DEFINED:
|
||||||
|
self._user_defined = True
|
||||||
|
self._mode = NONE
|
||||||
|
|
||||||
|
mode = property(getMode, setMode)
|
||||||
|
|
||||||
|
def mark(self, user_defined=None):
|
||||||
|
if user_defined is None:
|
||||||
|
user_defined = not self._user_defined
|
||||||
|
#print("Mark: " + str(user_defined))
|
||||||
|
self._user_defined = user_defined
|
||||||
|
|
||||||
|
def setSources(self, slot1, row1, col1, slot2, row2, col2):
|
||||||
|
self._src_slot1 = slot1
|
||||||
|
self._src_row1 = row1
|
||||||
|
self._src_col1 = col1
|
||||||
|
self._src_slot2 = slot2
|
||||||
|
self._src_row2 = row2
|
||||||
|
self._src_col2 = col2
|
||||||
|
#print("Sources: ({},{}) and ({},{})".format(row1,col1, row2,col2))
|
||||||
|
|
||||||
|
def getSource1(self):
|
||||||
|
return self._src_slot1, self._src_row1, self._src_col1
|
||||||
|
|
||||||
|
def getSource2(self):
|
||||||
|
return self._src_slot2, self._src_row2, self._src_col2
|
||||||
|
|
||||||
|
class Palette(object):
|
||||||
|
def __init__(self, mixer, nrows=1, ncols=7):
|
||||||
|
self.mixer = mixer
|
||||||
|
self.nrows = nrows
|
||||||
|
self.ncols = ncols
|
||||||
|
self.slots = [[Slot() for i in range(ncols)] for j in range(nrows)]
|
||||||
|
self.need_recalc_colors = True
|
||||||
|
self.meta = Meta()
|
||||||
|
|
||||||
|
def get_name(self):
|
||||||
|
return self.meta.get("Name", "Untited")
|
||||||
|
|
||||||
|
def set_name(self, name):
|
||||||
|
self.meta["Name"] = name
|
||||||
|
|
||||||
|
name = property(get_name, set_name)
|
||||||
|
|
||||||
|
def mark_color(self, row, column, mark=None):
|
||||||
|
print("Marking color at ({}, {})".format(row,column))
|
||||||
|
slot = self.slots[row][column]
|
||||||
|
slot.mark(mark)
|
||||||
|
self.need_recalc_colors = True
|
||||||
|
self.recalc()
|
||||||
|
|
||||||
|
def setMixer(self, mixer):
|
||||||
|
self.mixer = mixer
|
||||||
|
self.recalc()
|
||||||
|
|
||||||
|
def del_column(self, col):
|
||||||
|
if self.ncols < 2:
|
||||||
|
return
|
||||||
|
new = []
|
||||||
|
for row in self.slots:
|
||||||
|
new_row = []
|
||||||
|
for c, slot in enumerate(row):
|
||||||
|
if c != col:
|
||||||
|
new_row.append(slot)
|
||||||
|
new.append(new_row)
|
||||||
|
self.slots = new
|
||||||
|
self.ncols -= 1
|
||||||
|
self.recalc()
|
||||||
|
|
||||||
|
def add_column(self, col):
|
||||||
|
new = []
|
||||||
|
for row in self.slots:
|
||||||
|
new_row = []
|
||||||
|
for c, slot in enumerate(row):
|
||||||
|
if c == col:
|
||||||
|
new_row.append(Slot())
|
||||||
|
new_row.append(slot)
|
||||||
|
new.append(new_row)
|
||||||
|
self.slots = new
|
||||||
|
self.ncols += 1
|
||||||
|
self.recalc()
|
||||||
|
|
||||||
|
def del_row(self, row):
|
||||||
|
if self.nrows < 2:
|
||||||
|
return
|
||||||
|
new = []
|
||||||
|
for r,row_ in enumerate(self.slots):
|
||||||
|
if r != row:
|
||||||
|
new.append(row_)
|
||||||
|
self.slots = new
|
||||||
|
self.nrows -= 1
|
||||||
|
self.recalc()
|
||||||
|
|
||||||
|
def add_row(self, row):
|
||||||
|
new = []
|
||||||
|
for r,row_ in enumerate(self.slots):
|
||||||
|
if r == row:
|
||||||
|
new_row = [Slot() for k in range(self.ncols)]
|
||||||
|
new.append(new_row)
|
||||||
|
new.append(row_)
|
||||||
|
self.slots = new
|
||||||
|
self.nrows += 1
|
||||||
|
self.recalc()
|
||||||
|
|
||||||
|
def paint(self, row, column, color):
|
||||||
|
self.slots[row][column].color = color
|
||||||
|
self.slots[row][column].mark(True)
|
||||||
|
#self.recalc()
|
||||||
|
|
||||||
|
def erase(self, row, column):
|
||||||
|
self.paint(row, column, Color(0,0,0))
|
||||||
|
|
||||||
|
def getUserDefinedSlots(self):
|
||||||
|
"""Returns list of tuples: (row, column, slot)."""
|
||||||
|
result = []
|
||||||
|
for i,row in enumerate(self.slots):
|
||||||
|
for j,slot in enumerate(row):
|
||||||
|
if slot.mode == USER_DEFINED:
|
||||||
|
result.append((i,j,slot))
|
||||||
|
return result
|
||||||
|
|
||||||
|
def getColor(self, row, column):
|
||||||
|
if self.need_recalc_colors:
|
||||||
|
self.recalc()
|
||||||
|
try:
|
||||||
|
return self.slots[row][column].color
|
||||||
|
except IndexError:
|
||||||
|
#print("Cannot get color ({},{}): size is ({},{})".format(row,column, self.nrows, self.ncols))
|
||||||
|
return Color(255,255,255)
|
||||||
|
|
||||||
|
def getColors(self):
|
||||||
|
if self.need_recalc_colors:
|
||||||
|
self.recalc()
|
||||||
|
return [[slot.color for slot in row] for row in self.slots]
|
||||||
|
|
||||||
|
def setSlots(self, all_slots):
|
||||||
|
m = len(all_slots) % self.ncols
|
||||||
|
if m != 0:
|
||||||
|
for i in range(self.ncols - m):
|
||||||
|
all_slots.append(Slot(Color(255,255,255)))
|
||||||
|
self.slots = []
|
||||||
|
row = []
|
||||||
|
for i, slot in enumerate(all_slots):
|
||||||
|
if i % self.ncols == 0:
|
||||||
|
if len(row) != 0:
|
||||||
|
self.slots.append(row)
|
||||||
|
row = []
|
||||||
|
row.append(slot)
|
||||||
|
self.slots.append(row)
|
||||||
|
self.nrows = len(self.slots)
|
||||||
|
self.need_recalc_colors = True
|
||||||
|
self.recalc()
|
||||||
|
# print(self.slots)
|
||||||
|
|
||||||
|
def user_chosen_slot_down(self, i,j):
|
||||||
|
"""Returns tuple:
|
||||||
|
* Is slot found
|
||||||
|
* Row of found slot
|
||||||
|
* Column of found slot"""
|
||||||
|
|
||||||
|
#print("Searching down ({},{})".format(i,j))
|
||||||
|
for i1 in range(i, self.nrows):
|
||||||
|
try:
|
||||||
|
slot = self.slots[i1][j]
|
||||||
|
#print("Down: check ({},{}): {}".format(i1,j,slot))
|
||||||
|
if slot.mode == USER_DEFINED:
|
||||||
|
#print("Found down ({},{}): ({},{})".format(i,j, i1,j))
|
||||||
|
return True,i1,j
|
||||||
|
except IndexError:
|
||||||
|
print("Cannot get slot at ({}, {})".format(i,j))
|
||||||
|
return False, self.nrows-1,j
|
||||||
|
return False, self.nrows-1,j
|
||||||
|
|
||||||
|
def user_chosen_slot_up(self, i,j):
|
||||||
|
"""Returns tuple:
|
||||||
|
* Is slot found
|
||||||
|
* Row of found slot
|
||||||
|
* Column of found slot"""
|
||||||
|
|
||||||
|
for i1 in range(i-1, -1, -1):
|
||||||
|
if self.slots[i1][j].mode == USER_DEFINED:
|
||||||
|
#print("Found up ({},{}): ({},{})".format(i,j, i1,j))
|
||||||
|
return True,i1,j
|
||||||
|
return False, 0, j
|
||||||
|
|
||||||
|
def fixed_slot_right(self, i,j):
|
||||||
|
"""Returns tuple:
|
||||||
|
* Mode of found slot
|
||||||
|
* Row of found slot
|
||||||
|
* Column of found slot"""
|
||||||
|
|
||||||
|
for j1 in range(j, self.ncols):
|
||||||
|
if self.slots[i][j1].mode in [USER_DEFINED, VERTICALLY_GENERATED]:
|
||||||
|
return self.slots[i][j1].mode, i,j1
|
||||||
|
return NONE, i,self.ncols-1
|
||||||
|
|
||||||
|
def fixed_slot_left(self, i,j):
|
||||||
|
"""Returns tuple:
|
||||||
|
* Mode of found slot
|
||||||
|
* Row of found slot
|
||||||
|
* Column of found slot"""
|
||||||
|
|
||||||
|
for j1 in range(j-1, -1, -1):
|
||||||
|
if self.slots[i][j1].mode in [USER_DEFINED, VERTICALLY_GENERATED]:
|
||||||
|
return self.slots[i][j1].mode, i,j1
|
||||||
|
return NONE, i,0
|
||||||
|
|
||||||
|
def recalc(self):
|
||||||
|
self._calc_modes()
|
||||||
|
self._calc_modes()
|
||||||
|
self._calc_modes()
|
||||||
|
self._calc_colors()
|
||||||
|
self.need_recalc_colors = False
|
||||||
|
|
||||||
|
def _calc_modes(self):
|
||||||
|
for i,row in enumerate(self.slots):
|
||||||
|
for j,slot in enumerate(row):
|
||||||
|
if slot.mode == USER_DEFINED:
|
||||||
|
continue
|
||||||
|
# Should slot be vertically generated?
|
||||||
|
v1,iv1,jv1 = self.user_chosen_slot_down(i,j)
|
||||||
|
v2,iv2,jv2 = self.user_chosen_slot_up(i,j)
|
||||||
|
h1,ih1,jh1 = self.fixed_slot_left(i,j)
|
||||||
|
h2,ih2,jh2 = self.fixed_slot_right(i,j)
|
||||||
|
if v1 and v2: # if there are user chosen slots above and below current
|
||||||
|
slot.mode = VERTICALLY_GENERATED
|
||||||
|
s1 = self.slots[iv1][jv1]
|
||||||
|
s2 = self.slots[iv2][jv2]
|
||||||
|
slot.setSources(s1, iv1, jv1, s2, iv2, jv2)
|
||||||
|
elif ((v1 and j-jv1 > 1) or (v2 and jv2-j > 1)) and ((h1!=USER_DEFINED) or (h2!=USER_DEFINED)):
|
||||||
|
slot.mode = VERTICALLY_GENERATED
|
||||||
|
s1 = self.slots[iv1][jv1]
|
||||||
|
s2 = self.slots[iv2][jv2]
|
||||||
|
slot.setSources(s1, iv1, jv1, s2, iv2, jv2)
|
||||||
|
elif h1 and h2:
|
||||||
|
# if there are fixed slots at left and at right of current
|
||||||
|
slot.mode = HORIZONTALLY_GENERATED
|
||||||
|
s1 = self.slots[ih1][jh1]
|
||||||
|
s2 = self.slots[ih2][jh2]
|
||||||
|
slot.setSources(s1, ih1, jh1, s2, ih2, jh2)
|
||||||
|
elif (h1 or h2) and not (v1 or v2):
|
||||||
|
slot.mode = HORIZONTALLY_GENERATED
|
||||||
|
s1 = self.slots[ih1][jh1]
|
||||||
|
s2 = self.slots[ih2][jh2]
|
||||||
|
slot.setSources(s1, ih1, jh1, s2, ih2, jh2)
|
||||||
|
else:
|
||||||
|
slot.mode = HORIZONTALLY_GENERATED
|
||||||
|
s1 = self.slots[ih1][jh1]
|
||||||
|
s2 = self.slots[ih2][jh2]
|
||||||
|
slot.setSources(s1, ih1, jh1, s2, ih2, jh2)
|
||||||
|
|
||||||
|
def color_transition(self, from_color, to_color, steps, idx):
|
||||||
|
if self.mixer is None:
|
||||||
|
return Color(1,1,1)
|
||||||
|
q = float(idx+1) / float(steps+1)
|
||||||
|
return self.mixer.mix(from_color, to_color, q)
|
||||||
|
|
||||||
|
def _calc_colors(self):
|
||||||
|
for i,row in enumerate(self.slots):
|
||||||
|
for j,slot in enumerate(row):
|
||||||
|
if slot.mode == VERTICALLY_GENERATED:
|
||||||
|
slot_down, iv1, jv1 = slot.getSource1()
|
||||||
|
slot_up, iv2, jv2 = slot.getSource2()
|
||||||
|
clr_down = slot_down.color
|
||||||
|
clr_up = slot_up.color
|
||||||
|
length = iv1-iv2 - 1
|
||||||
|
idx = i-iv2 - 1
|
||||||
|
try:
|
||||||
|
#print("Mixing ({},{}) with ({},{}) to get ({},{})".format(iv1,jv1, iv2,jv2, i,j))
|
||||||
|
clr = self.color_transition(clr_up,clr_down,length, idx)
|
||||||
|
except IndexError:
|
||||||
|
clr = Color(1,1,1)
|
||||||
|
slot.color = clr
|
||||||
|
|
||||||
|
for i,row in enumerate(self.slots):
|
||||||
|
for j,slot in enumerate(row):
|
||||||
|
if slot.mode == HORIZONTALLY_GENERATED:
|
||||||
|
slot_left, ih1, jh1 = slot.getSource1()
|
||||||
|
slot_right, ih2, jh2 = slot.getSource2()
|
||||||
|
clr_left = slot_left.color
|
||||||
|
clr_right = slot_right.color
|
||||||
|
length = jh2-jh1 - 1
|
||||||
|
idx = j-jh1 - 1
|
||||||
|
try:
|
||||||
|
#print("Mixing ({},{}) with ({},{}) to get ({},{})".format(ih1,jh1, ih2,jh2, i,j))
|
||||||
|
clr = self.color_transition(clr_left,clr_right,length, idx)
|
||||||
|
except IndexError:
|
||||||
|
clr = Color(1,1,1)
|
||||||
|
slot.color = clr
|
||||||
|
|
||||||
125
extensions/fablabchemnitz/color_harmony/color_harmony/shades.py
Normal file
125
extensions/fablabchemnitz/color_harmony/color_harmony/shades.py
Normal file
@ -0,0 +1,125 @@
|
|||||||
|
#!/usr/bin/env python
|
||||||
|
# coding=utf-8
|
||||||
|
#
|
||||||
|
# Copyright (C) 2009-2018 Ilya Portnov <portnov84@rambler.ru>
|
||||||
|
# (original 'palette-editor' tool, version 0.0.7)
|
||||||
|
# 2020 Maren Hachmann (extension-ification)
|
||||||
|
#
|
||||||
|
# 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 2 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, write to the Free Software Foundation, Inc.,
|
||||||
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||||
|
|
||||||
|
from color_harmony.colorplus import ColorPlus
|
||||||
|
from color_harmony.utils import clip, seq, variate
|
||||||
|
|
||||||
|
# Shading functions
|
||||||
|
|
||||||
|
# 4 cooler colors
|
||||||
|
def cooler(color, parameter):
|
||||||
|
h,s,v = color.to_hsv()
|
||||||
|
if h < 1.0/6.0:
|
||||||
|
sign = -1.0
|
||||||
|
elif h > 2.0/3.0:
|
||||||
|
sign = -1.0
|
||||||
|
else:
|
||||||
|
sign = 1.0
|
||||||
|
step = 0.1 * parameter
|
||||||
|
result = []
|
||||||
|
for i in range(4):
|
||||||
|
h += sign * step
|
||||||
|
if h > 1.0:
|
||||||
|
h -= 1.0
|
||||||
|
elif h < 0.0:
|
||||||
|
h += 1.0
|
||||||
|
result.append(ColorPlus.from_hsv(h, s, v))
|
||||||
|
return result
|
||||||
|
|
||||||
|
# 4 warmer colors
|
||||||
|
def warmer(color, parameter):
|
||||||
|
h,s,v = color.to_hsv()
|
||||||
|
if h < 1.0/6.0:
|
||||||
|
sign = +1.0
|
||||||
|
elif h > 2.0/3.0:
|
||||||
|
sign = +1.0
|
||||||
|
else:
|
||||||
|
sign = -1.0
|
||||||
|
step = 0.1 * parameter
|
||||||
|
result = []
|
||||||
|
for i in range(4):
|
||||||
|
h += sign * step
|
||||||
|
if h > 1.0:
|
||||||
|
h -= 1.0
|
||||||
|
elif h < 0.0:
|
||||||
|
h += 1.0
|
||||||
|
result.append(ColorPlus.from_hsv(h, s, v))
|
||||||
|
return result
|
||||||
|
|
||||||
|
# returns 2 less saturated and 2 more saturated colors
|
||||||
|
def saturation(color, parameter):
|
||||||
|
h, s, v = color.to_hsv()
|
||||||
|
ss = [clip(x) for x in variate(s, 0.6*parameter, 1.2*parameter)]
|
||||||
|
# we don't want another copy of the original color
|
||||||
|
del ss[2]
|
||||||
|
return [ColorPlus.from_hsv(h, s, v) for s in ss]
|
||||||
|
|
||||||
|
# 2 colors with higher value, and 2 with lower
|
||||||
|
def value(color, parameter):
|
||||||
|
h, s, v = color.to_hsv()
|
||||||
|
vs = [clip(x) for x in variate(v, 0.4*parameter, 0.8*parameter)]
|
||||||
|
del vs[2]
|
||||||
|
return [ColorPlus.from_hsv(h, s, v) for v in vs]
|
||||||
|
|
||||||
|
# 2 colors with higher chroma, and 2 with lower
|
||||||
|
def chroma(color, parameter):
|
||||||
|
h, c, y = color.to_hcy()
|
||||||
|
cs = [clip(x) for x in variate(c, 0.4*parameter, 0.8*parameter)]
|
||||||
|
del cs[2]
|
||||||
|
return [ColorPlus.from_hcy(h, c, y) for c in cs]
|
||||||
|
|
||||||
|
# 2 colors with higher luma, and 2 with lower
|
||||||
|
def luma(color, parameter):
|
||||||
|
h, c, y = color.to_hcy()
|
||||||
|
ys = [clip(x) for x in variate(y, 0.3*parameter, 0.6*parameter)]
|
||||||
|
del ys[2]
|
||||||
|
return [ColorPlus.from_hcy(h, c, y) for y in ys]
|
||||||
|
|
||||||
|
# 2 colors with hue rotated to the left, and 2 rotated to the right
|
||||||
|
def hue(color, parameter):
|
||||||
|
h, c, y = color.to_hcy()
|
||||||
|
hs = [clip(x) for x in variate(h, 0.15*parameter, 0.3*parameter)]
|
||||||
|
del hs[2]
|
||||||
|
return [ColorPlus.from_hcy(h, c, y) for h in hs]
|
||||||
|
|
||||||
|
def hue_luma(color, parameter):
|
||||||
|
h, c, y = color.to_hcy()
|
||||||
|
hs = [clip(x) for x in variate(h, 0.15*parameter, 0.3*parameter)]
|
||||||
|
ys = [clip(x) for x in variate(y, 0.3*parameter, 0.6*parameter)]
|
||||||
|
del ys[2]
|
||||||
|
del hs[2]
|
||||||
|
return [ColorPlus.from_hcy(h, c, y) for h,y in zip(hs, ys)]
|
||||||
|
|
||||||
|
def luma_plus_chroma(color, parameter):
|
||||||
|
h, c, y = color.to_hcy()
|
||||||
|
cs = [clip(x) for x in variate(c, 0.4*parameter, 0.8*parameter)]
|
||||||
|
ys = [clip(x) for x in variate(y, 0.3*parameter, 0.6*parameter)]
|
||||||
|
del cs[2]
|
||||||
|
del ys[2]
|
||||||
|
return [ColorPlus.from_hcy(h, c, y) for c,y in zip(cs, ys)]
|
||||||
|
|
||||||
|
def luma_minus_chroma(color, parameter):
|
||||||
|
h, c, y = color.to_hcy()
|
||||||
|
cs = [clip(x) for x in variate(c, 0.4*parameter, 0.8*parameter)]
|
||||||
|
ys = list(reversed([clip(x) for x in variate(y, 0.3*parameter, 0.6*parameter)]))
|
||||||
|
del cs[2]
|
||||||
|
del ys[2]
|
||||||
|
return [ColorPlus.from_hcy(h, c, y) for c,y in zip(cs, ys)]
|
||||||
@ -0,0 +1 @@
|
|||||||
|
# empty
|
||||||
@ -0,0 +1,180 @@
|
|||||||
|
|
||||||
|
from math import sqrt, isnan
|
||||||
|
import numpy as np
|
||||||
|
|
||||||
|
try:
|
||||||
|
from sklearn.cluster import MeanShift, estimate_bandwidth
|
||||||
|
from sklearn.utils import shuffle
|
||||||
|
|
||||||
|
cluster_analysis_available = True
|
||||||
|
print("Cluster analysis is available")
|
||||||
|
except ImportError:
|
||||||
|
cluster_analysis_available = False
|
||||||
|
print("Cluster analysis is not available")
|
||||||
|
|
||||||
|
try:
|
||||||
|
import Image
|
||||||
|
pil_available = True
|
||||||
|
print("PIL is available")
|
||||||
|
except ImportError:
|
||||||
|
print("PIL is not available")
|
||||||
|
try:
|
||||||
|
from PIL import Image
|
||||||
|
print("Pillow is available")
|
||||||
|
pil_available = True
|
||||||
|
except ImportError:
|
||||||
|
print("Neither PIL or Pillow are available")
|
||||||
|
pil_available = False
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
|
||||||
|
if pil_available:
|
||||||
|
|
||||||
|
def imread(filename):
|
||||||
|
img = Image.open(filename)
|
||||||
|
|
||||||
|
class Box(object):
|
||||||
|
def __init__(self, arr):
|
||||||
|
self._array = arr
|
||||||
|
|
||||||
|
def population(self):
|
||||||
|
return self._array.size
|
||||||
|
|
||||||
|
def axis_size(self, idx):
|
||||||
|
slice_ = self._array[:, idx]
|
||||||
|
M = slice_.max()
|
||||||
|
m = slice_.min()
|
||||||
|
return M - m
|
||||||
|
|
||||||
|
def biggest_axis(self):
|
||||||
|
sizes = [self.axis_size(i) for i in range(3)]
|
||||||
|
return max(range(3), key = lambda i: sizes[i])
|
||||||
|
|
||||||
|
def mean(self):
|
||||||
|
return self._array.mean(axis=0)
|
||||||
|
|
||||||
|
def mean_color(self):
|
||||||
|
size = self._array.size
|
||||||
|
if not size:
|
||||||
|
return None
|
||||||
|
xs = self._array.mean(axis=0)
|
||||||
|
x,y,z = xs[0], xs[1], xs[2]
|
||||||
|
if isnan(x) or isnan(y) or isnan(z):
|
||||||
|
return None
|
||||||
|
return Color(int(x), int(y), int(z))
|
||||||
|
|
||||||
|
def div_pos(self, idx):
|
||||||
|
slice_ = self._array[:, idx]
|
||||||
|
M = slice_.max()
|
||||||
|
m = slice_.min()
|
||||||
|
return (m+M)/2.0
|
||||||
|
|
||||||
|
def divide(self):
|
||||||
|
axis = self.biggest_axis()
|
||||||
|
q = self.div_pos(axis)
|
||||||
|
idxs = self._array[:, axis] > q
|
||||||
|
smaller = self._array[~idxs]
|
||||||
|
bigger = self._array[idxs]
|
||||||
|
self._array = smaller
|
||||||
|
return Box(bigger)
|
||||||
|
|
||||||
|
if pil_available and cluster_analysis_available:
|
||||||
|
|
||||||
|
# Use Means Shift algorithm for cluster analysis
|
||||||
|
|
||||||
|
def cluster_analyze(filename, N=1000):
|
||||||
|
image = imread(filename)
|
||||||
|
w,h,d = tuple(image.shape)
|
||||||
|
image_array = np.array( np.reshape(image, (w * h, d)), dtype=np.float64 )
|
||||||
|
#if image.dtype == 'uint8':
|
||||||
|
# image_array = image_array / 255.0
|
||||||
|
image_array_sample = shuffle(image_array, random_state=0)[:N]
|
||||||
|
bandwidth = estimate_bandwidth(image_array_sample, quantile=0.01, n_samples=500)
|
||||||
|
ms = MeanShift(bandwidth=bandwidth, bin_seeding=True)
|
||||||
|
ms.fit(image_array_sample)
|
||||||
|
cluster_centers = ms.cluster_centers_
|
||||||
|
n_clusters = len(cluster_centers)
|
||||||
|
colors = []
|
||||||
|
print("Number of clusters: {}".format(n_clusters))
|
||||||
|
for x in cluster_centers:
|
||||||
|
#print x
|
||||||
|
clr = Color()
|
||||||
|
clr.setRGB1((x[0], x[1], x[2]))
|
||||||
|
colors.append(clr)
|
||||||
|
return colors
|
||||||
|
|
||||||
|
|
||||||
|
if pil_available:
|
||||||
|
|
||||||
|
# Use very fast algorithm for image analysis, translated from Krita's kis_common_colors_recalculation_runner.cpp
|
||||||
|
# Do not know exactly why does this algorithm work, but it does.
|
||||||
|
# Initial (C) Adam Celarek
|
||||||
|
|
||||||
|
def bin_divide_colors(filename, N=1<<16, n_clusters=49):
|
||||||
|
img = Image.open(filename)
|
||||||
|
if img.mode == 'P':
|
||||||
|
img = img.convert('RGB')
|
||||||
|
w,h = img.size
|
||||||
|
n_pixels = w*h
|
||||||
|
if n_pixels > N:
|
||||||
|
ratio = sqrt( float(N) / float(n_pixels) )
|
||||||
|
w,h = int(w*ratio), int(h*ratio)
|
||||||
|
img = img.resize((w,h))
|
||||||
|
|
||||||
|
image = np.array(img)
|
||||||
|
w,h,d = tuple(image.shape)
|
||||||
|
colors = np.array( np.reshape(image, (w * h, d)), dtype=np.float64 )
|
||||||
|
#if image.dtype == 'uint8':
|
||||||
|
# colors = colors / 255.0
|
||||||
|
colors = colors[:,0:3]
|
||||||
|
|
||||||
|
boxes = [Box(colors)]
|
||||||
|
|
||||||
|
while (len(boxes) < n_clusters * 3/5) and (len(colors) > n_clusters * 3/5):
|
||||||
|
biggest_box = None
|
||||||
|
biggest_box_population = None
|
||||||
|
|
||||||
|
for box in boxes:
|
||||||
|
population = box.population()
|
||||||
|
if population <= 3:
|
||||||
|
continue
|
||||||
|
if biggest_box_population is None or (population > biggest_box_population and box.axis_size(box.biggest_axis()) >= 3):
|
||||||
|
biggest_box = box
|
||||||
|
biggest_box_population = population
|
||||||
|
|
||||||
|
if biggest_box is None or biggest_box.population() <= 3:
|
||||||
|
break
|
||||||
|
|
||||||
|
new_box = biggest_box.divide()
|
||||||
|
boxes.append(new_box)
|
||||||
|
|
||||||
|
while (len(boxes) < n_clusters) and (len(colors) > n_clusters):
|
||||||
|
biggest_box = None
|
||||||
|
biggest_box_axis_size = None
|
||||||
|
|
||||||
|
for box in boxes:
|
||||||
|
if box.population() <= 3:
|
||||||
|
continue
|
||||||
|
size = box.axis_size(box.biggest_axis())
|
||||||
|
if biggest_box_axis_size is None or (size > biggest_box_axis_size and size >= 3):
|
||||||
|
biggest_box = box
|
||||||
|
biggest_box_axis_size = size
|
||||||
|
|
||||||
|
if biggest_box is None or biggest_box.population() <= 3:
|
||||||
|
break
|
||||||
|
|
||||||
|
new_box = biggest_box.divide()
|
||||||
|
boxes.append(new_box)
|
||||||
|
|
||||||
|
result = [box.mean_color() for box in boxes if box.mean_color() is not None]
|
||||||
|
return result
|
||||||
|
|
||||||
|
image_loading_supported = pil_available or cluster_analysis_available
|
||||||
|
|
||||||
|
if pil_available:
|
||||||
|
get_common_colors = bin_divide_colors
|
||||||
|
use_sklearn = False
|
||||||
|
elif cluster_analysis_available :
|
||||||
|
get_common_colors = cluster_analyze
|
||||||
|
use_sklearn = True
|
||||||
|
|
||||||
@ -0,0 +1,83 @@
|
|||||||
|
|
||||||
|
from os.path import join, basename
|
||||||
|
from math import sqrt, floor
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color import mixers
|
||||||
|
from palette.storage.storage import *
|
||||||
|
|
||||||
|
try:
|
||||||
|
from tinycss import make_parser, color3
|
||||||
|
css_support = True
|
||||||
|
except ImportError:
|
||||||
|
print("TinyCSS is not available")
|
||||||
|
css_support = False
|
||||||
|
|
||||||
|
class CSS(Storage):
|
||||||
|
name = 'css'
|
||||||
|
title = _("CSS cascading stylesheet")
|
||||||
|
filters = ["*.css"]
|
||||||
|
can_load = css_support
|
||||||
|
can_save = True
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def check(filename):
|
||||||
|
return True
|
||||||
|
|
||||||
|
def save(self, file_w):
|
||||||
|
pf = open(file_w, 'w')
|
||||||
|
|
||||||
|
for i, row in enumerate(self.palette.slots):
|
||||||
|
for j, slot in enumerate(row):
|
||||||
|
user = "-user" if slot.mode == USER_DEFINED else ""
|
||||||
|
hex = slot.color.hex()
|
||||||
|
s = ".color-{}-{}{} {{ color: {} }};\n".format(i,j, user, hex)
|
||||||
|
pf.write(s)
|
||||||
|
|
||||||
|
pf.close()
|
||||||
|
|
||||||
|
def load(self, mixer, file_r, options=None):
|
||||||
|
self.palette = Palette(mixer)
|
||||||
|
self.palette.ncols = None
|
||||||
|
|
||||||
|
all_slots = []
|
||||||
|
colors = []
|
||||||
|
|
||||||
|
def add_color(clr):
|
||||||
|
for c in colors:
|
||||||
|
if c.getRGB() == clr.getRGB():
|
||||||
|
return None
|
||||||
|
colors.append(clr)
|
||||||
|
return clr
|
||||||
|
|
||||||
|
parser = make_parser('page3')
|
||||||
|
css = parser.parse_stylesheet_file(file_r)
|
||||||
|
for ruleset in css.rules:
|
||||||
|
#print ruleset
|
||||||
|
if ruleset.at_keyword:
|
||||||
|
continue
|
||||||
|
for declaration in ruleset.declarations:
|
||||||
|
#print declaration
|
||||||
|
for token in declaration.value:
|
||||||
|
#print token
|
||||||
|
css_color = color3.parse_color(token)
|
||||||
|
if not isinstance(css_color, color3.RGBA):
|
||||||
|
continue
|
||||||
|
r,g,b = css_color.red, css_color.green, css_color.blue
|
||||||
|
color = Color()
|
||||||
|
color.setRGB1((clip(r), clip(g), clip(b)))
|
||||||
|
color = add_color(color)
|
||||||
|
if not color:
|
||||||
|
continue
|
||||||
|
slot = Slot(color, user_defined=True)
|
||||||
|
all_slots.append(slot)
|
||||||
|
n_colors = len(all_slots)
|
||||||
|
if n_colors > MAX_COLS:
|
||||||
|
self.palette.ncols = max( int( floor(sqrt(n_colors)) ), 1)
|
||||||
|
else:
|
||||||
|
self.palette.ncols = n_colors
|
||||||
|
self.palette.setSlots(all_slots)
|
||||||
|
self.palette.meta["SourceFormat"] = "CSS"
|
||||||
|
print("Loaded palette: {}x{}".format( self.palette.nrows, self.palette.ncols ))
|
||||||
|
return self.palette
|
||||||
|
|
||||||
@ -0,0 +1,188 @@
|
|||||||
|
|
||||||
|
from os.path import join, basename
|
||||||
|
from PyQt4 import QtGui
|
||||||
|
import re
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color import mixers
|
||||||
|
from palette.storage.storage import *
|
||||||
|
|
||||||
|
marker = '# Colors not marked with #USER are auto-generated'
|
||||||
|
|
||||||
|
metare = re.compile("^# (\\w+): (.+)")
|
||||||
|
|
||||||
|
def save_gpl(name, ncols, clrs, file_w):
|
||||||
|
if type(file_w) in [str,unicode]:
|
||||||
|
pf = open(file_w, 'w')
|
||||||
|
do_close = True
|
||||||
|
elif hasattr(file_w,'write'):
|
||||||
|
pf = file_w
|
||||||
|
do_close = False
|
||||||
|
else:
|
||||||
|
raise ValueError("Invalid argument type in save_gpl: {}".format(type(file_w)))
|
||||||
|
pf.write('GIMP Palette\n')
|
||||||
|
pf.write(u"Name: {}\n".format(name).encode('utf-8'))
|
||||||
|
if ncols is not None:
|
||||||
|
pf.write('Columns: %s\n' % ncols)
|
||||||
|
for color in clrs:
|
||||||
|
r, g, b = color.getRGB()
|
||||||
|
n = 'Untitled'
|
||||||
|
s = '%d %d %d %s\n' % (r, g, b, n)
|
||||||
|
pf.write(s)
|
||||||
|
if do_close:
|
||||||
|
pf.close()
|
||||||
|
|
||||||
|
class GimpPalette(Storage):
|
||||||
|
|
||||||
|
name = 'gpl'
|
||||||
|
title = _("Gimp palette")
|
||||||
|
filters = ["*.gpl"]
|
||||||
|
can_save = True
|
||||||
|
can_load = True
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def get_options_widget(dialog, filename):
|
||||||
|
|
||||||
|
def on_columns_changed(n):
|
||||||
|
dialog.options = n
|
||||||
|
dialog.on_current_changed(filename)
|
||||||
|
|
||||||
|
ncols = None
|
||||||
|
pf = open(filename,'r')
|
||||||
|
l = pf.readline().strip()
|
||||||
|
if l != 'GIMP Palette':
|
||||||
|
pf.close()
|
||||||
|
return None
|
||||||
|
for line in pf:
|
||||||
|
line = line.strip()
|
||||||
|
lst = line.split()
|
||||||
|
if lst[0]=='Columns:':
|
||||||
|
ncols = int( lst[1] )
|
||||||
|
break
|
||||||
|
pf.close()
|
||||||
|
|
||||||
|
widget = QtGui.QWidget()
|
||||||
|
box = QtGui.QHBoxLayout()
|
||||||
|
label = QtGui.QLabel(_("Columns: "))
|
||||||
|
spinbox = QtGui.QSpinBox()
|
||||||
|
spinbox.setMinimum(2)
|
||||||
|
spinbox.setMaximum(100)
|
||||||
|
if ncols is None:
|
||||||
|
ncols = MAX_COLS
|
||||||
|
spinbox.setValue(ncols)
|
||||||
|
box.addWidget(label)
|
||||||
|
box.addWidget(spinbox)
|
||||||
|
spinbox.valueChanged.connect(on_columns_changed)
|
||||||
|
widget.setLayout(box)
|
||||||
|
return widget
|
||||||
|
|
||||||
|
def save(self, file_w=None):
|
||||||
|
if type(file_w) in [str,unicode]:
|
||||||
|
pf = open(file_w, 'w')
|
||||||
|
do_close = True
|
||||||
|
elif hasattr(file_w,'write'):
|
||||||
|
pf = file_w
|
||||||
|
do_close = False
|
||||||
|
else:
|
||||||
|
raise ValueError("Invalid argument type in GimpPalette.save: {}".format(type(file_w)))
|
||||||
|
pf.write('GIMP Palette\n')
|
||||||
|
if not hasattr(self.palette, 'name'):
|
||||||
|
if type(file_w) in [str, unicode]:
|
||||||
|
self.palette.name = basename(file_w)
|
||||||
|
else:
|
||||||
|
self.palette.name='Colors'
|
||||||
|
pf.write(u"Name: {}\n".format(self.palette.name).encode('utf-8'))
|
||||||
|
if hasattr(self.palette, 'ncols') and self.palette.ncols:
|
||||||
|
pf.write('Columns: %s\n' % self.palette.ncols)
|
||||||
|
pf.write(marker+'\n')
|
||||||
|
for key,value in self.palette.meta.items():
|
||||||
|
if key != "Name":
|
||||||
|
pf.write(u"# {}: {}\n".format(key, value).encode('utf-8'))
|
||||||
|
pf.write('#\n')
|
||||||
|
for row in self.palette.slots:
|
||||||
|
for slot in row:
|
||||||
|
if slot.mode == USER_DEFINED:
|
||||||
|
n = slot.name + ' #USER'
|
||||||
|
else:
|
||||||
|
n = slot.name
|
||||||
|
r, g, b = slot.color.getRGB()
|
||||||
|
s = '%d %d %d %s\n' % (r, g, b, n)
|
||||||
|
pf.write(s)
|
||||||
|
for key,value in slot.color.meta.items():
|
||||||
|
if key != "Name":
|
||||||
|
pf.write(u"# {}: {}\n".format(key, value).encode('utf-8'))
|
||||||
|
if do_close:
|
||||||
|
pf.close()
|
||||||
|
|
||||||
|
def load(self, mixer, file_r, force_ncols=None):
|
||||||
|
self.palette = Palette(mixer)
|
||||||
|
self.palette.ncols = None
|
||||||
|
if not file_r:
|
||||||
|
palette.filename = None
|
||||||
|
palette.name = 'Gimp'
|
||||||
|
return
|
||||||
|
elif hasattr(file_r,'read'):
|
||||||
|
pf = file_r
|
||||||
|
self.palette.filename = None
|
||||||
|
do_close = False
|
||||||
|
elif type(file_r) in [str,unicode]:
|
||||||
|
pf = open(file_r)
|
||||||
|
self.palette.filename = file_r
|
||||||
|
do_close = True
|
||||||
|
l = pf.readline().strip()
|
||||||
|
if l != 'GIMP Palette':
|
||||||
|
raise SyntaxError, "Invalid palette file!"
|
||||||
|
self.palette.name = " ".join(pf.readline().strip().split()[1:])
|
||||||
|
all_user = True
|
||||||
|
n_colors = 0
|
||||||
|
all_slots = []
|
||||||
|
reading_header = True
|
||||||
|
for line in pf:
|
||||||
|
line = line.strip()
|
||||||
|
if line==marker:
|
||||||
|
all_user = False
|
||||||
|
meta_match = metare.match(line)
|
||||||
|
if meta_match is not None:
|
||||||
|
key = meta_match.group(1)
|
||||||
|
value = meta_match.group(2)
|
||||||
|
if reading_header:
|
||||||
|
self.palette.meta[key] = value
|
||||||
|
else:
|
||||||
|
clr.meta[key] = value
|
||||||
|
continue
|
||||||
|
if line.startswith('#'):
|
||||||
|
continue
|
||||||
|
lst = line.split()
|
||||||
|
if lst[0]=='Columns:':
|
||||||
|
self.palette.ncols = int( lst[1] )
|
||||||
|
if len(lst) < 3:
|
||||||
|
continue
|
||||||
|
rs,gs,bs = lst[:3]
|
||||||
|
clr = Color(float(rs), float(gs), float(bs))
|
||||||
|
reading_header = False
|
||||||
|
#print(str(clr))
|
||||||
|
slot = Slot(clr)
|
||||||
|
n_colors += 1
|
||||||
|
if all_user or lst[-1]=='#USER':
|
||||||
|
slot.mode = USER_DEFINED
|
||||||
|
name = ' '.join(lst[3:-1])
|
||||||
|
else:
|
||||||
|
name = ' '.join(lst[3:])
|
||||||
|
slot.name = name
|
||||||
|
all_slots.append(slot)
|
||||||
|
if do_close:
|
||||||
|
pf.close()
|
||||||
|
if n_colors < DEFAULT_GROUP_SIZE:
|
||||||
|
self.palette.ncols = n_colors
|
||||||
|
if not self.palette.ncols:
|
||||||
|
if n_colors > MAX_COLS:
|
||||||
|
self.palette.ncols = MAX_COLS
|
||||||
|
else:
|
||||||
|
self.palette.ncols = n_colors
|
||||||
|
if force_ncols is not None:
|
||||||
|
self.palette.ncols = force_ncols
|
||||||
|
self.palette.setSlots(all_slots)
|
||||||
|
self.palette.meta["SourceFormat"] = "Gimp gpl" if all_user else "palette_editor gpl"
|
||||||
|
print("Loaded palette: {}x{}".format( self.palette.nrows, self.palette.ncols ))
|
||||||
|
return self.palette
|
||||||
|
|
||||||
@ -0,0 +1,201 @@
|
|||||||
|
|
||||||
|
from os.path import join, basename, splitext
|
||||||
|
from math import sqrt, floor
|
||||||
|
from PyQt4 import QtGui
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color import spaces
|
||||||
|
from color import mixers
|
||||||
|
from palette.image import PaletteImage
|
||||||
|
from palette.palette import *
|
||||||
|
from palette.storage.storage import *
|
||||||
|
from palette.storage.cluster import *
|
||||||
|
from palette.storage.table import parse_color_table
|
||||||
|
from matching.transform import rho, get_center
|
||||||
|
|
||||||
|
LOAD_MORE = 1
|
||||||
|
LOAD_LESS_COMMON = 2
|
||||||
|
LOAD_LESS_FAREST = 3
|
||||||
|
LOAD_TABLE = 4
|
||||||
|
|
||||||
|
print("Ok")
|
||||||
|
|
||||||
|
class DialogOptions(object):
|
||||||
|
def __init__(self, method):
|
||||||
|
self.method = method
|
||||||
|
self.border_x = 10
|
||||||
|
self.border_y = 10
|
||||||
|
self.gap_x = 10
|
||||||
|
self.gap_y = 10
|
||||||
|
self.size_x = 5
|
||||||
|
self.size_y = 5
|
||||||
|
|
||||||
|
class Image(Storage):
|
||||||
|
name = 'image'
|
||||||
|
title = _("Raster image")
|
||||||
|
filters = ["*.jpg", "*.png", "*.gif"]
|
||||||
|
can_load = image_loading_supported
|
||||||
|
can_save = True
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def check(filename):
|
||||||
|
return True
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def get_options_widget(dialog, filename):
|
||||||
|
if use_sklearn:
|
||||||
|
return None
|
||||||
|
|
||||||
|
def dependencies():
|
||||||
|
if dialog.options is None or dialog.options.method != LOAD_TABLE:
|
||||||
|
table_w.setVisible(False)
|
||||||
|
else:
|
||||||
|
table_w.setVisible(True)
|
||||||
|
|
||||||
|
def on_method_changed(checked):
|
||||||
|
method = None
|
||||||
|
if dialog._more_button.isChecked():
|
||||||
|
method = LOAD_MORE
|
||||||
|
elif dialog._less_button.isChecked():
|
||||||
|
method = LOAD_LESS_COMMON
|
||||||
|
elif dialog._less_farest.isChecked():
|
||||||
|
method = LOAD_LESS_FAREST
|
||||||
|
elif dialog._table.isChecked():
|
||||||
|
method = LOAD_TABLE
|
||||||
|
dialog.options = DialogOptions(method)
|
||||||
|
if method == LOAD_TABLE:
|
||||||
|
dialog.options.border_x = dialog._border_x.value()
|
||||||
|
dialog.options.border_y = dialog._border_y.value()
|
||||||
|
dialog.options.gap_x = dialog._gap_x.value()
|
||||||
|
dialog.options.gap_y = dialog._gap_y.value()
|
||||||
|
dialog.options.size_x = dialog._size_x.value()
|
||||||
|
dialog.options.size_y = dialog._size_y.value()
|
||||||
|
dependencies()
|
||||||
|
dialog.on_current_changed(filename)
|
||||||
|
|
||||||
|
group_box = QtGui.QGroupBox(_("Loading method"))
|
||||||
|
dialog._more_button = more = QtGui.QRadioButton(_("Use 49 most used colors"))
|
||||||
|
dialog._less_button = less = QtGui.QRadioButton(_("Use 9 most used colors and mix them"))
|
||||||
|
dialog._less_farest = less_farest = QtGui.QRadioButton(_("Use 9 most different colors and mix them"))
|
||||||
|
dialog._table = table = QtGui.QRadioButton(_("Load table of colors"))
|
||||||
|
|
||||||
|
table_w = QtGui.QWidget(dialog)
|
||||||
|
table_form = QtGui.QFormLayout(table_w)
|
||||||
|
dialog._border_x = QtGui.QSpinBox(table_w)
|
||||||
|
dialog._border_x.valueChanged.connect(on_method_changed)
|
||||||
|
table_form.addRow(_("Border from right/left side, px"), dialog._border_x)
|
||||||
|
dialog._border_y = QtGui.QSpinBox(table_w)
|
||||||
|
dialog._border_y.valueChanged.connect(on_method_changed)
|
||||||
|
table_form.addRow(_("Border from top/bottom side, px"), dialog._border_y)
|
||||||
|
dialog._gap_x = QtGui.QSpinBox(table_w)
|
||||||
|
dialog._gap_x.valueChanged.connect(on_method_changed)
|
||||||
|
table_form.addRow(_("Width of gap between cells, px"), dialog._gap_x)
|
||||||
|
dialog._gap_y = QtGui.QSpinBox(table_w)
|
||||||
|
dialog._gap_y.valueChanged.connect(on_method_changed)
|
||||||
|
table_form.addRow(_("Height of gap between cells, px"), dialog._gap_y)
|
||||||
|
dialog._size_x = QtGui.QSpinBox(table_w)
|
||||||
|
dialog._size_x.setValue(5)
|
||||||
|
dialog._size_x.valueChanged.connect(on_method_changed)
|
||||||
|
table_form.addRow(_("Number of columns in the table"), dialog._size_x)
|
||||||
|
dialog._size_y = QtGui.QSpinBox(table_w)
|
||||||
|
dialog._size_y.setValue(5)
|
||||||
|
dialog._size_y.valueChanged.connect(on_method_changed)
|
||||||
|
table_form.addRow(_("Number of rows in the table"), dialog._size_y)
|
||||||
|
table_w.setLayout(table_form)
|
||||||
|
|
||||||
|
dependencies()
|
||||||
|
|
||||||
|
more.toggled.connect(on_method_changed)
|
||||||
|
less.toggled.connect(on_method_changed)
|
||||||
|
less_farest.toggled.connect(on_method_changed)
|
||||||
|
table.toggled.connect(on_method_changed)
|
||||||
|
|
||||||
|
if dialog.options is None or dialog.options.method == LOAD_MORE:
|
||||||
|
more.setChecked(True)
|
||||||
|
elif dialog.options.method == LOAD_LESS_COMMON:
|
||||||
|
less.setChecked(True)
|
||||||
|
elif dialog.options.method == LOAD_TABLE:
|
||||||
|
table.setChecked(True)
|
||||||
|
else:
|
||||||
|
less_farest.setChecked(True)
|
||||||
|
|
||||||
|
vbox = QtGui.QVBoxLayout()
|
||||||
|
vbox.addWidget(more)
|
||||||
|
vbox.addWidget(less)
|
||||||
|
vbox.addWidget(less_farest)
|
||||||
|
vbox.addWidget(table)
|
||||||
|
vbox.addWidget(table_w)
|
||||||
|
group_box.setLayout(vbox)
|
||||||
|
return group_box
|
||||||
|
|
||||||
|
def save(self, file_w):
|
||||||
|
w,h = self.palette.ncols * 48, self.palette.nrows * 48
|
||||||
|
image = PaletteImage( self.palette ).get(w,h)
|
||||||
|
print("Writing image: " + file_w)
|
||||||
|
res = image.save(file_w)
|
||||||
|
if not res:
|
||||||
|
image.save(file_w, format='PNG')
|
||||||
|
|
||||||
|
def load(self, mixer, file_r, options=None):
|
||||||
|
def _cmp(clr1,clr2):
|
||||||
|
h1,s1,v1 = clr1.getHSV()
|
||||||
|
h2,s2,v2 = clr2.getHSV()
|
||||||
|
x = cmp(h1,h2)
|
||||||
|
if x != 0:
|
||||||
|
return x
|
||||||
|
x = cmp(v1,v2)
|
||||||
|
if x != 0:
|
||||||
|
return x
|
||||||
|
return cmp(s1,s2)
|
||||||
|
|
||||||
|
def get_farest(space, colors, n=9):
|
||||||
|
points = [space.getCoords(c) for c in colors]
|
||||||
|
center = get_center(points)
|
||||||
|
srt = sorted(points, key = lambda c: -rho(center, c))
|
||||||
|
farest = srt[:n]
|
||||||
|
return [space.fromCoords(c) for c in farest]
|
||||||
|
|
||||||
|
if use_sklearn or options is None or options.method is None or options.method == LOAD_MORE:
|
||||||
|
colors = get_common_colors(file_r)
|
||||||
|
colors.sort(cmp=_cmp)
|
||||||
|
self.palette = create_palette(colors, mixer)
|
||||||
|
return self.palette
|
||||||
|
|
||||||
|
elif options.method == LOAD_TABLE:
|
||||||
|
self.palette = palette = Palette(mixer, nrows=options.size_y, ncols=options.size_x)
|
||||||
|
colors = parse_color_table(file_r, options)
|
||||||
|
|
||||||
|
for i in range(0, options.size_y):
|
||||||
|
for j in range(0, options.size_x):
|
||||||
|
palette.paint(i, j, colors[i][j])
|
||||||
|
|
||||||
|
return palette
|
||||||
|
|
||||||
|
else:
|
||||||
|
if options.method == LOAD_LESS_FAREST:
|
||||||
|
colors = get_common_colors(file_r)
|
||||||
|
colors = get_farest(spaces.RGB, colors)
|
||||||
|
else:
|
||||||
|
colors = get_common_colors(file_r, n_clusters=9)
|
||||||
|
|
||||||
|
self.palette = palette = Palette(mixer, nrows=7, ncols=7)
|
||||||
|
|
||||||
|
palette.paint(0, 0, colors[0])
|
||||||
|
palette.paint(0, 3, colors[1])
|
||||||
|
palette.paint(0, 6, colors[2])
|
||||||
|
palette.paint(3, 0, colors[3])
|
||||||
|
palette.paint(3, 3, colors[4])
|
||||||
|
palette.paint(3, 6, colors[5])
|
||||||
|
palette.paint(6, 0, colors[6])
|
||||||
|
palette.paint(6, 3, colors[7])
|
||||||
|
palette.paint(6, 6, colors[8])
|
||||||
|
|
||||||
|
palette.need_recalc_colors = True
|
||||||
|
palette.recalc()
|
||||||
|
|
||||||
|
name,ext = splitext(basename(file_r))
|
||||||
|
self.palette.meta["SourceFormat"] = ext
|
||||||
|
|
||||||
|
return palette
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,178 @@
|
|||||||
|
|
||||||
|
from os.path import join, basename
|
||||||
|
from PyQt4 import QtGui
|
||||||
|
from lxml import etree as ET
|
||||||
|
from zipfile import ZipFile, ZIP_DEFLATED
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color import mixers
|
||||||
|
from palette.storage.storage import *
|
||||||
|
|
||||||
|
MIMETYPE = "application/x-krita-palette"
|
||||||
|
DEFAULT_GROUP_NAME = "Default (root)"
|
||||||
|
|
||||||
|
class KplPalette(Storage):
|
||||||
|
name = 'kpl'
|
||||||
|
title = _("Krita 4.0+ palette format")
|
||||||
|
filters = ["*.kpl"]
|
||||||
|
can_load = True
|
||||||
|
can_save = True
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def check(filename):
|
||||||
|
try:
|
||||||
|
with ZipFile(filename, 'r') as zf:
|
||||||
|
mimetype = zf.read("mimetype")
|
||||||
|
return (mimetype == MIMETYPE)
|
||||||
|
except Exception as e:
|
||||||
|
print(e)
|
||||||
|
return False
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def get_group_names(filename):
|
||||||
|
result = [DEFAULT_GROUP_NAME]
|
||||||
|
|
||||||
|
with ZipFile(filename, 'r') as zf:
|
||||||
|
colorset_str = zf.read("colorset.xml")
|
||||||
|
colorset = ET.fromstring(colorset_str)
|
||||||
|
|
||||||
|
for xmlgrp in colorset.xpath("//Group"):
|
||||||
|
name = xmlgrp.attrib['name']
|
||||||
|
if name is not None:
|
||||||
|
result.append(name)
|
||||||
|
|
||||||
|
return result
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def get_options_widget(dialog, filename):
|
||||||
|
|
||||||
|
dialog.options = DEFAULT_GROUP_NAME
|
||||||
|
|
||||||
|
def on_group_changed(selector):
|
||||||
|
def handler():
|
||||||
|
dialog.options = selector.currentText()
|
||||||
|
dialog.on_current_changed(filename)
|
||||||
|
return handler
|
||||||
|
|
||||||
|
widget = QtGui.QWidget()
|
||||||
|
box = QtGui.QHBoxLayout()
|
||||||
|
label = QtGui.QLabel(_("Group: "))
|
||||||
|
selector = QtGui.QComboBox()
|
||||||
|
|
||||||
|
for group_name in KplPalette.get_group_names(filename):
|
||||||
|
selector.addItem(group_name)
|
||||||
|
|
||||||
|
selector.currentIndexChanged.connect(on_group_changed(selector))
|
||||||
|
selector.setCurrentIndex(0)
|
||||||
|
|
||||||
|
box.addWidget(label)
|
||||||
|
box.addWidget(selector)
|
||||||
|
widget.setLayout(box)
|
||||||
|
return widget
|
||||||
|
|
||||||
|
def load(self, mixer, file_r, group_name):
|
||||||
|
|
||||||
|
if group_name is None:
|
||||||
|
group_name = DEFAULT_GROUP_NAME
|
||||||
|
|
||||||
|
def find_group(xml):
|
||||||
|
if group_name == DEFAULT_GROUP_NAME:
|
||||||
|
return xml
|
||||||
|
for xmlgrp in xml.xpath("//Group"):
|
||||||
|
if xmlgrp.attrib['name'] == group_name:
|
||||||
|
return xmlgrp
|
||||||
|
return None
|
||||||
|
|
||||||
|
self.palette = Palette(mixer)
|
||||||
|
|
||||||
|
with ZipFile(file_r, 'r') as zf:
|
||||||
|
mimetype = zf.read("mimetype")
|
||||||
|
if mimetype != MIMETYPE:
|
||||||
|
raise Exception("This is not a valid Krita palette file")
|
||||||
|
|
||||||
|
colorset_str = zf.read("colorset.xml")
|
||||||
|
colorset = ET.fromstring(colorset_str)
|
||||||
|
self.palette.ncols = int( colorset.attrib['columns'] )
|
||||||
|
self.palette.name = colorset.attrib.get('name', "Untitled")
|
||||||
|
|
||||||
|
group = find_group(colorset)
|
||||||
|
if group is None:
|
||||||
|
print(u"Cannot find group by name {}".format(group_name).encode('utf-8'))
|
||||||
|
return None
|
||||||
|
else:
|
||||||
|
self.palette.name = self.palette.name + " - " + group.attrib.get('name', 'Untitled')
|
||||||
|
|
||||||
|
all_slots = []
|
||||||
|
n_colors = 0
|
||||||
|
for xmlclr in group.findall('ColorSetEntry'):
|
||||||
|
name = xmlclr.attrib['name']
|
||||||
|
if xmlclr.attrib['bitdepth'] != 'U8':
|
||||||
|
print("Skip color {}: unsupported bitdepth".format(name))
|
||||||
|
continue
|
||||||
|
rgb = xmlclr.find('RGB')
|
||||||
|
if rgb is None:
|
||||||
|
rgb = xmlclr.find('sRGB')
|
||||||
|
if rgb is None:
|
||||||
|
print("Skip color {}: no RGB representation".format(name))
|
||||||
|
continue
|
||||||
|
|
||||||
|
r = float(rgb.attrib['r'].replace(',', '.'))
|
||||||
|
g = float(rgb.attrib['g'].replace(',', '.'))
|
||||||
|
b = float(rgb.attrib['b'].replace(',', '.'))
|
||||||
|
clr = Color()
|
||||||
|
clr.setRGB1((r,g,b))
|
||||||
|
clr.name = name
|
||||||
|
slot = Slot(clr)
|
||||||
|
slot.mode = USER_DEFINED
|
||||||
|
|
||||||
|
all_slots.append(slot)
|
||||||
|
n_colors += 1
|
||||||
|
|
||||||
|
if n_colors < DEFAULT_GROUP_SIZE:
|
||||||
|
self.palette.ncols = n_colors
|
||||||
|
if not self.palette.ncols:
|
||||||
|
if n_colors > MAX_COLS:
|
||||||
|
self.palette.ncols = MAX_COLS
|
||||||
|
else:
|
||||||
|
self.palette.ncols = n_colors
|
||||||
|
#print("Loaded colors: {}".format(len(all_slots)))
|
||||||
|
self.palette.setSlots(all_slots)
|
||||||
|
self.palette.meta["SourceFormat"] = "KRITA KPL"
|
||||||
|
print("Loaded palette: {}x{}".format( self.palette.nrows, self.palette.ncols ))
|
||||||
|
return self.palette
|
||||||
|
|
||||||
|
def save(self, file_w=None):
|
||||||
|
with ZipFile(file_w, 'w', ZIP_DEFLATED) as zf:
|
||||||
|
zf.writestr("mimetype", MIMETYPE)
|
||||||
|
|
||||||
|
xml = ET.Element("Colorset")
|
||||||
|
xml.attrib['version'] = '1.0'
|
||||||
|
xml.attrib['columns'] = str(self.palette.ncols)
|
||||||
|
xml.attrib['name'] = self.palette.name
|
||||||
|
xml.attrib['comment'] = self.palette.meta.get("Comment", "Generated by Palette Editor")
|
||||||
|
|
||||||
|
for i,row in enumerate(self.palette.slots):
|
||||||
|
for j,slot in enumerate(row):
|
||||||
|
color = slot.color
|
||||||
|
name = color.name
|
||||||
|
default_name = "Swatch-{}-{}".format(i,j)
|
||||||
|
if not name:
|
||||||
|
name = default_name
|
||||||
|
|
||||||
|
elem = ET.SubElement(xml, "ColorSetEntry")
|
||||||
|
elem.attrib['spot'] = color.meta.get("Spot", "false")
|
||||||
|
elem.attrib['id'] = default_name
|
||||||
|
elem.attrib['name'] = name
|
||||||
|
elem.attrib['bitdepth'] = 'U8'
|
||||||
|
|
||||||
|
r,g,b = color.getRGB1()
|
||||||
|
srgb = ET.SubElement(elem, "sRGB")
|
||||||
|
srgb.attrib['r'] = str(r)
|
||||||
|
srgb.attrib['g'] = str(g)
|
||||||
|
srgb.attrib['b'] = str(b)
|
||||||
|
|
||||||
|
tree = ET.ElementTree(xml)
|
||||||
|
tree_str = ET.tostring(tree, encoding='utf-8', pretty_print=True, xml_declaration=False)
|
||||||
|
|
||||||
|
zf.writestr("colorset.xml", tree_str)
|
||||||
|
|
||||||
@ -0,0 +1,76 @@
|
|||||||
|
|
||||||
|
from math import floor
|
||||||
|
from os.path import join, basename
|
||||||
|
from lxml import etree as ET
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color import mixers
|
||||||
|
from palette.storage.storage import *
|
||||||
|
|
||||||
|
cmyk_factor = float(1.0/255.0)
|
||||||
|
|
||||||
|
def fromHex_CMYK(s):
|
||||||
|
t = s[1:]
|
||||||
|
cs,ms,ys,ks = t[0:2], t[2:4], t[4:6], t[6:8]
|
||||||
|
c,m,y,k = int(cs,16), int(ms,16), int(ys,16), int(ks,16)
|
||||||
|
c,m,y,k = [float(x)*cmyk_factor for x in [c,m,y,k]]
|
||||||
|
result = Color()
|
||||||
|
result.setCMYK((c,m,y,k))
|
||||||
|
return result
|
||||||
|
|
||||||
|
class Scribus(Storage):
|
||||||
|
name = 'scribus'
|
||||||
|
title = _("Scribus color swatches")
|
||||||
|
filters = ["*.xml"]
|
||||||
|
can_load = True
|
||||||
|
can_save = True
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def check(filename):
|
||||||
|
return ET.parse(filename).getroot().tag == 'SCRIBUSCOLORS'
|
||||||
|
|
||||||
|
def load(self, mixer, file_r, options=None):
|
||||||
|
xml = ET.parse(file_r).getroot()
|
||||||
|
|
||||||
|
colors = []
|
||||||
|
name = xml.attrib.get("Name", "Untitled")
|
||||||
|
|
||||||
|
for elem in xml.findall("COLOR"):
|
||||||
|
if "RGB" in elem.attrib:
|
||||||
|
color = fromHex(elem.attrib["RGB"])
|
||||||
|
colors.append(color)
|
||||||
|
elif "CMYK" in elem.attrib:
|
||||||
|
color = fromHex_CMYK(elem.attrib["CMYK"])
|
||||||
|
colors.append(color)
|
||||||
|
else:
|
||||||
|
continue
|
||||||
|
if "NAME" in elem.attrib:
|
||||||
|
color.meta["Name"] = elem.attrib["NAME"]
|
||||||
|
if "Spot" in elem.attrib:
|
||||||
|
color.meta["Spot"] = elem.attrib["Spot"]
|
||||||
|
if "Register" in elem.attrib:
|
||||||
|
color.meta["Register"] = elem.attrib["Register"]
|
||||||
|
|
||||||
|
self.palette = create_palette(colors)
|
||||||
|
self.palette.name = name
|
||||||
|
return self.palette
|
||||||
|
|
||||||
|
def save(self, file_w):
|
||||||
|
name = self.palette.name
|
||||||
|
if not name:
|
||||||
|
name = "Palette"
|
||||||
|
xml = ET.Element("SCRIBUSCOLORS", NAME=name)
|
||||||
|
|
||||||
|
for i,row in enumerate(self.palette.getColors()):
|
||||||
|
for j,color in enumerate(row):
|
||||||
|
name = color.name
|
||||||
|
if not name:
|
||||||
|
name = "Swatch-{}-{}".format(i,j)
|
||||||
|
elem = ET.SubElement(xml, "COLOR", NAME=name, RGB=color.hex())
|
||||||
|
if "Spot" in color.meta:
|
||||||
|
elem.attrib["Spot"] = color.meta["Spot"]
|
||||||
|
if "Register" in color.meta:
|
||||||
|
elem.attrib["Register"] = color.meta["Register"]
|
||||||
|
|
||||||
|
|
||||||
|
ET.ElementTree(xml).write(file_w, encoding="utf-8", pretty_print=True, xml_declaration=True)
|
||||||
@ -0,0 +1,62 @@
|
|||||||
|
|
||||||
|
from os.path import join, basename
|
||||||
|
from math import sqrt, floor
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color import mixers
|
||||||
|
from palette.palette import *
|
||||||
|
|
||||||
|
class Storage(object):
|
||||||
|
|
||||||
|
name = None
|
||||||
|
title = None
|
||||||
|
filters = []
|
||||||
|
|
||||||
|
can_load = False
|
||||||
|
can_save = False
|
||||||
|
|
||||||
|
def __init__(self, palette=None):
|
||||||
|
self.palette = palette
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def get_filter(cls):
|
||||||
|
return u"{} ({})".format(cls.title, u" ".join(cls.filters))
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def check(filename):
|
||||||
|
return True
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def get_options_widget(dialog, filename):
|
||||||
|
return None
|
||||||
|
|
||||||
|
def load(self, mixer, file_r, *args, **kwargs):
|
||||||
|
raise NotImplemented
|
||||||
|
|
||||||
|
def save(self, file_w):
|
||||||
|
raise NotImplemented
|
||||||
|
|
||||||
|
def create_palette(colors, mixer=None, ncols=None):
|
||||||
|
"""Create Palette from list of Colors."""
|
||||||
|
if mixer is None:
|
||||||
|
mixer = mixers.MixerRGB
|
||||||
|
palette = Palette(mixer)
|
||||||
|
palette.ncols = ncols
|
||||||
|
|
||||||
|
all_slots = []
|
||||||
|
|
||||||
|
for clr in colors:
|
||||||
|
slot = Slot(clr, user_defined=True)
|
||||||
|
all_slots.append(slot)
|
||||||
|
|
||||||
|
n_colors = len(all_slots)
|
||||||
|
|
||||||
|
if palette.ncols is None:
|
||||||
|
if n_colors > MAX_COLS:
|
||||||
|
palette.ncols = max( int( floor(sqrt(n_colors)) ), 1)
|
||||||
|
else:
|
||||||
|
palette.ncols = n_colors
|
||||||
|
|
||||||
|
palette.setSlots(all_slots)
|
||||||
|
return palette
|
||||||
|
|
||||||
@ -0,0 +1,179 @@
|
|||||||
|
|
||||||
|
from os.path import join, basename
|
||||||
|
from PyQt4 import QtGui
|
||||||
|
from lxml import etree as ET
|
||||||
|
|
||||||
|
from color.colors import *
|
||||||
|
from color import mixers
|
||||||
|
from palette.storage.storage import *
|
||||||
|
|
||||||
|
class XmlPalette(Storage):
|
||||||
|
name = 'xml'
|
||||||
|
title = _("CREATE palette format")
|
||||||
|
filters = ["*.xml"]
|
||||||
|
can_load = True
|
||||||
|
can_save = True
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def check(filename):
|
||||||
|
return ET.parse(filename).getroot().tag == 'colors'
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def get_options_widget(dialog, filename):
|
||||||
|
|
||||||
|
def on_group_changed(selector):
|
||||||
|
def handler():
|
||||||
|
dialog.options = selector.currentText()
|
||||||
|
dialog.on_current_changed(filename)
|
||||||
|
return handler
|
||||||
|
|
||||||
|
widget = QtGui.QWidget()
|
||||||
|
box = QtGui.QHBoxLayout()
|
||||||
|
label = QtGui.QLabel(_("Group: "))
|
||||||
|
selector = QtGui.QComboBox()
|
||||||
|
|
||||||
|
xml = ET.parse(filename)
|
||||||
|
for xmlgrp in xml.xpath("//group"):
|
||||||
|
xml_label = xmlgrp.find('label')
|
||||||
|
if xml_label is not None:
|
||||||
|
selector.addItem(xml_label.text)
|
||||||
|
|
||||||
|
selector.currentIndexChanged.connect(on_group_changed(selector))
|
||||||
|
selector.setCurrentIndex(0)
|
||||||
|
|
||||||
|
box.addWidget(label)
|
||||||
|
box.addWidget(selector)
|
||||||
|
widget.setLayout(box)
|
||||||
|
return widget
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def get_group_names(filename):
|
||||||
|
result = []
|
||||||
|
xml = ET.parse(filename)
|
||||||
|
for xmlgrp in xml.xpath("//group"):
|
||||||
|
xml_label = xmlgrp.find('label')
|
||||||
|
if xml_label is not None:
|
||||||
|
result.append(xml_label.text)
|
||||||
|
return result
|
||||||
|
|
||||||
|
def save(self, file_w=None):
|
||||||
|
xml = ET.Element("colors")
|
||||||
|
root_group = ET.SubElement(xml, "group")
|
||||||
|
group = ET.SubElement(root_group, "group")
|
||||||
|
label = ET.SubElement(group, "label")
|
||||||
|
label.text = self.palette.name
|
||||||
|
layout = ET.SubElement(group, "layout", columns=str(self.palette.ncols), expanded="True")
|
||||||
|
|
||||||
|
for key,value in self.palette.meta.items():
|
||||||
|
if key != "Name":
|
||||||
|
meta = ET.SubElement(group, "meta", name=key)
|
||||||
|
meta.text = value
|
||||||
|
|
||||||
|
for i,row in enumerate(self.palette.slots):
|
||||||
|
for j,slot in enumerate(row):
|
||||||
|
color = slot.color
|
||||||
|
name = color.name
|
||||||
|
if not name:
|
||||||
|
name = "Swatch-{}-{}".format(i,j)
|
||||||
|
elem = ET.SubElement(group, "color")
|
||||||
|
label = ET.SubElement(elem, "label")
|
||||||
|
label.text = name
|
||||||
|
if slot.mode == USER_DEFINED:
|
||||||
|
meta = ET.SubElement(elem, "meta", name="user_chosen")
|
||||||
|
meta.text = "True"
|
||||||
|
for key,value in color.meta.items():
|
||||||
|
if key != "Name":
|
||||||
|
meta = ET.SubElement(elem, "meta", name=key)
|
||||||
|
meta.text = value
|
||||||
|
rgb = ET.SubElement(elem, "sRGB")
|
||||||
|
r,g,b = color.getRGB1()
|
||||||
|
rgb.attrib["r"] = str(r)
|
||||||
|
rgb.attrib["g"] = str(g)
|
||||||
|
rgb.attrib["b"] = str(b)
|
||||||
|
|
||||||
|
ET.ElementTree(xml).write(file_w, encoding="utf-8", pretty_print=True, xml_declaration=True)
|
||||||
|
|
||||||
|
def load(self, mixer, file_r, group_name):
|
||||||
|
|
||||||
|
def get_label(grp):
|
||||||
|
xml_label = grp.find('label')
|
||||||
|
if xml_label is None:
|
||||||
|
return None
|
||||||
|
return xml_label.text
|
||||||
|
|
||||||
|
|
||||||
|
def find_group(xml):
|
||||||
|
#print("Searching {}".format(group_name))
|
||||||
|
grp = None
|
||||||
|
for xmlgrp in xml.xpath("//group"):
|
||||||
|
label = get_label(xmlgrp)
|
||||||
|
if label is None:
|
||||||
|
continue
|
||||||
|
#print("Found: {}".format(label))
|
||||||
|
if group_name is None or label == group_name:
|
||||||
|
grp = xmlgrp
|
||||||
|
break
|
||||||
|
return grp
|
||||||
|
|
||||||
|
self.palette = Palette(mixer)
|
||||||
|
self.palette.ncols = None
|
||||||
|
xml = ET.parse(file_r)
|
||||||
|
grp = find_group(xml)
|
||||||
|
if grp is None:
|
||||||
|
print(u"Cannot find group by name {}".format(group_name).encode('utf-8'))
|
||||||
|
return None
|
||||||
|
self.palette.name = get_label(grp)
|
||||||
|
|
||||||
|
layout = grp.find('layout')
|
||||||
|
if layout is not None:
|
||||||
|
self.palette.ncols = int( layout.attrib['columns'] )
|
||||||
|
|
||||||
|
metas = grp.findall('meta')
|
||||||
|
if metas is not None:
|
||||||
|
for meta in metas:
|
||||||
|
key = meta.attrib['name']
|
||||||
|
value = meta.text
|
||||||
|
if key != 'Name':
|
||||||
|
self.palette.meta[key] = value
|
||||||
|
|
||||||
|
all_slots = []
|
||||||
|
n_colors = 0
|
||||||
|
for xmlclr in grp.findall('color'):
|
||||||
|
sRGB = xmlclr.find('sRGB')
|
||||||
|
if sRGB is None:
|
||||||
|
continue
|
||||||
|
attrs = sRGB.attrib
|
||||||
|
r = float(attrs['r'].replace(',','.'))
|
||||||
|
g = float(attrs['g'].replace(',','.'))
|
||||||
|
b = float(attrs['b'].replace(',','.'))
|
||||||
|
clr = Color()
|
||||||
|
clr.setRGB1((r,g,b))
|
||||||
|
slot = Slot(clr)
|
||||||
|
metas = xmlclr.findall('meta')
|
||||||
|
if metas is not None:
|
||||||
|
for meta in metas:
|
||||||
|
key = meta.attrib['name']
|
||||||
|
value = meta.text
|
||||||
|
if key == 'user_chosen' and value == 'True':
|
||||||
|
slot.mode = USER_DEFINED
|
||||||
|
else:
|
||||||
|
clr.meta[key] = value
|
||||||
|
label = xmlclr.find('label')
|
||||||
|
if label is not None:
|
||||||
|
clr.name = label.text
|
||||||
|
all_slots.append(slot)
|
||||||
|
n_colors += 1
|
||||||
|
|
||||||
|
if n_colors < DEFAULT_GROUP_SIZE:
|
||||||
|
self.palette.ncols = n_colors
|
||||||
|
if not self.palette.ncols:
|
||||||
|
if n_colors > MAX_COLS:
|
||||||
|
self.palette.ncols = MAX_COLS
|
||||||
|
else:
|
||||||
|
self.palette.ncols = n_colors
|
||||||
|
#print("Loaded colors: {}".format(len(all_slots)))
|
||||||
|
self.palette.setSlots(all_slots)
|
||||||
|
self.palette.meta["SourceFormat"] = "CREATE XML"
|
||||||
|
print("Loaded palette: {}x{}".format( self.palette.nrows, self.palette.ncols ))
|
||||||
|
return self.palette
|
||||||
|
|
||||||
@ -0,0 +1,49 @@
|
|||||||
|
#!/usr/bin/env python
|
||||||
|
# coding=utf-8
|
||||||
|
#
|
||||||
|
# Copyright (C) 2009-2018 Ilya Portnov <portnov84@rambler.ru>
|
||||||
|
# (original 'palette-editor' tool, version 0.0.7)
|
||||||
|
# 2020 Maren Hachmann (extension-ification)
|
||||||
|
#
|
||||||
|
# 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 2 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, write to the Free Software Foundation, Inc.,
|
||||||
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||||
|
|
||||||
|
|
||||||
|
# Helper functions
|
||||||
|
def circle_hue(i, n, h, max=1.0):
|
||||||
|
h += i * max / n
|
||||||
|
if h > max:
|
||||||
|
h -= max
|
||||||
|
return h
|
||||||
|
|
||||||
|
def seq(start, stop, step=1):
|
||||||
|
n = int(round((stop - start)/step))
|
||||||
|
if n > 1:
|
||||||
|
return([start + step*i for i in range(n+1)])
|
||||||
|
else:
|
||||||
|
return([])
|
||||||
|
|
||||||
|
def variate(x, step=1.0, dmin=1.0, dmax=None):
|
||||||
|
if dmax is None:
|
||||||
|
dmax = dmin
|
||||||
|
return seq(x-dmin, x+dmax, step)
|
||||||
|
|
||||||
|
def clip(x, min=0.0, max=1.0):
|
||||||
|
if x < min:
|
||||||
|
#print("{:.2f} clipped up to {:.2f}".format(x, min))
|
||||||
|
return min
|
||||||
|
if x > max:
|
||||||
|
#print("{:.2f} clipped down to {:.2f}".format(x, max))
|
||||||
|
return max
|
||||||
|
return x
|
||||||
Reference in New Issue
Block a user