go – Image padding not controllable

I am creating images with text on the fly. The code works as expected with one problem. I can’t seem to figure out how to control the padding. With padding I mean the distance between the text the image border on all sides.

Any ideas?

package main

import (
    "fmt"
    "image"
    "image/color"
    "image/png"
    "math"
    "os"

    "github.com/fogleman/gg"
    "github.com/jimlawless/whereami"
)

type TextImage struct {
    BgImgPath string
    FontPath  string
    FontSize  float64
    Text      string
    Alignment string
}

var latinTxt string

func main() {
    createImage(len(latinTxt))
    writeImage()
}

func writeImage() {
    ti := TextImage{
        BgImgPath: "./image.png",
        FontPath:  "./arial.ttf",
        FontSize:  24,
        Text:      latinTxt,
        Alignment: "left",
    }

    img, err := textOnImg(ti)
    if err != nil {
        fmt.Println(err.Error() + " @ " + whereami.WhereAmI())
    }

    err = saveImage(img, "./image.png")
    if err != nil {
        fmt.Println(err.Error() + " @ " + whereami.WhereAmI())
    }
}

func createImage(textlength int) {
    minDim := 300
    scale := 30
    dim := math.Sqrt(float64(textlength))
    width := int(dim) * scale
    height := int(dim) * scale

    if width < minDim || height < minDim {
        width = minDim
        height = minDim
    }

    upLeft := image.Point{0, 0}
    lowRight := image.Point{width, height}

    img := image.NewRGBA(image.Rectangle{upLeft, lowRight})
    white := color.RGBA{255, 255, 255, 0xff}

    // Set color for each pixel.
    for x := 0; x < width; x++ {
        for y := 0; y < height; y++ {
            switch {
            case x < width/2 && y < height/2: // upper left quadrant
                img.Set(x, y, white)
            case x >= width/2 && y >= height/2: // lower right quadrant
                img.Set(x, y, color.White)
            default:
                img.Set(x, y, color.White)
            }
        }
    }

    f, err := os.Create("./image.png")
    if err != nil {
        fmt.Println(err.Error() + " @ " + whereami.WhereAmI())
    }
    err = png.Encode(f, img)
    if err != nil {
        fmt.Println(err.Error() + " @ " + whereami.WhereAmI())
    }
}

func textOnImg(ti TextImage) (image.Image, error) {
    bgImage, err := gg.LoadImage(ti.BgImgPath)
    if err != nil {
        fmt.Println(err.Error() + " @ " + whereami.WhereAmI())
        return nil, err
    }
    imgWidth := bgImage.Bounds().Dx()
    imgHeight := bgImage.Bounds().Dy()

    dc := gg.NewContext(imgWidth, imgHeight)
    dc.DrawImage(bgImage, 0, 0)

    if err := dc.LoadFontFace(ti.FontPath, ti.FontSize); err != nil {
        fmt.Println(err.Error() + " @ " + whereami.WhereAmI())
        return nil, err
    }

    x := float64(imgWidth / 2)
    y := float64((imgHeight / 2) - 80)   //80.0
    maxWidth := float64(imgWidth) - 60.0 //60.0
    dc.SetColor(color.Black)
    fmt.Println(ti.Text)

    ax := 0.5          //0.5
    ay := 0.5          //0.5
    linespacing := 2.5 //1.5

    if ti.Alignment == "right" {
        dc.DrawStringWrapped(ti.Text, x, y, ax, ay, maxWidth, linespacing, gg.AlignRight)
    } else {
        dc.DrawStringWrapped(ti.Text, x, y, ax, ay, maxWidth, linespacing, gg.AlignLeft)
    }

    return dc.Image(), nil
}

func saveImage(img image.Image, path string) error {
    if err := gg.SavePNG(path, img); err != nil {
        fmt.Println(err.Error() + " @ " + whereami.WhereAmI())
        return err
    }
    return nil
}

