Draw random black-and-white forest

C: 386311441023999942 927

The original solution saves 2 pnm files per run (one with g appended, before dithering). Because the dithering wasn't beautiful for the first few lines, there is a hack in place to render more lines than needed, and crop during output.

The golfed solution has a simpler dithering and saves only the dithered image. (no warnings with gcc -std=c11 -pedantic -Wall -Wextra)

Example images from 3 original program runs and one run of the golfed version (last image):

Golfed version

  #include <math.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#define D float
#define R rand()/RAND_MAX
#define Z(a,b,c) if(10.*R>a)T(h,s,j+b+c*R,g);
#define U a[y][x]
#define V e[y+1][x
#define F(x) for(i=0;i<x;++i)
int i,x,y,W=800,H=600;unsigned char a[600][800],c;D e[601][802],r,b,k,l,m,n,f,w,
d,q=.01;void T(D h,D s,D j,D g){r=b=0;do{j+=.04*R-.02;h+=sin(j)*q;s+=cos(j)*q;b
+=q;g+=q;f=525/d;r=.25-g/44;m=w*f+s*f+W/2;n=2*f-h*f+H/2;f*=r;for(y=n-f-2;y<n+f+2
;++y)if(y>=0&&y<H)for(x=m-f-2;x<m+f+2;++x)if(x>=0&&x<W)if(k=m-x,l=n-y,f>sqrt(k*k
+l*l))if(U>d*3)U=d*3;}while(b<10*r+12*r*R&&r>q);if(r>q){Z(2,.26,.35)Z(2,-.26,-
.35)Z(7,-.05,.1)}}int main(){FILE* o=fopen("i","wb");srand(time(0));F(W*H){y=i/W
;a[y][i%W]=(y<313)?255:6e3/(2*y-H);}F(200)w=1e2*R-60,d=80.*R+5,T(0,0,1.58,0);F(W
*H){x=i%W;y=i/W;k=U+e[y][x+1];U=-(k>0);l=(k-U)*.1;e[y][x+2]+=l*4;V]+=l*2;V+1]+=l
*3;V+2]+=l;}fprintf(o,"P5 800 600 255 ");fwrite(a,1,W*H,o);}


Original version

  #include <math.h>
#include <stdio.h>
#include <stdlib.h>

#define W 800
#define H 600
#define SPEED 0.01
#define HEIGHT 11.0

#define R(m) ((double)(m) * rand() / RAND_MAX)
#define RAD(deg) ((deg) / 180.0 * M_PI)
#define LIMIT(x, min, max) ((x) < (min) ? (min) : (x) > (max) ? (max) : (x))

void growTree(double dist, double side, double h, double s, double alpha, double grown);
void plot(double dist, double side, double h, double s, double alpha, double diam);
void dither(void);
void writeImg(int dither);

unsigned char img[H+10][W];
double err[H+10+2][W+4];
long tim;

int main(void)
{
int i;
tim = time(0);
srand(tim);
for(i = 0; i < 200; ++i)
{
growTree(5 + R(75), -60 + R(120), 0.0, 0.0, RAD(90), 0.0);
}
writeImg(0);
dither();
writeImg(1);
}

{
int y;
for(y = -10; y < H; ++y)
{
double dist = H * 3.5 / (2 * y - H);
unsigned char color = dist / 80 * 255;
if(y <= H / 2 || dist > 80) color = 255;
memset(img[y+10], color, W);
}
}

void growTree(double dist, double side, double h, double s, double alpha, double grown)
{
double diam, branchLength = 0.0;

do
{
h += sin(alpha) * SPEED;
s += cos(alpha) * SPEED;
branchLength += SPEED;
grown += SPEED;
diam = (1.0 - grown / HEIGHT) * 0.5;
plot(dist, side, h, s, alpha, diam);
} while(branchLength < 5 * diam + R(6 * diam) && diam > 0.02);

if(diam > 0.02)
{
int br = 0;

if(R(10) > 2) br++,growTree(dist, side, h, s, alpha + RAD(15) + R(RAD(20)), grown);
if(R(10) > 2) br++,growTree(dist, side, h, s, alpha - RAD(15) - R(RAD(20)), grown);
if(R(10) < 2 || br == 0) growTree(dist, side, h, s, alpha - RAD(2.5) + R(RAD(5)), grown);
}
}

void plot(double dist, double side, double h, double s, double alpha, double diam)
{
int x, y;
double scale = H / 4.0 * 3.5 / dist;
double x0 = side * scale + s * scale + W / 2.0;
double y0 = H / 2.0 + 2.0 * scale - h * scale;
diam *= scale;
h *= scale;
s *= scale;
for(y = y0 - diam / 2 - 2; y < y0 + diam / 2 + 2; ++y)
{
if(y < -10 || y >= H) continue;
for(x = x0 - diam / 2 - 2; x < x0 + diam / 2 + 2; ++x)
{
double dx, dy, d;
if(x < 0 || x >= W) continue;
dx = x0 - x;
dy = y0 - y;
d = diam / 2 - sqrt(dx * dx + dy * dy) + 0.5;
if(d > 0)
{
unsigned char color = dist / 80 * 255;
if(img[y+10][x] > color) img[y+10][x] = color;
}
}
}
}

