第三章

  • 整数
  • 浮点数
  • 复数
  • 布尔值
  • 字符串
  • 常量

这一章阅读体验很好,因为书上给的示例很炫酷,产生的结果是炫酷的图形,然而想要理解却挺头痛,因为需要一些基础的图形学知识,这章习题做得比较头疼,不是因为代码逻辑,而是因为”业务逻辑”

练习3.1

假如函数f返回一个float64型的无穷大值,就会导致SVG文件含有无效的元素.修改本程序以避免无效多边形

  • 我的想法是将无穷大和math.MaxFloat64进行比较,比它还大就替换为最大值

    1
    2
    3
    4
    5
    6
    7
    func TestMax(t *testing.T) {
    var z float64
    if 1/z > math.MaxFloat64{
    fmt.Println(math.MaxFloat64)
    }
    }

练习3.2

用math包的其他函数试验可视化效果.你是否能生成各种曲面,分别呈鸡蛋盒状、雪坡状或马鞍状

  • 没有完全搞明白,三维映射到二维的过程,不过整个代码的逻辑还是很清晰的,这一题略过
练习3.3

按高度给每个多边形上色,使得封顶呈红色(#ff0000),谷底呈蓝色(#0000ff)

  • 思路是得到最大值最小值,将中间部分分为256个部分,然后每个z值都能映射到一个颜色,想着可以平滑过渡,然而效果却很糟糕😰
  • svg的polygon显示颜色,只要在每个polygon上面添加fill属性就可以了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
package main
import (
"math"
"fmt"
)
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)
min, max := getMinMax()
for i := 0; i < cells; i++ {
for j := 0; j < cells; j++ {
ax, ay, r, g, b := corner(i+1, j, min, max)
bx, by, r, g, b := corner(i, j, min, max)
cx, cy, r, g, b := corner(i, j+1, min, max)
dx, dy, r, g, b := corner(i+1, j+1, min, max)
fmt.Printf("<polygon points='%g,%g %g,%g %g,%g %g,%g' fill='#%x%x%x'/>\n",
ax, ay, bx, by, cx, cy, dx, dy, r, g, b)
}
}
fmt.Println("</svg>")
}
func getColor(min, max, current float64) (int, int, int) {
step := (max - min) / 255
v := int((current - min) / step)
r := v
g := 0
b := 255 - v
return r, g, b
}
func getMinMax() (float64, float64) {
var min, max float64
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 z < min {
min = z
}
if z > max {
max = z
}
}
}
return min, max
}
func corner(i, j int, min, max float64) (float64, float64, int, int, int) {
x := xyrange * (float64(i)/cells - 0.5)
y := xyrange * (float64(j)/cells - 0.5)
z := f(x, y)
// 将(x,y,z)等角投射到二维SVG绘图平面上,坐标是(sx,sy)
sx := width/2 + (x-y)*cos30*xyscale
sy := height/2 + (x+y)*sin30*xyscale - z*zscale
r, g, b := getColor(min, max, z)
return sx, sy, r, g, b
}
func f(x float64, y float64) float64 {
r := math.Hypot(x, y)
return math.Sin(r) / r
}

练习3.4

仿照1.7节的示例Lissajous的方法,构建一个web服务器,计算并生成曲面,同时将svg数据写入客户端.服务器必须如下设置Content-Type报头 w.Header().set("Content-Type","image/svg+xml")

  • 这个问题比较简单,体现了Go的接口思维,将main改成函数,传入io.Writer接口,将fmt.Printf改为fmt.Fprintf就可以了,最后web请求加Header让浏览器识别svg
1
2
3
4
5
6
7
8
9
func main() {
handler := func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "image/svg+xml")
image(w)
}
http.HandleFunc("/", handler)
log.Fatal(http.ListenAndServe("localhost:8877", nil))
return
}

练习3.5

用image.NewRGBA函数和color.RGBA类型或color.YCbCr类型实现一个Mandelbrot集的全彩图

  • 又是一个图形学,一维变量最简单的方式是R=G=B,最后出来一个平滑变化的灰度图。作者要求变成全彩图(喂!大哥,我是来学Golang的,不是来搞图形学的),我也不知道这需要什么图形学知识😕,不过看到有人给出了这样一个看起来很简单也符合题目要求的变化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
func mandelbrot(z complex128) color.Color {
const iterations = 200
const contrast = 15
var v complex128
for n := uint8(0); n < iterations; n++ {
v = v*v + z
if cmplx.Abs(v) > 2 {
v := 255 - contrast*n
return color.YCbCr{v, 255 - v, 255}
}
}
return color.Black
}

练习3.6:

超采样通过对几个临近像素颜色取样并取均值,是一种减少锯齿化的方法.最简单的做法是将每个像素分为4个”子像素”.给出实现方式

  • 暂时略过

