पाइथन/numpy

Question

का उपयोग करके एक चित्र पर "पेंटिंग" एक सरणी है, मैं पाइथन में नजर रखने की प्रक्रिया को संसाधित करने के लिए एक लाइब्रेरी लिख रहा हूं, और मैं पूरी तरह से नुकीली दुनिया के लिए नया हूं। अनिवार्य रूप से, मैं समय में (x, y) मानों की एक सरणी लेना चाहता हूं और उन निर्देशांकों पर कैनवास पर कुछ आकार "पेंट" करना चाहता हूं। उदाहरण के लिए, आकार एक धुंधला सर्कल हो सकता है।

मेरे पास दिमाग में ऑपरेशन फ़ोटोशॉप में पेंटब्रश टूल का उपयोग करने के समान या कम समान है।

मुझे एक इंटरैक्टिव एल्गोरिदम मिला है जो मेरी "पेंटब्रश" को मेरी छवि की सीमाओं के भीतर ट्रिम करता है और प्रत्येक बिंदु को एक संचयक छवि में जोड़ता है, लेकिन यह धीमा (!) है, और ऐसा लगता है कि शायद मूल रूप से आसान है ऐसा करने का तरीका।

कोई संकेतक कहां से दिखना शुरू कर सकता है?

Answer 1

अपने प्रश्न में आप एक गॉसियन फ़िल्टर का वर्णन करते हैं, जिसके लिए package के माध्यम से समर्थन मिलता है। उदाहरण के लिए:

from scipy import * # rand 
from pylab import * # figure, imshow 
from scipy.ndimage import gaussian_filter 

# random "image" 
I = rand(100, 100) 
figure(1) 
imshow(I) 

# gaussian filter 
J = gaussian_filter(I, sigma=10) 
figure(2) 
imshow(J) 

बेशक

, आप टुकड़ा करने की क्रिया का उपयोग करते हुए पूरे छवि पर लागू कर सकते हैं, या सिर्फ एक पैच पर,:

J = array(I) # copy image 
J[30:70, 30:70] = gaussian_filter(I[30:70, 30:70], sigma=1) # apply filter to subregion 
figure(2) 
imshow(2) 

, अजगर छवि पुस्तकालय बुनियादी छवि हेरफेर के लिए (PIL) शायद आप क्या चाहते हैं।

नोट: "ब्रश" के साथ "पेंटिंग" के लिए, मुझे लगता है कि आप बस अपने ब्रश के साथ एक बूलियन मास्क सरणी बना सकते हैं। उदाहरण के लिए:

# 7x7 boolean mask with the "brush" (example: a _crude_ circle) 
mask = array([[0, 0, 1, 1, 1, 0, 0], 
       [0, 1, 1, 1, 1, 1, 0], 
       [1, 1, 1, 1, 1, 1, 1], 
       [1, 1, 1, 1, 1, 1, 1], 
       [1, 1, 1, 1, 1, 1, 1], 
       [0, 1, 1, 1, 1, 1, 0], 
       [0, 0, 1, 1, 1, 0, 0]], dtype=bool) 

# random image 
I = rand(100, 100) 
# apply filter only on mask 
# compute the gauss. filter only on the 7x7 subregion, not the whole image 
I[40:47, 40:47][mask] = gaussian_filter(I[40:47, 40:47][mask], sigma=1) 

Answer 2

क्या आपने Tkinter देखा है?

Python Image Library कुछ मदद भी हो सकती है।

Answer 3

आप वास्तव में एंड्रयू स्ट्रॉ motmot और libcamiface ध्यान देना चाहिए। उन्होंने कहा कि मक्खी व्यवहार प्रयोगों के लिए इसे इस्तेमाल करता है, लेकिन यह सिर्फ छवि अधिग्रहण की तरह कर रहे हैं और प्रसंस्करण आप कर रहे हैं मुझे लगता है कि के लिए एक लचीला पुस्तकालय है। SciPy2009 में उनकी प्रस्तुति के video है।

