Вікіпедія

Модуль:Graph: відмінності між версіями

Інтерактивний перегляд історії
[перевірена версія][перевірена версія]
← Попереднє редагуванняНаступне редагування →
Вилучено вміст Додано вміст
DimonBot (обговорення | внесок)
Боти
32 721 редагування
Немає опису редагування
оновлено з enwiki
Рядок 1:
 
-- ATTENTION: Please edit this code at https://de.wikipedia.org/wiki/Modul:Graph
-- ATTENTION: Please edit this code at https://de.wikipedia.org/wiki/Modul:Graph
-- This way all wiki languages can stay in sync. Thank you!
-- This way all wiki languages can stay in sync. Thank you!
--
-- BUGS: X-Axis label format bug? (xAxisFormat =) https://en.wikipedia.org/wiki/Template_talk:Graph:Chart#X-Axis_label_format_bug?_(xAxisFormat_=)
-- linewidths - doesnt work for two values (eg 0, 1) but work if added third value of both are zeros? Same for marksStroke - probably bug in Graph extension
-- clamp - "clamp" used to avoid marks outside marks area, "clip" should be use instead but not working in Graph extension, see https://phabricator.wikimedia.org/T251709
-- TODO:
-- marks:
-- - line strokeDash + serialization,
-- - symStroke serialization
-- - symbolsNoFill serialization
-- - arbitrary SVG path symbol shape as symbolsShape argument
-- - annotations
-- - vertical / horizontal line at specific values [DONE] 2020-09-01
-- - rectangle shape for x,y data range
-- - graph type serialization (deep rebuild reqired)
-- - second axis (deep rebuild required - assignment of series to one of two axies)
 
-- Version History (_PLEASE UPDATE when modifying anything_):
-- 2020-09-01 Vertical and horizontal line annotations
-- 2020-08-08 New logic for "nice" for x axis (problem with scale when xType = "date") and grid
-- 2020-06-21 Serializes symbol size
-- transparent symbosls (from line colour) - buggy (incorrect opacity on overlap with line)
-- Linewidth serialized with "linewidths"
-- Variable symbol size and shape of symbols on line charts, default showSymbols = 2, default symbolsShape = circle, symbolsStroke = 0
-- p.chartDebuger(frame) for easy debug and JSON output
-- 2020-06-07 Allow lowercase variables for use with [[Template:Wikidata list]]
-- 2020-05-27 Map: allow specification which feature to display and changing the map center
-- 2020-04-08 Change default showValues.fontcolor from black to persistentGrey
-- 2020-04-06 Logarithmic scale outputs wrong axis labels when "nice"=true
-- 2020-03-11 Allow user-defined scale types, e.g. logarithmic scale
-- 2019-11-08 Apply color-inversion-friendliness to legend title, labels, and xGrid
Рядок 17 ⟶ 44:
 
local p = {}
 
--add debug text to this string with eg. debuglog = debuglog .. "" .. "\n\n" .. "- " .. debug.traceback() .. "result type: ".. type(result) .. " result: \n\n" .. mw.dumpObject(result)
--invoke chartDebuger() to get graph JSON and this string
debuglog = "Debug " .. "\n\n"
 
local baseMapDirectory = "Module:Graph/"
local persistentGrey = "#54595d"
 
