Zoom sub-pixel

9

Il tuo compito è acquisire un'immagine sRGB di 24 BPP e produrre la stessa immagine ingrandita 3 volte in subpixel rossi, verdi e blu. L'immagine risultante sarà interamente realizzata con pixel neri, rossi, verdi e blu puri.

Ogni pixel dell'immagine sorgente, quando ingrandito, produce una disposizione di 9 sub-pixel che possono essere attivati ​​o disattivati ​​(ovvero il rispettivo colore o nero). La disposizione specifica utilizza tre colonne di rosso, verde e blu, in questo ordine, in questo modo:

Subpixel RGB

(Notare che i bordi su questi "pixel" sono solo a scopo dimostrativo.)

Poiché ciascuno dei nove subpixel può essere solo attivato o disattivato, sarà necessario quantizzare l'immagine di input e utilizzare diversi modelli di subpixel per raggiungere 3 livelli di luminosità.

Per ogni subpixel nell'immagine:

  • Per i livelli di colore 0-74, tutti i sottopixel devono essere neri.
  • Per i livelli di colore 75-134, il sottopixel medio dovrebbe essere il rispettivo colore e gli altri due dovrebbero essere neri.
  • Per i livelli di colore 135-179, il sottopixel medio dovrebbe essere nero e gli altri due dovrebbero essere il rispettivo colore
  • Per i livelli di colore 180-255, tutti e tre i subpixel devono essere del rispettivo colore

Ho scelto queste gamme di livelli perché sono proprio quelle che sembrano belle

Applica questa trasformazione a tutti i pixel dell'immagine e genera l'immagine ingrandita subpixel.

Esempi a pixel singolo

rgb (40, 130, 175) produrrà questo modello:

00B / 0G0 / 00B

rgb (160, 240, 100) produrrà questo modello:

RG0 / 0GB / RG0

Esempi di immagini complete

Monna Lisa Mona Lisa Subpixels

Notte stellata Sottopixel di notte stellata

Pappagallo Parrot Subpixels

Immagini provenienti da Wikipedia

Regole e note

  • L'input e l'output possono essere in qualsiasi formato conveniente, sia che si tratti di file di immagini reali o di elenchi (possibilmente nidificati) di valori RGB.
  • Si può presumere che i pixel siano nello spazio colore sRGB con 24BPP.

Buon golf!

code-golf  graphical-output 
— Beefster
fonte
2
La descrizione iniziale sembra non-Bayering. Si scopre che non lo è, in parte a causa della maschera non convenzionale 3x3 ma principalmente a causa della quantizzazione, ma IMO è ancora più vicino allo scioglimento che allo zoom subpixel (che sarebbe upscaling con una sorta di rilevamento dei bordi per anti- alias).
— Peter Taylor,
grazie per un'interessante sfida .... questo è effettivamente utilizzato per qualcosa nella vita reale?
— don luminoso

Risposte:

4

JavaScript (Nodo, Chrome, Firefox), 111 byte

Formato I / O: matrice di [R,G,B]valori.

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)))

Provalo online! (solo un singolo pixel)

Come?

Tutti i valori di soglia sono multipli di 15. Invece di eseguire test di confronto espliciti, è un po 'più breve testare una maschera di bit in cui ogni bit rappresenta un intervallo di 15 valori (tranne il bit più significativo che è mappato su un singolo valore).

 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

10

Noi abbiamo:

  • 000000000111111111511
  • 0000001110000111113615

Commentate

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

Esempio

Il frammento di codice seguente elabora la testa di Mona Lisa (64x64). Non funziona su Edge.

Mostra snippet di codice

— Arnauld
fonte
3

Gelatina , 27 byte

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

[0,255][r, g, b]

Provalo online! Questo esempio sta prendendo un'immagine due per due in cui il pixel in alto a sinistra è il primo pixel di esempio, il pixel in alto a destra è il secondo pixel di esempio, il pixel in basso a sinistra è un pixel nero e il pixel in basso a destra è un bianco pixel.

Come?

<“⁷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
— Jonathan Allan
fonte
sto cercando di capire dove codifica [[1,0,0]. [0,1,0], [0,0,1]] e sono sconcertato.
— don luminoso
@donbright 3⁼þ¤esegue un prodotto esterno di [1,2,3]=[1,2,3]cedimento [[1=1,2=1,3=1],[2=1,2=2,2=3],[3=1,3=2,3=3]]che è [[1,0,0],[0,1,0],[0,0,1]].
— Jonathan Allan,
2

Wolfram Language (Mathematica) , 186 byte

Input e Output sono elenchi di valori 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])&

Provalo online!


Wolfram Language (Mathematica), 243 byte

questo secondo codice è una funzione che accetta come input un'immagine e produce un'immagine
(non so perché le persone fossero confuse nei commenti)

Quindi, se dai da mangiare a questo img

inserisci qui la descrizione dell'immagine

in questa funzione 

(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"])&


otterrai questo risultato

inserisci qui la descrizione dell'immagine

— J42161217
fonte
2
Questo non sarebbe considerato un input hardcoded?
— attinat
"Input e output possono essere in qualsiasi formato conveniente, sia che si tratti di file di immagini reali ...". No, iè un'immagine.
— J42161217
Sono d'accordo con @attinat, questo sembra hardcoding.
— Jonathan Frech,
Ho apportato alcune modifiche e spero che ora sia tutto chiaro.
— J42161217
1

C # (compilatore interattivo Visual C #) , 157 byte

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;}

Stampa l'RGB dell'output. L'output è separato da una nuova riga e non allineato. Inizialmente, ho usato una maschera di bit con l' 1essere acceso e 0spento, ma poi ho visto la risposta di Arnauld, e mi sono reso conto che usare 0come acceso e 1spento poteva salvare byte nel numero. Il collegamento TIO contiene una "immagine" di esempio di 4 per 2 pixel.

Provalo online!

— Incarnazione dell'ignoranza
fonte
0

APL + WIN, 102 byte

Richiede una matrice 2d di pixel come numeri interi a 24 bit come apparirebbero nell'immagine

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

Provalo online! Per gentile concessione di Dyalog Classic

Emette una matrice 2d di numeri interi a 24 bit dell'immagine trasformata. Gran parte del codice gestisce la formattazione dell'input e dell'output.

Esempio: cattura un'immagine 2 x 2 composta dai pixel campione

Ingresso:

2654895 10547300
2654895 10547300

Produzione:.

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
— Graham
fonte
0

Ruggine - 281 byte

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}

Questa linea è una funzione che risponde alla sfida, tuttavia i suoi input sono in realtà dati nel formato di file TGA come descritto su paulbourke.net , insieme a larghezza e altezza pre-analizzate, in pixel, dell'immagine. Restituisce i dati pixel per l'output, come byte, in un vettore 9 volte la dimensione dei dati pixel di input.

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();}

Questa seconda riga è una funzione main () che può trasformare un file di input denominato i.tga in un file di output chiamato o.tga, chiamando la funzione z dalla prima riga, senza utilizzare alcuna libreria esterna. Gestisce l'analisi di larghezza / altezza, creando un'intestazione per il file di output e lettura e scrittura del file. Aggiungerebbe 402 byte se la sfida richiedesse l'I / O file, per un totale di 683. È utile per i test.

— don luminoso
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.