gopatterns/pkg/pattern/template/renderer.go

package template

import (
	"fmt"
	"git.wtrh.nl/patterns/gopatterns/pkg/pattern"
	"git.wtrh.nl/patterns/gopatterns/pkg/pattern/text"
	"github.com/stoewer/go-strcase"
	"github.com/tdewolff/canvas"
	"github.com/tdewolff/canvas/renderers"
	"path/filepath"
	"slices"
	"strings"
)

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

	filenames := make([]string, 0, len(template.Panels))
	dim, err := s.Dimensions(request.Sizes)

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

	for name, panel := range template.Panels {
		pat := pattern.NewPattern()
		pat.SetDimensions(dim)

		err = template.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 = pat.ToCanvas(c, 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
}

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

// BuildPanel translates the panel to the provided [pattern.Pattern].
func (r Renderer) BuildPanel(panel 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, pat *pattern.Pattern) error {
	err := Points{"_information": p.Information.Point}.AddToPattern(pat)
	if err != nil {
		return err
	}

	dimensions := make([]string, 0, len(r.dimensions))
	for _, dimension := range r.dimensions {
		dimensions = append(dimensions,
			fmt.Sprintf("  %s: %.1f cm", dimension.Name, dimension.Value/10))
	}

	slices.Sort(dimensions)
	dimensions = append([]string{
		"For: " + r.owner,
		"Pattern: " + startCase(r.pattern),
		"Panel: " + p.Name,
		"Hem allowance: " + p.Allowances.Hem,
		"Seam allowance: " + p.Allowances.Seam,
		"\nMeasurements:",
	}, dimensions...)

	point := pat.GetPoint("_information")
	point.SetHide()
	pat.AddText(text.NewText(point, "", strings.Join(dimensions, "\n")))
	return nil
}