local shapes = {}
shapes = {
circle = "circle", x= "M-.5,-.5L.5,.5M.5,-.5L-.5,.5" , square = "square",
cross = "cross", diamond = "diamond", triangle_up = "triangle-up",
triangle_down = "triangle-down", triangle_right = "triangle-right",
triangle_left = "triangle-left",
banana = "m -0.5281,0.2880 0.0020,0.0192 m 0,0 c 0.1253,0.0543 0.2118,0.0679 0.3268,0.0252 0.1569,-0.0582 0.3663,-0.1636 0.4607,-0.3407 0.0824,-0.1547 0.1202,-0.2850 0.0838,-0.4794 l 0.0111,-0.1498 -0.0457,-0.0015 c -0.0024,0.3045 -0.1205,0.5674 -0.3357,0.7414 -0.1409,0.1139 -0.3227,0.1693 -0.5031,0.1856 m 0,0 c 0.1804,-0.0163 0.3622,-0.0717 0.5031,-0.1856 0.2152,-0.1739 0.3329,-0.4291 0.3357,-0.7414 l -0.0422,0.0079 c 0,0 -0.0099,0.1111 -0.0227,0.1644 -0.0537,0.1937 -0.1918,0.3355 -0.3349,0.4481 -0.1393,0.1089 -0.2717,0.2072 -0.4326,0.2806 l -0.0062,0.0260"
}
 
 
local function numericArray(csv)
Рядок 39 ⟶ 80:
end
end
 
return result, isInteger
return result, isInteger
end
 
Рядок 72 ⟶ 114:
local projection = frame.args.projection or "equirectangular"
-- defaultValue for geographic objects without data
local defaultValue = frame.args.defaultValue or frame.args.defaultvalue
local scaleType = frame.args.scaleType or frame.args.scaletype or "linear"
-- minimaler Wertebereich (nur für numerische Daten)
local domainMin = tonumber(frame.args.domainMin or frame.args.domainmin)
-- maximaler Wertebereich (nur für numerische Daten)
local domainMax = tonumber(frame.args.domainMax or frame.args.domainmax)
-- Farbwerte der Farbskala (nur für numerische Daten)
local colorScale = frame.args.colorScale or frame.args.colorscale or "category10"
-- show legend
local legend = frame.args.legend
-- the map feature to display
local feature = frame.args.feature or "countries"
-- map center
local center = numericArray(frame.args.center)
-- format JSON output
local formatJson = frame.args.formatjson
Рядок 146 ⟶ 192:
}
end
 
