Масштабування пікселів

9

Ваше завдання - зробити зображення sRGB на 24 BPP та вивести одне і те ж зображення, збільшене до розміру 3x, на червоні, зелені та сині субпікселі. Отримане зображення буде зроблене повністю з чистого чорного, червоного, зеленого та синього пікселів.

Кожен піксель із вихідного зображення при збільшенні зображення створює розташування 9 пікселів, які можуть бути або вимкненими (тобто відповідним кольором або чорним). Конкретна композиція використовує три стовпці червоного, зеленого та синього у такому порядку:

Підпікселі RGB

(Зверніть увагу, що межі цих "пікселів" призначені лише для демонстрації.)

Оскільки кожен з дев'яти субпікселів може бути увімкненим або вимкненим, вам доведеться квантовати вхідне зображення та використовувати різні шаблони підпікселів для досягнення 3 рівнів яскравості.

Для кожного підпікселя на зображенні:

  • Для рівнів кольору 0-74 всі субпікселі повинні бути чорними.
  • Для рівнів кольорів 75-134 середній підпіксель повинен бути відповідним кольором, а інші два - чорним.
  • Для рівнів кольорів 135-179 середній підпіксель повинен бути чорним, а інші два - відповідним кольором
  • Для рівнів кольору 180-255 всі три субпікселі повинні бути відповідного кольору

Я вибрав ці діапазони рівнів, тому що це те, що трапилося, щоб виглядати добре

Застосуйте це перетворення до кожного пікселя на зображенні та виведіть зображення, що збільшує підпіксель.

Приклади однопіксельних

rgb (40, 130, 175) створить такий малюнок:

00B / 0G0 / 00B

rgb (160, 240, 100) створить такий малюнок:

RG0 / 0GB / RG0

Приклади повного зображення

Мона Ліза Субпікселі Mona Lisa

Зоряна ніч Зоряні нічні субпікселі

Папуга Підпікселі для папуг

Зображення походять із Вікіпедії

Правила та примітки

  • Введення та вихід можуть бути у будь-якому зручному форматі, будь то фактичні файли зображень або (можливо, вкладені) списки значень RGB.
  • Ви можете припустити, що пікселі знаходяться у кольорі простору sRGB з 24BPP.

Щасливого гольфу!

code-golf  graphical-output 
— Біфстер
джерело
2
Початковий опис звучить як un-Bayering. Виявляється, це не частково через нетрадиційну маску 3x3, а головним чином через квантування, але IMO все-таки ближче до un-Bayering, ніж до збільшення пікселів (що може бути погіршенням з якимось виявленням краю на анти- псевдонім).
— Пітер Тейлор
дякую за цікавий виклик .... чи справді це використовується для чогось у реальному житті?
— яскравий

Відповіді:

4

JavaScript (Node, Chrome, Firefox), 111 байт

Формат вводу / виводу: матриця [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

Приклад

Наступний фрагмент коду обробляє голову Mona Lisa (64x64). Не працює на Edge.

Показати фрагмент коду

— Арнольд
джерело
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
— Джонатан Аллан
джерело
Я намагаюся розібратися, де він кодує [[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

Мова Вольфрама (Mathematica) , 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])&

Спробуйте в Інтернеті!


Мова Вольфрама (Mathematica), 243 байти

цей другий код є функцією, яка приймає як введення зображення і видає зображення
(я не знаю, чому люди плутаються в коментарях)

Отже, якщо ви годуєте цим імг

введіть тут опис зображення

в цю функцію 

(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
Чи не вважатиметься це вкладеним кодом?
— attinat
"Введення та вихід можуть бути у будь-якому зручному форматі, будь то фактичні файли зображень ...". Ні, iце образ.
— J42161217
Я погодився б з @attinat, це виглядає як жорстке кодування.
— Джонатан
Я вніс деякі зміни і сподіваюся, що зараз усе зрозуміло.
— J42161217
1

C # (Visual C # Interactive Compiler) , 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;}

Друкує RGB ​​виводу. Вихід відокремлений і не вирівняний. Спочатку я використовував біт-маску з 1включенням і 0вимкненням, але потім я побачив відповідь Арнаульда, і зрозумів, що використання 0ввімкнення і 1вимкнення може зберегти байти в кількості. Посилання TIO містить "зображення" зразка 4 на 2 пікселі.

Спробуйте в Інтернеті!

— Втілення невігластва
джерело
0

APL + WIN, 102 байти

Запрошує 2d матрицю пікселів у вигляді 24-бітових цілих чисел, як вони відображатимуться на зображенні

((⍴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←⎕

Спробуйте в Інтернеті! Надано Dyalog Classic

Виводить 2d матрицю з 24-бітових цілих чисел перетвореного зображення. Більшість кодів обробляє форматування вводу та виводу.

Приклад: візьміть зображення 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 у вихідний файл з назвою o.tga, викликавши функцію z з першого рядка, не використовуючи жодних зовнішніх бібліотек. Він обробляє розбір ширини / висоти, створюючи заголовок для вихідного файлу та читання файлів + запис. Він додасть 402 байти, якщо для виклику потрібен ввід / вивід файлу, загалом 683. Це корисно для тестування.

— Дон яскравий
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.