Sub-pixel Zooming

Question

Your task is to take a 24 BPP sRGB image and output the same image upscaled 3x into red, green, and blue subpixels. The resulting image will be made entirely of pure black, red, green, and blue pixels.

Each pixel from the source image, when zoomed, produces an arrangement of 9 sub-pixels that can be either on or off (i.e. their respective color or black). The specific arrangement uses three columns of red, green, and blue, in that order, like so:

^{(Note that the borders on these "pixels" are for demonstration only.)}

Since each of the nine subpixels can only be on or off, you will have to quantize the input image and use different subpixel patterns to achieve 3 levels of brightness.

For each subpixel in the image:

• For color levels 0-74, all subpixels should be black.
• For color levels 75-134, the middle subpixel should be the respective color and the other two should be black.
• For color levels 135-179, the middle subpixel should be black and the other two should be the respective color
• For color levels 180-255, all three subpixels should be their respective color

^{I chose these level ranges because those are what happened to look good}

Apply this transformation to every pixel in the image and output the subpixel-upscaled image.

Single-pixel examples

rgb(40, 130, 175) will produce this pattern:

rgb(160, 240, 100) will produce this pattern:

Full Image Examples

Images sourced from Wikipedia

Rules and notes

• Input and output may be in any convenient format, whether that's actual image files or (possibly nested) lists of RGB values.
• You may assume the pixels are in the sRGB colorspace with 24BPP.

Happy golfing!

Answer 1

JavaScript (Node, Chrome, Firefox), 111 bytes

I/O format: matrix of [R,G,B] values.

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

Try it online! (just a single pixel)

How?

All threshold values are multiples of 15. Instead of doing explicit comparison tests, it's a bit shorter to test a bitmask where each bit represents an interval of 15 values (except the most significant bit which is mapped to a single value).

 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

We encode off as \$1\$ and on as \$0\$ in order to maximize the number of leading zeros.

We get:

• 000000000111111111 for top and bottom pixels (\$511\$ in decimal)
• 000000111000011111 for the middle pixel (\$3615\$ in decimal)

Commented

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

Example

The following code snippet processes the head of Mona Lisa (64x64). Doesn't work on Edge.

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

var img;

(img = new Image).onload = function(){
  var ctx = document.getElementById('c').getContext('2d');
  ctx.drawImage(img, 0, 0);
  var data = ctx.getImageData(0, 0, 192, 192), x, y, ptr, a = [];
  for(ptr = y = 0; y < 64; y++) {
    for(a[y] = [], x = 0; x < 64; x++) {
      a[y][x] = [data.data[ptr++], data.data[ptr++], data.data[ptr++]];
      ptr++;
    }
    ptr += 512;
  }
  a = f(a);
  for(ptr = y = 0; y < 192; y++) {
    for(x = 0; x < 192; x++) {
      data.data[ptr++] = a[y][x][0];
      data.data[ptr++] = a[y][x][1];
      data.data[ptr++] = a[y][x][2];
      data.data[ptr++] = 255;
    }
  }
  ctx.putImageData(data, 0, 0);
};

document.getElementById('img').src = img.src = "data:image/png;base64,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";

<img id="img" />
<canvas id="c" width=192 height=192></canvas>

Answer 2

Jelly, 27 bytes

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

A monadic Link accepting a list (picture) of lists (rows) of lists (pixels). Each pixel being three integers in \$[0,255]\$, [r, g, b], which yields the result in the same format.

Try it online! This example is taking a two by two image where the top-left pixel is the first example pixel, the top-right pixel is the second example pixel, the bottom-left pixel is a black pixel and the bottom-right pixel is a white pixel.

How?

<“⁷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

Answer 3

Wolfram Language (Mathematica), 186 bytes

Input and Output are lists of RGB values

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

Try it online!

Wolfram Language (Mathematica), 243 bytes

this second code is a function that takes as input an image and outputs an image
(I don't know why people were confused in the comments)

So, if you feed this img

into this function

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

you will get this output

Answer 4

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

Prints the RGB of the output. The output is newline separated and not aligned. Originally, I used a bit-mask with 1 being on and 0 being off, but then I saw Arnauld's answer, and I realized using 0 as on and 1 as off could save bytes in the number. The TIO link contains a 4 by 2 pixel sample "image".

Try it online!

Answer 5

APL+WIN, 102 bytes

Prompts for a 2d matrix of pixels as 24 bit integers as they would appear in the image

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

Try it online! Courtesy of Dyalog Classic

Outputs a 2d matrix of 24 bit integers of the transformed image. Most of the code is handling the formatting of the input and output.

Example: Take a 2 x 2 image made up of the sample pixels

Input:

2654895 10547300
2654895 10547300

Output:.

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

Answer 6

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

This line is a function that meets the challenge, however it's input is actually data in the TGA file format as described at paulbourke.net, along with pre-parsed width and height, in pixels, of the image. It returns pixel data for the output, as bytes, in a vector 9 times the size of the input pixel data.

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

This second line is a main() function that can transform an input file named i.tga into an output file named o.tga, by calling the function z from the first line, without using any external libraries. It handles parsing of width/height, creating a header for the output file, and file reading + writing. It would add 402 bytes if the challenge required File I/O, for a total of 683. It is useful for testing.