मोज़ेक चित्र बनाना

निश्चित रूप से आपने इंटरनेट पर ऐसी तस्वीरें बार-बार देखी हैं:


मैंने ऐसी छवियां बनाने के लिए एक सार्वभौमिक स्क्रिप्ट लिखने का फैसला किया।

सैद्धांतिक हिस्सा

आइए थोड़ी बात करते हैं कि हम यह सब कैसे करने जा रहे हैं। मान लीजिए कि छवियों के कुछ सीमित सेट हैं जिनके साथ हम कैनवास को प्रशस्त कर सकते हैं, साथ ही साथ एक छवि, जिसे मोज़ेक के रूप में प्रस्तुत किया जाना चाहिए। फिर हमें उस छवि को विभाजित करने की आवश्यकता है जिसे समान क्षेत्रों में परिवर्तित करने की आवश्यकता है, जिनमें से प्रत्येक को फिर चित्र के साथ डेटासेट से एक छवि के साथ बदल दिया जाता है।

इससे यह सवाल उठता है कि डेटासेट को समझने के लिए कि हमें किस क्षेत्र से एक निश्चित क्षेत्र को बदलना चाहिए। बेशक, एक निश्चित क्षेत्र का आदर्श टाइलिंग एक ही क्षेत्र होगा। प्रत्येक क्षेत्र का आकार $$$m \ n n$सेट कर सकते हैं $$$3 \ बार n \ गुना मी$संख्या (यहाँ, प्रत्येक पिक्सेल तीन संख्याओं से मेल खाती है - इसके R, G और B घटक)। दूसरे शब्दों में, प्रत्येक क्षेत्र को त्रि-आयामी टेंसर द्वारा परिभाषित किया गया है। अब यह स्पष्ट हो जाता है कि क्षेत्र को एक चित्र के साथ टाइलिंग की गुणवत्ता निर्धारित करने के लिए, बशर्ते कि उनके आकार मेल खाते हैं, हमें अपने नुकसान फ़ंक्शन की गणना करने की आवश्यकता है। इस समस्या में, हम दो टेनर्स के MSE पर विचार कर सकते हैं:

$$

$$MSE (x, y) = \ frac {\ _ sum \ limit_ {i = 1} ^ N (x_ {i} - y_ {i}) ^ 2} {N}$$

यहां $$$एन$- हमारे मामले में, संकेतों की संख्या $$$3 \ बार n \ गुना मी$।

हालाँकि, यह सूत्र वास्तविक मामलों पर लागू नहीं होता है। तथ्य यह है कि जब डेटासेट काफी बड़ा होता है, और जिन क्षेत्रों में मूल छवि विभाजित होती है, वे काफी छोटे होते हैं, तो आपको अस्वीकार्य रूप से कई क्रियाएं करनी होंगी, अर्थात्, प्रत्येक छवि को डाटासेट से क्षेत्र के आकार तक संकुचित करें और MSE पर विचार करें। $$$3 \ बार n \ गुना मी$विशेषताओं। अधिक सटीक रूप से, इस सूत्र में बुरी बात यह है कि हम तुलना के लिए पूरी तरह से हर छवि को एक से अधिक बार संपीड़ित करने के लिए मजबूर हैं, लेकिन उन क्षेत्रों की संख्या के बराबर संख्या जिसमें मूल चित्र विभाजित है।

मैं समस्या के लिए निम्नलिखित समाधान का प्रस्ताव करता हूं: हम थोड़ी गुणवत्ता का बलिदान करेंगे और अब हम डेटासेट से प्रत्येक छवि को केवल 3 संख्याओं के साथ चिह्नित करेंगे: छवि में औसत आरजीबी। बेशक, इससे कई समस्याएं पैदा होती हैं: सबसे पहले, अब एक क्षेत्र का आदर्श टाइलिंग न केवल स्वयं है, बल्कि, उदाहरण के लिए, यह उल्टा भी है (यह स्पष्ट है कि यह टाइलिंग पहले से भी बदतर है), और दूसरी बात, औसत रंग की गणना के बाद, हम हम ऐसे R, G और B प्राप्त कर सकते हैं कि छवि में ऐसे घटकों के साथ एक पिक्सेल भी नहीं होगा (दूसरे शब्दों में, यह कहना मुश्किल है कि हमारी आंख छवि को अपने सभी रंगों के मिश्रण के रूप में मानती है)। हालांकि, मैं बेहतर तरीके से नहीं आया।

