Wikipedia

Modulo:Graph: differenze tra le versioni

Naviga nella cronologia in modo interattivo
← Differenza precedente
Contenuto cancellato Contenuto aggiunto
Moroboshi (discussione | contributi)
75 152 modifiche
rimosso poi non implementato
m correggo
 
(20 versioni intermedie di 4 utenti non mostrate)
Riga 1:
local p = {}
local cfg = mw.loadData( 'ModuloModule:Chart/sandboxGraph/Configurazione' );
local getArgs = require('Module:Arguments').getArgs
local errors = { }
 
local function dump(t, ...)
local args = {...}
for _, s in ipairs(args) do
table.insert(t, s)
end
end
 
Riga 16:
-- ===============================================================================
local function add_error(msg_key, args)
local msg = cfg.errors_key[msg_key]
if not msg then msg = cfg.errors_key.unknown_error end
if args then
errors[#errors+1] = mw.ustring.format(msg, unpack(args))
else
errors[#errors+1] = msg
end
end
 
Riga 29:
-- ===============================================================================
local function errors_output(nocat)
if #errors > 0 then
local out = string.format('<strong class="error">%s</strong>', table.concat(errors, "; "))
if nocat or not cfg.uncategorized_namespaces[mw.title.getCurrentTitle().nsnsText] then
out = out .. '[[Category:' .. cfg.errors_category .. ']]'
end
return out
end
return ''
end
 
-- ==============================================================================
-- Return true if t is a table
-- ===============================================================================
local function isTable(t)
-- Return true if val is not nil and is a string in the array cfg.yes_values
return type(t) == "table"
end
 
-- ===============================================================================
-- Class to manage access to arguments
local function return_yes_value(val)
-- ===============================================================================
return val and cfg.yes_values[mw.ustring.lower(val)]
local Args = {}
Args.__index = Args
 
function Args.new(arguments)
local self = {}
self.args = arguments
return setmetatable(self, Args)
end
 
-- ===============================================================================
-- Return value of parameter name
-- Return true if val is not nil and is a string in the array cfg.no_value
-- ===============================================================================
function Args:value(name, default, transform)
local function return_no_value(val)
if cfg.localization[name] then
return val and cfg.no_values[mw.ustring.lower(val)]
val = self.args[cfg.localization[name]]
if val and transform then
val = transform(val)
end
if val then
return val
end
return default
end
return --TODO raise an error ?
end
 
-- ===============================================================================
-- Return value of parameter name as number
-- ===============================================================================
function Args:number(name, default)
local val = self:value(name)
return (val and tonumber(val)) or default
end
 
 
-- ===============================================================================
-- Return array of value of parameters base_name, base_name2, ... base_namen
-- ===============================================================================
function Args:values_indexed(base_name)
local base_name_localized = cfg.localization[base_name]
if not base_name_localized then return end
local values = {}
local index = 1
if self.args[base_name_localized] then
values[1] = self.args[base_name_localized]
index = 2
end
while true do
local val = self.args[base_name_localized .. tostring(index)]
if not val then break end
values[index] = val
index = index + 1
end
return values
end
 
-- ===============================================================================
-- Return true if parameter arg is present and is a yes value (a valor
-- in the array cfg.yes_values
-- ===============================================================================
function Args:is_yes(name)
local val = self:value(name)
return val and cfg.yes_values[mw.ustring.lower(val)]
end
 
-- ===============================================================================
-- Return true if parameter arg is present and is a yes value (a valor
-- in the array cfg.yes_values
-- ===============================================================================
function Args:is_no(name)
local val = self:value(name)
return val and cfg.no_values[mw.ustring.lower(val)]
end
 
setmetatable(Args, { __call = function(_, ...) return Args.new(...) end })
 
-- ===============================================================================
Line 59 ⟶ 131:
-- ===============================================================================
local function numericArray(csv, default_empty)
if not csv then return end
if default_empty == nil then default_empty = 'x' end
local list = {}
-- check for local separator character instead of ","
if mw.ustring.find(csv, cfg.separator.list) then
list = mw.text.split(mw.ustring.gsub(csv, "%s", ""), cfg.separator.list)
for index,v in ipairs(list) do
list[index] = mw.ustring.gsub(v, cfg.separator.decimal, ".")
end
else
list = mw.text.split(mw.ustring.gsub(csv, "%s", ""), ",")
end
-- build output array replacing empty value with a "x"
local result = {}
for i, val in ipairs(list) do
if val == '' then
result[i] = 'x'
else
result[i] = tonumber(val)
end
end
return result
end
 
Line 87 ⟶ 159:
-- ===============================================================================
local function stringArray(csv)
if not csv then return end
local t = {}
for s in mw.text.gsplit(csv, ",") do
t[#t+1] = mw.text.trim(s)
end
return t
end
 
 
-- ==============================================================================
-- Return true if t is a table
-- ===============================================================================
local function isTable(t)
return type(t) == "table"
end
 
-- ==============================================================================
Line 107 ⟶ 172:
-- ==============================================================================
local function extend_table(t, new_len)
if #t >= new_len then return t end
local pos = 1
local old_len = #t
for i = #t+1, new_len do
t[i] = t[pos]
pos = pos + 1
if pos > old_len then pos = 1 end
end
return t
end
 
-- ==============================================================================
-- Generate a color palette from thea palette name (must be in cfg.colors_palette)
-- or an array of color values
-- with minimal length len
-- ==============================================================================
local function generate_color_palette(palette, lennew_len)
local color_palette = {}
if not cfg.colors_palette[palette] then
local palette_len
colors_palette = "category10"
palette = palette or "category10"
end
if isTable(palette) and #palette local== palette_len,1 color_palette =and cfg.colors_palette[palette][1],cfg.colors_palette[palette][2] then
palette_len, color_palette = cfg.colors_palette[palette[1]][1], cfg.colors_palette[palette[1]][2]
local t = {}
elseif not isTable(palette) then
local pos = 1
palette = (cfg.colors_palette[palette] and palette) or "category10"
for i = 1, palette_len do
palette_len, color_palette = cfg.colors_palette[palette][1], cfg.colors_palette[palette][2]
t[i] = color_palette[pos]
else
pos = pos + 1
if pos > palette_len, then poscolor_palette = 1#palette, endpalette
end
local new_len = new_len or palette_len
--t = extend_table(palette, len or 1)
return t
local t = {}
local pos = 1
for i = 1, new_len do
t[i] = color_palette[pos]
pos = pos + 1
if pos > palette_len then pos = 1 end
end
return t
end
 
Line 143 ⟶ 216:
-- ===================================================================================
local function wrap_graph(graph, legend, align, width)
local html = mw.html.create('div'):addClass('thumb')
if align then
html:addClass('t' .. align)
else
html:css('display', 'inline-block')
end
 
html:tag('div')
:addClass('thumbinner')
:tag('div')
:wikitext(graph)
:done()
:tag('div')
:node(legend)
:css('width', tostring(width) .. 'px')
return tostring(html)
end
 
Line 165 ⟶ 238:
-- ===================================================================================
local function legend_item(color, text)
local item = mw.html.create('p'):cssText('margin:0px;font-size:100%;text-align:left')
item:tag('span'):cssText(string.format('border:none;background-color:%s;color:%s;', color, color)):wikitext("██")
item:wikitext(string.format("&nbsp;%s", text))
return item
end
 
Line 175 ⟶ 248:
-- ===================================================================================
local function build_legend(colors, labels, title, ncols)
local legend = mw.html.create('div'):addClass('thumbcaption'):css('text-align', 'center')
legend:wikitext(title or '')
local legend_list= mw.html.create('div')
local cols = tonumber(ncols or "1")
if cols>1 then
local col_string = tostring(cols)
legend_list
:css('-moz-column-count', col_string)
:css('-webkit-column-count', col_string)
:css('column-count:', col_string)
end
for i,label in ipairs(labels) do
if not isTable(colors) then
legend_list:node(legend_item(colors[i], label))
colors = generate_color_palette(colors, #labels)
end
legend:node(legend_list)
for i,label in ipairs(labels) do
return legend
legend_list:node(legend_item(colors[i], label))
end
legend:node(legend_list)
return legend
end
 
Line 200 ⟶ 270:
-- ===================================================================================
function p.pie_chart_json(args)
local data = {}
for pos,x in= ipairs(1,#args.values) do
data[pos] = { x = xargs.labels[pos], colory = args.colorsvalues[pos] }
end
local graph = {
version = 2,
name = args.name,
name = args.name,
width = math.floor(args.graphwidth / 3),
height = math.floor(args.graphwidth / 3),
data = {
{
{
name = "table",
values = data,
transform = { { type = "pie", value = "data.x" } }
}
}
},
},
marks = {
{
{
type = "arc",
from = { data = "table"},
transform = { { field = "y", type = "pie"} }
properties = {
},
enter = {
properties = {
x = { field = "data.x", group = "width", mult = 0.5 },
enter = {
y = { field = "data.x", group = "height", mult = 0.5 },
innerRadius = {value = args.inner_radius},
startAngle = { field = "startAngle"},
endAngle startAngle = { field = "endAnglelayout_start"},
innerRadius outerRadius = {value = args.inner_radiusouter_radius },
endAngle = {field = "layout_end"},
outerRadius = {value = args.outer_radius },
stroke = {value = "#fff"},
fill = { field = "x", scale = "color"},
},
},
update = { fill = { field = "data.color"} },
},
hover = { fill = {value = "pink"} }
}
},
},
}
scales = {
}
{
}
name = "color",
local flags = return_yes_value(args[cfg.localization.debug_json]) and mw.text.JSON_PRETTY
range = args.colors,
return mw.text.jsonEncode(graph, flags)
___domain = { data = "table", field = "x"},
["type"] = "ordinal"
}
}
}
if args.internal_legend then
data[#data] = { { fill = "color", stroke = "color", title = args.internal_legend } }
end
local flags = args.debug_json and mw.text.JSON_PRETTY
return mw.text.jsonEncode(graph, flags)
end
 
Line 243 ⟶ 324:
-- ===================================================================================
function p.pie_chart(frame)
local args = Args(getArgs(frame, {parentOnly = true}))
local argumentspie_args = { }
arguments pie_args.name = args[cfg.localization.:value('name] or', 'grafico a torta')
arguments pie_args.values = numericArray(args[cfg.localization.:value('values], 0'))
-- Se non trova valori validi termina
-- get marks colors, use default category10 palette as default,
if not pie_args.values or #pie_args.values == 0 then
-- if colors is not the name of a palette then read it as an array of colors
add_error('no_values')
arguments.colors = args[cfg.localization.colors] or "category10"
return errors_output(args.NoTracking)
if not cfg.colors_palette[arguments.colors] then
end
arguments.colors = stringArray(arguments.colors)
pie_args.labels = args:values_indexed('label')
else
-- Se è definito 'other' assumo che sia calcolato su base %, calcolo il suo valore e l'aggiungo alla tabella dati
arguments.colors = generate_color_palette(arguments.colors)
if args:value('other') then
end
local total = 0
arguments.labels = {}
for _,val in ipairs(pie_args.values) do total = total + val end
local index = 1
if total > 0 and total < 100 then
label_string = cfg.localization.label
pie_args.values[#pie_args.values+1]= math.max(0, 100 - total)
if args[label_string] then
pie_args.labels[#pie_args.values] = "Altri"
arguments.labels[1] = args[label_string]
end
index = 2
end
-- build array of colors values
while true do
local palette = stringArray(args:value('colors'))
if not args[label_string .. tostring(index)] then break end
if not palette then palette = stringArray(args:value('color')) end
arguments.labels[index] = args[label_string .. tostring(index)]
pie_args.colors = generate_color_palette(palette, #pie_args.values)
index = index + 1
pie_args.graphwidth = args:number('width', cfg.default.width_piechart)
end
pie_args.outer_radius = pie_args.graphwidth / 2 - 5
-- Se è definito 'other' assumo che sia calcolato su base %, calcolo il suo valore e l'aggiungo alla tabella dati
if args[cfg.localization.other]:is_yes('ring') then
pie_args.inner_radius = pie_args.outer_radius / 3
local total = 0
else
for _,val in ipairs(arguments.values) do total = total + val end
pie_args.inner_radius = 0
if total > 0 and total < 100 then
end
arguments.values[#arguments.values+1]= math.max(0, 100 - total)
pie_args.legend = args:value('internal_legend') or args:value('external_legend', 'Legenda')
arguments.labels[#arguments.values] = "Altri"
for pos,txt in ipairs(pie_args.labels) do
end
pie_args.labels[pos] = txt .. ' (' .. mw.language.getContentLanguage():formatNum(pie_args.values[pos] or 0) .. '%)'
end
end
arguments.colors = extend_table(arguments.colors, #arguments.values)
pie_args.debug_json = args:is_yes('debug_json')
arguments.graphwidth = tonumber(args[cfg.localization.width]) or cfg.default.width_piechart
local json_code = p.pie_chart_json(pie_args)
arguments.outer_radius = arguments.graphwidth / 2 - 5
if pie_args.debug_json then return frame:extensionTag('syntaxhighlight', json_code) end
if return_yes_value(args[cfg.localization.ring]) then
local external_legend
arguments.inner_radius = arguments.outer_radius / 3
if not args:is_no('legend') then
else
external_legend = build_legend(pie_args.colors, pie_args.labels, pie_args.legend, args:value('nCols'))
arguments.inner_radius = 0
end
local chart = frame:extensionTag('graph', json_code)
arguments.legend = args[cfg.localization.internal_legend] or args[cfg.localization.external_legend] or 'Legenda'
local align = args:value('thumb')
for pos,txt in ipairs(arguments.labels) do
return wrap_graph(chart, external_legend, align, pie_args.graphwidth ) .. errors_output(args:value('NoTracking'))
arguments.labels[pos] = txt .. ' (' .. mw.language.getContentLanguage():formatNum(arguments.values[pos] or 0) .. '%)'
end
local json_code = p.pie_chart_json(arguments)
if args[cfg.localization.debug_json] then return frame:extensionTag('syntaxhighlight', json_code) end
local external_legend
if not return_no_value(arguments.legend) then
external_legend = build_legend(arguments.colors, arguments.labels, arguments.legend, args[cfg.localization.nCols])
end
local chart = frame:extensionTag('graph', json_code)
local align = args[cfg.localization.thumb]
return wrap_graph(chart, external_legend, align, arguments.graphwidth ) .. errors_output(args.NoTracking)
end
 
Line 304 ⟶ 375:
local function build_ax(args, ax_name)
 
local ax = {
type = ax_name,
scale = ax_name,
title = args[ax_name .. 'title'],
format = args[ax_name .. 'format'],
grid = args[ax_name .. 'grid'],
layer = "back"
}
}
if isTable(args[ax_name .. 'AxisPrimaryTicks']) then
ax.values = args[ax_name .. 'AxisPrimaryTicks']
elseif args[ax_name .. 'nTicks'] then
ax.ticks = args[ax_name .. 'nTicks']
end
if args[ax_name .. 'SecondaryTicks'] then ax.subdivide = args[ax_name .. 'SecondaryTicks'] end
return ax
end
 
Line 326 ⟶ 397:
-- ===================================================================================
function p.chart_json(args)
-- build axes
local x_ax = build_ax(args, 'x')
local y_ax = build_ax(args, 'y')
local axes = { x_ax, y_ax }
 
-- create data tuples, consisting of series index, x value, y value
local data = { name = "chart", values = {} }
for i, yserie in ipairs(args.y) do
for j = 1, math.min(#yserie, #args.x) do
if yserie[j] ~= 'x' then data.values[#data.values + 1] = { series = args.seriesTitles[i], x = args.x[j], y = yserie[j] } end
end
end
-- calculate statistics of data as stacking requires cumulative y values
local stats
if args.is_stacked then
stats =
{
{
name = "stats", source = "chart", transform = {
{
{
type = "aggregate",
{ type = "facet", keys = { "data.x" } },
summarize = { y = "sum" },
{ type = "stats", value = "data.y" }
groupby = { "x" }
}
}
}
}
end
}
-- create scales
end
local xscale =
-- create scales
{
local xscale =
name = "x",
{
type = "linear",
range name = "widthx",
type = "linear",
zero = false, -- do not include zero value
range = "width",
nice = true, -- force round numbers for y scale
zero = false, -- do not include zero value
___domain = { data = "chart", field = "data.x" }
nice = true, -- force round numbers for y scale
}
___domain = { data = "chart", field = "x" }
if args.xMin then xscale.domainMin = args.xMin end
}
if args.xMax then xscale.domainMax = args.xMax end
if args.xMin or args.xMax then xscale.clampdomainMin = trueargs.xMin end
if args.graph_type == "rect" or args.force_x_ordinal xMax then xscale.typedomainMax = "ordinal"args.xMax end
if args.xMin or args.xMax then xscale.clamp = true end
if args.graph_type == "rect" or args.force_x_ordinal then xscale.type = "ordinal" end
 
local yscale =
{
{
name = "y",
type = "linear",
range = "height",
-- area charts have the lower boundary of their filling at y=0 (see marks.properties.enter.y2), therefore these need to start at zero
zero = args.graph_type ~= "line",
nice = true
}
}
if args.yMin then yscale.domainMin = args.yMin end
if args.yMax then yscale.domainMax = args.yMax end
if args.yMin or args.yMax then yscale.clamp = true end
if args.is_stacked then
yscale.___domain = { data = "stats", field = "sumsum_y" }
else
yscale.___domain = { data = "chart", field = "data.y" }
end
-- Color scale
local colorScale = {
name = "color",
type = "ordinal",
range = args.colors },
___domain = { data = "chart", field = "series" }
local alphaScale
}
if args.alphas then alphaScale = { name = "transparency", graph_type = "ordinal", range = args.alphas } end
local alphaScale
-- Symbols scale
if args.alphas then alphaScale = { name = "transparency", graph_type = "ordinal", range = args.alphas } end
local symbolsScale
-- Symbols scale
if args.symbols then symbolsScale = { name = "symbols", type = "ordinal", range = args.symbols } end
local symbolsScale
-- for bar charts with multiple series: each series is grouped by the x value, therefore the series need their own scale within each x group
if type(args.symbols) == 'table' then
local groupScale
symbolsScale = { name = "symShape", type = "ordinal", range = args.symbols, ___domain = { data = "chart", field = "series" } }
if args.graph_type == "rect" and not is_stacked and #args.y > 1 then
end
groupScale = { name = "series", type = "ordinal", range = "width", ___domain = { field = "data.series" } }
-- for bar charts with multiple series: each series is grouped by the x value, therefore the series need their own scale within each x group
xscale.padding = 0.2 -- pad each bar group
local groupScale
end
if args.graph_type == "rect" and not args.is_stacked and #args.y > 1 then
groupScale = { name = "series", type = "ordinal", range = "width", ___domain = { field = "series" } }
xscale.padding = 0.2 -- pad each bar group
end
 
-- decide if lines (strokes) or areas (fills) should be drawn
local colorField
if args.graph_type == "line" then colorField = "stroke" else colorField = "fill" end
 
-- create chart markings
local marks =
{
{
type = args.graph_type,
properties =
{
{
-- chart creation event handler
enter =
{
{
x = { scale = "x", field = "data.x" },
y = { scale = "y", field = "data.y" },
 
},
},
-- chart update event handler
update = { },
-- chart hover event handler
hover = { }
}
}
}
}
marks.properties.update[colorField] = { scale = "color" }
marks.properties.hover[colorField] = { value = "red" }
if alphaScale then marks.properties.update[colorField .. "Opacity"] = { scale = "transparency" } end
-- for bars and area charts set the lower bound of their areas
if args.graph_type == "rect" or args.graph_type == "area" then
if args.is_stacked then
-- for stacked charts this lower bound is cumulative/stacking
marks.properties.enter.y2 = { scale = "y", field = "y2layout_end" }
else
--[[
for non-stacking charts the lower bound is y=0
TODO: "yscale.zero" is currently set to "true" for this case, but "false" for all other cases.
For the similar behavior "y2" should actually be set to where y axis crosses the x axis,
if there are only positive or negative values in the data ]]
marks.properties.enter.y2 = { scale = "y", value = 0 }
end
end
-- for bar charts ...
if args.graph_type == "rect" then
-- set 1 pixel width between the bars
marks.properties.enter.width = { scale = "x", band = true, offset = -1 }
-- for multiple series the bar marking need to use the "inner" series scale, whereas the "outer" x scale is used by the grouping
if not args.is_stacked and #args.y > 1 then
marks.properties.enter.x.scale = "series"
marks.properties.enter.x.field = "data.series"
marks.properties.enter.width.scale = "series"
end
end
if args.graph_type == "line" then marks.properties.enter.strokeWidth = { value = args.stroke_thickness } end
-- stacked charts have their own (stacked) y values
if args.is_stacked then marks.properties.enter.y.field = "ylayout_start" end
-- set interpolation mode
if args.interpolate then marks.properties.enter.interpolate = { value = args.interpolate } end
local symbolsMarks
if symbolsScale then
symbolsMarks = {
type = "symbol",
from = { data = "chart" },
properties = {
enter = {
x = { scale = "x", field = "x" },
{
x y = { scale = "xy", field = "data.xy" },
y shape = { scale = "ysymShape", field = "data.yseries" },
stroke = { shapescale = {"color", scalefield = "symbolsseries" },
},
},
}
update = { stroke = { scale = "color"} }
}
}
if args.symbol_size then symbolsMarks.properties.enter.size = { value = args.symbol_size } end
}
if alphaScale then
if args.symbol_size then symbolsMarks.properties.enter.size = { value = args.symbol_size } end
symbolsMarks.properties.enter.fillOpacity = { scale = "transparency", field = "series" }
end
symbolsMarks.properties.enter.strokeOpacity = { scale = "transparency", field = "series" }
if #args.y == 1 then
end
marks.from = { data = "chart" }
end
marks = { marks, symbolsMarks }
if #args.y == 1 then
else
marks.from = { data = "chart" }
-- if there are multiple series, connect colors to series
marks = { marks, symbolsMarks }
if args.graph_type == "rect" and args.colorsByGroup then
else
marks.properties.update[colorField].field = "data.x"
-- if there are multiple series, connect colors to series
else
if args.graph_type == "rect" and args.colorsByGroup then
marks.properties.update[colorField].field = "data.series"
marks.properties.update[colorField].field = "x"
end
else
if symbolsScale then
symbolsMarks marks.properties.enter.shapeupdate[colorField].field = "data.series"
end
symbolsMarks.properties.update.stroke.field = "data.series"
if symbolsScale then
end
if alphaScale then marks symbolsMarks.properties.update[colorField enter.. "Opacity"]shape.field = "data.series" end
end
if alphaScale then marks.properties.update[colorField .. "Opacity"].field = "series" end
 
-- apply a grouping (facetting) transformation
marks =
{
{
type = "group",
marks = { marks, symbolsMarks },
from =
{
{
data = "chart",
transform =
{
{
{
{
type = "facet",
keys groupby = { "data.series" }
}
}
}
}
}
}
}
}
-- for stacked charts apply a stacking transformation
if args.is_stacked then
table.insert(marks.from.transform[2] = { type = "stack", point = "data.x"1, height = "data.y" }{
field = "y",
else
type = "stack",
-- for bar charts the series are side-by-side grouped by x
sortby = { "-_id" },
if args.graph_type == "rect" then
groupby = { "x" }
marks.from.transform[1].keys = "data.x"
})
marks.scales = { groupScale }
else
marks.properties = { enter = { x = { field = "key", scale = "x" }, width = { scale = "x", band = true } } }
-- for bar charts the series are side-by-side grouped by x
end
if args.graph_type == "rect" then
end
marks.from.transform[1].groupby = "x"
marks = { marks }
marks.scales = { groupScale }
end
marks.properties = { enter = { x = { field = "key", scale = "x" }, width = { scale = "x", band = true } } }
end
end
marks = { marks }
end
 
-- create legend
local legend
if args.internal_legend then
if args.internal_legend then
legend = { { fill = "color", stroke = "color", title = args.internal_legend } }
end
 
-- build final output object
local scales = { xscale, yscale, colorScale}
if alphaScale then scales[#scales+1] = alphaScale end
if symbolsScale then scales[#scales+1] = symbolsScale end
local output =
{
{
version = 2,
width = args.graphwidth,
height width = args.graphheightgraphwidth,
height = args.graphheight,
data = { data, stats },
data = { data, stats },
scales = scales,
scales = scales,
axes = axes,
marks axes = marks axes,
marks = marks ,
legends = legend
legends = legend
}
}
local flags = return_yes_value(args[cfg.localization.debug_json]) and mw.text.JSON_PRETTY
local flags = (args.debug_json and mw.text.JSON_PRETTY) or 0
return mw.text.jsonEncode(output, flags)
return mw.text.jsonEncode(output, flags)
end
 
Line 544 ⟶ 633:
function p.chart(frame)
 
-- Read ax arguments
local function read_ax_arguments(args, ax_name, argumentschart_arg)
arguments chart_arg[ax_name .. 'title'] = args[cfg.localization[:value(ax_name .. 'AxisTitle']])
arguments chart_arg[ax_name .. 'format'] = args[cfg.localization[:value(ax_name .. 'AxisFormat']])
local grid = cfg.default[ax_name .. 'Grid']
if grid then
grid = not return_no_valueargs:is_no(args[cfg.localization[ax_name .. 'Grid']])
else
grid = return_yes_valueargs:is_yes(args[cfg.localization[ax_name .. 'Grid']])
end
arguments chart_arg[ax_name .. 'grid'] = grid
arguments chart_arg[ax_name .. 'AxisPrimaryTicks'] = numericArray(args[cfg.localization[:value(ax_name .. 'AxisPrimaryTicks']]))
arguments chart_arg[ax_name .. 'nTicks'] = tonumberargs:number(args[cfg.localization[ax_name .. 'AxisPrimaryTicksNumber']])
arguments chart_arg[ax_name .. 'SecondaryTicks'] = tonumberargs:number(args[cfg.localization[ax_name .. 'AxisSecondaryTicks']])
arguments chart_arg[ax_name ..'Min'] = tonumberargs:number(args[cfg.localization[ax_name .. 'AxisMin']])
arguments chart_arg[ax_name ..'Max'] = tonumberargs:number(args[cfg.localization[ax_name .. 'AxisMax']])
end
 
-- get graph type
local function get_graph_type(graph_string)
if graph_string == nil then return "line", false end
local graph_type = cfg.graph_type[mw.ustring.lower(graph_string)]
if graph_type then return graph_type[1], graph_type[2] end
add_error('type_unknown', {graph_string})
end
 
local args = Args(getArgs(frame, {parentOnly = true}))
-- analyze and build data to build the chart
local chart_arg = { }
chart_arg.graphwidth = args:number('width', cfg.default.width)
chart_arg.graphheight = args:number('height', cfg.default.height)
chart_arg.graph_type, chart_arg.is_stacked = get_graph_type(args:value('type'))
chart_arg.interpolate = args:value('interpolate')
if chart_arg.interpolate and not cfg.interpolate[chart_arg.interpolate] then
add_error('value_not_valid', {cfg.localization.interpolate, chart_arg.interpolate})
interpolate = nil
end
-- get marks symbols, default symbol is used if the type of graph is line, otherwise the default
-- is not to use symbol.
if chart_arg.graph_type == "line" and not args:is_no('symbols') then
chart_arg.symbols = stringArray(args:value('symbols') or cfg.default.symbol)
chart_arg.symbol_size = args:number('symbolSize', cfg.default.symbol_size)
end
if chart_arg.graph_type =="line" then
chart_arg.stroke_thickness = args:number('strokeThickness', cfg.default.stroke_thickness)
end
-- show legend, optionally caption
chart_arg.internal_legend = args:value('internal_legend')
-- get x values
chart_arg.x = numericArray(args:value('x'))
chart_arg.force_x_ordinal = false
if #chart_arg.x == 0 then
chart_arg.force_x_ordinal = true
else
for _,val in ipairs(chart_arg.x) do
if val == 'x' then
chart_arg.force_x_ordinal = true
break
end
end
end
if chart_arg.force_x_ordinal then chart_arg.x = stringArray(args:value('x')) end
-- get y values (series)
chart_arg.y = args:values_indexed('y')
if not chart_arg.y then return '' end --TODO message error mancanza dati per asse y
chart_arg.seriesTitles = args:values_indexed('yTitle')
for pos, y in ipairs(chart_arg.y) do
chart_arg.y[pos] = numericArray(y)
chart_arg.seriesTitles[pos] = chart_arg.seriesTitles[pos] or ("y" .. tostring(pos))
end
-- ignore stacked charts if there is only one series
if #chart_arg.y == 1 then chart_arg.is_stacked = false end
-- read axes arguments
read_ax_arguments(args, 'x', chart_arg)
read_ax_arguments(args, 'y', chart_arg)
-- get marks colors, default palette is category10,
-- if colors is not the name of a predefined palette then read it as an array of colors
--chart_arg.colors = args[cfg.localization.colors] or "category10"
--if not cfg.colors_palette[chart_arg.colors] then
-- chart_arg.colors = stringArray(chart_arg.colors)
--elseif chart_arg.colors ~="category10" and chart_arg.colors ~="category20" then
-- chart_arg.colors = generate_color_palette(chart_arg.colors)
--end
local palette = stringArray(args:value('colors'))
if not palette then palette = stringArray(args:value('color')) end
chart_arg.colors = generate_color_palette(palette, #chart_arg.y)
--if true then return mw.text.jsonEncode(chart_arg.colors) end
-- assure that colors, stroke_thickness and symbols table are at least the same lenght that the number of
-- y series
if isTable(chart_arg.stroke_thickness) then chart_arg.stroke_thickness = extend_table(chart_arg.stroke_thickness, #chart_arg.y) end
if isTable(chart_arg.symbols) then chart_arg.symbols = extend_table(chart_arg.symbols, #chart_arg.y) end
-- if there is at least one color in the format "#aarrggbb", create a transparency (alpha) scale
if isTable(chart_arg.colors) then
alphas = {}
local hasAlpha = false
for i, color in ipairs(chart_arg.colors) do
local a, rgb = string.match(color, "#(%x%x)(%x%x%x%x%x%x)")
if a then
hasAlpha = true
alphas[i] = tostring(tonumber(a, 16) / 255.0)
chart_arg.colors[i] = "#" .. rgb
else
alphas[i] = "1"
end
end
for i = #chart_arg.colors + 1, #chart_arg.y do alphas[i] = "1" end
if hasAlpha then chart_arg.alphas = alphas end
elseif args[cfg.localization.alpha] then
chart_arg.alphas = stringArray(args[cfg.localization.alpha])
if chart_arg.alphas then
for i,a in ipairs(chart_arg.alphas) do chart_arg.alphas[i] = tostring(tonumber(a, 16) / 255.0) end
chart_arg.alphas = extend_table(chart_arg.alphas, #chart_arg.y)
end
end
chart_arg.colorsByGroup = args:is_yes('colorsByGroup')
chart_arg.debug_json = args:is_yes('debug_json') or false
-- if true then return frame:extensionTag('syntaxhighlight', mw.text.jsonEncode(chart_arg, mw.text.JSON_PRETTY)) end
local chart_json = p.chart_json(chart_arg)
if chart_arg.debug_json then return frame:extensionTag('syntaxhighlight', chart_json) end
local external_legend
if args:value('external_legend') then
external_legend = build_legend(chart_arg.colors, chart_arg.seriesTitles, args:value('external_legend'),
args:value('nCols'))
end
local chart = frame:extensionTag('graph', chart_json)
local align = args:value('thumb')
return wrap_graph(chart, external_legend, align, chart_arg.graphwidth) .. errors_output(args:value('NoTracking'))
end
 
-- ===================================================================================
-- Return a json structure to generate a map chart
-- Imported and modified from de:Modul:Graph revision 142970943 of 10 giugno 2015
-- ===================================================================================
function p.map_json(args)
-- create highlight scale
local scales
if args.isNumbers then
scales =
{
{
name = "color",
type = args.scaleType,
___domain = { data = "highlights", field = "v" },
range = args.colorScale,
nice = true,
zero = false
}
}
if args.domainMin then scales[1].domainMin = args.domainMin end
if args.domainMax then scales[1].domainMax = args.domainMax end
 
local exponent = string.match(args.scaleType, "pow%s+(%d+%.?%d+)") -- check for exponent
if exponent then
scales[1].type = "pow"
scales[1].exponent = args.exponent
end
end
 
-- create legend
if args.legend then
legend =
{
{
fill = "color",
properties =
{
title = { fontSize = { value = 14 } },
labels = { fontSize = { value = 12 } },
legend =
{
stroke = { value = "silver" },
strokeWidth = { value = 1.5 }
}
}
}
}
end
 
-- get map url
local basemapUrl
if (string.sub(args.basemap, 1, 7) == "http://") or (string.sub(args.basemap, 1, 8) == "https://") or (string.sub(args.basemap, 1, 2) == "//") then
basemapUrl = args.basemap
else
-- if not a (supported) url look for a colon as namespace separator. If none prepend default map directory name.
local basemap = args.basemap
if not string.find(basemap, ":") then basemap = cfg.default.base_map_directory .. basemap end
basemapUrl = mw.title.new(basemap):fullUrl("action=raw")
end
local output =
{
version = 2,
width = 1, -- generic value as output size depends solely on map size and scaling factor
height = 1, -- ditto
data =
{
{
-- data source for the highlights
name = "highlights",
values = args.values
},
{
-- data source for map paths data
name = "countries",
url = basemapUrl,
format = { type = "topojson", feature = "countries" },
transform =
{
{
-- geographic transformation ("geopath") of map paths data
type = "geopath",
value = "data", -- data source
scale = args.scale,
translate = { 0, 0 },
projection = args.projection
},
{
-- join ("zip") of mutiple data source: here map paths data and highlights
type = "zip",
key = "id", -- key for map paths data
with = "highlights", -- name of highlight data source
withKey = "id", -- key for highlight data source
as = "zipped", -- name of resulting table
default = { data = { v = args.defaultValue } } -- default value for geographic objects that could not be joined
}
}
}
},
marks =
{
-- output markings (map paths and highlights)
{
type = "path",
from = { data = "countries" },
properties =
{
enter = { path = { field = "path" } },
update = { fill = { field = "zipped.data.v" } },
hover = { fill = { value = "darkgrey" } }
}
}
},
legends = legend
}
if (scales) then
output.scales = scales
output.marks[1].properties.update.fill.scale = "color"
end
flags = args.debug_json and mw.text.JSON_PRETTY
return mw.text.jsonEncode(output, flags)
end
 
-- ===================================================================================
-- Interface function for template:Mappa a colori
-- ===================================================================================
function p.map(frame)
local args = Args(getArgs(frame, {parentOnly = true}))
map_args = {}
-- map path data for geographic objects
map_args.basemap = args:value('basemap', cfg.default.world_map)
-- scaling factor
map_args.scale = args:number('scale', cfg.default.scale)
-- map projection, see https://github.com/mbostock/d3/wiki/Geo-Projections
map_args.projection = args:value('projection', "equirectangular")
-- defaultValue for geographic objects without data
map_args.defaultValue = args:value('defaultValue')
map_args.scaleType = args:value('scaleType' , "linear")
-- minimaler Wertebereich (nur für numerische Daten)
map_args.domainMin = args:number('domainMin')
-- maximaler Wertebereich (nur für numerische Daten)
map_args.domainMax = args:number('domainMax')
-- Farbwerte der Farbskala (nur für numerische Daten)
local palette = stringArray(args:value('colors'))
if not palette then palette = stringArray(args:value('color')) end
map_args.colors = generate_color_palette(palette)
-- show legend
map_args.legend = args[cfg.localization.internal_legend]
-- map data are key-value pairs: keys are non-lowercase strings (ideally ISO codes) which need
-- to match the "id" values of the map path data
map_args.values = {}
local isNumbers = nil
for name, value in pairs(args) do
if mw.ustring.find(name, "^[^%l]+$") then
if isNumbers == nil then isNumbers = tonumber(value) end
local data = { id = name, v = value }
if isNumbers then data.v = tonumber(data.v) end
map_args.values[#arguments.values+1] = data
end
end
if not map_args.defaultValue then
if isNumbers then map_args.defaultValue = 0 else map_args.defaultValue = "silver" end
end
map_args.isNumbers = isNumbers
map_args.debug_json = args:is_yes('debug_json')
local output_json = p.map_json(map_args)
if map_args.debug_json then
return frame:extensionTag('syntaxhighlight', output_json)
end
return frame:extensionTag('graph', output_json)
end
 
function p.palette_list(frame)
local args = getArgs(frame, {parentOnly = true})
local output = { '<table class="wikitable"><tr><th>Nome</th><th>Colori</th></tr>'}
-- analyze and build data to build the chart
local argumentspalette_name = { }
for name,colors in pairs(cfg.colors_palette) do
arguments.graphwidth = tonumber(args[cfg.localization.width]) or cfg.default.width
palette_name[#palette_name+1] = name
arguments.graphheight = tonumber(args[cfg.localization.height]) or cfg.default.height
end
arguments.graph_type, arguments.is_stacked = get_graph_type(args[cfg.localization.type])
table.sort(palette_name)
arguments.interpolate = args[cfg.localization.interpolate]
for _,name in ipairs(palette_name) do
if arguments.interpolate and not cfg.interpolate[arguments.interpolate] then
dump(output, '<tr><td>' .. name .. '</td><td>')
add_error('value_not_valid', {cfg.localization.interpolate, arguments.interpolate})
for _,color in ipairs(cfg.colors_palette[name][2]) do
interpolate = nil
dump(output, string.format('<span style="border:none;background-color:%s;color:%s;">██</span>', color, color))
end
end
-- get marks symbols, default symbol is used if the type of graph is line, otherwise the default
dump(output, '</td></tr>')
-- is not to use symbol.
end
if arguments.graph_type == "line" and not return_no_value(args[cfg.localization.symbols]) then
dump(output, '</table>')
arguments.symbols = stringArray(args[cfg.localization.symbols]) or cfg.default.symbol
return table.concat(output)
arguments.symbol_size = tonumber(args[cfg.localization.symbolSize]) or cfg.default.symbol_size
end
if arguments.graph_type =="line" then
arguments.stroke_thickness = tonumber(args[cfg.localization.strokeThickness]) or cfg.default.stroke_thickness
end
-- show legend, optionally caption
arguments.internal_legend = args[cfg.localization.internal_legend]
-- get x values
arguments.x = numericArray(args.x)
arguments.force_x_ordinal = false
if #arguments.x == 0 then
arguments.force_x_ordinal = true
else
for _,val in ipairs(arguments.x) do
if val == 'x' then
arguments.force_x_ordinal = true
break
end
end
end
if arguments.force_x_ordinal then arguments.x = stringArray(args.x) end
-- get y values (series)
arguments.y = {}
local index = 1
arguments.seriesTitles = {}
if args.y then
arguments.y[1] = numericArray(args.y)
arguments.seriesTitles[1] = args[string.gsub(cfg.localization.yTitle, '#', '')] or args[string.gsub(cfg.localization.yTitle, '#', '1')] or "y"
index = 2
end
while true do
if not args['y'..tostring(index)] then break end
arguments.y[index] = numericArray(args['y'..tostring(index)])
arguments.seriesTitles[index] = args[string.gsub(cfg.localization.yTitle, '#', tostring(index))] or ('y' .. tostring(index))
index = index + 1
end
-- ignore stacked charts if there is only one series
if #arguments.y == 1 then arguments.is_stacked = false end
-- read axes arguments
read_ax_arguments(args, 'x', arguments)
read_ax_arguments(args, 'y', arguments)
-- get marks colors, default palette is category10,
-- if colors is not the name of a predefined palette then read it as an array of colors
arguments.colors = args[cfg.localization.colors] or "category10"
if not cfg.colors_palette[arguments.colors] then
arguments.colors = stringArray(arguments.colors)
elseif arguments.colors ~="category10" and arguments.colors ~="category20" then
arguments.colors = generate_color_palette(arguments.colors)
end
-- assure that colors, stroke_thickness and symbols table are at least the same lenght that the number of
-- y series
if isTable(arguments.colors) then arguments.colors = extend_table(arguments.colors, #arguments.y) end
if isTable(arguments.stroke_thickness) then arguments.stroke_thickness = extend_table(arguments.stroke_thickness, #arguments.y) end
if isTable(arguments.symbols) then arguments.symbols = extend_table(arguments.symbols, #arguments.y) end
-- if there is at least one color in the format "#aarrggbb", create a transparency (alpha) scale
if isTable(arguments.colors) then
alphas = {}
local hasAlpha = false
for i, color in ipairs(arguments.colors) do
local a, rgb = string.match(color, "#(%x%x)(%x%x%x%x%x%x)")
if a then
hasAlpha = true
alphas[i] = tostring(tonumber(a, 16) / 255.0)
arguments.colors[i] = "#" .. rgb
else
alphas[i] = "1"
end
end
for i = #arguments.colors + 1, #arguments.y do alphas[i] = "1" end
if hasAlpha then arguments.alphas = alphas end
elseif args[cfg.localization.alpha] then
arguments.alphas = stringArray(args[cfg.localization.alpha])
if arguments.alphas then
for i,a in ipairs(arguments.alphas) do arguments.alphas[i] = tostring(tonumber(a, 16) / 255.0) end
arguments.alphas = extend_table(arguments.alphas, #arguments.y)
end
end
arguments.colorsByGroup = return_yes_value(args[cfg.localization.colorsByGroup])
local chart_json = p.chart_json(arguments)
if args[cfg.localization.debug_json] then return frame:extensionTag('syntaxhighlight', chart_json) end
local external_legend
if args[cfg.localization.external_legend] then
external_legend = build_legend(arguments.colors, arguments.seriesTitles, args[cfg.localization.external_legend],
args[cfg.localization.nCols])
end
local chart = frame:extensionTag('graph', chart_json)
local align = args[cfg.localization.thumb]
return wrap_graph(chart, external_legend, align, arguments.graphwidth) .. errors_output(args.NoTracking)
end
 
Estratto da "https://it.wikipedia.org/wiki/Modulo:Graph"