Produce an image based on an elementary cellular automata ruleset

Question

What is elementary cellular automata?

Since I'm not sure I'll be able to explain this so that somebody who has never heard of this is able to understand, I'm giving an explanation from https://mathworld.wolfram.com/ElementaryCellularAutomaton.html

Elementary cellular automata have two possible values for each cell (0 or 1), and rules that depend only on nearest neighbor values. As a result, the evolution of an elementary cellular automaton can completely be described by a table specifying the state a given cell will have in the next generation based on the value of the cell to its left, the value the cell itself, and the value of the cell to its right. Since there are 2×2×2=2^3=8 possible binary states for the three cells neighboring a given cell, there are a total of 2^8=256 elementary cellular automata, each of which can be indexed with an 8-bit binary number. For example, the table giving the evolution of rule 30 (30=00011110_2) is illustrated above. In this diagram, the possible values of the three neighboring cells are shown in the top row of each panel, and the resulting value the central cell takes in the next generation is shown below in the center.

The evolution of a one-dimensional cellular automaton can be illustrated by starting with the initial state (generation zero) in the first row, the first generation on the second row, and so on. For example, the figure bellow illustrated the first 20 generations of the rule 30 elementary cellular automaton starting with a single black cell.

The task

Given a ruleset n, where n is positive and less than 256, produce an image like the one above, with 15 generations (+1 starting gen-0) and 2 colors of your choice. The starting gen-0 is one active cell in the center, like in the image above. You can choose to start from the bottom and work upwards.

Input

You can take input either as a:

• Binary number (for example, rule 30 would be 00011110 or the reverse 01111000)
• Decimal number (rule 30 would be 30)

You cannot take images from external resources, the image should made from scratch by your program.

Output

Your output should be a 31x16 image, with each row representing a separate generation. Generations should not be given in a mixed order.

Submissions

Your submission should always contain the following:

1. Your code
2. An image produced by your program, representing a ruleset of your liking. Standard loopholes apply. Your program should work for any n in the range [0,256).

Scoring is done by byte count

EDIT

As requested, adding some test cases specifically for edge handling.

rule 222:

rule 201:

rule 162:

rule 16:

Answer 1

Python 2, 178 167 ... 128 bytes

-13 bytes thanks to @Surculose Sputum!

-2 bytes thanks to @dingledooper!

thanks @Surculose Sputum again for saving some bytes and fixing the boundary bug!!!!

n=input()
print'P1 31 16'
c='%061d'%10**30
exec"print' '.join(c[15:46]);c='0'+''.join(n[int(c[u:u+3],2)]for u in range(60));"*16

Try it online!

Output a 31x16 pbm image in stdout. You might need a magnifying glass to see those tinnie images though.

'01111000' => (30 in reverse)
'01011000' => (26 in reverse)

Answer 2

Wolfram Language (Mathematica), 42 bytes

¯\_(ツ)_/¯

Image@CellularAutomaton[#,{{1},0},15]&    

n=30

n=26

Since this challenged changed to gode-golf I applied the changes that @Dan the Man proposed and saved some bytes.
The images now should have inverted colors

Answer 3

Sledgehammer, 24 19 bytes

^{(alternatively, 18.625)}
Obtained from the Wolfram code ExportString[ArrayPlot[CellularAutomaton[Input[], {{1}, 0}, {15, All}]], "SVG"].

Outputs via (as you could easily tell) SVG. The ExportString part can be dropped, but then it will output a Graphics object - it's basically an image, but it's hard to view without loading it into Mathematica or exporting it via Export/ExportString.

⣕⢼⡔⡼⣂⡏⢂⠌⢤⡾⣧⣾⢴⠮⣯⠴⢒⣈⣱

Answer 4

05AB1E, 57 bytes

"P1 31 16",¾16иJD"ÿ1ÿ"16E©D¦¨Sðý,31Lε<®s.$3£C7αIsè}J"0ÿ0"

a (bad) port of this python answer

Try it online!

Answer 5

Haskell, 175 158 154 bytes

t=take 16
f=t$0:f
(a:b)!s=s<$>p(a:a:b)
p(a:b:c:d)=(4*a+2*b+c):p(b:c:d)
p[a,b]=[4*a+3*b]
m s=putStr"P1 33 16 ">>mapM_ print`mapM_`t(iterate(!(s!!))$f++1:f)

