add lib

zhangmeng

2019-11-21 b084893de86cf4f15e37f49836e49fe25f19034e

add lib

 godraw.go

New file
@@ -0,0 +1,123 @@
package godraw

import (
    "bufio"
    "bytes"
    "errors"
    "image"
    "image/color"
    "image/jpeg"

    "github.com/llgcode/draw2d/draw2dimg"
)

// ToImage bgr -> image.Image
func ToImage(data []byte, w, h int) (image.Image, error) {
    width := w
    height := h
    step := w * 3
    channels := 3

    img := image.NewRGBA(image.Rect(0, 0, width, height))
    c := color.RGBA{
        R: uint8(0),
        G: uint8(0),
        B: uint8(0),
        A: uint8(255),
    }

    for y := 0; y < height; y++ {
        for x := 0; x < step; x = x + channels {
            c.B = uint8(data[y*step+x])
            c.G = uint8(data[y*step+x+1])
            c.R = uint8(data[y*step+x+2])
            if channels == 4 {
                c.A = uint8(data[y*step+x+3])
            }
            img.SetRGBA(int(x/channels), y, c)
        }
    }

    return img, nil
}

// Image2BGR img->bgr
func Image2BGR(img image.Image) []byte {
    bounds := img.Bounds()
    x := bounds.Dx()
    y := bounds.Dy()
    data := make([]byte, 0, x*y*3)
    for j := bounds.Min.Y; j < bounds.Max.Y; j++ {
        for i := bounds.Min.X; i < bounds.Max.X; i++ {
            r, g, b, _ := img.At(i, j).RGBA()
            data = append(data, byte(b>>8), byte(g>>8), byte(r>>8))
        }
    }
    return data
}

// DrawRectangle draw rect
func DrawRectangle(img image.Image, rc image.Rectangle, clr color.RGBA, lw float64) error {

    l, t, r, b := rc.Min.X, rc.Min.Y, rc.Max.X, rc.Max.Y

    pt := []image.Point{
        image.Pt(l, t),
        image.Pt(l, r),
        image.Pt(r, b),
        image.Pt(r, l),
    }

    return DrawPolygon(img, pt, clr, lw)
}

// DrawPolygon draw polygon
func DrawPolygon(img image.Image, pt []image.Point, clr color.RGBA, lw float64) error {
    rgba, ok := img.(*image.RGBA)
    if !ok {
        return errors.New("IMAGE CONVERT TO RGBA ERROR")
    }

    pt = append(pt, pt[0])

    gc := draw2dimg.NewGraphicContext(rgba)
    gc.SetStrokeColor(clr)
    gc.SetLineWidth(lw)

    gc.BeginPath()
    start := pt[0]
    pt = pt[1:]
    gc.MoveTo((float64)(start.X), (float64)(start.Y))
    for _, v := range pt {
        gc.LineTo((float64)(v.X), (float64)(v.Y))
    }
    // gc.QuadCurveTo(100, 10, 10, 10)
    gc.Close()
    gc.Stroke()
    return nil
}

// ToJpeg bgr -> jpeg file
func ToJpeg(bgr []byte, w, h int, quality *int) ([]byte, error) {
    img, err := ToImage(bgr, w, h)
    if err != nil {
        return nil, err
    }
    return ImageToJpeg(img, quality)
}

// ImageToJpeg save to jpeg data
func ImageToJpeg(img image.Image, quality *int) ([]byte, error) {
    var o *jpeg.Options

    if quality != nil {
        o = &jpeg.Options{Quality: *quality}
    }
    var b bytes.Buffer
    w := bufio.NewWriter(&b)
    err := jpeg.Encode(w, img, o)
    if err != nil {
        return nil, err
    }
    return b.Bytes(), err
}