पाइथन में पीआईएल आसान से कठिन है

जटिल प्रसंस्करण एल्गोरिदम पर जाने के लिए, यह मानक योजनाओं का विश्लेषण करने के लायक है, जिसके साथ मैं शुरू करने का सुझाव देता हूं।

प्रसंस्करण के उदाहरणों के लिए, रंगों के विभिन्न सेटों के साथ एक छवि का उपयोग किया जाएगा:



शुरू करने के लिए, हमें दो पुस्तकालय मॉड्यूल चाहिए:

from PIL import Image, ImageDraw 

आरामदायक भविष्य के काम के लिए उपकरण सेट करें:

 image = Image.open('test.jpg') #   draw = ImageDraw.Draw(image) #     width = image.size[0] #   height = image.size[1] #   pix = image.load() #    

चलिए शुरू करते हैं

हम RGB फॉर्मेट में इमेज प्रोसेस करेंगे। PIL स्वरूपों 1, L, P, RGB, RGBA, CMYK, YCbCr, LAB, HSV, I, F के साथ काम करने का समर्थन करता है।

छवि में पिक्सेल मान प्रारूप में सेट किए गए हैं: (x, y), (लाल, हरा, नीला) , जहां x, y निर्देशांक हैं, और RGB के संख्यात्मक मान 0 से 255 तक के हैं। यानी, हम 8-बिट छवि के साथ काम करते हैं ।

ग्रे की छाया

एक ग्रे टिंट सभी रंग पट्टियों की समानता के मामले में दिखाई देता है, इसलिए हमें तीनों बिंदुओं में अंकगणितीय माध्य मान प्राप्त करने की आवश्यकता है:

 for x in range(width): for y in range(height): r = pix[x, y][0] #     g = pix[x, y][1] # b = pix[x, y][2] # sr = (r + g + b) // 3 #  draw.point((x, y), (sr, sr, sr)) #  image.save("result.jpg", "JPEG") #    

उलट देना

वर्तमान रंग 255 से घटाकर उलटा प्राप्त किया जाता है:

 for x in range(width): for y in range(height): r = pix[x, y][0] g = pix[x, y][1] b = pix[x, y][2] draw.point((x, y), (255 - r, 255 - g, 255 - b)) 

ग्रेस्केल उलटा

दो पिछले एल्गोरिदम को मिलाकर, आप निम्नलिखित कोड लिख सकते हैं:

 for x in range(width): for y in range(height): r = pix[x, y][0] g = pix[x, y][1] b = pix[x, y][2] sr = (r + g + b) // 3 draw.point((x, y), (255 - sr, 255 - sr, 255 - sr)) 

चयनात्मक ग्रेस्केल उलटा

इस एल्गोरिथ्म के लिए, आपको थ्रेशोल्ड मान निर्धारित करने की आवश्यकता है, जिसे मैं 100 में ले जाऊंगा:

 for x in range(width): for y in range(height): r = pix[x, y][0] g = pix[x, y][1] b = pix[x, y][2] if (r+g+b)>100: #    100 ,    sr = (r + g + b) // 3 draw.point((x, y), (255-sr, 255-sr, 255-sr)) else: #    sr = (r + g + b) // 3 draw.point((x, y), (sr, sr, sr)) 

निष्कर्ष

निम्नलिखित लेखों में, मैं इस बारे में बात करना चाहूंगा कि कैसे अधिक स्थानीय रूप से छवि को फ़िल्टर करके इसे क्षेत्रों में विभाजित किया जा सकता है, और छवि प्रसंस्करण एल्गोरिदम में दिलचस्प डीएफएस विशेषताओं को भी दिखाया जा सकता है।