All geek questions in one place

How can I distribute the list evenly to include extrapolated averages?

I have a Python module that provides color palettes and utilities for working with them. The color palette object is simply inherited from listand is a list of the colors specified in the HEX lines. The object of the color palette has the ability to expand itself to provide as many colors as necessary. Imagine a graph with many different data sets to be presented: a palette may be asked to expand the number of colors it has in the amount necessary to provide unique colors for each graph data set. He does this by simply taking the average of the adjacent colors and inserting this new middle color.

The function extend_paletteworks, but it does not expand the palette evenly. For example, a palette might look like this:

Extending to 15 colors can still be used:

Extending to 30 colors makes the problem with the expansion algorithm obvious; new colors are added only at one end of the color list:

How should the function of the extend_palettemodule be changed to make the expanded new colors more evenly distributed in the palette?

The code follows (the function extend_palettehas a special focus and other bits of code for the convenience of experiments):

def clamp(x): 
    return max(0, min(x, 255))

def RGB_to_HEX(RGB_tuple):
    # This function returns a HEX string given an RGB tuple.
    r = RGB_tuple[0]
    g = RGB_tuple[1]
    b = RGB_tuple[2]
    return "#{0:02x}{1:02x}{2:02x}".format(clamp(r), clamp(g), clamp(b))

def HEX_to_RGB(HEX_string):
    # This function returns an RGB tuple given a HEX string.
    HEX = HEX_string.lstrip("#")
    HEX_length = len(HEX)
    return tuple(
        int(HEX[i:i + HEX_length // 3], 16) for i in range(
            0,
            HEX_length,
            HEX_length // 3
        )
    )

def mean_color(colors_in_HEX):
    # This function returns a HEX string that represents the mean color of a
    # list of colors represented by HEX strings.
    colors_in_RGB = []
    for color_in_HEX in colors_in_HEX:
        colors_in_RGB.append(HEX_to_RGB(color_in_HEX))
    sum_r = 0
    sum_g = 0
    sum_b = 0
    for color_in_RGB in colors_in_RGB:
        sum_r += color_in_RGB[0]
        sum_g += color_in_RGB[1]
        sum_b += color_in_RGB[2]
    mean_r = sum_r / len(colors_in_RGB)
    mean_g = sum_g / len(colors_in_RGB)
    mean_b = sum_b / len(colors_in_RGB)
    return RGB_to_HEX((mean_r, mean_g, mean_b))

class Palette(list):

    def __init__(
        self,
        name        = None, # string name
        description = None, # string description
        colors      = None, # list of colors
        *args
        ):
        super(Palette, self).__init__(*args)
        self._name          = name
        self._description   = description
        self.extend(colors)

    def name(
        self
        ):
        return self._name

    def set_name(
        self,
        name = None
        ):
        self._name = name

    def description(
        self
        ):
        return self._description

    def set_description(
        self,
        description = None
        ):
        self._description = description

    def extend_palette(
        self,
        minimum_number_of_colors_needed = 15
        ):
        colors = extend_palette(
            colors = self,
            minimum_number_of_colors_needed = minimum_number_of_colors_needed
        )
        self = colors

    def save_image_of_palette(
        self,
        filename = "palette.png"
        ):
        save_image_of_palette(
            colors   = self,
            filename = filename
        )

def extend_palette(
    colors = None, # list of HEX string colors
    minimum_number_of_colors_needed = 15
    ):
    while len(colors) < minimum_number_of_colors_needed:
        for index in range(1, len(colors), 2):
            colors.insert(index, mean_color([colors[index - 1], colors[index]]))
    return colors

def save_image_of_palette(
    colors   = None, # list of HEX string colors
    filename = "palette.png"
    ):
    import numpy
    import Image
    scale_x = 200
    scale_y = 124
    data = numpy.zeros((1, len(colors), 3), dtype = numpy.uint8)
    index = -1
    for color in colors:
        index += 1
        color_RGB = HEX_to_RGB(color)
        data[0, index] = [color_RGB[0], color_RGB[1], color_RGB[2]]
    data = numpy.repeat(data, scale_x, axis=0)
    data = numpy.repeat(data, scale_y, axis=1)
    image = Image.fromarray(data)
    image.save(filename)

# Define color palettes.
palettes = []
palettes.append(Palette(
    name        = "palette1",
    description = "primary colors for white background",
    colors      = [
                  "#fc0000",
                  "#ffae3a",
                  "#00ac00",
                  "#6665ec",
                  "#a9a9a9",
                  ]
))
palettes.append(Palette(
    name        = "palette2",
    description = "ATLAS clarity",
    colors      = [
                  "#FEFEFE",
                  "#AACCFF",
                  "#649800",
                  "#9A33CC",
                  "#EE2200",
                  ]
))

def save_images_of_palettes():
    for index, palette in enumerate(palettes):
        save_image_of_palette(
            colors   = palette,
            filename = "palette_{index}.png".format(index = index + 1)
        )

def access_palette(
    name = "palette1"
    ):
    for palette in palettes:
        if palette.name() == name:
            return palette
    return None
+4
source share
2 answers

I think the problem you are having is easier to understand if you start with a simplified example:

nums = [1, 100]

def extend_nums(nums, min_needed):
    while len(nums) < min_needed:
        for index in range(1, len(nums), 2):
            nums.insert(index, mean(nums[index - 1], nums[index]))
    return nums


def mean(x, y):
    return (x + y) / 2

, , . , :

>>> nums = [0, 100]
>>> extend_nums(nums, 5)
[0, 12.5, 25.0, 37.5, 50.0, 100]

?

  • 50 - 0 100.
  • 25 - 0 50.
  • 12.5 - 0 25.
  • 37.5 - 25 50.

, ? , : nums . index for -loop , : nums[3] nums.insert(1, something).

:

def extend_nums(nums, min_needed):
    while len(nums) < min_needed:
        new_nums = []  # This new list will hold the extended nums.
        for index in range(1, len(nums)):
            new_nums.append(nums[index - 1])
            new_nums.append(mean(nums[index - 1], nums[index]))
        new_nums.append(nums[-1])
        nums = new_nums
    return nums

:

>>> nums = [0, 100]
>>> extend_nums(nums, 5)
[0, 25.0, 50.0, 75.0, 100]

( ). ? for -loop index . index.

+3

while len(colors) < minimum_number_of_colors_needed:
    for index in range(1, len(colors), 2):
        colors.insert(index, mean_color([colors[index - 1], colors[index]]))

. , :

colors = range(5)
while len(colors) < 15:
    for index in range(1, len(colors), 2):
        colors.insert(index, 99)
print(colors)


[0, 99, 99, 99, 99, 99, 99, 99, 1, 99, 99, 99, 2, 3, 4]

, 99, , .

, numpy, np.interp . , (0, 10), (0,5, 20), (1, 30), x = [0, 0.33, 0.67, 1], y :

In [80]: np.interp([0, 0.33, 0.67, 1], [0, 0.5, 1], [10, 20, 30])
Out[80]: array([ 10. ,  16.6,  23.4,  30. ])

np.interp 1D-, RGB :

[np.interp(np.linspace(0,1,min_colors), np.linspace(0,1,ncolors), self.rgb[:,i]) 
 for i in range(nchannels)])

