ch3/ch3-02

[giscus[bot]]

ch3/ch3-02

中文版

https://golang-china.github.io/gopl-zh/ch3/ch3-02.html

[cicospui]

纯新手，感觉练习好难啊！有没有答案什么的

[Bibooo25730]

l练个毛线哦

[xq-120]

3.4

func main() {
	http.HandleFunc("/", handler)
	err := http.ListenAndServe("localhost:8080", nil)
	log.Fatal(err)
}

func handler(w http.ResponseWriter, r *http.Request) {
	//不加Content-Type，浏览器显示的是svg文件内容，而不是解析显示为图片。
	w.Header().Set("Content-Type", "image/svg+xml")

	err := r.ParseForm()
	if err != nil {
		log.Print(err)
	}
	form := r.Form

	wd := 0
	wdQuery := form["width"]
	if len(wdQuery) > 0 { //必须判断数组是否为空，否则越界崩溃
		wdStr := wdQuery[0]
		wd, err = strconv.Atoi(wdStr)
		if err != nil {
			log.Print(err)
		}
	}

	ht := 0
	htQuery := form["height"]
	if len(htQuery) > 0 { //必须判断数组是否为空，否则越界崩溃
		htStr := htQuery[0]
		ht, err = strconv.Atoi(htStr)
		if err != nil {
			log.Print(err)
		}
	}

	stroke := ""
	strokeQuery := form["stroke"]
	if len(strokeQuery) > 0 { //必须判断数组是否为空，否则越界崩溃
		stroke = strokeQuery[0]
	}

	surface(w, wd, ht, stroke)
}

func surface(w io.Writer, wd int, ht int, stroke string) {
	if wd <= 0 {
		wd = width
	}
	if ht <= 0 {
		ht = height
	}
	if len(stroke) == 0 {
		stroke = "grey"
	}
	fmt.Fprintf(w, "<svg xmlns='http://www.w3.org/2000/svg' "+
		"style='stroke: %s; fill: white; stroke-width: 0.7' "+
		"width='%d' height='%d'>", stroke, wd, ht)
	for i := 0; i < cells; i++ {
		for j := 0; j < cells; j++ {
			ax, ay := corner(i+1, j)
			bx, by := corner(i, j)
			cx, cy := corner(i, j+1)
			dx, dy := corner(i+1, j+1)
			fmt.Fprintf(w, "<polygon points='%g,%g %g,%g %g,%g %g,%g'/>\n",
				ax, ay, bx, by, cx, cy, dx, dy)
		}
	}
	fmt.Fprintf(w, "</svg>")
}

func corner(i, j int) (float64, float64) {
	x := xyrange * (float64(i)/cells - 0.5)
	y := xyrange * (float64(j)/cells - 0.5)
	z := f(x, y)

	sx := width/2 + (x-y)*cos30*xyscale
	sy := height/2 + (x+y)*sin30*xyscale - z*zscale
	return sx, sy
}

func f(x, y float64) float64 {
	r := math.Hypot(x, y)
	return math.Sin(r) / r
}

[liudeihao]

练习3.2：
因为需要根据z值调整颜色，所以让corner函数把z值也返回。
然后根据z的大小调整颜色。

package main

import (
	"fmt"
	"math"
)

const (
	width, height = 600, 320
	cells         = 100
	xyrange       = 30.0
	xyscale       = width / 2 / xyrange
	zscale        = height * 0.4
	angle         = math.Pi / 6
)

var sin30, cos30 = math.Sin(angle), math.Cos(angle)

func main() {
	fmt.Printf("<svg xmlns='http://www.w3.org/2000/svg' "+
		"style='stroke: grey; fill: white; stroke-width: 0.7' "+
		"width='%d' height='%d'>", width, height)

	for i := 0; i < cells; i++ {
		for j := 0; j < cells; j++ {
			ax, ay, az := corner(i+1, j)
			bx, by, bz := corner(i, j)
			cx, cy, cz := corner(i, j+1)
			dx, dy, dz := corner(i+1, j+1)
			
			avgZ := (az + bz + cz + dz) / 4
			maxZ := 1.
			minZ := -1 / math.Pi
			
			relativeZ := int32(math.Round((avgZ - minZ) / (maxZ - minZ) * 255))
			color := (relativeZ << 16) | (255 - relativeZ)
			fmt.Printf("<polygon points='%g,%g %g,%g %g,%g %g,%g' fill='#%6x'/>\n",
				ax, ay, bx, by, cx, cy, dx, dy, color)
		}
	}
	fmt.Println("</svg>\n")
}