-- get map url
local basemapUrl
Рядок 171 ⟶ 217:
{
-- data source for map paths data
name = "countries"feature,
url = basemapUrl,
format = { type = "topojson", feature = "countries"feature },
transform =
{
Рядок 181 ⟶ 227:
value = "data", -- data source
scale = scale,
translate = { 0, 0 },
center = center,
projection = projection
},
Рядок 201 ⟶ 248:
{
type = "path",
from = { data = "countries"feature },
properties =
{
Рядок 242 ⟶ 289:
if not xType then xType = "string" end
end
 
return x, xType, xMin, xMax
end
Рядок 322 ⟶ 368:
range = "width",
zero = false, -- do not include zero value
nice = true, -- force round numbers for y scale
domain = { data = "chart", field = "x" }
}
Рядок 335 ⟶ 380:
xscale.type = "ordinal"
if not stacked then xscale.padding = 0.2 end -- pad each bar group
else
if xType == "date" then
xscale.type = "time"
elseif xType == "string" then
xscale.type = "ordinal"
Рядок 342 ⟶ 388:
end
end
if xType and xType ~= "date" and xScaleType ~= "log" then xscale.nice = true end -- force round numbers for x scale, but "log" and "date" scale outputs a wrong "nice" scale
 
return xscale
end
Рядок 352 ⟶ 398:
{
name = "y",
--type = yScaleType or "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 = chartType ~= "line",
nice = yScaleType ~= "log" -- force round numbers for y scale, but log scale outputs a wrong "nice" scale
nice = true
}
if yScaleType then yscale.type = yScaleType else yscale.type = "linear" end
Рядок 408 ⟶ 455:
end
return alphaScale
end
 
local function getLineScale(linewidths, chartType)
local lineScale = {}
lineScale =
{
name = "line",
type = "ordinal",
range = linewidths,
domain = { data = "chart", field = "series" }
}
 
return lineScale
end
 
local function getSymSizeScale(symSize)
local SymSizeScale = {}
SymSizeScale =
{
name = "symSize",
type = "ordinal",
range = symSize,
domain = { data = "chart", field = "series" }
}
 
return SymSizeScale
end
 
local function getSymShapeScale(symShape)
local SymShapeScale = {}
SymShapeScale =
{
name = "symShape",
type = "ordinal",
range = symShape,
domain = { data = "chart", field = "series" }
}
 
return SymShapeScale
end
 
Рядок 466 ⟶ 553:
end
 
local function getChartVisualisation(chartType, stacked, colorField, yCount, innerRadius, outerRadius, linewidth, alphaScale, radiusScale, lineScale, interpolate)
if chartType == "pie" then return getPieChartVisualisation(yCount, innerRadius, outerRadius, linewidth, radiusScale) end
 
Рядок 485 ⟶ 572:
if colorField == "stroke" then
chartvis.properties.enter.strokeWidth = { value = linewidth or 2.5 }
if type(lineScale) =="table" then
chartvis.properties.enter.strokeWidth.value = nil
chartvis.properties.enter.strokeWidth =
{
scale = "line",
field= "series"
}
end
end
 
Рядок 525 ⟶ 620:
chartvis.properties.update[colorField].field = "series"
if alphaScale then chartvis.properties.update[colorField .. "Opacity"].field = "series" end
-- if there are multiple series, connect linewidths to series
if chartype == "line" then
chartvis.properties.update["strokeWidth"].field = "series"
end
 
-- apply a grouping (facetting) transformation
chartvis =
Рядок 587 ⟶ 689:
else
properties.align.value = "left"
properties.fill.value = showValues.fontcolor or "black"persistentGrey
end
elseif chartType == "pie" then
Рядок 596 ⟶ 698:
radius = { offset = tonumber(showValues.offset) or -4 },
theta = { field = "layout_mid" },
fill = { value = showValues.fontcolor or "black"persistentGrey },
baseline = { },
angle = { },
Рядок 655 ⟶ 757:
end
 
local function getSymbolMarks(chartvis, symSize, symShape, symStroke, noFill, alphaScale)
 
local symbolmarks =
local symbolmarks
symbolmarks =
{
type = "symbol",
Рядок 665 ⟶ 769:
x = { scale = "x", field = "x" },
y = { scale = "y", field = "y" },
strokeWidth = { value = symStroke },
stroke = { scale = "color", field = "series" },
fill = { scale = "color", field = "series" },
shape = "circle",
size = { value = 49 }
}
}
}
if type(symShape) == "string" then
symbolmarks.properties.enter.shape = { value = symShape }
end
if type(symShape) == "table" then
symbolmarks.properties.enter.shape = { scale = "symShape", field = "series" }
end
if type(symSize) == "number" then
symbolmarks.properties.enter.size = { value = symSize }
end
if type(symSize) == "table" then
symbolmarks.properties.enter.size = { scale = "symSize", field = "series" }
end
if noFill then
symbolmarks.properties.enter.fill = nil
end
if alphaScale then
symbolmarks.properties.enter.fillOpacity =
{ scale = "transparency", field = "series" }
symbolmarks.properties.enter.strokeOpacity =
{ scale = "transparency", field = "series" }
end
if chartvis.from then symbolmarks.from = copy(chartvis.from) end
 
return symbolmarks
end
 
local function getAnnoMarks(chartvis, stroke, fill, opacity)
 
local vannolines, hannolines, vannoLabels, vannoLabels
vannolines =
{
type = "rule",
from = { data = "v_anno" },
properties =
{
update =
{
x = { scale = "x", field = "x" },
y = { value = 0 },
y2 = { field = { group = "height" } },
strokeWidth = { value = stroke },
stroke = { value = persistentGrey },
opacity = { value = opacity }
}
}
}
vannolabels =
{
type = "text",
from = { data = "v_anno" },
properties =
{
update =
{
x = { scale = "x", field = "x", offset = 3 },
y = { field = { group = "height" }, offset = -3 },
text = { field = "label" },
baseline = { value = "top" },
angle = { value = -90 },
fill = { value = persistentGrey },
opacity = { value = opacity }
}
}
}
hannolines =
{
type = "rule",
from = { data = "h_anno" },
properties =
{
update =
{
y = { scale = "y", field = "y" },
x = { value = 0 },
x2 = { field = { group = "width" } },
strokeWidth = { value = stroke },
stroke = { value = persistentGrey },
opacity = { value = opacity }
}
}
}
hannolabels =
{
type = "text",
from = { data = "h_anno" },
properties =
{
update =
{
y = { scale = "y", field = "y", offset = 3 },
x = { value = 0 , offset = 3 },
text = { field = "label" },
baseline = { value = "top" },
angle = { value = 0 },
fill = { value = persistentGrey },
opacity = { value = opacity }
}
}
}
return vannolines, vannolabels, hannolines, hannolabels
end
 
