दिलचस्प पोस्ट
किसी तत्व की घटना के बाहर कोणीय क्लिक करें कैसे एक वैश्विक चर परिभाषित करने के लिए कि मेरे आवेदन में कहीं भी पहुँचा जा सकता है? सी ++ 11 के पीओडी "मानक लेआउट" की परिभाषा किस तरह से है? सकारात्मक वजन के साथ निर्देशित आलेख में कम से कम लंबाई के चक्र का पता लगाएं तुल्यकालिक एजेक्स कॉल का उपयोग करने की कमी क्या है? पृष्ठभूमि छवि पर ओवरले डेटा क्या मतलब है? Enum विशेषता से enum प्राप्त करें अगर Postgres सरणी में मौजूद मान जांचें UITableView में स्क्रॉल स्थिति सेट करना आईओएस ऑटोलायआउट- दृश्यों के बीच दो अलग-अलग दूरी सेट करने के तरीके, स्क्रीन ऊंचाई पर निर्भर करता है स्क्रॉलएव्यू में वेबदृश्य जावा का उपयोग कर फ़ोल्डर में फाइलें ढूंढें व्युत्पन्न ** से बेस में परिवर्तन ** नेटवर्क के लिए विजुअल स्टूडियो 2015 एंड्रॉइड इम्यूलेटर कैसे जुड़ें?

मैं कैसे एक आरजीबी छवि को पायथन में ग्रेस्केल में परिवर्तित कर सकता हूँ?

मैं एक आरजीबी छवि में पढ़ने और इसे ग्रेस्केल में परिवर्तित करने के लिए matplotlib का उपयोग करने की कोशिश कर रहा हूं।

Matlab में मैं इसका उपयोग करता हूँ:

 img = rgb2gray(imread('image.png')); 

Matplotlib ट्यूटोरियल में वे इसे कवर नहीं करते हैं। वे सिर्फ छवि में पढ़ा है

 import matplotlib.image as mpimg img = mpimg.imread('image.png') 

और फिर वे सरणी को टुकड़ा करते हैं, लेकिन यह आरजीबी को बदलने से एक ही चीज नहीं है जो मैं समझता हूं।

 lum_img = img[:,:,0] 

संपादित करें:

मुझे यह विश्वास करना कठिन लगता है कि एमएमपी या मैटप्ललिब में आरजीबी से ग्रे तक कन्वर्ट करने के लिए एक अंतर्निहित फ़ंक्शन नहीं है क्या यह छवि प्रसंस्करण में एक सामान्य संचालन नहीं है?

मैंने एक बहुत ही सरल कार्य लिखा था जो 5 मिनट में imread करके आयात की गई छवि के साथ काम करता है। यह बहुत ही अक्षम है, लेकिन इसलिए मैं एक पेशेवर कार्यान्वयन के लिए उम्मीद कर रहा था।

सेबेस्टियन ने मेरे कार्य में सुधार किया है, लेकिन मैं अब भी एक-एक बिल्ट-इन को खोजने की उम्मीद कर रहा हूं।

मैटलब (एनटीएससी / पाल) कार्यान्वयन:

 import numpy as np def rgb2gray(rgb): r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2] gray = 0.2989 * r + 0.5870 * g + 0.1140 * b return gray 

Solutions Collecting From Web of "मैं कैसे एक आरजीबी छवि को पायथन में ग्रेस्केल में परिवर्तित कर सकता हूँ?"

यह पीआईएल के साथ कैसे करें:

 from PIL import Image img = Image.open('image.png').convert('LA') img.save('greyscale.png') 

Matplotlib और सूत्र का उपयोग करना

 Y' = 0.299 R + 0.587 G + 0.114 B 

तुम यह कर सकते थे:

 import numpy as np import matplotlib.pyplot as plt import matplotlib.image as mpimg def rgb2gray(rgb): return np.dot(rgb[...,:3], [0.299, 0.587, 0.114]) img = mpimg.imread('image.png') gray = rgb2gray(img) plt.imshow(gray, cmap = plt.get_cmap('gray')) plt.show() 