func corner(i, j int) (float64, float64, float64) {
	x := xyrange * (float64(i)/cells - 0.5)
	y := xyrange * (float64(j)/cells - 0.5)
	z := f(x, y)
	sx := width/2 + (x-y)*cos30*xyscale
	sy := height/2 + (x+y)*sin30*xyscale - z*zscale
	return sx, sy, z
}

func f(x, y float64) float64 {
	r := math.Hypot(x, y)
	return math.Sin(r) / r
}

[esheeper]

练习3.1
/*
练习 3.1： 如果f函数返回的是无限制的float64值，那么SVG文件可能输出无效的多边形元素（虽然许多SVG渲染器会妥善处理这类问题）。修改程序跳过无效的多边形。
原理：polygon中统一四个点，就是四边形，无效的四边形就是第1、2点组成的线段和第3、4点组成的线段相交
*/

// Surface computes an SVG rendering of a 3-D surface function.
package main

import (
"fmt"
"math"
"os"
)

const (
width, height = 600, 320 // canvas size in pixels
cells = 100 // number of grid cells
xyrange = 30.0 // axis ranges (-xyrange..+xyrange)
xyscale = width / 2 / xyrange // pixels per x or y unit
zscale = height * 0.4 // pixels per z unit
angle = math.Pi / 6 // angle of x, y axes (=30°)
)

var sin30, cos30 = math.Sin(angle), math.Cos(angle) // sin(30°), cos(30°)

func main() {
fp, err := os.OpenFile("output.svg", os.O_WRONLY|os.O_CREATE, 0644)
if err != nil {
fmt.Fprintln(os.Stderr, "File open failed: ", err)
return
}

fmt.Fprintf(fp, "<svg xmlns='http://www.w3.org/2000/svg' "+
	"style='stroke: grey; fill: white; stroke-width: 0.7' "+
	"width='%d' height='%d'>", width, height)
var count int
for i := 0; i < cells; i++ {
	for j := 0; j < cells; j++ {
		ax, ay := corner(i+1, j)
		bx, by := corner(i, j)
		cx, cy := corner(i, j+1)
		dx, dy := corner(i+1, j+1)
		line1 := []float64{ax, ay, bx, by}
		line2 := []float64{cx, cy, dx, dy}
		if line_intersect(line1, line2) {
			fmt.Printf("line intersect: %g,%g %g,%g %g,%g %g,%g\n",
				ax, ay, bx, by, cx, cy, dx, dy)
			count += 1
			continue
		}
		fmt.Fprintf(fp, "<polygon points='%g,%g %g,%g %g,%g %g,%g'/>\n",
			ax, ay, bx, by, cx, cy, dx, dy)
	}
}
fmt.Println("Error Line number: ", count)
fmt.Fprintln(fp, "</svg>")

}

func corner(i, j int) (float64, float64) {
// Find point (x,y) at corner of cell (i,j).
x := xyrange * (float64(i)/cells - 0.5)
y := xyrange * (float64(j)/cells - 0.5)

// Compute surface height z.
z := f(x, y)

// Project (x,y,z) isometrically onto 2-D SVG canvas (sx,sy).
sx := width/2 + (x-y)*cos30*xyscale
sy := height/2 + (x+y)*sin30*xyscale - z*zscale
return sx, sy

}

func f(x, y float64) float64 {
r := math.Hypot(x, y) // distance from (0,0)
return math.Sin(r) / r
}

