उप-पिक्सेल ज़ूमिंग

9

आपका काम एक 24 BPP sRGB इमेज लेना है और एक ही इमेज को लाल, हरे और नीले रंग के सबसिक्सेल्स में 3x बढ़ा देता है। परिणामस्वरूप छवि पूरी तरह से शुद्ध काले, लाल, हरे और नीले रंग के पिक्सेल से बनेगी।

स्रोत की छवि से प्रत्येक पिक्सेल, जब ज़ूम किया जाता है, 9 उप-पिक्सेल की व्यवस्था पैदा करता है जो या तो चालू या बंद हो सकता है (अर्थात उनका संबंधित रंग या काला)। विशिष्ट व्यवस्था उस क्रम में लाल, हरे और नीले रंग के तीन कॉलम का उपयोग करती है, जैसे:

आरजीबी उपप्रिक्सल

(ध्यान दें कि इन "पिक्सेल" पर सीमाएँ केवल प्रदर्शन के लिए हैं।)

चूँकि प्रत्येक नौ उप-अक्षर केवल चालू या बंद हो सकते हैं, इसलिए आपको 3 स्तर की चमक प्राप्त करने के लिए इनपुट छवि की मात्रा निर्धारित करनी होगी और विभिन्न उप-प्रकार पैटर्न का उपयोग करना होगा।

छवि में प्रत्येक उप-पृष्ठ के लिए:

  • रंग के स्तर 0-74 के लिए, सभी उप-अक्षर काले होने चाहिए।
  • रंग के स्तर 75-134 के लिए, मध्य उप-पृष्ठ संबंधित रंग होना चाहिए और अन्य दो काले होने चाहिए।
  • रंग स्तर 135-179 के लिए, मध्य उप-रंग काला होना चाहिए और अन्य दो संबंधित रंग होना चाहिए
  • रंग के स्तर 180-255 के लिए, तीनों उप-प्रकार उनके संबंधित रंग होने चाहिए

मैंने इन स्तरों को चुना क्योंकि वे वही हैं जो अच्छे दिखने के लिए हुए हैं

छवि में प्रत्येक पिक्सेल के लिए इस परिवर्तन को लागू करें और सबपिक्सल-अपग्रेड की गई छवि को आउटपुट करें।

एकल-पिक्सेल उदाहरण

आरजीबी (40, 130, 175) इस पैटर्न का उत्पादन करेगा:

00B / 0G0 / 00B

आरजीबी (160, 240, 100) इस पैटर्न का उत्पादन करेगा:

RG0 / 0GB / RG0

पूर्ण छवि उदाहरण

मोना लीसा मोना लिसा सबपिक्सल्स

तारों भरी रात स्टाररी नाइट सबपिक्सल्स

तोता तोता उपपिक्सल

चित्र विकिपीडिया से लिए गए हैं

नियम और नोट

  • इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में हो सकते हैं, चाहे वह वास्तविक छवि फ़ाइलें हों या (संभवतः नेस्टेड) ​​आरजीबी मूल्यों की सूची।
  • आप मान सकते हैं कि पिक्सेल 24BPP के साथ sRGB कलरस्पेस में हैं।

हैप्पी गोल्फिंग!

code-golf  graphical-output 
— Beefster
स्रोत
2
प्रारंभिक विवरण संयुक्त राष्ट्र की तरह लगता है। यह पता चलता है कि यह अपरंपरागत 3x3 मुखौटा के कारण आंशिक रूप से नहीं है, लेकिन मुख्य रूप से परिमाण के कारण है, लेकिन IMO यह अभी भी संयुक्त राष्ट्र के करीब है, जो सबपिक्सल जूमिंग की तुलना में अधिक है (जो कि किनारे से विरोधी का पता लगाने के लिए किसी प्रकार का अपक्षय होगा) उपनाम)।
— पीटर टेलर
एक दिलचस्प निवेश के लिए धन्यवाद .... क्या यह वास्तव में वास्तविक जीवन में किसी भी चीज के लिए उपयोग किया जाता है?
— उज्ज्वल

जवाबों:

4

जावास्क्रिप्ट (नोड, क्रोम, फ़ायरफ़ॉक्स), 111 बाइट्स

I / O प्रारूप: [R,G,B]मूल्यों का मैट्रिक्स ।

a=>[...a,...a,...a].map((r,y)=>r.flat().map((_,x)=>a[y/3|0][x/3|0].map(v=>x--%3|511+y%3%2*3104>>v/15&1?0:255)))