void dither(void)
{
int x0, x, y;
for(y = -10; y < H; ++y)
{
for(x0 = 0; x0 < W; ++x0)
{
double error, oldpixel;
unsigned char newpixel;
if(y%2) x = W - 1 - x0;
else x = x0;
oldpixel = img[y+10][x] + err[y+10][x+2];
newpixel = oldpixel > 127 ? 255 : 0;
img[y+10][x] = newpixel;
error = oldpixel - newpixel;
err[y+10  ][x+1+2*(1-y%2)] += error * 7 / 48;
err[y+10  ][x+4*(1-y%2)] += error * 5 / 48;
err[y+10+1][x  ] += error * 3 / 48;
err[y+10+1][x+1] += error * 5 / 48;
err[y+10+1][x+2] += error * 7 / 48;
err[y+10+1][x+3] += error * 5 / 48;
err[y+10+1][x+4] += error * 3 / 48;
err[y+10+2][x  ] += error * 1 / 48;
err[y+10+2][x+1] += error * 3 / 48;
err[y+10+2][x+2] += error * 5 / 48;
err[y+10+2][x+3] += error * 3 / 48;
err[y+10+2][x+4] += error * 1 / 48;
}
}
}

void writeImg(int dither)
{
FILE* fp;
char buffer[32];
sprintf(buffer, "%ld%s.pnm", tim, dither ? "" : "g");
fp = fopen(buffer, "wb");
fprintf(fp, "P5\n%d %d\n255\n", W, H);
fwrite(&img[10][0], 1, W * H, fp);
fclose(fp);
}


Java Jungle

(954 golfed)

Full of deep, twisting undergrowth, this is a forest not easily traversed.

It's basically a fractal random walk with slowly shrinking, twisty vines. I draw 75 of them, gradually changing from white in the back to black up front. Then I dither the whole thing, shamelessly adapting Averroes' code here for that.

Golfed: (Just because others decided to)

import java.awt.*;import java.awt.image.*;import java.util.*;class P{static Random rand=new Random();public static void main(String[]a){float c=255;int i,j;Random rand=new Random();final BufferedImage m=new BufferedImage(800,600,BufferedImage.TYPE_INT_RGB);Graphics g=m.getGraphics();for(i=0;i++<75;g.setColor(new Color((int)c,(int)c,(int)c)),b(g,rand.nextInt(800),599,25+(rand.nextInt(21-10)),rand.nextInt(7)-3),c-=3.4);for(i=0;i<800;i++)for(j=0;j<600;j++)if(((m.getRGB(i,j)>>>16)&0xFF)/255d<rand.nextFloat()*.7+.05)m.setRGB(i,j,0);else m.setRGB(i,j,0xFFFFFF);new Frame(){public void paint(Graphics g){setSize(800,600);g.drawImage(m,0,0,null);}}.show();}static void b(Graphics g,float x,float y,float s,float a){if(s>1){g.fillOval((int)(x-s/2),(int)(y-s/2),(int)s,(int)s);s-=0.1;float n,t,u;for(int i=0,c=rand.nextInt(50)<1?2:1;i++<c;n=a+rand.nextFloat()-0.5f,n=n<-15?-15:n>15?15:n,t=x+s/2*(float)Math.cos(n),u=y-s/2*(float)Math.sin(n),b(g,t,u,s,n));}}}


Sane original code:

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.Random;
import javax.swing.JFrame;

public class Paint {

static int minSize = 1;
static int startSize = 25;
static double shrink = 0.1;
static int branch = 50;
static int treeCount = 75;

static Random rand = new Random();
static BufferedImage img;

public static void main(String[] args) {
img = new BufferedImage(800,600,BufferedImage.TYPE_INT_ARGB);
forest(img);
dither(img);
new JFrame() {
public void paint(Graphics g) {
setSize(800,600);
g.drawImage(img,0,0,null);
}
}.show();
}

static void forest(BufferedImage img){
Graphics g = img.getGraphics();
for(int i=0;i<treeCount;i++){
int c = 255-(int)((double)i/treeCount*256);
g.setColor(new Color(c,c,c));
tree(g,rand.nextInt(800), 599, startSize+(rand.nextInt(21-10)), rand.nextInt(7)-3);
}
}

static void tree(Graphics g, double x, double y, double scale, double angle){
if(scale < minSize)
return;
g.fillOval((int)(x-scale/2), (int)(y-scale/2), (int)scale, (int)scale);
scale -= shrink;
int count = rand.nextInt(branch)==0?2:1;
for(int i=0;i<count;i++){
double newAngle = angle + rand.nextDouble()-0.5;
if(newAngle < -15) newAngle = -15;
if(newAngle > 15) newAngle = 15;
double nx = x + (scale/2)*Math.cos(newAngle);
double ny = y - (scale/2)*Math.sin(newAngle);
tree(g, nx, ny, scale, newAngle);
}
}

static void dither(BufferedImage img) {
for (int i=0;i<800;i++)
for (int j=0;j<600;j++) {
double lum = ((img.getRGB(i, j) >>> 16) & 0xFF) / 255d;
if (lum <= threshold[rand.nextInt(threshold.length)]-0.2)
img.setRGB(i, j, 0xFF000000);
else
img.setRGB(i, j, 0xFFFFFFFF);
}
}

static double[] threshold = { 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31,
0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42,
0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53,
0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6, 0.61, 0.62, 0.63, 0.64,
0.65, 0.66, 0.67, 0.68, 0.69 };

}