यह पता चला है कि अब हम केवल डेटासेट से छवियों के लिए औसत आरजीबी की गणना कर सकते हैं, और फिर प्राप्त जानकारी का उपयोग कर सकते हैं।

उपरोक्त को सारांशित करते हुए, हम पाते हैं कि अब हमें सेट से RGB पिक्सेल से निकटतम क्षेत्र का चयन करने की आवश्यकता है, और फिर उस क्षेत्र को उस छवि से टाइल से डेटासेट से टाइल करें, जिसमें ऐसा पाया गया है जो मध्यम RGB का है। क्षेत्र और पिक्सेल की तुलना करने के लिए, हम ऐसा ही करेंगे: हम क्षेत्र को तीन संख्याओं में बदलते हैं और निकटतम औसत आरजीबी पाते हैं। यह पता चला है कि हम केवल कर सकते हैं $$$आर, जी, बी$ऐसे सेट में खोजें $$$R_ {i}, G_ {i}, B_ {i}$तीन-आयामी अंतरिक्ष में इन दो बिंदुओं के बीच यूक्लिडियन दूरी न्यूनतम होगी:

$$$\ sqrt {(R - R_ {i}) ^ 2 + (G - G_ {i}) ^ 2 + (B - B_ {i}) ^ 2} = मिनट$

प्रीप्रोसेसिंग डेटासेट

आप अपना स्वयं का चित्र डेटासेट बना सकते हैं। मैंने बिल्लियों और कुत्तों की छवियों के साथ डेटासेट के एक मर्ज का उपयोग किया।

जैसा कि मैंने ऊपर लिखा था, हम डेटासेट से छवियों के लिए औसत आरजीबी मूल्यों की गणना कर सकते हैं और उन्हें बचा सकते हैं। हम क्या करते हैं:

import os import cv2 import numpy as np import pickle items = {} # cv2      BGR,   RGB,     for path in os.listdir('dogs_images_dataset'): #      ,    for file in os.listdir(os.path.join('dogs_images_dataset', path)): file1 = os.path.join('dogs_images_dataset', path + '/' + file) img = np.array(cv2.cvtColor(cv2.imread(file1), cv2.COLOR_BGR2RGB)) r = round(img[:, :, 0].mean()) g = round(img[:, :, 1].mean()) b = round(img[:, :, 2].mean()) items[file1] = (r, g, b,) for file in os.listdir('cats_images_dataset'): #      ,          file1 = os.path.join('cats_images_dataset', file) img = np.array(cv2.cvtColor(cv2.imread(file1), cv2.COLOR_BGR2RGB)) r = round(img[:, :, 0].mean()) g = round(img[:, :, 1].mean()) b = round(img[:, :, 2].mean()) items[file1] = (r, g, b,) with open('data.pickle', 'wb') as f: pickle.dump(items, f) 

इस स्क्रिप्ट को अपेक्षाकृत लंबे समय के लिए निष्पादित किया जाएगा, जिसके बाद हमें जो जानकारी चाहिए वह डेटा.पिकल फ़ाइल में सहेजी जाएगी।

मोज़ेक बनाना

अंत में, चलो मोज़ेक बनाने के लिए आगे बढ़ते हैं। सबसे पहले, हम आवश्यक आयात लिखेंगे, और कई स्थिरांक भी घोषित करेंगे:

 import os import cv2 import pickle import numpy as np from math import sqrt PATH_TO_PICTURE = '' #       PICTURE = 'picture.png' #     VERTICAL_SECTION_SIZE = 7 #       HORIZONTAL_SECTION_SIZE = 7 #       

हमें फ़ाइल से सहेजा गया डेटा मिलता है:

 with open('data.pickle', 'rb') as f: items = pickle.load(f) 

हम नुकसान फ़ंक्शन का वर्णन करते हैं:

 def lost_function(r_segm, g_segm, b_segm, arg): r, g, b = arg[1] return sqrt((r - r_segm) ** 2 + (g - g_segm) ** 2 + (b - b_segm) ** 2) 

मूल छवि खोलें:

 file = os.path.join(PATH_TO_PICTURE, PICTURE) img = np.array(cv2.cvtColor(cv2.imread(file), cv2.COLOR_BGR2RGB)) size = img.shape x, y = size[0], size[1] 