func init() {
    latinTxt = `Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elementum erat elit, vestibulum pretium leo tincidunt vitae. Nulla ultrices blandit leo ac rutrum. Sed ac eros sit amet velit eleifend vehicula vel sit amet enim. Phasellus efficitur nibh urna, sed consectetur libero dapibus eu. In quis ullamcorper nisi, sit amet porttitor turpis. Sed aliquam ultrices nunc, ut ullamcorper ex egestas nec. Maecenas dapibus, nisl vel fermentum consectetur, augue tellus viverra lacus, vitae tempor leo ipsum in enim. Donec vitae auctor augue.

    Vivamus ut magna a lacus tincidunt egestas sed a nibh. Sed vulputate, nisl eu faucibus convallis, libero turpis sodales nibh, a laoreet dui sem non enim. Donec scelerisque, turpis ac placerat placerat, felis tortor tincidunt felis, quis malesuada ligula metus eu odio. Nam dictum metus at mauris tempor, et venenatis libero rutrum. Praesent quis felis et ex rhoncus vestibulum. Quisque non purus congue, consectetur nunc quis, tincidunt urna. Praesent et mi non tellus blandit convallis. Sed eget scelerisque magna, sed lacinia ante. Praesent quis suscipit metus, quis aliquet ex. Aenean imperdiet ultricies convallis. Curabitur nulla metus, placerat sed euismod a, commodo vitae diam. Duis a libero felis. Etiam in tincidunt ante, sed fringilla turpis. Cras vel interdum ipsum, sit amet congue tortor.
    
    Donec sollicitudin metus non est cursus tincidunt. Duis tincidunt tellus id sapien consequat, non auctor enim volutpat. Integer blandit leo eget odio facilisis rhoncus. Sed interdum vehicula urna. Suspendisse vel iaculis lorem, at consequat nunc. Nam eu massa sit amet quam tempus ultricies nec ac purus. Etiam tortor augue, porta vel risus vitae, tincidunt efficitur ex. Nam a dui ex. Morbi non magna eu mi cursus feugiat. Quisque quam nunc, rutrum et dolor maximus, ornare molestie elit.
    
    Sed a est et mi molestie mattis id eu est. Suspendisse quis luctus neque. Vestibulum sagittis eros eu nulla pulvinar, ut placerat mauris rutrum. Mauris finibus pretium erat at bibendum. Praesent et accumsan velit, sit amet ullamcorper enim. Quisque quis scelerisque felis, nec varius velit. Donec ut lectus a ipsum pharetra maximus quis sit amet purus. Donec fringilla et ipsum non pretium.
    
    Fusce convallis, nisl eget dictum semper, arcu nibh molestie nisi, vitae semper orci nulla id ante. Morbi a urna mollis, posuere turpis a, laoreet ligula. Fusce condimentum vehicula justo, imperdiet sagittis sem tristique quis. Nunc tincidunt eros in nisl vehicula malesuada. Quisque mattis neque vel ultrices molestie. Quisque finibus velit eu ante tincidunt tincidunt. Nam malesuada consequat leo, ut suscipit dui tincidunt in. Nam blandit eget est ac dictum. Nunc facilisis purus orci, ornare ultrices sem laoreet vel.
    
    Integer vel ex pulvinar tellus eleifend placerat. Aliquam erat volutpat. Praesent lobortis lacus ut fringilla volutpat. Cras ullamcorper eros id feugiat pretium. Ut auctor quam quis lobortis auctor. Donec mi orci, porta eu arcu id, faucibus porttitor tellus. Etiam sed mi ac orci consequat pellentesque eget a nibh. Etiam sollicitudin urna sed leo aliquet tristique. Pellentesque sapien magna, cursus in est sed, facilisis faucibus lectus.
    
    In finibus at risus in vehicula. In posuere lacus et mauris pulvinar hendrerit. Morbi imperdiet ante eros, ac aliquam nunc rutrum feugiat. Nullam id fringilla nibh. Nulla feugiat molestie dapibus. Proin imperdiet bibendum rhoncus. Nullam commodo ultricies luctus. Phasellus tincidunt tempor faucibus.`
}

Leave a Comment