feature: heatmap

Author: johnfercher

cmd/heatmap/main.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"github.com/johnfercher/maroto/v2"
+	"github.com/johnfercher/maroto/v2/pkg/components/chart"
+	"github.com/johnfercher/maroto/v2/pkg/components/text"
+	"github.com/johnfercher/maroto/v2/pkg/config"
+	"log"
+	"math/rand"
+)
+
+func main() {
+	cfg := config.NewBuilder().
+		WithPageNumber().
+		WithDebug(true).
+		Build()
+
+	mrt := maroto.New(cfg)
+	m := maroto.NewMetricsDecorator(mrt)
+
+	xMax := 10
+	yMax := 10
+	max := 10
+	heat := buildHeat(xMax, yMax, max)
+
+	m.AddRows(text.NewRow(10, "HeatMap"))
+	m.AddRows(chart.NewHeatMapRow(100, "map", heat, max))
+
+	document, err := m.Generate()
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	err = document.Save("docs/assets/pdf/heatmap.pdf")
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	err = document.GetReport().Save("docs/assets/text/heatmap.txt")
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+}
+
+func buildHeat(x, y, max int) [][]int {
+	var heat [][]int
+	for i := 0; i < x; i++ {
+		var line []int
+		for j := 0; j < y; j++ {
+			line = append(line, rand.Intn(max))
+		}
+		heat = append(heat, line)
+	}
+	return heat
+}

docs/assets/pdf/heatmap.pdf

@@ -0,0 +1,3 @@
+generate -> avg: 646.00μs, executions: [646.00μs]
+add_rows -> avg: 5854.50ns, executions: [11.58μs, 0.12μs]
+file_size -> 6.47Kb

docs/assets/pdf/v2.pdf

@@ -1,5 +1,5 @@
-generate -> avg: 18.06ms, executions: [18.06ms]
-header -> avg: 356.00ns, executions: [356.00ns]
-footer -> avg: 71.00ns, executions: [71.00ns]
-add_row -> avg: 112.55ns, executions: [0.11μs, 0.15μs, 0.05μs, 0.08μs, 0.02μs, 0.02μs, 0.53μs, 0.06μs, 0.02μs, 0.07μs, 0.02μs, 0.02μs, 0.02μs, 0.06μs, 0.02μs, 0.02μs, 0.03μs, 1.41μs, 0.06μs, 0.02μs, 0.06μs, 0.02μs, 0.02μs, 0.01μs, 0.07μs, 0.02μs, 0.02μs, 0.03μs, 0.29μs, 1.74μs, 0.02μs, 0.07μs, 0.02μs, 0.02μs, 0.02μs, 0.06μs, 0.02μs, 0.02μs, 0.02μs, 0.24μs, 0.05μs, 0.02μs, 0.07μs, 0.02μs, 0.01μs, 0.02μs, 0.06μs, 0.03μs, 0.01μs, 0.01μs, 0.24μs, 0.05μs, 0.01μs, 0.05μs, 0.02μs]
-file_size -> 267.93Kb
+generate -> avg: 26.67ms, executions: [26.67ms]
+header -> avg: 21.00μs, executions: [21.00μs]
+footer -> avg: 333.00ns, executions: [333.00ns]
+add_rows -> avg: 157.56ns, executions: [0.29μs, 0.50μs, 0.29μs, 0.50μs, 0.08μs, 0.12μs, 1.21μs, 0.17μs, 0.04μs, 0.08μs, 0.04μs, 0.04μs, 0.04μs, 0.21μs, 0.04μs, 0.04μs, 0.04μs, 0.67μs, 0.17μs, 0.04μs, 0.12μs, 0.04μs, 0.04μs, 0.04μs, 0.17μs, 0.04μs, 0.04μs, 0.04μs, 0.50μs, 0.12μs, 0.04μs, 0.12μs, 0.04μs, 0.21μs, 0.04μs, 0.12μs, 0.04μs, 0.04μs, 0.08μs, 0.50μs, 0.17μs, 0.04μs, 0.08μs, 0.04μs, 0.04μs, 0.04μs, 0.33μs, 0.04μs, 0.04μs, 0.04μs, 0.46μs, 0.08μs, 0.04μs, 0.12μs, 0.04μs]
+file_size -> 282.23Kb

docs/assets/text/heatmap.txt

