Dwuwymiarowa rampa kolorów (matryca 256x256) interpolowana z 4 kolorów narożników

Question

Co chcę osiągnąć, to programowo utworzyć dwuwymiarową rampę kolorów reprezentowaną przez matrycę 256x256 wartości kolorów. Oczekiwany wynik można zobaczyć na załączonym obrazie. To, co mam dla punktu początkowego, to 4 kolory narożne macierzy, z których należy interpolować pozostałe 254 kolory między nimi. Chociaż odniosłem sukces w interpolacji kolorów dla jednej osi, dwuwymiarowe obliczenia dają mi pewne złe bóle głowy. Chociaż wydaje się, że obraz ma nieliniowy gradient koloru, byłbym zadowolony z liniowego.

Jeśli mógłbyś dać mi wskazówki, jak to zrobić za pomocą numpy lub innych narzędzi, będę wdzięczny.

Answer 1

Oto bardzo krótki rozwiązanie używając zoom function z scipy.ndimage. Zdefiniuję obraz 2x2 RGB z kolorami początkowymi (tutaj losowymi) i po prostu powiększam do 256x256, order=1 czyni interpolację liniową. Oto kod:

import numpy as np 
import matplotlib.pyplot as plt 

im=(np.random.rand(2,2,3)*255).astype(np.uint8) 

from scipy.ndimage.interpolation import zoom 
zoomed=zoom(im,(128,128,1),order=1) 

plt.subplot(121) 
plt.imshow(im,interpolation='nearest') 
plt.subplot(122) 
plt.imshow(zoomed,interpolation='nearest') 
plt.show() 

wyjściowa:

Answer 2

Oto bardzo krótki sposób to zrobić z ImageMagick który jest zainstalowany na większości dystrybucji Linuksa i jest dostępny dla OS X i Windows. Istnieją również powiązania w Pythonie. W każdym razie, po prostu w linii poleceń, należy utworzyć kwadrat 2x2 z kolorami w 4 rogach obrazu, pozwól ImageMagick poszerzyć i interpolować aż do pełnego rozmiaru:

convert \(xc:"#59605c" xc:"#ebedb3" +append \) \ 
     \(xc:"#69766d" xc:"#b3b3a0" +append \) \ 
     -append -resize 256x256 result.png 

pierwszej linii tworzy 1x1 piksel każdego z twoich górnych lewych i górnych prawej krawędzi i dołącza dwa obok siebie. Druga linia tworzy 1x1 piksel każdego z twoich dolnych lewych i dolnych prawych rogów i dołącza je obok siebie. Ostatnia linia dodaje dolny rząd poniżej górnego wiersza i powiększa się poprzez interpolację do 256x256.

Jeśli chcesz lepiej zrozumieć, co się dzieje, tutaj jest ten sam podstawowy obraz ale skaluje się za pomocą najbliższego sąsiada zamiast interpolacja:

convert \(xc:"#59605c" xc:"#ebedb3" +append \) \ 
     \(xc:"#69766d" xc:"#b3b3a0" +append \) \ 
     -append -scale 20x20 result.png 

Answer 3

Oto 3 sposoby wykonywania tej dwuliniowy interpolacja. Pierwsza wersja wykonuje całą arytmetykę w czystym Pythonie, druga wykorzystuje kompozycję obrazu PIL, trzecia wykorzystuje Numpy do wykonywania arytmetyki. Zgodnie z oczekiwaniami, czysty Python jest znacznie wolniejszy niż inne podejścia. Wersja Numpy (wywodząca się z kodu napisanego przez Andras Deak) jest prawie tak samo szybka jak wersja PIL dla małych obrazów, ale dla większych obrazów wersja PIL jest zauważalnie szybsza.

Próbowałem również używać techniki skalowania jadsqa w PIL, ale wyniki nie były dobre - podejrzewam, że kod interpolacyjny PIL jest trochę błędny.

Jeśli chcesz utworzyć wiele bilinearnych obrazów tego samego rozmiaru, technika PIL ma jeszcze jedną zaletę: po utworzeniu masek kompozycji nie trzeba ich odbudowywać dla każdego obrazu.

#!/usr/bin/env python3 

''' Simple bilinear interpolation 
    Written by PM 2Ring 2016.09.14 
''' 

from PIL import Image 
from math import floor 
import numpy as np 

