defmodule Contex.SVG do
@moduledoc """
Convenience functions for generating SVG output
"""
def text(x, y, content, opts \\ []) do
attrs = opts_to_attrs(opts)
[
"<text ",
~s|x="#{x}" y="#{y}"|,
attrs,
">",
clean(content),
"</text>"
]
end
def text(content, opts \\ []) do
attrs = opts_to_attrs(opts)
[
"<text ",
attrs,
">",
clean(content),
"</text>"
]
end
def title(content, opts \\ []) do
attrs = opts_to_attrs(opts)
[
"<title ",
attrs,
">",
clean(content),
"</title>"
]
end
def rect({_x1, _x2} = x_extents, {_y1, _y2} = y_extents, inner_content, opts \\ []) do
width = width(x_extents)
height = width(y_extents)
y = min(y_extents)
x = min(x_extents)
attrs = opts_to_attrs(opts)
[
"<rect ",
~s|x="#{x}" y="#{y}" width="#{width}" height="#{height}"|,
attrs,
">",
inner_content,
"</rect>"
]
end
def circle(x, y, radius, opts \\ []) do
attrs = opts_to_attrs(opts)
[
"<circle ",
~s|cx="#{x}" cy="#{y}" r="#{radius}"|,
attrs,
"></circle>"
]
end
def line(points, smoothed, opts \\ []) do
attrs = opts_to_attrs(opts)
path = path(points, smoothed)
[
"<path d=\"",
path,
"\"",
attrs,
"></path>"
]
end
defp path([], _), do: ""
defp path(points, false) do
Enum.reduce(points, :first, fn {x, y}, acc ->
coord = ~s|#{x} #{y}|
case acc do
:first -> ["M ", coord]
_ -> [acc, [" L ", coord]]
end
end)
end
defp path(points, true) do
# Use Catmull-Rom curve - see http://schepers.cc/getting-to-the-point
# First point stays as-is. Subsequent points are draw using SVG cubic-spline
# where control points are calculated as follows:
# - Take the immediately prior data point, the data point itself and the next two into
# an array of 4 points. Where this isn't possible (first & last) duplicate
# Apply Cardinal Spline to Cubic Bezier conversion matrix (this is with tension = 0.0)
# 0 1 0 0
# -1/6 1 1/6 0
# 0 1/6 1 -1/6
# 0 0 1 0
# First control point is second result, second control point is third result, end point is last result
initial_window = {nil, nil, nil, nil}
{_, window, last_p, result} =
Enum.reduce(points, {:first, initial_window, nil, ""}, fn p,
{step, window, last_p, result} ->
case step do
:first ->
{:second, {p, p, p, p}, p, []}
:second ->
{:rest, bump_window(window, p), p, ["M ", coord(last_p)]}
:rest ->
window = bump_window(window, p)
{cp1, cp2} = cardinal_spline_control_points(window)
{:rest, window, p, [result, " C " | [coord(cp1), coord(cp2), coord(last_p)]]}
end
end)
window = bump_window(window, last_p)
{cp1, cp2} = cardinal_spline_control_points(window)
[result, " C " | [coord(cp1), coord(cp2), coord(last_p)]]
end
defp bump_window({_p1, p2, p3, p4}, new_p), do: {p2, p3, p4, new_p}
@spline_tension 0.3
@factor (1.0 - @spline_tension) / 6.0
defp cardinal_spline_control_points({{x1, y1}, {x2, y2}, {x3, y3}, {x4, y4}}) do
cp1 = {x2 + @factor * (x3 - x1), y2 + @factor * (y3 - y1)}
cp2 = {x3 + @factor * (x2 - x4), y3 + @factor * (y2 - y4)}
{cp1, cp2}
end
defp coord({x, y}) do
x = if is_float(x), do: :erlang.float_to_binary(x, decimals: 2), else: x
y = if is_float(y), do: :erlang.float_to_binary(y, decimals: 2), else: y
~s| #{x} #{y}|
end
def opts_to_attrs(opts), do: opts_to_attrs(opts, [])
defp opts_to_attrs([{_, nil} | t], attrs), do: opts_to_attrs(t, attrs)
defp opts_to_attrs([{_, ""} | t], attrs), do: opts_to_attrs(t, attrs)
defp opts_to_attrs([{:phx_click, val} | t], attrs),
do: opts_to_attrs(t, [[" phx-click=\"", val, "\""] | attrs])
defp opts_to_attrs([{:phx_target, val} | t], attrs),
do: opts_to_attrs(t, [[" phx-target=\"", val, "\""] | attrs])
defp opts_to_attrs([{:series, val} | t], attrs),
do: opts_to_attrs(t, [[" phx-value-series=\"", "#{clean(val)}", "\""] | attrs])
defp opts_to_attrs([{:category, val} | t], attrs),
do: opts_to_attrs(t, [[" phx-value-category=\"", "#{clean(val)}", "\""] | attrs])
defp opts_to_attrs([{:value, val} | t], attrs),
do: opts_to_attrs(t, [[" phx-value-value=\"", "#{clean(val)}", "\""] | attrs])
defp opts_to_attrs([{:id, val} | t], attrs),
do: opts_to_attrs(t, [[" phx-value-id=\"", "#{val}", "\""] | attrs])
defp opts_to_attrs([{:task, val} | t], attrs),
do: opts_to_attrs(t, [[" phx-value-task=\"", "#{clean(val)}", "\""] | attrs])
# TODO: This is going to break down with more complex styles
defp opts_to_attrs([{:fill, val} | t], attrs),
do: opts_to_attrs(t, [[" style=\"fill:#", val, ";\""] | attrs])
defp opts_to_attrs([{:transparent, true} | t], attrs),
do: opts_to_attrs(t, [[" fill=\"transparent\""] | attrs])
defp opts_to_attrs([{:stroke, val} | t], attrs),
do: opts_to_attrs(t, [[" stroke=\"#", val, "\""] | attrs])
defp opts_to_attrs([{:stroke_width, val} | t], attrs),
do: opts_to_attrs(t, [[" stroke-width=\"", val, "\""] | attrs])
defp opts_to_attrs([{:stroke_linejoin, val} | t], attrs),
do: opts_to_attrs(t, [[" stroke-linejoin=\"", val, "\""] | attrs])
defp opts_to_attrs([{:opacity, val} | t], attrs),
do: opts_to_attrs(t, [[" fill-opacity=\"", val, "\""] | attrs])
defp opts_to_attrs([{:class, val} | t], attrs),
do: opts_to_attrs(t, [[" class=\"", val, "\""] | attrs])
defp opts_to_attrs([{:transform, val} | t], attrs),
do: opts_to_attrs(t, [[" transform=\"", val, "\""] | attrs])
defp opts_to_attrs([{:text_anchor, val} | t], attrs),
do: opts_to_attrs(t, [[" text-anchor=\"", val, "\""] | attrs])
defp opts_to_attrs([{:dominant_baseline, val} | t], attrs),
do: opts_to_attrs(t, [[" dominant-baseline=\"", val, "\""] | attrs])
defp opts_to_attrs([{:alignment_baseline, val} | t], attrs),
do: opts_to_attrs(t, [[" alignment-baseline=\"", val, "\""] | attrs])
defp opts_to_attrs([{:marker_start, val} | t], attrs),
do: opts_to_attrs(t, [[" marker-start=\"", val, "\""] | attrs])
defp opts_to_attrs([{:marker_mid, val} | t], attrs),
do: opts_to_attrs(t, [[" marker-mid=\"", val, "\""] | attrs])
defp opts_to_attrs([{:marker_end, val} | t], attrs),
do: opts_to_attrs(t, [[" marker-end=\"", val, "\""] | attrs])
defp opts_to_attrs([{key, val} | t], attrs) when is_atom(key),
do: opts_to_attrs(t, [[" ", Atom.to_string(key), "=\"", clean(val), "\""] | attrs])
defp opts_to_attrs([{key, val} | t], attrs) when is_binary(key),
do: opts_to_attrs(t, [[" ", key, "=\"", clean(val), "\""] | attrs])
defp opts_to_attrs([], attrs), do: attrs
defp width({a, b}), do: abs(a - b)
defp min({a, b}), do: min(a, b)
defp clean(s), do: Contex.SVG.Sanitize.basic_sanitize(s)
end