तूलिका परिदृश्य आप का उल्लेख के रूप में, मैं विधि .copy() के साथ छवि की एक प्रतिलिपि बनाने चाहते हैं, एक सरणी में तूलिका छवि रखने के लिए, और केवल

arr[first_br_row:last_br_row, first_br_col:last_br_col] += brush[first_row:last_row, first_col:last_col] 

जहां से इसे जोड़ने 1, लेकिन जब आप 'को समायोजित - आप subimage पता करने के लिए जहाँ आप ब्रश और first_row, last_row, first_col, last_col ब्रश क्लिप करने के लिए (सामान्य रूप से उन्हें 0 और # पंक्तियों/कॉलम करने के लिए सेट जोड़ना चाहते हैं first_br_row, last_br_rowfirst_br_col, last_br_col सेट केवल छवि सीमा तक पर्याप्त ब्रश के हिस्से को पेंट करना चाहते हैं)।

आशा है कि सभी मदद करता है।

Answer 4

फूरियर स्पेस में थोड़ा गणित करने में मदद मिल सकती है: एक अनुवाद (एक डायरैक द्वारा संकल्प) फूरियर में एक चरण द्वारा एक साधारण गुणा के बराबर है ... इससे आपका पेंटब्रश सही स्थान पर जाता है (एक समान समाधान से catchmeifyoutry & DWF, लेकिन इस पिक्सेल की तुलना में एक अनुवाद महीन की अनुमति देता है, 2.5 की तरह, कुछ बज के साथ अफसोस)। फिर, इस तरह के स्ट्रोक का एक योग इन परिचालनों का योग है।

कोड में:

import numpy 
import pylab 
from scipy import mgrid 

def FTfilter(image, FTfilter): 
    from scipy.fftpack import fftn, fftshift, ifftn, ifftshift 
    from scipy import real 
    FTimage = fftshift(fftn(image)) * FTfilter 
    return real(ifftn(ifftshift(FTimage))) 

def translate(image, vec): 
    """ 
    Translate image by vec (in pixels) 

    """ 
    u = ((vec[0]+image.shape[0]/2) % image.shape[0]) - image.shape[0]/2 
    v = ((vec[1]+image.shape[1]/2) % image.shape[1]) - image.shape[1]/2 
    f_x, f_y = mgrid[-1:1:1j*image.shape[0], -1:1:1j*image.shape[1]] 
    trans = numpy.exp(-1j*numpy.pi*(u*f_x + v*f_y)) 
    return FTfilter(image, trans) 

def occlude(image, mask): 
    # combine in oclusive mode 
    return numpy.max(numpy.dstack((image, mask)), axis=2) 

if __name__ == '__main__': 
    Image = numpy.random.rand(100, 100) 
    X, Y = mgrid[-1:1:1j*Image.shape[0], -1:1:1j*Image.shape[1]] 
    brush = X**2 + Y**2 < .05 # relative size of the brush 
    # shows the brush 
    pylab.imshow(brush) 

    # move it to some other position/use a threshold to avoid ringing 
    brushed = translate(brush, [20, -10.51]) > .6 
    pylab.imshow(brushed) 

    pylab.imshow(occlude(Image, brushed)) 

    more_strokes = [[40, -15.1], [-40, -15.1], [-25, 15.1], [20, 10], [0, -10], [25, -10.51]] 
    for stroke in more_strokes: 
     brushed = brushed + translate(brush, stroke) > .6 

    pylab.imshow(occlude(Image, brushed)) 

Answer 5

OpenCV NumPy सरणी का उपयोग करता है और बुनियादी ड्राइंग कार्य हैं: हलकों, elipses, पोलीलाइंस ...

एक रेखा खींच करने के लिए आप कॉल कर सकते हैं

cv.line(array,previous_point,new_point,colour,thickness=x) 

हर बार जब आप एक माउस घटना प्राप्त करते हैं।