इसे ऑनलाइन आज़माएं! (सिर्फ एक पिक्सेल)

कैसे?

सभी थ्रेशोल्ड मान 15. के गुणक हैं। स्पष्ट तुलना परीक्षण करने के बजाय, यह एक बिटमास्क का परीक्षण करने के लिए थोड़ा कम है, जहां प्रत्येक बिट 15 मूल्यों के अंतराल का प्रतिनिधित्व करता है (सबसे महत्वपूर्ण बिट को छोड़कर जो एकल मान पर मैप किया जाता है)।

 bit | range   | top/bottom | middle
-----+---------+------------+--------
  0  |   0- 14 |     off    |   off
  1  |  15- 29 |     off    |   off
  2  |  30- 44 |     off    |   off
  3  |  45- 59 |     off    |   off
  4  |  60- 74 |     off    |   off
  5  |  75- 89 |     off    |    on
  6  |  90-104 |     off    |    on
  7  | 105-119 |     off    |    on
  8  | 120-134 |     off    |    on
  9  | 135-149 |      on    |   off
 10  | 150-164 |      on    |   off
 11  | 165-179 |      on    |   off
 12  | 180-194 |      on    |    on
 13  | 195-209 |      on    |    on
 14  | 210-224 |      on    |    on
 15  | 225-239 |      on    |    on
 16  | 240-254 |      on    |    on
 17  |   255   |      on    |    on

हम के रूप में बंद सांकेतिक शब्दों में बदलना1और पर के रूप में0 अग्रणी शून्य की संख्या को अधिकतम करने के लिए।

हमें मिला:

  • 000000000111111111 ऊपर और नीचे पिक्सेल के लिए (511 दशमलव में)
  • 000000111000011111 मध्य पिक्सेल के लिए (3615 दशमलव में)

टिप्पणी की गई

a =>                      // a[] = input matrix
  [...a, ...a, ...a]      // create a new matrix with 3 times more rows
  .map((r, y) =>          // for each row r[] at position y:
    r.flat()              //   turn [[R,G,B],[R,G,B],...] into [R,G,B,R,G,B,...]
                          //   i.e. create a new list with 3 times more columns
    .map((_, x) =>        //   for each value at position x:
      a[y / 3 | 0]        //     get [R,G,B] from the original matrix
       [x / 3 | 0]        //     for the pixel at position (floor(x/3), floor(y/3))
      .map(v =>           //     for each component v:
        x-- % 3 |         //       1) yield a non-zero value if this is not the component
                          //          that we're interested in at this position
        511 +             //       2) use either 511 for top and bottom pixels
        y % 3 % 2 * 3104  //          or 3615 for the middle pixel (y mod 3 = 1)
        >> v / 15         //          divide v by 15
        & 1               //          and test the corresponding bit
        ?                 //       if either of the above tests is truthy:
          0               //         yield 0
        :                 //       else:
          255             //         yield 255
      )                   //     end of map() over RGB components
    )                     //   end of map() over columns
  )                       // end of map() over rows

उदाहरण

निम्नलिखित कोड स्निपेट मोना लिसा (64x64) के सिर को संसाधित करता है। एज पर काम नहीं करता है।

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
3

जेली , 27 बाइट्स

<“⁷KṆ‘‘Ḅœ?Ɗo⁹’)×€"3⁼þ¤)ẎZ)Ẏ

सूचियों (पिक्सेल) की सूचियों (पंक्तियों) की एक सूची (चित्र) को स्वीकार करने वाला एक उन्मत्त लिंक। प्रत्येक पिक्सेल में तीन पूर्णांक होते हैं[0,255], [r, g, b]जिसके परिणाम स्वरूप समान स्वरूप प्राप्त होता है।

इसे ऑनलाइन आज़माएं! यह उदाहरण दो-दो छवि ले रहा है जहां शीर्ष-बाएँ पिक्सेल पहला उदाहरण पिक्सेल है, शीर्ष-दाएँ पिक्सेल दूसरा उदाहरण पिक्सेल है, नीचे-बाएँ पिक्सेल एक काला पिक्सेल है और नीचे-दाएँ पिक्सेल एक सफेद है पिक्सेल।

कैसे?

