ch3/ch3-03

[giscus[bot]]

ch3/ch3-03

中文版

https://gopl-zh.github.io/ch3/ch3-03.html

[hongjiala]

3.5
package main

import (
"image"
"image/color"
"image/png"
"math/cmplx"
"os"
)

func main() {
const (
xmin, ymin, xmax, ymax = -2, -2, +2, +2
width, height = 1024, 1024
)

img := image.NewRGBA(image.Rect(0, 0, width, height))
for py := 0; py < height; py++ {
	y := float64(py)/height*(ymax-ymin) + ymin
	for px := 0; px < width; px++ {
		x := float64(px)/width*(xmax-xmin) + xmin
		z := complex(x, y)
		img.Set(px, py, mandelbrot(z))
	}
}
filenames := os.Args[1:]
if len(filenames) == 0 {
	println("Usage: go run hello.go <filename>")
	return
}

// **改进：将图片写入文件**
file, err := os.Create(string(filenames[0]))
if err != nil {
	panic(err) // 遇到错误直接报错
}
defer file.Close()

// 编码 PNG 并检查错误
err = png.Encode(file, img)
if err != nil {
	panic(err)
}

println("Mandelbrot fractal image saved as mandelbrot.png")

}

func mandelbrot(z complex128) color.Color {
const iterations = 200

var v complex128
for n := uint8(0); n < iterations; n++ {
	v = v*v + z
	if cmplx.Abs(v) > 2 {
		return color.RGBA{255 - n*8, 222 - n*4, 222 + n*2, 255}
	} else if cmplx.Abs(v) > 1 {
		return color.RGBA{255 - n*7, 222 - n*3, 222 + n*3, 255}
	}
}
return color.Black

}

[hongjiala]

3.6
package main

import (
"image"
"image/color"
"image/png"
"math/cmplx"
"os"
)

func main() {
const (
xmin, ymin, xmax, ymax = -2, -2, +2, +2
width, height = 1024, 1024
scale = 2 // 超级采样比例，每个像素 2×2 = 4 子像素
)

img := image.NewRGBA(image.Rect(0, 0, width, height))
for py := 0; py < height; py++ {
	for px := 0; px < width; px++ {
		var r, g, b, a uint32
		// 采样 2×2 子像素
		for sy := 0; sy < scale; sy++ {
			for sx := 0; sx < scale; sx++ {
				x := (float64(px)+float64(sx)/float64(scale))/float64(width)*(xmax-xmin) + xmin
				y := (float64(py)+float64(sy)/float64(scale))/float64(height)*(ymax-ymin) + ymin
				c := mandelbrot(complex(x, y))

				// 取颜色值
				cr, cg, cb, ca := c.RGBA()
				r += cr
				g += cg
				b += cb
				a += ca
			}
		}
		// 计算子像素的平均颜色
		img.Set(px, py, color.RGBA{
			uint8(r / (scale * scale) >> 8),
			uint8(g / (scale * scale) >> 8),
			uint8(b / (scale * scale) >> 8),
			uint8(a / (scale * scale) >> 8),
		})
	}
}

// 保存到文件
file, err := os.Create("mandelbrot.png")
if err != nil {
	panic(err)
}
defer file.Close()
if err := png.Encode(file, img); err != nil {
	panic(err)
}
println("Mandelbrot fractal image saved as mandelbrot.png")

}

func mandelbrot(z complex128) color.Color {
const iterations = 200

var v complex128
for n := uint8(0); n < iterations; n++ {
	v = v*v + z
	if cmplx.Abs(v) > 2 {
		return color.RGBA{255 - n*8, 222 - n*4, n * 2, 255}
	}
}
return color.Black

}

[hongjiala]

3.7
package main

import (
"image"
"image/color"
"image/png"
"math/cmplx"
"os"
)

func main() {
const (
xmin, ymin, xmax, ymax = -2, -2, 2, 2
width, height = 1024, 1024
maxIterations = 50
tolerance = 1e-6
)

roots := []complex128{
	1, -1, 1i, -1i, // 4 个复数根
}

colors := []color.RGBA{
	{255, 0, 0, 255},   // 红色
	{0, 255, 0, 255},   // 绿色
	{0, 0, 255, 255},   // 蓝色
	{255, 255, 0, 255}, // 黄色
}

img := image.NewRGBA(image.Rect(0, 0, width, height))
for py := 0; py < height; py++ {
	y := float64(py)/float64(height)*(ymax-ymin) + ymin
	for px := 0; px < width; px++ {
		x := float64(px)/float64(width)*(xmax-xmin) + xmin
		z := complex(x, y)
		rootIndex, iter := newtonFractal(z, roots, maxIterations, tolerance)

		// 根据迭代次数调整亮度
		shade := uint8(255 - iter*10)
		c := colors[rootIndex]
		img.Set(px, py, color.RGBA{c.R * shade, c.G * shade, c.B * shade, 255})
	}
}

// 保存图像
file, err := os.Create("newton_fractal.png")
if err != nil {
	panic(err)
}
defer file.Close()
if err := png.Encode(file, img); err != nil {
	panic(err)
}
println("Newton fractal image saved as newton_fractal.png")

}