func line_intersect(line1 []float64, line2 []float64) bool {
// 水平方向相交 并且 垂直方向相交
min_line1_x := line1[0]
max_line1_x := line1[2]
if min_line1_x > max_line1_x {
min_line1_x, max_line1_x = max_line1_x, min_line1_x
}

min_line2_x := line2[0]
max_line2_x := line2[2]
if min_line2_x > max_line2_x {
	min_line2_x, max_line2_x = max_line2_x, min_line2_x
}

if min_line1_x > max_line2_x || max_line1_x < min_line2_x {
	return false
}

min_line1_y := line1[1]
max_line1_y := line1[3]
if min_line1_y > max_line1_y {
	min_line1_y, max_line1_y = max_line1_y, min_line1_y
}

min_line2_y := line2[1]
max_line2_y := line2[3]
if min_line2_y > max_line2_y {
	min_line2_y, max_line2_y = max_line2_y, min_line2_y
}

if min_line1_y > max_line2_y || max_line1_y < min_line2_y {
	return false
}

return true

}

[esheeper]

/*
练习 3.4： 参考1.7节Lissajous例子的函数，构造一个web服务器，用于计算函数曲面然后返回SVG数据给客户端。
*/

// Surface computes an SVG rendering of a 3-D surface function.
package main

import (
"fmt"
"log"
"math"
"net/http"
)

type GenFunc func(float64, float64) float64

const (
width, height = 600, 320 // canvas size in pixels
cells = 100 // number of grid cells
xyrange = 30.0 // axis ranges (-xyrange..+xyrange)
xyscale = width / 2 / xyrange // pixels per x or y unit
zscale = height * 0.4 // pixels per z unit
angle = math.Pi / 6 // angle of x, y axes (=30°)
)

var sin30, cos30 = math.Sin(angle), math.Cos(angle) // sin(30°), cos(30°)

func main() {
http.HandleFunc("/svg", handle)
http.ListenAndServe("localhost:8000", nil)
log.Fatal("Finish")
}

func handle(res http.ResponseWriter, req *http.Request) {
res.Header().Set("Content-Type", "image/svg+xml")
fp := res
if err := req.ParseForm(); err != nil {
log.Print(err)
return
}
query := req.Form
var genFuncKey string = "f"
if value, ok := query["func"]; ok {
genFuncKey = value[0]
}
fmt.Println(req.Form, genFuncKey)

fmt.Fprintf(fp, "<svg xmlns='http://www.w3.org/2000/svg' "+
	"style='stroke: grey; fill: white; stroke-width: 0.7' "+
	"width='%d' height='%d'>", width, height)
var count int

for i := 0; i < cells; i++ {
	for j := 0; j < cells; j++ {
		ax, ay := corner(i+1, j, genFuncKey)
		bx, by := corner(i, j, genFuncKey)
		cx, cy := corner(i, j+1, genFuncKey)
		dx, dy := corner(i+1, j+1, genFuncKey)
		fmt.Fprintf(fp, "<polygon points='%g,%g %g,%g %g,%g %g,%g'/>\n",
			ax, ay, bx, by, cx, cy, dx, dy)
	}
}
fmt.Println("Error Line number: ", count)
fmt.Fprintln(fp, "</svg>")

}

func corner(i, j int, key string) (float64, float64) {
// Find point (x,y) at corner of cell (i,j).
x := xyrange * (float64(i)/cells - 0.5)
y := xyrange * (float64(j)/cells - 0.5)

// Compute surface height z.
var z float64
switch key {
case "eggBox":
	z = eggBox(x, y)
case "saddle":
	z = saddle(x, y)
case "moguls":
	z = moguls(x, y)
default:
	z = f(x, y)
}

// Project (x,y,z) isometrically onto 2-D SVG canvas (sx,sy).
sx := width/2 + (x-y)*cos30*xyscale
sy := height/2 + (x+y)*sin30*xyscale - z*zscale
return sx, sy

}

func f(x, y float64) float64 {
r := math.Hypot(x, y) // distance from (0,0)
return math.Sin(r) / r
}

func eggBox(x, y float64) float64 {
return (math.Sin(x) + math.Sin(y)) / 10
}

func saddle(x, y float64) float64 {
return math.Pow(y/xyrange2, 2) - math.Pow(x/xyrange2, 2)
}

func moguls(x, y float64) float64 {
return math.Pow(math.Sin(x/xyrange3math.Pi), 2) * math.Cos(y/xyrange3math.Pi)
}

[hongjiala]

