figlet_visualizer

main.go

package main

import (
	"bufio"
	"bytes"
	"fmt"
	"image"
	"image/color"
	"image/jpeg"
	"net/http"
	"os"
	"strconv"
	"strings"

	"github.com/fogleman/gg"
	"github.com/lukesampson/figlet/figletlib"

	"golang.org/x/image/font"
	"golang.org/x/image/font/opentype"
)

func generate_image(w int, h int, chrs []string, fnt string, figfnt string, clr color.RGBA, cltx color.RGBA) *image.RGBA {

	//draw.Draw(img, img.Bounds(), &image.Uniform{clr}, image.ZP, draw.Src)

	ftf, err := os.Open(fnt)
	fmt.Println(fnt)
	if err != nil {

		fmt.Println("opening", fnt, err)
		return nil
	}
	ftfSts, _ := ftf.Stat()
	ftfb := make([]byte, ftfSts.Size())
	_, _ = ftf.Read(ftfb)
	font_, err := opentype.Parse(ftfb)
	if err != nil {
		fmt.Println("making", err)
		return nil
	}

	face, err := opentype.NewFace(font_, &opentype.FaceOptions{
		Size:    50,
		DPI:     72,
		Hinting: font.HintingNone,
	})

	if err != nil {
		fmt.Println(err)
		return nil
	}

	img := image.NewRGBA(image.Rect(0, 0, face.Metrics().Ascent.Ceil()*w, face.Metrics().Height.Floor()*h))
	dc := gg.NewContextForRGBA(img)
	dc.SetColor(clr)
	dc.Clear()
	dc.SetColor(cltx)
	fmt.Println("hh", face.Metrics().Ascent.Floor(), face.Metrics().Height.Floor())
	//dc.SetRGBA(float64(cltx.R), float64(cltx.G), float64(cltx.B), float64(cltx.A))
	fmt.Println("db", cltx.R, cltx.G, cltx.B, cltx.A)
	dc.SetFontFace(face)
	for i := 0; i < len(chrs); i++ {
		fmt.Println(i, chrs[i], float64(50.0*(i+1)))

		dc.DrawStringAnchored(chrs[i], float64(face.Metrics().Ascent.Ceil()*w)/2, float64(50.0*(i+1)), 0.5, 0.5)
	}
	dc.Fill()

	return img

}

func main() {

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		//fmt.Fprintf(w, r.FormValue("text"))

		font := r.FormValue("font")
		fontsdir := "figlet-fonts/"
		conf, err := figletlib.GetFontByName(fontsdir, font)
		if err != nil {
			fmt.Println("ERR", err)
			w.Header().Set("Content-Type", "text-plain")

		}
		fmt.Println(r.Form)

		bg := strings.Split(r.FormValue("bg"), ",")

		var bg_ color.RGBA
		if len(bg) < 2 {

			bg_ = color.RGBA{0, 0, 0, 255}
		} else {
			bgr, _ := strconv.Atoi(bg[0])
			bgg, _ := strconv.Atoi(bg[1])
			bgb, _ := strconv.Atoi(bg[2])
			bg_ = color.RGBA{uint8(bgr), uint8(bgg), uint8(bgb), 255}
		}

		fg := strings.Split(r.FormValue("fg"), ",")
		var fg_ color.RGBA
		if len(fg) < 2 {

			fg_ = color.RGBA{255, 255, 255, 255}
		} else {
			fgr, _ := strconv.Atoi(fg[0])
			fgg, _ := strconv.Atoi(bg[1])
			fgb, _ := strconv.Atoi(bg[2])
			fg_ = color.RGBA{uint8(fgr), uint8(fgg), uint8(fgb), 255}
		}

		text_ := r.FormValue("text")

		if len(text_) > 0 {
			figfont := "figlet-fonts/" + r.FormValue("font") + "."

			chr := figletlib.SprintMsg(text_, conf, 1024, conf.Settings(), "left")

			chrs := strings.Split(chr, "\n")
			img := generate_image(len(chrs[0])-strings.Count(text_, " ")-1, len(chrs), chrs, "MonospaceBold.ttf", figfont, bg_, fg_)
			if img == nil {
				fmt.Fprintf(w, "error")
			} else {
				var imgjpbuf bytes.Buffer
				imgwrt := bufio.NewWriter(&imgjpbuf)

				if err := jpeg.Encode(imgwrt, img, nil); err != nil {
					fmt.Println("Ошибка кодирования изображения в jpeg:", err)

				}
				w.Header().Set("Content-Type", "image/jpeg")
				w.Write(imgjpbuf.Bytes())
			}
		}
	})

	http.ListenAndServeTLS("librejokes.ru:8050", "/root/ultra_trash_storage/certificate.crt", "/root/ultra_trash_storage/certificate.key", nil)}
//go func(){http.ListenAndServe("librejokes.ru:8050", nil)}