आप स्किकिट-इमेज भी उपयोग कर सकते हैं, जो rgb2gray में एक छवि को बदलने के लिए कुछ फ़ंक्शन प्रदान करता है, जैसे rgb2gray

 from skimage import color from skimage import io img = color.rgb2gray(io.imread('image.png')) 

नोट्स : इस रूपांतरण में उपयोग किए गए वजन समकालीन सीआरटी फोस्फोर्स के लिए कैलिब्रेटेड हैं: वाई = 0.2125 आर + 0.7154 जी +0721 बी

वैकल्पिक रूप से, आप चित्र को ग्रेस्केल में इन्हें पढ़ सकते हैं:

 from skimage import io img = io.imread('image.png', as_grey=True) 

आप हमेशा OpenCV से imread का इस्तेमाल करते हुए छवि फ़ाइल को शुरुआत से ठीक से imread स्केल के रूप में पढ़ सकते हैं:

 img = cv2.imread('messi5.jpg', 0) 

इसके अलावा, अगर आप आरजीबी के रूप में छवि को पढ़ना चाहते हैं, तो कुछ प्रोसेसिंग करें और फिर ग्रे स्केल में परिवर्तित करें आप cvtcolor से cvtcolor उपयोग कर सकते हैं:

 gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) 

सबसे तेज़ और वर्तमान तरीका तकिया का उपयोग करना है, pip install Pillow माध्यम से pip install Pillow

तब कोड है:

 from PIL import Image img = Image.open('input_file.jpg').convert('L') img.save('output_file.jpg') 

ट्यूटोरियल धोखा दे रहा है क्योंकि यह ग्रेस्केल छवि आरजीबी में एन्कोडेड के साथ शुरू हो रहा है, इसलिए वे सिर्फ एक रंग चैनल का टुकड़ा कर रहे हैं और इसे ग्रेस्केल के रूप में इलाज कर रहे हैं। आपको जो बुनियादी कदम उठाने होंगे आपको आरजीबी रंग-स्थान से एक रंग-स्प्लेस में बदलना होगा, जो कि यूयूवी / वाईआईक्यूएफ़ या एचएसएल / एचएसवी जैसे लूमा / क्रोमा मॉडल के अनुमान के साथ कुछ एन्कोड होते हैं, फिर लूमा जैसी चैनल बंद कर देते हैं और इसका इस्तेमाल करते हैं आपकी ग्रेस्केल छवि matplotlib YUV / YIQ में परिवर्तित करने के लिए एक तंत्र प्रदान नहीं करता है, लेकिन यह आपको एचएसवी में कनवर्ट करने देता है

matplotlib.colors.rgb_to_hsv(img) का उपयोग करने की कोशिश करें, फिर अपने ग्रेस्केल के लिए सरणी से अंतिम मान (वी) का टुकड़ा करना यह लूमा मूल्य के समान नहीं है, लेकिन इसका मतलब है कि आप इसे पूरी तरह से matplotlib में कर सकते हैं।

पृष्ठभूमि:

वैकल्पिक रूप से, आप पीआईएल या अंतर्निहित colorsys.rgb_to_yiq() का इस्तेमाल कर सकते हैं एक रंगों में एक सच्चे luma मूल्य के साथ कन्वर्ट करने के लिए। आप सभी में भी जा सकते हैं और अपने स्वयं के luma-only कनवर्टर को रोल कर सकते हैं, हालांकि यह संभवतः ओवरकिल है।

उबंटू 16.04 एलटीएस (एसएसडी के साथ Xeon E5 2670) पर पायथन 3.5 के साथ चलने वाली 1000 RGBA PNG छवियों (224 x 256 पिक्सल) के साथ तीन तरीकों की गति के लिए परीक्षण किया गया था।

औसत चलाने का समय

pil : 1.037 सेकंड

scipy: 1.040 सेकंड

sk : 2.120 सेकंड

numpy और numpy ने समान numpy एरेज़ (0 से 255 से लेकर) को दिया था स्किमेज 0 से 1 से एरेज़ देता है। इसके अलावा रंग थोड़ा अलग रूपांतरित होते हैं, उदाहरण के लिए CUB-200 डेटासेट से देखें।