3.3
package main

import (
"fmt"
"math"
)

const (
width, height = 600, 320 // canvas size in pixels
cells = 100 // number of grid cells
xyrange = 30.0 // axis ranges (-xyrange..+xyrange)
xyscale = width / 2 / xyrange // pixels per x or y unit
zscale = height * 0.4 // pixels per z unit
angle = math.Pi / 6 // angle of x, y axes (=30°)
)

var sin30, cos30 = math.Sin(angle), math.Cos(angle) // sin(30°), cos(30°)

func main() {
// 预计算所有顶点的z值
zValues := make([][]float64, cells+1)
for i := 0; i <= cells; i++ {
zValues[i] = make([]float64, cells+1)
for j := 0; j <= cells; j++ {
x := xyrange * (float64(i)/cells - 0.5)
y := xyrange * (float64(j)/cells - 0.5)
zValues[i][j] = saddle(x, y)
}
}

// 找到最大和最小z值
maxZ := math.Inf(-1)
minZ := math.Inf(1)
for _, row := range zValues {
	for _, z := range row {
		if z > maxZ {
			maxZ = z
		}
		if z < minZ {
			minZ = z
		}
	}
}

fmt.Printf("<svg xmlns='http://www.w3.org/2000/svg' "+
	"style='stroke: grey; fill: white; stroke-width: 0.7' "+
	"width='%d' height='%d'>", width, height)
for i := 0; i < cells; i++ {
	for j := 0; j < cells; j++ {
		ax, ay := corner(i+1, j, zValues)
		bx, by := corner(i, j, zValues)
		cx, cy := corner(i, j+1, zValues)
		dx, dy := corner(i+1, j+1, zValues)

		// 计算平均z值
		z1 := zValues[i+1][j]
		z2 := zValues[i][j]
		z3 := zValues[i][j+1]
		z4 := zValues[i+1][j+1]
		avgZ := (z1 + z2 + z3 + z4) / 4

		// 获取颜色
		color := getColor(avgZ, minZ, maxZ)

		fmt.Printf("<polygon fill='%s' points='%g,%g %g,%g %g,%g %g,%g'/>\n",
			color, ax, ay, bx, by, cx, cy, dx, dy)
	}
}
fmt.Println("</svg>")

}

func corner(i, j int, zValues [][]float64) (float64, float64) {
x := xyrange * (float64(i)/cells - 0.5)
y := xyrange * (float64(j)/cells - 0.5)
z := zValues[i][j]

// Project (x,y,z) isometrically onto 2-D SVG canvas (sx,sy)
sx := width/2 + (x-y)*cos30*xyscale
sy := height/2 + (x+y)*sin30*xyscale - z*zscale
return sx, sy

}

func f(x, y float64) float64 {
r := math.Hypot(x, y) // distance from (0,0)
if math.IsInf(math.Sin(r)/r, 0) || math.IsNaN(math.Sin(r)/r) {
return 0
}
return math.Sin(r) / r
}

func getColor(z, minZ, maxZ float64) string {
if maxZ == minZ {
return "#ff0000" // 所有点颜色相同
}
t := (z - minZ) / (maxZ - minZ)
t = math.Max(0, math.Min(1, t)) // 确保t在0到1之间
red := int(255 * t)
blue := int(255 * (1 - t))
return fmt.Sprintf("#%02x00%02x", red, blue)
}

// 鸡蛋盒函数 (Eggbox)
func eggbox(x, y float64) float64 {
return 0.2 * (math.Sin(x) * math.Sin(y))
}

// 雪坡函数 (Moguls)
func moguls(x, y float64) float64 {
return 0.1 * (math.Sin(2x) + math.Sin(2y))
}

// 马鞍面 (Saddle)
func saddle(x, y float64) float64 {
return 0.03 * (xx - yy)
}

[hongjiala]

3.4
package main

import (
"fmt"
"io"
"log"
"math"
"math/rand"
"net/http"
"os"
"time"
)

func main() {
rand.Seed(time.Now().UTC().UnixNano())
if len(os.Args) > 1 && os.Args[1] == "web" {
http.HandleFunc("/", handler) // 处理根路径
log.Fatal(http.ListenAndServe("localhost:8080", nil))
return
}
// 直接输出到标准输出
svgplot(os.Stdout)
}

