दो आयामी रंग रैंप (256x256 मैट्रिक्स) 4 कोने रंग

Question

से अंतर्वेशित क्या मैं हासिल करना चाहते हैं प्रोग्राम के रूप में एक दो आयामी रंग रैंप रंग मूल्यों की एक 256x256 मैट्रिक्स का प्रतिनिधित्व करती तैयार करना है। अपेक्षित परिणाम संलग्न छवि में देखा जा सकता है। क्या मैं एक प्रारंभिक बिंदु के लिए है मैट्रिक्स जहाँ से शेष 254 रंग inbetween अंतर्वेशित किया जाना चाहिए के 4 कोने रंग हैं। जब मैं एक धुरी के लिए रंग interpolating के लिए कुछ सफलता मिली, दो आयामी गणना मुझे कुछ बुरा सिर दर्द देता है। हालांकि छवि में एक गैर-रैखिक रंग ढाल होता है, लेकिन मैं एक रैखिक से खुश हूं।

क्या आप मुझे कुछ संकेत कैसे numpy या अन्य उपकरणों के साथ ऐसा करने के लिए आभारी से भी अधिक हो मैं `करूँगा दे सकता है।

Answer 1

यहाँ एक सुपर कम समाधान scipy.ndimage से zoom function का उपयोग कर रहा है। मैं आरंभिक रंग (यहाँ यादृच्छिक वाले) के साथ एक 2x2 आरजीबी छवि को परिभाषित और बस 256x256 करने के लिए इसे ज़ूम, order=1 प्रक्षेप रैखिक बनाता है। यहाँ कोड है:

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() 

आउटपुट:

Answer 2

यहाँ ImageMagick जो सबसे Linux distros पर स्थापित और OSX के लिए और Windows उपलब्ध है के साथ यह करने के लिए एक बहुत ही कम तरीका है। पाइथन बाइंडिंग भी हैं।

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

प्रथम पंक्ति: वैसे भी, बस आदेश पंक्ति पर, अपनी छवि के 4 कोनों पर रंग के साथ एक 2x2 वर्ग बनाने के लिए, तो ImageMagick विस्तार करने और पूर्ण आकार तक को जोड़ देना आपके प्रत्येक टॉप-बाएं और टॉप-दाएं कोनों में से 1x1 पिक्सेल बनाता है और दोनों तरफ से जोड़ता है। दूसरी पंक्ति आपके नीचे-बाएं और निचले-दाएं कोनों में से प्रत्येक का 1x1 पिक्सेल बनाती है और उन्हें एक तरफ जोड़ती है। अंतिम पंक्ति शीर्ष पंक्ति के नीचे की निचली पंक्ति को जोड़ती है और 256x256 पर इंटरपोलेशन द्वारा बढ़ाती है।

आप बेहतर समझने के लिए क्या हो रहा है चाहते हैं, यहाँ एक ही मूल छवि है लेकिन प्रक्षेप के बजाय निकटतम पड़ोसी का उपयोग कर को बढ़ाया:

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

Answer 3

यहाँ इस द्विरेखीय करने के लिए 3 तरीके हैं प्रक्षेप। पहले संस्करण तीसरे गणित करने के लिए Numpy का उपयोग करता है शुद्ध अजगर के सारे गणित, दूसरी PIL छवि रचना का उपयोग करता है,। जैसा कि अपेक्षित था, शुद्ध पायथन अन्य दृष्टिकोणों की तुलना में काफी धीमी है। नम्पी संस्करण (जिसे Andras Deak द्वारा लिखे गए कोड से लिया गया था) छोटी छवियों के लिए पीआईएल संस्करण जितना तेज़ है, लेकिन बड़ी छवियों के लिए पीआईएल संस्करण काफी तेज़ है।

मैंने पीआईएल में जाडस्क की स्केलिंग तकनीक का उपयोग करने का भी प्रयास किया लेकिन परिणाम अच्छे नहीं थे - मुझे संदेह है कि पीआईएल का इंटरपोलेशन कोड थोड़ा छोटी है।

यदि आप एक ही आकार की इन बिलीनेर ढाल छवियों को बनाना चाहते हैं, तो पीआईएल तकनीक का एक और फायदा होता है: एक बार जब आप रचना मास्क बनाते हैं तो आपको हर छवि के लिए उन्हें पुनर्निर्माण करने की आवश्यकता नहीं होती है।

#!/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') 

उत्पादन

---

बस मस्ती के लिए, यहाँ एक सरल GUI Tkinter का उपयोग कर इन ढ़ाल उत्पन्न करने के लिए इस्तेमाल किया जा सकता है जो कार्यक्रम है।

#!/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()