<“⁷KṆ‘‘Ḅœ?Ɗo⁹’)×€"3⁼þ¤)ẎZ)Ẏ - Link: list of lists of lists of integers, I
                         )  - for each row, R, in I:
                      )     -   for each pixel, P, in R:
              )             -     for each integer, C, in P:
 “⁷KṆ‘                      -       list of code-page indices = [135,75,180]
<                           -       less than -> [C<135,C<75,C<180] 
          Ɗ                 -       last three links as a monad:
      ‘                     -         increment -> [1+(C<135),1+(C<75),1+(C<180)]
       Ḅ                    -         from binary -> 4*(1+(C<135))+2*(1+(C<75))+1+(C<180)
        œ?                  -         permutation at that index of [C<135,C<75,C<180]
                            -         when all permutations sorted lexicographically
                            -       ... a no-op for all but [0,0,1]->[0,1,0]
            ⁹               -       256
           o                -       logical OR  e.g. [0,1,0]->[256,1,256]
             ’              -       decrement               ->[255,0,255]
                     ¤      -     nilad followed by link(s) as a nilad:
                  3         -       three
                    þ       -       table with: (i.e. [1,2,3] . [1,2,3])
                   ⁼        -         equal?    -> [[1,0,0],[0,1,0],[0,0,1]]
                 "          -     zip with:
                €           -       for each:
               ×            -         multiply
                       Ẏ    -   tighten (reduce with concatenation)
                        Z   -   transpose
                          Ẏ - tighten
— जोनाथन एलन
स्रोत
im यह पता लगाने की कोशिश कर रहा है कि यह कहां [[1,0,0]। [0,1,0], [0,0,1]] और मैं चकित हूं।
— उज्ज्वल
@donbright पैदावार 3⁼þ¤का एक बाहरी उत्पाद है जो है । [1,2,3]=[1,2,3][[1=1,2=1,3=1],[2=1,2=2,2=3],[3=1,3=2,3=3]][[1,0,0],[0,1,0],[0,0,1]]
— जोनाथन एलन
2

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 186 बाइट्स

इनपुट और आउटपुट RGB मूल्यों की सूची है 

