gopatterns/pkg/renderer/renderer.go

package renderer

import (
	"fmt"
	"path/filepath"
	"strings"
	"unicode"

	"git.wtrh.nl/patterns/gopatterns/pkg/config"
	"git.wtrh.nl/patterns/gopatterns/pkg/dimensions"
	"git.wtrh.nl/patterns/gopatterns/pkg/template"
	"github.com/stoewer/go-strcase"
	"github.com/tdewolff/canvas"
	"github.com/tdewolff/canvas/renderers"
	"golang.org/x/image/font/gofont/goregular"
)

type Storage interface {
	LoadDimensions(sizes config.Sizes) (dimensions.Dimensions, error)
	LoadTemplate(name string) (template.Template, error)
}

// RenderPatterns loads a [Request] from yaml file and renders the pattern to an SVG.
func RenderPatterns(s Storage, request config.Request, outputDir string, debug bool) ([]string, error) {
	loadedTemplate, err := s.LoadTemplate(request.Template)
	if err != nil {
		return nil, fmt.Errorf("load pattern %q: %w", request.Template, err)
	}

	filenames := make([]string, 0, len(loadedTemplate.Panels))

	dim, err := s.LoadDimensions(request.Sizes)
	if err != nil {
		return nil, fmt.Errorf("load dimensions: %w", err)
	}

	// renderer := Renderer{dimensions: dim, owner: request.Owner, pattern: request.Template}

	for name := range loadedTemplate.Panels {
		newPanel, err := loadedTemplate.GetPanel(template.Request{Dims: dim, Panel: name})
		if err != nil {
			return nil, err
		}
		//
		//pat := pattern.NewPattern()
		//pat.SetDimensions(dim)
		//
		//err = loadedTemplate.Points.AddToPattern(pat)
		//if err != nil {
		//	return nil, fmt.Errorf("add generic points to pattern: %w", err)
		//}
		//
		//err = renderer.BuildPanel(panel, pat)
		//if err != nil {
		//	return nil, fmt.Errorf("constructing %s panel: %w", name, err)
		//}

		c := canvas.New(200, 200)

		err = newPanel.Draw(c, loadFont(), debug)
		if err != nil {
			return nil, fmt.Errorf("write pattern to canvas: %w", err)
		}

		c.Fit(10)

		filename := filepath.Join(outputDir, strings.Join([]string{
			request.Template, name,
			strcase.SnakeCase(request.Owner),
		}, "_")+".pdf")

		filenames = append(filenames, filename)

		err = renderers.Write(filename, c)
		if err != nil {
			return nil, fmt.Errorf("write canvas to file: %w", err)
		}
	}

	return filenames, nil
}

func loadFont() *canvas.FontFace {
	fontDejaVu := canvas.NewFontFamily("latin")

	if err := fontDejaVu.LoadFont(goregular.TTF, 0, canvas.FontRegular); err != nil {
		panic(err)
	}

	return fontDejaVu.Face(12.0, canvas.Black, canvas.FontRegular)
}

type Renderer struct {
	dimensions dimensions.Dimensions
	owner      string
	pattern    string
}

//// BuildPanel translates the panel to the provided [pattern.Pattern].
//func (r Renderer) BuildPanel(panel template.Panel, pat *pattern.Pattern) error {
//	err := panel.Points.AddToPattern(pat)
//	if err != nil {
//		return err
//	}
//
//	err = panel.Lines.Build(pat)
//	if err != nil {
//		return err
//	}
//
//	err = r.GenerateInformation(panel, pat)
//	if err != nil {
//		return err
//	}
//
//	return nil
//}

//func (r Renderer) GenerateInformation(p panel.Panel, pat *pattern.Pattern) error {
//	err := template.Points{"_information": p.Information.Point}
//	if err != nil {
//		return err
//	}
//
//	dims := make([]string, 0, len(r.dimensions))
//	for _, dimension := range r.dimensions {
//		dims = append(dims, fmt.Sprintf("  %s: %.1f cm", dimension.Name, dimension.Value/10))
//	}
//
//	slices.Sort(dims)
//	dims = append([]string{
//		"For: " + r.owner,
//		"Pattern: " + startCase(r.pattern),
//		"Panel: " + p.Name,
//		"Hem allowance: " + p.Allowances.Hem,
//		"Seam allowance: " + p.Allowances.Seam,
//		"\nMeasurements:",
//	}, dims...)
//
//	point := pat.GetPoint("_information")
//	point.SetHide()
//	pat.AddText(text.NewText(point, "", strings.Join(dims, "\n")))
//
//	return nil
//}

func startCase(text string) string {
	output := make([]rune, len(text))

	for i, val := range text {
		switch {
		case i == 0:
			output[i] = unicode.ToUpper(val)
		case val == '_':
			output[i] = ' '
		case output[i-1] == ' ':
			output[i] = unicode.ToUpper(val)
		default:
			output[i] = val
		}
	}

	return string(output)
}