गैर-नकारात्मक मैट्रिक्स अपघटन का उपयोग करके ASCII ग्राफिक्स में काले और सफेद चित्रों को परिवर्तित करें

सामान्य तौर पर, एक छवि को ASCII ग्राफिक्स में परिवर्तित करना एक अधिक समय लेने वाला कार्य है, लेकिन ऐसे एल्गोरिदम हैं जो इस प्रक्रिया को स्वचालित करते हैं। यह लेख शोधकर्ताओं पॉल डी। ओ'ग्रेडी और स्कॉट टी। रिकार्ड द्वारा प्रस्तावित दृष्टिकोण "गैर-नकारात्मक बाधाओं का उपयोग करके द्विआधारी छवियों के स्वचालित एएससीआईआई कला रूपांतरण" पर चर्चा करता है। उन्होंने जिस विधि का वर्णन किया है, उसमें छवि रूपांतरण प्रक्रिया को एक अनुकूलन समस्या के रूप में प्रस्तुत करना और एक गैर-नकारात्मक मैट्रिक्स अपघटन का उपयोग करके इस समस्या को हल करना शामिल है। नीचे प्रश्न में एल्गोरिथ्म का वर्णन है, साथ ही इसके कार्यान्वयन:

एल्गोरिथम विवरण

मूल छवि को आकार के ब्लॉक में विभाजित किया गया है जहाँ और - पिक्सल में एक वर्ण की चौड़ाई और ऊंचाई। यदि छवि की चौड़ाई \ ऊंचाई चरित्र की चौड़ाई \ ऊंचाई की एक से अधिक नहीं है, तो चित्र को इच्छित आकार के सफेद क्षेत्रों के साथ क्रॉप या पूरक किया जाता है।


प्रत्येक विभाजन के बाद प्राप्त ब्लॉक को लंबाई के वेक्टर के रूप में दर्शाया जाता है जिनके मूल्य छवि पिक्सेल की रंग तीव्रता (मान 0 से 255 तक हैं, जहां सफेद पिक्सेल मान 0 से मेल खाता है और काला पिक्सेल 255 से मेल खाता है)। परिणामी वैक्टर को आदर्श का उपयोग करके सामान्यीकृत किया जाना चाहिए :

सामान्यीकृत वैक्टर को कॉलम के रूप में फिर से लिखा जाता है, इस प्रकार एक मैट्रिक्स बनता है आकार ।

परिणामी मैट्रिक्स मैट्रिक्स के उत्पाद के रूप में प्रतिनिधित्व करने की आवश्यकता है और सभी तत्व जो नकारात्मक हैं:

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

यह अभिव्यक्ति अनिवार्य रूप से कई उद्देश्य कार्यों को जोड़ती है: जब यह यूक्लिडियन दूरी (स्क्वेरड यूक्लिडियन दूरी) के वर्ग में परिवर्तित हो जाता है, जब कुल्लबैक-लीब्लर डाइवर्जेंस दूरी के पास पहुंचता है - इटकुरा-सैटो (इटकुरा-सैटो डाइवर्जेंस) की दूरी तक।

डायरेक्ट मैट्रिक्स चयन निम्नानुसार उत्पादित: 0 से 1 तक यादृच्छिक मूल्यों के साथ आरंभीकृत, जिसके बाद इसके मान निम्न नियम के अनुसार पुन: अद्यतन किए जाते हैं (पुनरावृत्तियों की संख्या पहले से निर्धारित है):

प्रत्येक मूल्य समानता की डिग्री से मेल खाती है के साथ सेट से चरित्र छवि का -इस खंड।


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

कार्यान्वयन

एल्गोरिथ्म C # में लागू किया गया है। एएससीआईआई ग्राफिक्स 11x23 पिक्सल के आकार के साथ 95 अक्षरों (0x20 से 0x7E तक) का उपयोग करके उत्पन्न होता है; उपयोग किया जाने वाला फ़ॉन्ट कूरियर है। मूल छवि को ASCII ग्राफिक्स में बदलने के लिए फ़ंक्शन का स्रोत कोड नीचे दिया गया है:

public static char[,] ConvertImage( Bitmap image, double beta, double threshold, ushort iterationsCount, ushort threadsNumber, Action<int> ProgressUpdated) { int charNumHor = (int)Math.Round((double)image.Width / glyphWidth); int charNumVert = (int)Math.Round((double)image.Height / glyphHeight); int totalCharactersNumber = charNumVert * charNumHor; int glyphSetSize = wNorm.ColumnCount; Matrix<double> v = SplitImage(image, charNumVert, charNumHor); Matrix<double> h = Matrix<double>.Build.Random( glyphSetSize, totalCharactersNumber, new ContinuousUniform()); int progress = 0; ushort step = (ushort)(iterationsCount / 10); for (ushort i = 0; i < iterationsCount; i++) { UpdateH(v, wNorm, h, beta, threadsNumber); if((i + 1) % step == 0) { progress += 10; if(progress < 100) { ProgressUpdated(progress); } } } var result = GetAsciiRepresentation(h, charNumVert, charNumHor, threshold); ProgressUpdated(100); return result; } 

व्यक्तिगत रूप से प्रत्येक चरण पर विचार करें:

1) हम गणना करते हैं कि छवि की चौड़ाई और ऊंचाई में कितने वर्ण फिट हो सकते हैं:

 int charNumHor = (int)Math.Round((double)image.Width / glyphWidth); int charNumVert = (int)Math.Round((double)image.Height / glyphHeight); 

