Pretty mandelbrot pictures using awk - a language that has no graphics commands

[miriam_e]

This graphics server that Kimi AI has been helping me to build lets me do wonderful things. Here are some pictures made using awk to explore the famous mandelbrot set:


x = 0.3798053
y = 0.09999955
side = .0000002
hue = 0.005


x = 0.3798053523334
y = 0.0999995944562
side = 0.000000000005
hue = 0.0035

The x and y coordinates are the position of the middle of the image. The side is the size of the vertical side of the image in the mandelbrot set. And hue is really a measurement of the spread of colors over the values in the image.

When I've eliminated the main bugs in the server I'll upload the program so anybody can use it from any computer language, regardless of whether the language has graphics commands.

I should have added the mandelbrot set using awk. Here it is (I've highlighted in red the special commands sent to the canvas server via its pixel bridge):

#!/bin/bash

wide=$(awk '/width/ {print $2}' ~/.config/canvas/settings)
high=$(awk '/height/ {print $2}' ~/.config/canvas/settings)

awk -v w="$wide" -v h="$high" '
BEGIN {
    hue_scale = 0.0035
    saturation = 0.9
    lightness = 0.5
    max = 10000          # iterations
    side = 0.000000000005     # size of image side (smaller = deeper zoom)
    midx = 0.3798053523334    # Center X (bigger = move camera right)
    midy = 0.0999995944562    # Center Y (bigger = move camera down)

	# X image size scales by aspect ratio to match Y size
    xside = side * w / h

    for (py = 0; py < h; py++) {
        y0 = (py - h/2) * side / h + midy
        
        for (px = 0; px < w; px++) {
            x0 = (px - w/2) * xside / w + midx
            
            x = 0; y = 0; iter = 0
            
            while (iter < max) {
                zx = x * x
                zy = y * y
                
                if (zx + zy > 4) break
                
                xtemp = zx - zy + x0
                y = 2 * x * y + y0
                x = xtemp
                iter++
            }
            
            # Color
            if (iter >= max) {
                print "pset " px, py, "(0 0 0)"
            } else {
                log_z = log(zx + zy) / 2
                smooth_n = iter + 1 - log(log_z) / log(2)
                hue = (smooth_n * hue_scale) % 1.0
                hsl_to_rgb(hue, saturation, lightness)
                print "pset " px, py, "(" _r, _g, _b ")"
            }
        }
        
        if (py % 10 == 0) print "flush"
    }
    print "flush"

}


function hsl_to_rgb(h, s, l,    q, p) {
	h = h - int(h)
	
	if (s == 0) {
		_r = _g = _b = int(l * 255)
		return
	}
	
	q = (l < 0.5) ? (l * (1 + s)) : (l + s - l * s)
	p = 2 * l - q
	
	_r = int(hue_helper(p, q, h + 1/3) * 255)
	_g = int(hue_helper(p, q, h) * 255)
	_b = int(hue_helper(p, q, h - 1/3) * 255)
}

function hue_helper(p, q, t) {
	if (t < 0) t += 1
	if (t > 1) t -= 1
	if (t < 1/6) return p + (q - p) * 6 * t
	if (t < 1/2) return q
	if (t < 2/3) return p + (q - p) * (2/3 - t) * 6
	return p
}

' | ./pixel_bridge --batch