Рядок 686 ⟶ 887:
title = xTitle,
format = xAxisFormat,
grid = xGrid ~= "0"
}
if xAxisAngle then
Рядок 751 ⟶ 952:
title = yTitle,
format = yAxisFormat,
grid = yGrid ~= "0"
}
yAxis.properties =
Рядок 777 ⟶ 978:
}
}
end
 
Рядок 828 ⟶ 1030:
-- for line charts, the thickness of the line; for pie charts the gap between each slice
local linewidth = tonumber(frame.args.linewidth)
local linewidthsString = frame.args.linewidths
local linewidths
if linewidthsString and linewidthsString ~= "" then linewidths = numericArray(linewidthsString) or false end
-- x and y axis caption
local xTitle = frame.args.xAxisTitle or frame.args.xaxistitle
local yTitle = frame.args.yAxisTitle or frame.args.yaxistitle
-- x and y value types
local xType = frame.args.xType or frame.args.xtype
local yType = frame.args.yType or frame.args.ytype
-- override x and y axis minimum and maximum
local xMin = frame.args.xAxisMin or frame.args.xaxismin
local xMax = frame.args.xAxisMax or frame.args.xaxismax
local yMin = frame.args.yAxisMin or frame.args.yaxismin
local yMax = frame.args.yAxisMax or frame.args.yaxismax
-- override x and y axis label formatting
local xAxisFormat = frame.args.xAxisFormat or frame.args.xaxisformat
local yAxisFormat = frame.args.yAxisFormat or frame.args.yaxisformat
local xAxisAngle = tonumber(frame.args.xAxisAngle) or tonumber(frame.args.xaxisangle)
-- x and y scale types
local xScaleType = frame.args.xScaleType or frame.args.xscaletype
local yScaleType = frame.args.yScaleType or frame.args.yscaletype
-- log scale require minimum > 0, for now it's no possible to plot negative values on log - TODO see: https://www.mathworks.com/matlabcentral/answers/1792-log-scale-graphic-with-negative-value
-- if xScaleType == "log" then
-- if (not xMin or tonumber(xMin) <= 0) then xMin = 0.1 end
-- if not xType then xType = "number" end
-- end
-- if yScaleType == "log" then
-- if (not yMin or tonumber(yMin) <= 0) then yMin = 0.1 end
-- if not yType then yType = "number" end
-- end
 
-- show grid
local xGrid = frame.args.xGrid or "0"frame.args.xgrid or false
local yGrid = frame.args.yGrid or "0"frame.args.ygrid or false
-- for line chart, show a symbol at each data point
local showSymbols = frame.args.showSymbols or frame.args.showsymbols
local symbolsShape = frame.args.symbolsShape or frame.args.symbolsshape
local symbolsNoFill = frame.args.symbolsNoFill or frame.args.symbolsnofill
local symbolsStroke = tonumber(frame.args.symbolsStroke or frame.args.symbolsstroke)
-- show legend with given title
local legendTitle = frame.args.legend
-- show values as text
local showValues = frame.args.showValues or frame.args.showvalues
-- show v- and h-line annotations
local v_annoLineString = frame.args.vAnnotatonsLine or frame.args.vannotatonsline
local h_annoLineString = frame.args.hAnnotatonsLine or frame.args.hannotatonsline
local v_annoLabelString = frame.args.vAnnotatonsLabel or frame.args.vannotatonslabel
local h_annoLabelString = frame.args.hAnnotatonsLabel or frame.args.hannotatonslabel
 
 
 
 
 