Try it online!

Outputs to a pbm file with white being off and black being on. You can switch the on and off colors at no cost to bytes.

Sample outputs

Rule 30

• Raw

  

• Increased size

  

Rule 121

• Raw

  

• Increased Size

  

Answer 6

MATL, 36 bytes

Thanks to @AdHocGarfHunter for pointing out a mistake, now corrected

l30Ya!15:"GyFTYa3YC!XBQ)]v16:46Z)0YG

Input is binary in reverse order. Output is white for active cell, black for inactive.

Try it at MATL Online!

Explanation

l       % Push 1
30Ya    % Padarray: pads 1 with 30 zeros on each side. Gives a column vector.
        % This large amount of padding is necessary to avoid edge effects in
        % the output
!       % Transpose into a row vector
15:"    % Do the following 15 times
  G     %   Push input
  y     %   Duplicate from below: pushes a copy of the latest row vector
  FTYa  %   Pad with one zero to the left and one to the right
  3YC   %   Matrix of length-3 sliding blocks arranged as columns
  !     %   Transpose. Each block is now a row
  XB    %   Convert each row from binary to a number
  Q     %   Add 1 (this is needed because indexing is 1-based)
  )     %   Index the input with these numbers. This applies the automaton
        %   rule to each length-3 block, producing a new generation
]       % End
v       % Concatenate all row vectors into a matrix
16:46   % Push [16 17 ... 46]: indices of the columns to be kept
Z)      % Use as column indices
0YG     % Write to image file. This is implicitly displayed by MATL Online

Answer 7

Java, 247 bytes

import java.awt.image.*;r->{BufferedImage i=new BufferedImage(31,16,1);int[]p=((DataBufferInt)i.getRaster().getDataBuffer()).getData();p[15]=-1;for(int a=31;a<496;a++)p[a]=r<<31-(p[a==31?0:a-32]<<2&4|p[a-31]<<1&2|p[a==495?0:a-30]&1)>>31;return i;}

repl.it

Before minimizing:

rule -> {
    BufferedImage image  = new BufferedImage(31, 16, BufferedImage.TYPE_INT_RGB);
    int[]         pixels = ((DataBufferInt)image.getRaster().getDataBuffer()).getData();
    pixels[15]           = -1;
    for (int i = 31; i < 496; i++)
        pixels[i] = rule << 31 - (pixels[Math.max(0, a - 32)] << 2 & 4 | 
                                  pixels[i - 31] << 1 & 2 | 
                                  pixels[i == 495 ? 0 : i - 30] & 1) >> 31;
    return image;
};

Inner magic ungolfed:

BOTTOM_LEFT_PIXEL_WHICH_IS_WRITTEN = 465;
int upLeft  = pixels[Math.max(0, i - 32)];
int up      = pixels[i - 31];
int upRight = pixels[i - 30 == BOTTOM_LEFT_PIXEL_WHICH_IS_WRITTEN ? 0 : i - 30];
int code    = ((upLeft << 2) & 4) | ((up << 1) & 2) | (upRight & 1);
int newBit  = (rule >> code) & 1;
pixels[i] = newBit == 0 ? 0x00000000 : 0xFFFFFFFF;

Notes: The code could be even shorter if the output image was allowed to be 32 pixels wide instead of 31. It could be even shorter if 'active' pixels may be impossibly invisible dark blue (#000001)

It could surely be shorter with pbm output, but I like to see my stuff directly.

Answer 8

Python 3, 335 334 bytes

from PIL import Image
from numpy import*
a=zeros((16,31),dtype=uint8)
x,a[0][15]=list(map(int,input())),1
for i in range(1,16):
 a[i][15-i],a[i][15+i]=x[a[i-1][15-i]*2+a[i-1][16-i]],x[a[i-1][14+i]*4+a[i-1][15+i]*2]
 for j in range(16-i,15+i):
  a[i][j]=x[a[i-1][j-1]*4+a[i-1][j]*2+a[i-1][j+1]]
Image.fromarray(a*255,"L").save('1.png')

This is not very golfed, so no need to explain it.

Outputs to 1.png and black for 0, white for 1.

Since Python can't do image processing by itself, the packages pillow and numpy are required.

Input is reversed bits.