golang go中绘制文本的三种方法

Posted 2021-05-24

// Initialize an empty image
dest := image.NewRGBA(image.Rect(0, 0, 800, 300))

// Draw a white background
draw.Draw(dest, dest.Bounds(), &image.Uniform{color.White}, image.ZP, draw.Src)

// Read the font

fontBytes, err := ioutil.ReadFile(exeDir + "/DejaVuSans.ttf")
if err != nil {
  log.Fatal(err)
}
f, err := freetype.ParseFont(fontBytes)
if err != nil {
  log.Fatal(err)
}

// Variant 1 (Freetype "high-level API")

ft := freetype.NewContext()
ft.SetDst(dest)
ft.SetFont(f)
ft.SetFontSize(8)
ft.SetDPI(96)
ft.SetClip(dest.Bounds())
ft.SetSrc(image.Black)
ft.SetHinting(font.HintingNone)
ft.DrawString("some text", freetype.Pt(100, 100))

// Variant 2 (Freetype/Go font API)

opts := &truetype.Options{}
opts.DPI = 96
opts.Size = 8
opts.Hinting = font.HintingNone

d := font.Drawer{}
d.Dst = dest
d.Src = image.Black
d.Face = truetype.NewFace(f, opts)
d.Dot = freetype.Pt(100, 120)
d.DrawString("some text")

// Variant 3 (draw2d)

gc := draw2dimg.NewGraphicContext(dest)

draw2d.RegisterFont(draw2dbase.DefaultFontData, f)
gc.SetFillColor(color.Black)
gc.SetFontSize(8)
gc.SetDPI(96)
gc.FillStringAt("some text", 100, 140)

// Write PNG

fd, err := os.Create(exeDir + "/image.png")
if err != nil {
  log.Fatal(err)
}
defer fd.Close()

encoder := png.Encoder{}
encoder.CompressionLevel = png.DefaultCompression
encoder.Encode(fd, dest)

Go_18: Golang 中三种读取文件发放性能对比

　　Golang 中读取文件大概有三种方法，分别为：

　　　　1. 通过原生态 io 包中的 read 方法进行读取

　　　　2. 通过 io/ioutil 包提供的 read 方法进行读取

　　　　3. 通过 bufio 包提供的 read 方法进行读取

　　下面通过代码来验证这三种方式的读取性能，并总结出我们平时应该使用的方案，以便我们可以写出最优代码：

package main

import (
    "os"
    "io"
    "bufio"
    "io/ioutil"
    "time"
    "log"
)

func readCommon(path string) {
    file, err := os.Open(path)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    buf := make([]byte, 1024)
    for {
        readNum, err := file.Read(buf)
        if err != nil && err != io.EOF {
            panic(err)
        }
        if 0 == readNum {
            break
        }
    }
}

func readBufio(path string) {
    file, err := os.Open(path)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    bufReader := bufio.NewReader(file)
    buf := make([]byte, 1024)

    for {
        readNum, err := bufReader.Read(buf)
        if err != nil && err != io.EOF {
            panic(err)
        }
        if 0 == readNum {
            break
        }
    }
}

func readIOUtil(path string) {
    file, err := os.Open(path)
    if err != nil {
        panic(err)
    }
    defer file.Close()
    _, err = ioutil.ReadAll(file)
}

func main() {
    //size is 26MB
    pathName := "/Users/mfw/Desktop/shakespeare.json"
    start := time.Now()
    readCommon(pathName)
    timeCommon := time.Now()
    log.Printf("read common cost time %v\n", timeCommon.Sub(start))

    readBufio(pathName)
    timeBufio := time.Now()
    log.Printf("read bufio cost time %v\n", timeBufio.Sub(timeCommon))

    readIOUtil(pathName)
    timeIOUtil := time.Now()
    log.Printf("read ioutil cost time %v\n", timeIOUtil.Sub(timeBufio))
}

　　以上代码运行结果打印如下：

2017/05/11 19:23:46 read common cost time 25.584882ms
2017/05/11 19:23:46 read bufio  cost time 11.857878ms
2017/05/11 19:23:46 read ioutil cost time 35.033003ms

　　再运行一次打印的结果如下：

2017/05/11 21:59:11 read common cost time 32.374922ms
2017/05/11 21:59:11 read bufio  cost time 12.155643ms
2017/05/11 21:59:11 read ioutil cost time 27.193033ms

 　　再多运行几次，发现 readCommon 和 readIOUtil 运行时间相差不大，通过查看源代码发现 io/ioutil 包其实就是封装了 io 包中的方法，故他们两没有性能优先之说；但是不管你运行多少次，readBufio 耗费时间是他们两各自所耗费时间一半左右。

　　由此可见性能最好的是通过带有缓冲的 io 流来读取文件性能最佳。