-- decode annotations cvs
local v_annoLine, v_annoLabel, h_annoLine, h_annoLabel
if v_annoLineString and v_annoLineString ~= "" then
 
if xType == "number" or xType == "integer" then
v_annoLine = numericArray(v_annoLineString)
 
else
v_annoLine = stringArray(v_annoLineString)
 
end
v_annoLabel = stringArray(v_annoLabelString)
end
if h_annoLineString and h_annoLineString ~= "" then
 
if yType == "number" or yType == "integer" then
h_annoLine = numericArray(h_annoLineString)
 
else
h_annoLine = stringArray(h_annoLineString)
 
end
h_annoLabel = stringArray(h_annoLabelString)
end
 
 
 
 
 
-- pie chart radiuses
local innerRadius = tonumber(frame.args.innerRadius) or tonumber(frame.args.innerradius) or 0
local outerRadius = math.min(graphwidth, graphheight)
-- format JSON output
Рядок 874 ⟶ 1131:
yValues[yNum] = value
-- name the series: default is "y<number>". Can be overwritten using the "y<number>Title" parameters.
seriesTitles[yNum] = frame.args["y" .. yNum .. "Title"] or frame.args["y" .. yNum .. "title"] or name
end
end
Рядок 910 ⟶ 1167:
end
end
-- add annotations to data
local vannoData, hannoData
if v_annoLine then
vannoData = { name = "v_anno", format = { type = "json", parse = { x = xType } }, values = {} }
for i = 1, #v_annoLine do
local item = { x = v_annoLine[i], label = v_annoLabel[i] }
table.insert(vannoData.values, item)
end
end
if h_annoLine then
hannoData = { name = "h_anno", format = { type = "json", parse = { y = yType } }, values = {} }
for i = 1, #h_annoLine do
local item = { y = h_annoLine[i], label = h_annoLabel[i] }
table.insert(hannoData.values, item)
end
end
 
 
-- create scales
Рядок 924 ⟶ 1200:
local alphaScale = getAlphaColorScale(colors, y)
table.insert(scales, alphaScale)
 
local lineScale
if (linewidths) and (chartType == "line") then
lineScale = getLineScale(linewidths, chartType)
table.insert(scales, lineScale)
end
 
local radiusScale
Рядок 934 ⟶ 1216:
local colorField
if chartType == "line" then colorField = "stroke" else colorField = "fill" end
 
 
 
