fix: Avoid title and legend collisions

This checks if there is a collision between the title and legend and adjusts the legend down if necessary to avoid the collision.

Because this resulted in a lot of SVG changes (in part because of the render order), the double space (`  `) in the `path` tag was also fixed.

Author: jentfoo

alias_test.go

@@ -262,7 +262,7 @@ func TestMergeFontStyles(t *testing.T) {
 			assert.InDelta(t, tt.expected.FontSize, result.FontSize, matrix.DefaultEpsilon)
 			assert.Equal(t, tt.expected.FontColor, result.FontColor)
 
-			// Handle font comparison carefully since they're pointers
+			// Handle font comparison carefully since their pointers
 			if tt.expected.Font != nil && result.Font != nil {
 				// Both should be non-nil, check if they match expected source
 				if tt.primary.Font != nil {

axis_test.go

@@ -389,8 +389,17 @@ func (c *canvas) Path(parts []string, style Style) {
 	bb := c.bb
 	defer c.bb.Reset()
 
-	bb.WriteString(`<path `)
-	c.writeStrokeDashArray(bb, style)
+	bb.WriteString(`<path`)
+	if len(style.StrokeDashArray) > 0 {
+		bb.WriteString(" stroke-dasharray=\"")
+		for i, v := range style.StrokeDashArray {
+			if i > 0 {
+				bb.WriteString(", ")
+			}
+			_, _ = fmt.Fprintf(bb, "%0.1f", v)
+		}
+		bb.WriteString("\"")
+	}
 	bb.WriteString(` d="`)
 	for i, p := range parts {
 		if i > 0 {
@@ -419,7 +428,7 @@ func (c *canvas) Text(x, y int, body string, style Style) {
 	bb.WriteString(`" `)
 	styleAsSVG(bb, style, c.dpi, true)
 	if c.textTheta != nil {
-		fmt.Fprintf(bb, ` transform="rotate(%0.2f,%d,%d)"`, RadiansToDegrees(*c.textTheta), x, y)
+		_, _ = fmt.Fprintf(bb, ` transform="rotate(%0.2f,%d,%d)"`, RadiansToDegrees(*c.textTheta), x, y)
 	}
 	bb.WriteRune('>')
 	bb.WriteString(body)
@@ -449,20 +458,6 @@ func (c *canvas) End() {
 	_, _ = c.w.Write([]byte("</svg>"))
 }
 
-// writeStrokeDashArray writes the stroke-dasharray property of a style.
-func (c *canvas) writeStrokeDashArray(bb *bytes.Buffer, s Style) {
-	if len(s.StrokeDashArray) > 0 {
-		bb.WriteString("stroke-dasharray=\"")
-		for i, v := range s.StrokeDashArray {
-			if i > 0 {
-				bb.WriteString(", ")
-			}
-			fmt.Fprintf(bb, "%0.1f", v)
-		}
-		bb.WriteString("\"")
-	}
-}
-
 // styleAsSVG returns the style as a svg style or class string.
 func styleAsSVG(bb *bytes.Buffer, s Style, dpi float64, applyText bool) {
 	sw := s.StrokeWidth

bar_chart_test.go

@@ -3,6 +3,7 @@ package charts
 import (
 	"errors"
 	"math"
+	"strconv"
 	"strings"
 
 	"github.com/go-analyze/charts/chartdraw"
@@ -140,37 +141,97 @@ func defaultRender(p *Painter, opt defaultRenderOption) (*defaultRenderResult, e
 
 	const legendTitlePadding = 15
 	var legendTopSpacing int
-	legendResult, err := newLegendPainter(p, *opt.legend).Render()
+	var titleBox, legendResult Box
+	var err error
+
+	// make a local copy of legend options before we modify position during collision handling
+	legendOpt := *opt.legend
+
+	// helper to check if legend can be repositioned to avoid title collision
+	// repositioning is allowed when no explicit numeric offset is set
+	// OverlayChart only controls legend/chart overlap, not legend/title overlap
+	legendCanReposition := func() bool {
+		return (legendOpt.Offset.Top == "" || legendOpt.Offset.Top == PositionTop ||
+			legendOpt.Offset.Top == PositionBottom) &&
+			(legendOpt.Offset.Left == "" || legendOpt.Offset.Left == PositionLeft ||
+				legendOpt.Offset.Left == PositionCenter || legendOpt.Offset.Left == PositionRight)
+	}
+
+	// determine positioning
+	titleAtBottom := opt.title.Offset.Top == PositionBottom
+	legendAtBottom := legendOpt.Offset.Top == PositionBottom
+
+	// calculate legend box for both-at-bottom check and collision detection
+	legendPainter := newLegendPainter(p, legendOpt)
+	legendResult, err = legendPainter.calculateBox()
+	if err != nil {
+		return nil, err
+	}
+
+	// when both title and legend are at bottom (without overlay), render title on a reduced canvas
+	// so title appears above where legend will render (title above legend in reading order)
+	titleCanvas := p
+	adjustedForBottom := false
+	if titleAtBottom && legendAtBottom && !legendResult.IsZero() &&
+		!flagIs(true, legendOpt.OverlayChart) {
+		titleCanvas = p.Child(PainterPaddingOption(Box{
+			Bottom: legendResult.Height() + legendTitlePadding,
+			IsSet:  true,
+		}))
+		adjustedForBottom = true
+	}
+
+	titleBox, err = newTitlePainter(titleCanvas, opt.title).Render()
 	if err != nil {
 		return nil, err
 	}
-	if !legendResult.IsZero() && !flagIs(true, opt.legend.Vertical) && !flagIs(true, opt.legend.OverlayChart) {
-		legendHeight := legendResult.Height()
+
+	// check for collision and reposition if needed
+	// skip if both-at-bottom was handled via canvas adjustment
+	if !adjustedForBottom &&
+		!titleBox.IsZero() && !legendResult.IsZero() &&
+		legendCanReposition() && titleBox.Overlaps(legendResult) {
+		legendOpt.Offset.Top = strconv.Itoa(titleBox.Bottom)
+		legendPainter = newLegendPainter(p, legendOpt)
+	}
+
+	// render legend with final position
+	legendResult, err = legendPainter.Render()
+	if err != nil {
+		return nil, err
+	}
+
+	// reserve space for the legend if not in overlay mode
+	// - horizontal legends reserve space (top or bottom)
+	// - vertical legends always overlay from the side
+	// - skip for adjustedForBottom since title reservation handles combined space
+	if !legendResult.IsZero() && !flagIs(true, legendOpt.OverlayChart) && !adjustedForBottom &&
+		!flagIs(true, legendOpt.Vertical) {
 		if legendResult.Bottom < p.Height()/2 {
-			// horizontal legend at the top, set the spacing based on the height
-			legendTopSpacing = legendHeight + legendTitlePadding
+			// horizontal legend at top - reserve top space
+			legendTopSpacing = chartdraw.MaxInt(legendResult.Height(), legendResult.Bottom) + legendTitlePadding
 		} else {
 			// horizontal legend at the bottom, raise the chart above it
 			p = p.Child(PainterPaddingOption(Box{
-				Bottom: legendHeight + legendTitlePadding,
+				Bottom: legendResult.Height() + legendTitlePadding,
 				IsSet:  true,
 			}))
 		}
 	}
 
-	titleBox, err := newTitlePainter(p, opt.title).Render()
-	if err != nil {
-		return nil, err
-	}
+	// apply title and legend spacing to chart area
 	if !titleBox.IsZero() {
 		titlePadBox := Box{IsSet: true}
 		if titleBox.Bottom < p.Height()/2 {
 			titlePadBox.Top = chartdraw.MaxInt(legendTopSpacing, titleBox.Bottom+legendTitlePadding)
-		} else { // else, title is at the bottom, raise the chart to be above the title
-			titlePadBox.Top = legendTopSpacing // the legend may still need space on the top, set to the legend space
-			titlePadBox.Bottom = titleBox.Height()
+		} else { // title is at the bottom, raise the chart to be above the title
+			titlePadBox.Top = legendTopSpacing
+			if adjustedForBottom {
+				titlePadBox.Bottom = p.Height() - titleBox.Top
+			} else {
+				titlePadBox.Bottom = titleBox.Height()
+			}
 		}
-
 		p = p.Child(PainterPaddingOption(titlePadBox))
 	} else if legendTopSpacing > 0 { // apply chart spacing below legend
 		p = p.Child(PainterPaddingOption(Box{

candlestick_chart_test.go

@@ -5,10 +5,194 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetNullValue(t *testing.T) {
 	t.Parallel()
 
 	assert.InDelta(t, math.MaxFloat64, GetNullValue(), 0.0)
 }
+
+func TestLegendRepositioning(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name                     string
+		titleOpt                 TitleOption
+		legendOpt                LegendOption
+		expectLegendRepositioned bool
+	}{
+		{
+			name: "horizontal_center_with_center_title_collision",
+			titleOpt: TitleOption{
+				Text:   "Test Title",
+				Offset: OffsetCenter,
+			},
+			legendOpt: LegendOption{
+				SeriesNames: []string{"Series A", "Series B", "Series C", "Series D", "Series E"},
+			},
+			expectLegendRepositioned: true,
+		},
+		{
+			name: "horizontal_center_no_title",
+			titleOpt: TitleOption{
+				Text: "",
+			},
+			legendOpt: LegendOption{
+				SeriesNames: []string{"Series A", "Series B"},
+			},
+			expectLegendRepositioned: false,
+		},
+		{
+			name: "horizontal_bottom_no_collision",
+			titleOpt: TitleOption{
+				Text:   "Test Title",
+				Offset: OffsetCenter,
+			},
+			legendOpt: LegendOption{
+				SeriesNames: []string{"A", "B"},
+				Offset: OffsetStr{
+					Top: PositionBottom,
+				},
+			},
+			expectLegendRepositioned: false,
+		},
+		{
+			name: "vertical_legend_with_collision",
+			titleOpt: TitleOption{
+				Text:   "Test Title",
+				Offset: OffsetLeft,
+			},
+			legendOpt: LegendOption{
+				SeriesNames: []string{"Series A", "Series B"},
+				Vertical:    Ptr(true),
+			},
+			expectLegendRepositioned: true,
+		},
+		{
+			name: "vertical_legend_no_collision_right_position",
+			titleOpt: TitleOption{
+				Text:   "Test Title",
+				Offset: OffsetLeft,
+			},
+			legendOpt: LegendOption{
+				SeriesNames: []string{"Series A", "Series B"},
+				Vertical:    Ptr(true),
+				Offset:      OffsetRight,
+			},
+			expectLegendRepositioned: false,
+		},
+		{
+			name: "explicit_numeric_offset_blocks_repositioning",
+			titleOpt: TitleOption{
+				Text:   "Test Title",
+				Offset: OffsetCenter,
+			},
+			legendOpt: LegendOption{
+				SeriesNames: []string{"A", "B", "C", "D", "E"},
+				Offset: OffsetStr{
+					Top: "10",
+				},
+			},
+			expectLegendRepositioned: false,
+		},
+		{
+			name: "explicit_numeric_left_offset_blocks_repositioning",
+			titleOpt: TitleOption{
+				Text:   "Test Title",
+				Offset: OffsetCenter,
+			},
+			legendOpt: LegendOption{
+				SeriesNames: []string{"A", "B", "C", "D", "E"},
+				Offset: OffsetStr{
+					Left: "50",
+				},
+			},
+			expectLegendRepositioned: false,
+		},
+		{
+			name: "overlay_chart_blocks_repositioning",
+			titleOpt: TitleOption{
+				Text:   "Test Title",
+				Offset: OffsetCenter,
+			},
+			legendOpt: LegendOption{
+				SeriesNames:  []string{"A", "B", "C", "D", "E"},
+				OverlayChart: Ptr(true),
+			},
+			expectLegendRepositioned: false,
+		},
+		{
+			name: "title_and_legend_both_bottom",
+			titleOpt: TitleOption{
+				Text: "Test Title",
+				Offset: OffsetStr{
+					Top: PositionBottom,
+				},
+			},
+			legendOpt: LegendOption{
+				SeriesNames: []string{"A", "B"},
+				Offset: OffsetStr{
+					Top: PositionBottom,
+				},
+			},
+			expectLegendRepositioned: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// create chart with line series to trigger defaultRender
+			opt := ChartOption{
+				Title:      tt.titleOpt,
+				Legend:     tt.legendOpt,
+				SeriesList: NewSeriesListGeneric([][]float64{{1, 2, 3}}, ChartTypeLine),
+				Width:      600,
+				Height:     400,
+			}
+
+			// save original offset
+			originalTopOffset := tt.legendOpt.Offset.Top
+
+			p, err := Render(opt)
+			require.NoError(t, err)
+			require.NotNil(t, p)
+
+			// check if legend was repositioned by verifying original option wasn't mutated
+			// (we use a copy internally, so original should always remain unchanged)
+			assert.Equal(t, originalTopOffset, tt.legendOpt.Offset.Top,
+				"original legend option should not be mutated")
+		})
+	}
+}
+
+func TestLegendOptionNotMutated(t *testing.T) {
+	t.Parallel()
+
+	// verify that rendering does not mutate the original legend option
+	legendOpt := LegendOption{
+		SeriesNames: []string{"A", "B", "C", "D", "E"},
+		Offset: OffsetStr{
+			Top: PositionTop,
+		},
+	}
+	titleOpt := TitleOption{
+		Text:   "Wide Title That Should Cause Collision",
+		Offset: OffsetCenter,
+	}
+
+	opt := ChartOption{
+		Title:      titleOpt,
+		Legend:     legendOpt,
+		SeriesList: NewSeriesListGeneric([][]float64{{1, 2, 3}}, ChartTypeLine),
+		Width:      600,
+		Height:     400,
+	}
+
+	_, err := Render(opt)
+	require.NoError(t, err)
+
+	// original should not have been modified
+	assert.Equal(t, PositionTop, legendOpt.Offset.Top)
+}