अब ध्यान दें कि टाइलिंग संभव है यदि और केवल यदि $$$(x \ _orig \ space \ vdots \ space x) \ space \ wedge \ space (y \ _orig \ space \ vdots \ space y)$जहाँ $$$x \ _orig, y \ _orig$- मूल छवि का आकार, और $$$x, y$- टाइलिंग क्षेत्र के आयाम। बेशक, उपरोक्त स्थिति हमेशा संतुष्ट नहीं होती है। इसलिए, हम मूल छवि को उपयुक्त आकारों में क्रॉप करेंगे, छवि के आकार को उनके अवशेषों को घटाकर क्षेत्र के आकार से विभाजित करके:

 img = cv2.resize(img, (y - (y % VERTICAL_SECTION_SIZE), x - (x % HORIZONTAL_SECTION_SIZE))) size = img.shape x, y = size[0], size[1] 

अब हम सीधे टाइलिंग के लिए आगे बढ़ते हैं:

 for i in range(x // HORIZONT AL_SECTION_SIZE): for j in range(y // VERTICAL_SECTION_SIZE): sect = img[i * HORIZONTAL_SECTION_SIZE:(i + 1) * HORIZONTAL_SECTION_SIZE, j * VERTICAL_SECTION_SIZE:(j + 1) * VERTICAL_SECTION_SIZE] r_mean, g_mean, b_mean = sect[:, :, 0].mean(), sect[:, :, 1].mean(), sect[:, :, 2].mean() 

यहां, प्रायद्वीपीय रेखा में, वांछित छवि क्षेत्र का चयन किया जाता है, और अंतिम पंक्ति में इसके औसत आरजीबी घटकों को माना जाता है।

अब सबसे महत्वपूर्ण लाइनों में से एक पर विचार करें:

 current = sorted(items.items(), key=lambda argument: lost_function(r_mean, g_mean, b_mean, argument))[0] 

यह लाइन उनके लिए नुकसान फ़ंक्शन के मान से आरोही क्रम में डेटासेट की सभी छवियों को क्रमबद्ध करती है और argmin हो जाती है।

अब हमें केवल छवि को क्रॉप करना है और उस क्षेत्र को उसके साथ बदलना है:

 resized = cv2.resize(cv2.cvtColor(cv2.imread(current[0]), cv2.COLOR_BGR2RGB), (VERTICAL_SECTION_SIZE, HORIZONTAL_SECTION_SIZE,)) img[i * HORIZONTAL_SECTION_SIZE:(i + 1) * HORIZONTAL_SECTION_SIZE, j * VERTICAL_SECTION_SIZE:(j + 1) * VERTICAL_SECTION_SIZE] = resized 

और अंत में, स्क्रीन पर परिणामी छवि प्रदर्शित करें:

 img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) cv2.imshow('ImageWindow', img) cv2.waitKey(0) 

नुकसान समारोह के बारे में थोड़ा और

सामान्य तौर पर, नुकसान फ़ंक्शन के लिए कई विकल्प हैं, जिनमें से प्रत्येक सैद्धांतिक रूप से इस समस्या पर लागू होता है। उनकी गुणवत्ता का केवल अनुभवजन्य मूल्यांकन किया जा सकता है, आप क्या कर सकते हैं :)

$$

$$| \ Delta R | + | \ डेल्टा जी | + | \ Delta B | \\ \ sqrt {\ Delta R ^ 2 + \ Delta G ^ 2 + \ Delta B ^ 2} \\ \ sqrt {0.2126 \ Delta R ^ 2 + 0.7152 \ Delta G ^ 2 + 0.0722 \ Delta B ^ 2} \ \ \ sqrt {0.2126 ^ 2 \ Delta R ^ 2 + 0.7152 ^ 2 \ Delta G ^ 2 + 0.0722 ^ 2 \ Delta B ^ 2}$$

निष्कर्ष

यहाँ मेरे कुछ परिणाम हैं:



पूर्ण स्रोत कोड, पहले से ही गणना की गई data.pickle फ़ाइल, साथ ही मेरे द्वारा एकत्र किए गए डेटासेट के साथ संग्रह, आप रिपॉजिटरी में देख सकते हैं।