गणना किए गए मानों का उपयोग करते हुए, हम मूल छवि को आवश्यक आकार के ब्लॉकों में विभाजित करते हैं। प्रत्येक ब्लॉक के लिए, हम इसी मैट्रिक्स कॉलम में पिक्सेल रंग की तीव्रता के मान लिखते हैं (यदि आवश्यक हो, तो हम मैट्रिक्स में सफेद पिक्सेल के अनुरूप शून्य मान जोड़कर मूल छवि का विस्तार करते हैं), जिसके बाद हम सभी कॉलमों को सामान्य करते हैं:

 private static Matrix<double> SplitImage( Bitmap image, int charNumVert, int charNumHor) { Matrix<double> result = Matrix<double>.Build.Dense( glyphHeight * glyphWidth, charNumHor * charNumVert); for (int y = 0; y < charNumVert; y++) { for (int x = 0; x < charNumHor; x++) { for (int j = 0; j < glyphHeight; j++) { for (int i = 0; i < glyphWidth; i++) { byte color = 0; if ((x * glyphWidth + i < image.Width) && (y * glyphHeight + j < image.Height)) { color = (byte)(255 - image.GetPixel( x * glyphWidth + i, y * glyphHeight + j).R); } result[glyphWidth * j + i, charNumHor * y + x] = color; } } } } result = result.NormalizeColumns(2.0); return result; } 

2) मैट्रिक्स भरें 0 से 1 तक यादृच्छिक मान:

 Matrix<double> h = Matrix<double>.Build.Random( glyphSetSize, totalCharactersNumber, new ContinuousUniform()); 

हम अद्यतन नियम को उसके तत्वों के लिए कई बार लागू करते हैं:

 for (ushort i = 0; i < iterationsCount; i++) { UpdateH(v, wNorm, h, beta, threadsNumber); if((i + 1) % step == 0) { progress += 10; if(progress < 100) { ProgressUpdated(progress); } } } 

मैट्रिक्स तत्वों को सीधे अपडेट करना निम्नानुसार लागू किया जाता है (दुर्भाग्य से, शून्य से विभाजित होने से जुड़ी समस्याएं कुछ बैसाखियों का उपयोग करके हल की जाती हैं):

 private static void UpdateH( Matrix<double> v, Matrix<double> w, Matrix<double> h, double beta, ushort threadsNumber) { const double epsilon = 1e-6; Matrix<double> vApprox = w.Multiply(h); Parallel.For( 0, h.RowCount, new ParallelOptions() { MaxDegreeOfParallelism = threadsNumber }, j => { for (int k = 0; k < h.ColumnCount; k++) { double numerator = 0.0; double denominator = 0.0; for (int i = 0; i < w.RowCount; i++) { if (Math.Abs(vApprox[i, k]) > epsilon) { numerator += w[i, j] * v[i, k] / Math.Pow(vApprox[i, k], 2.0 - beta); denominator += w[i, j] * Math.Pow(vApprox[i, k], beta - 1.0); } else { numerator += w[i, j] * v[i, k]; if (beta - 1.0 > 0.0) { denominator += w[i, j] * Math.Pow(vApprox[i, k], beta - 1.0); } else { denominator += w[i, j]; } } } if (Math.Abs(denominator) > epsilon) { h[j, k] = h[j, k] * numerator / denominator; } else { h[j, k] = h[j, k] * numerator; } } }); } 

3) अंतिम चरण मैट्रिक्स कॉलम में अधिकतम मान ज्ञात करके प्रत्येक छवि अनुभाग के लिए एक उपयुक्त प्रतीक का चयन करना है :

 private static char[,] GetAsciiRepresentation( Matrix<double> h, int charNumVert, int charNumHor, double threshold) { char[,] result = new char[charNumVert, charNumHor]; for (int j = 0; j < h.ColumnCount; j++) { double max = 0.0; int maxIndex = 0; for (int i = 0; i < h.RowCount; i++) { if (max < h[i, j]) { max = h[i, j]; maxIndex = i; } } result[j / charNumHor, j % charNumHor] = (max >= threshold) ? (char)(firstGlyphCode + maxIndex) : ' '; } return result; } 

परिणामी छवि को html फ़ाइल में लिखा गया है। कार्यक्रम का पूर्ण स्रोत कोड यहां पाया जा सकता है ।

उत्पन्न छवियों के उदाहरण

नीचे विभिन्न पैरामीटर मानों पर बनाई गई छवियों के उदाहरण हैं और पुनरावृत्तियों की संख्या। मूल छवि में क्रमशः 407x500 पिक्सेल का आकार था, परिणामस्वरूप छवि का आकार 37x22 वर्ण था।

निष्कर्ष

माना एल्गोरिथ्म में, निम्नलिखित नुकसानों को प्रतिष्ठित किया जा सकता है:

1. लंबी छवि प्रसंस्करण: छवि के आकार और पुनरावृत्तियों की संख्या के आधार पर, इसका प्रसंस्करण कई सेकंड से लेकर दसियों मिनट तक हो सकता है।
2. विस्तृत छवियों की खराब गुणवत्ता प्रसंस्करण। उदाहरण के लिए, एक मानवीय चेहरे की छवि को बदलने का प्रयास निम्नलिखित परिणाम देता है:
   
   
   

उसी समय, छवि की चमक और इसके विपरीत को बढ़ाकर भागों की संख्या को कम करने से परिणामस्वरूप छवि की उपस्थिति में काफी सुधार हो सकता है:


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