def color_square0(colors, size): 
    tl, tr, bl, br = colors 
    m = size - 1 
    r = range(size) 

    def interp_2D(tl, tr, bl, br, x, y): 
     u0, v0 = x/m, y/m 
     u1, v1 = 1 - u0, 1 - v0 
     return floor(0.5 + u1*v1*tl + u0*v1*tr + u1*v0*bl + u0*v0*br) 

    data = bytes(interp_2D(tl[i], tr[i], bl[i], br[i], x, y) 
     for y in r for x in r for i in (0, 1, 2)) 
    return Image.frombytes('RGB', (size, size), data) 

# Fastest 
def color_square1(colors, size): 
    #Make an Image of each corner color 
    tl, tr, bl, br = [Image.new('RGB', (size, size), color=c) for c in colors] 

    #Make the composition mask 
    mask = Image.new('L', (size, size)) 
    m = 255.0/(size - 1) 
    mask.putdata([int(m * x) for x in range(size)] * size) 

    imgt = Image.composite(tr, tl, mask) 
    imgb = Image.composite(br, bl, mask) 
    return Image.composite(imgb, imgt, mask.transpose(Image.TRANSPOSE)) 

# This function was derived from code written by Andras Deak  
def color_square2(colors, size): 
    tl, tr, bl, br = map(np.array, colors) 
    m = size - 1 
    x, y = np.mgrid[0:size, 0:size] 
    x = x[..., None]/m 
    y = y[..., None]/m 
    data = np.floor(x*y*br + (1-x)*y*tr + x*(1-y)*bl + (1-x)*(1-y)*tl + 0.5) 
    return Image.fromarray(np.array(data, dtype = 'uint8'), 'RGB') 

color_square = color_square1 

#tl = (255, 0, 0) 
#tr = (255, 255, 0) 
#bl = (0, 0, 255) 
#br = (0, 255, 0) 

tl = (108, 115, 111) 
tr = (239, 239, 192) 
bl = (124, 137, 129) 
br = (192, 192, 175) 

colors = (tl, tr, bl, br) 
size = 256 
img = color_square(colors, size) 
img.show() 
#img.save('test.png') 

wyjście

---

Tak dla zabawy, oto prosty program GUI używając Tkinter, który może być używany do generowania tych wzniesień.

#!/usr/bin/env python3 

''' Simple bilinear colour interpolation 
    using PIL, in a Tkinter GUI 

    Inspired by https://stackoverflow.com/q/39485178/4014959 

    Written by PM 2Ring 2016.09.15 
''' 

import tkinter as tk 
from tkinter.colorchooser import askcolor 
from tkinter.filedialog import asksaveasfilename 

from PIL import Image, ImageTk 

DEFCOLOR = '#d9d9d9' 
SIZE = 256 

#Make the composition masks 
mask = Image.new('L', (SIZE, SIZE)) 
m = 255.0/(SIZE - 1) 
mask.putdata([int(m * x) for x in range(SIZE)] * SIZE) 
maskt = mask.transpose(Image.TRANSPOSE) 

def do_gradient(): 
    imgt = Image.composite(tr.img, tl.img, mask) 
    imgb = Image.composite(br.img, bl.img, mask) 
    img = Image.composite(imgb, imgt, maskt) 
    ilabel.img = img 
    photo = ImageTk.PhotoImage(img) 
    ilabel.config(image=photo) 
    ilabel.photo = photo 

def set_color(w, c): 
    w.color = c 
    w.config(background=c, activebackground=c) 
    w.img = Image.new('RGB', (SIZE, SIZE), color=c) 

def show_color(w): 
    c = w.color 
    newc = askcolor(c)[1] 
    if newc is not None and newc != c: 
     set_color(w, newc) 
     do_gradient() 

def color_button(row, column, initcolor=DEFCOLOR): 
    b = tk.Button(root) 
    b.config(command=lambda w=b:show_color(w)) 
    set_color(b, initcolor) 
    b.grid(row=row, column=column) 
    return b 

def save_image(): 
    filetypes = [('All files', '.*'), ('PNG files', '.png')] 
    fname = asksaveasfilename(title="Save Image",filetypes=filetypes) 
    if fname: 
     ilabel.img.save(fname) 
     print('Saved image as %r' % fname) 
    else: 
     print('Cancelled') 

root = tk.Tk() 
root.title("Color interpolation") 

coords = ((0, 0), (0, 2), (2, 0), (2, 2)) 
tl, tr, bl, br = [color_button(r, c) for r,c in coords] 

ilabel = tk.Label(root, relief=tk.SUNKEN) 
do_gradient() 
ilabel.grid(row=1, column=1) 

b = tk.Button(root, text="Save", command=save_image) 
b.grid(row=3, column=1) 

root.mainloop()