SkImage: SkImage

PIL : जनहित याचिका

SciPy : SciPy

Original: मूल

Diff : यहां छवि विवरण दर्ज करें

कोड

  1. प्रदर्शन

     run_times = dict(sk=list(), pil=list(), scipy=list()) for t in range(100): start_time = time.time() for i in range(1000): z = random.choice(filenames_png) img = skimage.color.rgb2gray(skimage.io.imread(z)) run_times['sk'].append(time.time() - start_time) 

    run_times = dict(sk=list(), pil=list(), scipy=list()) for t in range(100): start_time = time.time() for i in range(1000): z = random.choice(filenames_png) img = skimage.color.rgb2gray(skimage.io.imread(z)) run_times['sk'].append(time.time() - start_time)

     start_time = time.time() for i in range(1000): z = random.choice(filenames_png) img = np.array(Image.open(z).convert('L')) run_times['pil'].append(time.time() - start_time) start_time = time.time() for i in range(1000): z = random.choice(filenames_png) img = scipy.ndimage.imread(z, mode='L') run_times['scipy'].append(time.time() - start_time) 

    कश्मीर के लिए, run_times.items में v):
    प्रिंट ('{5}: {0.3f} सेकंड'। प्रारूप (कश्मीर, राशि (वी) / लेन (वी)))

  2. उत्पादन
     z = 'Cardinal_0007_3025810472.jpg' img1 = skimage.color.rgb2gray(skimage.io.imread(z)) * 255 IPython.display.display(PIL.Image.fromarray(img1).convert('RGB')) img2 = np.array(Image.open(z).convert('L')) IPython.display.display(PIL.Image.fromarray(img2)) img3 = scipy.ndimage.imread(z, mode='L') IPython.display.display(PIL.Image.fromarray(img3)) 
  3. तुलना
     img_diff = np.ndarray(shape=img1.shape, dtype='float32') img_diff.fill(128) img_diff += (img1 - img3) img_diff -= img_diff.min() img_diff *= (255/img_diff.max()) IPython.display.display(PIL.Image.fromarray(img_diff).convert('RGB')) 
  4. आयात
     import skimage.color import skimage.io import random import time from PIL import Image import numpy as np import scipy.ndimage import IPython.display 
  5. संस्करण
     skimage. version 0.13.0 scipy. version 0.19.1 np. version 1.13.1 

अगर आप पहले से ही NumPy / SciPy का प्रयोग कर रहे हैं तो आप इसका इस्तेमाल कर सकते हैं :

scipy.ndimage.imread(file_name, mode='L')

एचथ, डीटीके

मैं इस सवाल पर Google के माध्यम से एक पहले से भरी हुई छवि को ग्रेस्केल में कनवर्ट करने का एक तरीका खोज रहा हूं।

यहाँ SciPy के साथ ऐसा करने का एक तरीका है:

 import scipy.misc import scipy.ndimage # Load an example image # Use scipy.ndimage.imread(file_name, mode='L') if you have your own img = scipy.misc.face() # Convert the image R = img[:, :, 0] G = img[:, :, 1] B = img[:, :, 2] img_gray = R * 299. / 1000 + G * 587. / 1000 + B * 114. / 1000 # Show the image scipy.misc.imshow(img_gray) 

तुम यह कर सकते थे:

 import numpy as np import matplotlib.pyplot as plt import matplotlib.image as mpimg def rgb_to_gray(img): grayImage = np.zeros(img.shape) R = np.array(img[:, :, 0]) G = np.array(img[:, :, 1]) B = np.array(img[:, :, 2]) R = (R *.299) G = (G *.587) B = (B *.114) Avg = (R+G+B) grayImage = img for i in range(3): grayImage[:,:,i] = Avg return grayImage image = mpimg.imread("your_image.png") grayImage = rgb_to_gray(image) plt.imshow(grayImage) plt.show() 
 image=myCamera.getImage().crop(xx,xx,xx,xx).scale(xx,xx).greyscale() 

आप रूपांतरण के लिए सीधे greyscale() उपयोग कर सकते हैं