func handler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "image/svg+xml") // 设置内容类型
svgplot(w)
}

const (
width, height = 600, 320 // canvas size in pixels
cells = 100 // number of grid cells
xyrange = 30.0 // axis ranges (-xyrange..+xyrange)
xyscale = width / 2 / xyrange // pixels per x or y unit
zscale = height * 0.4 // pixels per z unit
angle = math.Pi / 6 // angle of x, y axes (=30°)
)

var sin30, cos30 = math.Sin(angle), math.Cos(angle) // sin(30°), cos(30°)

func svgplot(w io.Writer) {
// 预计算所有顶点的z值
zValues := make([][]float64, cells+1)
for i := 0; i <= cells; i++ {
zValues[i] = make([]float64, cells+1)
for j := 0; j <= cells; j++ {
x := xyrange * (float64(i)/cells - 0.5)
y := xyrange * (float64(j)/cells - 0.5)
zValues[i][j] = f(x, y)
}
}

// 找到最大和最小z值
maxZ := math.Inf(-1)
minZ := math.Inf(1)
for _, row := range zValues {
	for _, z := range row {
		if z > maxZ {
			maxZ = z
		}
		if z < minZ {
			minZ = z
		}
	}
}

fmt.Fprintf(w, `<svg xmlns="http://www.w3.org/2000/svg" 
style="stroke: grey; fill: white; stroke-width: 0.7" 
width="%d" height="%d">`, width, height)
for i := 0; i < cells; i++ {
	for j := 0; j < cells; j++ {
		ax, ay := corner(i+1, j, zValues)
		bx, by := corner(i, j, zValues)
		cx, cy := corner(i, j+1, zValues)
		dx, dy := corner(i+1, j+1, zValues)

		// 计算平均z值
		z1 := zValues[i+1][j]
		z2 := zValues[i][j]
		z3 := zValues[i][j+1]
		z4 := zValues[i+1][j+1]
		avgZ := (z1 + z2 + z3 + z4) / 4

		// 获取颜色
		color := getColor(avgZ, minZ, maxZ)

		fmt.Fprintf(w, "<polygon fill='%s' points='%g,%g %g,%g %g,%g %g,%g'/>\n",
			color, ax, ay, bx, by, cx, cy, dx, dy)
	}
}
fmt.Fprintf(w, "</svg>")

}

func corner(i, j int, zValues [][]float64) (float64, float64) {
x := xyrange * (float64(i)/cells - 0.5)
y := xyrange * (float64(j)/cells - 0.5)
z := zValues[i][j]

// Project (x,y,z) isometrically onto 2-D SVG canvas (sx,sy)
sx := width/2 + (x-y)*cos30*xyscale
sy := height/2 + (x+y)*sin30*xyscale - z*zscale
return sx, sy

}

func f(x, y float64) float64 {
r := math.Hypot(x, y) // distance from (0,0)
if math.IsInf(math.Sin(r)/r, 0) || math.IsNaN(math.Sin(r)/r) {
return 0
}
return math.Sin(r) / r
}

func getColor(z, minZ, maxZ float64) string {
if maxZ == minZ {
return "#ff0000" // 所有点颜色相同
}
t := (z - minZ) / (maxZ - minZ)
t = math.Max(0, math.Min(1, t)) // 确保t在0到1之间
red := int(255 * t)
blue := int(255 * (1 - t))
return fmt.Sprintf("#%02x00%02x", red, blue)
}

// 鸡蛋盒函数 (Eggbox)
func eggbox(x, y float64) float64 {
return 0.2 * (math.Sin(x) * math.Sin(y))
}

// 雪坡函数 (Moguls)
func moguls(x, y float64) float64 {
return 0.1 * (math.Sin(2x) + math.Sin(2y))
}

// 马鞍面 (Saddle)
func saddle(x, y float64) float64 {
return 0.03 * (xx - yy)
}

[celiachu]

练习3.1

bool 表示该点是否合法。如果 z 是 NaN 或 Inf，就跳过这个点。