-- create chart markings
local chartvis = getChartVisualisation(chartType, stacked, colorField, #y, innerRadius, outerRadius, linewidth, alphaScale, radiusScale, lineScale, interpolate)
local marks = { chartvis }
Рядок 959 ⟶ 1243:
end
end
 
-- grids
if xGrid then
if xGrid == "0" then xGrid = false
elseif xGrid == 0 then xGrid = false
elseif xGrid == "false" then xGrid = false
elseif xGrid == "n" then xGrid = false
else xGrid = true
end
end
if yGrid then
if yGrid == "0" then yGrid = false
elseif yGrid == 0 then yGrid = false
elseif yGrid == "false" then yGrid = false
elseif yGrid == "n" then yGrid = false
else yGrid = true
end
end
-- symbol marks
if showSymbols and chartType =~= "linerect" and showSymbols then
local chartmarks = chartvis
if chartmarks.marks then chartmarks = chartmarks.marks[1] end
 
local symbolmarks = getSymbolMarks(chartmarks)
if type(showSymbols) == "string" then
if showSymbols == "" then showSymbols = true
else showSymbols = numericArray(showSymbols)
end
else
showSymbols = tonumber(showSymbols)
end
 
-- custom size
local symSize
if type(showSymbols) == "number" then
symSize = tonumber(showSymbols*showSymbols*8.5)
elseif type(showSymbols) == "table" then
symSize = {}
for k, v in pairs(showSymbols) do
symSize[k]=v*v*8.5 -- "size" acc to Vega syntax is area of symbol
end
else
symSize = 50
end
-- symSizeScale
local symSizeScale = {}
if type(symSize) == "table" then
symSizeScale = getSymSizeScale(symSize)
table.insert(scales, symSizeScale)
end
 
-- custom shape
if stringArray(symbolsShape) and #stringArray(symbolsShape) > 1 then symbolsShape = stringArray(symbolsShape) end
local symShape = " "
if type(symbolsShape) == "string" and shapes[symbolsShape] then
symShape = shapes[symbolsShape]
elseif type(symbolsShape) == "table" then
symShape = {}
for k, v in pairs(symbolsShape) do
if symbolsShape[k] and shapes[symbolsShape[k]] then
symShape[k]=shapes[symbolsShape[k]]
else
symShape[k] = "circle"
end
end
else
symShape = "circle"
end
-- symShapeScale
local symShapeScale = {}
if type(symShape) == "table" then
symShapeScale = getSymShapeScale(symShape)
table.insert(scales, symShapeScale)
end
-- custom stroke
local symStroke
if (type(symbolsStroke) == "number") then
symStroke = tonumber(symbolsStroke)
-- TODO symStroke serialization
-- elseif type(symbolsStroke) == "table" then
-- symStroke = {}
-- for k, v in pairs(symbolsStroke) do
-- symStroke[k]=symbolsStroke[k]
-- --always draw x with stroke
-- if symbolsShape[k] == "x" then symStroke[k] = 2.5 end
--always draw x with stroke
-- if symbolsNoFill[k] then symStroke[k] = 2.5 end
-- end
else
symStroke = 0
--always draw x with stroke
if symbolsShape == "x" then symStroke = 2.5 end
--always draw x with stroke
if symbolsNoFill then symStroke = 2.5 end
end
 
 
-- TODO -- symStrokeScale
-- local symStrokeScale = {}
-- if type(symStroke) == "table" then
-- symStrokeScale = getSymStrokeScale(symStroke)
-- table.insert(scales, symStrokeScale)
-- end
 
 
local symbolmarks = getSymbolMarks(chartmarks, symSize, symShape, symStroke, symbolsNoFill, alphaScale)
if chartmarks ~= chartvis then
table.insert(chartvis.marks, symbolmarks)
Рядок 970 ⟶ 1359:
table.insert(marks, symbolmarks)
end
end
 
 
local vannolines, vannolabels, hannolines, hannolabels = getAnnoMarks(chartmarks, persistentGrey, persistentGrey, 0.75)
if vannoData then
table.insert(marks, vannolines)
table.insert(marks, vannolabels)
end
if hannoData then
table.insert(marks, hannolines)
table.insert(marks, hannolabels)
end
 
-- axes
local xAxis, yAxis = getAxes(xTitle, xAxisFormat, xAxisAngle, xType, xGrid, yTitle, yAxisFormat, yType, yGrid, chartType)
 
-- legend
local legend
if legendTitle and tonumber(legendTitle) ~= 0 then legend = getLegend(legendTitle, chartType, outerRadius) end
 
-- construct final output object
local output =
Рядок 985 ⟶ 1384:
width = graphwidth,
height = graphheight,
data = { data, stats },
scales = scales,
axes = { xAxis, yAxis },
Рядок 991 ⟶ 1390:
legends = { legend }
}
if vannoData then table.insert(output.data, vannoData) end
if hannoData then table.insert(output.data, hannoData) end
if stats then table.insert(output.data, stats) end
 
local flags
Рядок 1004 ⟶ 1406:
return p.chart(frame:getParent())
end
 
function p.chartDebuger(frame)
return "\n\nchart JSON\n ".. p.chart(frame) .. " \n\n" .. debuglog
end
 
 
-- Given an HTML-encoded title as first argument, e.g. one produced with {{ARTICLEPAGENAME}},
Отримано з https://uk.wikipedia.org/wiki/Модуль:Graph