यह स्पष्ट करें! ग्रेस्केल में एक सबक ... एर ... रंग ... एर ... जो भी हो

Question

रूबिक के क्यूब और कूल आर्ट का बहुत बड़ा प्रशंसक होने के नाते, मैं दोनों के साथ मिलकर कुछ बहुत अच्छा काम कर रहा हूं। मूल रूप से रुबिक की क्यूब कला के निर्माण में अल्पविकसित पिक्सेल बनाने के लिए लघु रूबिक के क्यूब्स को हल करना। इस लिंक के माध्यम से ऐसी कला के उदाहरण देखे जा सकते हैं: http://google.com/search?q=rubik%27s+cube+art

अब, इस कोड गोल्फ का उद्देश्य एक ऐसा कोड बनाना है जो किसी छवि को इनपुट के रूप में स्वीकार करता है, और फिर उसे निम्नलिखित तरीके से परिवर्तित करता है:

छवि को शुरू में वेब-सुरक्षित ग्रेस्केल रंगों में घटाया गया है। इसके पीछे का कारण यह है कि हमें वेब-सुरक्षित ग्रेस्केल पैलेट (यानी 000000, 333333, 666666, 999999, CCCCCC, और FFFFFF) को अलग करना होगा। ग्रेस्केल में परिवर्तित करने की वर्णमिति पद्धति पर एक एल्गोरिथ्म उपलब्ध है: http://en.wikipedia.org/wiki/Grayscale#Colorimetric_.2STuminance-presinating.29_conversion_bgrcc , क्या आपको प्रेरणा के रूप में उपयोग करना चाहिए।

एक तब ग्रेस्केल को उपयुक्त रंगों में प्रस्तुत करेगा। इसे जल्दी से तोड़ने के लिए: 000000 रुबिक के नीले को संदर्भित करेगा, 333333 रूबिक के लाल को संदर्भित करेगा, 666666 रूबिक के हरे को संदर्भित करेगा, 999999 रुबिक के नारंगी को संदर्भित करेगा, CCCCCC रुबिक के पीले को संदर्भित करेगा, और FFFFFF रूबिक के सफेद को संदर्भित करेगा।

मैं बल्कि यह चाहता हूं कि आपका परिणामी कोड फोटो के पैलेट से सीधे रूबिक के रंगों में रेंडर हो सके। वेब-सुरक्षित ग्रेस्केल और फिर रूबिक के पैलेट में परिवर्तित होने से दो-चरण की विधि आपको प्रक्रिया के पीछे के तर्क पर एक विचार देने के लिए है, लेकिन अगर आपके लिए ऐसा करना आसान है, तो हर तरह से।

रूबिक के पैलेट के लिए वास्तविक आरजीबी मान निम्नलिखित के अनुरूप होना चाहिए:

• लाल: # C41E3A
• हरा: # 009E60
• नीला: # 0051BA
• नारंगी: # FF5800
• पीला: # FFD500
• सफ़ेद: # फाफ

आपको एक उदाहरण देने के लिए, मैंने अब्राहम लिंकन के सिर को निम्न चित्र से काट दिया है: और निम्नलिखित को उत्पन्न करने के लिए एल्गोरिथ्म का प्रतिपादन किया:

ग्रिड वहाँ है ताकि आप देख सकें कि प्रत्येक व्यक्ति लघु रुबिक के क्यूब को छवि बनाने के लिए कैसे कॉन्फ़िगर करना होगा। परिणामी छवि का सही आकार 45 पिक्सेल 45 पिक्सेल है, जिसका अर्थ है (45/3) * (45/3) = 15 * 15 = 225 लघु रुबिक के क्यूब्स का उपयोग इस छवि को बनाने के लिए किया जाएगा। मुझे आपसे अपेक्षा नहीं है कि परिणामी छवि को एक ग्रिड के रूप में प्रस्तुत करूंगा जैसा कि मेरे पास है।

तो यह वही है जो आवश्यक है:

1. इस एल्गोरिथ्म द्वारा संसाधित की जाने वाली छवि y पिक्सेल से x पिक्सेल चौड़ी होनी चाहिए, जैसे कि x और y 3. के गुणक हैं। यह रूबिक क्यूब मोज़ेक के भाग के रूप में प्रदान करने में आसानी के साथ सहायता करता है। यदि आपकी छवि काफी बड़ी है, तो इसे 45 x 45 से 75 x 75 के आसपास किसी चीज़ में कम करना या प्रसंस्करण से पहले आयामों में उपचार की सलाह दी जाती है। ध्यान रखें, यह आकार देने वाला घटक वैकल्पिक है।