func corner(i, j int) (float64, float64, bool) {
    // Find point (x,y) at corner of cell (i,j).
    x := xyrange * (float64(i)/cells - 0.5)
    y := xyrange * (float64(j)/cells - 0.5)

    // Compute surface height z.
    z := f(x, y)

		// 检查 z 是否为合法数字
	if math.IsInf(z, 0) || math.IsNaN(z) {
		return 0, 0, false
	}

    // Project (x,y,z) isometrically onto 2-D SVG canvas (sx,sy).
    sx := width/2 + (x-y)*cos30*xyscale
    sy := height/2 + (x+y)*sin30*xyscale - z*zscale
    return sx, sy, true
}

[celiachu]

练习3.2

// egg box
func fEggBox(x, y float64) float64 {
	return math.Sin(x) * math.Sin(y)
}

func fMoguls(x, y float64) float64 {
	return math.Cos(x) + math.Cos(y)
}

func fSaddle(x, y float64) float64 {
	return (x*x - y*y) / 40
}

[celiachu]

练习3.3

上色

Fill 属性
fill：定义图形的填充颜色。与 stroke 属性类似，可以使用颜色名称、RGB 值、十六进制颜色代码等格式。

<rect x="10" y="10" width="50" height="50" fill="#ff0000" />

预计算全局极值

在生成图形前，先遍历所有格点计算 z 值，更新全局最小（minZ）和最大（maxZ）值，这样后续对颜色映射时能够正确归一化 z 值。最后算出来的浮点数取两位拼接到字符串当中去

package main

import (
	"fmt"
	"math"
)

const (
	width, height = 600, 320            // 画布尺寸（像素）
	cells         = 100                 // 网格单元数
	xyrange       = 30.0                // 轴范围（-xyrange..+xyrange）
	xyscale       = width / 2 / xyrange // 每个 x 或 y 单位对应的像素数
	zscale        = height * 0.4        // 每个 z 单位对应的像素数
	angle         = math.Pi / 6         // x, y 轴的角度（30°）
)

var sin30, cos30 = math.Sin(angle), math.Cos(angle) // sin(30°) 与 cos(30°)
var minZ, maxZ float64 = math.Inf(1), math.Inf(-1)      // 全局 z 值极值

func main() {
	// 第一遍遍历：预先计算所有角点的 z 值，更新全局 minZ 和 maxZ
	for i := 0; i <= cells; i++ {
		for j := 0; j <= cells; j++ {
			x := xyrange * (float64(i)/cells - 0.5)
			y := xyrange * (float64(j)/cells - 0.5)
			z := f(x, y)
			if math.IsInf(z, 0) || math.IsNaN(z) {
				continue
			}
			if z < minZ {
				minZ = z
			}
			if z > maxZ {
				maxZ = z
			}
		}
	}

	// 输出 SVG 文件头
	fmt.Printf("<svg xmlns='http://www.w3.org/2000/svg' "+
		"style='stroke: grey; fill: white; stroke-width: 0.7' "+
		"width='%d' height='%d'>\n", width, height)
	// 第二遍遍历：绘制每个单元格对应的多边形
	for i := 0; i < cells; i++ {
		for j := 0; j < cells; j++ {
			ax, ay, az, ok1 := corner(i+1, j)
			bx, by, bz, ok2 := corner(i, j)
			cx, cy, cz, ok3 := corner(i, j+1)
			dx, dy, dz, ok4 := corner(i+1, j+1)
			if ok1 && ok2 && ok3 && ok4 {
				avgZ := (az + bz + cz + dz) / 4
				color := colorForZ(avgZ)
				fmt.Printf("<polygon points='%g,%g %g,%g %g,%g %g,%g' fill='%s'/>\n",
					ax, ay, bx, by, cx, cy, dx, dy, color)
			}
		}
	}
	fmt.Println("</svg>")
}

// 根据 z 值生成颜色（归一化后，z 越高颜色越红，越低则越蓝）
func colorForZ(z float64) string {
	norm := (z - minZ) / (maxZ - minZ)
	r := int(255 * norm)
	b := int(255 * (1 - norm))
	return fmt.Sprintf("#%02x00%02x", r, b)
}