练习3.7:

另一种简单的分形是运用牛顿法求某个函数的复数解,比如z的四次方-1 = 0.以平面上各点作为牛顿法的起始,根据逼近其中一个根(共有四个根)所需的迭代次数对该点设定灰度.再根据求得的根对每个点进行全彩上色

  • 暂时略过

练习3.8:

生成高度放大的分形需要极高的数学精度.分别用以下四种类型(complex64,complex128,big.Float,big.Rat)表示数据实现同一个分形(后面两种类型由math/big包给出.big.Float类型随意选用float32/float64浮点数,但精度有限;big.Rat类型使用无限精度的有理数.)它们在计算性能和内存消耗上相比如何?放大到什么程度,渲染的失真变得可见

  • 暂时略过

练习3.9:

编写一个web服务器,它生成分形并将图像写入客户端.要让客户端得以通过HTTP请求的参数指定x,y值和放大系数

  • 终于有一题能做的了😭,读取查询参数,修改函数输出传入参数io.Writer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package main
import (
"image"
"image/png"
"math/cmplx"
"image/color"
"net/http"
"io"
"log"
"strconv"
)
func main() {
handler := func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "image/x-png")
xv := r.URL.Query().Get("x")
x, err := strconv.Atoi(xv)
if err != nil {
x = 2
}
yv := r.URL.Query().Get("y")
y, err := strconv.Atoi(yv)
if err != nil {
y = 2
}
generate(x, y, w)
}
http.HandleFunc("/", handler)
log.Fatal(http.ListenAndServe("localhost:8877", nil))
return
}
func generate(_x, _y int, w io.Writer) {
var xmin, ymin, xmax, ymax float64 = float64(-1*_x), float64(-1*_x), float64(_y), float64(_y)
const (
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))
}
}
png.Encode(w, img)
}
func mandelbrot(z complex128) color.Color {
const iterations = 200
const contrast = 15
var v complex128
for n := uint8(0); n < iterations; n++ {
v = v*v + z
if cmplx.Abs(v) > 2 {
v := 255 - contrast*n
return color.YCbCr{v, 255 - v, 255}
}
}
return color.Black
}

练习3.10:

编写一个非递归的comma函数,运用bytes.Buffer,而不是简单的字符串拼接

  • 得到字符串长度,先对三取余,然后每三位循环一次,最后一个循环特殊处理
  • 使用bytes.Buffer.String得到结果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main
import (
"bytes"
"fmt"
)
func comma(s string) {
var r bytes.Buffer
l := len(s)
mod := l % 3
if mod > 0 {
r.Write([]byte(s[:mod] + ","))
}
for mod+3 < l {
r.Write([]byte(s[mod:mod+3] + ","))
mod += 3
}
if mod+3 == l {
r.Write([]byte(s[mod:mod+3]))
}
fmt.Println(r.String())
}
func main() {
comma("12345")
}

练习3.11

完善comma函数,以支持浮点数处理和一个可选的正负号的处理

  • 先处理(剔除)前置符号,在处理后置浮点数,最后stings.Join连接起来
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package main
import (
"bytes"
"fmt"
"strings"
)
func comma(s string) {
var r bytes.Buffer
start := ""
if strings.HasPrefix(s, "-") || strings.HasPrefix(s, "+") {
start = string(s[0])
s = s[1:]
}
end := ""
if strings.Contains(s, ".") {
ss := strings.Split(s, ".")
s, end = ss[0], "."+ss[1]
}
l := len(s)
mod := l % 3
if mod > 0 {
r.Write([]byte(s[:mod] + ","))
}
for mod+3 < l {
r.Write([]byte(s[mod:mod+3] + ","))
mod += 3
}
if mod+3 == l {
r.Write([]byte(s[mod:mod+3]))
}
fmt.Println(strings.Join([]string{start, r.String(), end}, ""))
}
func main() {
comma("12345")
comma("12345.1")
comma("-12345.1")
}

练习3.12

编写一个函数,判断两个字符串是否是相互打乱的,也就是说它们有着相同的字符,但是对应不同的顺序

  • 遍历字符串A,对比字符在两个字符串的个数是否相等
  • 字符串遍历有坑,得到的是数字,需要string转换一下类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main
import (
"fmt"
"strings"
)
func same(s1, s2 string) bool {
if len(s1) != len(s2) {
return false
}
for _, v := range s1 {
if strings.Count(s1, string(v)) != strings.Count(s2, string(v)) {
return false
}
}
return true
}
func main() {
fmt.Println(same("123", "122"))
fmt.Println(same("123", "3321"))
fmt.Println(same("123", "321"))
}

练习3.13

编写KB、MB的常量声明,然后扩展到YB

  • iota

暂略