,

import numpy as np
import Image

def RGB_to_HEX(RGB_tuple):
    """
    Return a HEX string given an RGB tuple.
    """
    return "#{0:02x}{1:02x}{2:02x}".format(*np.clip(RGB_tuple, 0, 255))


def HEX_to_RGB(HEX_string):
    """
    Return an RGB tuple given a HEX string.
    """
    HEX = HEX_string.lstrip("#")
    HEX_length = len(HEX)
    return tuple(
        int(HEX[i:i + HEX_length // 3], 16) for i in range(
            0,
            HEX_length,
            HEX_length // 3 ))

class Palette(object):

    def __init__(self, name=None, description=None, colors=None, *args):
        super(Palette, self).__init__(*args)
        self.name = name
        self.description = description
        self.rgb = np.array(colors)

    @classmethod
    def from_hex(cls, name=None, description=None, colors=None, *args):
        colors = np.array([HEX_to_RGB(c) for c in colors])
        return cls(name, description, colors, *args)

    def to_hex(self):
        return [RGB_to_HEX(color) for color in self.rgb]

    def extend_palette(self, min_colors=15):
        ncolors, nchannels = self.rgb.shape
        if ncolors >= min_colors:
            return self.rgb

        return np.column_stack(
            [np.interp(
                np.linspace(0,1,min_colors), np.linspace(0,1,ncolors), self.rgb[:,i]) 
             for i in range(nchannels)])

def save_image_of_palette(rgb, filename="palette.png"):
    scale_x = 200
    scale_y = 124
    data = (np.kron(rgb[np.newaxis,...], np.ones((scale_x, scale_y, 1)))
            .astype(np.uint8))
    image = Image.fromarray(data)
    image.save(filename)


# Define color palettes.
palettes = []
palettes.append(Palette.from_hex(
    name="palette1",
    description="primary colors for white background",
    colors=[
        "#fc0000",
        "#ffae3a",
        "#00ac00",
        "#6665ec",
        "#a9a9a9", ]))
palettes.append(Palette.from_hex(
    name="palette2",
    description="ATLAS clarity",
    colors=[
        "#FEFEFE",
        "#AACCFF",
        "#649800",
        "#9A33CC",
        "#EE2200",]))
palettes = {p.name:p for p in palettes}


p = palettes['palette1']
save_image_of_palette(p.extend_palette(), '/tmp/out.png')

, HSV ( RGB) .

+1

Source: https://habr.com/ru/post/1626859/

More articles:


All Articles