// 计算格点 (i,j) 对应的 2D 投影坐标及其高度 z
func corner(i, j int) (float64, float64, float64, bool) {
	x := xyrange * (float64(i)/cells - 0.5)
	y := xyrange * (float64(j)/cells - 0.5)
	z := f(x, y)
	if math.IsInf(z, 0) || math.IsNaN(z) {
		return 0, 0, 0, false
	}
	sx := width/2 + (x-y)*cos30*xyscale
	sy := height/2 + (x+y)*sin30*xyscale - z*zscale
	return sx, sy, z, true
}


func f(x, y float64) float64 {
	r := math.Hypot(x, y)
	return math.Sin(r) / r
}

[celiachu]

练习3.4

主要修改点 在于 http.ResponseWriter
用于向客户端写入响应数据（比如 HTML、JSON、SVG 等）。
相应的将surface当中的打印换成

fmt.Fprintf(w, ...)

把内容“格式化”并写到 io.Writer（比如 HTTP 响应）。

类似于 printf，但目标是写入到 w 而不是终端。

package main

import (
	"fmt"
	"io"
	"math"
	"net/http"
)

func main() {
	printURL("http://localhost:8080/svg") // 打印访问地址
	http.HandleFunc("/svg", handler)
	http.ListenAndServe(":8080", nil)
	
}
func printURL(url string) {
	fmt.Println("服务已启动，访问以下地址查看 SVG 图像：")
	fmt.Println(url)
}

func handler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "image/svg+xml")
	Surface(w)
}

const (
	width, height = 600, 320
	cells         = 100
	xyrange       = 30.0
	xyscale       = width / 2 / xyrange
	zscale        = height * 0.4
	angle         = math.Pi / 6
)

var sin30, cos30 = math.Sin(angle), math.Cos(angle)
var minZ, maxZ float64 = math.Inf(1), math.Inf(-1)

func Surface(w io.Writer) {
	for i := 0; i <= cells; i++ {
		for j := 0; j <= cells; j++ {
			x := xyrange * (float64(i)/cells - 0.5)
			y := xyrange * (float64(j)/cells - 0.5)
			z := f(x, y)
			if math.IsInf(z, 0) || math.IsNaN(z) {
				continue
			}
			if z < minZ {
				minZ = z
			}
			if z > maxZ {
				maxZ = z
			}
		}
	}

	fmt.Fprintf(w, "<svg xmlns='http://www.w3.org/2000/svg' "+
		"style='stroke: grey; fill: white; stroke-width: 0.7' "+
		"width='%d' height='%d'>\n", width, height)

	for i := 0; i < cells; i++ {
		for j := 0; j < cells; j++ {
			ax, ay, az, ok1 := corner(i+1, j)
			bx, by, bz, ok2 := corner(i, j)
			cx, cy, cz, ok3 := corner(i, j+1)
			dx, dy, dz, ok4 := corner(i+1, j+1)
			if ok1 && ok2 && ok3 && ok4 {
				avgZ := (az + bz + cz + dz) / 4
				color := colorForZ(avgZ)
				fmt.Fprintf(w, "<polygon points='%g,%g %g,%g %g,%g %g,%g' fill='%s'/>\n",
					ax, ay, bx, by, cx, cy, dx, dy, color)
			}
		}
	}
	fmt.Fprintln(w, "</svg>")
}

func colorForZ(z float64) string {
	norm := (z - minZ) / (maxZ - minZ)
	r := int(255 * norm)
	b := int(255 * (1 - norm))
	return fmt.Sprintf("#%02x00%02x", r, b)
}

func corner(i, j int) (float64, float64, float64, bool) {
	x := xyrange * (float64(i)/cells - 0.5)
	y := xyrange * (float64(j)/cells - 0.5)
	z := f(x, y)
	if math.IsInf(z, 0) || math.IsNaN(z) {
		return 0, 0, 0, false
	}
	sx := width/2 + (x-y)*cos30*xyscale
	sy := height/2 + (x+y)*sin30*xyscale - z*zscale
	return sx, sy, z, true
}

func f(x, y float64) float64 {
	r := math.Hypot(x, y)
	return math.Sin(r) / r
}