2. मोज़ेक बनाने के लिए छवि को sextacolored Rubik's cube पैलेट में बदलना होगा।

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

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

5. सबसे छोटा कोड जीतता है।

मैं इसे एक लोकप्रियता प्रतियोगिता में बदल रहा हूं ... मैं देखूंगा कि बाइट काउंट पर प्रतिस्पर्धा किए बिना कौन ऐसा कर सकता है ... इसलिए मैं इसे 28 फरवरी, 2014 के बाद इनाम के साथ पुरस्कार दूंगा।

Comments

मुझे लगता है कि अगर आप किसी लिंक पर भरोसा करने के बजाय रूबिक आरजीबी मानों को पोस्ट में जोड़ देंगे तो बेहतर होगा।

— स्वस्तिक

क्या "संसाधित होने वाली छवि को x पिक्सेल से y पिक्सेल उच्च होना चाहिए" का अर्थ है कि आकार बदलना कोड का हिस्सा है या वह छवि आवश्यक आकार के लिए पूर्व-संसाधित है?

— user2846289

क्या रुबिक क्यूब के किसी भी असंभव राज्य हैं यदि आप केवल एक चेहरे को कसते हैं?

— निक टी

@WallyWest आप मेरे ऐप MineCam को पसंद करेंगे, यह ऐसा करता है, लेकिन यह स्क्वायर बनाने के बजाय, मेरा क्राफ्ट ब्लॉक का उपयोग करता है, और यह वास्तविक समय iPhone कैमरा के साथ प्रति सेकंड 15 बार करता है, इस प्रकार यह आपके आस-पास की पूरी दुनिया को एक में बदल देता है। मेरा शिल्प ब्रह्मांड। itunes.apple.com/us/app/minecam/id675845303?mt=8 (यदि केवल यह उक्त विश्व हाहाहा के लिए एक बीज भी उत्पन्न कर सकता है)

— अल्बर्ट रेनशॉ

@WallyWest: यह आलसीपन के बारे में नहीं है। समस्या आपको सभी जानकारी देनी चाहिए जो आपको आरंभ करने की आवश्यकता है, भले ही शेष इंटरनेट नीचे हो। एक या दो साल में, उस लिंक को नीचे ले जाया जा सकता है और कोई भी लिंक को अपडेट नहीं करेगा। यदि आप वेब-सुरक्षित ग्रेस्केल रंगों (जो समस्या को हल करने के लिए आवश्यक नहीं है) बनाने के बारे में पर्याप्त जानकारी प्रदान करते हैं, तो आप आसानी से एक छोटी मानचित्रण तालिका, जैसे #000000 => #0051BA, आदि जोड़ सकते हैं

— SztupY

Answer 1

छविमगिक (108)

संस्करण: ImageMagick 6.8.7-7 Q16 x86_64 2013-11-27

निम्नलिखित कॉल:

$ convert -resize 75x75 -fx "q=p.intensity;q<1/6?#0051BA:q<2/6?#C41E3A:q<3/6?#009e60:q<4/6?#ff5800:q<5/6?#FFD500:#FFF" input output

जहां inputऔर outputइनपुट और आउटपुट फ़ाइल नाम के लिए संशोधित किया जाना है।

मैंने केवल उन वर्णों के बीच गिनती की -resizeऔर #FFF", यदि आपको लगता है कि यह टिप्पणी करने के लिए स्वतंत्र है।

मैंने लेनना को छवि के रूप में इस्तेमाल किया (वह एक प्लेबॉय में दिखाई दी, और कोई भी ऐसा कर सकता है जिसे हॉलीवुड सेलिब्रिटी के रूप में गिना जाना चाहिए?)

इनपुट:

आउटपुट:

$ convert -resize 75x75 -fx "q=p.intensity;q<1/6?#0051BA:q<2/6?#C41E3A:q<3/6?#009e60:q<4/6?#ff5800:q<5/6?#FFD500:#FFF" Lenna.png LennaRubik.png

आउटपुट बढ़े हुए:

नोट: इमेजमैजिक डॉक्स के अनुसार आपके पास एक स्टेटमेंट में एक से अधिक सशर्त ऑपरेटर नहीं हो सकते हैं, लेकिन कॉल अभी भी ठीक काम करता है, इसलिए शायद यह तय हो गया था और डॉक्स अभी अपडेट नहीं हुए थे।

परिणाम छवि पर चल रही पहचान (रंग दिखाने के लिए वास्तव में ठीक हैं):