func newtonFractal(z complex128, roots []complex128, maxIter int, tol float64) (int, int) {
for i := 0; i < maxIter; i++ {
z -= (zzz*z - 1) / (4 * z * z * z) // Newton's method for z^4 - 1 = 0
for idx, root := range roots {
if cmplx.Abs(z-root) < tol {
return idx, i
}
}
}
return 0, maxIter // 默认返回第一个根，迭代达到上限
}

[hongjiala]

3.9package main

import (
"image"
"image/color"
"image/png"
"io"
"log"
"math"
"math/cmplx"
"net/http"
"os"
"strconv"
)

var (
x float64 = 0
y float64 = 0
zoom float64 = 1
width int = 1024
height int = 1024
)

func main() {
if len(os.Args) > 3 {
// 解析命令行参数
var err error
x, err = strconv.ParseFloat(os.Args[1], 64)
if err != nil {
log.Fatalf("Invalid x value: %v", err)
}
y, err = strconv.ParseFloat(os.Args[2], 64)
if err != nil {
log.Fatalf("Invalid y value: %v", err)
}
zoom, err = strconv.ParseFloat(os.Args[3], 64)
if err != nil {
log.Fatalf("Invalid zoom value: %v", err)
}

	http.HandleFunc("/", handler)
	log.Fatal(http.ListenAndServe(":8080", nil))
	return
}

// 直接输出图片到标准输出
pngplot(os.Stdout, x, y, zoom)

}

func handler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "image/png")
pngplot(w, x, y, zoom)
}

func pngplot(w io.Writer, cx, cy, zoom float64) {
const scaleFactor = 2.0 // 缩放因子
xmin, xmax := cx-scaleFactor/zoom, cx+scaleFactor/zoom
ymin, ymax := cy-scaleFactor/zoom, cy+scaleFactor/zoom

img := image.NewRGBA(image.Rect(0, 0, width, height))
for py := 0; py < height; py++ {
	y := ymin + (float64(py)/float64(height))*(ymax-ymin)
	for px := 0; px < width; px++ {
		x := xmin + (float64(px)/float64(width))*(xmax-xmin)
		z := complex(x, y)
		img.Set(px, py, mandelbrot(z))
	}
}
png.Encode(w, img)

}

func mandelbrot(z complex128) color.Color {
const iterations = 200
const escapeRadius = 2.0

var v complex128
for n := uint8(0); n < iterations; n++ {
	v = v*v + z
	if cmplx.Abs(v) > escapeRadius {
		t := float64(n) / float64(iterations)
		r := uint8(255 * math.Pow(t, 0.3))
		g := uint8(200 * math.Pow(t, 0.5))
		b := uint8(150 * math.Pow(t, 0.8))
		return color.RGBA{r * 255, g * 255, b * 255, 255}
	}
}
return color.Black

}

[celiachu]

3.5

package main

import (
	"image"
	"image/color"
	"image/png"
	"math/cmplx"
	"os"
)

func mandelbrot(c complex128, maxIter int) int {
	z := complex(0, 0)
	for n := 0; n < maxIter; n++ {
		if cmplx.Abs(z) > 2 {
			return n
		}
		z = z*z + c
	}
	return maxIter
}

func getColor(iter, maxIter int) color.Color {
	if iter == maxIter {
		return color.Black
	}

	r := uint8(255 - iter*7%255)
	g := uint8(iter * 9 % 255)
	b := uint8(255 - iter*5%255)
	return color.RGBA{R: r, G: g, B: b, A: 255}
}

func main() {
	const (
		width, height = 1024, 1024
		xmin, ymin    = -2.8, -2.8
		xmax, ymax    = 2.0, 2.0
		maxIter       = 200
	)
	img := image.NewRGBA(image.Rect(0, 0, width, height))

	for py := 0; py < height; py++ {
		y := float64(py)/height*(ymax-ymin) + ymin
		for px := 0; px < width; px++ {
			x := float64(px)/width*(xmax-xmin) + xmin
			c := complex(x, y)
			iter := mandelbrot(c, maxIter)
			col := getColor(iter, maxIter)
			img.Set(px, py, col)
		}
	}
	file, err := os.Create("mandelbrot.png")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	png.Encode(file, img)
}