Create 2D Composition
2D graphics via SVG + layout + compositing + batch → charts, diagrams, infographics.
Use When
- Diagrams/flowcharts/infographics programmatic
- Repro scientific figures
- Auto badges/icons/assets
- Composite imgs / data viz
- Custom chart types (not in libs)
- Batch gen w/ param variations
- SVG templates web/print
In
| In | Type | Desc | Example |
|---|---|---|---|
| Layout spec | Config | Dims, margins, grid | 800x600px canvas, 20px margins |
| Visual elements | Data/Assets | Shapes, text, imgs, pts | Rect coords, labels, icons |
| Style params | CSS/Attrs | Colors, fonts, stroke, opacity | fill="#3366cc", stroke-width="2" |
| Data sources | Files/Arrays | Values → viz | CSV, JSON config |
| Out format | String | SVG/PNG/PDF | output.svg, 300 DPI PNG |
Do
1. Python Env Setup
# Core libraries
pip install svgwrite pillow cairosvg
# Optional: advanced features
pip install drawsvg reportlab pycairo
# For data-driven graphics
pip install matplotlib numpy pandas
Got: Libs installed If err: Check Python 3.7+, use venv
2. Basic SVG
import svgwrite
from svgwrite import cm, mm
def create_basic_svg(output_path):
"""Create a simple SVG graphic."""
# Initialize drawing (use mm for precise dimensions)
dwg = svgwrite.Drawing(output_path, size=('180mm', '120mm'), profile='full')
# Add background rectangle
dwg.add(dwg.rect(
insert=(0, 0),
size=('100%', '100%'),
fill='white'
))
# Add shapes
dwg.add(dwg.circle(
center=(90*mm, 60*mm),
r=30*mm,
fill='lightblue',
stroke='navy',
stroke_width=2
))
dwg.add(dwg.rect(
insert=(30*mm, 30*mm),
size=(60*mm, 40*mm),
fill='lightgreen',
stroke='darkgreen',
stroke_width=2,
rx=5, # Rounded corners
ry=5
))
# Add text
dwg.add(dwg.text(
'Example Graphic',
insert=(90*mm, 20*mm),
text_anchor='middle',
font_size='18pt',
font_family='Arial',
fill='black'
))
dwg.save()
print(f"Saved: {output_path}")
Got: SVG w/ shapes + text If err: Check svgwrite ver, out dir writable
3. Diagram Layout
def create_flowchart(steps, output_path):
"""Generate a flowchart from list of steps."""
dwg = svgwrite.Drawing(output_path, size=('800px', '600px'))
# Layout parameters
box_width = 120
box_height = 60
spacing_y = 100
start_x = 340
start_y = 50
for i, step in enumerate(steps):
y_pos = start_y + i * spacing_y
# Draw box
box = dwg.add(dwg.g(id=f'step_{i}'))
box.add(dwg.rect(
insert=(start_x, y_pos),
size=(box_width, box_height),
fill='lightblue',
stroke='navy',
stroke_width=2,
rx=5,
ry=5
))
# Add text (wrapped if needed)
text_lines = wrap_text(step, max_width=16)
text_y = y_pos + box_height/2 - (len(text_lines)-1) * 7
for j, line in enumerate(text_lines):
box.add(dwg.text(
line,
insert=(start_x + box_width/2, text_y + j*14),
text_anchor='middle',
font_size='12pt',
font_family='Arial',
fill='black'
))
# Draw arrow to next step
if i < len(steps) - 1:
arrow_start_y = y_pos + box_height
arrow_end_y = y_pos + spacing_y
dwg.add(dwg.line(
start=(start_x + box_width/2, arrow_start_y),
end=(start_x + box_width/2, arrow_end_y),
stroke='black',
stroke_width=2,
marker_end=dwg.marker(
id='arrow',
viewBox='0 0 10 10',
refX=5,
refY=5,
markerWidth=6,
markerHeight=6,
orient='auto'
)
))
dwg.save()
def wrap_text(text, max_width=20):
"""Simple text wrapping."""
words = text.split()
lines = []
current_line = []
for word in words:
test_line = ' '.join(current_line + [word])
if len(test_line) <= max_width:
current_line.append(word)
else:
if current_line:
lines.append(' '.join(current_line))
current_line = [word]
if current_line:
lines.append(' '.join(current_line))
return lines
Got: Flowchart w/ boxes + arrows If err: Adjust layout calc, verify arrow markers
4. Composite Raster
Full Pillow composite (grid/horiz/vert + annotate) → references/EXAMPLES.md.
Got: Composite img w/ layout If err: Check inputs exist, img modes compat
5. Data-Driven Graphics
import numpy as np
def create_bar_chart_svg(data, labels, output_path):
"""Generate SVG bar chart from data."""
dwg = svgwrite.Drawing(output_path, size=('600px', '400px'))
# Chart area
margin = 50
chart_width = 500
chart_height = 300
bar_spacing = 10
# Calculate bar dimensions
n_bars = len(data)
bar_width = (chart_width - (n_bars - 1) * bar_spacing) / n_bars
# Scale data to fit chart
max_value = max(data)
scale = chart_height / max_value
# Draw axes
dwg.add(dwg.line(
start=(margin, margin),
end=(margin, margin + chart_height),
stroke='black',
stroke_width=2
))
dwg.add(dwg.line(
start=(margin, margin + chart_height),
end=(margin + chart_width, margin + chart_height),
stroke='black',
stroke_width=2
))
# Draw bars
for i, (value, label) in enumerate(zip(data, labels)):
x = margin + i * (bar_width + bar_spacing)
bar_height = value * scale
y = margin + chart_height - bar_height
# Bar
dwg.add(dwg.rect(
insert=(x, y),
size=(bar_width, bar_height),
fill='steelblue',
stroke='navy',
stroke_width=1
))
# Value label
dwg.add(dwg.text(
f'{value:.1f}',
insert=(x + bar_width/2, y - 5),
text_anchor='middle',
font_size='10pt',
fill='black'
))
# X-axis label
dwg.add(dwg.text(
label,
insert=(x + bar_width/2, margin + chart_height + 20),
text_anchor='middle',
font_size='10pt',
fill='black'
))
dwg.save()
Got: SVG bar chart scaled If err: Handle edge cases (empty, neg), add validate
6. Batch Gen
def batch_generate_badges(users, template_path, output_dir):
"""Generate badge for each user."""
os.makedirs(output_dir, exist_ok=True)
for user in users:
output_path = os.path.join(output_dir, f"{user['id']}_badge.svg")
dwg = svgwrite.Drawing(output_path, size=('300px', '100px'))
# Background
dwg.add(dwg.rect(
insert=(0, 0),
size=('100%', '100%'),
fill='#3366cc',
rx=10,
ry=10
))
# User name
dwg.add(dwg.text(
user['name'],
insert=(150, 40),
text_anchor='middle',
font_size='20pt',
font_weight='bold',
fill='white'
))
# User role
dwg.add(dwg.text(
user['role'],
insert=(150, 70),
text_anchor='middle',
font_size='14pt',
fill='lightblue'
))
dwg.save()
print(f"Generated badge: {output_path}")
Got: Per-item graphic gen If err: Check data struct, defaults for missing
7. SVG → Raster
import cairosvg
def svg_to_png(svg_path, png_path, dpi=300):
"""Convert SVG to PNG with specified DPI."""
# Calculate pixel dimensions from DPI
# Assuming A4 size as example
width_inches = 8.27
height_inches = 11.69
width_px = int(width_inches * dpi)
height_px = int(height_inches * dpi)
cairosvg.svg2png(
url=svg_path,
write_to=png_path,
output_width=width_px,
output_height=height_px
)
print(f"Converted to PNG: {png_path}")
def svg_to_pdf(svg_path, pdf_path):
"""Convert SVG to PDF."""
cairosvg.svg2pdf(url=svg_path, write_to=pdf_path)
print(f"Converted to PDF: {pdf_path}")
Got: Raster out @ res If err: Install cairo sys lib, check SVG valid
Check
- Graphics render in target apps
- Text readable + positioned
- Colors match (hex)
- Dims fit use case
- SVG validates (if req)
- Raster DPI correct
- Layout adapts to data
- Batch completes no err
- Out files organized
- Err handling in code
Traps
- Unit confusion: SVG units (px, mm, cm) vs screen px vs print DPI
- Text overflow: Text exceeds shape → wrap
- Font avail: Sys fonts differ → embed / web-safe
- Coord calc: Off-by-one in grids
- Color fmt: SVG hex (
#rrggbb), not tuples - SVG valid: XML struct, close tags
- File paths: Special chars, spaces
- Memory: Large batch → chunk
- Aspect ratio: Preserve on resize
- Transparency: PNG alpha, JPEG not
→
- render-publication-graphic: Publication out reqs
- create-3d-scene: 3D variant
- generate-quarto-report: Graphics in reports