defmodule Contex.PieChart do
@moduledoc """
A Pie Chart that displays data in a circular graph.
The pieces of the graph are proportional to the fraction of the whole in each category.
Each slice of the pie is relative to the size of that category in the group as a whole.
The entire “pie” represents 100 percent of a whole, while the pie “slices” represent portions of the whole.
Fill colours for each slice can be specified with `colour_palette` parameter in chart options, or can be
applied from a `CategoryColourScale` suppled in the `colour_scale` parameter. If neither option is supplied
a default colour palette is used.
"""
alias __MODULE__
alias Contex.{Dataset, Mapping, CategoryColourScale}
defstruct [
:dataset,
:mapping,
:options,
:colour_scale
]
@type t() :: %__MODULE__{}
@required_mappings [
category_col: :zero_or_one,
value_col: :zero_or_one
]
@default_options [
width: 600,
height: 400,
colour_palette: :default,
colour_scale: nil,
data_labels: true
]
@doc """
Create a new PieChart struct from Dataset.
Options may be passed to control the settings for the barchart. Options available are:
- `:data_labels` : `true` (default) or false - display labels for each slice value
- `:colour_palette` : `:default` (default) or colour palette - see `colours/2`
An example:
data = [
["Cat", 10.0],
["Dog", 20.0],
["Hamster", 5.0]
]
dataset = Dataset.new(data, ["Pet", "Preference"])
opts = [
mapping: %{category_col: "Pet", value_col: "Preference"},
colour_palette: ["fbb4ae", "b3cde3", "ccebc5"],
legend_setting: :legend_right,
data_labels: false,
title: "Why dogs are better than cats"
]
Contex.Plot.new(dataset, Contex.PieChart, 600, 400, opts)
"""
def new(%Dataset{} = dataset, options \\ []) when is_list(options) do
options = check_options(options)
options = Keyword.merge(@default_options, options)
mapping = Mapping.new(@required_mappings, Keyword.get(options, :mapping), dataset)
%PieChart{
dataset: dataset,
mapping: mapping,
options: options,
colour_scale: Keyword.get(options, :colour_scale)
}
end
defp check_options(options) do
colour_scale = check_colour_scale(Keyword.get(options, :colour_scale))
Keyword.put(options, :colour_scale, colour_scale)
end
defp check_colour_scale(%CategoryColourScale{} = scale), do: scale
defp check_colour_scale(_), do: nil
@doc false
def set_size(%PieChart{} = chart, width, height) do
chart
|> set_option(:width, width)
|> set_option(:height, height)
end
@doc false
def get_legend_scales(%PieChart{} = chart) do
[get_colour_palette(chart)]
end
@doc """
Overrides the default colours.
Colours can either be a named palette defined in `Contex.CategoryColourScale` or a list of strings representing hex code
of the colour as per CSS colour hex codes, but without the #. For example:
```
barchart = BarChart.colours(barchart, ["fbb4ae", "b3cde3", "ccebc5"])
```
The colours will be applied to the data series in the same order as the columns are specified in `set_val_col_names/2`
"""
@deprecated "Set in new/2 options"
@spec colours(PieChart.t(), Contex.CategoryColourScale.colour_palette()) ::
PieChart.t()
def colours(%PieChart{} = chart, colour_palette) when is_list(colour_palette) do
set_option(chart, :colour_palette, colour_palette)
end
def colours(%PieChart{} = chart, colour_palette) when is_atom(colour_palette) do
set_option(chart, :colour_palette, colour_palette)
end
def colours(%PieChart{} = chart, _) do
set_option(chart, :colour_palette, :default)
end
@doc """
Renders the PieChart to svg, including the svg wrapper, as a string or improper string list that
is marked safe.
"""
def to_svg(%PieChart{} = chart) do
[
"<g>",
generate_slices(chart),
"</g>"
]
end
def get_categories(%PieChart{dataset: dataset, mapping: mapping}) do
cat_accessor = dataset |> Dataset.value_fn(mapping.column_map[:category_col])
dataset.data
|> Enum.map(&cat_accessor.(&1))
end
defp set_option(%PieChart{options: options} = plot, key, value) do
options = Keyword.put(options, key, value)
%{plot | options: options}
end
defp get_option(%PieChart{options: options}, key) do
Keyword.get(options, key)
end
defp get_colour_palette(%PieChart{colour_scale: colour_scale}) when not is_nil(colour_scale) do
colour_scale
end
defp get_colour_palette(%PieChart{} = chart) do
get_categories(chart)
|> CategoryColourScale.new()
|> CategoryColourScale.set_palette(get_option(chart, :colour_palette))
end
defp generate_slices(%PieChart{} = chart) do
height = get_option(chart, :height)
with_labels? = get_option(chart, :data_labels)
colour_palette = get_colour_palette(chart)
r = height / 2
stroke_circumference = 2 * :math.pi() * r / 2
scale_values(chart)
|> Enum.map_reduce({0, 0}, fn {value, category}, {idx, offset} ->
text_rotation = rotate_for(value, offset)
label =
if with_labels? do
~s"""
<text x="#{negate_if_flipped(r, text_rotation)}"
y="#{negate_if_flipped(r, text_rotation)}"
text-anchor="middle"
fill="white"
stroke-width="1"
transform="rotate(#{text_rotation},#{r},#{r})
translate(#{r / 2}, #{negate_if_flipped(5, text_rotation)})
#{if need_flip?(text_rotation), do: "scale(-1,-1)"}"
>
#{Float.round(value, 2)}%
</text>
"""
else
""
end
{
~s"""
<circle r="#{r / 2}" cx="#{r}" cy="#{r}" fill="transparent"
stroke="##{CategoryColourScale.colour_for_value(colour_palette, category)}"
stroke-width="#{r}"
stroke-dasharray="#{slice_value(value, stroke_circumference)} #{stroke_circumference}"
stroke-dashoffset="-#{slice_value(offset, stroke_circumference)}">
</circle>
#{label}
""",
{idx + 1, offset + value}
}
end)
|> elem(0)
|> Enum.join()
end
defp slice_value(value, stroke_circumference) do
value * stroke_circumference / 100
end
defp rotate_for(n, offset) do
n / 2 * 3.6 + offset * 3.6
end
defp need_flip?(rotation) do
90 < rotation and rotation < 270
end
defp negate_if_flipped(number, rotation) do
if need_flip?(rotation),
do: -number,
else: number
end
@spec scale_values(PieChart.t()) :: [{value :: number(), label :: any()}]
defp scale_values(%PieChart{dataset: dataset, mapping: mapping}) do
val_accessor = dataset |> Dataset.value_fn(mapping.column_map[:value_col])
cat_accessor = dataset |> Dataset.value_fn(mapping.column_map[:category_col])
sum = dataset.data |> Enum.reduce(0, fn col, acc -> val_accessor.(col) + acc end)
dataset.data
|> Enum.map_reduce(sum, &{{val_accessor.(&1) / &2 * 100, cat_accessor.(&1)}, &2})
|> elem(0)
end
end