$ identify -verbose LennaRubik.png
  (...)   
  Colors: 6
  Histogram:
       338: (  0, 81,186) #0051BA srgb(0,81,186)
      1652: (  0,158, 96) #009E60 srgb(0,158,96)
      1187: (196, 30, 58) #C41E3A srgb(196,30,58)
      1674: (255, 88,  0) #FF5800 srgb(255,88,0)
       706: (255,213,  0) #FFD500 srgb(255,213,0)
        68: (255,255,255) #FFFFFF white
  (...)

यदि आपको लगता है कि लेनना उचित हस्ती के रूप में नहीं गिना जाता है, तो यहां ब्रूस विलिस है:

Comments

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

— विक्टर स्टाफ़ुसा

@ विक्टर: मुझे लगता है कि Mathematica, Matlab या Octave इसे आसानी से हरा सकता है, क्योंकि fxभाग के अंदर की स्थितियों को और भी बेहतर भाषा में संपीड़ित किया जा सकता है। और उन भाषाओं में भी देशी छवि का समर्थन होता है (इसलिए कोई छवि बनाने के लिए इमेजमागिक / gd / etc आयात करने की आवश्यकता नहीं होती है।)

— SztupY

@SupupY मुझे लेनना के बारे में अच्छी तरह से पता है ... मैं गिनती करूँगा ... ब्रूस विलिस के साथ भी अच्छा काम ...

— WallyWest

लेनना प्यारा (आर) है। ऊपर।

— blabla999

नौकरी के लिए सही उपकरण का उपयोग करने के लिए +1। मेरी समझ में, इमेजमैगिक का उपयोग करने का सही तरीका यह है कि आप आउटपुट फाइल की तुलना में विकल्पों की तुलना में पहले इमेज को कॉल करें।

— कज़िन कोकीन

Answer 2

मेथेमेटिका

हम ग्रेटा गार्बो की विशेषता वाले यूएस स्टांप से एक वर्ग क्षेत्र के साथ काम करेंगे। इसे के रूप में संदर्भित किया जाएगा j।

f[i_,rs_,m_:True]:=
Module[{(*rs=rastersize-4*)r={0.77,0.12,0.23},gr={0,0.62,0.38},b={0,0.32,0.73},o={1,0.35,0},y={1,0.84,0},w={1,1,1},
c1={r,gr,b,o,y,w},grayGreta,garboColors},
grayGreta=(*Reverse@*)ImageData[ColorQuantize[Rasterize[i,(*ImageResolution \[Rule]15*)RasterSize->rs+1,ImageSize->rs],6]];
garboColors=Union@Flatten[grayGreta,1];
ArrayPlot[grayGreta/.Thread[garboColors-> RGBColor@@@c1],
Mesh->If[m==True,{rs-1,rs-1},None],MeshStyle->Black]]

फ़ंक्शन f में 3 पैरामीटर होते हैं:

• i जो छवि को संदर्भित करता है
• rs, रेखापुंज आकार
• m, एक बूलियन चर जो बताता है कि क्या मेष लाइनों का उपयोग किया जाना चाहिए। (डिफ़ॉल्ट सेटिंग सत्य है)।

---

15, 30, 45 और 75 के रेखापुंज आकार का उपयोग करना:

GraphicsGrid[{{f[j, 15], f[j, 30]}, {f[j, 45], f[j, 75]}}, ImageSize -> 800]

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

---

रंगों के साथ खेल रहे हैं

यह पहले वाली प्रविष्टि से है। कोड थोड़ा अलग है। Graphicsके बजाय प्रयोग किया जाता है ArrayPlot। इसके अलावा, हम पूर्ण मोहर का उपयोग करते हैं, भले ही वह वर्गाकार न हो।

रूब्रिक क्यूब रंगों के 6! = 720 क्रमचय हैं।

निम्न ऊपरी पंक्ति की केंद्र छवि प्रदर्शित करता है (नीचे 6 चित्र सेट करें)। जब ग्रेस्केल मान अंधेरे से सबसे हल्के से व्यवस्थित होते हैं, तो रंग {आर, जीआर, बी, ओ, वाई, डब्ल्यू} होते हैं। अन्य विविधताएं फिर भी काम करती हैं।

i ग्रेस्केल में मूल छवि है।

Graphics[Raster[(g=Reverse@ImageData[ColorQuantize[Rasterize[i,RasterSize->75],6]])
/.Thread[Union@Flatten[g,1]-> {{7,1,2},{0,6,4},{0,3,7},{10,4,0},{10,8,0},{10,10,10}}/10]]]

---