One more? Okay! This one has the dithering tuned down a bit, so the blacks in front are much flatter.

Unfortunately, the dither doesn't show the fine details of the vine layers. Here's a greyscale version, just for comparison:

Javascript + HTML - not golfed

A javascript porting of the algorithm of @Manuel Kansten - it's amazing how good these trees look.

Just to do something different, I draw the image in color, then dither to b/w at the last step.

I don't know why, but my forest is less dark and less frightening respect to Manuel's.

Test with JSfiddle or run the new Snippet below. That's NOT fast. Be patient and watch the forest grow.

W=800
H=600
canvas.width = W;
canvas.height = H;

var ctx = canvas.getContext("2d");

R=function(m) { return m * Math.random()};
RAD=function(deg) { return deg / 180 * Math.PI};
LIMIT=function(x, min, max) {return x < min ? min : x > max ? max : x};
var SPEED = 0.01, HEIGHT = 11.0;

// Ground
ctx.fillStyle = grd;
ctx.fillRect(0,0, W,H);

Plot = function(dist, side, h, s, alpha, diam)
{
var x, y, a1,a2,scale = H/4 * 3.5 / dist,
x0 = side * scale + s * scale + W/2,
y0 = H/2 + 2.5*scale - h*scale;

k = dist
if (diam > 0.05) {
red = k*3|0;
green = k|0;
a1=alpha+1
a2=alpha-1
}
else
{
green= 80+(1-diam)*k*2|0;
red = k|0;
a1=0;
a2=2*Math.PI;
}
diam *= scale;
h *= scale;
s *= scale;
ctx.beginPath();
ctx.arc(x0,y0,diam/2, a1,a2);//lpha-1, alpha+1);//0,2*Math.PI);
ctx.fillStyle = 'rgb('+red+','+green+',0)';
ctx.fill();
}

Grow = function(dist, side, h, s, alpha, grown)
{
var diam, branchLength = 0.0;
diam = (1.0 - grown / HEIGHT) * 0.5;
do
{
h += Math.sin(alpha) * SPEED;
s += Math.cos(alpha) * SPEED;
branchLength += SPEED;
grown += SPEED;
diam = (1.0 - grown / HEIGHT) * 0.5;
Plot(dist, side, h, s, alpha, diam);
} while(branchLength < 5 * diam + R(6 * diam) && diam > 0.02);

if (diam > 0.02)
{
var br = 0;

if(R(10) > 2) br++,Grow(dist, side, h, s, alpha + RAD(15) + R(RAD(20)), grown);
if(R(10) > 2) br++,Grow(dist, side, h, s, alpha - RAD(15) - R(RAD(20)), grown);
if(R(10) < 2 || br == 0) Grow(dist, side, h, s, alpha - RAD(2.5) + R(RAD(5)), grown);
}
}

trees=[]
for(i = 0; i < 300; ++i) trees.push({ z: 1+R(70), s:R(120)-60 });
trees.sort( function (a,b) { return a.z - b.z} );

Draw = function()
{
t = trees.pop();
if (t)
{
Grow(t.z, t.s, 0, 0, RAD(90), 0);
setTimeout(Draw, 100);
}
else
{
var e,c,d,p,i,l, img = ctx.getImageData(0,0,W,H);
l = img.data.length;
for (i = 0; i < l-W*4-4; i+=4)
{
c = (img.data[i]+img.data[i+1])/2|0
c = img.data[i]
d = c > 120 + R(16) ? 255 : 0
e = c - d;
img.data[i]=img.data[i+1]=img.data[i+2]=d
c = (img.data[i+4]+img.data[i+5])/2|0

c = LIMIT(c + ((e*7)>>4),0,255)
img.data[i+4]=img.data[i+5]=img.data[i+6]=c
p = i+W*4
c = (img.data[p-4]+img.data[p-3])/2|0
c = LIMIT(c + ((e*3)>>4),0,255)
img.data[p-4]=img.data[p-3]=img.data[p-2]=c
c = (img.data[p]+img.data[p+1])/2|0
c = LIMIT(c+ ((e*5)>>4),0,255)
img.data[p]=img.data[p+1]=img.data[p+2]=c
c = (img.data[p+4]+img.data[p+5]*2)/3|0
c = LIMIT(c + (e>>4),0,255)
img.data[p+4]=img.data[p+5]=img.data[p+6]=c

}
bwcanvas.width = W;
bwcanvas.height = H;
var bwx = bwcanvas.getContext("2d");
bwx.putImageData(img,0,0);
}
}

setTimeout(Draw, 10);
<canvas id='bwcanvas'  width="2" height="2"></canvas>
<canvas id='canvas'  width="2" height="2"></canvas>