@@ -20,6 +20,7 @@ type Dependencies struct {
 	Code       core.Code
 	Image      core.Image
 	Line       core.Line
+	HeatMap    core.HeatMap
 	Cache      cache.Cache
 	CellWriter cellwriter.CellWriter
 	Cfg        *entity.Config
@@ -68,6 +69,7 @@ func (b *builder) Build(cfg *entity.Config, cache cache.Cache) *Dependencies {
 	text := NewText(fpdf, math, font)
 	image := NewImage(fpdf, math)
 	line := NewLine(fpdf)
+	heatMap := NewHeatMap(fpdf, math)
 	cellWriter := cellwriter.NewBuilder().
 		Build(fpdf)
 
@@ -78,6 +80,7 @@ func (b *builder) Build(cfg *entity.Config, cache cache.Cache) *Dependencies {
 		Code:       code,
 		Image:      image,
 		Line:       line,
+		HeatMap:    heatMap,
 		CellWriter: cellWriter,
 		Cfg:        cfg,
 		Cache:      cache,

docs/assets/text/v2.txt

@@ -0,0 +1,105 @@
+package gofpdf
+
+import (
+	"errors"
+	"fmt"
+	"github.com/johnfercher/maroto/v2/pkg/props"
+	"math"
+
+	"github.com/johnfercher/maroto/v2/internal/providers/gofpdf/gofpdfwrapper"
+	"github.com/johnfercher/maroto/v2/pkg/core"
+	"github.com/johnfercher/maroto/v2/pkg/core/entity"
+)
+
+var ErrOutOfRange = errors.New("out of range")
+
+type heatMap struct {
+	pdf              gofpdfwrapper.Fpdf
+	math             core.Math
+	defaultFillColor *props.Color
+}
+
+func NewHeatMap(pdf gofpdfwrapper.Fpdf, math core.Math) *heatMap {
+	return &heatMap{
+		pdf:              pdf,
+		math:             math,
+		defaultFillColor: &props.WhiteColor,
+	}
+}
+
+func (s heatMap) Add(heatMap [][]int, max int, cell *entity.Cell, margins *entity.Margins) {
+	if heatMap == nil {
+		return
+	}
+
+	ySize := len(heatMap)
+	if ySize == 0 {
+		return
+	}
+	stepY := (cell.Height) / float64(ySize-1)
+
+	xSize := len(heatMap[0])
+	if xSize == 0 {
+		return
+	}
+	stepX := (cell.Width) / float64(xSize-1)
+
+	for i := 0; i < len(heatMap)-1; i++ {
+		for j := 0; j < len(heatMap[i])-1; j++ {
+			r, g, b := s.GetHeatColor(heatMap[i][j], max)
+
+			x := float64(i)*stepX + cell.X + margins.Left
+			y := float64(j)*stepY + cell.Y + margins.Top
+			width := stepX
+			height := stepY
+
+			fmt.Println(x, y, width, height)
+
+			s.pdf.SetFillColor(r, g, b)
+			s.pdf.Rect(x, y, width, height, "F")
+			s.pdf.SetFillColor(s.defaultFillColor.Red, s.defaultFillColor.Green, s.defaultFillColor.Blue)
+		}
+	}
+}
+
+func (s heatMap) GetHeatColor(i int, total int) (int, int, int) {
+	hueMax := 160.0
+	step := hueMax / float64(total)
+	iStep := step * float64(i)
+
+	r, g, b, _ := HSVToRGB(iStep, 1.0, 1.0)
+	return int(r), int(g), int(b)
+}
+
+// HSVToRGB converts an HSV triple to an RGB triple.
+// Source: https://github.com/Crazy3lf/colorconv/blob/master/colorconv.go
+func HSVToRGB(h, s, v float64) (r, g, b uint8, err error) {
+	if h < 0 || h >= 360 ||
+		s < 0 || s > 1 ||
+		v < 0 || v > 1 {
+		return 0, 0, 0, ErrOutOfRange
+	}
+	// When 0 ≤ h < 360, 0 ≤ s ≤ 1 and 0 ≤ v ≤ 1:
+	C := v * s
+	X := C * (1 - math.Abs(math.Mod(h/60, 2)-1))
+	m := v - C
+	var Rnot, Gnot, Bnot float64
+	switch {
+	case 0 <= h && h < 60:
+		Rnot, Gnot, Bnot = C, X, 0
+	case 60 <= h && h < 120:
+		Rnot, Gnot, Bnot = X, C, 0
+	case 120 <= h && h < 180:
+		Rnot, Gnot, Bnot = 0, C, X
+	case 180 <= h && h < 240:
+		Rnot, Gnot, Bnot = 0, X, C
+	case 240 <= h && h < 300:
+		Rnot, Gnot, Bnot = X, 0, C
+	case 300 <= h && h < 360:
+		Rnot, Gnot, Bnot = C, 0, X
+	}
+	r = uint8(math.Round((Rnot + m) * 255))
+	g = uint8(math.Round((Gnot + m) * 255))
+	b = uint8(math.Round((Bnot + m) * 255))
+	return r, g, b, nil
+}

internal/providers/gofpdf/builder.go

@@ -26,6 +26,7 @@ type provider struct {
 	code       core.Code
 	image      core.Image
 	line       core.Line
+	heatMap    core.HeatMap
 	cache      cache.Cache
 	cellWriter cellwriter.CellWriter
 	cfg        *entity.Config
@@ -40,6 +41,7 @@ func New(dep *Dependencies) core.Provider {
 		code:       dep.Code,
 		image:      dep.Image,
 		line:       dep.Line,
+		heatMap:    dep.HeatMap,
 		cellWriter: dep.CellWriter,
 		cfg:        dep.Cfg,
 		cache:      dep.Cache,
@@ -268,6 +270,10 @@ func (g *provider) SetCompression(compression bool) {
 	g.fpdf.SetCompression(compression)
 }
 
+func (g *provider) AddHeatMap(heatMap [][]int, max int, cell *entity.Cell) {
+	g.heatMap.Add(heatMap, max, cell, g.cfg.Margins)
+}
+
 func (g *provider) getBarcodeImageName(code string, prop *props.Barcode) string {
 	if prop == nil {
 		return code + string(barcode.Code128)

internal/providers/gofpdf/heatmap.go

@@ -0,0 +1,66 @@
+package chart
+
+import (
+	"github.com/johnfercher/go-tree/node"
+	"github.com/johnfercher/maroto/v2/pkg/components/col"
+	"github.com/johnfercher/maroto/v2/pkg/components/row"
+	"github.com/johnfercher/maroto/v2/pkg/core"
+	"github.com/johnfercher/maroto/v2/pkg/core/entity"
+	"github.com/johnfercher/maroto/v2/pkg/props"
+)
+
+type HeatMap struct {
+	name   string
+	heat   [][]int
+	max    int
+	prop   props.Rect
+	config *entity.Config
+}
+
+func NewHeatMap(name string, heat [][]int, max int, ps ...props.Rect) core.Component {
+	prop := props.Rect{}
+	if len(ps) > 0 {
+		prop = ps[0]
+	}
+	prop.MakeValid()
+
+	return &HeatMap{
+		name: name,
+		prop: prop,
+		heat: heat,
+		max:  max,
+	}
+}
+
+func NewHeatMapCol(size int, name string, heat [][]int, max int, ps ...props.Rect) core.Col {
+	heatMap := NewHeatMap(name, heat, max, ps...)
+	return col.New(size).Add(heatMap)
+}
+
+func NewHeatMapRow(height float64, name string, heat [][]int, max int, ps ...props.Rect) core.Row {
+	heatMap := NewHeatMap(name, heat, max, ps...)
+	c := col.New().Add(heatMap)
+	return row.New(height).Add(c)
+}
+
+func (b *HeatMap) Render(provider core.Provider, cell *entity.Cell) {
+	provider.AddHeatMap(b.heat, b.max, cell)
+}
+
+func (b *HeatMap) GetStructure() *node.Node[core.Structure] {
+	str := core.Structure{
+		Type:    "heatmap",
+		Value:   b.name,
+		Details: b.prop.ToMap(),
+	}
+
+	return node.New(str)
+}
+
+func (b *HeatMap) GetHeight(provider core.Provider, cell *entity.Cell) float64 {
+	return float64(len(b.heat))
+}
+
+func (b *HeatMap) SetConfig(config *entity.Config) {
+	b.config = config
+}

internal/providers/gofpdf/provider.go

@@ -28,6 +28,7 @@ type Image interface {
 	GetImageInfo(img *entity.Image, extension extension.Type) (*gofpdf.ImageInfoType, uuid.UUID)
 }
 
+// Line is the abstraction which deals with lines in a PDF.
 type Line interface {
 	Add(cell *entity.Cell, prop *props.Line)
 }
@@ -52,3 +53,8 @@ type Font interface {
 	SetColor(color *props.Color)
 	GetColor() *props.Color
 }
+
+// HeatMap is the abstraction which deals with heapmap charts.
+type HeatMap interface {
+	Add(heatMap [][]int, max int, cell *entity.Cell, margins *entity.Margins)
+}