i पूर्ण ग्रेटा गार्बो स्टैम्प की मूल ग्रेस्केल छवि है।

Rasterize[garbo,RasterSize->75 एक 75 से 75 सरणी में छवि rasterizes।

ColorQuantize[<>, 6] 6 के सेट पर ग्रेस्केल मान को कम करता है।

ImageDataछवि से डेटा सरणी पुनर्प्राप्त करता है; यह उल्टा आता है।

Reverse डेटा सरणी फ़्लिप करता है, इसलिए चित्र, राइट-साइड अप।

garboColors परिमाणित छवि में 6 ग्रेस्केल मान हैं।

Graphics[Raster अंतिम छवि प्रदर्शित करता है।

rubrikColors 6 रुब्रिक क्यूब रंगों के RGB मान हैं।

रेड, ग्रीन, ब्लू, ऑरेंज, येलो और व्हाइट के विभिन्न रंग क्रमपरिवर्तन दिए गए हैं।

r={0.77,0.12,0.23};gr={0,0.62,0.38};b={0,0.32,0.73};o={1,0.35,0};y={1,0.84,0};w={1,1,1};
c1={r,gr,b,o,y,w};
c2={r,b,gr,o,y,w};
c3={b,r,gr,o,y,w};
c4={gr,b,r,o,y,w};
c5={b,r,gr,y,o,w};

और कोड:

grayGreta=Reverse@ImageData[ColorQuantize[Rasterize[i,RasterSize->75],6]];
garboColors=Union@Flatten[grayGreta,1];
Grid[{{i,
Graphics[Raster[grayGreta/.Thread[garboColors-> c1]]],
Graphics[Raster[grayGreta/.Thread[garboColors-> c2]]]},
{Graphics[Raster[grayGreta/.Thread[garboColors-> c3]]],
Graphics[Raster[grayGreta/.Thread[garboColors-> c4]]],
Graphics[Raster[grayGreta/.Thread[garboColors-> c5]]]}}]

---

गरबोस जालोर

यहां ग्रेटा गार्बो के 72 (720) चित्र हैं जो 6 रूब्रिक क्यूब रंगों का उपयोग करते हैं। कुछ छवियां दूसरों की तुलना में बेहतर काम करती हैं, क्या आपको नहीं लगता?

GraphicsGrid@Partition[(Graphics[Raster[grayGreta /. Thread[garboColors -> #]]] & 
/@ Take[Permutations[{r, gr, b, o, y, w}, {6}], 72]), 12]

Comments

ग्रेटा, ओह ग्रेटा ... यह मेरी अपेक्षा से बेहतर निकला। @DavidCarraher, यहाँ अच्छा काम ...

— WallyWest

@WallyWest। धन्यवाद। यह एक बहुत ही रोचक चुनौती थी।

— डेविड एफसी

मुझे बहुत यकीन था कि मैथेमेटिका इमेजमेगिक को हरा देगी, क्या इसे और आगे नहीं बढ़ाया जा सकता है? क्या उन सभी कार्यों को पुन: व्यवस्थित किया गया है?

— SztupY

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

— डेविड एफसी

वास्तव में कोड में कुछ विसंगतियां थीं। मुझे उम्मीद है कि वे अब चले गए हैं। iमूल छवि रखें। grरुब्रिक के हरे रंग के लिए खड़ा है। gग्रेस्केल छवि के लिए रेखापुंज और परिमाणित छवि डेटा को संदर्भित करता है।

— डेविड एफसी

Answer 3

स्मॉलटॉक (स्मॉलटाक / एक्स), २ * ९ १३० *

इनपुट: मैं; आउटपुट: आर

r:=i magnifiedTo:75@75.
r colorMapProcessing:[:c||b|b:=c brightness.Color rgbValue:(#(16r0051BA 16rC41E3A 16r009e60 16rff5800 16rFFD500 16rFFFFFF)at:(b*6)ceiling)]

इनपुट:

उत्पादन:

बढ़े:

(सभी युवाओं के लिए: यह मैडोना नहीं है ;-)

[*] मैंने (५x the५ (पहली पंक्ति) के आवर्धन को नहीं गिना है - इनपुट के रूप में पहले से ही आकार परिवर्तन का उपयोग कर सकता था। आशा है कि आपके साथ ठीक है।

Comments

मैं मर्लिन मुनरो को पसंद करता हूं ... महान पसंद ... रीसाइज़िंग एक वैकल्पिक विशेषता थी ...

— वैलेस्ट

Answer 4

पोस्टस्क्रिप्ट, और सही रूबिक रंग! ;-)

ठीक है, यह समाधान यहाँ ऑफ-टॉपिक है, क्योंकि यह कुछ हद तक विशिष्ट क्षेत्र तक ही सीमित है। लेकिन उदाहरण के लिए "अजीब संख्या प्रश्न" (व्यावहारिक रूप से कुछ काम करने में असमर्थ होने के कारण) के साथ बहुत हताशा के बाद, मैंने कुछ प्रकाशित करने का फैसला किया और इसलिए इसने आधे-अधूरे स्क्रिबल्स के अपने ढेर से बाहर निकाला और इसे प्रस्तुत करने योग्य बनाया।

समाधान इस तथ्य का शोषण करता है, कि इस प्रश्न का 1 संशोधन किसी साइट से लिंक करके आवश्यक रंगों को परिभाषित करता है, जो स्पष्ट रूप से बताता है कि पैनटोन (आर) रंगों का उपयोग किया जाना है, और आरजीबी रंग केवल सन्निकटन हैं। फिर मैंने सोचा, जब मैं वास्तविक रंग कर सकता हूं, तो मैं सन्निकटन क्यों करूंगा? - :)

10 dict begin
/Size 75 def
/Names  [(PMS 012C) (PMS 021C) (PMS 347C)   (PMS 200C)    (PMS 293C)   ] def
/Colors [[0 .16 1 0][0 .65 1 0][1 0 .39 .38][0 .9 .72 .28][1 .56 0 .27]] def
<</PageSize [Size dup]>> setpagedevice
Size dup scale
true setoverprint
(%stdin) (r) file 100 string readline pop 
(r) file <</CloseSource true>>/DCTDecode filter
0 1000000 string 
dup <</CloseTarget true>>/NullEncode filter 
{
    3 index 3 string readstring
    {
        4 -1 roll 1 add 4 1 roll
        {} forall
        0.11 mul exch 0.59 mul add exch 0.3 mul add cvi
        1 index exch write
    } {pop exit} ifelse
} loop
closefile
0 3 -1 roll getinterval
exch closefile
/data exch def
/n data length sqrt cvi def
1 1 Names length {
    /N exch def
    { 
        dup N Names length 1 add div gt 
            {N 1 add Names length 1 add div gt 
                {1} {0} ifelse} 
            {pop 1} 
        ifelse
    } settransfer
    [/Separation Names N 1 sub get /DeviceCMYK {
        Colors N 1 sub get 
        { 1 index mul exch } forall pop
    }] setcolorspace
    <<
        /ImageType        1
        /Width            n
        /Height           n
        /ImageMatrix      [n 0 0 n neg 0 n]
        /BitsPerComponent 8
        /Decode           [0 1]
        /DataSource       data
    >> image
} for
showpage
end

इस कोड को उदाहरण के रूप में सहेजा जाना है rubik.psऔर फिर सामान्य झुकाव के साथ घोस्टस्क्रिप्ट को खिलाया जाता है:

gs -q -sDEVICE=psdcmyk -o out.psd rubik.ps

यह तब JPG फ़ाइल नाम जैसे इनपुट के लिए, अगली पंक्ति में आपका इंतजार करता है

kelly.jpg

और, अगर सब ठीक हो जाता है, आउटपुट out.psdफाइल करने के लिए बचाता है ।

इनपुट आरजीबी जेपीईजी (किसी भी आकार) होना चाहिए, आउटपुट स्पॉट कलर चैनलों के साथ PSD है। फ़ाइल देखने के लिए आपको फ़ोटोशॉप की आवश्यकता होगी। जीएस डिवाइस psdcmykको किसी और चीज से बदलने से कुछ भी बेकार नहीं होगा। जेपीईजी इनपुट के रूप में - क्योंकि पोस्टस्क्रिप्ट दुभाषिया सीधे से डेटा स्ट्रीम को डीकोड कर सकता है। चौकोर आकार - क्योंकि यह प्रोग्राम sqrtछवि की चौड़ाई (और ऊंचाई) खोजने के लिए स्ट्रिंग लंबाई पर निर्भर करता है ।

पहली पंक्तियाँ आउटपुट छवि आकार को परिभाषित करती हैं (डिफ़ॉल्ट 75 से बदला जा सकता है) और रंग पैलेट (रंग और उनकी संख्या को भी बदला जा सकता है)। मुझे लगता है कि कुछ भी हार्ड-कोडेड नहीं है।

क्या चल रहा है? RGB ट्रिपल की धारा को मक्खी पर ग्रेस्केल वैल्यू (सरल सूत्र के साथ) में परिवर्तित किया जाता है, सामान्य रूप से 8-बिट कॉनटोन इमेज डिक्शनरी बनाई जाती है और 5 Separationकलर स्पेस में एक दूसरे के ऊपर 5 समान चित्रों को पेंट करने के लिए उपयोग किया जाता है । चाल imageऑपरेटर के प्रत्येक आह्वान से पहले स्थानांतरण कार्यों को लागू करने के लिए है । जैसे पीले रंग के लिए यह फ़ंक्शन 0.167 .. 0.333 श्रेणी में इनपुट मानों के लिए 0 देता है, और 1 अन्यथा।

इनपुट:

फ़ोटोशॉप में खुले आउटपुट 75x75 का स्क्रीनशॉट, बढ़े हुए 800%:

और फ़ोटोशॉप चैनल पैलेट:

Comments

ग्रेस केली का उपयोग करने के लिए +1 ... आपको मेरा पूरा सम्मान है ...

— वैलीवेस्ट

Answer 5

सी#

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        unchecked
        {
            var t = new[] { 0xFFC41E3A, 0xFF009E60, 0xFF0051BA, 0xFFFF5800, 0xFFFFD500, 0xFFFFFFFF }.Select(v => Color.FromArgb((int)v)).ToArray();
            var o = new Bitmap(Bitmap.FromFile(args[1]));
            var m = double.Parse(args[0]);
            var r = Math.Min(m / o.Width, m / o.Height);
            var w = (int)(o.Width * r);
            var h = (int)(o.Height * r);

            o = new Bitmap(o, w - (w % 3), h - (h % 3));
            for (int y = 0; y < o.Height; y++)
                for (int x = 0; x < o.Width; x++)
                    o.SetPixel(x, y, N(o.GetPixel(x, y), t));
            o.Save(args[2], ImageFormat.Png);
        }
    }

    static Color N(Color c, Color[] t)
    {
        return t.OrderBy(v => Math.Abs(W(v) - W(c))).First();
    }

    static double W(Color c)
    {
        return .11 * c.B + .59 * c.G + .30 * c.R;
    }
}

आपको इसे 3 मापदंडों के साथ चलाने की आवश्यकता है:

foo.exe 75 d:\test.jpg d:\out.png

75अधिकतम कहां है? चौड़ाई / ऊंचाई, d:\test.jpgइनपुट फ़ाइल है और d:\out.pngआउटपुट फ़ाइल है।

इस प्रतियोगिता में विभिन्न छवियों के लिए आउटपुट:

मेरी अपनी हस्ती:

आउटपुट:

हालांकि, अन्य (75x75 से अधिक) आकार बेहतर छवियों में परिणाम करते हैं:

और, अगर हम राष्ट्रपतियों के साथ रहें:

चूंकि यह नहीं है (अब?) कोडगुल्फ़ मैं कोड को बहुत "कम" करने की जहमत नहीं उठाई। इसके अलावा, चूंकि निर्देशों में विशेष रूप से छवि का उल्लेख नहीं किया गया था, इसलिए ऊंचाई (वर्ग) के समान चौड़ाई होनी चाहिए जो मैंने फसल के साथ परेशान नहीं की थी; मैं ऐसा है, तथापि, यह सुनिश्चित करें छवि 3 पिक्सल चौड़ा / उच्च का गुणज है बनाते हैं। यदि आप वर्गाकार चित्र चाहते हैं, तो अंत में वर्गाकार इनपुट का उपयोग करें ; एल्गोरिथ्म इष्टतम से बहुत दूर है।

कुछ और (चूंकि लोग हॉट लड़कियों / इंटरनेट के नायकों को अधिक उभारते हैं )

Answer 6

Brainfuck

++++[->+[,.----------]<]>>>>---->->++++++++++>>------------>+++>+++>--
--->++++++[->+++++<]---->+[-<+++++++<+++<+++++<+++<+++<++++++<++++++<+
<++>>>>>>>>>]<[<]<<,+[,<++++++>[>++++++[->+++++++<]>+[<<[->]>[<]>-]<<<
->]+<[-[-[-[-[[-].>>>>>>>>.<.<<<<<<-<]>[->>>>>[.<]<<]<]>[-.>>>[>]<<<.<
.[<]<<]<]>[--.+>>>[>]<<.[<].<<]<]>[--.+>>>[>]<.[<].<<]<]>[--...+],,+]

इसके लिए BF इंटरप्रेटर / कंपाइलर की आवश्यकता होती है, जिसमें EOF के रूप में -1 है और जिसकी 8 बिट कोशिकाओं से अधिक है यदि लाल पिक्सेल में से एक 255 हैं। अन्यथा यह समय से पहले बंद हो जाएगा क्योंकि यह EOF और मान 0xFF के बीच अंतर करने में सक्षम नहीं होगा। । Jitbf के साथ आपके पास जो कुछ भी है मशीन के पूर्णांक आकार के रूप में है और इसे EOF के रूप में -1 करने के लिए कर सकते हैं:

jitbf --eof -1 rubiks.bf < angelina.pnm > angelina-rubix.pnm

प्रदान की गई छवि फ़ाइल प्रारूप पूर्ण आरजीबी पीएनएम फ़ाइल (पी 6) है, जिम्प में विकल्प के रूप में कच्चा है।

यह केवल हरे रंग के चैनल का उपयोग करता है (जो कि एक रंग छवि को greyscale में बदलने के कई तरीकों में से एक है)। यह शून्य से नीचे के मूल्य को 43 तक कम कर देता है, यह जानने के लिए कि कौन सा रुबिक रंग उपयोग करने के लिए शून्य से नीचे है और एक स्विच है जो सही आरबीजी रंग से मेल खाता है जो मेल खाता है।

हैकर्स (1995) से एंजेलीना जोली की छवि 75x75 तक घट गई और आवेदन के साथ संसाधित हुई:

समान, केवल मैंने मूल आकार का उपयोग किया :

और जब से मैं मानसिक रूप से यहाँ एक राष्ट्रपति हूँ:

Comments

ऑफ़ टॉपिक, लेकिन टुडे xkcd में हैकर्स (1995)

— सिल्वेस्टर

यह एक भी करता है: xkcd.com/1247

— शेड

Answer 7

उद्देश्य सी

मैंने इस चुनौती को कल रात देखा था और इसमें इतना थोड़ा भ्रमित समय था -[NSArray indexOfObject:inSortedRange:options:usingComparator:], इसलिए देरी हुई।

- (UIImage  *)rubiksImage:(UIImage *)inputImg
{
    //Thank you http://stackoverflow.com/a/11687434/1153630 for the greyscale code
    CGRect imageRect = CGRectMake(0, 0, inputImg.size.width, inputImg.size.height);

    int width = imageRect.size.width;
    int height = imageRect.size.height;

    uint32_t *pixels = (uint32_t*)malloc(width * height * sizeof(uint32_t));

    memset(pixels, 0, width * height * sizeof(uint32_t));

    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    CGContextRef context = CGBitmapContextCreate(pixels, width, height, 8, width * sizeof(uint32_t), colorSpace, kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedLast);

    CGContextDrawImage(context, imageRect, [inputImg CGImage]);

    const int RED = 1;
    const int GREEN = 2;
    const int BLUE = 3;

    for (int y = 0; y < height; y++)
    {
        for (int x = 0; x < width; x++)
        {
            uint8_t* rgbaPixel = (uint8_t*)&pixels[y * width + x];
            uint32_t grayPixel = 0.3 * rgbaPixel[RED] + 0.59 * rgbaPixel[GREEN] + 0.11 * rgbaPixel[BLUE];

            NSArray *r = [self rubixColorFromGrey:grayPixel];

            rgbaPixel[RED] = [r[2] integerValue];
            rgbaPixel[GREEN] = [r[1] integerValue];
            rgbaPixel[BLUE] = [r[0] integerValue];
        }
    }

    CGImageRef newCGImage = CGBitmapContextCreateImage(context);

    CGContextRelease(context);
    CGColorSpaceRelease(colorSpace);
    free(pixels);

    UIImage* newUIImage = [UIImage imageWithCGImage:newCGImage];

    CGImageRelease(newCGImage);

    return newUIImage;
}

- (NSArray *)rubixColorFromGrey:(uint32_t)p
{
    NSArray *colors = @[@0, @51, @102, @153, @204, @255];

    NSUInteger index = [colors indexOfObject:@(p)
                               inSortedRange:NSMakeRange(0, colors.count)
                                     options:NSBinarySearchingInsertionIndex | NSBinarySearchingFirstEqual
                             usingComparator:^(id a, id b) {
                                return [a compare:b];
                             }];
    switch (index) {
        case 0:
            return rgb(0, 81, 186);
            break;
        case 1:
            return rgb(196, 30, 58);
            break;
        case 2:
            return rgb(0, 156, 96);
            break;
        case 3:
            return rgb(255, 82, 0);
            break;
        case 4:
            return rgb(255, 213, 0);
            break;
        case 5:
            return rgb(255, 255, 255);
            break;

        default:
            break;
    }

    return colors; //go wild
}

NSArray *rgb(int r, int g, int b)
{
    return @[@(r), @(g), @(b)];
}

मैंने इसे अपने iPad पर ऐसे ही चलाया:

UIImageView *img = [[UIImageView alloc] initWithImage:[self rubiksImage:[UIImage imageNamed:@"danny.png"]]];
[img setCenter:self.view.center];
[self.view addSubview:img];

इससे पहले के बाद

इससे पहले के बाद

Answer 8

अजगर

प्रारूप: python rubik.py <input> <max_cubes> <output>।

सुझाए गए एल्गोरिथ्म का उपयोग करके पिक्सेल को ग्रेस्केल में कवर करता है।

import Image, sys

def rubik(x, max_cubes = 25):

    img = x
    max_cubes *= 3

    if x.size[0] > max_cubes or x.size[1] > max_cubes:

        print "Resizing image...",

        if x.size[0] > x.size[1]:
            img = x.resize((max_cubes, int(max_cubes * float(x.size[1]) / x.size[0])), Image.ANTIALIAS)
        else:
            img = x.resize((int((max_cubes * float(x.size[0]) / x.size[1])), max_cubes), Image.ANTIALIAS)

    if x.size[0] % 3 or x.size[1] % 3:
        print "Sizes aren't multiples of 3"
        return

    print "Image resized to %i x %i pixels" % img.size

    out = Image.new('RGB', img.size)

    print "Converting image...",

    for x in xrange(out.size[0]):
        for y in xrange(out.size[1]):
            r, g, b = img.getpixel((x, y))
            if r == g == b == 255:
                out.putpixel((x,y), (255, 255, 255))
            else:
                l = 0.2126 * r + 0.7152 * g + 0.0722 * b
                l /= 255
                out.putpixel((x,y), (
                        (0x00, 0x51, 0xBA),
                        (0xC4, 0x1E, 0x3A),
                        (0x00, 0x9E, 0x60),
                        (0xFF, 0x58, 0x00),
                        (0xFF, 0xD5, 0x00)
                    )[int(5 * (l <= 0.0031308 and 12.92 * l  or 1.055 * l ** (1/2.4) - 0.055))])

    print "Image converted successfully."

    print "Stats:"
    h, v = img.size[0] / 3, img.size[1] / 3
    print "   ", h, "horiz. Rubik cubes"
    print "   ", v, "vert. Rubik cubes"
    print "   ", h * v, "total Rubik cubes"

    return out.resize((out.size[0], out.size[1]))

if __name__ == "__main__":
    rubik(Image.open(sys.argv[1]).convert("RGB"), int(sys.argv[2])).save(sys.argv[3])

इनपुट:

_{(स्रोत: ilmamilio.it )}

इसके साथ आउटपुट max_cubes = 25:

इसके साथ आउटपुट max_cubes = 75:

इसके साथ आउटपुट max_cubes = 225:

Comments

क्या सफेद रंग गायब नहीं है? और सबसे गहरा नीला होना चाहिए, लेकिन, जैसा कि मैं अभी देखता हूं, यह कुछ अन्य छवियों के साथ भी समस्या है।

— user2846289

@VAdimiR वूप्स! उन्हें गलत क्रम में मैप किया। जैसा कि सफेद नहीं दिखा रहा है, यह एफपी परिशुद्धता (1.055 - 0.055 = 0.9999999999999999) के कारण है। मुझे लगता है कि मुझे सफेद को हार्डकोड करना होगा, जो कठिन नहीं है, क्योंकि यह केवल #FFFFFF के मूल मूल्य पर दिखाई देगा।

— ओबेरॉन

सफेद के बारे में, मेरी राय यह थी कि 0..1 (हल्की) सीमा को 6 भागों में विभाजित किया गया है, और कुछ भी 0.83..1.00 को सफेद रंग में मैप किया गया है, या अन्यथा घन के 6 रंगों की तस्वीर बनाने में बहुत समझदारी नहीं होगी , लेकिन यह है कि मैं इसे कैसे पढ़ता हूं।

— user2846289

@ ऑर्टन ने पर्टिनी का उपयोग करते हुए दिलचस्प विकल्प ... वह लगभग 94 वर्ष की आयु में रहते थे ... और पायथन का उपयोग करके महान काम करते हैं, और मुझे स्वीकार करना होगा, न कि सबसे आसान भाषाओं में से एक, जो मैंने अच्छी तरह से की है!

— वॉलीवेस्ट