Zoom sub-pixel

9

Sua tarefa é obter uma imagem sRGB de 24 BPP e gerar a mesma imagem ampliada em 3x em subpixels vermelho, verde e azul. A imagem resultante será composta inteiramente de pixels pretos, vermelhos, verdes e azuis.

Cada pixel da imagem de origem, quando ampliado, produz um arranjo de 9 subpixels que podem ser ativados ou desativados (ou seja, suas respectivas cores ou preto). O arranjo específico usa três colunas de vermelho, verde e azul, nessa ordem, da seguinte maneira:

Subpixels RGB

(Observe que as bordas desses "pixels" são apenas para demonstração.)

Como cada um dos nove subpixels só pode ser ativado ou desativado, você precisará quantizar a imagem de entrada e usar diferentes padrões de subpixel para alcançar 3 níveis de brilho.

Para cada subpixel na imagem:

  • Para os níveis de cor de 0 a 74, todos os subpixels devem ser pretos.
  • Para os níveis de cor 75-134, o subpixel do meio deve ser a cor respectiva e os outros dois devem ser pretos.
  • Para os níveis de cor 135-179, o subpixel do meio deve ser preto e os outros dois devem ter a respectiva cor
  • Para os níveis de cor 180-255, todos os três subpixels devem ter suas respectivas cores

Eu escolhi esses intervalos de nível porque foi isso que aconteceu com uma boa aparência

Aplique essa transformação a todos os pixels da imagem e produza a imagem com sub-pixel.

Exemplos de pixel único

rgb (40, 130, 175) produzirá este padrão:

00B / 0G0 / 00B

rgb (160, 240, 100) produzirá este padrão:

RG0 / 0GB / RG0

Exemplos de imagem completa

Monalisa Mona Lisa Subpixels

Noite estrelada Subpixels da noite estrelada

Papagaio Subpixels Parrot

Imagens originárias da Wikipedia

Regras e notas

  • A entrada e a saída podem estar em qualquer formato conveniente, sejam arquivos de imagem reais ou (possivelmente aninhadas) listas de valores RGB.
  • Você pode assumir que os pixels estão no espaço de cores sRGB com 24BPP.

Feliz golfe!

code-golf graphical-output Beefster
fonte
2
A descrição inicial soa como não Bayering. Acontece que não é, em parte por causa da máscara 3x3 não convencional, mas principalmente por causa da quantização, mas a IMO ainda está mais perto de remover o Bayering do que usar o zoom subpixel (o que seria melhor com algum tipo de detecção de borda para anti- alias).
Peter Taylor
obrigado por um desafio interessante .... isso é realmente usado para algo na vida real?
3111 don don bright

Respostas:

4

JavaScript (Nó, Chrome, Firefox), 111 bytes

Formato de E / S: matriz de [R,G,B]valores.

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

Experimente online! (apenas um pixel)

Como?

Todos os valores limite são múltiplos de 15. Em vez de fazer testes de comparação explícitos, é um pouco mais curto testar uma máscara de bits em que cada bit representa um intervalo de 15 valores (exceto o bit mais significativo que é mapeado para um único valor).

 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

Nós temos:

  • 000000000111111111511
  • 0000001110000111113615

Comentado

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

Exemplo

O seguinte trecho de código processa a cabeça da Mona Lisa (64x64). Não funciona no Edge.

Mostrar snippet de código

Arnauld
fonte
3

Gelatina , 27 bytes

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

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

Experimente online! Este exemplo está tirando uma imagem dois por dois, onde o pixel superior esquerdo é o primeiro exemplo de pixel, o pixel superior direito é o segundo exemplo de pixel, o pixel inferior esquerdo é um pixel preto e o pixel inferior direito é um branco pixel.

Como?

<“⁷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
estou tentando descobrir onde ele codifica [[1,0,0]. [0,1,0], [0,0,1]] e estou confuso.
don bright
@donbright 3⁼þ¤executa um produto externo de [1,2,3]=[1,2,3]produção [[1=1,2=1,3=1],[2=1,2=2,2=3],[3=1,3=2,3=3]]que é [[1,0,0],[0,1,0],[0,0,1]].
Jonathan Allan
2

Wolfram Language (Mathematica) , 186 bytes

Entrada e Saída são listas de valores 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])&

Experimente online!


Wolfram Language (Mathematica), 243 bytes

esse segundo código é uma função que recebe como entrada uma imagem e gera uma imagem
(não sei por que as pessoas ficaram confusas nos comentários)

Então, se você alimentar esse img

insira a descrição da imagem aqui

nessa função 

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


você obterá essa saída

insira a descrição da imagem aqui

J42161217
fonte
2
Isso não conta como uma entrada codificada?
attinat 24/03/19
"Entrada e saída podem estar em qualquer formato conveniente, sejam arquivos de imagem reais ...". Não, ié uma imagem.
J42161217
Concordo com o @attinat, isso parece codificado.
Jonathan Frech
Fiz algumas mudanças e espero que tudo esteja claro agora.
J42161217
1

C # (compilador interativo do Visual C #) , 157 bytes

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

Imprime o RGB da saída. A saída é nova linha separada e não alinhada. Originalmente, eu usava uma máscara de bits quando 1estava ligado e 0desligado, mas então vi a resposta de Arnauld e percebi que usar 0como ligado e 1desligado poderia salvar bytes no número. O link TIO contém uma "imagem" de amostra de 4 por 2 pixels.

Experimente online!

Modalidade de ignorância
fonte
0

APL + WIN, 102 bytes

Solicita uma matriz 2D de pixels como números inteiros de 24 bits, como apareceriam na imagem

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

Experimente online! Cortesia de Dyalog Classic

Produz uma matriz 2D de números inteiros de 24 bits da imagem transformada. A maior parte do código está lidando com a formatação da entrada e saída.

Exemplo: Tire uma imagem 2 x 2 composta pelos pixels de amostra

Entrada:

2654895 10547300
2654895 10547300

Resultado:.

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

Ferrugem - 281 bytes

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}

Essa linha é uma função que atende ao desafio, no entanto, sua entrada é realmente dados no formato de arquivo TGA, conforme descrito em paulbourke.net , juntamente com largura e altura pré-analisadas, em pixels, da imagem. Retorna dados de pixel para a saída, como bytes, em um vetor 9 vezes o tamanho dos dados de pixel de entrada.

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

Essa segunda linha é uma função main () que pode transformar um arquivo de entrada chamado i.tga em um arquivo de saída chamado o.tga, chamando a função z da primeira linha, sem usar bibliotecas externas. Ele lida com a análise de largura / altura, criando um cabeçalho para o arquivo de saída e lendo + gravando. Seria adicionar 402 bytes se o desafio exigisse E / S de arquivo, para um total de 683. É útil para teste.

não brilhante
fonte