(g=#;Flatten[(T=Transpose)@Flatten[T/@{{#,v={0,0,0},v},{v,#2,v},{v,v,#3}}&@@(If[(l=Max@#)<75,v,If[74<l<135,{0,l,0},If[134<l<179,{l,0,l},{l,l,l}]]]&/@#)&/@g[[#]],1]&/@Range[Length@g],1])&

इसे ऑनलाइन आज़माएं!


वोल्फ्राम भाषा (गणितज्ञ), 243 बाइट्स

इस दूसरे कोड एक है समारोह है कि एक इनपुट के रूप लेता है छवि और एक आउटपुट छवि
(मैं क्यों लोग टिप्पणी में भ्रमित कर रहे थे पता नहीं है)

तो, अगर आप इस img फ़ीड

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

इस समारोह में 

(i=#;Image[Flatten[(T=Transpose)@Flatten[T/@{{#,v={0,0,0},v},{v,#2,v},{v,v,#3}}&@@(If[(l=Max@#)<75,v,If[74<l<135,{0,l,0},If[134<l<179,{l,0,l},{l,l,l}]]]&/@#)&/@ImageData[i,"Byte"][[#]],1]&/@Range[Last@ImageDimensions@i],1],ColorSpace->"RGB"])&


आपको यह आउटपुट मिलेगा

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

— J42161217
स्रोत
2
क्या इसे हार्डकोड इनपुट के रूप में नहीं गिना जाएगा?
— 196
"इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में हो सकते हैं, चाहे वह वास्तविक छवि फ़ाइलें हों ..."। नहीं, iएक छवि है।
— J42161217
मैं @attinat से सहमत हूं, यह हार्डकोडिंग जैसा लगता है।
— जोनाथन फ्रीच
मैंने कुछ बदलाव किए और मुझे उम्मीद है कि अब सब कुछ स्पष्ट है।
— J42161217
1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 157 बाइट्स

n=>{int i=0,j=n[0].Length;for(;;Write(z(0)+",0,0|0,"+z(1)+",0|0,0,"+z(2)+"\n|"[++i%j&1]));int z(int k)=>(((511^i/j%3%2*4064)>>n[i/j/3][i%j][k]/15)&1^1)*255;}

आउटपुट के आरजीबी प्रिंट करता है। आउटपुट न्यूलाइन अलग है और संरेखित नहीं है। मूल रूप से, मैंने 1चालू और 0बंद होने के साथ एक बिट-मास्क का उपयोग किया था, लेकिन फिर मैंने अर्नाउल्ड के उत्तर को देखा, और मुझे एहसास हुआ 0कि ऑन और 1ऑफ का उपयोग करके संख्या में बाइट्स बचा सकता है। TIO लिंक में 4 बाय 2 पिक्सेल नमूना "इमेज" है।

इसे ऑनलाइन आज़माएं!

— अज्ञान का अवतार
स्रोत
0

एपीएल + विन, 102 बाइट्स

24 बिट पूर्णांक के रूप में पिक्सेल के 2d मैट्रिक्स के लिए संकेत जैसा कि वे छवि में दिखाई देंगे

((⍴a)⍴,3 3⍴255*⍳3)×a←(3 1×⍴m)⍴∊⍉((1↓⍴m)/⍳↑⍴m)⊂n←(-+⌿n)⊖n←1 0↓0 75 135 180∘.≤,m←(1 3×⍴m)⍴,⍉(3⍴256)⊤,m←⎕

इसे ऑनलाइन आज़माएं! दरोगल क्लासिक के सौजन्य से

परिवर्तित छवि के 24 बिट पूर्णांक के 2d मैट्रिक्स को आउटपुट करता है। अधिकांश कोड इनपुट और आउटपुट के प्रारूपण को संभाल रहे हैं।

उदाहरण: नमूना पिक्सल से बनी 2 x 2 छवि लें

इनपुट:

2654895 10547300
2654895 10547300

आउटपुट :.

0     0 16581375 255 65025        0
0 65025        0   0 65025 16581375
0     0 16581375 255 65025        0
0     0 16581375 255 65025        0
0 65025        0   0 65025 16581375
0     0 16581375 255 65025        0
— ग्राहम
स्रोत
0

जंग - 281 बाइट्स

fn z(p:Vec<u8>,wh:[usize;2])->Vec<u8>{let mut o=vec![0;wh[0]*wh[1]*27];for m in 0..wh[0]{for n in 0..wh[1]{for i in 1..=3{for j in 0..3{o[m*9+n*wh[0]*27+j*wh[0]*9+i*2]=match p[18+m*3+n*wh[0]*3+3-i]{75..=134=>[0,1,0],135..=179=>[1,0,1],180..=255=>[1,1,1],_=>[0,0,0],}[j]*255;}}}}o}

यह लाइन एक ऐसा फ़ंक्शन है जो चुनौती से मिलता है, हालांकि यह इनपुट वास्तव में TGA फ़ाइल प्रारूप में डेटा है जैसा कि paulbourke.net पर वर्णित है, छवि के पिक्सेल में, पूर्व-पार्स्ड चौड़ाई और ऊंचाई के साथ। यह आउटपुट के लिए पिक्सेल डेटा देता है, बाइट्स के रूप में, वेक्टर पिक्सेल में इनपुट पिक्सेल डेटा के आकार का 9 गुना होता है।

use std::fs::File;use std::io::{Read,Write};fn main(){let mut p=vec![];let mut o=vec![0u8;18];File::open("i.tga").unwrap().read_to_end(&mut p).unwrap();let mut wh=[0;2];let h=|x|p[x] as usize;let g=|x|(3*x/256) as u8;for i in 0..2{wh[i]=h(12+i*2)+256*h(13+i*2);o[12+i*2]=g(wh[i]*256);o[13+i*2]=g(wh[i]);}let mut f=File::create("o.tga").unwrap();o[2]=2;o[16]=24;o.extend(z(p,wh));f.write(&o).unwrap();}

यह दूसरी पंक्ति एक मुख्य () फ़ंक्शन है जो i.tga नाम की एक इनपुट फ़ाइल को किसी बाहरी पुस्तकालयों का उपयोग किए बिना, पहली पंक्ति से फ़ंक्शन z को कॉल करके, o.tga नामक आउटपुट फ़ाइल में बदल सकती है। यह चौड़ाई / ऊंचाई के पार्सिंग को हैंडल करता है, आउटपुट फाइल के लिए हेडर बनाता है, और रीडिंग + राइटिंग फाइल करता है। यदि कुल 683 के लिए फ़ाइल I / O को चुनौती चाहिए तो यह 402 बाइट्स जोड़ देगा। यह परीक्षण के लिए उपयोगी है।

— चमकाओ
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.